1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 97, 98, 1999
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
34 #include "termhooks.h"
35 /* cm.h must come after dispextern.h on Windows. */
36 #include "dispextern.h"
45 #include "intervals.h"
46 #include "blockinput.h"
50 /* I don't know why DEC Alpha OSF1 fail to compile this file if we
51 include the following file. */
52 /* #include "systty.h" */
53 #include "syssignal.h"
57 #endif /* HAVE_X_WINDOWS */
61 #endif /* HAVE_NTGUI */
63 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
68 /* To get the prototype for `sleep'. */
74 #define max(a, b) ((a) > (b) ? (a) : (b))
75 #define min(a, b) ((a) < (b) ? (a) : (b))
77 /* Get number of chars of output now in the buffer of a stdio stream.
78 This ought to be built in in stdio, but it isn't. Some s- files
79 override this because their stdio internals differ. */
81 #ifdef __GNU_LIBRARY__
83 /* The s- file might have overridden the definition with one that
84 works for the system's C library. But we are using the GNU C
85 library, so this is the right definition for every system. */
87 #ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT
88 #define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT
90 #undef PENDING_OUTPUT_COUNT
91 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
93 #else /* not __GNU_LIBRARY__ */
94 #if !defined (PENDING_OUTPUT_COUNT) && HAVE_STDIO_EXT_H && HAVE___FPENDING
95 #include <stdio_ext.h>
96 #define PENDING_OUTPUT_COUNT(FILE) __fpending (FILE)
98 #ifndef PENDING_OUTPUT_COUNT
99 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
101 #endif /* not __GNU_LIBRARY__ */
104 /* Structure to pass dimensions around. Used for character bounding
105 boxes, glyph matrix dimensions and alike. */
114 /* Function prototypes. */
116 static void redraw_overlapping_rows
P_ ((struct window
*, int));
117 static void redraw_overlapped_rows
P_ ((struct window
*, int));
118 static int count_blanks
P_ ((struct glyph
*, int));
119 static int count_match
P_ ((struct glyph
*, struct glyph
*,
120 struct glyph
*, struct glyph
*));
121 static unsigned line_draw_cost
P_ ((struct glyph_matrix
*, int));
122 static void update_frame_line
P_ ((struct frame
*, int));
123 static struct dim allocate_matrices_for_frame_redisplay
124 P_ ((Lisp_Object
, int, int, struct dim
, int, int *));
125 static void allocate_matrices_for_window_redisplay
P_ ((struct window
*,
127 static int realloc_glyph_pool
P_ ((struct glyph_pool
*, struct dim
));
128 static void adjust_frame_glyphs
P_ ((struct frame
*));
129 struct glyph_matrix
*new_glyph_matrix
P_ ((struct glyph_pool
*));
130 static void free_glyph_matrix
P_ ((struct glyph_matrix
*));
131 static void adjust_glyph_matrix
P_ ((struct window
*, struct glyph_matrix
*,
132 int, int, struct dim
));
133 static void change_frame_size_1
P_ ((struct frame
*, int, int, int, int, int));
134 static void swap_glyphs_in_rows
P_ ((struct glyph_row
*, struct glyph_row
*));
135 static void swap_glyph_pointers
P_ ((struct glyph_row
*, struct glyph_row
*));
136 static int glyph_row_slice_p
P_ ((struct glyph_row
*, struct glyph_row
*));
137 static void fill_up_frame_row_with_spaces
P_ ((struct glyph_row
*, int));
138 static void build_frame_matrix_from_window_tree
P_ ((struct glyph_matrix
*,
140 static void build_frame_matrix_from_leaf_window
P_ ((struct glyph_matrix
*,
142 static struct glyph_pool
*new_glyph_pool
P_ ((void));
143 static void free_glyph_pool
P_ ((struct glyph_pool
*));
144 static void adjust_frame_glyphs_initially
P_ ((void));
145 static void adjust_frame_message_buffer
P_ ((struct frame
*));
146 static void adjust_decode_mode_spec_buffer
P_ ((struct frame
*));
147 static void fill_up_glyph_row_with_spaces
P_ ((struct glyph_row
*));
148 static void build_frame_matrix
P_ ((struct frame
*));
149 void clear_current_matrices
P_ ((struct frame
*));
150 void scroll_glyph_matrix_range
P_ ((struct glyph_matrix
*, int, int,
152 static void clear_window_matrices
P_ ((struct window
*, int));
153 static void fill_up_glyph_row_area_with_spaces
P_ ((struct glyph_row
*, int));
154 static int scrolling_window
P_ ((struct window
*, int));
155 static int update_window_line
P_ ((struct window
*, int));
156 static void update_marginal_area
P_ ((struct window
*, int, int));
157 static int update_text_area
P_ ((struct window
*, int));
158 static void make_current
P_ ((struct glyph_matrix
*, struct glyph_matrix
*,
160 static void mirror_make_current
P_ ((struct window
*, int));
161 void check_window_matrix_pointers
P_ ((struct window
*));
163 static void check_matrix_pointers
P_ ((struct glyph_matrix
*,
164 struct glyph_matrix
*));
166 static void mirror_line_dance
P_ ((struct window
*, int, int, int *, char *));
167 static int update_window_tree
P_ ((struct window
*, int));
168 static int update_window
P_ ((struct window
*, int));
169 static int update_frame_1
P_ ((struct frame
*, int, int));
170 static void set_window_cursor_after_update
P_ ((struct window
*));
171 static int row_equal_p
P_ ((struct window
*, struct glyph_row
*,
172 struct glyph_row
*));
173 static void adjust_frame_glyphs_for_window_redisplay
P_ ((struct frame
*));
174 static void adjust_frame_glyphs_for_frame_redisplay
P_ ((struct frame
*));
175 static void reverse_rows
P_ ((struct glyph_matrix
*, int, int));
176 static int margin_glyphs_to_reserve
P_ ((struct window
*, int, Lisp_Object
));
180 /* Non-zero means don't pause redisplay for pending input. (This is
181 for debugging and for a future implementation of EDT-like
184 int redisplay_dont_pause
;
186 /* Nonzero upon entry to redisplay means do not assume anything about
187 current contents of actual terminal frame; clear and redraw it. */
191 /* Nonzero means last display completed. Zero means it was preempted. */
193 int display_completed
;
195 /* Lisp variable visible-bell; enables use of screen-flash instead of
200 /* Invert the color of the whole frame, at a low level. */
204 /* Line speed of the terminal. */
208 /* Either nil or a symbol naming the window system under which Emacs
211 Lisp_Object Vwindow_system
;
213 /* Version number of X windows: 10, 11 or nil. */
215 Lisp_Object Vwindow_system_version
;
217 /* Vector of glyph definitions. Indexed by glyph number, the contents
218 are a string which is how to output the glyph.
220 If Vglyph_table is nil, a glyph is output by using its low 8 bits
223 This is an obsolete feature that is no longer used. The variable
224 is retained for compatibility. */
226 Lisp_Object Vglyph_table
;
228 /* Display table to use for vectors that don't specify their own. */
230 Lisp_Object Vstandard_display_table
;
232 /* Nonzero means reading single-character input with prompt so put
233 cursor on mini-buffer after the prompt. positive means at end of
234 text in echo area; negative means at beginning of line. */
236 int cursor_in_echo_area
;
238 Lisp_Object Qdisplay_table
;
241 /* The currently selected frame. In a single-frame version, this
242 variable always equals the_only_frame. */
244 Lisp_Object selected_frame
;
246 /* A frame which is not just a mini-buffer, or 0 if there are no such
247 frames. This is usually the most recent such frame that was
248 selected. In a single-frame version, this variable always holds
249 the address of the_only_frame. */
251 struct frame
*last_nonminibuf_frame
;
253 /* Stdio stream being used for copy of all output. */
257 /* Structure for info on cursor positioning. */
261 /* 1 means SIGWINCH happened when not safe. */
263 int delayed_size_change
;
265 /* 1 means glyph initialization has been completed at startup. */
267 static int glyphs_initialized_initially_p
;
269 /* Updated window if != 0. Set by update_window. */
271 struct window
*updated_window
;
273 /* Glyph row updated in update_window_line, and area that is updated. */
275 struct glyph_row
*updated_row
;
278 /* A glyph for a space. */
280 struct glyph space_glyph
;
282 /* Non-zero means update has been performed directly, so that there's
283 no need for redisplay_internal to do much work. Set by
284 direct_output_for_insert. */
286 int redisplay_performed_directly_p
;
288 /* Counts of allocated structures. These counts serve to diagnose
289 memory leaks and double frees. */
291 int glyph_matrix_count
;
292 int glyph_pool_count
;
294 /* If non-null, the frame whose frame matrices are manipulated. If
295 null, window matrices are worked on. */
297 static struct frame
*frame_matrix_frame
;
299 /* Current interface for window-based redisplay. Set from init_xterm.
300 A null value means we are not using window-based redisplay. */
302 struct redisplay_interface
*rif
;
304 /* Non-zero means that fonts have been loaded since the last glyph
305 matrix adjustments. Redisplay must stop, and glyph matrices must
306 be adjusted when this flag becomes non-zero during display. The
307 reason fonts can be loaded so late is that fonts of fontsets are
312 /* Convert vpos and hpos from frame to window and vice versa.
313 This may only be used for terminal frames. */
317 static int window_to_frame_vpos
P_ ((struct window
*, int));
318 static int window_to_frame_hpos
P_ ((struct window
*, int));
319 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
320 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
322 #else /* GLYPH_DEBUG == 0 */
324 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + XFASTINT ((W)->top))
325 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + XFASTINT ((W)->left))
327 #endif /* GLYPH_DEBUG == 0 */
330 /* Like bcopy except never gets confused by overlap. Let this be the
331 first function defined in this file, or change emacs.c where the
332 address of this function is used. */
335 safe_bcopy (from
, to
, size
)
339 if (size
<= 0 || from
== to
)
342 /* If the source and destination don't overlap, then bcopy can
343 handle it. If they do overlap, but the destination is lower in
344 memory than the source, we'll assume bcopy can handle that. */
345 if (to
< from
|| from
+ size
<= to
)
346 bcopy (from
, to
, size
);
348 /* Otherwise, we'll copy from the end. */
351 register char *endf
= from
+ size
;
352 register char *endt
= to
+ size
;
354 /* If TO - FROM is large, then we should break the copy into
355 nonoverlapping chunks of TO - FROM bytes each. However, if
356 TO - FROM is small, then the bcopy function call overhead
357 makes this not worth it. The crossover point could be about
358 anywhere. Since I don't think the obvious copy loop is too
359 bad, I'm trying to err in its favor. */
364 while (endf
!= from
);
376 bcopy (endf
, endt
, to
- from
);
379 /* If SIZE wasn't a multiple of TO - FROM, there will be a
380 little left over. The amount left over is (endt + (to -
381 from)) - to, which is endt - from. */
382 bcopy (from
, to
, endt
- from
);
389 /***********************************************************************
391 ***********************************************************************/
393 /* Allocate and return a glyph_matrix structure. POOL is the glyph
394 pool from which memory for the matrix should be allocated, or null
395 for window-based redisplay where no glyph pools are used. The
396 member `pool' of the glyph matrix structure returned is set to
397 POOL, the structure is otherwise zeroed. */
399 struct glyph_matrix
*
400 new_glyph_matrix (pool
)
401 struct glyph_pool
*pool
;
403 struct glyph_matrix
*result
;
405 /* Allocate and clear. */
406 result
= (struct glyph_matrix
*) xmalloc (sizeof *result
);
407 bzero (result
, sizeof *result
);
409 /* Increment number of allocated matrices. This count is used
410 to detect memory leaks. */
411 ++glyph_matrix_count
;
413 /* Set pool and return. */
419 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
421 The global counter glyph_matrix_count is decremented when a matrix
422 is freed. If the count gets negative, more structures were freed
423 than allocated, i.e. one matrix was freed more than once or a bogus
424 pointer was passed to this function.
426 If MATRIX->pool is null, this means that the matrix manages its own
427 glyph memory---this is done for matrices on X frames. Freeing the
428 matrix also frees the glyph memory in this case. */
431 free_glyph_matrix (matrix
)
432 struct glyph_matrix
*matrix
;
438 /* Detect the case that more matrices are freed than were
440 if (--glyph_matrix_count
< 0)
443 /* Free glyph memory if MATRIX owns it. */
444 if (matrix
->pool
== NULL
)
445 for (i
= 0; i
< matrix
->rows_allocated
; ++i
)
446 xfree (matrix
->rows
[i
].glyphs
[LEFT_MARGIN_AREA
]);
448 /* Free row structures and the matrix itself. */
449 xfree (matrix
->rows
);
455 /* Return the number of glyphs to reserve for a marginal area of
456 window W. TOTAL_GLYPHS is the number of glyphs in a complete
457 display line of window W. MARGIN gives the width of the marginal
458 area in canonical character units. MARGIN should be an integer
462 margin_glyphs_to_reserve (w
, total_glyphs
, margin
)
469 if (NUMBERP (margin
))
471 int width
= XFASTINT (w
->width
);
472 double d
= max (0, XFLOATINT (margin
));
473 d
= min (width
/ 2 - 1, d
);
474 n
= (int) ((double) total_glyphs
/ width
* d
);
483 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
486 W is null if the function is called for a frame glyph matrix.
487 Otherwise it is the window MATRIX is a member of. X and Y are the
488 indices of the first column and row of MATRIX within the frame
489 matrix, if such a matrix exists. They are zero for purely
490 window-based redisplay. DIM is the needed size of the matrix.
492 In window-based redisplay, where no frame matrices exist, glyph
493 matrices manage their own glyph storage. Otherwise, they allocate
494 storage from a common frame glyph pool which can be found in
497 The reason for this memory management strategy is to avoid complete
498 frame redraws if possible. When we allocate from a common pool, a
499 change of the location or size of a sub-matrix within the pool
500 requires a complete redisplay of the frame because we cannot easily
501 make sure that the current matrices of all windows still agree with
502 what is displayed on the screen. While this is usually fast, it
503 leads to screen flickering. */
506 adjust_glyph_matrix (w
, matrix
, x
, y
, dim
)
508 struct glyph_matrix
*matrix
;
514 int marginal_areas_changed_p
= 0;
515 int header_line_changed_p
= 0;
516 int header_line_p
= 0;
517 int left
= -1, right
= -1;
518 int window_x
, window_y
, window_width
, window_height
;
520 /* See if W had a top line that has disappeared now, or vice versa. */
523 header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
524 header_line_changed_p
= header_line_p
!= matrix
->header_line_p
;
526 matrix
->header_line_p
= header_line_p
;
528 /* Do nothing if MATRIX' size, position, vscroll, and marginal areas
529 haven't changed. This optimization is important because preserving
530 the matrix means preventing redisplay. */
531 if (matrix
->pool
== NULL
)
533 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
534 left
= margin_glyphs_to_reserve (w
, dim
.width
, w
->left_margin_width
);
535 right
= margin_glyphs_to_reserve (w
, dim
.width
, w
->right_margin_width
);
536 xassert (left
>= 0 && right
>= 0);
537 marginal_areas_changed_p
= (left
!= matrix
->left_margin_glyphs
538 || right
!= matrix
->right_margin_glyphs
);
540 if (!marginal_areas_changed_p
542 && !header_line_changed_p
543 && matrix
->window_top_y
== XFASTINT (w
->top
)
544 && matrix
->window_height
== window_height
545 && matrix
->window_vscroll
== w
->vscroll
546 && matrix
->window_width
== window_width
)
550 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
551 if (matrix
->rows_allocated
< dim
.height
)
553 int size
= dim
.height
* sizeof (struct glyph_row
);
554 new_rows
= dim
.height
- matrix
->rows_allocated
;
555 matrix
->rows
= (struct glyph_row
*) xrealloc (matrix
->rows
, size
);
556 bzero (matrix
->rows
+ matrix
->rows_allocated
,
557 new_rows
* sizeof *matrix
->rows
);
558 matrix
->rows_allocated
= dim
.height
;
563 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
564 on a frame not using window-based redisplay. Set up pointers for
565 each row into the glyph pool. */
568 xassert (matrix
->pool
->glyphs
);
572 left
= margin_glyphs_to_reserve (w
, dim
.width
,
573 w
->left_margin_width
);
574 right
= margin_glyphs_to_reserve (w
, dim
.width
,
575 w
->right_margin_width
);
580 for (i
= 0; i
< dim
.height
; ++i
)
582 struct glyph_row
*row
= &matrix
->rows
[i
];
584 row
->glyphs
[LEFT_MARGIN_AREA
]
585 = (matrix
->pool
->glyphs
586 + (y
+ i
) * matrix
->pool
->ncolumns
590 || row
== matrix
->rows
+ dim
.height
- 1
591 || (row
== matrix
->rows
&& matrix
->header_line_p
))
593 row
->glyphs
[TEXT_AREA
]
594 = row
->glyphs
[LEFT_MARGIN_AREA
];
595 row
->glyphs
[RIGHT_MARGIN_AREA
]
596 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
597 row
->glyphs
[LAST_AREA
]
598 = row
->glyphs
[RIGHT_MARGIN_AREA
];
602 row
->glyphs
[TEXT_AREA
]
603 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
604 row
->glyphs
[RIGHT_MARGIN_AREA
]
605 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
606 row
->glyphs
[LAST_AREA
]
607 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
611 matrix
->left_margin_glyphs
= left
;
612 matrix
->right_margin_glyphs
= right
;
616 /* If MATRIX->pool is null, MATRIX is responsible for managing
617 its own memory. Allocate glyph memory from the heap. */
618 if (dim
.width
> matrix
->matrix_w
620 || header_line_changed_p
621 || marginal_areas_changed_p
)
623 struct glyph_row
*row
= matrix
->rows
;
624 struct glyph_row
*end
= row
+ matrix
->rows_allocated
;
628 row
->glyphs
[LEFT_MARGIN_AREA
]
629 = (struct glyph
*) xrealloc (row
->glyphs
[LEFT_MARGIN_AREA
],
631 * sizeof (struct glyph
)));
633 /* The mode line never has marginal areas. */
634 if (row
== matrix
->rows
+ dim
.height
- 1
635 || (row
== matrix
->rows
&& matrix
->header_line_p
))
637 row
->glyphs
[TEXT_AREA
]
638 = row
->glyphs
[LEFT_MARGIN_AREA
];
639 row
->glyphs
[RIGHT_MARGIN_AREA
]
640 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
641 row
->glyphs
[LAST_AREA
]
642 = row
->glyphs
[RIGHT_MARGIN_AREA
];
646 row
->glyphs
[TEXT_AREA
]
647 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
648 row
->glyphs
[RIGHT_MARGIN_AREA
]
649 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
650 row
->glyphs
[LAST_AREA
]
651 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
657 xassert (left
>= 0 && right
>= 0);
658 matrix
->left_margin_glyphs
= left
;
659 matrix
->right_margin_glyphs
= right
;
662 /* Number of rows to be used by MATRIX. */
663 matrix
->nrows
= dim
.height
;
665 /* Mark rows in a current matrix of a window as not having valid
666 contents. It's important to not do this for desired matrices.
667 When Emacs starts, it may already be building desired matrices
668 when this function runs. */
669 if (w
&& matrix
== w
->current_matrix
)
671 /* Optimize the case that only the height has changed (C-x 2,
672 upper window). Invalidate all rows that are no longer part
674 if (!marginal_areas_changed_p
675 && matrix
->window_top_y
== XFASTINT (w
->top
)
676 && matrix
->window_width
== window_width
)
679 while (matrix
->rows
[i
].enabled_p
680 && (MATRIX_ROW_BOTTOM_Y (matrix
->rows
+ i
)
681 < matrix
->window_height
))
684 /* Window end is invalid, if inside of the rows that
686 if (INTEGERP (w
->window_end_vpos
)
687 && XFASTINT (w
->window_end_vpos
) >= i
)
688 w
->window_end_valid
= Qnil
;
690 while (i
< matrix
->nrows
)
691 matrix
->rows
[i
++].enabled_p
= 0;
695 for (i
= 0; i
< matrix
->nrows
; ++i
)
696 matrix
->rows
[i
].enabled_p
= 0;
700 /* Remember last values to be able to optimize frame redraws. */
701 matrix
->matrix_x
= x
;
702 matrix
->matrix_y
= y
;
703 matrix
->matrix_w
= dim
.width
;
704 matrix
->matrix_h
= dim
.height
;
706 /* Record the top y location and height of W at the time the matrix
707 was last adjusted. This is used to optimize redisplay above. */
710 matrix
->window_top_y
= XFASTINT (w
->top
);
711 matrix
->window_height
= window_height
;
712 matrix
->window_width
= window_width
;
713 matrix
->window_vscroll
= w
->vscroll
;
718 /* Reverse the contents of rows in MATRIX between START and END. The
719 contents of the row at END - 1 end up at START, END - 2 at START +
720 1 etc. This is part of the implementation of rotate_matrix (see
724 reverse_rows (matrix
, start
, end
)
725 struct glyph_matrix
*matrix
;
730 for (i
= start
, j
= end
- 1; i
< j
; ++i
, --j
)
732 /* Non-ISO HP/UX compiler doesn't like auto struct
734 struct glyph_row temp
;
735 temp
= matrix
->rows
[i
];
736 matrix
->rows
[i
] = matrix
->rows
[j
];
737 matrix
->rows
[j
] = temp
;
742 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
743 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
744 indices. (Note: this does not copy glyphs, only glyph pointers in
745 row structures are moved around).
747 The algorithm used for rotating the vector was, I believe, first
748 described by Kernighan. See the vector R as consisting of two
749 sub-vectors AB, where A has length BY for BY >= 0. The result
750 after rotating is then BA. Reverse both sub-vectors to get ArBr
751 and reverse the result to get (ArBr)r which is BA. Similar for
755 rotate_matrix (matrix
, first
, last
, by
)
756 struct glyph_matrix
*matrix
;
761 /* Up (rotate left, i.e. towards lower indices). */
763 reverse_rows (matrix
, first
, first
+ by
);
764 reverse_rows (matrix
, first
+ by
, last
);
765 reverse_rows (matrix
, first
, last
);
769 /* Down (rotate right, i.e. towards higher indices). */
770 reverse_rows (matrix
, last
- by
, last
);
771 reverse_rows (matrix
, first
, last
- by
);
772 reverse_rows (matrix
, first
, last
);
777 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
778 with indices START <= index < END. Increment positions by DELTA/
782 increment_glyph_matrix_buffer_positions (matrix
, start
, end
, delta
,
784 struct glyph_matrix
*matrix
;
785 int start
, end
, delta
, delta_bytes
;
787 /* Check that START and END are reasonable values. */
788 xassert (start
>= 0 && start
<= matrix
->nrows
);
789 xassert (end
>= 0 && end
<= matrix
->nrows
);
790 xassert (start
<= end
);
792 for (; start
< end
; ++start
)
793 increment_glyph_row_buffer_positions (matrix
->rows
+ start
,
798 /* Enable a range of rows in glyph matrix MATRIX. START and END are
799 the row indices of the first and last + 1 row to enable. If
800 ENABLED_P is non-zero, enabled_p flags in rows will be set to 1. */
803 enable_glyph_matrix_rows (matrix
, start
, end
, enabled_p
)
804 struct glyph_matrix
*matrix
;
808 xassert (start
<= end
);
809 xassert (start
>= 0 && start
< matrix
->nrows
);
810 xassert (end
>= 0 && end
<= matrix
->nrows
);
812 for (; start
< end
; ++start
)
813 matrix
->rows
[start
].enabled_p
= enabled_p
!= 0;
819 This empties all rows in MATRIX by setting the enabled_p flag for
820 all rows of the matrix to zero. The function prepare_desired_row
821 will eventually really clear a row when it sees one with a zero
824 Resets update hints to defaults value. The only update hint
825 currently present is the flag MATRIX->no_scrolling_p. */
828 clear_glyph_matrix (matrix
)
829 struct glyph_matrix
*matrix
;
833 enable_glyph_matrix_rows (matrix
, 0, matrix
->nrows
, 0);
834 matrix
->no_scrolling_p
= 0;
839 /* Shift part of the glyph matrix MATRIX of window W up or down.
840 Increment y-positions in glyph rows between START and END by DY,
841 and recompute their visible height. */
844 shift_glyph_matrix (w
, matrix
, start
, end
, dy
)
846 struct glyph_matrix
*matrix
;
851 xassert (start
<= end
);
852 xassert (start
>= 0 && start
< matrix
->nrows
);
853 xassert (end
>= 0 && end
<= matrix
->nrows
);
855 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
856 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
858 for (; start
< end
; ++start
)
860 struct glyph_row
*row
= &matrix
->rows
[start
];
865 row
->visible_height
= row
->height
- (min_y
- row
->y
);
866 else if (row
->y
+ row
->height
> max_y
)
867 row
->visible_height
= row
->height
- (row
->y
+ row
->height
- max_y
);
869 row
->visible_height
= row
->height
;
874 /* Mark all rows in current matrices of frame F as invalid. Marking
875 invalid is done by setting enabled_p to zero for all rows in a
879 clear_current_matrices (f
)
880 register struct frame
*f
;
882 /* Clear frame current matrix, if we have one. */
883 if (f
->current_matrix
)
884 clear_glyph_matrix (f
->current_matrix
);
886 /* Clear the matrix of the menu bar window, if such a window exists.
887 The menu bar window is currently used to display menus on X when
888 no toolkit support is compiled in. */
889 if (WINDOWP (f
->menu_bar_window
))
890 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->current_matrix
);
892 /* Clear the matrix of the tool-bar window, if any. */
893 if (WINDOWP (f
->tool_bar_window
))
894 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
896 /* Clear current window matrices. */
897 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
898 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 0);
902 /* Clear out all display lines of F for a coming redisplay. */
905 clear_desired_matrices (f
)
906 register struct frame
*f
;
908 if (f
->desired_matrix
)
909 clear_glyph_matrix (f
->desired_matrix
);
911 if (WINDOWP (f
->menu_bar_window
))
912 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->desired_matrix
);
914 if (WINDOWP (f
->tool_bar_window
))
915 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->desired_matrix
);
917 /* Do it for window matrices. */
918 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
919 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
923 /* Clear matrices in window tree rooted in W. If DESIRED_P is
924 non-zero clear desired matrices, otherwise clear current matrices. */
927 clear_window_matrices (w
, desired_p
)
933 if (!NILP (w
->hchild
))
935 xassert (WINDOWP (w
->hchild
));
936 clear_window_matrices (XWINDOW (w
->hchild
), desired_p
);
938 else if (!NILP (w
->vchild
))
940 xassert (WINDOWP (w
->vchild
));
941 clear_window_matrices (XWINDOW (w
->vchild
), desired_p
);
946 clear_glyph_matrix (w
->desired_matrix
);
949 clear_glyph_matrix (w
->current_matrix
);
950 w
->window_end_valid
= Qnil
;
954 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
960 /***********************************************************************
963 See dispextern.h for an overall explanation of glyph rows.
964 ***********************************************************************/
966 /* Clear glyph row ROW. Do it in a way that makes it robust against
967 changes in the glyph_row structure, i.e. addition or removal of
968 structure members. */
971 clear_glyph_row (row
)
972 struct glyph_row
*row
;
974 struct glyph
*p
[1 + LAST_AREA
];
975 static struct glyph_row null_row
;
978 p
[LEFT_MARGIN_AREA
] = row
->glyphs
[LEFT_MARGIN_AREA
];
979 p
[TEXT_AREA
] = row
->glyphs
[TEXT_AREA
];
980 p
[RIGHT_MARGIN_AREA
] = row
->glyphs
[RIGHT_MARGIN_AREA
];
981 p
[LAST_AREA
] = row
->glyphs
[LAST_AREA
];
986 /* Restore pointers. */
987 row
->glyphs
[LEFT_MARGIN_AREA
] = p
[LEFT_MARGIN_AREA
];
988 row
->glyphs
[TEXT_AREA
] = p
[TEXT_AREA
];
989 row
->glyphs
[RIGHT_MARGIN_AREA
] = p
[RIGHT_MARGIN_AREA
];
990 row
->glyphs
[LAST_AREA
] = p
[LAST_AREA
];
994 /* Make ROW an empty, enabled row of canonical character height,
995 in window W starting at y-position Y. */
998 blank_row (w
, row
, y
)
1000 struct glyph_row
*row
;
1005 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
1006 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
1008 clear_glyph_row (row
);
1010 row
->ascent
= row
->phys_ascent
= 0;
1011 row
->height
= row
->phys_height
= CANON_Y_UNIT (XFRAME (w
->frame
));
1014 row
->visible_height
= row
->height
- (min_y
- row
->y
);
1015 else if (row
->y
+ row
->height
> max_y
)
1016 row
->visible_height
= row
->height
- (row
->y
+ row
->height
- max_y
);
1018 row
->visible_height
= row
->height
;
1024 /* Increment buffer positions in glyph row ROW. DELTA and DELTA_BYTES
1025 are the amounts by which to change positions. Note that the first
1026 glyph of the text area of a row can have a buffer position even if
1027 the used count of the text area is zero. Such rows display line
1031 increment_glyph_row_buffer_positions (row
, delta
, delta_bytes
)
1032 struct glyph_row
*row
;
1033 int delta
, delta_bytes
;
1037 /* Increment start and end positions. */
1038 MATRIX_ROW_START_CHARPOS (row
) += delta
;
1039 MATRIX_ROW_START_BYTEPOS (row
) += delta_bytes
;
1040 MATRIX_ROW_END_CHARPOS (row
) += delta
;
1041 MATRIX_ROW_END_BYTEPOS (row
) += delta_bytes
;
1043 /* Increment positions in glyphs. */
1044 for (area
= 0; area
< LAST_AREA
; ++area
)
1045 for (i
= 0; i
< row
->used
[area
]; ++i
)
1046 if (BUFFERP (row
->glyphs
[area
][i
].object
)
1047 && row
->glyphs
[area
][i
].charpos
> 0)
1048 row
->glyphs
[area
][i
].charpos
+= delta
;
1050 /* Capture the case of rows displaying a line end. */
1051 if (row
->used
[TEXT_AREA
] == 0
1052 && MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1053 row
->glyphs
[TEXT_AREA
]->charpos
+= delta
;
1057 /* Swap glyphs between two glyph rows A and B. This exchanges glyph
1058 contents, i.e. glyph structure contents are exchanged between A and
1059 B without changing glyph pointers in A and B. */
1062 swap_glyphs_in_rows (a
, b
)
1063 struct glyph_row
*a
, *b
;
1067 for (area
= 0; area
< LAST_AREA
; ++area
)
1069 /* Number of glyphs to swap. */
1070 int max_used
= max (a
->used
[area
], b
->used
[area
]);
1072 /* Start of glyphs in area of row A. */
1073 struct glyph
*glyph_a
= a
->glyphs
[area
];
1075 /* End + 1 of glyphs in area of row A. */
1076 struct glyph
*glyph_a_end
= a
->glyphs
[max_used
];
1078 /* Start of glyphs in area of row B. */
1079 struct glyph
*glyph_b
= b
->glyphs
[area
];
1081 while (glyph_a
< glyph_a_end
)
1083 /* Non-ISO HP/UX compiler doesn't like auto struct
1087 *glyph_a
= *glyph_b
;
1096 /* Exchange pointers to glyph memory between glyph rows A and B. */
1099 swap_glyph_pointers (a
, b
)
1100 struct glyph_row
*a
, *b
;
1103 for (i
= 0; i
< LAST_AREA
+ 1; ++i
)
1105 struct glyph
*temp
= a
->glyphs
[i
];
1106 a
->glyphs
[i
] = b
->glyphs
[i
];
1107 b
->glyphs
[i
] = temp
;
1112 /* Copy glyph row structure FROM to glyph row structure TO, except
1113 that glyph pointers in the structures are left unchanged. */
1116 copy_row_except_pointers (to
, from
)
1117 struct glyph_row
*to
, *from
;
1119 struct glyph
*pointers
[1 + LAST_AREA
];
1121 /* Save glyph pointers of TO. */
1122 bcopy (to
->glyphs
, pointers
, sizeof to
->glyphs
);
1124 /* Do a structure assignment. */
1127 /* Restore original pointers of TO. */
1128 bcopy (pointers
, to
->glyphs
, sizeof to
->glyphs
);
1132 /* Copy contents of glyph row FROM to glyph row TO. Glyph pointers in
1133 TO and FROM are left unchanged. Glyph contents are copied from the
1134 glyph memory of FROM to the glyph memory of TO. Increment buffer
1135 positions in row TO by DELTA/ DELTA_BYTES. */
1138 copy_glyph_row_contents (to
, from
, delta
, delta_bytes
)
1139 struct glyph_row
*to
, *from
;
1140 int delta
, delta_bytes
;
1144 /* This is like a structure assignment TO = FROM, except that
1145 glyph pointers in the rows are left unchanged. */
1146 copy_row_except_pointers (to
, from
);
1148 /* Copy glyphs from FROM to TO. */
1149 for (area
= 0; area
< LAST_AREA
; ++area
)
1150 if (from
->used
[area
])
1151 bcopy (from
->glyphs
[area
], to
->glyphs
[area
],
1152 from
->used
[area
] * sizeof (struct glyph
));
1154 /* Increment buffer positions in TO by DELTA. */
1155 increment_glyph_row_buffer_positions (to
, delta
, delta_bytes
);
1159 /* Assign glyph row FROM to glyph row TO. This works like a structure
1160 assignment TO = FROM, except that glyph pointers are not copied but
1161 exchanged between TO and FROM. Pointers must be exchanged to avoid
1165 assign_row (to
, from
)
1166 struct glyph_row
*to
, *from
;
1168 swap_glyph_pointers (to
, from
);
1169 copy_row_except_pointers (to
, from
);
1173 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1174 a row in a window matrix, is a slice of the glyph memory of the
1175 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1176 is non-zero if the glyph memory of WINDOW_ROW is part of the glyph
1177 memory of FRAME_ROW. */
1180 glyph_row_slice_p (window_row
, frame_row
)
1181 struct glyph_row
*window_row
, *frame_row
;
1183 struct glyph
*window_glyph_start
= window_row
->glyphs
[0];
1184 struct glyph
*frame_glyph_start
= frame_row
->glyphs
[0];
1185 struct glyph
*frame_glyph_end
= frame_row
->glyphs
[LAST_AREA
];
1187 return (frame_glyph_start
<= window_glyph_start
1188 && window_glyph_start
< frame_glyph_end
);
1192 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1193 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1194 in WINDOW_MATRIX is found satisfying the condition. */
1196 static struct glyph_row
*
1197 find_glyph_row_slice (window_matrix
, frame_matrix
, row
)
1198 struct glyph_matrix
*window_matrix
, *frame_matrix
;
1203 xassert (row
>= 0 && row
< frame_matrix
->nrows
);
1205 for (i
= 0; i
< window_matrix
->nrows
; ++i
)
1206 if (glyph_row_slice_p (window_matrix
->rows
+ i
,
1207 frame_matrix
->rows
+ row
))
1210 return i
< window_matrix
->nrows
? window_matrix
->rows
+ i
: 0;
1214 /* Prepare ROW for display. Desired rows are cleared lazily,
1215 i.e. they are only marked as to be cleared by setting their
1216 enabled_p flag to zero. When a row is to be displayed, a prior
1217 call to this function really clears it. */
1220 prepare_desired_row (row
)
1221 struct glyph_row
*row
;
1223 if (!row
->enabled_p
)
1225 clear_glyph_row (row
);
1231 /* Return a hash code for glyph row ROW. */
1234 line_hash_code (row
)
1235 struct glyph_row
*row
;
1243 /* Give all highlighted lines the same hash code
1244 so as to encourage scrolling to leave them in place. */
1249 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
1250 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
1254 GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*glyph
);
1255 if (must_write_spaces
)
1257 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + g
;
1270 /* Return the cost of drawing line VPOS In MATRIX. The cost equals
1271 the number of characters in the line. If must_write_spaces is
1272 zero, leading and trailing spaces are ignored. */
1275 line_draw_cost (matrix
, vpos
)
1276 struct glyph_matrix
*matrix
;
1279 struct glyph_row
*row
= matrix
->rows
+ vpos
;
1280 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
1281 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
];
1283 Lisp_Object
*glyph_table_base
= GLYPH_TABLE_BASE
;
1284 int glyph_table_len
= GLYPH_TABLE_LENGTH
;
1286 /* Ignore trailing and leading spaces if we can. */
1287 if (!must_write_spaces
)
1289 /* Skip from the end over trailing spaces. */
1290 while (end
!= beg
&& CHAR_GLYPH_SPACE_P (*end
))
1293 /* All blank line. */
1297 /* Skip over leading spaces. */
1298 while (CHAR_GLYPH_SPACE_P (*beg
))
1302 /* If we don't have a glyph-table, each glyph is one character,
1303 so return the number of glyphs. */
1304 if (glyph_table_base
== 0)
1308 /* Otherwise, scan the glyphs and accumulate their total length
1313 GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*beg
);
1315 if (GLYPH_SIMPLE_P (glyph_table_base
, glyph_table_len
, g
))
1318 len
+= GLYPH_LENGTH (glyph_table_base
, g
);
1328 /* Test two glyph rows A and B for equality. Value is non-zero if A
1329 and B have equal contents. W is the window to which the glyphs
1330 rows A and B belong. It is needed here to test for partial row
1334 row_equal_p (w
, a
, b
)
1336 struct glyph_row
*a
, *b
;
1340 else if (a
->hash
!= b
->hash
)
1344 struct glyph
*a_glyph
, *b_glyph
, *a_end
;
1347 /* Compare glyphs. */
1348 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
1350 if (a
->used
[area
] != b
->used
[area
])
1353 a_glyph
= a
->glyphs
[area
];
1354 a_end
= a_glyph
+ a
->used
[area
];
1355 b_glyph
= b
->glyphs
[area
];
1357 while (a_glyph
< a_end
1358 && GLYPH_EQUAL_P (a_glyph
, b_glyph
))
1359 ++a_glyph
, ++b_glyph
;
1361 if (a_glyph
!= a_end
)
1365 if (a
->truncated_on_left_p
!= b
->truncated_on_left_p
1366 || a
->inverse_p
!= b
->inverse_p
1367 || a
->fill_line_p
!= b
->fill_line_p
1368 || a
->truncated_on_right_p
!= b
->truncated_on_right_p
1369 || a
->overlay_arrow_p
!= b
->overlay_arrow_p
1370 || a
->continued_p
!= b
->continued_p
1371 || a
->indicate_empty_line_p
!= b
->indicate_empty_line_p
1372 || a
->overlapped_p
!= b
->overlapped_p
1373 || (MATRIX_ROW_CONTINUATION_LINE_P (a
)
1374 != MATRIX_ROW_CONTINUATION_LINE_P (b
))
1375 /* Different partially visible characters on left margin. */
1377 /* Different height. */
1378 || a
->ascent
!= b
->ascent
1379 || a
->phys_ascent
!= b
->phys_ascent
1380 || a
->phys_height
!= b
->phys_height
1381 || a
->visible_height
!= b
->visible_height
)
1390 /***********************************************************************
1393 See dispextern.h for an overall explanation of glyph pools.
1394 ***********************************************************************/
1396 /* Allocate a glyph_pool structure. The structure returned is
1397 initialized with zeros. The global variable glyph_pool_count is
1398 incremented for each pool allocated. */
1400 static struct glyph_pool
*
1403 struct glyph_pool
*result
;
1405 /* Allocate a new glyph_pool and clear it. */
1406 result
= (struct glyph_pool
*) xmalloc (sizeof *result
);
1407 bzero (result
, sizeof *result
);
1409 /* For memory leak and double deletion checking. */
1416 /* Free a glyph_pool structure POOL. The function may be called with
1417 a null POOL pointer. The global variable glyph_pool_count is
1418 decremented with every pool structure freed. If this count gets
1419 negative, more structures were freed than allocated, i.e. one
1420 structure must have been freed more than once or a bogus pointer
1421 was passed to free_glyph_pool. */
1424 free_glyph_pool (pool
)
1425 struct glyph_pool
*pool
;
1429 /* More freed than allocated? */
1431 xassert (glyph_pool_count
>= 0);
1433 xfree (pool
->glyphs
);
1439 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1440 columns we need. This function never shrinks a pool. The only
1441 case in which this would make sense, would be when a frame's size
1442 is changed from a large value to a smaller one. But, if someone
1443 does it once, we can expect that he will do it again.
1445 Value is non-zero if the pool changed in a way which makes
1446 re-adjusting window glyph matrices necessary. */
1449 realloc_glyph_pool (pool
, matrix_dim
)
1450 struct glyph_pool
*pool
;
1451 struct dim matrix_dim
;
1456 changed_p
= (pool
->glyphs
== 0
1457 || matrix_dim
.height
!= pool
->nrows
1458 || matrix_dim
.width
!= pool
->ncolumns
);
1460 /* Enlarge the glyph pool. */
1461 needed
= matrix_dim
.width
* matrix_dim
.height
;
1462 if (needed
> pool
->nglyphs
)
1464 int size
= needed
* sizeof (struct glyph
);
1467 pool
->glyphs
= (struct glyph
*) xrealloc (pool
->glyphs
, size
);
1470 pool
->glyphs
= (struct glyph
*) xmalloc (size
);
1471 bzero (pool
->glyphs
, size
);
1474 pool
->nglyphs
= needed
;
1477 /* Remember the number of rows and columns because (a) we use then
1478 to do sanity checks, and (b) the number of columns determines
1479 where rows in the frame matrix start---this must be available to
1480 determine pointers to rows of window sub-matrices. */
1481 pool
->nrows
= matrix_dim
.height
;
1482 pool
->ncolumns
= matrix_dim
.width
;
1489 /***********************************************************************
1491 ***********************************************************************/
1495 /* Check that no glyph pointers have been lost in MATRIX. If a
1496 pointer has been lost, e.g. by using a structure assignment between
1497 rows, at least one pointer must occur more than once in the rows of
1501 check_matrix_pointer_lossage (matrix
)
1502 struct glyph_matrix
*matrix
;
1506 for (i
= 0; i
< matrix
->nrows
; ++i
)
1507 for (j
= 0; j
< matrix
->nrows
; ++j
)
1509 || (matrix
->rows
[i
].glyphs
[TEXT_AREA
]
1510 != matrix
->rows
[j
].glyphs
[TEXT_AREA
]));
1514 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1517 matrix_row (matrix
, row
)
1518 struct glyph_matrix
*matrix
;
1521 xassert (matrix
&& matrix
->rows
);
1522 xassert (row
>= 0 && row
< matrix
->nrows
);
1524 /* That's really too slow for normal testing because this function
1525 is called almost everywhere. Although---it's still astonishingly
1526 fast, so it is valuable to have for debugging purposes. */
1528 check_matrix_pointer_lossage (matrix
);
1531 return matrix
->rows
+ row
;
1535 #if 0 /* This function makes invalid assumptions when text is
1536 partially invisible. But it might come handy for debugging
1539 /* Check invariants that must hold for an up to date current matrix of
1543 check_matrix_invariants (w
)
1546 struct glyph_matrix
*matrix
= w
->current_matrix
;
1547 int yb
= window_text_bottom_y (w
);
1548 struct glyph_row
*row
= matrix
->rows
;
1549 struct glyph_row
*last_text_row
= NULL
;
1550 struct buffer
*saved
= current_buffer
;
1551 struct buffer
*buffer
= XBUFFER (w
->buffer
);
1554 /* This can sometimes happen for a fresh window. */
1555 if (matrix
->nrows
< 2)
1558 set_buffer_temp (buffer
);
1560 /* Note: last row is always reserved for the mode line. */
1561 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1562 && MATRIX_ROW_BOTTOM_Y (row
) < yb
)
1564 struct glyph_row
*next
= row
+ 1;
1566 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1567 last_text_row
= row
;
1569 /* Check that character and byte positions are in sync. */
1570 xassert (MATRIX_ROW_START_BYTEPOS (row
)
1571 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row
)));
1573 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1574 have such a position temporarily in case of a minibuffer
1575 displaying something like `[Sole completion]' at its end. */
1576 if (MATRIX_ROW_END_CHARPOS (row
) < BUF_ZV (current_buffer
))
1577 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1578 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row
)));
1580 /* Check that end position of `row' is equal to start position
1582 if (next
->enabled_p
&& MATRIX_ROW_DISPLAYS_TEXT_P (next
))
1584 xassert (MATRIX_ROW_END_CHARPOS (row
)
1585 == MATRIX_ROW_START_CHARPOS (next
));
1586 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1587 == MATRIX_ROW_START_BYTEPOS (next
));
1592 xassert (w
->current_matrix
->nrows
== w
->desired_matrix
->nrows
);
1593 xassert (w
->desired_matrix
->rows
!= NULL
);
1594 set_buffer_temp (saved
);
1599 #endif /* GLYPH_DEBUG != 0 */
1603 /**********************************************************************
1604 Allocating/ Adjusting Glyph Matrices
1605 **********************************************************************/
1607 /* Allocate glyph matrices over a window tree for a frame-based
1610 X and Y are column/row within the frame glyph matrix where
1611 sub-matrices for the window tree rooted at WINDOW must be
1612 allocated. CH_DIM contains the dimensions of the smallest
1613 character that could be used during display. DIM_ONLY_P non-zero
1614 means that the caller of this function is only interested in the
1615 result matrix dimension, and matrix adjustments should not be
1618 The function returns the total width/height of the sub-matrices of
1619 the window tree. If called on a frame root window, the computation
1620 will take the mini-buffer window into account.
1622 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1624 NEW_LEAF_MATRIX set if any window in the tree did not have a
1625 glyph matrices yet, and
1627 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1628 any window in the tree will be changed or have been changed (see
1631 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1634 Windows are arranged into chains of windows on the same level
1635 through the next fields of window structures. Such a level can be
1636 either a sequence of horizontally adjacent windows from left to
1637 right, or a sequence of vertically adjacent windows from top to
1638 bottom. Each window in a horizontal sequence can be either a leaf
1639 window or a vertical sequence; a window in a vertical sequence can
1640 be either a leaf or a horizontal sequence. All windows in a
1641 horizontal sequence have the same height, and all windows in a
1642 vertical sequence have the same width.
1644 This function uses, for historical reasons, a more general
1645 algorithm to determine glyph matrix dimensions that would be
1648 The matrix height of a horizontal sequence is determined by the
1649 maximum height of any matrix in the sequence. The matrix width of
1650 a horizontal sequence is computed by adding up matrix widths of
1651 windows in the sequence.
1653 |<------- result width ------->|
1654 +---------+----------+---------+ ---
1657 +---------+ | | result height
1662 The matrix width of a vertical sequence is the maximum matrix width
1663 of any window in the sequence. Its height is computed by adding up
1664 matrix heights of windows in the sequence.
1666 |<---- result width -->|
1674 +------------+---------+ |
1677 +------------+---------+ --- */
1679 /* Bit indicating that a new matrix will be allocated or has been
1682 #define NEW_LEAF_MATRIX (1 << 0)
1684 /* Bit indicating that a matrix will or has changed its location or
1687 #define CHANGED_LEAF_MATRIX (1 << 1)
1690 allocate_matrices_for_frame_redisplay (window
, x
, y
, ch_dim
,
1691 dim_only_p
, window_change_flags
)
1696 int *window_change_flags
;
1698 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1700 int wmax
= 0, hmax
= 0;
1704 int in_horz_combination_p
;
1706 /* What combination is WINDOW part of? Compute this once since the
1707 result is the same for all windows in the `next' chain. The
1708 special case of a root window (parent equal to nil) is treated
1709 like a vertical combination because a root window's `next'
1710 points to the mini-buffer window, if any, which is arranged
1711 vertically below other windows. */
1712 in_horz_combination_p
1713 = (!NILP (XWINDOW (window
)->parent
)
1714 && !NILP (XWINDOW (XWINDOW (window
)->parent
)->hchild
));
1716 /* For WINDOW and all windows on the same level. */
1719 w
= XWINDOW (window
);
1721 /* Get the dimension of the window sub-matrix for W, depending
1722 on whether this a combination or a leaf window. */
1723 if (!NILP (w
->hchild
))
1724 dim
= allocate_matrices_for_frame_redisplay (w
->hchild
, x
, y
, ch_dim
,
1726 window_change_flags
);
1727 else if (!NILP (w
->vchild
))
1728 dim
= allocate_matrices_for_frame_redisplay (w
->vchild
, x
, y
, ch_dim
,
1730 window_change_flags
);
1733 /* If not already done, allocate sub-matrix structures. */
1734 if (w
->desired_matrix
== NULL
)
1736 w
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1737 w
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1738 *window_change_flags
|= NEW_LEAF_MATRIX
;
1741 /* Width and height MUST be chosen so that there are no
1742 holes in the frame matrix. */
1743 dim
.width
= w
->width
;
1744 dim
.height
= w
->height
;
1746 /* Will matrix be re-allocated? */
1747 if (x
!= w
->desired_matrix
->matrix_x
1748 || y
!= w
->desired_matrix
->matrix_y
1749 || dim
.width
!= w
->desired_matrix
->matrix_w
1750 || dim
.height
!= w
->desired_matrix
->matrix_h
1751 || (margin_glyphs_to_reserve (w
, dim
.width
,
1752 w
->right_margin_width
)
1753 != w
->desired_matrix
->left_margin_glyphs
)
1754 || (margin_glyphs_to_reserve (w
, dim
.width
,
1755 w
->left_margin_width
)
1756 != w
->desired_matrix
->right_margin_glyphs
))
1757 *window_change_flags
|= CHANGED_LEAF_MATRIX
;
1759 /* Actually change matrices, if allowed. Do not consider
1760 CHANGED_LEAF_MATRIX computed above here because the pool
1761 may have been changed which we don't now here. We trust
1762 that we only will be called with DIM_ONLY_P != 0 when
1766 adjust_glyph_matrix (w
, w
->desired_matrix
, x
, y
, dim
);
1767 adjust_glyph_matrix (w
, w
->current_matrix
, x
, y
, dim
);
1771 /* If we are part of a horizontal combination, advance x for
1772 windows to the right of W; otherwise advance y for windows
1774 if (in_horz_combination_p
)
1779 /* Remember maximum glyph matrix dimensions. */
1780 wmax
= max (wmax
, dim
.width
);
1781 hmax
= max (hmax
, dim
.height
);
1783 /* Next window on same level. */
1786 while (!NILP (window
));
1788 /* Set `total' to the total glyph matrix dimension of this window
1789 level. In a vertical combination, the width is the width of the
1790 widest window; the height is the y we finally reached, corrected
1791 by the y we started with. In a horizontal combination, the total
1792 height is the height of the tallest window, and the width is the
1793 x we finally reached, corrected by the x we started with. */
1794 if (in_horz_combination_p
)
1796 total
.width
= x
- x0
;
1797 total
.height
= hmax
;
1802 total
.height
= y
- y0
;
1809 /* Allocate window matrices for window-based redisplay. W is the
1810 window whose matrices must be allocated/reallocated. CH_DIM is the
1811 size of the smallest character that could potentially be used on W. */
1814 allocate_matrices_for_window_redisplay (w
, ch_dim
)
1818 struct frame
*f
= XFRAME (w
->frame
);
1822 if (!NILP (w
->vchild
))
1823 allocate_matrices_for_window_redisplay (XWINDOW (w
->vchild
), ch_dim
);
1824 else if (!NILP (w
->hchild
))
1825 allocate_matrices_for_window_redisplay (XWINDOW (w
->hchild
), ch_dim
);
1828 /* W is a leaf window. */
1829 int window_pixel_width
= XFLOATINT (w
->width
) * CANON_X_UNIT (f
);
1830 int window_pixel_height
= window_box_height (w
) + abs (w
->vscroll
);
1833 /* If matrices are not yet allocated, allocate them now. */
1834 if (w
->desired_matrix
== NULL
)
1836 w
->desired_matrix
= new_glyph_matrix (NULL
);
1837 w
->current_matrix
= new_glyph_matrix (NULL
);
1840 /* Compute number of glyphs needed in a glyph row. */
1841 dim
.width
= (((window_pixel_width
+ ch_dim
.width
- 1)
1843 /* 2 partially visible columns in the text area. */
1845 /* One partially visible column at the right
1846 edge of each marginal area. */
1849 /* Compute number of glyph rows needed. */
1850 dim
.height
= (((window_pixel_height
+ ch_dim
.height
- 1)
1852 /* One partially visible line at the top and
1853 bottom of the window. */
1855 /* 2 for top and mode line. */
1858 /* Change matrices. */
1859 adjust_glyph_matrix (w
, w
->desired_matrix
, 0, 0, dim
);
1860 adjust_glyph_matrix (w
, w
->current_matrix
, 0, 0, dim
);
1863 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
1868 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
1869 do it for all frames; otherwise do it just for the given frame.
1870 This function must be called when a new frame is created, its size
1871 changes, or its window configuration changes. */
1877 /* Block input so that expose events and other events that access
1878 glyph matrices are not processed while we are changing them. */
1882 adjust_frame_glyphs (f
);
1885 Lisp_Object tail
, lisp_frame
;
1887 FOR_EACH_FRAME (tail
, lisp_frame
)
1888 adjust_frame_glyphs (XFRAME (lisp_frame
));
1895 /* Adjust frame glyphs when Emacs is initialized.
1897 To be called from init_display.
1899 We need a glyph matrix because redraw will happen soon.
1900 Unfortunately, window sizes on selected_frame are not yet set to
1901 meaningful values. I believe we can assume that there are only two
1902 windows on the frame---the mini-buffer and the root window. Frame
1903 height and width seem to be correct so far. So, set the sizes of
1904 windows to estimated values. */
1907 adjust_frame_glyphs_initially ()
1909 struct frame
*sf
= SELECTED_FRAME ();
1910 struct window
*root
= XWINDOW (sf
->root_window
);
1911 struct window
*mini
= XWINDOW (root
->next
);
1912 int frame_height
= FRAME_HEIGHT (sf
);
1913 int frame_width
= FRAME_WIDTH (sf
);
1914 int top_margin
= FRAME_TOP_MARGIN (sf
);
1916 /* Do it for the root window. */
1917 XSETFASTINT (root
->top
, top_margin
);
1918 XSETFASTINT (root
->width
, frame_width
);
1919 set_window_height (sf
->root_window
, frame_height
- 1 - top_margin
, 0);
1921 /* Do it for the mini-buffer window. */
1922 XSETFASTINT (mini
->top
, frame_height
- 1);
1923 XSETFASTINT (mini
->width
, frame_width
);
1924 set_window_height (root
->next
, 1, 0);
1926 adjust_frame_glyphs (sf
);
1927 glyphs_initialized_initially_p
= 1;
1931 /* Allocate/reallocate glyph matrices of a single frame F. */
1934 adjust_frame_glyphs (f
)
1937 if (FRAME_WINDOW_P (f
))
1938 adjust_frame_glyphs_for_window_redisplay (f
);
1940 adjust_frame_glyphs_for_frame_redisplay (f
);
1942 /* Don't forget the message buffer and the buffer for
1943 decode_mode_spec. */
1944 adjust_frame_message_buffer (f
);
1945 adjust_decode_mode_spec_buffer (f
);
1947 f
->glyphs_initialized_p
= 1;
1951 /* Allocate/reallocate glyph matrices of a single frame F for
1952 frame-based redisplay. */
1955 adjust_frame_glyphs_for_frame_redisplay (f
)
1959 struct dim matrix_dim
;
1961 int window_change_flags
;
1964 if (!FRAME_LIVE_P (f
))
1967 /* Determine the smallest character in any font for F. On
1968 console windows, all characters have dimension (1, 1). */
1969 ch_dim
.width
= ch_dim
.height
= 1;
1971 top_window_y
= FRAME_TOP_MARGIN (f
);
1973 /* Allocate glyph pool structures if not already done. */
1974 if (f
->desired_pool
== NULL
)
1976 f
->desired_pool
= new_glyph_pool ();
1977 f
->current_pool
= new_glyph_pool ();
1980 /* Allocate frames matrix structures if needed. */
1981 if (f
->desired_matrix
== NULL
)
1983 f
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1984 f
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1987 /* Compute window glyph matrices. (This takes the mini-buffer
1988 window into account). The result is the size of the frame glyph
1989 matrix needed. The variable window_change_flags is set to a bit
1990 mask indicating whether new matrices will be allocated or
1991 existing matrices change their size or location within the frame
1993 window_change_flags
= 0;
1995 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
1998 &window_change_flags
);
2000 /* Add in menu bar lines, if any. */
2001 matrix_dim
.height
+= top_window_y
;
2003 /* Enlarge pools as necessary. */
2004 pool_changed_p
= realloc_glyph_pool (f
->desired_pool
, matrix_dim
);
2005 realloc_glyph_pool (f
->current_pool
, matrix_dim
);
2007 /* Set up glyph pointers within window matrices. Do this only if
2008 absolutely necessary since it requires a frame redraw. */
2009 if (pool_changed_p
|| window_change_flags
)
2011 /* Do it for window matrices. */
2012 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2013 0, top_window_y
, ch_dim
, 0,
2014 &window_change_flags
);
2016 /* Size of frame matrices must equal size of frame. Note
2017 that we are called for X frames with window widths NOT equal
2018 to the frame width (from CHANGE_FRAME_SIZE_1). */
2019 xassert (matrix_dim
.width
== FRAME_WIDTH (f
)
2020 && matrix_dim
.height
== FRAME_HEIGHT (f
));
2022 /* Resize frame matrices. */
2023 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2024 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2026 /* Since location and size of sub-matrices within the pool may
2027 have changed, and current matrices don't have meaningful
2028 contents anymore, mark the frame garbaged. */
2029 SET_FRAME_GARBAGED (f
);
2034 /* Allocate/reallocate glyph matrices of a single frame F for
2035 window-based redisplay. */
2038 adjust_frame_glyphs_for_window_redisplay (f
)
2044 xassert (FRAME_WINDOW_P (f
) && FRAME_LIVE_P (f
));
2046 /* Get minimum sizes. */
2047 #ifdef HAVE_WINDOW_SYSTEM
2048 ch_dim
.width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2049 ch_dim
.height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
2051 ch_dim
.width
= ch_dim
.height
= 1;
2054 /* Allocate/reallocate window matrices. */
2055 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f
)),
2058 /* Allocate/ reallocate matrices of the dummy window used to display
2059 the menu bar under X when no X toolkit support is available. */
2060 #ifndef USE_X_TOOLKIT
2062 /* Allocate a dummy window if not already done. */
2063 if (NILP (f
->menu_bar_window
))
2065 f
->menu_bar_window
= make_window ();
2066 w
= XWINDOW (f
->menu_bar_window
);
2067 XSETFRAME (w
->frame
, f
);
2068 w
->pseudo_window_p
= 1;
2071 w
= XWINDOW (f
->menu_bar_window
);
2073 /* Set window dimensions to frame dimensions and allocate or
2074 adjust glyph matrices of W. */
2075 XSETFASTINT (w
->top
, 0);
2076 XSETFASTINT (w
->left
, 0);
2077 XSETFASTINT (w
->height
, FRAME_MENU_BAR_LINES (f
));
2078 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2079 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2081 #endif /* not USE_X_TOOLKIT */
2083 /* Allocate/ reallocate matrices of the tool bar window. If we
2084 don't have a tool bar window yet, make one. */
2085 if (NILP (f
->tool_bar_window
))
2087 f
->tool_bar_window
= make_window ();
2088 w
= XWINDOW (f
->tool_bar_window
);
2089 XSETFRAME (w
->frame
, f
);
2090 w
->pseudo_window_p
= 1;
2093 w
= XWINDOW (f
->tool_bar_window
);
2095 XSETFASTINT (w
->top
, FRAME_MENU_BAR_LINES (f
));
2096 XSETFASTINT (w
->left
, 0);
2097 XSETFASTINT (w
->height
, FRAME_TOOL_BAR_LINES (f
));
2098 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2099 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2103 /* Adjust/ allocate message buffer of frame F.
2105 Note that the message buffer is never freed. Since I could not
2106 find a free in 19.34, I assume that freeing it would be
2107 problematic in some way and don't do it either.
2109 (Implementation note: It should be checked if we can free it
2110 eventually without causing trouble). */
2113 adjust_frame_message_buffer (f
)
2116 int size
= FRAME_MESSAGE_BUF_SIZE (f
) + 1;
2118 if (FRAME_MESSAGE_BUF (f
))
2120 char *buffer
= FRAME_MESSAGE_BUF (f
);
2121 char *new_buffer
= (char *) xrealloc (buffer
, size
);
2122 FRAME_MESSAGE_BUF (f
) = new_buffer
;
2125 FRAME_MESSAGE_BUF (f
) = (char *) xmalloc (size
);
2129 /* Re-allocate buffer for decode_mode_spec on frame F. */
2132 adjust_decode_mode_spec_buffer (f
)
2135 f
->decode_mode_spec_buffer
2136 = (char *) xrealloc (f
->decode_mode_spec_buffer
,
2137 FRAME_MESSAGE_BUF_SIZE (f
) + 1);
2142 /**********************************************************************
2143 Freeing Glyph Matrices
2144 **********************************************************************/
2146 /* Free glyph memory for a frame F. F may be null. This function can
2147 be called for the same frame more than once. The root window of
2148 F may be nil when this function is called. This is the case when
2149 the function is called when F is destroyed. */
2155 if (f
&& f
->glyphs_initialized_p
)
2157 f
->glyphs_initialized_p
= 0;
2159 /* Release window sub-matrices. */
2160 if (!NILP (f
->root_window
))
2161 free_window_matrices (XWINDOW (f
->root_window
));
2163 /* Free the dummy window for menu bars without X toolkit and its
2165 if (!NILP (f
->menu_bar_window
))
2167 struct window
*w
= XWINDOW (f
->menu_bar_window
);
2168 free_glyph_matrix (w
->desired_matrix
);
2169 free_glyph_matrix (w
->current_matrix
);
2170 w
->desired_matrix
= w
->current_matrix
= NULL
;
2171 f
->menu_bar_window
= Qnil
;
2174 /* Free the tool bar window and its glyph matrices. */
2175 if (!NILP (f
->tool_bar_window
))
2177 struct window
*w
= XWINDOW (f
->tool_bar_window
);
2178 free_glyph_matrix (w
->desired_matrix
);
2179 free_glyph_matrix (w
->current_matrix
);
2180 w
->desired_matrix
= w
->current_matrix
= NULL
;
2181 f
->tool_bar_window
= Qnil
;
2184 /* Release frame glyph matrices. Reset fields to zero in
2185 case we are called a second time. */
2186 if (f
->desired_matrix
)
2188 free_glyph_matrix (f
->desired_matrix
);
2189 free_glyph_matrix (f
->current_matrix
);
2190 f
->desired_matrix
= f
->current_matrix
= NULL
;
2193 /* Release glyph pools. */
2194 if (f
->desired_pool
)
2196 free_glyph_pool (f
->desired_pool
);
2197 free_glyph_pool (f
->current_pool
);
2198 f
->desired_pool
= f
->current_pool
= NULL
;
2204 /* Free glyph sub-matrices in the window tree rooted at W. This
2205 function may be called with a null pointer, and it may be called on
2206 the same tree more than once. */
2209 free_window_matrices (w
)
2214 if (!NILP (w
->hchild
))
2215 free_window_matrices (XWINDOW (w
->hchild
));
2216 else if (!NILP (w
->vchild
))
2217 free_window_matrices (XWINDOW (w
->vchild
));
2220 /* This is a leaf window. Free its memory and reset fields
2221 to zero in case this function is called a second time for
2223 free_glyph_matrix (w
->current_matrix
);
2224 free_glyph_matrix (w
->desired_matrix
);
2225 w
->current_matrix
= w
->desired_matrix
= NULL
;
2228 /* Next window on same level. */
2229 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2234 /* Check glyph memory leaks. This function is called from
2235 shut_down_emacs. Note that frames are not destroyed when Emacs
2236 exits. We therefore free all glyph memory for all active frames
2237 explicitly and check that nothing is left allocated. */
2240 check_glyph_memory ()
2242 Lisp_Object tail
, frame
;
2244 /* Free glyph memory for all frames. */
2245 FOR_EACH_FRAME (tail
, frame
)
2246 free_glyphs (XFRAME (frame
));
2248 /* Check that nothing is left allocated. */
2249 if (glyph_matrix_count
)
2251 if (glyph_pool_count
)
2257 /**********************************************************************
2258 Building a Frame Matrix
2259 **********************************************************************/
2261 /* Most of the redisplay code works on glyph matrices attached to
2262 windows. This is a good solution most of the time, but it is not
2263 suitable for terminal code. Terminal output functions cannot rely
2264 on being able to set an arbitrary terminal window. Instead they
2265 must be provided with a view of the whole frame, i.e. the whole
2266 screen. We build such a view by constructing a frame matrix from
2267 window matrices in this section.
2269 Windows that must be updated have their must_be_update_p flag set.
2270 For all such windows, their desired matrix is made part of the
2271 desired frame matrix. For other windows, their current matrix is
2272 made part of the desired frame matrix.
2274 +-----------------+----------------+
2275 | desired | desired |
2277 +-----------------+----------------+
2280 +----------------------------------+
2282 Desired window matrices can be made part of the frame matrix in a
2283 cheap way: We exploit the fact that the desired frame matrix and
2284 desired window matrices share their glyph memory. This is not
2285 possible for current window matrices. Their glyphs are copied to
2286 the desired frame matrix. The latter is equivalent to
2287 preserve_other_columns in the old redisplay.
2289 Used glyphs counters for frame matrix rows are the result of adding
2290 up glyph lengths of the window matrices. A line in the frame
2291 matrix is enabled, if a corresponding line in a window matrix is
2294 After building the desired frame matrix, it will be passed to
2295 terminal code, which will manipulate both the desired and current
2296 frame matrix. Changes applied to the frame's current matrix have
2297 to be visible in current window matrices afterwards, of course.
2299 This problem is solved like this:
2301 1. Window and frame matrices share glyphs. Window matrices are
2302 constructed in a way that their glyph contents ARE the glyph
2303 contents needed in a frame matrix. Thus, any modification of
2304 glyphs done in terminal code will be reflected in window matrices
2307 2. Exchanges of rows in a frame matrix done by terminal code are
2308 intercepted by hook functions so that corresponding row operations
2309 on window matrices can be performed. This is necessary because we
2310 use pointers to glyphs in glyph row structures. To satisfy the
2311 assumption of point 1 above that glyphs are updated implicitly in
2312 window matrices when they are manipulated via the frame matrix,
2313 window and frame matrix must of course agree where to find the
2314 glyphs for their rows. Possible manipulations that must be
2315 mirrored are assignments of rows of the desired frame matrix to the
2316 current frame matrix and scrolling the current frame matrix. */
2318 /* Build frame F's desired matrix from window matrices. Only windows
2319 which have the flag must_be_updated_p set have to be updated. Menu
2320 bar lines of a frame are not covered by window matrices, so make
2321 sure not to touch them in this function. */
2324 build_frame_matrix (f
)
2329 /* F must have a frame matrix when this function is called. */
2330 xassert (!FRAME_WINDOW_P (f
));
2332 /* Clear all rows in the frame matrix covered by window matrices.
2333 Menu bar lines are not covered by windows. */
2334 for (i
= FRAME_TOP_MARGIN (f
); i
< f
->desired_matrix
->nrows
; ++i
)
2335 clear_glyph_row (MATRIX_ROW (f
->desired_matrix
, i
));
2337 /* Build the matrix by walking the window tree. */
2338 build_frame_matrix_from_window_tree (f
->desired_matrix
,
2339 XWINDOW (FRAME_ROOT_WINDOW (f
)));
2343 /* Walk a window tree, building a frame matrix MATRIX from window
2344 matrices. W is the root of a window tree. */
2347 build_frame_matrix_from_window_tree (matrix
, w
)
2348 struct glyph_matrix
*matrix
;
2353 if (!NILP (w
->hchild
))
2354 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->hchild
));
2355 else if (!NILP (w
->vchild
))
2356 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->vchild
));
2358 build_frame_matrix_from_leaf_window (matrix
, w
);
2360 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2365 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2366 desired frame matrix built. W is a leaf window whose desired or
2367 current matrix is to be added to FRAME_MATRIX. W's flag
2368 must_be_updated_p determines which matrix it contributes to
2369 FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix
2370 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2371 Adding a desired matrix means setting up used counters and such in
2372 frame rows, while adding a current window matrix to FRAME_MATRIX
2373 means copying glyphs. The latter case corresponds to
2374 preserve_other_columns in the old redisplay. */
2377 build_frame_matrix_from_leaf_window (frame_matrix
, w
)
2378 struct glyph_matrix
*frame_matrix
;
2381 struct glyph_matrix
*window_matrix
;
2382 int window_y
, frame_y
;
2383 /* If non-zero, a glyph to insert at the right border of W. */
2384 GLYPH right_border_glyph
= 0;
2386 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2387 if (w
->must_be_updated_p
)
2389 window_matrix
= w
->desired_matrix
;
2391 /* Decide whether we want to add a vertical border glyph. */
2392 if (!WINDOW_RIGHTMOST_P (w
))
2394 struct Lisp_Char_Table
*dp
= window_display_table (w
);
2395 right_border_glyph
= (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
2396 ? XINT (DISP_BORDER_GLYPH (dp
))
2401 window_matrix
= w
->current_matrix
;
2403 /* For all rows in the window matrix and corresponding rows in the
2406 frame_y
= window_matrix
->matrix_y
;
2407 while (window_y
< window_matrix
->nrows
)
2409 struct glyph_row
*frame_row
= frame_matrix
->rows
+ frame_y
;
2410 struct glyph_row
*window_row
= window_matrix
->rows
+ window_y
;
2412 /* Fill up the frame row with spaces up to the left margin of the
2414 fill_up_frame_row_with_spaces (frame_row
, window_matrix
->matrix_x
);
2416 /* Fill up areas in the window matrix row with spaces. */
2417 fill_up_glyph_row_with_spaces (window_row
);
2419 if (window_matrix
== w
->current_matrix
)
2421 /* We have to copy W's current matrix. Copy window
2422 row to frame row. */
2423 bcopy (window_row
->glyphs
[0],
2424 frame_row
->glyphs
[TEXT_AREA
] + window_matrix
->matrix_x
,
2425 window_matrix
->matrix_w
* sizeof (struct glyph
));
2429 /* Copy W's desired matrix. */
2431 /* Maybe insert a vertical border between horizontally adjacent
2433 if (right_border_glyph
)
2435 struct glyph
*border
= window_row
->glyphs
[LAST_AREA
] - 1;
2436 SET_CHAR_GLYPH_FROM_GLYPH (*border
, right_border_glyph
);
2439 /* Due to hooks installed, it normally doesn't happen that
2440 window rows and frame rows of the same matrix are out of
2441 sync, i.e. have a different understanding of where to
2442 find glyphs for the row. The following is a safety-belt
2443 that doesn't cost much and makes absolutely sure that
2444 window and frame matrices are in sync. */
2445 if (!glyph_row_slice_p (window_row
, frame_row
))
2447 /* Find the row in the window being a slice. There
2448 should exist one from program logic. */
2449 struct glyph_row
*slice_row
2450 = find_glyph_row_slice (window_matrix
, frame_matrix
, frame_y
);
2451 xassert (slice_row
!= 0);
2453 /* Exchange glyphs between both window rows. */
2454 swap_glyphs_in_rows (window_row
, slice_row
);
2456 /* Exchange pointers between both rows. */
2457 swap_glyph_pointers (window_row
, slice_row
);
2460 /* Now, we are sure that window row window_y is a slice of
2461 the frame row frame_y. But, lets check that assumption. */
2462 xassert (glyph_row_slice_p (window_row
, frame_row
));
2464 /* If rows are in sync, we don't have to copy glyphs because
2465 frame and window share glyphs. */
2468 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
2472 /* Set number of used glyphs in the frame matrix. Since we fill
2473 up with spaces, and visit leaf windows from left to right it
2474 can be done simply. */
2475 frame_row
->used
[TEXT_AREA
]
2476 = window_matrix
->matrix_x
+ window_matrix
->matrix_w
;
2479 frame_row
->enabled_p
|= window_row
->enabled_p
;
2480 frame_row
->inverse_p
|= window_row
->inverse_p
;
2489 /* Add spaces to a glyph row ROW in a window matrix.
2491 Each row has the form:
2493 +---------+-----------------------------+------------+
2494 | left | text | right |
2495 +---------+-----------------------------+------------+
2497 Left and right marginal areas are optional. This function adds
2498 spaces to areas so that there are no empty holes between areas.
2499 In other words: If the right area is not empty, the text area
2500 is filled up with spaces up to the right area. If the text area
2501 is not empty, the left area is filled up.
2503 To be called for frame-based redisplay, only. */
2506 fill_up_glyph_row_with_spaces (row
)
2507 struct glyph_row
*row
;
2509 fill_up_glyph_row_area_with_spaces (row
, LEFT_MARGIN_AREA
);
2510 fill_up_glyph_row_area_with_spaces (row
, TEXT_AREA
);
2511 fill_up_glyph_row_area_with_spaces (row
, RIGHT_MARGIN_AREA
);
2515 /* Fill area AREA of glyph row ROW with spaces. To be called for
2516 frame-based redisplay only. */
2519 fill_up_glyph_row_area_with_spaces (row
, area
)
2520 struct glyph_row
*row
;
2523 if (row
->glyphs
[area
] < row
->glyphs
[area
+ 1])
2525 struct glyph
*end
= row
->glyphs
[area
+ 1];
2526 struct glyph
*text
= row
->glyphs
[area
] + row
->used
[area
];
2529 *text
++ = space_glyph
;
2530 row
->used
[area
] = text
- row
->glyphs
[area
];
2535 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2536 reached. In frame matrices only one area, TEXT_AREA, is used. */
2539 fill_up_frame_row_with_spaces (row
, upto
)
2540 struct glyph_row
*row
;
2543 int i
= row
->used
[TEXT_AREA
];
2544 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
2547 glyph
[i
++] = space_glyph
;
2549 row
->used
[TEXT_AREA
] = i
;
2554 /**********************************************************************
2555 Mirroring operations on frame matrices in window matrices
2556 **********************************************************************/
2558 /* Set frame being updated via frame-based redisplay to F. This
2559 function must be called before updates to make explicit that we are
2560 working on frame matrices or not. */
2563 set_frame_matrix_frame (f
)
2566 frame_matrix_frame
= f
;
2570 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2571 DESIRED_MATRIX is the desired matrix corresponding to
2572 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2573 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2574 frame_matrix_frame is non-null, this indicates that the exchange is
2575 done in frame matrices, and that we have to perform analogous
2576 operations in window matrices of frame_matrix_frame. */
2579 make_current (desired_matrix
, current_matrix
, row
)
2580 struct glyph_matrix
*desired_matrix
, *current_matrix
;
2583 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, row
);
2584 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, row
);
2586 /* Do current_row = desired_row. This exchanges glyph pointers
2587 between both rows, and does a structure assignment otherwise. */
2588 assign_row (current_row
, desired_row
);
2590 /* Enable current_row to mark it as valid. */
2591 current_row
->enabled_p
= 1;
2593 /* If we are called on frame matrices, perform analogous operations
2594 for window matrices. */
2595 if (frame_matrix_frame
)
2596 mirror_make_current (XWINDOW (frame_matrix_frame
->root_window
), row
);
2600 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2601 W's frame which has been made current (by swapping pointers between
2602 current and desired matrix). Perform analogous operations in the
2603 matrices of leaf windows in the window tree rooted at W. */
2606 mirror_make_current (w
, frame_row
)
2612 if (!NILP (w
->hchild
))
2613 mirror_make_current (XWINDOW (w
->hchild
), frame_row
);
2614 else if (!NILP (w
->vchild
))
2615 mirror_make_current (XWINDOW (w
->vchild
), frame_row
);
2618 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2619 here because the checks performed in debug mode there
2620 will not allow the conversion. */
2621 int row
= frame_row
- w
->desired_matrix
->matrix_y
;
2623 /* If FRAME_ROW is within W, assign the desired row to the
2624 current row (exchanging glyph pointers). */
2625 if (row
>= 0 && row
< w
->desired_matrix
->matrix_h
)
2627 struct glyph_row
*current_row
2628 = MATRIX_ROW (w
->current_matrix
, row
);
2629 struct glyph_row
*desired_row
2630 = MATRIX_ROW (w
->desired_matrix
, row
);
2632 if (desired_row
->enabled_p
)
2633 assign_row (current_row
, desired_row
);
2635 swap_glyph_pointers (desired_row
, current_row
);
2636 current_row
->enabled_p
= 1;
2640 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2645 /* Perform row dance after scrolling. We are working on the range of
2646 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2647 including) in MATRIX. COPY_FROM is a vector containing, for each
2648 row I in the range 0 <= I < NLINES, the index of the original line
2649 to move to I. This index is relative to the row range, i.e. 0 <=
2650 index < NLINES. RETAINED_P is a vector containing zero for each
2651 row 0 <= I < NLINES which is empty.
2653 This function is called from do_scrolling and do_direct_scrolling. */
2656 mirrored_line_dance (matrix
, unchanged_at_top
, nlines
, copy_from
,
2658 struct glyph_matrix
*matrix
;
2659 int unchanged_at_top
, nlines
;
2663 /* A copy of original rows. */
2664 struct glyph_row
*old_rows
;
2666 /* Rows to assign to. */
2667 struct glyph_row
*new_rows
= MATRIX_ROW (matrix
, unchanged_at_top
);
2671 /* Make a copy of the original rows. */
2672 old_rows
= (struct glyph_row
*) alloca (nlines
* sizeof *old_rows
);
2673 bcopy (new_rows
, old_rows
, nlines
* sizeof *old_rows
);
2675 /* Assign new rows, maybe clear lines. */
2676 for (i
= 0; i
< nlines
; ++i
)
2678 int enabled_before_p
= new_rows
[i
].enabled_p
;
2680 xassert (i
+ unchanged_at_top
< matrix
->nrows
);
2681 xassert (unchanged_at_top
+ copy_from
[i
] < matrix
->nrows
);
2682 new_rows
[i
] = old_rows
[copy_from
[i
]];
2683 new_rows
[i
].enabled_p
= enabled_before_p
;
2685 /* RETAINED_P is zero for empty lines. */
2686 if (!retained_p
[copy_from
[i
]])
2687 new_rows
[i
].enabled_p
= 0;
2690 /* Do the same for window matrices, if MATRIX Is a frame matrix. */
2691 if (frame_matrix_frame
)
2692 mirror_line_dance (XWINDOW (frame_matrix_frame
->root_window
),
2693 unchanged_at_top
, nlines
, copy_from
, retained_p
);
2697 /* Perform a line dance in the window tree rooted at W, after
2698 scrolling a frame matrix in mirrored_line_dance.
2700 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
2701 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
2702 COPY_FROM is a vector containing, for each row I in the range 0 <=
2703 I < NLINES, the index of the original line to move to I. This
2704 index is relative to the row range, i.e. 0 <= index < NLINES.
2705 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
2709 mirror_line_dance (w
, unchanged_at_top
, nlines
, copy_from
, retained_p
)
2711 int unchanged_at_top
, nlines
;
2717 if (!NILP (w
->hchild
))
2718 mirror_line_dance (XWINDOW (w
->hchild
), unchanged_at_top
,
2719 nlines
, copy_from
, retained_p
);
2720 else if (!NILP (w
->vchild
))
2721 mirror_line_dance (XWINDOW (w
->vchild
), unchanged_at_top
,
2722 nlines
, copy_from
, retained_p
);
2725 /* W is a leaf window, and we are working on its current
2727 struct glyph_matrix
*m
= w
->current_matrix
;
2731 struct glyph_row
*old_rows
;
2733 /* Make a copy of the original rows of matrix m. */
2734 old_rows
= (struct glyph_row
*) alloca (m
->nrows
* sizeof *old_rows
);
2735 bcopy (m
->rows
, old_rows
, m
->nrows
* sizeof *old_rows
);
2737 for (i
= 0; i
< nlines
; ++i
)
2739 /* Frame relative line assigned to. */
2740 int frame_to
= i
+ unchanged_at_top
;
2742 /* Frame relative line assigned. */
2743 int frame_from
= copy_from
[i
] + unchanged_at_top
;
2745 /* Window relative line assigned to. */
2746 int window_to
= frame_to
- m
->matrix_y
;
2748 /* Window relative line assigned. */
2749 int window_from
= frame_from
- m
->matrix_y
;
2751 /* Is assigned line inside window? */
2752 int from_inside_window_p
2753 = window_from
>= 0 && window_from
< m
->matrix_h
;
2755 if (from_inside_window_p
)
2758 /* Is assigned to line inside window? */
2759 int to_inside_window_p
2760 = window_to
>= 0 && window_to
< m
->matrix_h
;
2763 /* Enabled setting before assignment. */
2764 int enabled_before_p
;
2766 /* If not both lines inside the window, we have a
2768 xassert (to_inside_window_p
);
2770 /* Do the assignment. The enabled_p flag is saved
2771 over the assignment because the old redisplay did
2773 enabled_before_p
= m
->rows
[window_to
].enabled_p
;
2774 m
->rows
[window_to
] = old_rows
[window_from
];
2775 m
->rows
[window_to
].enabled_p
= enabled_before_p
;
2777 /* If frame line is empty, window line is empty, too. */
2778 if (!retained_p
[copy_from
[i
]])
2779 m
->rows
[window_to
].enabled_p
= 0;
2783 /* Check that no pointers are lost. */
2787 /* Next window on same level. */
2788 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2795 /* Check that window and frame matrices agree about their
2796 understanding where glyphs of the rows are to find. For each
2797 window in the window tree rooted at W, check that rows in the
2798 matrices of leaf window agree with their frame matrices about
2802 check_window_matrix_pointers (w
)
2807 if (!NILP (w
->hchild
))
2808 check_window_matrix_pointers (XWINDOW (w
->hchild
));
2809 else if (!NILP (w
->vchild
))
2810 check_window_matrix_pointers (XWINDOW (w
->vchild
));
2813 struct frame
*f
= XFRAME (w
->frame
);
2814 check_matrix_pointers (w
->desired_matrix
, f
->desired_matrix
);
2815 check_matrix_pointers (w
->current_matrix
, f
->current_matrix
);
2818 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2823 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
2824 a window and FRAME_MATRIX is the corresponding frame matrix. For
2825 each row in WINDOW_MATRIX check that it's a slice of the
2826 corresponding frame row. If it isn't, abort. */
2829 check_matrix_pointers (window_matrix
, frame_matrix
)
2830 struct glyph_matrix
*window_matrix
, *frame_matrix
;
2832 /* Row number in WINDOW_MATRIX. */
2835 /* Row number corresponding to I in FRAME_MATRIX. */
2836 int j
= window_matrix
->matrix_y
;
2838 /* For all rows check that the row in the window matrix is a
2839 slice of the row in the frame matrix. If it isn't we didn't
2840 mirror an operation on the frame matrix correctly. */
2841 while (i
< window_matrix
->nrows
)
2843 if (!glyph_row_slice_p (window_matrix
->rows
+ i
,
2844 frame_matrix
->rows
+ j
))
2850 #endif /* GLYPH_DEBUG != 0 */
2854 /**********************************************************************
2855 VPOS and HPOS translations
2856 **********************************************************************/
2860 /* Translate vertical position VPOS which is relative to window W to a
2861 vertical position relative to W's frame. */
2864 window_to_frame_vpos (w
, vpos
)
2868 struct frame
*f
= XFRAME (w
->frame
);
2870 xassert (!FRAME_WINDOW_P (f
));
2871 xassert (vpos
>= 0 && vpos
<= w
->desired_matrix
->nrows
);
2872 vpos
+= XFASTINT (w
->top
);
2873 xassert (vpos
>= 0 && vpos
<= FRAME_HEIGHT (f
));
2878 /* Translate horizontal position HPOS which is relative to window W to
2879 a vertical position relative to W's frame. */
2882 window_to_frame_hpos (w
, hpos
)
2886 struct frame
*f
= XFRAME (w
->frame
);
2888 xassert (!FRAME_WINDOW_P (f
));
2889 hpos
+= XFASTINT (w
->left
);
2893 #endif /* GLYPH_DEBUG */
2897 /**********************************************************************
2899 **********************************************************************/
2901 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
2902 "Clear frame FRAME and output again what is supposed to appear on it.")
2908 CHECK_LIVE_FRAME (frame
, 0);
2911 /* Ignore redraw requests, if frame has no glyphs yet.
2912 (Implementation note: It still has to be checked why we are
2913 called so early here). */
2914 if (!glyphs_initialized_initially_p
)
2918 if (FRAME_MSDOS_P (f
))
2919 set_terminal_modes ();
2921 clear_current_matrices (f
);
2924 windows_or_buffers_changed
++;
2925 /* Mark all windows as inaccurate, so that every window will have
2926 its redisplay done. */
2927 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
2928 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
2934 /* Redraw frame F. This is nothing more than a call to the Lisp
2935 function redraw-frame. */
2942 XSETFRAME (frame
, f
);
2943 Fredraw_frame (frame
);
2947 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
2948 "Clear and redisplay all visible frames.")
2951 Lisp_Object tail
, frame
;
2953 FOR_EACH_FRAME (tail
, frame
)
2954 if (FRAME_VISIBLE_P (XFRAME (frame
)))
2955 Fredraw_frame (frame
);
2961 /* This is used when frame_garbaged is set. Call Fredraw_frame on all
2962 visible frames marked as garbaged. */
2965 redraw_garbaged_frames ()
2967 Lisp_Object tail
, frame
;
2969 FOR_EACH_FRAME (tail
, frame
)
2970 if (FRAME_VISIBLE_P (XFRAME (frame
))
2971 && FRAME_GARBAGED_P (XFRAME (frame
)))
2972 Fredraw_frame (frame
);
2977 /***********************************************************************
2979 ***********************************************************************/
2981 /* Try to update display and current glyph matrix directly.
2983 This function is called after a character G has been inserted into
2984 current_buffer. It tries to update the current glyph matrix and
2985 perform appropriate screen output to reflect the insertion. If it
2986 succeeds, the global flag redisplay_performed_directly_p will be
2987 set to 1, and thereby prevent the more costly general redisplay
2988 from running (see redisplay_internal).
2990 This function is not called for `hairy' character insertions.
2991 In particular, it is not called when after or before change
2992 functions exist, like they are used by font-lock. See keyboard.c
2993 for details where this function is called. */
2996 direct_output_for_insert (g
)
2999 register struct frame
*f
= SELECTED_FRAME ();
3000 struct window
*w
= XWINDOW (selected_window
);
3002 struct glyph_row
*glyph_row
;
3003 struct glyph
*glyphs
, *glyph
, *end
;
3005 /* Non-null means that Redisplay of W is based on window matrices. */
3006 int window_redisplay_p
= FRAME_WINDOW_P (f
);
3007 /* Non-null means we are in overwrite mode. */
3008 int overwrite_p
= !NILP (current_buffer
->overwrite_mode
);
3010 struct text_pos pos
;
3011 int delta
, delta_bytes
;
3013 /* Not done directly. */
3014 redisplay_performed_directly_p
= 0;
3016 /* Quickly give up for some common cases. */
3017 if (cursor_in_echo_area
3018 /* Give up if fonts have changed. */
3020 /* Give up if face attributes have been changed. */
3021 || face_change_count
3022 /* Give up if cursor position not really known. */
3023 || !display_completed
3024 /* Give up if buffer appears in two places. */
3025 || buffer_shared
> 1
3026 /* Give up if w is mini-buffer and a message is being displayed there */
3027 || (MINI_WINDOW_P (w
) && !NILP (echo_area_buffer
[0]))
3028 /* Give up for hscrolled mini-buffer because display of the prompt
3029 is handled specially there (see display_line). */
3030 || (MINI_WINDOW_P (w
) && XFASTINT (w
->hscroll
))
3031 /* Give up if overwriting in the middle of a line. */
3034 && FETCH_BYTE (PT
) != '\n')
3035 /* Give up for tabs and line ends. */
3039 /* Give up if unable to display the cursor in the window. */
3040 || w
->cursor
.vpos
< 0
3041 || (glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
),
3042 /* Can't do it in a continued line because continuation
3043 lines would change. */
3044 (glyph_row
->continued_p
3045 /* Can't use this method if the line overlaps others or is
3046 overlapped by others because these other lines would
3047 have to be redisplayed. */
3048 || glyph_row
->overlapping_p
3049 || glyph_row
->overlapped_p
))
3050 /* Can't do it for partial width windows on terminal frames
3051 because we can't clear to eol in such a window. */
3052 || (!window_redisplay_p
&& !WINDOW_FULL_WIDTH_P (w
)))
3055 /* Set up a display iterator structure for W. Glyphs will be
3056 produced in scratch_glyph_row. Current position is W's cursor
3058 clear_glyph_row (&scratch_glyph_row
);
3059 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
3061 init_iterator (&it
, w
, CHARPOS (pos
), BYTEPOS (pos
), &scratch_glyph_row
,
3064 glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3066 /* Give up if highlighting trailing whitespace and we have trailing
3067 whitespace in glyph_row. We would have to remove the trailing
3068 whitespace face in that case. */
3069 if (!NILP (Vshow_trailing_whitespace
)
3070 && glyph_row
->used
[TEXT_AREA
])
3074 last
= glyph_row
->glyphs
[TEXT_AREA
] + glyph_row
->used
[TEXT_AREA
] - 1;
3075 if (last
->type
== STRETCH_GLYPH
3076 || (last
->type
== CHAR_GLYPH
3077 && last
->u
.ch
.code
== ' '))
3081 /* Give up if there are overlay strings at pos. This would fail
3082 if the overlay string has newlines in it. */
3083 if (STRINGP (it
.string
))
3086 it
.hpos
= w
->cursor
.hpos
;
3087 it
.vpos
= w
->cursor
.vpos
;
3088 it
.current_x
= w
->cursor
.x
+ it
.first_visible_x
;
3089 it
.current_y
= w
->cursor
.y
;
3090 it
.end_charpos
= PT
;
3091 it
.stop_charpos
= min (PT
, it
.stop_charpos
);
3093 /* More than one display element may be returned for PT - 1 if
3094 (i) it's a control character which is translated into `\003' or
3095 `^C', or (ii) it has a display table entry, or (iii) it's a
3096 combination of both. */
3097 delta
= delta_bytes
= 0;
3098 while (get_next_display_element (&it
))
3100 PRODUCE_GLYPHS (&it
);
3102 /* Give up if glyph doesn't fit completely on the line. */
3103 if (it
.current_x
>= it
.last_visible_x
)
3106 /* Give up if new glyph has different ascent or descent than
3107 the original row, or if it is not a character glyph. */
3108 if (glyph_row
->ascent
!= it
.ascent
3109 || glyph_row
->height
!= it
.ascent
+ it
.descent
3110 || glyph_row
->phys_ascent
!= it
.phys_ascent
3111 || glyph_row
->phys_height
!= it
.phys_ascent
+ it
.phys_descent
3112 || it
.what
!= IT_CHARACTER
)
3116 delta_bytes
+= it
.len
;
3117 set_iterator_to_next (&it
);
3120 /* Give up if we hit the right edge of the window. We would have
3121 to insert truncation or continuation glyphs. */
3122 added_width
= it
.current_x
- (w
->cursor
.x
+ it
.first_visible_x
);
3123 if (glyph_row
->pixel_width
+ added_width
>= it
.last_visible_x
)
3126 /* Give up if there is a \t following in the line. */
3128 it2
.end_charpos
= ZV
;
3129 it2
.stop_charpos
= min (it2
.stop_charpos
, ZV
);
3130 while (get_next_display_element (&it2
)
3131 && !ITERATOR_AT_END_OF_LINE_P (&it2
))
3135 set_iterator_to_next (&it2
);
3138 /* Number of new glyphs produced. */
3139 n
= it
.glyph_row
->used
[TEXT_AREA
];
3141 /* Start and end of glyphs in original row. */
3142 glyphs
= glyph_row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
3143 end
= glyph_row
->glyphs
[1 + TEXT_AREA
];
3145 /* Make room for new glyphs, then insert them. */
3146 xassert (end
- glyphs
- n
>= 0);
3147 safe_bcopy ((char *) glyphs
, (char *) (glyphs
+ n
),
3148 (end
- glyphs
- n
) * sizeof (*end
));
3149 bcopy (it
.glyph_row
->glyphs
[TEXT_AREA
], glyphs
, n
* sizeof *glyphs
);
3150 glyph_row
->used
[TEXT_AREA
] = min (glyph_row
->used
[TEXT_AREA
] + n
,
3151 end
- glyph_row
->glyphs
[TEXT_AREA
]);
3153 /* Compute new line width. */
3154 glyph
= glyph_row
->glyphs
[TEXT_AREA
];
3155 end
= glyph
+ glyph_row
->used
[TEXT_AREA
];
3156 glyph_row
->pixel_width
= glyph_row
->x
;
3159 glyph_row
->pixel_width
+= glyph
->pixel_width
;
3163 /* Increment buffer positions for glyphs following the newly
3165 for (glyph
= glyphs
+ n
; glyph
< end
; ++glyph
)
3166 if (glyph
->charpos
> 0 && BUFFERP (glyph
->object
))
3167 glyph
->charpos
+= delta
;
3169 if (MATRIX_ROW_END_CHARPOS (glyph_row
) > 0)
3171 MATRIX_ROW_END_CHARPOS (glyph_row
) += delta
;
3172 MATRIX_ROW_END_BYTEPOS (glyph_row
) += delta_bytes
;
3175 /* Adjust positions in lines following the one we are in. */
3176 increment_glyph_matrix_buffer_positions (w
->current_matrix
,
3178 w
->current_matrix
->nrows
,
3179 delta
, delta_bytes
);
3181 glyph_row
->contains_overlapping_glyphs_p
3182 |= it
.glyph_row
->contains_overlapping_glyphs_p
;
3184 glyph_row
->displays_text_p
= 1;
3185 w
->window_end_vpos
= make_number (max (w
->cursor
.vpos
,
3186 XFASTINT (w
->window_end_vpos
)));
3188 if (!NILP (Vshow_trailing_whitespace
))
3189 highlight_trailing_whitespace (it
.f
, glyph_row
);
3191 /* Write glyphs. If at end of row, we can simply call write_glyphs.
3192 In the middle, we have to insert glyphs. Note that this is now
3193 implemented for X frames. The implementation uses updated_window
3195 updated_row
= glyph_row
;
3199 rif
->update_window_begin_hook (w
);
3201 if (glyphs
== end
- n
)
3202 rif
->write_glyphs (glyphs
, n
);
3204 rif
->insert_glyphs (glyphs
, n
);
3208 if (glyphs
== end
- n
)
3209 write_glyphs (glyphs
, n
);
3211 insert_glyphs (glyphs
, n
);
3214 w
->cursor
.hpos
+= n
;
3215 w
->cursor
.x
= it
.current_x
- it
.first_visible_x
;
3216 xassert (w
->cursor
.hpos
>= 0
3217 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3219 /* How to set the cursor differs depending on whether we are
3220 using a frame matrix or a window matrix. Note that when
3221 a frame matrix is used, cursor_to expects frame coordinates,
3222 and the X and Y parameters are not used. */
3223 if (window_redisplay_p
)
3224 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3225 w
->cursor
.y
, w
->cursor
.x
);
3229 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3230 + (INTEGERP (w
->left_margin_width
)
3231 ? XFASTINT (w
->left_margin_width
)
3233 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3238 rif
->update_window_end_hook (w
, 1);
3243 TRACE ((stderr
, "direct output for insert\n"));
3245 UNCHANGED_MODIFIED
= MODIFF
;
3246 BEG_UNCHANGED
= GPT
- BEG
;
3247 XSETFASTINT (w
->last_point
, PT
);
3248 w
->last_cursor
= w
->cursor
;
3249 XSETFASTINT (w
->last_modified
, MODIFF
);
3250 XSETFASTINT (w
->last_overlay_modified
, OVERLAY_MODIFF
);
3252 redisplay_performed_directly_p
= 1;
3257 /* Perform a direct display update for moving PT by N positions
3258 left or right. N < 0 means a movement backwards. This function
3259 is currently only called for N == 1 or N == -1. */
3262 direct_output_forward_char (n
)
3265 struct frame
*f
= SELECTED_FRAME ();
3266 struct window
*w
= XWINDOW (selected_window
);
3267 struct glyph_row
*row
;
3269 /* Give up if point moved out of or into a composition. */
3270 if (check_point_in_composition (current_buffer
, w
->last_point
,
3271 current_buffer
, PT
))
3274 /* Give up if face attributes have been changed. */
3275 if (face_change_count
)
3278 /* Give up if current matrix is not up to date or we are
3279 displaying a message. */
3280 if (!display_completed
|| cursor_in_echo_area
)
3283 /* Give up if the buffer's direction is reversed. */
3284 if (!NILP (XBUFFER (w
->buffer
)->direction_reversed
))
3287 /* Can't use direct output if highlighting a region. */
3288 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
3291 /* Can't use direct output if highlighting trailing whitespace. */
3292 if (!NILP (Vshow_trailing_whitespace
))
3295 /* Give up if we are showing a message or just cleared the message
3296 because we might need to resize the echo area window. */
3297 if (!NILP (echo_area_buffer
[0]) || !NILP (echo_area_buffer
[1]))
3300 /* Give up if we don't know where the cursor is. */
3301 if (w
->cursor
.vpos
< 0)
3304 row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3306 if (PT
<= MATRIX_ROW_START_BYTEPOS (row
)
3307 || PT
>= MATRIX_ROW_END_BYTEPOS (row
))
3310 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
3311 w
->last_cursor
= w
->cursor
;
3312 XSETFASTINT (w
->last_point
, PT
);
3314 xassert (w
->cursor
.hpos
>= 0
3315 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3317 if (FRAME_WINDOW_P (f
))
3318 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3319 w
->cursor
.y
, w
->cursor
.x
);
3323 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3324 + (INTEGERP (w
->left_margin_width
)
3325 ? XFASTINT (w
->left_margin_width
)
3327 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3332 redisplay_performed_directly_p
= 1;
3338 /***********************************************************************
3340 ***********************************************************************/
3342 /* Update frame F based on the data in desired matrices.
3344 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3345 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3348 Value is non-zero if redisplay was stopped due to pending input. */
3351 update_frame (f
, force_p
, inhibit_hairy_id_p
)
3354 int inhibit_hairy_id_p
;
3356 /* 1 means display has been paused because of pending input. */
3358 struct window
*root_window
= XWINDOW (f
->root_window
);
3360 if (FRAME_WINDOW_P (f
))
3362 /* We are working on window matrix basis. All windows whose
3363 flag must_be_updated_p is set have to be updated. */
3365 /* Record that we are not working on frame matrices. */
3366 set_frame_matrix_frame (NULL
);
3368 /* Update all windows in the window tree of F, maybe stopping
3369 when pending input is detected. */
3372 /* Update the menu bar on X frames that don't have toolkit
3374 if (WINDOWP (f
->menu_bar_window
))
3375 update_window (XWINDOW (f
->menu_bar_window
), 1);
3377 /* Update the tool-bar window, if present. */
3378 if (WINDOWP (f
->tool_bar_window
))
3381 struct window
*w
= XWINDOW (f
->tool_bar_window
);
3383 /* Update tool-bar window. */
3384 if (w
->must_be_updated_p
)
3386 update_window (w
, 1);
3387 w
->must_be_updated_p
= 0;
3389 /* Swap tool-bar strings. We swap because we want to
3391 tem
= f
->current_tool_bar_string
;
3392 f
->current_tool_bar_string
= f
->desired_tool_bar_string
;
3393 f
->desired_tool_bar_string
= tem
;
3394 f
->n_current_tool_bar_items
= f
->n_desired_tool_bar_items
;
3396 /* Swap tool-bar items. We swap because we want to
3398 tem
= f
->current_tool_bar_items
;
3399 f
->current_tool_bar_items
= f
->desired_tool_bar_items
;
3400 f
->desired_tool_bar_items
= tem
;
3405 /* Update windows. */
3406 paused_p
= update_window_tree (root_window
, force_p
);
3408 display_completed
= !paused_p
;
3410 /* The flush is a performance bottleneck under X. */
3412 rif
->flush_display (f
);
3417 /* We are working on frame matrix basis. Set the frame on whose
3418 frame matrix we operate. */
3419 set_frame_matrix_frame (f
);
3421 /* Build F's desired matrix from window matrices. For windows
3422 whose must_be_updated_p flag is set, desired matrices are
3423 made part of the desired frame matrix. For other windows,
3424 the current matrix is copied. */
3425 build_frame_matrix (f
);
3427 /* Do the update on the frame desired matrix. */
3428 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3430 /* Check window matrices for lost pointers. */
3431 IF_DEBUG (check_window_matrix_pointers (root_window
));
3434 /* Reset flags indicating that a window should be updated. */
3435 set_window_update_flags (root_window
, 0);
3441 /************************************************************************
3442 Window-based updates
3443 ************************************************************************/
3445 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3446 don't stop updating when input is pending. */
3449 update_window_tree (w
, force_p
)
3455 while (w
&& !paused_p
)
3457 if (!NILP (w
->hchild
))
3458 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
3459 else if (!NILP (w
->vchild
))
3460 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
3461 else if (w
->must_be_updated_p
)
3462 paused_p
|= update_window (w
, force_p
);
3464 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3471 /* Update window W if its flag must_be_updated_p is non-zero. If
3472 FORCE_P is non-zero, don't stop updating if input is pending. */
3475 update_single_window (w
, force_p
)
3479 if (w
->must_be_updated_p
)
3481 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3483 /* Record that this is not a frame-based redisplay. */
3484 set_frame_matrix_frame (NULL
);
3488 update_window (w
, force_p
);
3491 /* Reset flag in W. */
3492 w
->must_be_updated_p
= 0;
3497 /* Redraw lines from the current matrix of window W that are
3498 overlapped by other rows. YB is bottom-most y-position in W. */
3501 redraw_overlapped_rows (w
, yb
)
3506 struct glyph_row
*row
;
3508 /* If rows overlapping others have been changed, the rows being
3509 overlapped have to be redrawn. This won't draw lines that have
3510 already been drawn in update_window_line because overlapped_p in
3511 desired rows is 0, so after row assignment overlapped_p in
3512 current rows is 0. */
3513 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3515 row
= w
->current_matrix
->rows
+ i
;
3517 if (!row
->enabled_p
)
3519 else if (row
->mode_line_p
)
3522 if (row
->overlapped_p
)
3524 enum glyph_row_area area
;
3526 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3529 updated_area
= area
;
3530 rif
->cursor_to (i
, 0, row
->y
, area
== TEXT_AREA
? row
->x
: 0);
3531 if (row
->used
[area
])
3532 rif
->write_glyphs (row
->glyphs
[area
], row
->used
[area
]);
3533 rif
->clear_end_of_line (-1);
3536 row
->overlapped_p
= 0;
3539 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3546 /* Redraw lines from the current matrix of window W that overlap
3547 others. YB is bottom-most y-position in W. */
3550 redraw_overlapping_rows (w
, yb
)
3555 struct glyph_row
*row
;
3557 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3559 row
= w
->current_matrix
->rows
+ i
;
3561 if (!row
->enabled_p
)
3563 else if (row
->mode_line_p
)
3566 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3568 if (row
->overlapping_p
&& i
> 0 && bottom_y
< yb
)
3570 if (row
->used
[LEFT_MARGIN_AREA
])
3571 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
);
3573 if (row
->used
[TEXT_AREA
])
3574 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
);
3576 if (row
->used
[RIGHT_MARGIN_AREA
])
3577 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
);
3579 /* Record in neighbor rows that ROW overwrites part of their
3581 if (row
->phys_ascent
> row
->ascent
&& i
> 0)
3582 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3583 if ((row
->phys_height
- row
->phys_ascent
3584 > row
->height
- row
->ascent
)
3586 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
3595 /* Update display of window W. FORCE_P non-zero means that we should
3596 not stop when detecting pending input. */
3599 update_window (w
, force_p
)
3603 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
3605 int preempt_count
= baud_rate
/ 2400 + 1;
3606 extern int input_pending
;
3608 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3609 extern struct frame
*updating_frame
;
3612 /* Check that W's frame doesn't have glyph matrices. */
3613 xassert (FRAME_WINDOW_P (f
));
3614 xassert (updating_frame
!= NULL
);
3616 /* Check pending input the first time so that we can quickly return. */
3617 if (redisplay_dont_pause
)
3620 detect_input_pending ();
3622 /* If forced to complete the update, or if no input is pending, do
3624 if (force_p
|| !input_pending
)
3626 struct glyph_row
*row
, *end
;
3627 struct glyph_row
*mode_line_row
;
3628 struct glyph_row
*header_line_row
= NULL
;
3629 int yb
, changed_p
= 0;
3631 rif
->update_window_begin_hook (w
);
3632 yb
= window_text_bottom_y (w
);
3634 /* If window has a top line, update it before everything else.
3635 Adjust y-positions of other rows by the top line height. */
3636 row
= desired_matrix
->rows
;
3637 end
= row
+ desired_matrix
->nrows
- 1;
3638 if (row
->mode_line_p
)
3639 header_line_row
= row
++;
3641 /* Update the mode line, if necessary. */
3642 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3643 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
3645 mode_line_row
->y
= yb
;
3646 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
3651 /* Find first enabled row. Optimizations in redisplay_internal
3652 may lead to an update with only one row enabled. There may
3653 be also completely empty matrices. */
3654 while (row
< end
&& !row
->enabled_p
)
3657 /* Try reusing part of the display by inserting/deleting lines. */
3658 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
3660 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
3663 /* All rows were found to be equal. */
3672 /* Update the top mode line after scrolling because a new top
3673 line would otherwise overwrite lines at the top of the window
3674 that can be scrolled. */
3675 if (header_line_row
&& header_line_row
->enabled_p
)
3677 header_line_row
->y
= 0;
3678 update_window_line (w
, 0);
3682 /* Update the rest of the lines. */
3683 for (; row
< end
&& (force_p
|| !input_pending
); ++row
)
3685 /* A row can be completely invisible in case a desired
3686 matrix was built with a vscroll and then
3687 make_cursor_line_fully_visible shifts the matrix. */
3688 && row
->visible_height
> 0)
3690 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
3693 /* We'll Have to play a little bit with when to
3694 detect_input_pending. If it's done too often,
3695 scrolling large windows with repeated scroll-up
3696 commands will too quickly pause redisplay. */
3697 if (!force_p
&& vpos
% preempt_count
== 0)
3698 detect_input_pending ();
3700 changed_p
|= update_window_line (w
, vpos
);
3702 /* Mark all rows below the last visible one in the current
3703 matrix as invalid. This is necessary because of
3704 variable line heights. Consider the case of three
3705 successive redisplays, where the first displays 5
3706 lines, the second 3 lines, and the third 5 lines again.
3707 If the second redisplay wouldn't mark rows in the
3708 current matrix invalid, the third redisplay might be
3709 tempted to optimize redisplay based on lines displayed
3710 in the first redisplay. */
3711 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3712 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
3713 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
3716 /* Was display preempted? */
3717 paused_p
= row
< end
;
3721 /* Fix the appearance of overlapping(overlapped rows. */
3722 if (rif
->fix_overlapping_area
3723 && !w
->pseudo_window_p
3727 redraw_overlapped_rows (w
, yb
);
3728 redraw_overlapping_rows (w
, yb
);
3731 if (!paused_p
&& !w
->pseudo_window_p
)
3733 /* Make cursor visible at cursor position of W. */
3734 set_window_cursor_after_update (w
);
3737 /* Check that current matrix invariants are satisfied. This
3738 is for debugging only. See the comment around
3739 check_matrix_invariants. */
3740 IF_DEBUG (check_matrix_invariants (w
));
3745 /* Remember the redisplay method used to display the matrix. */
3746 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
3749 /* End of update of window W. */
3750 rif
->update_window_end_hook (w
, 1);
3756 clear_glyph_matrix (desired_matrix
);
3762 /* Update the display of area AREA in window W, row number VPOS.
3763 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3766 update_marginal_area (w
, area
, vpos
)
3770 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3772 /* Let functions in xterm.c know what area subsequent X positions
3773 will be relative to. */
3774 updated_area
= area
;
3776 /* Set cursor to start of glyphs, write them, and clear to the end
3777 of the area. I don't think that something more sophisticated is
3778 necessary here, since marginal areas will not be the default. */
3779 rif
->cursor_to (vpos
, 0, desired_row
->y
, 0);
3780 if (desired_row
->used
[area
])
3781 rif
->write_glyphs (desired_row
->glyphs
[area
], desired_row
->used
[area
]);
3782 rif
->clear_end_of_line (-1);
3786 /* Update the display of the text area of row VPOS in window W.
3787 Value is non-zero if display has changed. */
3790 update_text_area (w
, vpos
)
3794 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3795 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3798 /* Let functions in xterm.c know what area subsequent X positions
3799 will be relative to. */
3800 updated_area
= TEXT_AREA
;
3802 /* If rows are at different X or Y, or rows have different height,
3803 or the current row is marked invalid, write the entire line. */
3804 if (!current_row
->enabled_p
3805 || desired_row
->y
!= current_row
->y
3806 || desired_row
->ascent
!= current_row
->ascent
3807 || desired_row
->phys_ascent
!= current_row
->phys_ascent
3808 || desired_row
->phys_height
!= current_row
->phys_height
3809 || desired_row
->visible_height
!= current_row
->visible_height
3810 || current_row
->overlapped_p
3811 || current_row
->x
!= desired_row
->x
)
3813 rif
->cursor_to (vpos
, 0, desired_row
->y
, desired_row
->x
);
3815 if (desired_row
->used
[TEXT_AREA
])
3816 rif
->write_glyphs (desired_row
->glyphs
[TEXT_AREA
],
3817 desired_row
->used
[TEXT_AREA
]);
3819 /* Clear to end of window. */
3820 rif
->clear_end_of_line (-1);
3826 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
3827 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
3829 /* If the desired row extends its face to the text area end,
3830 make sure we write at least one glyph, so that the face
3831 extension actually takes place. */
3832 int desired_stop_pos
= (desired_row
->used
[TEXT_AREA
]
3833 - (MATRIX_ROW_EXTENDS_FACE_P (desired_row
)
3836 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
3842 /* Skip over glyphs that both rows have in common. These
3843 don't have to be written. */
3845 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3847 x
+= desired_glyph
->pixel_width
;
3848 ++desired_glyph
, ++current_glyph
, ++i
;
3851 /* Consider the case that the current row contains "xxx ppp
3852 ggg" in italic Courier font, and the desired row is "xxx
3853 ggg". The character `p' has lbearing, `g' has not. The
3854 loop above will stop in front of the first `p' in the
3855 current row. If we would start writing glyphs there, we
3856 wouldn't erase the lbearing of the `p'. The rest of the
3857 lbearing problem is then taken care of by x_draw_glyphs. */
3858 if (current_row
->contains_overlapping_glyphs_p
3860 && i
< current_row
->used
[TEXT_AREA
]
3861 && current_row
->used
[TEXT_AREA
] != desired_row
->used
[TEXT_AREA
])
3864 rif
->get_glyph_overhangs (current_glyph
, XFRAME (w
->frame
),
3866 while (left
> 0 && i
> 0)
3868 --i
, --desired_glyph
, --current_glyph
;
3869 x
-= desired_glyph
->pixel_width
;
3870 left
-= desired_glyph
->pixel_width
;
3874 /* Try to avoid writing the entire rest of the desired row
3875 by looking for a resync point. This mainly prevents
3876 mode line flickering in the case the mode line is in
3877 fixed-pitch font, which it usually will be. */
3878 if (i
< desired_row
->used
[TEXT_AREA
])
3880 int start_x
= x
, start_hpos
= i
;
3881 struct glyph
*start
= desired_glyph
;
3884 /* Find the next glyph that's equal again. */
3886 && !GLYPH_EQUAL_P (desired_glyph
, current_glyph
)
3889 x
+= desired_glyph
->pixel_width
;
3890 current_x
+= current_glyph
->pixel_width
;
3891 ++desired_glyph
, ++current_glyph
, ++i
;
3894 if (i
== start_hpos
|| x
!= current_x
)
3898 desired_glyph
= start
;
3902 rif
->cursor_to (vpos
, start_hpos
, desired_row
->y
, start_x
);
3903 rif
->write_glyphs (start
, i
- start_hpos
);
3908 /* Write the rest. */
3909 if (i
< desired_row
->used
[TEXT_AREA
])
3911 rif
->cursor_to (vpos
, i
, desired_row
->y
, x
);
3912 rif
->write_glyphs (desired_glyph
, desired_row
->used
[TEXT_AREA
] - i
);
3916 /* Maybe clear to end of line. */
3917 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
3919 /* If new row extends to the end of the text area, nothing
3920 has to be cleared, if and only if we did a write_glyphs
3921 above. This is made sure by setting desired_stop_pos
3922 appropriately above. */
3923 xassert (i
< desired_row
->used
[TEXT_AREA
]);
3925 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
3927 /* If old row extends to the end of the text area, clear. */
3928 if (i
>= desired_row
->used
[TEXT_AREA
])
3929 rif
->cursor_to (vpos
, i
, desired_row
->y
,
3930 desired_row
->x
+ desired_row
->pixel_width
);
3931 rif
->clear_end_of_line (-1);
3934 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
3936 /* Otherwise clear to the end of the old row. Everything
3937 after that position should be clear already. */
3940 if (i
>= desired_row
->used
[TEXT_AREA
])
3941 rif
->cursor_to (vpos
, i
, desired_row
->y
,
3942 desired_row
->x
+ desired_row
->pixel_width
);
3944 /* If cursor is displayed at the end of the line, make sure
3945 it's cleared. Nowadays we don't have a phys_cursor_glyph
3946 with which to erase the cursor (because this method
3947 doesn't work with lbearing/rbearing), so we must do it
3949 if (vpos
== w
->phys_cursor
.vpos
3950 && w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])
3952 w
->phys_cursor_on_p
= 0;
3956 x
= current_row
->x
+ current_row
->pixel_width
;
3957 rif
->clear_end_of_line (x
);
3966 /* Update row VPOS in window W. Value is non-zero if display has been
3970 update_window_line (w
, vpos
)
3974 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3975 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3978 xassert (desired_row
->enabled_p
);
3980 /* Set the row being updated. This is important to let xterm.c
3981 know what line height values are in effect. */
3982 updated_row
= desired_row
;
3984 /* Update display of the left margin area, if there is one. */
3985 if (!desired_row
->full_width_p
3986 && !NILP (w
->left_margin_width
))
3988 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
3992 /* Update the display of the text area. */
3993 changed_p
|= update_text_area (w
, vpos
);
3995 /* Update display of the right margin area, if there is one. */
3996 if (!desired_row
->full_width_p
3997 && !NILP (w
->right_margin_width
))
4000 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
4003 /* Draw truncation marks etc. */
4004 if (!current_row
->enabled_p
4005 || desired_row
->y
!= current_row
->y
4006 || desired_row
->visible_height
!= current_row
->visible_height
4007 || desired_row
->overlay_arrow_p
!= current_row
->overlay_arrow_p
4008 || desired_row
->truncated_on_left_p
!= current_row
->truncated_on_left_p
4009 || desired_row
->truncated_on_right_p
!= current_row
->truncated_on_right_p
4010 || desired_row
->continued_p
!= current_row
->continued_p
4011 || desired_row
->mode_line_p
!= current_row
->mode_line_p
4012 || (desired_row
->indicate_empty_line_p
4013 != current_row
->indicate_empty_line_p
)
4014 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
4015 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
4016 rif
->after_update_window_line_hook (desired_row
);
4018 /* Update current_row from desired_row. */
4019 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4025 /* Set the cursor after an update of window W. This function may only
4026 be called from update_window. */
4029 set_window_cursor_after_update (w
)
4032 struct frame
*f
= XFRAME (w
->frame
);
4033 int cx
, cy
, vpos
, hpos
;
4035 /* Not intended for frame matrix updates. */
4036 xassert (FRAME_WINDOW_P (f
));
4038 if (cursor_in_echo_area
4039 && !NILP (echo_area_buffer
[0])
4040 /* If we are showing a message instead of the mini-buffer,
4041 show the cursor for the message instead. */
4042 && XWINDOW (minibuf_window
) == w
4043 && EQ (minibuf_window
, echo_area_window
)
4044 /* These cases apply only to the frame that contains
4045 the active mini-buffer window. */
4046 && FRAME_HAS_MINIBUF_P (f
)
4047 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4049 cx
= cy
= vpos
= hpos
= 0;
4051 if (cursor_in_echo_area
>= 0)
4053 /* If the mini-buffer is several lines high, find the last
4054 line that has any text on it. Note: either all lines
4055 are enabled or none. Otherwise we wouldn't be able to
4057 struct glyph_row
*row
, *last_row
;
4058 struct glyph
*glyph
;
4059 int yb
= window_text_bottom_y (w
);
4062 for (row
= MATRIX_ROW (w
->current_matrix
, 0);
4066 if (row
->used
[TEXT_AREA
]
4067 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4070 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4076 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
4077 struct glyph
*last
= start
+ row
->used
[TEXT_AREA
] - 1;
4079 while (last
> start
&& last
->charpos
< 0)
4082 for (glyph
= start
; glyph
< last
; ++glyph
)
4084 cx
+= glyph
->pixel_width
;
4089 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4097 hpos
= w
->cursor
.hpos
;
4098 vpos
= w
->cursor
.vpos
;
4101 /* Window cursor can be out of sync for horizontally split windows. */
4102 hpos
= max (0, hpos
);
4103 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4104 vpos
= max (0, vpos
);
4105 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4106 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4110 /* Try to reuse part of the current display of W by scrolling lines.
4111 HEADER_LINE_P non-zero means W has a top mode line.
4113 The algorithm is taken from Communications of the ACM, Apr78 "A
4114 Technique for Isolating Differences Between Files." It should take
4117 A short outline of the steps of the algorithm
4119 1. Skip lines equal at the start and end of both matrices.
4121 2. Enter rows in the current and desired matrix into a symbol
4122 table, counting how often they appear in both matrices.
4124 3. Rows that appear exactly once in both matrices serve as anchors,
4125 i.e. we assume that such lines are likely to have been moved.
4127 4. Starting from anchor lines, extend regions to be scrolled both
4128 forward and backward.
4132 -1 if all rows were found to be equal.
4133 0 to indicate that we did not scroll the display, or
4134 1 if we did scroll. */
4137 scrolling_window (w
, header_line_p
)
4143 /* Number of occurrences of this line in old and new matrix. */
4144 short old_uses
, new_uses
;
4146 /* Vpos of line in new matrix. */
4147 short new_line_number
;
4149 /* The line itself. */
4150 struct glyph_row
*row
;
4152 /* Hash collision chain. */
4153 struct symbol
*next
;
4156 int SYMBOL_TABLE_SIZE
= 101;
4157 struct symbol
**table
;
4158 struct symbol
**old_line_syms
, **new_line_syms
;
4159 int i
, j
, first_old
, first_new
, last_old
, last_new
;
4163 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4164 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4165 int yb
= window_text_bottom_y (w
);
4167 /* Skip over rows equal at the start. */
4168 i
= header_line_p
? 1 : 0;
4169 while (i
< current_matrix
->nrows
- 1
4170 && MATRIX_ROW_ENABLED_P (current_matrix
, i
)
4171 && MATRIX_ROW_ENABLED_P (desired_matrix
, i
)
4172 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) < yb
4173 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) < yb
4175 MATRIX_ROW (desired_matrix
, i
),
4176 MATRIX_ROW (current_matrix
, i
)))
4178 assign_row (MATRIX_ROW (current_matrix
, i
),
4179 MATRIX_ROW (desired_matrix
, i
));
4180 MATRIX_ROW (desired_matrix
, i
)->enabled_p
= 0;
4184 /* Give up if some rows in the desired matrix are not enabled. */
4185 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4188 first_old
= first_new
= i
;
4190 /* Set last_new to the index + 1 of the last enabled row in the
4193 while (i
< desired_matrix
->nrows
- 1
4194 && MATRIX_ROW (desired_matrix
, i
)->enabled_p
4195 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) < yb
)
4198 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4203 /* Set last_old to the index + 1 of the last enabled row in the
4204 current matrix. We don't look at the enabled flag here because
4205 we plan to reuse part of the display even if other parts are
4208 while (i
< current_matrix
->nrows
- 1
4209 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) < yb
)
4213 /* Skip over rows equal at the bottom. */
4216 while (i
- 1 > first_new
4217 && j
- 1 > first_old
4218 && MATRIX_ROW (current_matrix
, i
- 1)->enabled_p
4219 && (MATRIX_ROW (current_matrix
, i
- 1)->y
4220 == MATRIX_ROW (desired_matrix
, j
- 1)->y
)
4222 MATRIX_ROW (desired_matrix
, i
- 1),
4223 MATRIX_ROW (current_matrix
, j
- 1)))
4228 /* Nothing to do if all rows are equal. */
4229 if (last_new
== first_new
)
4232 /* Allocate a hash table in which all rows will be inserted. */
4233 table
= (struct symbol
**) alloca (SYMBOL_TABLE_SIZE
* sizeof *table
);
4234 bzero (table
, SYMBOL_TABLE_SIZE
* sizeof *table
);
4236 /* For each row in the current matrix, record the symbol belonging
4237 to the row in OLD_LINE_SYMS. */
4238 old_line_syms
= (struct symbol
**) alloca (current_matrix
->nrows
4239 * sizeof *old_line_syms
);
4240 new_line_syms
= (struct symbol
**) alloca (desired_matrix
->nrows
4241 * sizeof *new_line_syms
);
4243 #define ADDSYM(ROW) \
4246 struct glyph_row *row_ = (ROW); \
4247 int i_ = row_->hash % SYMBOL_TABLE_SIZE; \
4249 while (sym && !row_equal_p (w, sym->row, row_)) \
4253 sym = (struct symbol *) alloca (sizeof *sym); \
4255 sym->old_uses = sym->new_uses = 0; \
4256 sym->next = table[i_]; \
4262 /* Add current rows to the symbol table. */
4263 for (i
= first_old
; i
< last_old
; ++i
)
4265 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4267 ADDSYM (MATRIX_ROW (current_matrix
, i
));
4268 old_line_syms
[i
] = sym
;
4272 old_line_syms
[i
] = NULL
;
4275 /* Add desired rows to the symbol table. */
4276 for (i
= first_new
; i
< last_new
; ++i
)
4278 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4279 ADDSYM (MATRIX_ROW (desired_matrix
, i
));
4281 new_line_syms
[i
] = sym
;
4282 sym
->new_line_number
= i
;
4287 /* Record in runs which moves were found, ordered by pixel
4288 height of copied areas. */
4290 runs
= (struct run
**) alloca (desired_matrix
->nrows
* sizeof *runs
);
4292 /* Identify moves based on lines that are unique and equal
4293 in both matrices. */
4294 for (i
= first_old
; i
< last_old
;)
4295 if (old_line_syms
[i
]
4296 && old_line_syms
[i
]->old_uses
== 1
4297 && old_line_syms
[i
]->new_uses
== 1)
4300 int new_line
= old_line_syms
[i
]->new_line_number
;
4301 struct run
*run
= (struct run
*) alloca (sizeof *run
);
4304 run
->current_vpos
= i
;
4305 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4306 run
->desired_vpos
= new_line
;
4307 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4309 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4311 /* Extend backward. */
4314 while (j
> first_old
4316 && old_line_syms
[j
] == new_line_syms
[k
])
4318 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4319 --run
->current_vpos
;
4320 --run
->desired_vpos
;
4323 run
->desired_y
-= h
;
4324 run
->current_y
-= h
;
4328 /* Extend forward. */
4333 && old_line_syms
[j
] == new_line_syms
[k
])
4335 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4341 /* Insert run into list of all runs. Order runs by copied
4342 pixel lines. Note that we record runs that don't have to
4343 be copied because they are already in place. This is done
4344 because we can avoid calling update_window_line in this
4346 for (j
= 0; j
< nruns
&& runs
[j
]->height
> run
->height
; ++j
)
4348 for (k
= nruns
; k
>= j
; --k
)
4349 runs
[k
] = runs
[k
- 1];
4358 /* Do the moves. Do it in a way that we don't overwrite something
4359 we want to copy later on. This is not solvable in general
4360 because there is only one display and we don't have a way to
4361 exchange areas on this display. Example:
4363 +-----------+ +-----------+
4365 +-----------+ --> +-----------+
4367 +-----------+ +-----------+
4369 Instead, prefer bigger moves, and invalidate moves that would
4370 copy from where we copied to. */
4372 for (i
= 0; i
< nruns
; ++i
)
4373 if (runs
[i
]->nrows
> 0)
4375 struct run
*r
= runs
[i
];
4377 /* Copy on the display. */
4378 if (r
->current_y
!= r
->desired_y
)
4380 rif
->scroll_run_hook (w
, r
);
4382 /* Invalidate runs that copy from where we copied to. */
4383 for (j
= i
+ 1; j
< nruns
; ++j
)
4385 struct run
*p
= runs
[j
];
4387 if ((p
->current_y
>= r
->desired_y
4388 && p
->current_y
< r
->desired_y
+ r
->height
)
4389 || (p
->current_y
+ p
->height
>= r
->desired_y
4390 && (p
->current_y
+ p
->height
4391 < r
->desired_y
+ r
->height
)))
4396 /* Assign matrix rows. */
4397 for (j
= 0; j
< r
->nrows
; ++j
)
4399 struct glyph_row
*from
, *to
;
4400 int to_overlapped_p
;
4402 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
4403 to_overlapped_p
= to
->overlapped_p
;
4404 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
4405 assign_row (to
, from
);
4406 to
->enabled_p
= 1, from
->enabled_p
= 0;
4407 to
->overlapped_p
= to_overlapped_p
;
4411 /* Value is non-zero to indicate that we scrolled the display. */
4416 /* Set WINDOW->must_be_updated_p TO ON_P for all windows WINDOW in the
4417 window tree rooted at W. */
4420 set_window_update_flags (w
, on_p
)
4426 if (!NILP (w
->hchild
))
4427 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4428 else if (!NILP (w
->vchild
))
4429 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4431 w
->must_be_updated_p
= on_p
;
4433 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4439 /************************************************************************
4441 ************************************************************************/
4443 /* Update the desired frame matrix of frame F.
4445 FORCE_P non-zero means that the update should not be stopped by
4446 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
4447 should not be tried.
4449 Value is non-zero if update was stopped due to pending input. */
4452 update_frame_1 (f
, force_p
, inhibit_id_p
)
4457 /* Frame matrices to work on. */
4458 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4459 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4462 int preempt_count
= baud_rate
/ 2400 + 1;
4463 extern int input_pending
;
4465 xassert (current_matrix
&& desired_matrix
);
4467 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
4468 calculate_costs (f
);
4470 if (preempt_count
<= 0)
4473 detect_input_pending ();
4474 if (input_pending
&& !force_p
)
4482 /* If we cannot insert/delete lines, it's no use trying it. */
4483 if (!line_ins_del_ok
)
4486 /* See if any of the desired lines are enabled; don't compute for
4487 i/d line if just want cursor motion. */
4488 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
4489 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4492 /* Try doing i/d line, if not yet inhibited. */
4493 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
4494 force_p
|= scrolling (f
);
4496 /* Update the individual lines as needed. Do bottom line first. */
4497 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
4498 update_frame_line (f
, desired_matrix
->nrows
- 1);
4500 /* Now update the rest of the lines. */
4501 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
4503 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4505 if (FRAME_TERMCAP_P (f
))
4507 /* Flush out every so many lines.
4508 Also flush out if likely to have more than 1k buffered
4509 otherwise. I'm told that some telnet connections get
4510 really screwed by more than 1k output at once. */
4511 int outq
= PENDING_OUTPUT_COUNT (stdout
);
4513 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
4516 if (preempt_count
== 1)
4518 #ifdef EMACS_OUTQSIZE
4519 if (EMACS_OUTQSIZE (0, &outq
) < 0)
4520 /* Probably not a tty. Ignore the error and reset
4521 * the outq count. */
4522 outq
= PENDING_OUTPUT_COUNT (stdout
);
4525 if (baud_rate
<= outq
&& baud_rate
> 0)
4526 sleep (outq
/ baud_rate
);
4531 if ((i
- 1) % preempt_count
== 0)
4532 detect_input_pending ();
4534 update_frame_line (f
, i
);
4538 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
4540 /* Now just clean up termcap drivers and set cursor, etc. */
4543 if ((cursor_in_echo_area
4544 /* If we are showing a message instead of the mini-buffer,
4545 show the cursor for the message instead of for the
4546 (now hidden) mini-buffer contents. */
4547 || (EQ (minibuf_window
, selected_window
)
4548 && EQ (minibuf_window
, echo_area_window
)
4549 && !NILP (echo_area_buffer
[0])))
4550 /* These cases apply only to the frame that contains
4551 the active mini-buffer window. */
4552 && FRAME_HAS_MINIBUF_P (f
)
4553 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4555 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
4558 if (cursor_in_echo_area
< 0)
4560 /* Negative value of cursor_in_echo_area means put
4561 cursor at beginning of line. */
4567 /* Positive value of cursor_in_echo_area means put
4568 cursor at the end of the prompt. If the mini-buffer
4569 is several lines high, find the last line that has
4571 row
= FRAME_HEIGHT (f
);
4577 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
4579 /* Frame rows are filled up with spaces that
4580 must be ignored here. */
4581 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
4583 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
4584 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
4587 && (last
- 1)->charpos
< 0)
4593 while (row
> top
&& col
== 0);
4595 /* Make sure COL is not out of range. */
4596 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
4598 /* If we have another row, advance cursor into it. */
4599 if (row
< FRAME_HEIGHT (f
) - 1)
4601 col
= FRAME_LEFT_SCROLL_BAR_WIDTH (f
);
4604 /* Otherwise move it back in range. */
4606 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
4610 cursor_to (row
, col
);
4614 /* We have only one cursor on terminal frames. Use it to
4615 display the cursor of the selected window. */
4616 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
4617 if (w
->cursor
.vpos
>= 0)
4619 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
4620 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
4622 if (INTEGERP (w
->left_margin_width
))
4623 x
+= XFASTINT (w
->left_margin_width
);
4625 /* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
4634 fflush (termscript
);
4639 display_completed
= !pause
;
4640 clear_desired_matrices (f
);
4645 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4649 struct frame
*frame
;
4651 int unchanged_at_top
, unchanged_at_bottom
;
4654 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4655 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4656 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4657 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4659 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
4660 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4661 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4663 if (!current_matrix
)
4666 /* Compute hash codes of all the lines. Also calculate number of
4667 changed lines, number of unchanged lines at the beginning, and
4668 number of unchanged lines at the end. */
4670 unchanged_at_top
= 0;
4671 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
4672 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
4674 /* Give up on this scrolling if some old lines are not enabled. */
4675 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
4677 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
4678 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4680 /* This line cannot be redrawn, so don't let scrolling mess it. */
4681 new_hash
[i
] = old_hash
[i
];
4682 #define INFINITY 1000000 /* Taken from scroll.c */
4683 draw_cost
[i
] = INFINITY
;
4687 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
4688 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
4691 if (old_hash
[i
] != new_hash
[i
])
4694 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
4696 else if (i
== unchanged_at_top
)
4698 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
4701 /* If changed lines are few, don't allow preemption, don't scroll. */
4702 if ((!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400)
4703 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
4706 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
4707 - unchanged_at_bottom
);
4709 if (scroll_region_ok
)
4710 free_at_end_vpos
-= unchanged_at_bottom
;
4711 else if (memory_below_frame
)
4712 free_at_end_vpos
= -1;
4714 /* If large window, fast terminal and few lines in common between
4715 current frame and desired frame, don't bother with i/d calc. */
4716 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
4718 10 * scrolling_max_lines_saved (unchanged_at_top
,
4719 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
4720 old_hash
, new_hash
, draw_cost
)))
4723 if (window_size
< 2)
4726 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
4727 draw_cost
+ unchanged_at_top
- 1,
4728 old_draw_cost
+ unchanged_at_top
- 1,
4729 old_hash
+ unchanged_at_top
- 1,
4730 new_hash
+ unchanged_at_top
- 1,
4731 free_at_end_vpos
- unchanged_at_top
);
4737 /* Count the number of blanks at the start of the vector of glyphs R
4738 which is LEN glyphs long. */
4741 count_blanks (r
, len
)
4747 for (i
= 0; i
< len
; ++i
)
4748 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
4755 /* Count the number of glyphs in common at the start of the glyph
4756 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
4757 of STR2. Value is the number of equal glyphs equal at the start. */
4760 count_match (str1
, end1
, str2
, end2
)
4761 struct glyph
*str1
, *end1
, *str2
, *end2
;
4763 struct glyph
*p1
= str1
;
4764 struct glyph
*p2
= str2
;
4768 && GLYPH_FROM_CHAR_GLYPH (*p1
) == GLYPH_FROM_CHAR_GLYPH (*p2
))
4775 /* Char insertion/deletion cost vector, from term.c */
4777 extern int *char_ins_del_vector
;
4778 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
4781 /* Perform a frame-based update on line VPOS in frame FRAME. */
4784 update_frame_line (frame
, vpos
)
4785 register struct frame
*frame
;
4788 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
4790 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
4791 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4792 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4793 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
4794 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
4795 int must_write_whole_line_p
;
4797 if (desired_row
->inverse_p
4798 != (current_row
->enabled_p
&& current_row
->inverse_p
))
4800 int n
= current_row
->enabled_p
? current_row
->used
[TEXT_AREA
] : 0;
4801 change_line_highlight (desired_row
->inverse_p
, vpos
, vpos
, n
);
4802 current_row
->enabled_p
= 0;
4805 reassert_line_highlight (desired_row
->inverse_p
, vpos
);
4807 /* Current row not enabled means it has unknown contents. We must
4808 write the whole desired line in that case. */
4809 must_write_whole_line_p
= !current_row
->enabled_p
;
4810 if (must_write_whole_line_p
)
4817 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
4818 olen
= current_row
->used
[TEXT_AREA
];
4820 if (! current_row
->inverse_p
)
4822 /* Ignore trailing spaces, if we can. */
4823 if (!must_write_spaces
)
4824 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
4829 /* For an inverse-video line, make sure it's filled with
4830 spaces all the way to the frame edge so that the reverse
4831 video extends all the way across. */
4832 while (olen
< FRAME_WIDTH (frame
) - 1)
4833 obody
[olen
++] = space_glyph
;
4837 current_row
->enabled_p
= 1;
4838 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
4839 current_row
->inverse_p
= desired_row
->inverse_p
;
4841 /* If desired line is empty, just clear the line. */
4842 if (!desired_row
->enabled_p
)
4848 nbody
= desired_row
->glyphs
[TEXT_AREA
];
4849 nlen
= desired_row
->used
[TEXT_AREA
];
4850 nend
= nbody
+ nlen
;
4852 /* If display line has unknown contents, write the whole line. */
4853 if (must_write_whole_line_p
)
4855 /* Ignore spaces at the end, if we can. */
4856 if (!must_write_spaces
)
4857 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4860 /* Write the contents of the desired line. */
4863 cursor_to (vpos
, 0);
4864 write_glyphs (nbody
, nlen
);
4867 /* Don't call clear_end_of_line if we already wrote the whole
4868 line. The cursor will not be at the right margin in that
4869 case but in the line below. */
4870 if (nlen
< FRAME_WINDOW_WIDTH (frame
))
4872 cursor_to (vpos
, nlen
);
4873 clear_end_of_line (FRAME_WINDOW_WIDTH (frame
));
4876 make_current (desired_matrix
, current_matrix
, vpos
);
4880 /* Pretend trailing spaces are not there at all,
4881 unless for one reason or another we must write all spaces. */
4882 if (!desired_row
->inverse_p
)
4884 if (!must_write_spaces
)
4885 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4890 /* For an inverse-video line, give it extra trailing spaces all
4891 the way to the frame edge so that the reverse video extends
4892 all the way across. */
4893 while (nlen
< FRAME_WIDTH (frame
) - 1)
4894 nbody
[nlen
++] = space_glyph
;
4897 /* If there's no i/d char, quickly do the best we can without it. */
4898 if (!char_ins_del_ok
)
4902 /* Find the first glyph in desired row that doesn't agree with
4903 a glyph in the current row, and write the rest from there on. */
4904 for (i
= 0; i
< nlen
; i
++)
4906 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
4908 /* Find the end of the run of different glyphs. */
4912 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
4913 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
4916 /* Output this run of non-matching chars. */
4917 cursor_to (vpos
, i
);
4918 write_glyphs (nbody
+ i
, j
- i
);
4921 /* Now find the next non-match. */
4925 /* Clear the rest of the line, or the non-clear part of it. */
4928 cursor_to (vpos
, nlen
);
4929 clear_end_of_line (olen
);
4932 /* Make current row = desired row. */
4933 make_current (desired_matrix
, current_matrix
, vpos
);
4937 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
4938 characters in a row. */
4942 /* If current line is blank, skip over initial spaces, if
4943 possible, and write the rest. */
4944 if (must_write_spaces
|| desired_row
->inverse_p
)
4947 nsp
= count_blanks (nbody
, nlen
);
4951 cursor_to (vpos
, nsp
);
4952 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
4955 /* Exchange contents between current_frame and new_frame. */
4956 make_current (desired_matrix
, current_matrix
, vpos
);
4960 /* Compute number of leading blanks in old and new contents. */
4961 osp
= count_blanks (obody
, olen
);
4962 nsp
= desired_row
->inverse_p
? 0 : count_blanks (nbody
, nlen
);
4964 /* Compute number of matching chars starting with first non-blank. */
4965 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
4966 nbody
+ nsp
, nbody
+ nlen
);
4968 /* Spaces in new match implicit space past the end of old. */
4969 /* A bug causing this to be a no-op was fixed in 18.29. */
4970 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
4973 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
4977 /* Avoid doing insert/delete char
4978 just cause number of leading spaces differs
4979 when the following text does not match. */
4980 if (begmatch
== 0 && osp
!= nsp
)
4981 osp
= nsp
= min (osp
, nsp
);
4983 /* Find matching characters at end of line */
4986 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
4988 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
4993 endmatch
= obody
+ olen
- op1
;
4995 /* tem gets the distance to insert or delete.
4996 endmatch is how many characters we save by doing so.
4999 tem
= (nlen
- nsp
) - (olen
- osp
);
5001 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
5004 /* nsp - osp is the distance to insert or delete.
5005 If that is nonzero, begmatch is known to be nonzero also.
5006 begmatch + endmatch is how much we save by doing the ins/del.
5010 && (!char_ins_del_ok
5011 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
5015 osp
= nsp
= min (osp
, nsp
);
5018 /* Now go through the line, inserting, writing and
5019 deleting as appropriate. */
5023 cursor_to (vpos
, nsp
);
5024 delete_glyphs (osp
- nsp
);
5028 /* If going to delete chars later in line
5029 and insert earlier in the line,
5030 must delete first to avoid losing data in the insert */
5031 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
5033 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
5034 delete_glyphs (olen
+ nsp
- osp
- nlen
);
5035 olen
= nlen
- (nsp
- osp
);
5037 cursor_to (vpos
, osp
);
5038 insert_glyphs (0, nsp
- osp
);
5042 tem
= nsp
+ begmatch
+ endmatch
;
5043 if (nlen
!= tem
|| olen
!= tem
)
5045 cursor_to (vpos
, nsp
+ begmatch
);
5046 if (!endmatch
|| nlen
== olen
)
5048 /* If new text being written reaches right margin,
5049 there is no need to do clear-to-eol at the end.
5050 (and it would not be safe, since cursor is not
5051 going to be "at the margin" after the text is done) */
5052 if (nlen
== FRAME_WINDOW_WIDTH (frame
))
5054 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5056 else if (nlen
> olen
)
5058 /* Here, we used to have the following simple code:
5059 ----------------------------------------
5060 write_glyphs (nbody + nsp + begmatch, olen - tem);
5061 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5062 ----------------------------------------
5063 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5064 is a padding glyph. */
5065 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5068 /* Calculate columns we can actually overwrite. */
5069 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
])) out
--;
5070 write_glyphs (nbody
+ nsp
+ begmatch
, out
);
5071 /* If we left columns to be overwritten, we must delete them. */
5072 del
= olen
- tem
- out
;
5073 if (del
> 0) delete_glyphs (del
);
5074 /* At last, we insert columns not yet written out. */
5075 insert_glyphs (nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5078 else if (olen
> nlen
)
5080 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5081 delete_glyphs (olen
- nlen
);
5087 /* If any unerased characters remain after the new line, erase them. */
5090 cursor_to (vpos
, nlen
);
5091 clear_end_of_line (olen
);
5094 /* Exchange contents between current_frame and new_frame. */
5095 make_current (desired_matrix
, current_matrix
, vpos
);
5100 /***********************************************************************
5101 X/Y Position -> Buffer Position
5102 ***********************************************************************/
5104 /* Return the character position of the character at window relative
5105 pixel position (*X, *Y). *X and *Y are adjusted to character
5109 buffer_posn_from_coords (w
, x
, y
)
5114 struct buffer
*old_current_buffer
= current_buffer
;
5115 struct text_pos startp
;
5116 int left_area_width
;
5118 current_buffer
= XBUFFER (w
->buffer
);
5119 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5120 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5121 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5122 start_display (&it
, w
, startp
);
5124 left_area_width
= WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH (w
);
5125 move_it_to (&it
, -1, *x
+ it
.first_visible_x
- left_area_width
, *y
, -1,
5126 MOVE_TO_X
| MOVE_TO_Y
);
5128 *x
= it
.current_x
- it
.first_visible_x
+ left_area_width
;
5130 current_buffer
= old_current_buffer
;
5131 return IT_CHARPOS (it
);
5135 /* Value is the string under window-relative coordinates X/Y in the
5136 mode or top line of window W, or nil if none. MODE_LINE_P non-zero
5137 means look at the mode line. *CHARPOS is set to the position in
5138 the string returned. */
5141 mode_line_string (w
, x
, y
, mode_line_p
, charpos
)
5146 struct glyph_row
*row
;
5147 struct glyph
*glyph
, *end
;
5148 struct frame
*f
= XFRAME (w
->frame
);
5150 Lisp_Object string
= Qnil
;
5152 /* Only do this for frames under a window system. */
5153 if (!FRAME_WINDOW_P (f
))
5157 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5159 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
5161 if (row
->mode_line_p
&& row
->enabled_p
)
5163 /* The mode lines are displayed over scroll bars and bitmap
5164 areas, and X is window-relative. Correct X by the scroll bar
5165 and bitmap area width. */
5166 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
5167 x
+= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
5168 x
+= FRAME_LEFT_FLAGS_AREA_WIDTH (f
);
5170 /* Find the glyph under X. If we find one with a string object,
5171 it's the one we were looking for. */
5172 glyph
= row
->glyphs
[TEXT_AREA
];
5173 end
= glyph
+ row
->used
[TEXT_AREA
];
5174 for (x0
= 0; glyph
< end
; x0
+= glyph
->pixel_width
, ++glyph
)
5175 if (x
>= x0
&& x
< x0
+ glyph
->pixel_width
)
5177 string
= glyph
->object
;
5178 *charpos
= glyph
->charpos
;
5187 /***********************************************************************
5188 Changing Frame Sizes
5189 ***********************************************************************/
5194 window_change_signal (signalnum
) /* If we don't have an argument, */
5195 int signalnum
; /* some compilers complain in signal calls. */
5199 int old_errno
= errno
;
5201 get_frame_size (&width
, &height
);
5203 /* The frame size change obviously applies to a termcap-controlled
5204 frame. Find such a frame in the list, and assume it's the only
5205 one (since the redisplay code always writes to stdout, not a
5206 FILE * specified in the frame structure). Record the new size,
5207 but don't reallocate the data structures now. Let that be done
5208 later outside of the signal handler. */
5211 Lisp_Object tail
, frame
;
5213 FOR_EACH_FRAME (tail
, frame
)
5215 if (FRAME_TERMCAP_P (XFRAME (frame
)))
5217 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5223 signal (SIGWINCH
, window_change_signal
);
5226 #endif /* SIGWINCH */
5229 /* Do any change in frame size that was requested by a signal. SAFE
5230 non-zero means this function is called from a place where it is
5231 safe to change frame sizes while a redisplay is in progress. */
5234 do_pending_window_change (safe
)
5237 /* If window_change_signal should have run before, run it now. */
5238 if (redisplaying_p
&& !safe
)
5241 while (delayed_size_change
)
5243 Lisp_Object tail
, frame
;
5245 delayed_size_change
= 0;
5247 FOR_EACH_FRAME (tail
, frame
)
5249 struct frame
*f
= XFRAME (frame
);
5251 int height
= FRAME_NEW_HEIGHT (f
);
5252 int width
= FRAME_NEW_WIDTH (f
);
5254 if (height
!= 0 || width
!= 0)
5255 change_frame_size (f
, height
, width
, 0, 0, safe
);
5261 /* Change the frame height and/or width. Values may be given as zero to
5262 indicate no change is to take place.
5264 If DELAY is non-zero, then assume we're being called from a signal
5265 handler, and queue the change for later - perhaps the next
5266 redisplay. Since this tries to resize windows, we can't call it
5267 from a signal handler.
5269 SAFE non-zero means this function is called from a place where it's
5270 safe to change frame sizes while a redisplay is in progress. */
5273 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5274 register struct frame
*f
;
5275 int newheight
, newwidth
, pretend
, delay
, safe
;
5277 Lisp_Object tail
, frame
;
5279 if (! FRAME_WINDOW_P (f
))
5281 /* When using termcap, or on MS-DOS, all frames use
5282 the same screen, so a change in size affects all frames. */
5283 FOR_EACH_FRAME (tail
, frame
)
5284 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5285 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5286 pretend
, delay
, safe
);
5289 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
5293 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5294 register struct frame
*f
;
5295 int newheight
, newwidth
, pretend
, delay
, safe
;
5297 int new_frame_window_width
;
5298 int count
= specpdl_ptr
- specpdl
;
5300 /* If we can't deal with the change now, queue it for later. */
5301 if (delay
|| (redisplaying_p
&& !safe
))
5303 FRAME_NEW_HEIGHT (f
) = newheight
;
5304 FRAME_NEW_WIDTH (f
) = newwidth
;
5305 delayed_size_change
= 1;
5309 /* This size-change overrides any pending one for this frame. */
5310 FRAME_NEW_HEIGHT (f
) = 0;
5311 FRAME_NEW_WIDTH (f
) = 0;
5313 /* If an argument is zero, set it to the current value. */
5315 newheight
= FRAME_HEIGHT (f
);
5317 newwidth
= FRAME_WIDTH (f
);
5319 /* Compute width of windows in F.
5320 This is the width of the frame without vertical scroll bars. */
5321 new_frame_window_width
= FRAME_WINDOW_WIDTH_ARG (f
, newwidth
);
5323 /* Round up to the smallest acceptable size. */
5324 check_frame_size (f
, &newheight
, &newwidth
);
5326 /* If we're not changing the frame size, quit now. */
5327 if (newheight
== FRAME_HEIGHT (f
)
5328 && new_frame_window_width
== FRAME_WINDOW_WIDTH (f
))
5334 /* We only can set screen dimensions to certain values supported
5335 by our video hardware. Try to find the smallest size greater
5336 or equal to the requested dimensions. */
5337 dos_set_window_size (&newheight
, &newwidth
);
5340 if (newheight
!= FRAME_HEIGHT (f
))
5342 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
5344 /* Frame has both root and mini-buffer. */
5345 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f
))->top
,
5346 FRAME_TOP_MARGIN (f
));
5347 set_window_height (FRAME_ROOT_WINDOW (f
),
5350 - FRAME_TOP_MARGIN (f
)),
5352 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
,
5354 set_window_height (FRAME_MINIBUF_WINDOW (f
), 1, 0);
5357 /* Frame has just one top-level window. */
5358 set_window_height (FRAME_ROOT_WINDOW (f
),
5359 newheight
- FRAME_TOP_MARGIN (f
), 0);
5361 if (FRAME_TERMCAP_P (f
) && !pretend
)
5362 FrameRows
= newheight
;
5365 if (new_frame_window_width
!= FRAME_WINDOW_WIDTH (f
))
5367 set_window_width (FRAME_ROOT_WINDOW (f
), new_frame_window_width
, 0);
5368 if (FRAME_HAS_MINIBUF_P (f
))
5369 set_window_width (FRAME_MINIBUF_WINDOW (f
), new_frame_window_width
, 0);
5371 if (FRAME_TERMCAP_P (f
) && !pretend
)
5372 FrameCols
= newwidth
;
5374 if (WINDOWP (f
->tool_bar_window
))
5375 XSETFASTINT (XWINDOW (f
->tool_bar_window
)->width
, newwidth
);
5378 FRAME_HEIGHT (f
) = newheight
;
5379 SET_FRAME_WIDTH (f
, newwidth
);
5382 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5383 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
5385 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
5387 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
5388 w
->cursor
.hpos
= w
->cursor
.x
= 0;
5389 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
5390 w
->cursor
.vpos
= w
->cursor
.y
= 0;
5394 SET_FRAME_GARBAGED (f
);
5395 calculate_costs (f
);
5399 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
5401 /* This isn't quite a no-op: it runs window-configuration-change-hook. */
5402 Fset_window_buffer (FRAME_SELECTED_WINDOW (f
),
5403 XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
);
5405 unbind_to (count
, Qnil
);
5410 /***********************************************************************
5411 Terminal Related Lisp Functions
5412 ***********************************************************************/
5414 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
5415 1, 1, "FOpen termscript file: ",
5416 "Start writing all terminal output to FILE as well as the terminal.\n\
5417 FILE = nil means just close any termscript file currently open.")
5421 if (termscript
!= 0) fclose (termscript
);
5426 file
= Fexpand_file_name (file
, Qnil
);
5427 termscript
= fopen (XSTRING (file
)->data
, "w");
5428 if (termscript
== 0)
5429 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
5435 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
5436 Ssend_string_to_terminal
, 1, 1, 0,
5437 "Send STRING to the terminal without alteration.\n\
5438 Control characters in STRING will have terminal-dependent effects.")
5442 /* ??? Perhaps we should do something special for multibyte strings here. */
5443 CHECK_STRING (string
, 0);
5444 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)), stdout
);
5448 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)),
5450 fflush (termscript
);
5456 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
5457 "Beep, or flash the screen.\n\
5458 Also, unless an argument is given,\n\
5459 terminate any keyboard macro currently executing.")
5482 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
5483 error ("Keyboard macro terminated by a command ringing the bell");
5491 /***********************************************************************
5493 ***********************************************************************/
5495 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
5496 "Pause, without updating display, for SECONDS seconds.\n\
5497 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5498 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5499 additional wait period, in milliseconds; this may be useful if your\n\
5500 Emacs was built without floating point support.\n\
5501 \(Not all operating systems support waiting for a fraction of a second.)")
5502 (seconds
, milliseconds
)
5503 Lisp_Object seconds
, milliseconds
;
5507 if (NILP (milliseconds
))
5508 XSETINT (milliseconds
, 0);
5510 CHECK_NUMBER (milliseconds
, 1);
5511 usec
= XINT (milliseconds
) * 1000;
5513 #ifdef LISP_FLOAT_TYPE
5515 double duration
= extract_float (seconds
);
5516 sec
= (int) duration
;
5517 usec
+= (duration
- sec
) * 1000000;
5520 CHECK_NUMBER (seconds
, 0);
5521 sec
= XINT (seconds
);
5524 #ifndef EMACS_HAS_USECS
5525 if (sec
== 0 && usec
!= 0)
5526 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
5529 /* Assure that 0 <= usec < 1000000. */
5532 /* We can't rely on the rounding being correct if user is negative. */
5533 if (-1000000 < usec
)
5534 sec
--, usec
+= 1000000;
5536 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
5539 sec
+= usec
/ 1000000, usec
%= 1000000;
5541 if (sec
< 0 || (sec
== 0 && usec
== 0))
5547 XSETFASTINT (zero
, 0);
5548 wait_reading_process_input (sec
, usec
, zero
, 0);
5551 /* We should always have wait_reading_process_input; we have a dummy
5552 implementation for systems which don't support subprocesses. */
5554 /* No wait_reading_process_input */
5561 /* The reason this is done this way
5562 (rather than defined (H_S) && defined (H_T))
5563 is because the VMS preprocessor doesn't grok `defined' */
5565 EMACS_GET_TIME (end_time
);
5566 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
5567 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
5571 EMACS_GET_TIME (timeout
);
5572 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
5573 if (EMACS_TIME_NEG_P (timeout
)
5574 || !select (1, 0, 0, 0, &timeout
))
5577 #else /* not HAVE_SELECT */
5579 #endif /* HAVE_SELECT */
5580 #endif /* not VMS */
5583 #endif /* no subprocesses */
5589 /* This is just like wait_reading_process_input, except that
5590 it does the redisplay.
5592 It's also much like Fsit_for, except that it can be used for
5593 waiting for input as well. */
5596 sit_for (sec
, usec
, reading
, display
, initial_display
)
5597 int sec
, usec
, reading
, display
, initial_display
;
5599 Lisp_Object read_kbd
;
5601 swallow_events (display
);
5603 if (detect_input_pending_run_timers (display
))
5606 if (initial_display
)
5607 redisplay_preserve_echo_area ();
5609 if (sec
== 0 && usec
== 0)
5616 XSETINT (read_kbd
, reading
? -1 : 1);
5617 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
5619 return detect_input_pending () ? Qnil
: Qt
;
5623 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
5624 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
5625 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5626 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5627 additional wait period, in milliseconds; this may be useful if your\n\
5628 Emacs was built without floating point support.\n\
5629 \(Not all operating systems support waiting for a fraction of a second.)\n\
5630 Optional third arg NODISP non-nil means don't redisplay, just wait for input.\n\
5631 Redisplay is preempted as always if input arrives, and does not happen\n\
5632 if input is available before it starts.\n\
5633 Value is t if waited the full time with no input arriving.")
5634 (seconds
, milliseconds
, nodisp
)
5635 Lisp_Object seconds
, milliseconds
, nodisp
;
5639 if (NILP (milliseconds
))
5640 XSETINT (milliseconds
, 0);
5642 CHECK_NUMBER (milliseconds
, 1);
5643 usec
= XINT (milliseconds
) * 1000;
5645 #ifdef LISP_FLOAT_TYPE
5647 double duration
= extract_float (seconds
);
5648 sec
= (int) duration
;
5649 usec
+= (duration
- sec
) * 1000000;
5652 CHECK_NUMBER (seconds
, 0);
5653 sec
= XINT (seconds
);
5656 #ifndef EMACS_HAS_USECS
5657 if (usec
!= 0 && sec
== 0)
5658 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
5661 return sit_for (sec
, usec
, 0, NILP (nodisp
), NILP (nodisp
));
5666 /***********************************************************************
5667 Other Lisp Functions
5668 ***********************************************************************/
5670 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
5671 session's frames, frame names, buffers, buffer-read-only flags, and
5672 buffer-modified-flags, and a trailing sentinel (so we don't need to
5673 add length checks). */
5675 static Lisp_Object frame_and_buffer_state
;
5678 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
5679 Sframe_or_buffer_changed_p
, 0, 0, 0,
5680 "Return non-nil if the frame and buffer state appears to have changed.\n\
5681 The state variable is an internal vector containing all frames and buffers,\n\
5682 aside from buffers whose names start with space,\n\
5683 along with the buffers' read-only and modified flags, which allows a fast\n\
5684 check to see whether the menu bars might need to be recomputed.\n\
5685 If this function returns non-nil, it updates the internal vector to reflect\n\
5686 the current state.\n")
5689 Lisp_Object tail
, frame
, buf
;
5693 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5694 FOR_EACH_FRAME (tail
, frame
)
5696 if (!EQ (*vecp
++, frame
))
5698 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
5701 /* Check that the buffer info matches.
5702 No need to test for the end of the vector
5703 because the last element of the vector is lambda
5704 and that will always cause a mismatch. */
5705 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5707 buf
= XCDR (XCAR (tail
));
5708 /* Ignore buffers that aren't included in buffer lists. */
5709 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5711 if (!EQ (*vecp
++, buf
))
5713 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
5715 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
5718 /* Detect deletion of a buffer at the end of the list. */
5719 if (EQ (*vecp
, Qlambda
))
5722 /* Start with 1 so there is room for at least one lambda at the end. */
5724 FOR_EACH_FRAME (tail
, frame
)
5726 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5728 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
5729 if (n
> XVECTOR (frame_and_buffer_state
)->size
5730 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
5731 /* Add 20 extra so we grow it less often. */
5732 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
5733 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5734 FOR_EACH_FRAME (tail
, frame
)
5737 *vecp
++ = XFRAME (frame
)->name
;
5739 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5741 buf
= XCDR (XCAR (tail
));
5742 /* Ignore buffers that aren't included in buffer lists. */
5743 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5746 *vecp
++ = XBUFFER (buf
)->read_only
;
5747 *vecp
++ = Fbuffer_modified_p (buf
);
5749 /* Fill up the vector with lambdas (always at least one). */
5751 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5752 < XVECTOR (frame_and_buffer_state
)->size
)
5754 /* Make sure we didn't overflow the vector. */
5755 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5756 > XVECTOR (frame_and_buffer_state
)->size
)
5763 /***********************************************************************
5765 ***********************************************************************/
5767 char *terminal_type
;
5769 /* Initialization done when Emacs fork is started, before doing stty.
5770 Determine terminal type and set terminal_driver. Then invoke its
5771 decoding routine to set up variables in the terminal package. */
5776 #ifdef HAVE_X_WINDOWS
5777 extern int display_arg
;
5780 /* Construct the space glyph. */
5781 space_glyph
.type
= CHAR_GLYPH
;
5782 SET_CHAR_GLYPH_FROM_GLYPH (space_glyph
, ' ');
5783 space_glyph
.charpos
= -1;
5787 cursor_in_echo_area
= 0;
5788 terminal_type
= (char *) 0;
5790 /* Now is the time to initialize this; it's used by init_sys_modes
5792 Vwindow_system
= Qnil
;
5794 /* If the user wants to use a window system, we shouldn't bother
5795 initializing the terminal. This is especially important when the
5796 terminal is so dumb that emacs gives up before and doesn't bother
5797 using the window system.
5799 If the DISPLAY environment variable is set and nonempty,
5800 try to use X, and die with an error message if that doesn't work. */
5802 #ifdef HAVE_X_WINDOWS
5807 display
= getenv ("DECW$DISPLAY");
5809 display
= getenv ("DISPLAY");
5812 display_arg
= (display
!= 0 && *display
!= 0);
5815 if (!inhibit_window_system
&& display_arg
5821 Vwindow_system
= intern ("x");
5823 Vwindow_system_version
= make_number (11);
5825 Vwindow_system_version
= make_number (10);
5827 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
5828 /* In some versions of ncurses,
5829 tputs crashes if we have not called tgetent.
5831 { char b
[2044]; tgetent (b
, "xterm");}
5833 adjust_frame_glyphs_initially ();
5836 #endif /* HAVE_X_WINDOWS */
5839 if (!inhibit_window_system
)
5841 Vwindow_system
= intern ("w32");
5842 Vwindow_system_version
= make_number (1);
5843 adjust_frame_glyphs_initially ();
5846 #endif /* HAVE_NTGUI */
5848 /* If no window system has been specified, try to use the terminal. */
5851 fatal ("standard input is not a tty");
5855 /* Look at the TERM variable */
5856 terminal_type
= (char *) getenv ("TERM");
5860 fprintf (stderr
, "Please specify your terminal type.\n\
5861 For types defined in VMS, use set term /device=TYPE.\n\
5862 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
5863 \(The quotation marks are necessary since terminal types are lower case.)\n");
5865 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
5871 /* VMS DCL tends to up-case things, so down-case term type.
5872 Hardly any uppercase letters in terminal types; should be none. */
5874 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
5877 strcpy (new, terminal_type
);
5879 for (p
= new; *p
; p
++)
5883 terminal_type
= new;
5887 term_init (terminal_type
);
5890 struct frame
*sf
= SELECTED_FRAME ();
5891 int width
= FRAME_WINDOW_WIDTH (sf
);
5892 int height
= FRAME_HEIGHT (sf
);
5894 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (struct glyph
);
5896 /* If these sizes are so big they cause overflow, just ignore the
5897 change. It's not clear what better we could do. */
5898 if (total_glyphs
/ sizeof (struct glyph
) / height
!= width
+ 2)
5899 fatal ("screen size %dx%d too big", width
, height
);
5902 adjust_frame_glyphs_initially ();
5903 calculate_costs (XFRAME (selected_frame
));
5908 #endif /* CANNOT_DUMP */
5909 signal (SIGWINCH
, window_change_signal
);
5910 #endif /* SIGWINCH */
5912 /* Set up faces of the initial terminal frame of a dumped Emacs. */
5916 /* The MSDOS terminal turns on its ``window system'' relatively
5917 late into the startup, so we cannot do the frame faces'
5918 initialization just yet. It will be done later by pc-win.el
5919 and internal_terminal_init. */
5920 && (strcmp (terminal_type
, "internal") != 0 || inhibit_window_system
)
5922 && NILP (Vwindow_system
))
5924 /* For the initial frame, we don't have any way of knowing what
5925 are the foreground and background colors of the terminal. */
5926 struct frame
*sf
= SELECTED_FRAME();
5928 FRAME_FOREGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_FG_COLOR
;
5929 FRAME_BACKGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_BG_COLOR
;
5930 call0 (intern ("tty-set-up-initial-frame-faces"));
5936 /***********************************************************************
5938 ***********************************************************************/
5940 DEFUN ("internal-show-cursor", Finternal_show_cursor
,
5941 Sinternal_show_cursor
, 2, 2, 0,
5942 "Set the cursor-visibility flag of WINDOW to SHOW.\n\
5943 WINDOW nil means use the selected window. SHOW non-nil means\n\
5944 show a cursor in WINDOW in the next redisplay. SHOW nil means\n\
5945 don't show a cursor.")
5947 Lisp_Object window
, show
;
5949 /* Don't change cursor state while redisplaying. This could confuse
5951 if (!redisplaying_p
)
5954 window
= selected_window
;
5956 CHECK_WINDOW (window
, 2);
5958 XWINDOW (window
)->cursor_off_p
= NILP (show
);
5965 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p
,
5966 Sinternal_show_cursor_p
, 0, 1, 0,
5967 "Value is non-nil if next redisplay will display a cursor in WINDOW.\n\
5968 WINDOW nil or omitted means report on the selected window.")
5975 window
= selected_window
;
5977 CHECK_WINDOW (window
, 2);
5979 w
= XWINDOW (window
);
5980 return w
->cursor_off_p
? Qnil
: Qt
;
5984 /***********************************************************************
5986 ***********************************************************************/
5991 defsubr (&Sredraw_frame
);
5992 defsubr (&Sredraw_display
);
5993 defsubr (&Sframe_or_buffer_changed_p
);
5994 defsubr (&Sopen_termscript
);
5996 defsubr (&Ssit_for
);
5997 defsubr (&Ssleep_for
);
5998 defsubr (&Ssend_string_to_terminal
);
5999 defsubr (&Sinternal_show_cursor
);
6000 defsubr (&Sinternal_show_cursor_p
);
6002 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
6003 staticpro (&frame_and_buffer_state
);
6005 Qdisplay_table
= intern ("display-table");
6006 staticpro (&Qdisplay_table
);
6008 DEFVAR_INT ("baud-rate", &baud_rate
,
6009 "*The output baud rate of the terminal.\n\
6010 On most systems, changing this value will affect the amount of padding\n\
6011 and the other strategic decisions made during redisplay.");
6013 DEFVAR_BOOL ("inverse-video", &inverse_video
,
6014 "*Non-nil means invert the entire frame display.\n\
6015 This means everything is in inverse video which otherwise would not be.");
6017 DEFVAR_BOOL ("visible-bell", &visible_bell
,
6018 "*Non-nil means try to flash the frame to represent a bell.");
6020 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
6021 "*Non-nil means no need to redraw entire frame after suspending.\n\
6022 A non-nil value is useful if the terminal can automatically preserve\n\
6023 Emacs's frame display when you reenter Emacs.\n\
6024 It is up to you to set this variable if your terminal can do that.");
6026 DEFVAR_LISP ("window-system", &Vwindow_system
,
6027 "A symbol naming the window-system under which Emacs is running\n\
6028 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
6030 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
6031 "The version number of the window system in use.\n\
6032 For X windows, this is 10 or 11.");
6034 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
6035 "Non-nil means put cursor in minibuffer, at end of any message there.");
6037 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
6038 "Table defining how to output a glyph code to the frame.\n\
6039 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
6040 Each element can be:\n\
6041 integer: a glyph code which this glyph is an alias for.\n\
6042 string: output this glyph using that string (not impl. in X windows).\n\
6043 nil: this glyph mod 256 is char code to output,\n\
6044 and this glyph / 256 is face code for X windows (see `face-id').");
6045 Vglyph_table
= Qnil
;
6047 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
6048 "Display table to use for buffers that specify none.\n\
6049 See `buffer-display-table' for more information.");
6050 Vstandard_display_table
= Qnil
;
6052 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause
,
6053 "*Non-nil means update isn't paused when input is detected.");
6054 redisplay_dont_pause
= 0;
6056 /* Initialize `window-system', unless init_display already decided it. */
6061 Vwindow_system
= Qnil
;
6062 Vwindow_system_version
= Qnil
;