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
));
177 static void sync_window_with_frame_matrix_rows
P_ ((struct window
*));
178 struct window
*frame_row_to_window
P_ ((struct window
*, int));
182 /* Non-zero means don't pause redisplay for pending input. (This is
183 for debugging and for a future implementation of EDT-like
186 int redisplay_dont_pause
;
188 /* Nonzero upon entry to redisplay means do not assume anything about
189 current contents of actual terminal frame; clear and redraw it. */
193 /* Nonzero means last display completed. Zero means it was preempted. */
195 int display_completed
;
197 /* Lisp variable visible-bell; enables use of screen-flash instead of
202 /* Invert the color of the whole frame, at a low level. */
206 /* Line speed of the terminal. */
210 /* Either nil or a symbol naming the window system under which Emacs
213 Lisp_Object Vwindow_system
;
215 /* Version number of X windows: 10, 11 or nil. */
217 Lisp_Object Vwindow_system_version
;
219 /* Vector of glyph definitions. Indexed by glyph number, the contents
220 are a string which is how to output the glyph.
222 If Vglyph_table is nil, a glyph is output by using its low 8 bits
225 This is an obsolete feature that is no longer used. The variable
226 is retained for compatibility. */
228 Lisp_Object Vglyph_table
;
230 /* Display table to use for vectors that don't specify their own. */
232 Lisp_Object Vstandard_display_table
;
234 /* Nonzero means reading single-character input with prompt so put
235 cursor on mini-buffer after the prompt. positive means at end of
236 text in echo area; negative means at beginning of line. */
238 int cursor_in_echo_area
;
240 Lisp_Object Qdisplay_table
;
243 /* The currently selected frame. In a single-frame version, this
244 variable always equals the_only_frame. */
246 Lisp_Object selected_frame
;
248 /* A frame which is not just a mini-buffer, or 0 if there are no such
249 frames. This is usually the most recent such frame that was
250 selected. In a single-frame version, this variable always holds
251 the address of the_only_frame. */
253 struct frame
*last_nonminibuf_frame
;
255 /* Stdio stream being used for copy of all output. */
259 /* Structure for info on cursor positioning. */
263 /* 1 means SIGWINCH happened when not safe. */
265 int delayed_size_change
;
267 /* 1 means glyph initialization has been completed at startup. */
269 static int glyphs_initialized_initially_p
;
271 /* Updated window if != 0. Set by update_window. */
273 struct window
*updated_window
;
275 /* Glyph row updated in update_window_line, and area that is updated. */
277 struct glyph_row
*updated_row
;
280 /* A glyph for a space. */
282 struct glyph space_glyph
;
284 /* Non-zero means update has been performed directly, so that there's
285 no need for redisplay_internal to do much work. Set by
286 direct_output_for_insert. */
288 int redisplay_performed_directly_p
;
290 /* Counts of allocated structures. These counts serve to diagnose
291 memory leaks and double frees. */
293 int glyph_matrix_count
;
294 int glyph_pool_count
;
296 /* If non-null, the frame whose frame matrices are manipulated. If
297 null, window matrices are worked on. */
299 static struct frame
*frame_matrix_frame
;
301 /* Current interface for window-based redisplay. Set from init_xterm.
302 A null value means we are not using window-based redisplay. */
304 struct redisplay_interface
*rif
;
306 /* Non-zero means that fonts have been loaded since the last glyph
307 matrix adjustments. Redisplay must stop, and glyph matrices must
308 be adjusted when this flag becomes non-zero during display. The
309 reason fonts can be loaded so late is that fonts of fontsets are
314 /* Convert vpos and hpos from frame to window and vice versa.
315 This may only be used for terminal frames. */
319 static int window_to_frame_vpos
P_ ((struct window
*, int));
320 static int window_to_frame_hpos
P_ ((struct window
*, int));
321 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
322 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
324 #else /* GLYPH_DEBUG == 0 */
326 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + XFASTINT ((W)->top))
327 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + XFASTINT ((W)->left))
329 #endif /* GLYPH_DEBUG == 0 */
332 /* Like bcopy except never gets confused by overlap. Let this be the
333 first function defined in this file, or change emacs.c where the
334 address of this function is used. */
337 safe_bcopy (from
, to
, size
)
341 if (size
<= 0 || from
== to
)
344 /* If the source and destination don't overlap, then bcopy can
345 handle it. If they do overlap, but the destination is lower in
346 memory than the source, we'll assume bcopy can handle that. */
347 if (to
< from
|| from
+ size
<= to
)
348 bcopy (from
, to
, size
);
350 /* Otherwise, we'll copy from the end. */
353 register char *endf
= from
+ size
;
354 register char *endt
= to
+ size
;
356 /* If TO - FROM is large, then we should break the copy into
357 nonoverlapping chunks of TO - FROM bytes each. However, if
358 TO - FROM is small, then the bcopy function call overhead
359 makes this not worth it. The crossover point could be about
360 anywhere. Since I don't think the obvious copy loop is too
361 bad, I'm trying to err in its favor. */
366 while (endf
!= from
);
378 bcopy (endf
, endt
, to
- from
);
381 /* If SIZE wasn't a multiple of TO - FROM, there will be a
382 little left over. The amount left over is (endt + (to -
383 from)) - to, which is endt - from. */
384 bcopy (from
, to
, endt
- from
);
391 /***********************************************************************
393 ***********************************************************************/
395 /* Allocate and return a glyph_matrix structure. POOL is the glyph
396 pool from which memory for the matrix should be allocated, or null
397 for window-based redisplay where no glyph pools are used. The
398 member `pool' of the glyph matrix structure returned is set to
399 POOL, the structure is otherwise zeroed. */
401 struct glyph_matrix
*
402 new_glyph_matrix (pool
)
403 struct glyph_pool
*pool
;
405 struct glyph_matrix
*result
;
407 /* Allocate and clear. */
408 result
= (struct glyph_matrix
*) xmalloc (sizeof *result
);
409 bzero (result
, sizeof *result
);
411 /* Increment number of allocated matrices. This count is used
412 to detect memory leaks. */
413 ++glyph_matrix_count
;
415 /* Set pool and return. */
421 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
423 The global counter glyph_matrix_count is decremented when a matrix
424 is freed. If the count gets negative, more structures were freed
425 than allocated, i.e. one matrix was freed more than once or a bogus
426 pointer was passed to this function.
428 If MATRIX->pool is null, this means that the matrix manages its own
429 glyph memory---this is done for matrices on X frames. Freeing the
430 matrix also frees the glyph memory in this case. */
433 free_glyph_matrix (matrix
)
434 struct glyph_matrix
*matrix
;
440 /* Detect the case that more matrices are freed than were
442 if (--glyph_matrix_count
< 0)
445 /* Free glyph memory if MATRIX owns it. */
446 if (matrix
->pool
== NULL
)
447 for (i
= 0; i
< matrix
->rows_allocated
; ++i
)
448 xfree (matrix
->rows
[i
].glyphs
[LEFT_MARGIN_AREA
]);
450 /* Free row structures and the matrix itself. */
451 xfree (matrix
->rows
);
457 /* Return the number of glyphs to reserve for a marginal area of
458 window W. TOTAL_GLYPHS is the number of glyphs in a complete
459 display line of window W. MARGIN gives the width of the marginal
460 area in canonical character units. MARGIN should be an integer
464 margin_glyphs_to_reserve (w
, total_glyphs
, margin
)
471 if (NUMBERP (margin
))
473 int width
= XFASTINT (w
->width
);
474 double d
= max (0, XFLOATINT (margin
));
475 d
= min (width
/ 2 - 1, d
);
476 n
= (int) ((double) total_glyphs
/ width
* d
);
485 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
488 W is null if the function is called for a frame glyph matrix.
489 Otherwise it is the window MATRIX is a member of. X and Y are the
490 indices of the first column and row of MATRIX within the frame
491 matrix, if such a matrix exists. They are zero for purely
492 window-based redisplay. DIM is the needed size of the matrix.
494 In window-based redisplay, where no frame matrices exist, glyph
495 matrices manage their own glyph storage. Otherwise, they allocate
496 storage from a common frame glyph pool which can be found in
499 The reason for this memory management strategy is to avoid complete
500 frame redraws if possible. When we allocate from a common pool, a
501 change of the location or size of a sub-matrix within the pool
502 requires a complete redisplay of the frame because we cannot easily
503 make sure that the current matrices of all windows still agree with
504 what is displayed on the screen. While this is usually fast, it
505 leads to screen flickering. */
508 adjust_glyph_matrix (w
, matrix
, x
, y
, dim
)
510 struct glyph_matrix
*matrix
;
516 int marginal_areas_changed_p
= 0;
517 int header_line_changed_p
= 0;
518 int header_line_p
= 0;
519 int left
= -1, right
= -1;
520 int window_x
, window_y
, window_width
, window_height
;
522 /* See if W had a top line that has disappeared now, or vice versa. */
525 header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
526 header_line_changed_p
= header_line_p
!= matrix
->header_line_p
;
528 matrix
->header_line_p
= header_line_p
;
530 /* Do nothing if MATRIX' size, position, vscroll, and marginal areas
531 haven't changed. This optimization is important because preserving
532 the matrix means preventing redisplay. */
533 if (matrix
->pool
== NULL
)
535 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
536 left
= margin_glyphs_to_reserve (w
, dim
.width
, w
->left_margin_width
);
537 right
= margin_glyphs_to_reserve (w
, dim
.width
, w
->right_margin_width
);
538 xassert (left
>= 0 && right
>= 0);
539 marginal_areas_changed_p
= (left
!= matrix
->left_margin_glyphs
540 || right
!= matrix
->right_margin_glyphs
);
542 if (!marginal_areas_changed_p
544 && !header_line_changed_p
545 && matrix
->window_top_y
== XFASTINT (w
->top
)
546 && matrix
->window_height
== window_height
547 && matrix
->window_vscroll
== w
->vscroll
548 && matrix
->window_width
== window_width
)
552 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
553 if (matrix
->rows_allocated
< dim
.height
)
555 int size
= dim
.height
* sizeof (struct glyph_row
);
556 new_rows
= dim
.height
- matrix
->rows_allocated
;
557 matrix
->rows
= (struct glyph_row
*) xrealloc (matrix
->rows
, size
);
558 bzero (matrix
->rows
+ matrix
->rows_allocated
,
559 new_rows
* sizeof *matrix
->rows
);
560 matrix
->rows_allocated
= dim
.height
;
565 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
566 on a frame not using window-based redisplay. Set up pointers for
567 each row into the glyph pool. */
570 xassert (matrix
->pool
->glyphs
);
574 left
= margin_glyphs_to_reserve (w
, dim
.width
,
575 w
->left_margin_width
);
576 right
= margin_glyphs_to_reserve (w
, dim
.width
,
577 w
->right_margin_width
);
582 for (i
= 0; i
< dim
.height
; ++i
)
584 struct glyph_row
*row
= &matrix
->rows
[i
];
586 row
->glyphs
[LEFT_MARGIN_AREA
]
587 = (matrix
->pool
->glyphs
588 + (y
+ i
) * matrix
->pool
->ncolumns
592 || row
== matrix
->rows
+ dim
.height
- 1
593 || (row
== matrix
->rows
&& matrix
->header_line_p
))
595 row
->glyphs
[TEXT_AREA
]
596 = row
->glyphs
[LEFT_MARGIN_AREA
];
597 row
->glyphs
[RIGHT_MARGIN_AREA
]
598 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
599 row
->glyphs
[LAST_AREA
]
600 = row
->glyphs
[RIGHT_MARGIN_AREA
];
604 row
->glyphs
[TEXT_AREA
]
605 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
606 row
->glyphs
[RIGHT_MARGIN_AREA
]
607 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
608 row
->glyphs
[LAST_AREA
]
609 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
613 matrix
->left_margin_glyphs
= left
;
614 matrix
->right_margin_glyphs
= right
;
618 /* If MATRIX->pool is null, MATRIX is responsible for managing
619 its own memory. Allocate glyph memory from the heap. */
620 if (dim
.width
> matrix
->matrix_w
622 || header_line_changed_p
623 || marginal_areas_changed_p
)
625 struct glyph_row
*row
= matrix
->rows
;
626 struct glyph_row
*end
= row
+ matrix
->rows_allocated
;
630 row
->glyphs
[LEFT_MARGIN_AREA
]
631 = (struct glyph
*) xrealloc (row
->glyphs
[LEFT_MARGIN_AREA
],
633 * sizeof (struct glyph
)));
635 /* The mode line never has marginal areas. */
636 if (row
== matrix
->rows
+ dim
.height
- 1
637 || (row
== matrix
->rows
&& matrix
->header_line_p
))
639 row
->glyphs
[TEXT_AREA
]
640 = row
->glyphs
[LEFT_MARGIN_AREA
];
641 row
->glyphs
[RIGHT_MARGIN_AREA
]
642 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
643 row
->glyphs
[LAST_AREA
]
644 = row
->glyphs
[RIGHT_MARGIN_AREA
];
648 row
->glyphs
[TEXT_AREA
]
649 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
650 row
->glyphs
[RIGHT_MARGIN_AREA
]
651 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
652 row
->glyphs
[LAST_AREA
]
653 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
659 xassert (left
>= 0 && right
>= 0);
660 matrix
->left_margin_glyphs
= left
;
661 matrix
->right_margin_glyphs
= right
;
664 /* Number of rows to be used by MATRIX. */
665 matrix
->nrows
= dim
.height
;
667 /* Mark rows in a current matrix of a window as not having valid
668 contents. It's important to not do this for desired matrices.
669 When Emacs starts, it may already be building desired matrices
670 when this function runs. */
671 if (w
&& matrix
== w
->current_matrix
)
673 /* Optimize the case that only the height has changed (C-x 2,
674 upper window). Invalidate all rows that are no longer part
676 if (!marginal_areas_changed_p
677 && matrix
->window_top_y
== XFASTINT (w
->top
)
678 && matrix
->window_width
== window_width
)
681 while (matrix
->rows
[i
].enabled_p
682 && (MATRIX_ROW_BOTTOM_Y (matrix
->rows
+ i
)
683 < matrix
->window_height
))
686 /* Window end is invalid, if inside of the rows that
688 if (INTEGERP (w
->window_end_vpos
)
689 && XFASTINT (w
->window_end_vpos
) >= i
)
690 w
->window_end_valid
= Qnil
;
692 while (i
< matrix
->nrows
)
693 matrix
->rows
[i
++].enabled_p
= 0;
697 for (i
= 0; i
< matrix
->nrows
; ++i
)
698 matrix
->rows
[i
].enabled_p
= 0;
702 /* Remember last values to be able to optimize frame redraws. */
703 matrix
->matrix_x
= x
;
704 matrix
->matrix_y
= y
;
705 matrix
->matrix_w
= dim
.width
;
706 matrix
->matrix_h
= dim
.height
;
708 /* Record the top y location and height of W at the time the matrix
709 was last adjusted. This is used to optimize redisplay above. */
712 matrix
->window_top_y
= XFASTINT (w
->top
);
713 matrix
->window_height
= window_height
;
714 matrix
->window_width
= window_width
;
715 matrix
->window_vscroll
= w
->vscroll
;
720 /* Reverse the contents of rows in MATRIX between START and END. The
721 contents of the row at END - 1 end up at START, END - 2 at START +
722 1 etc. This is part of the implementation of rotate_matrix (see
726 reverse_rows (matrix
, start
, end
)
727 struct glyph_matrix
*matrix
;
732 for (i
= start
, j
= end
- 1; i
< j
; ++i
, --j
)
734 /* Non-ISO HP/UX compiler doesn't like auto struct
736 struct glyph_row temp
;
737 temp
= matrix
->rows
[i
];
738 matrix
->rows
[i
] = matrix
->rows
[j
];
739 matrix
->rows
[j
] = temp
;
744 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
745 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
746 indices. (Note: this does not copy glyphs, only glyph pointers in
747 row structures are moved around).
749 The algorithm used for rotating the vector was, I believe, first
750 described by Kernighan. See the vector R as consisting of two
751 sub-vectors AB, where A has length BY for BY >= 0. The result
752 after rotating is then BA. Reverse both sub-vectors to get ArBr
753 and reverse the result to get (ArBr)r which is BA. Similar for
757 rotate_matrix (matrix
, first
, last
, by
)
758 struct glyph_matrix
*matrix
;
763 /* Up (rotate left, i.e. towards lower indices). */
765 reverse_rows (matrix
, first
, first
+ by
);
766 reverse_rows (matrix
, first
+ by
, last
);
767 reverse_rows (matrix
, first
, last
);
771 /* Down (rotate right, i.e. towards higher indices). */
772 reverse_rows (matrix
, last
- by
, last
);
773 reverse_rows (matrix
, first
, last
- by
);
774 reverse_rows (matrix
, first
, last
);
779 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
780 with indices START <= index < END. Increment positions by DELTA/
784 increment_matrix_positions (matrix
, start
, end
, delta
, delta_bytes
)
785 struct glyph_matrix
*matrix
;
786 int start
, end
, delta
, delta_bytes
;
788 /* Check that START and END are reasonable values. */
789 xassert (start
>= 0 && start
<= matrix
->nrows
);
790 xassert (end
>= 0 && end
<= matrix
->nrows
);
791 xassert (start
<= end
);
793 for (; start
< end
; ++start
)
794 increment_row_positions (matrix
->rows
+ start
, delta
, delta_bytes
);
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_row_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_row_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 int c
= glyph
->u
.ch
;
1255 int face_id
= glyph
->face_id
;
1256 if (must_write_spaces
)
1258 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + c
;
1259 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + face_id
;
1272 /* Return the cost of drawing line VPOS In MATRIX. The cost equals
1273 the number of characters in the line. If must_write_spaces is
1274 zero, leading and trailing spaces are ignored. */
1277 line_draw_cost (matrix
, vpos
)
1278 struct glyph_matrix
*matrix
;
1281 struct glyph_row
*row
= matrix
->rows
+ vpos
;
1282 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
1283 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
];
1285 Lisp_Object
*glyph_table_base
= GLYPH_TABLE_BASE
;
1286 int glyph_table_len
= GLYPH_TABLE_LENGTH
;
1288 /* Ignore trailing and leading spaces if we can. */
1289 if (!must_write_spaces
)
1291 /* Skip from the end over trailing spaces. */
1292 while (end
!= beg
&& CHAR_GLYPH_SPACE_P (*end
))
1295 /* All blank line. */
1299 /* Skip over leading spaces. */
1300 while (CHAR_GLYPH_SPACE_P (*beg
))
1304 /* If we don't have a glyph-table, each glyph is one character,
1305 so return the number of glyphs. */
1306 if (glyph_table_base
== 0)
1310 /* Otherwise, scan the glyphs and accumulate their total length
1315 GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*beg
);
1318 || GLYPH_SIMPLE_P (glyph_table_base
, glyph_table_len
, g
))
1321 len
+= GLYPH_LENGTH (glyph_table_base
, g
);
1331 /* Test two glyph rows A and B for equality. Value is non-zero if A
1332 and B have equal contents. W is the window to which the glyphs
1333 rows A and B belong. It is needed here to test for partial row
1337 row_equal_p (w
, a
, b
)
1339 struct glyph_row
*a
, *b
;
1343 else if (a
->hash
!= b
->hash
)
1347 struct glyph
*a_glyph
, *b_glyph
, *a_end
;
1350 /* Compare glyphs. */
1351 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
1353 if (a
->used
[area
] != b
->used
[area
])
1356 a_glyph
= a
->glyphs
[area
];
1357 a_end
= a_glyph
+ a
->used
[area
];
1358 b_glyph
= b
->glyphs
[area
];
1360 while (a_glyph
< a_end
1361 && GLYPH_EQUAL_P (a_glyph
, b_glyph
))
1362 ++a_glyph
, ++b_glyph
;
1364 if (a_glyph
!= a_end
)
1368 if (a
->truncated_on_left_p
!= b
->truncated_on_left_p
1369 || a
->inverse_p
!= b
->inverse_p
1370 || a
->fill_line_p
!= b
->fill_line_p
1371 || a
->truncated_on_right_p
!= b
->truncated_on_right_p
1372 || a
->overlay_arrow_p
!= b
->overlay_arrow_p
1373 || a
->continued_p
!= b
->continued_p
1374 || a
->indicate_empty_line_p
!= b
->indicate_empty_line_p
1375 || a
->overlapped_p
!= b
->overlapped_p
1376 || (MATRIX_ROW_CONTINUATION_LINE_P (a
)
1377 != MATRIX_ROW_CONTINUATION_LINE_P (b
))
1378 /* Different partially visible characters on left margin. */
1380 /* Different height. */
1381 || a
->ascent
!= b
->ascent
1382 || a
->phys_ascent
!= b
->phys_ascent
1383 || a
->phys_height
!= b
->phys_height
1384 || a
->visible_height
!= b
->visible_height
)
1393 /***********************************************************************
1396 See dispextern.h for an overall explanation of glyph pools.
1397 ***********************************************************************/
1399 /* Allocate a glyph_pool structure. The structure returned is
1400 initialized with zeros. The global variable glyph_pool_count is
1401 incremented for each pool allocated. */
1403 static struct glyph_pool
*
1406 struct glyph_pool
*result
;
1408 /* Allocate a new glyph_pool and clear it. */
1409 result
= (struct glyph_pool
*) xmalloc (sizeof *result
);
1410 bzero (result
, sizeof *result
);
1412 /* For memory leak and double deletion checking. */
1419 /* Free a glyph_pool structure POOL. The function may be called with
1420 a null POOL pointer. The global variable glyph_pool_count is
1421 decremented with every pool structure freed. If this count gets
1422 negative, more structures were freed than allocated, i.e. one
1423 structure must have been freed more than once or a bogus pointer
1424 was passed to free_glyph_pool. */
1427 free_glyph_pool (pool
)
1428 struct glyph_pool
*pool
;
1432 /* More freed than allocated? */
1434 xassert (glyph_pool_count
>= 0);
1436 xfree (pool
->glyphs
);
1442 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1443 columns we need. This function never shrinks a pool. The only
1444 case in which this would make sense, would be when a frame's size
1445 is changed from a large value to a smaller one. But, if someone
1446 does it once, we can expect that he will do it again.
1448 Value is non-zero if the pool changed in a way which makes
1449 re-adjusting window glyph matrices necessary. */
1452 realloc_glyph_pool (pool
, matrix_dim
)
1453 struct glyph_pool
*pool
;
1454 struct dim matrix_dim
;
1459 changed_p
= (pool
->glyphs
== 0
1460 || matrix_dim
.height
!= pool
->nrows
1461 || matrix_dim
.width
!= pool
->ncolumns
);
1463 /* Enlarge the glyph pool. */
1464 needed
= matrix_dim
.width
* matrix_dim
.height
;
1465 if (needed
> pool
->nglyphs
)
1467 int size
= needed
* sizeof (struct glyph
);
1470 pool
->glyphs
= (struct glyph
*) xrealloc (pool
->glyphs
, size
);
1473 pool
->glyphs
= (struct glyph
*) xmalloc (size
);
1474 bzero (pool
->glyphs
, size
);
1477 pool
->nglyphs
= needed
;
1480 /* Remember the number of rows and columns because (a) we use then
1481 to do sanity checks, and (b) the number of columns determines
1482 where rows in the frame matrix start---this must be available to
1483 determine pointers to rows of window sub-matrices. */
1484 pool
->nrows
= matrix_dim
.height
;
1485 pool
->ncolumns
= matrix_dim
.width
;
1492 /***********************************************************************
1494 ***********************************************************************/
1499 /* Flush standard output. This is sometimes useful to call from
1509 /* Check that no glyph pointers have been lost in MATRIX. If a
1510 pointer has been lost, e.g. by using a structure assignment between
1511 rows, at least one pointer must occur more than once in the rows of
1515 check_matrix_pointer_lossage (matrix
)
1516 struct glyph_matrix
*matrix
;
1520 for (i
= 0; i
< matrix
->nrows
; ++i
)
1521 for (j
= 0; j
< matrix
->nrows
; ++j
)
1523 || (matrix
->rows
[i
].glyphs
[TEXT_AREA
]
1524 != matrix
->rows
[j
].glyphs
[TEXT_AREA
]));
1528 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1531 matrix_row (matrix
, row
)
1532 struct glyph_matrix
*matrix
;
1535 xassert (matrix
&& matrix
->rows
);
1536 xassert (row
>= 0 && row
< matrix
->nrows
);
1538 /* That's really too slow for normal testing because this function
1539 is called almost everywhere. Although---it's still astonishingly
1540 fast, so it is valuable to have for debugging purposes. */
1542 check_matrix_pointer_lossage (matrix
);
1545 return matrix
->rows
+ row
;
1549 #if 0 /* This function makes invalid assumptions when text is
1550 partially invisible. But it might come handy for debugging
1553 /* Check invariants that must hold for an up to date current matrix of
1557 check_matrix_invariants (w
)
1560 struct glyph_matrix
*matrix
= w
->current_matrix
;
1561 int yb
= window_text_bottom_y (w
);
1562 struct glyph_row
*row
= matrix
->rows
;
1563 struct glyph_row
*last_text_row
= NULL
;
1564 struct buffer
*saved
= current_buffer
;
1565 struct buffer
*buffer
= XBUFFER (w
->buffer
);
1568 /* This can sometimes happen for a fresh window. */
1569 if (matrix
->nrows
< 2)
1572 set_buffer_temp (buffer
);
1574 /* Note: last row is always reserved for the mode line. */
1575 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1576 && MATRIX_ROW_BOTTOM_Y (row
) < yb
)
1578 struct glyph_row
*next
= row
+ 1;
1580 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1581 last_text_row
= row
;
1583 /* Check that character and byte positions are in sync. */
1584 xassert (MATRIX_ROW_START_BYTEPOS (row
)
1585 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row
)));
1587 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1588 have such a position temporarily in case of a minibuffer
1589 displaying something like `[Sole completion]' at its end. */
1590 if (MATRIX_ROW_END_CHARPOS (row
) < BUF_ZV (current_buffer
))
1591 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1592 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row
)));
1594 /* Check that end position of `row' is equal to start position
1596 if (next
->enabled_p
&& MATRIX_ROW_DISPLAYS_TEXT_P (next
))
1598 xassert (MATRIX_ROW_END_CHARPOS (row
)
1599 == MATRIX_ROW_START_CHARPOS (next
));
1600 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1601 == MATRIX_ROW_START_BYTEPOS (next
));
1606 xassert (w
->current_matrix
->nrows
== w
->desired_matrix
->nrows
);
1607 xassert (w
->desired_matrix
->rows
!= NULL
);
1608 set_buffer_temp (saved
);
1613 #endif /* GLYPH_DEBUG != 0 */
1617 /**********************************************************************
1618 Allocating/ Adjusting Glyph Matrices
1619 **********************************************************************/
1621 /* Allocate glyph matrices over a window tree for a frame-based
1624 X and Y are column/row within the frame glyph matrix where
1625 sub-matrices for the window tree rooted at WINDOW must be
1626 allocated. CH_DIM contains the dimensions of the smallest
1627 character that could be used during display. DIM_ONLY_P non-zero
1628 means that the caller of this function is only interested in the
1629 result matrix dimension, and matrix adjustments should not be
1632 The function returns the total width/height of the sub-matrices of
1633 the window tree. If called on a frame root window, the computation
1634 will take the mini-buffer window into account.
1636 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1638 NEW_LEAF_MATRIX set if any window in the tree did not have a
1639 glyph matrices yet, and
1641 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1642 any window in the tree will be changed or have been changed (see
1645 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1648 Windows are arranged into chains of windows on the same level
1649 through the next fields of window structures. Such a level can be
1650 either a sequence of horizontally adjacent windows from left to
1651 right, or a sequence of vertically adjacent windows from top to
1652 bottom. Each window in a horizontal sequence can be either a leaf
1653 window or a vertical sequence; a window in a vertical sequence can
1654 be either a leaf or a horizontal sequence. All windows in a
1655 horizontal sequence have the same height, and all windows in a
1656 vertical sequence have the same width.
1658 This function uses, for historical reasons, a more general
1659 algorithm to determine glyph matrix dimensions that would be
1662 The matrix height of a horizontal sequence is determined by the
1663 maximum height of any matrix in the sequence. The matrix width of
1664 a horizontal sequence is computed by adding up matrix widths of
1665 windows in the sequence.
1667 |<------- result width ------->|
1668 +---------+----------+---------+ ---
1671 +---------+ | | result height
1676 The matrix width of a vertical sequence is the maximum matrix width
1677 of any window in the sequence. Its height is computed by adding up
1678 matrix heights of windows in the sequence.
1680 |<---- result width -->|
1688 +------------+---------+ |
1691 +------------+---------+ --- */
1693 /* Bit indicating that a new matrix will be allocated or has been
1696 #define NEW_LEAF_MATRIX (1 << 0)
1698 /* Bit indicating that a matrix will or has changed its location or
1701 #define CHANGED_LEAF_MATRIX (1 << 1)
1704 allocate_matrices_for_frame_redisplay (window
, x
, y
, ch_dim
,
1705 dim_only_p
, window_change_flags
)
1710 int *window_change_flags
;
1712 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1714 int wmax
= 0, hmax
= 0;
1718 int in_horz_combination_p
;
1720 /* What combination is WINDOW part of? Compute this once since the
1721 result is the same for all windows in the `next' chain. The
1722 special case of a root window (parent equal to nil) is treated
1723 like a vertical combination because a root window's `next'
1724 points to the mini-buffer window, if any, which is arranged
1725 vertically below other windows. */
1726 in_horz_combination_p
1727 = (!NILP (XWINDOW (window
)->parent
)
1728 && !NILP (XWINDOW (XWINDOW (window
)->parent
)->hchild
));
1730 /* For WINDOW and all windows on the same level. */
1733 w
= XWINDOW (window
);
1735 /* Get the dimension of the window sub-matrix for W, depending
1736 on whether this a combination or a leaf window. */
1737 if (!NILP (w
->hchild
))
1738 dim
= allocate_matrices_for_frame_redisplay (w
->hchild
, x
, y
, ch_dim
,
1740 window_change_flags
);
1741 else if (!NILP (w
->vchild
))
1742 dim
= allocate_matrices_for_frame_redisplay (w
->vchild
, x
, y
, ch_dim
,
1744 window_change_flags
);
1747 /* If not already done, allocate sub-matrix structures. */
1748 if (w
->desired_matrix
== NULL
)
1750 w
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1751 w
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1752 *window_change_flags
|= NEW_LEAF_MATRIX
;
1755 /* Width and height MUST be chosen so that there are no
1756 holes in the frame matrix. */
1757 dim
.width
= XINT (w
->width
);
1758 dim
.height
= XINT (w
->height
);
1760 /* Will matrix be re-allocated? */
1761 if (x
!= w
->desired_matrix
->matrix_x
1762 || y
!= w
->desired_matrix
->matrix_y
1763 || dim
.width
!= w
->desired_matrix
->matrix_w
1764 || dim
.height
!= w
->desired_matrix
->matrix_h
1765 || (margin_glyphs_to_reserve (w
, dim
.width
,
1766 w
->right_margin_width
)
1767 != w
->desired_matrix
->left_margin_glyphs
)
1768 || (margin_glyphs_to_reserve (w
, dim
.width
,
1769 w
->left_margin_width
)
1770 != w
->desired_matrix
->right_margin_glyphs
))
1771 *window_change_flags
|= CHANGED_LEAF_MATRIX
;
1773 /* Actually change matrices, if allowed. Do not consider
1774 CHANGED_LEAF_MATRIX computed above here because the pool
1775 may have been changed which we don't now here. We trust
1776 that we only will be called with DIM_ONLY_P != 0 when
1780 adjust_glyph_matrix (w
, w
->desired_matrix
, x
, y
, dim
);
1781 adjust_glyph_matrix (w
, w
->current_matrix
, x
, y
, dim
);
1785 /* If we are part of a horizontal combination, advance x for
1786 windows to the right of W; otherwise advance y for windows
1788 if (in_horz_combination_p
)
1793 /* Remember maximum glyph matrix dimensions. */
1794 wmax
= max (wmax
, dim
.width
);
1795 hmax
= max (hmax
, dim
.height
);
1797 /* Next window on same level. */
1800 while (!NILP (window
));
1802 /* Set `total' to the total glyph matrix dimension of this window
1803 level. In a vertical combination, the width is the width of the
1804 widest window; the height is the y we finally reached, corrected
1805 by the y we started with. In a horizontal combination, the total
1806 height is the height of the tallest window, and the width is the
1807 x we finally reached, corrected by the x we started with. */
1808 if (in_horz_combination_p
)
1810 total
.width
= x
- x0
;
1811 total
.height
= hmax
;
1816 total
.height
= y
- y0
;
1823 /* Allocate window matrices for window-based redisplay. W is the
1824 window whose matrices must be allocated/reallocated. CH_DIM is the
1825 size of the smallest character that could potentially be used on W. */
1828 allocate_matrices_for_window_redisplay (w
, ch_dim
)
1832 struct frame
*f
= XFRAME (w
->frame
);
1836 if (!NILP (w
->vchild
))
1837 allocate_matrices_for_window_redisplay (XWINDOW (w
->vchild
), ch_dim
);
1838 else if (!NILP (w
->hchild
))
1839 allocate_matrices_for_window_redisplay (XWINDOW (w
->hchild
), ch_dim
);
1842 /* W is a leaf window. */
1843 int window_pixel_width
= XFLOATINT (w
->width
) * CANON_X_UNIT (f
);
1844 int window_pixel_height
= window_box_height (w
) + abs (w
->vscroll
);
1847 /* If matrices are not yet allocated, allocate them now. */
1848 if (w
->desired_matrix
== NULL
)
1850 w
->desired_matrix
= new_glyph_matrix (NULL
);
1851 w
->current_matrix
= new_glyph_matrix (NULL
);
1854 /* Compute number of glyphs needed in a glyph row. */
1855 dim
.width
= (((window_pixel_width
+ ch_dim
.width
- 1)
1857 /* 2 partially visible columns in the text area. */
1859 /* One partially visible column at the right
1860 edge of each marginal area. */
1863 /* Compute number of glyph rows needed. */
1864 dim
.height
= (((window_pixel_height
+ ch_dim
.height
- 1)
1866 /* One partially visible line at the top and
1867 bottom of the window. */
1869 /* 2 for top and mode line. */
1872 /* Change matrices. */
1873 adjust_glyph_matrix (w
, w
->desired_matrix
, 0, 0, dim
);
1874 adjust_glyph_matrix (w
, w
->current_matrix
, 0, 0, dim
);
1877 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
1882 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
1883 do it for all frames; otherwise do it just for the given frame.
1884 This function must be called when a new frame is created, its size
1885 changes, or its window configuration changes. */
1891 /* Block input so that expose events and other events that access
1892 glyph matrices are not processed while we are changing them. */
1896 adjust_frame_glyphs (f
);
1899 Lisp_Object tail
, lisp_frame
;
1901 FOR_EACH_FRAME (tail
, lisp_frame
)
1902 adjust_frame_glyphs (XFRAME (lisp_frame
));
1909 /* Adjust frame glyphs when Emacs is initialized.
1911 To be called from init_display.
1913 We need a glyph matrix because redraw will happen soon.
1914 Unfortunately, window sizes on selected_frame are not yet set to
1915 meaningful values. I believe we can assume that there are only two
1916 windows on the frame---the mini-buffer and the root window. Frame
1917 height and width seem to be correct so far. So, set the sizes of
1918 windows to estimated values. */
1921 adjust_frame_glyphs_initially ()
1923 struct frame
*sf
= SELECTED_FRAME ();
1924 struct window
*root
= XWINDOW (sf
->root_window
);
1925 struct window
*mini
= XWINDOW (root
->next
);
1926 int frame_height
= FRAME_HEIGHT (sf
);
1927 int frame_width
= FRAME_WIDTH (sf
);
1928 int top_margin
= FRAME_TOP_MARGIN (sf
);
1930 /* Do it for the root window. */
1931 XSETFASTINT (root
->top
, top_margin
);
1932 XSETFASTINT (root
->width
, frame_width
);
1933 set_window_height (sf
->root_window
, frame_height
- 1 - top_margin
, 0);
1935 /* Do it for the mini-buffer window. */
1936 XSETFASTINT (mini
->top
, frame_height
- 1);
1937 XSETFASTINT (mini
->width
, frame_width
);
1938 set_window_height (root
->next
, 1, 0);
1940 adjust_frame_glyphs (sf
);
1941 glyphs_initialized_initially_p
= 1;
1945 /* Allocate/reallocate glyph matrices of a single frame F. */
1948 adjust_frame_glyphs (f
)
1951 if (FRAME_WINDOW_P (f
))
1952 adjust_frame_glyphs_for_window_redisplay (f
);
1954 adjust_frame_glyphs_for_frame_redisplay (f
);
1956 /* Don't forget the message buffer and the buffer for
1957 decode_mode_spec. */
1958 adjust_frame_message_buffer (f
);
1959 adjust_decode_mode_spec_buffer (f
);
1961 f
->glyphs_initialized_p
= 1;
1965 /* Allocate/reallocate glyph matrices of a single frame F for
1966 frame-based redisplay. */
1969 adjust_frame_glyphs_for_frame_redisplay (f
)
1973 struct dim matrix_dim
;
1975 int window_change_flags
;
1978 if (!FRAME_LIVE_P (f
))
1981 /* Determine the smallest character in any font for F. On
1982 console windows, all characters have dimension (1, 1). */
1983 ch_dim
.width
= ch_dim
.height
= 1;
1985 top_window_y
= FRAME_TOP_MARGIN (f
);
1987 /* Allocate glyph pool structures if not already done. */
1988 if (f
->desired_pool
== NULL
)
1990 f
->desired_pool
= new_glyph_pool ();
1991 f
->current_pool
= new_glyph_pool ();
1994 /* Allocate frames matrix structures if needed. */
1995 if (f
->desired_matrix
== NULL
)
1997 f
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1998 f
->current_matrix
= new_glyph_matrix (f
->current_pool
);
2001 /* Compute window glyph matrices. (This takes the mini-buffer
2002 window into account). The result is the size of the frame glyph
2003 matrix needed. The variable window_change_flags is set to a bit
2004 mask indicating whether new matrices will be allocated or
2005 existing matrices change their size or location within the frame
2007 window_change_flags
= 0;
2009 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2012 &window_change_flags
);
2014 /* Add in menu bar lines, if any. */
2015 matrix_dim
.height
+= top_window_y
;
2017 /* Enlarge pools as necessary. */
2018 pool_changed_p
= realloc_glyph_pool (f
->desired_pool
, matrix_dim
);
2019 realloc_glyph_pool (f
->current_pool
, matrix_dim
);
2021 /* Set up glyph pointers within window matrices. Do this only if
2022 absolutely necessary since it requires a frame redraw. */
2023 if (pool_changed_p
|| window_change_flags
)
2025 /* Do it for window matrices. */
2026 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2027 0, top_window_y
, ch_dim
, 0,
2028 &window_change_flags
);
2030 /* Size of frame matrices must equal size of frame. Note
2031 that we are called for X frames with window widths NOT equal
2032 to the frame width (from CHANGE_FRAME_SIZE_1). */
2033 xassert (matrix_dim
.width
== FRAME_WIDTH (f
)
2034 && matrix_dim
.height
== FRAME_HEIGHT (f
));
2036 /* Resize frame matrices. */
2037 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2038 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2040 /* Since location and size of sub-matrices within the pool may
2041 have changed, and current matrices don't have meaningful
2042 contents anymore, mark the frame garbaged. */
2043 SET_FRAME_GARBAGED (f
);
2048 /* Allocate/reallocate glyph matrices of a single frame F for
2049 window-based redisplay. */
2052 adjust_frame_glyphs_for_window_redisplay (f
)
2058 xassert (FRAME_WINDOW_P (f
) && FRAME_LIVE_P (f
));
2060 /* Get minimum sizes. */
2061 #ifdef HAVE_WINDOW_SYSTEM
2062 ch_dim
.width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2063 ch_dim
.height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
2065 ch_dim
.width
= ch_dim
.height
= 1;
2068 /* Allocate/reallocate window matrices. */
2069 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f
)),
2072 /* Allocate/ reallocate matrices of the dummy window used to display
2073 the menu bar under X when no X toolkit support is available. */
2074 #ifndef USE_X_TOOLKIT
2076 /* Allocate a dummy window if not already done. */
2077 if (NILP (f
->menu_bar_window
))
2079 f
->menu_bar_window
= make_window ();
2080 w
= XWINDOW (f
->menu_bar_window
);
2081 XSETFRAME (w
->frame
, f
);
2082 w
->pseudo_window_p
= 1;
2085 w
= XWINDOW (f
->menu_bar_window
);
2087 /* Set window dimensions to frame dimensions and allocate or
2088 adjust glyph matrices of W. */
2089 XSETFASTINT (w
->top
, 0);
2090 XSETFASTINT (w
->left
, 0);
2091 XSETFASTINT (w
->height
, FRAME_MENU_BAR_LINES (f
));
2092 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2093 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2095 #endif /* not USE_X_TOOLKIT */
2097 /* Allocate/ reallocate matrices of the tool bar window. If we
2098 don't have a tool bar window yet, make one. */
2099 if (NILP (f
->tool_bar_window
))
2101 f
->tool_bar_window
= make_window ();
2102 w
= XWINDOW (f
->tool_bar_window
);
2103 XSETFRAME (w
->frame
, f
);
2104 w
->pseudo_window_p
= 1;
2107 w
= XWINDOW (f
->tool_bar_window
);
2109 XSETFASTINT (w
->top
, FRAME_MENU_BAR_LINES (f
));
2110 XSETFASTINT (w
->left
, 0);
2111 XSETFASTINT (w
->height
, FRAME_TOOL_BAR_LINES (f
));
2112 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2113 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2117 /* Adjust/ allocate message buffer of frame F.
2119 Note that the message buffer is never freed. Since I could not
2120 find a free in 19.34, I assume that freeing it would be
2121 problematic in some way and don't do it either.
2123 (Implementation note: It should be checked if we can free it
2124 eventually without causing trouble). */
2127 adjust_frame_message_buffer (f
)
2130 int size
= FRAME_MESSAGE_BUF_SIZE (f
) + 1;
2132 if (FRAME_MESSAGE_BUF (f
))
2134 char *buffer
= FRAME_MESSAGE_BUF (f
);
2135 char *new_buffer
= (char *) xrealloc (buffer
, size
);
2136 FRAME_MESSAGE_BUF (f
) = new_buffer
;
2139 FRAME_MESSAGE_BUF (f
) = (char *) xmalloc (size
);
2143 /* Re-allocate buffer for decode_mode_spec on frame F. */
2146 adjust_decode_mode_spec_buffer (f
)
2149 f
->decode_mode_spec_buffer
2150 = (char *) xrealloc (f
->decode_mode_spec_buffer
,
2151 FRAME_MESSAGE_BUF_SIZE (f
) + 1);
2156 /**********************************************************************
2157 Freeing Glyph Matrices
2158 **********************************************************************/
2160 /* Free glyph memory for a frame F. F may be null. This function can
2161 be called for the same frame more than once. The root window of
2162 F may be nil when this function is called. This is the case when
2163 the function is called when F is destroyed. */
2169 if (f
&& f
->glyphs_initialized_p
)
2171 /* Block interrupt input so that we don't get surprised by an X
2172 event while we're in an inconsistent state. */
2174 f
->glyphs_initialized_p
= 0;
2176 /* Release window sub-matrices. */
2177 if (!NILP (f
->root_window
))
2178 free_window_matrices (XWINDOW (f
->root_window
));
2180 /* Free the dummy window for menu bars without X toolkit and its
2182 if (!NILP (f
->menu_bar_window
))
2184 struct window
*w
= XWINDOW (f
->menu_bar_window
);
2185 free_glyph_matrix (w
->desired_matrix
);
2186 free_glyph_matrix (w
->current_matrix
);
2187 w
->desired_matrix
= w
->current_matrix
= NULL
;
2188 f
->menu_bar_window
= Qnil
;
2191 /* Free the tool bar window and its glyph matrices. */
2192 if (!NILP (f
->tool_bar_window
))
2194 struct window
*w
= XWINDOW (f
->tool_bar_window
);
2195 free_glyph_matrix (w
->desired_matrix
);
2196 free_glyph_matrix (w
->current_matrix
);
2197 w
->desired_matrix
= w
->current_matrix
= NULL
;
2198 f
->tool_bar_window
= Qnil
;
2201 /* Release frame glyph matrices. Reset fields to zero in
2202 case we are called a second time. */
2203 if (f
->desired_matrix
)
2205 free_glyph_matrix (f
->desired_matrix
);
2206 free_glyph_matrix (f
->current_matrix
);
2207 f
->desired_matrix
= f
->current_matrix
= NULL
;
2210 /* Release glyph pools. */
2211 if (f
->desired_pool
)
2213 free_glyph_pool (f
->desired_pool
);
2214 free_glyph_pool (f
->current_pool
);
2215 f
->desired_pool
= f
->current_pool
= NULL
;
2223 /* Free glyph sub-matrices in the window tree rooted at W. This
2224 function may be called with a null pointer, and it may be called on
2225 the same tree more than once. */
2228 free_window_matrices (w
)
2233 if (!NILP (w
->hchild
))
2234 free_window_matrices (XWINDOW (w
->hchild
));
2235 else if (!NILP (w
->vchild
))
2236 free_window_matrices (XWINDOW (w
->vchild
));
2239 /* This is a leaf window. Free its memory and reset fields
2240 to zero in case this function is called a second time for
2242 free_glyph_matrix (w
->current_matrix
);
2243 free_glyph_matrix (w
->desired_matrix
);
2244 w
->current_matrix
= w
->desired_matrix
= NULL
;
2247 /* Next window on same level. */
2248 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2253 /* Check glyph memory leaks. This function is called from
2254 shut_down_emacs. Note that frames are not destroyed when Emacs
2255 exits. We therefore free all glyph memory for all active frames
2256 explicitly and check that nothing is left allocated. */
2259 check_glyph_memory ()
2261 Lisp_Object tail
, frame
;
2263 /* Free glyph memory for all frames. */
2264 FOR_EACH_FRAME (tail
, frame
)
2265 free_glyphs (XFRAME (frame
));
2267 /* Check that nothing is left allocated. */
2268 if (glyph_matrix_count
)
2270 if (glyph_pool_count
)
2276 /**********************************************************************
2277 Building a Frame Matrix
2278 **********************************************************************/
2280 /* Most of the redisplay code works on glyph matrices attached to
2281 windows. This is a good solution most of the time, but it is not
2282 suitable for terminal code. Terminal output functions cannot rely
2283 on being able to set an arbitrary terminal window. Instead they
2284 must be provided with a view of the whole frame, i.e. the whole
2285 screen. We build such a view by constructing a frame matrix from
2286 window matrices in this section.
2288 Windows that must be updated have their must_be_update_p flag set.
2289 For all such windows, their desired matrix is made part of the
2290 desired frame matrix. For other windows, their current matrix is
2291 made part of the desired frame matrix.
2293 +-----------------+----------------+
2294 | desired | desired |
2296 +-----------------+----------------+
2299 +----------------------------------+
2301 Desired window matrices can be made part of the frame matrix in a
2302 cheap way: We exploit the fact that the desired frame matrix and
2303 desired window matrices share their glyph memory. This is not
2304 possible for current window matrices. Their glyphs are copied to
2305 the desired frame matrix. The latter is equivalent to
2306 preserve_other_columns in the old redisplay.
2308 Used glyphs counters for frame matrix rows are the result of adding
2309 up glyph lengths of the window matrices. A line in the frame
2310 matrix is enabled, if a corresponding line in a window matrix is
2313 After building the desired frame matrix, it will be passed to
2314 terminal code, which will manipulate both the desired and current
2315 frame matrix. Changes applied to the frame's current matrix have
2316 to be visible in current window matrices afterwards, of course.
2318 This problem is solved like this:
2320 1. Window and frame matrices share glyphs. Window matrices are
2321 constructed in a way that their glyph contents ARE the glyph
2322 contents needed in a frame matrix. Thus, any modification of
2323 glyphs done in terminal code will be reflected in window matrices
2326 2. Exchanges of rows in a frame matrix done by terminal code are
2327 intercepted by hook functions so that corresponding row operations
2328 on window matrices can be performed. This is necessary because we
2329 use pointers to glyphs in glyph row structures. To satisfy the
2330 assumption of point 1 above that glyphs are updated implicitly in
2331 window matrices when they are manipulated via the frame matrix,
2332 window and frame matrix must of course agree where to find the
2333 glyphs for their rows. Possible manipulations that must be
2334 mirrored are assignments of rows of the desired frame matrix to the
2335 current frame matrix and scrolling the current frame matrix. */
2337 /* Build frame F's desired matrix from window matrices. Only windows
2338 which have the flag must_be_updated_p set have to be updated. Menu
2339 bar lines of a frame are not covered by window matrices, so make
2340 sure not to touch them in this function. */
2343 build_frame_matrix (f
)
2348 /* F must have a frame matrix when this function is called. */
2349 xassert (!FRAME_WINDOW_P (f
));
2351 /* Clear all rows in the frame matrix covered by window matrices.
2352 Menu bar lines are not covered by windows. */
2353 for (i
= FRAME_TOP_MARGIN (f
); i
< f
->desired_matrix
->nrows
; ++i
)
2354 clear_glyph_row (MATRIX_ROW (f
->desired_matrix
, i
));
2356 /* Build the matrix by walking the window tree. */
2357 build_frame_matrix_from_window_tree (f
->desired_matrix
,
2358 XWINDOW (FRAME_ROOT_WINDOW (f
)));
2362 /* Walk a window tree, building a frame matrix MATRIX from window
2363 matrices. W is the root of a window tree. */
2366 build_frame_matrix_from_window_tree (matrix
, w
)
2367 struct glyph_matrix
*matrix
;
2372 if (!NILP (w
->hchild
))
2373 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->hchild
));
2374 else if (!NILP (w
->vchild
))
2375 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->vchild
));
2377 build_frame_matrix_from_leaf_window (matrix
, w
);
2379 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2384 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2385 desired frame matrix built. W is a leaf window whose desired or
2386 current matrix is to be added to FRAME_MATRIX. W's flag
2387 must_be_updated_p determines which matrix it contributes to
2388 FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix
2389 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2390 Adding a desired matrix means setting up used counters and such in
2391 frame rows, while adding a current window matrix to FRAME_MATRIX
2392 means copying glyphs. The latter case corresponds to
2393 preserve_other_columns in the old redisplay. */
2396 build_frame_matrix_from_leaf_window (frame_matrix
, w
)
2397 struct glyph_matrix
*frame_matrix
;
2400 struct glyph_matrix
*window_matrix
;
2401 int window_y
, frame_y
;
2402 /* If non-zero, a glyph to insert at the right border of W. */
2403 GLYPH right_border_glyph
= 0;
2405 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2406 if (w
->must_be_updated_p
)
2408 window_matrix
= w
->desired_matrix
;
2410 /* Decide whether we want to add a vertical border glyph. */
2411 if (!WINDOW_RIGHTMOST_P (w
))
2413 struct Lisp_Char_Table
*dp
= window_display_table (w
);
2414 right_border_glyph
= (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
2415 ? XINT (DISP_BORDER_GLYPH (dp
))
2420 window_matrix
= w
->current_matrix
;
2422 /* For all rows in the window matrix and corresponding rows in the
2425 frame_y
= window_matrix
->matrix_y
;
2426 while (window_y
< window_matrix
->nrows
)
2428 struct glyph_row
*frame_row
= frame_matrix
->rows
+ frame_y
;
2429 struct glyph_row
*window_row
= window_matrix
->rows
+ window_y
;
2431 /* Fill up the frame row with spaces up to the left margin of the
2433 fill_up_frame_row_with_spaces (frame_row
, window_matrix
->matrix_x
);
2435 /* Fill up areas in the window matrix row with spaces. */
2436 fill_up_glyph_row_with_spaces (window_row
);
2438 if (window_matrix
== w
->current_matrix
)
2440 /* We have to copy W's current matrix. Copy window
2441 row to frame row. */
2442 bcopy (window_row
->glyphs
[0],
2443 frame_row
->glyphs
[TEXT_AREA
] + window_matrix
->matrix_x
,
2444 window_matrix
->matrix_w
* sizeof (struct glyph
));
2448 /* Copy W's desired matrix. */
2450 /* Maybe insert a vertical border between horizontally adjacent
2452 if (right_border_glyph
)
2454 struct glyph
*border
= window_row
->glyphs
[LAST_AREA
] - 1;
2455 SET_CHAR_GLYPH_FROM_GLYPH (*border
, right_border_glyph
);
2458 #if 0 /* This shouldn't be necessary. Let's check it. */
2459 /* Due to hooks installed, it normally doesn't happen that
2460 window rows and frame rows of the same matrix are out of
2461 sync, i.e. have a different understanding of where to
2462 find glyphs for the row. The following is a safety-belt
2463 that doesn't cost much and makes absolutely sure that
2464 window and frame matrices are in sync. */
2465 if (!glyph_row_slice_p (window_row
, frame_row
))
2467 /* Find the row in the window being a slice. There
2468 should exist one from program logic. */
2469 struct glyph_row
*slice_row
2470 = find_glyph_row_slice (window_matrix
, frame_matrix
, frame_y
);
2471 xassert (slice_row
!= 0);
2473 /* Exchange glyphs between both window rows. */
2474 swap_glyphs_in_rows (window_row
, slice_row
);
2476 /* Exchange pointers between both rows. */
2477 swap_glyph_pointers (window_row
, slice_row
);
2481 /* Window row window_y must be a slice of frame row
2483 xassert (glyph_row_slice_p (window_row
, frame_row
));
2485 /* If rows are in sync, we don't have to copy glyphs because
2486 frame and window share glyphs. */
2489 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
2493 /* Set number of used glyphs in the frame matrix. Since we fill
2494 up with spaces, and visit leaf windows from left to right it
2495 can be done simply. */
2496 frame_row
->used
[TEXT_AREA
]
2497 = window_matrix
->matrix_x
+ window_matrix
->matrix_w
;
2500 frame_row
->enabled_p
|= window_row
->enabled_p
;
2501 frame_row
->inverse_p
|= window_row
->inverse_p
;
2510 /* Add spaces to a glyph row ROW in a window matrix.
2512 Each row has the form:
2514 +---------+-----------------------------+------------+
2515 | left | text | right |
2516 +---------+-----------------------------+------------+
2518 Left and right marginal areas are optional. This function adds
2519 spaces to areas so that there are no empty holes between areas.
2520 In other words: If the right area is not empty, the text area
2521 is filled up with spaces up to the right area. If the text area
2522 is not empty, the left area is filled up.
2524 To be called for frame-based redisplay, only. */
2527 fill_up_glyph_row_with_spaces (row
)
2528 struct glyph_row
*row
;
2530 fill_up_glyph_row_area_with_spaces (row
, LEFT_MARGIN_AREA
);
2531 fill_up_glyph_row_area_with_spaces (row
, TEXT_AREA
);
2532 fill_up_glyph_row_area_with_spaces (row
, RIGHT_MARGIN_AREA
);
2536 /* Fill area AREA of glyph row ROW with spaces. To be called for
2537 frame-based redisplay only. */
2540 fill_up_glyph_row_area_with_spaces (row
, area
)
2541 struct glyph_row
*row
;
2544 if (row
->glyphs
[area
] < row
->glyphs
[area
+ 1])
2546 struct glyph
*end
= row
->glyphs
[area
+ 1];
2547 struct glyph
*text
= row
->glyphs
[area
] + row
->used
[area
];
2550 *text
++ = space_glyph
;
2551 row
->used
[area
] = text
- row
->glyphs
[area
];
2556 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2557 reached. In frame matrices only one area, TEXT_AREA, is used. */
2560 fill_up_frame_row_with_spaces (row
, upto
)
2561 struct glyph_row
*row
;
2564 int i
= row
->used
[TEXT_AREA
];
2565 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
2568 glyph
[i
++] = space_glyph
;
2570 row
->used
[TEXT_AREA
] = i
;
2575 /**********************************************************************
2576 Mirroring operations on frame matrices in window matrices
2577 **********************************************************************/
2579 /* Set frame being updated via frame-based redisplay to F. This
2580 function must be called before updates to make explicit that we are
2581 working on frame matrices or not. */
2584 set_frame_matrix_frame (f
)
2587 frame_matrix_frame
= f
;
2591 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2592 DESIRED_MATRIX is the desired matrix corresponding to
2593 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2594 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2595 frame_matrix_frame is non-null, this indicates that the exchange is
2596 done in frame matrices, and that we have to perform analogous
2597 operations in window matrices of frame_matrix_frame. */
2600 make_current (desired_matrix
, current_matrix
, row
)
2601 struct glyph_matrix
*desired_matrix
, *current_matrix
;
2604 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, row
);
2605 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, row
);
2607 /* Do current_row = desired_row. This exchanges glyph pointers
2608 between both rows, and does a structure assignment otherwise. */
2609 assign_row (current_row
, desired_row
);
2611 /* Enable current_row to mark it as valid. */
2612 current_row
->enabled_p
= 1;
2614 /* If we are called on frame matrices, perform analogous operations
2615 for window matrices. */
2616 if (frame_matrix_frame
)
2617 mirror_make_current (XWINDOW (frame_matrix_frame
->root_window
), row
);
2621 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2622 W's frame which has been made current (by swapping pointers between
2623 current and desired matrix). Perform analogous operations in the
2624 matrices of leaf windows in the window tree rooted at W. */
2627 mirror_make_current (w
, frame_row
)
2633 if (!NILP (w
->hchild
))
2634 mirror_make_current (XWINDOW (w
->hchild
), frame_row
);
2635 else if (!NILP (w
->vchild
))
2636 mirror_make_current (XWINDOW (w
->vchild
), frame_row
);
2639 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2640 here because the checks performed in debug mode there
2641 will not allow the conversion. */
2642 int row
= frame_row
- w
->desired_matrix
->matrix_y
;
2644 /* If FRAME_ROW is within W, assign the desired row to the
2645 current row (exchanging glyph pointers). */
2646 if (row
>= 0 && row
< w
->desired_matrix
->matrix_h
)
2648 struct glyph_row
*current_row
2649 = MATRIX_ROW (w
->current_matrix
, row
);
2650 struct glyph_row
*desired_row
2651 = MATRIX_ROW (w
->desired_matrix
, row
);
2653 if (desired_row
->enabled_p
)
2654 assign_row (current_row
, desired_row
);
2656 swap_glyph_pointers (desired_row
, current_row
);
2657 current_row
->enabled_p
= 1;
2661 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2666 /* Perform row dance after scrolling. We are working on the range of
2667 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2668 including) in MATRIX. COPY_FROM is a vector containing, for each
2669 row I in the range 0 <= I < NLINES, the index of the original line
2670 to move to I. This index is relative to the row range, i.e. 0 <=
2671 index < NLINES. RETAINED_P is a vector containing zero for each
2672 row 0 <= I < NLINES which is empty.
2674 This function is called from do_scrolling and do_direct_scrolling. */
2677 mirrored_line_dance (matrix
, unchanged_at_top
, nlines
, copy_from
,
2679 struct glyph_matrix
*matrix
;
2680 int unchanged_at_top
, nlines
;
2684 /* A copy of original rows. */
2685 struct glyph_row
*old_rows
;
2687 /* Rows to assign to. */
2688 struct glyph_row
*new_rows
= MATRIX_ROW (matrix
, unchanged_at_top
);
2692 /* Make a copy of the original rows. */
2693 old_rows
= (struct glyph_row
*) alloca (nlines
* sizeof *old_rows
);
2694 bcopy (new_rows
, old_rows
, nlines
* sizeof *old_rows
);
2696 /* Assign new rows, maybe clear lines. */
2697 for (i
= 0; i
< nlines
; ++i
)
2699 int enabled_before_p
= new_rows
[i
].enabled_p
;
2701 xassert (i
+ unchanged_at_top
< matrix
->nrows
);
2702 xassert (unchanged_at_top
+ copy_from
[i
] < matrix
->nrows
);
2703 new_rows
[i
] = old_rows
[copy_from
[i
]];
2704 new_rows
[i
].enabled_p
= enabled_before_p
;
2706 /* RETAINED_P is zero for empty lines. */
2707 if (!retained_p
[copy_from
[i
]])
2708 new_rows
[i
].enabled_p
= 0;
2711 /* Do the same for window matrices, if MATRIX Is a frame matrix. */
2712 if (frame_matrix_frame
)
2713 mirror_line_dance (XWINDOW (frame_matrix_frame
->root_window
),
2714 unchanged_at_top
, nlines
, copy_from
, retained_p
);
2718 /* Synchronize glyph pointers in the current matrix of window W with
2719 the current frame matrix. W must be full-width, and be on a tty
2723 sync_window_with_frame_matrix_rows (w
)
2726 struct frame
*f
= XFRAME (w
->frame
);
2727 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
2729 /* Preconditions: W must be a leaf window and full-width. Its frame
2730 must have a frame matrix. */
2731 xassert (NILP (w
->hchild
) && NILP (w
->vchild
));
2732 xassert (WINDOW_FULL_WIDTH_P (w
));
2733 xassert (!FRAME_WINDOW_P (f
));
2735 /* If W is a full-width window, glyph pointers in W's current matrix
2736 have, by definition, to be the same as glyph pointers in the
2737 corresponding frame matrix. */
2738 window_row
= w
->current_matrix
->rows
;
2739 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
2740 frame_row
= f
->current_matrix
->rows
+ XFASTINT (w
->top
);
2741 while (window_row
< window_row_end
)
2745 for (area
= LEFT_MARGIN_AREA
; area
<= LAST_AREA
; ++area
)
2746 window_row
->glyphs
[area
] = frame_row
->glyphs
[area
];
2748 ++window_row
, ++frame_row
;
2753 /* Return the window in the window tree rooted in W containing frame
2754 row ROW. Value is null if none is found. */
2757 frame_row_to_window (w
, row
)
2761 struct window
*found
= NULL
;
2765 if (!NILP (w
->hchild
))
2766 found
= frame_row_to_window (XWINDOW (w
->hchild
), row
);
2767 else if (!NILP (w
->vchild
))
2768 found
= frame_row_to_window (XWINDOW (w
->vchild
), row
);
2769 else if (row
>= XFASTINT (w
->top
)
2770 && row
< XFASTINT (w
->top
) + XFASTINT (w
->height
))
2773 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2780 /* Perform a line dance in the window tree rooted at W, after
2781 scrolling a frame matrix in mirrored_line_dance.
2783 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
2784 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
2785 COPY_FROM is a vector containing, for each row I in the range 0 <=
2786 I < NLINES, the index of the original line to move to I. This
2787 index is relative to the row range, i.e. 0 <= index < NLINES.
2788 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
2792 mirror_line_dance (w
, unchanged_at_top
, nlines
, copy_from
, retained_p
)
2794 int unchanged_at_top
, nlines
;
2800 if (!NILP (w
->hchild
))
2801 mirror_line_dance (XWINDOW (w
->hchild
), unchanged_at_top
,
2802 nlines
, copy_from
, retained_p
);
2803 else if (!NILP (w
->vchild
))
2804 mirror_line_dance (XWINDOW (w
->vchild
), unchanged_at_top
,
2805 nlines
, copy_from
, retained_p
);
2808 /* W is a leaf window, and we are working on its current
2810 struct glyph_matrix
*m
= w
->current_matrix
;
2812 struct glyph_row
*old_rows
;
2814 /* Make a copy of the original rows of matrix m. */
2815 old_rows
= (struct glyph_row
*) alloca (m
->nrows
* sizeof *old_rows
);
2816 bcopy (m
->rows
, old_rows
, m
->nrows
* sizeof *old_rows
);
2818 for (i
= 0; i
< nlines
; ++i
)
2820 /* Frame relative line assigned to. */
2821 int frame_to
= i
+ unchanged_at_top
;
2823 /* Frame relative line assigned. */
2824 int frame_from
= copy_from
[i
] + unchanged_at_top
;
2826 /* Window relative line assigned to. */
2827 int window_to
= frame_to
- m
->matrix_y
;
2829 /* Window relative line assigned. */
2830 int window_from
= frame_from
- m
->matrix_y
;
2832 /* Is assigned line inside window? */
2833 int from_inside_window_p
2834 = window_from
>= 0 && window_from
< m
->matrix_h
;
2836 /* Is assigned to line inside window? */
2837 int to_inside_window_p
2838 = window_to
>= 0 && window_to
< m
->matrix_h
;
2840 if (from_inside_window_p
&& to_inside_window_p
)
2842 /* Enabled setting before assignment. */
2843 int enabled_before_p
;
2845 /* Do the assignment. The enabled_p flag is saved
2846 over the assignment because the old redisplay did
2848 enabled_before_p
= m
->rows
[window_to
].enabled_p
;
2849 m
->rows
[window_to
] = old_rows
[window_from
];
2850 m
->rows
[window_to
].enabled_p
= enabled_before_p
;
2852 /* If frame line is empty, window line is empty, too. */
2853 if (!retained_p
[copy_from
[i
]])
2854 m
->rows
[window_to
].enabled_p
= 0;
2856 else if (to_inside_window_p
)
2858 /* A copy between windows. This is an infrequent
2859 case not worth optimizing. */
2860 struct frame
*f
= XFRAME (w
->frame
);
2861 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
2863 struct glyph_matrix
*m2
;
2866 w2
= frame_row_to_window (root
, frame_to
);
2867 m2
= w2
->current_matrix
;
2868 m2_from
= frame_from
- m2
->matrix_y
;
2869 copy_row_except_pointers (m
->rows
+ window_to
,
2870 m2
->rows
+ m2_from
);
2872 /* If frame line is empty, window line is empty, too. */
2873 if (!retained_p
[copy_from
[i
]])
2874 m
->rows
[window_to
].enabled_p
= 0;
2877 else if (from_inside_window_p
)
2881 /* If there was a copy between windows, make sure glyph
2882 pointers are in sync with the frame matrix. */
2884 sync_window_with_frame_matrix_rows (w
);
2886 /* Check that no pointers are lost. */
2890 /* Next window on same level. */
2891 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2898 /* Check that window and frame matrices agree about their
2899 understanding where glyphs of the rows are to find. For each
2900 window in the window tree rooted at W, check that rows in the
2901 matrices of leaf window agree with their frame matrices about
2905 check_window_matrix_pointers (w
)
2910 if (!NILP (w
->hchild
))
2911 check_window_matrix_pointers (XWINDOW (w
->hchild
));
2912 else if (!NILP (w
->vchild
))
2913 check_window_matrix_pointers (XWINDOW (w
->vchild
));
2916 struct frame
*f
= XFRAME (w
->frame
);
2917 check_matrix_pointers (w
->desired_matrix
, f
->desired_matrix
);
2918 check_matrix_pointers (w
->current_matrix
, f
->current_matrix
);
2921 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2926 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
2927 a window and FRAME_MATRIX is the corresponding frame matrix. For
2928 each row in WINDOW_MATRIX check that it's a slice of the
2929 corresponding frame row. If it isn't, abort. */
2932 check_matrix_pointers (window_matrix
, frame_matrix
)
2933 struct glyph_matrix
*window_matrix
, *frame_matrix
;
2935 /* Row number in WINDOW_MATRIX. */
2938 /* Row number corresponding to I in FRAME_MATRIX. */
2939 int j
= window_matrix
->matrix_y
;
2941 /* For all rows check that the row in the window matrix is a
2942 slice of the row in the frame matrix. If it isn't we didn't
2943 mirror an operation on the frame matrix correctly. */
2944 while (i
< window_matrix
->nrows
)
2946 if (!glyph_row_slice_p (window_matrix
->rows
+ i
,
2947 frame_matrix
->rows
+ j
))
2953 #endif /* GLYPH_DEBUG != 0 */
2957 /**********************************************************************
2958 VPOS and HPOS translations
2959 **********************************************************************/
2963 /* Translate vertical position VPOS which is relative to window W to a
2964 vertical position relative to W's frame. */
2967 window_to_frame_vpos (w
, vpos
)
2971 struct frame
*f
= XFRAME (w
->frame
);
2973 xassert (!FRAME_WINDOW_P (f
));
2974 xassert (vpos
>= 0 && vpos
<= w
->desired_matrix
->nrows
);
2975 vpos
+= XFASTINT (w
->top
);
2976 xassert (vpos
>= 0 && vpos
<= FRAME_HEIGHT (f
));
2981 /* Translate horizontal position HPOS which is relative to window W to
2982 a vertical position relative to W's frame. */
2985 window_to_frame_hpos (w
, hpos
)
2989 struct frame
*f
= XFRAME (w
->frame
);
2991 xassert (!FRAME_WINDOW_P (f
));
2992 hpos
+= XFASTINT (w
->left
);
2996 #endif /* GLYPH_DEBUG */
3000 /**********************************************************************
3002 **********************************************************************/
3004 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
3005 "Clear frame FRAME and output again what is supposed to appear on it.")
3011 CHECK_LIVE_FRAME (frame
, 0);
3014 /* Ignore redraw requests, if frame has no glyphs yet.
3015 (Implementation note: It still has to be checked why we are
3016 called so early here). */
3017 if (!glyphs_initialized_initially_p
)
3021 if (FRAME_MSDOS_P (f
))
3022 set_terminal_modes ();
3024 clear_current_matrices (f
);
3027 windows_or_buffers_changed
++;
3028 /* Mark all windows as inaccurate, so that every window will have
3029 its redisplay done. */
3030 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
3031 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
3037 /* Redraw frame F. This is nothing more than a call to the Lisp
3038 function redraw-frame. */
3045 XSETFRAME (frame
, f
);
3046 Fredraw_frame (frame
);
3050 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
3051 "Clear and redisplay all visible frames.")
3054 Lisp_Object tail
, frame
;
3056 FOR_EACH_FRAME (tail
, frame
)
3057 if (FRAME_VISIBLE_P (XFRAME (frame
)))
3058 Fredraw_frame (frame
);
3064 /* This is used when frame_garbaged is set. Call Fredraw_frame on all
3065 visible frames marked as garbaged. */
3068 redraw_garbaged_frames ()
3070 Lisp_Object tail
, frame
;
3072 FOR_EACH_FRAME (tail
, frame
)
3073 if (FRAME_VISIBLE_P (XFRAME (frame
))
3074 && FRAME_GARBAGED_P (XFRAME (frame
)))
3075 Fredraw_frame (frame
);
3080 /***********************************************************************
3082 ***********************************************************************/
3084 /* Try to update display and current glyph matrix directly.
3086 This function is called after a character G has been inserted into
3087 current_buffer. It tries to update the current glyph matrix and
3088 perform appropriate screen output to reflect the insertion. If it
3089 succeeds, the global flag redisplay_performed_directly_p will be
3090 set to 1, and thereby prevent the more costly general redisplay
3091 from running (see redisplay_internal).
3093 This function is not called for `hairy' character insertions.
3094 In particular, it is not called when after or before change
3095 functions exist, like they are used by font-lock. See keyboard.c
3096 for details where this function is called. */
3099 direct_output_for_insert (g
)
3102 register struct frame
*f
= SELECTED_FRAME ();
3103 struct window
*w
= XWINDOW (selected_window
);
3105 struct glyph_row
*glyph_row
;
3106 struct glyph
*glyphs
, *glyph
, *end
;
3108 /* Non-null means that Redisplay of W is based on window matrices. */
3109 int window_redisplay_p
= FRAME_WINDOW_P (f
);
3110 /* Non-null means we are in overwrite mode. */
3111 int overwrite_p
= !NILP (current_buffer
->overwrite_mode
);
3113 struct text_pos pos
;
3114 int delta
, delta_bytes
;
3116 /* Not done directly. */
3117 redisplay_performed_directly_p
= 0;
3119 /* Quickly give up for some common cases. */
3120 if (cursor_in_echo_area
3121 /* Give up if fonts have changed. */
3123 /* Give up if face attributes have been changed. */
3124 || face_change_count
3125 /* Give up if cursor position not really known. */
3126 || !display_completed
3127 /* Give up if buffer appears in two places. */
3128 || buffer_shared
> 1
3129 /* Give up if w is mini-buffer and a message is being displayed there */
3130 || (MINI_WINDOW_P (w
) && !NILP (echo_area_buffer
[0]))
3131 /* Give up for hscrolled mini-buffer because display of the prompt
3132 is handled specially there (see display_line). */
3133 || (MINI_WINDOW_P (w
) && XFASTINT (w
->hscroll
))
3134 /* Give up if overwriting in the middle of a line. */
3137 && FETCH_BYTE (PT
) != '\n')
3138 /* Give up for tabs and line ends. */
3142 /* Give up if unable to display the cursor in the window. */
3143 || w
->cursor
.vpos
< 0
3144 || (glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
),
3145 /* Can't do it in a continued line because continuation
3146 lines would change. */
3147 (glyph_row
->continued_p
3148 /* Can't use this method if the line overlaps others or is
3149 overlapped by others because these other lines would
3150 have to be redisplayed. */
3151 || glyph_row
->overlapping_p
3152 || glyph_row
->overlapped_p
))
3153 /* Can't do it for partial width windows on terminal frames
3154 because we can't clear to eol in such a window. */
3155 || (!window_redisplay_p
&& !WINDOW_FULL_WIDTH_P (w
)))
3158 /* Set up a display iterator structure for W. Glyphs will be
3159 produced in scratch_glyph_row. Current position is W's cursor
3161 clear_glyph_row (&scratch_glyph_row
);
3162 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
3163 DEC_TEXT_POS (pos
, !NILP (current_buffer
->enable_multibyte_characters
));
3164 init_iterator (&it
, w
, CHARPOS (pos
), BYTEPOS (pos
), &scratch_glyph_row
,
3167 glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3169 /* Give up if highlighting trailing whitespace and we have trailing
3170 whitespace in glyph_row. We would have to remove the trailing
3171 whitespace face in that case. */
3172 if (!NILP (Vshow_trailing_whitespace
)
3173 && glyph_row
->used
[TEXT_AREA
])
3177 last
= glyph_row
->glyphs
[TEXT_AREA
] + glyph_row
->used
[TEXT_AREA
] - 1;
3178 if (last
->type
== STRETCH_GLYPH
3179 || (last
->type
== CHAR_GLYPH
3180 && last
->u
.ch
== ' '))
3184 /* Give up if there are overlay strings at pos. This would fail
3185 if the overlay string has newlines in it. */
3186 if (STRINGP (it
.string
))
3189 it
.hpos
= w
->cursor
.hpos
;
3190 it
.vpos
= w
->cursor
.vpos
;
3191 it
.current_x
= w
->cursor
.x
+ it
.first_visible_x
;
3192 it
.current_y
= w
->cursor
.y
;
3193 it
.end_charpos
= PT
;
3194 it
.stop_charpos
= min (PT
, it
.stop_charpos
);
3196 /* More than one display element may be returned for PT - 1 if
3197 (i) it's a control character which is translated into `\003' or
3198 `^C', or (ii) it has a display table entry, or (iii) it's a
3199 combination of both. */
3200 delta
= delta_bytes
= 0;
3201 while (get_next_display_element (&it
))
3203 PRODUCE_GLYPHS (&it
);
3205 /* Give up if glyph doesn't fit completely on the line. */
3206 if (it
.current_x
>= it
.last_visible_x
)
3209 /* Give up if new glyph has different ascent or descent than
3210 the original row, or if it is not a character glyph. */
3211 if (glyph_row
->ascent
!= it
.ascent
3212 || glyph_row
->height
!= it
.ascent
+ it
.descent
3213 || glyph_row
->phys_ascent
!= it
.phys_ascent
3214 || glyph_row
->phys_height
!= it
.phys_ascent
+ it
.phys_descent
3215 || it
.what
!= IT_CHARACTER
)
3219 delta_bytes
+= it
.len
;
3220 set_iterator_to_next (&it
);
3223 /* Give up if we hit the right edge of the window. We would have
3224 to insert truncation or continuation glyphs. */
3225 added_width
= it
.current_x
- (w
->cursor
.x
+ it
.first_visible_x
);
3226 if (glyph_row
->pixel_width
+ added_width
>= it
.last_visible_x
)
3229 /* Give up if there is a \t following in the line. */
3231 it2
.end_charpos
= ZV
;
3232 it2
.stop_charpos
= min (it2
.stop_charpos
, ZV
);
3233 while (get_next_display_element (&it2
)
3234 && !ITERATOR_AT_END_OF_LINE_P (&it2
))
3238 set_iterator_to_next (&it2
);
3241 /* Number of new glyphs produced. */
3242 n
= it
.glyph_row
->used
[TEXT_AREA
];
3244 /* Start and end of glyphs in original row. */
3245 glyphs
= glyph_row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
3246 end
= glyph_row
->glyphs
[1 + TEXT_AREA
];
3248 /* Make room for new glyphs, then insert them. */
3249 xassert (end
- glyphs
- n
>= 0);
3250 safe_bcopy ((char *) glyphs
, (char *) (glyphs
+ n
),
3251 (end
- glyphs
- n
) * sizeof (*end
));
3252 bcopy (it
.glyph_row
->glyphs
[TEXT_AREA
], glyphs
, n
* sizeof *glyphs
);
3253 glyph_row
->used
[TEXT_AREA
] = min (glyph_row
->used
[TEXT_AREA
] + n
,
3254 end
- glyph_row
->glyphs
[TEXT_AREA
]);
3256 /* Compute new line width. */
3257 glyph
= glyph_row
->glyphs
[TEXT_AREA
];
3258 end
= glyph
+ glyph_row
->used
[TEXT_AREA
];
3259 glyph_row
->pixel_width
= glyph_row
->x
;
3262 glyph_row
->pixel_width
+= glyph
->pixel_width
;
3266 /* Increment buffer positions for glyphs following the newly
3268 for (glyph
= glyphs
+ n
; glyph
< end
; ++glyph
)
3269 if (glyph
->charpos
> 0 && BUFFERP (glyph
->object
))
3270 glyph
->charpos
+= delta
;
3272 if (MATRIX_ROW_END_CHARPOS (glyph_row
) > 0)
3274 MATRIX_ROW_END_CHARPOS (glyph_row
) += delta
;
3275 MATRIX_ROW_END_BYTEPOS (glyph_row
) += delta_bytes
;
3278 /* Adjust positions in lines following the one we are in. */
3279 increment_matrix_positions (w
->current_matrix
,
3281 w
->current_matrix
->nrows
,
3282 delta
, delta_bytes
);
3284 glyph_row
->contains_overlapping_glyphs_p
3285 |= it
.glyph_row
->contains_overlapping_glyphs_p
;
3287 glyph_row
->displays_text_p
= 1;
3288 w
->window_end_vpos
= make_number (max (w
->cursor
.vpos
,
3289 XFASTINT (w
->window_end_vpos
)));
3291 if (!NILP (Vshow_trailing_whitespace
))
3292 highlight_trailing_whitespace (it
.f
, glyph_row
);
3294 /* Write glyphs. If at end of row, we can simply call write_glyphs.
3295 In the middle, we have to insert glyphs. Note that this is now
3296 implemented for X frames. The implementation uses updated_window
3298 updated_row
= glyph_row
;
3302 rif
->update_window_begin_hook (w
);
3304 if (glyphs
== end
- n
)
3305 rif
->write_glyphs (glyphs
, n
);
3307 rif
->insert_glyphs (glyphs
, n
);
3311 if (glyphs
== end
- n
)
3312 write_glyphs (glyphs
, n
);
3314 insert_glyphs (glyphs
, n
);
3317 w
->cursor
.hpos
+= n
;
3318 w
->cursor
.x
= it
.current_x
- it
.first_visible_x
;
3319 xassert (w
->cursor
.hpos
>= 0
3320 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3322 /* How to set the cursor differs depending on whether we are
3323 using a frame matrix or a window matrix. Note that when
3324 a frame matrix is used, cursor_to expects frame coordinates,
3325 and the X and Y parameters are not used. */
3326 if (window_redisplay_p
)
3327 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3328 w
->cursor
.y
, w
->cursor
.x
);
3332 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3333 + (INTEGERP (w
->left_margin_width
)
3334 ? XFASTINT (w
->left_margin_width
)
3336 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3341 rif
->update_window_end_hook (w
, 1);
3346 TRACE ((stderr
, "direct output for insert\n"));
3348 UNCHANGED_MODIFIED
= MODIFF
;
3349 BEG_UNCHANGED
= GPT
- BEG
;
3350 XSETFASTINT (w
->last_point
, PT
);
3351 w
->last_cursor
= w
->cursor
;
3352 XSETFASTINT (w
->last_modified
, MODIFF
);
3353 XSETFASTINT (w
->last_overlay_modified
, OVERLAY_MODIFF
);
3355 redisplay_performed_directly_p
= 1;
3360 /* Perform a direct display update for moving PT by N positions
3361 left or right. N < 0 means a movement backwards. This function
3362 is currently only called for N == 1 or N == -1. */
3365 direct_output_forward_char (n
)
3368 struct frame
*f
= SELECTED_FRAME ();
3369 struct window
*w
= XWINDOW (selected_window
);
3370 struct glyph_row
*row
;
3372 /* Give up if point moved out of or into a composition. */
3373 if (check_point_in_composition (current_buffer
, XINT (w
->last_point
),
3374 current_buffer
, PT
))
3377 /* Give up if face attributes have been changed. */
3378 if (face_change_count
)
3381 /* Give up if current matrix is not up to date or we are
3382 displaying a message. */
3383 if (!display_completed
|| cursor_in_echo_area
)
3386 /* Give up if the buffer's direction is reversed. */
3387 if (!NILP (XBUFFER (w
->buffer
)->direction_reversed
))
3390 /* Can't use direct output if highlighting a region. */
3391 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
3394 /* Can't use direct output if highlighting trailing whitespace. */
3395 if (!NILP (Vshow_trailing_whitespace
))
3398 /* Give up if we are showing a message or just cleared the message
3399 because we might need to resize the echo area window. */
3400 if (!NILP (echo_area_buffer
[0]) || !NILP (echo_area_buffer
[1]))
3403 /* Give up if we don't know where the cursor is. */
3404 if (w
->cursor
.vpos
< 0)
3407 row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3409 if (PT
<= MATRIX_ROW_START_BYTEPOS (row
)
3410 || PT
>= MATRIX_ROW_END_BYTEPOS (row
))
3413 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
3414 w
->last_cursor
= w
->cursor
;
3415 XSETFASTINT (w
->last_point
, PT
);
3417 xassert (w
->cursor
.hpos
>= 0
3418 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3420 if (FRAME_WINDOW_P (f
))
3421 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3422 w
->cursor
.y
, w
->cursor
.x
);
3426 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3427 + (INTEGERP (w
->left_margin_width
)
3428 ? XFASTINT (w
->left_margin_width
)
3430 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3435 redisplay_performed_directly_p
= 1;
3441 /***********************************************************************
3443 ***********************************************************************/
3445 /* Update frame F based on the data in desired matrices.
3447 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3448 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3451 Value is non-zero if redisplay was stopped due to pending input. */
3454 update_frame (f
, force_p
, inhibit_hairy_id_p
)
3457 int inhibit_hairy_id_p
;
3459 /* 1 means display has been paused because of pending input. */
3461 struct window
*root_window
= XWINDOW (f
->root_window
);
3463 if (FRAME_WINDOW_P (f
))
3465 /* We are working on window matrix basis. All windows whose
3466 flag must_be_updated_p is set have to be updated. */
3468 /* Record that we are not working on frame matrices. */
3469 set_frame_matrix_frame (NULL
);
3471 /* Update all windows in the window tree of F, maybe stopping
3472 when pending input is detected. */
3475 /* Update the menu bar on X frames that don't have toolkit
3477 if (WINDOWP (f
->menu_bar_window
))
3478 update_window (XWINDOW (f
->menu_bar_window
), 1);
3480 /* Update the tool-bar window, if present. */
3481 if (WINDOWP (f
->tool_bar_window
))
3484 struct window
*w
= XWINDOW (f
->tool_bar_window
);
3486 /* Update tool-bar window. */
3487 if (w
->must_be_updated_p
)
3489 update_window (w
, 1);
3490 w
->must_be_updated_p
= 0;
3492 /* Swap tool-bar strings. We swap because we want to
3494 tem
= f
->current_tool_bar_string
;
3495 f
->current_tool_bar_string
= f
->desired_tool_bar_string
;
3496 f
->desired_tool_bar_string
= tem
;
3497 f
->n_current_tool_bar_items
= f
->n_desired_tool_bar_items
;
3499 /* Swap tool-bar items. We swap because we want to
3501 tem
= f
->current_tool_bar_items
;
3502 f
->current_tool_bar_items
= f
->desired_tool_bar_items
;
3503 f
->desired_tool_bar_items
= tem
;
3508 /* Update windows. */
3509 paused_p
= update_window_tree (root_window
, force_p
);
3511 display_completed
= !paused_p
;
3513 /* The flush is a performance bottleneck under X. */
3515 rif
->flush_display (f
);
3520 /* We are working on frame matrix basis. Set the frame on whose
3521 frame matrix we operate. */
3522 set_frame_matrix_frame (f
);
3524 /* Build F's desired matrix from window matrices. For windows
3525 whose must_be_updated_p flag is set, desired matrices are
3526 made part of the desired frame matrix. For other windows,
3527 the current matrix is copied. */
3528 build_frame_matrix (f
);
3530 /* Do the update on the frame desired matrix. */
3531 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3533 /* Check window matrices for lost pointers. */
3534 IF_DEBUG (check_window_matrix_pointers (root_window
));
3537 /* Reset flags indicating that a window should be updated. */
3538 set_window_update_flags (root_window
, 0);
3544 /************************************************************************
3545 Window-based updates
3546 ************************************************************************/
3548 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3549 don't stop updating when input is pending. */
3552 update_window_tree (w
, force_p
)
3558 while (w
&& !paused_p
)
3560 if (!NILP (w
->hchild
))
3561 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
3562 else if (!NILP (w
->vchild
))
3563 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
3564 else if (w
->must_be_updated_p
)
3565 paused_p
|= update_window (w
, force_p
);
3567 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3574 /* Update window W if its flag must_be_updated_p is non-zero. If
3575 FORCE_P is non-zero, don't stop updating if input is pending. */
3578 update_single_window (w
, force_p
)
3582 if (w
->must_be_updated_p
)
3584 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3586 /* Record that this is not a frame-based redisplay. */
3587 set_frame_matrix_frame (NULL
);
3591 update_window (w
, force_p
);
3594 /* Reset flag in W. */
3595 w
->must_be_updated_p
= 0;
3600 /* Redraw lines from the current matrix of window W that are
3601 overlapped by other rows. YB is bottom-most y-position in W. */
3604 redraw_overlapped_rows (w
, yb
)
3609 struct glyph_row
*row
;
3611 /* If rows overlapping others have been changed, the rows being
3612 overlapped have to be redrawn. This won't draw lines that have
3613 already been drawn in update_window_line because overlapped_p in
3614 desired rows is 0, so after row assignment overlapped_p in
3615 current rows is 0. */
3616 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3618 row
= w
->current_matrix
->rows
+ i
;
3620 if (!row
->enabled_p
)
3622 else if (row
->mode_line_p
)
3625 if (row
->overlapped_p
)
3627 enum glyph_row_area area
;
3629 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3632 updated_area
= area
;
3633 rif
->cursor_to (i
, 0, row
->y
, area
== TEXT_AREA
? row
->x
: 0);
3634 if (row
->used
[area
])
3635 rif
->write_glyphs (row
->glyphs
[area
], row
->used
[area
]);
3636 rif
->clear_end_of_line (-1);
3639 row
->overlapped_p
= 0;
3642 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3649 /* Redraw lines from the current matrix of window W that overlap
3650 others. YB is bottom-most y-position in W. */
3653 redraw_overlapping_rows (w
, yb
)
3658 struct glyph_row
*row
;
3660 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3662 row
= w
->current_matrix
->rows
+ i
;
3664 if (!row
->enabled_p
)
3666 else if (row
->mode_line_p
)
3669 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3671 if (row
->overlapping_p
&& i
> 0 && bottom_y
< yb
)
3673 if (row
->used
[LEFT_MARGIN_AREA
])
3674 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
);
3676 if (row
->used
[TEXT_AREA
])
3677 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
);
3679 if (row
->used
[RIGHT_MARGIN_AREA
])
3680 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
);
3682 /* Record in neighbor rows that ROW overwrites part of their
3684 if (row
->phys_ascent
> row
->ascent
&& i
> 0)
3685 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3686 if ((row
->phys_height
- row
->phys_ascent
3687 > row
->height
- row
->ascent
)
3689 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
3698 /* Update display of window W. FORCE_P non-zero means that we should
3699 not stop when detecting pending input. */
3702 update_window (w
, force_p
)
3706 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
3708 int preempt_count
= baud_rate
/ 2400 + 1;
3709 extern int input_pending
;
3711 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3712 extern struct frame
*updating_frame
;
3715 /* Check that W's frame doesn't have glyph matrices. */
3716 xassert (FRAME_WINDOW_P (f
));
3717 xassert (updating_frame
!= NULL
);
3719 /* Check pending input the first time so that we can quickly return. */
3720 if (redisplay_dont_pause
)
3723 detect_input_pending ();
3725 /* If forced to complete the update, or if no input is pending, do
3727 if (force_p
|| !input_pending
)
3729 struct glyph_row
*row
, *end
;
3730 struct glyph_row
*mode_line_row
;
3731 struct glyph_row
*header_line_row
= NULL
;
3732 int yb
, changed_p
= 0;
3734 rif
->update_window_begin_hook (w
);
3735 yb
= window_text_bottom_y (w
);
3737 /* If window has a top line, update it before everything else.
3738 Adjust y-positions of other rows by the top line height. */
3739 row
= desired_matrix
->rows
;
3740 end
= row
+ desired_matrix
->nrows
- 1;
3741 if (row
->mode_line_p
)
3742 header_line_row
= row
++;
3744 /* Update the mode line, if necessary. */
3745 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3746 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
3748 mode_line_row
->y
= yb
;
3749 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
3754 /* Find first enabled row. Optimizations in redisplay_internal
3755 may lead to an update with only one row enabled. There may
3756 be also completely empty matrices. */
3757 while (row
< end
&& !row
->enabled_p
)
3760 /* Try reusing part of the display by inserting/deleting lines. */
3761 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
3763 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
3766 /* All rows were found to be equal. */
3775 /* Update the top mode line after scrolling because a new top
3776 line would otherwise overwrite lines at the top of the window
3777 that can be scrolled. */
3778 if (header_line_row
&& header_line_row
->enabled_p
)
3780 header_line_row
->y
= 0;
3781 update_window_line (w
, 0);
3785 /* Update the rest of the lines. */
3786 for (; row
< end
&& (force_p
|| !input_pending
); ++row
)
3788 /* A row can be completely invisible in case a desired
3789 matrix was built with a vscroll and then
3790 make_cursor_line_fully_visible shifts the matrix. */
3791 && row
->visible_height
> 0)
3793 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
3796 /* We'll Have to play a little bit with when to
3797 detect_input_pending. If it's done too often,
3798 scrolling large windows with repeated scroll-up
3799 commands will too quickly pause redisplay. */
3800 if (!force_p
&& vpos
% preempt_count
== 0)
3801 detect_input_pending ();
3803 changed_p
|= update_window_line (w
, vpos
);
3805 /* Mark all rows below the last visible one in the current
3806 matrix as invalid. This is necessary because of
3807 variable line heights. Consider the case of three
3808 successive redisplays, where the first displays 5
3809 lines, the second 3 lines, and the third 5 lines again.
3810 If the second redisplay wouldn't mark rows in the
3811 current matrix invalid, the third redisplay might be
3812 tempted to optimize redisplay based on lines displayed
3813 in the first redisplay. */
3814 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3815 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
3816 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
3819 /* Was display preempted? */
3820 paused_p
= row
< end
;
3824 /* Fix the appearance of overlapping(overlapped rows. */
3825 if (rif
->fix_overlapping_area
3826 && !w
->pseudo_window_p
3830 redraw_overlapped_rows (w
, yb
);
3831 redraw_overlapping_rows (w
, yb
);
3834 if (!paused_p
&& !w
->pseudo_window_p
)
3836 /* Make cursor visible at cursor position of W. */
3837 set_window_cursor_after_update (w
);
3840 /* Check that current matrix invariants are satisfied. This
3841 is for debugging only. See the comment around
3842 check_matrix_invariants. */
3843 IF_DEBUG (check_matrix_invariants (w
));
3848 /* Remember the redisplay method used to display the matrix. */
3849 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
3852 /* End of update of window W. */
3853 rif
->update_window_end_hook (w
, 1);
3859 clear_glyph_matrix (desired_matrix
);
3865 /* Update the display of area AREA in window W, row number VPOS.
3866 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3869 update_marginal_area (w
, area
, vpos
)
3873 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3875 /* Let functions in xterm.c know what area subsequent X positions
3876 will be relative to. */
3877 updated_area
= area
;
3879 /* Set cursor to start of glyphs, write them, and clear to the end
3880 of the area. I don't think that something more sophisticated is
3881 necessary here, since marginal areas will not be the default. */
3882 rif
->cursor_to (vpos
, 0, desired_row
->y
, 0);
3883 if (desired_row
->used
[area
])
3884 rif
->write_glyphs (desired_row
->glyphs
[area
], desired_row
->used
[area
]);
3885 rif
->clear_end_of_line (-1);
3889 /* Update the display of the text area of row VPOS in window W.
3890 Value is non-zero if display has changed. */
3893 update_text_area (w
, vpos
)
3897 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3898 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3901 /* Let functions in xterm.c know what area subsequent X positions
3902 will be relative to. */
3903 updated_area
= TEXT_AREA
;
3905 /* If rows are at different X or Y, or rows have different height,
3906 or the current row is marked invalid, write the entire line. */
3907 if (!current_row
->enabled_p
3908 || desired_row
->y
!= current_row
->y
3909 || desired_row
->ascent
!= current_row
->ascent
3910 || desired_row
->phys_ascent
!= current_row
->phys_ascent
3911 || desired_row
->phys_height
!= current_row
->phys_height
3912 || desired_row
->visible_height
!= current_row
->visible_height
3913 || current_row
->overlapped_p
3914 || current_row
->x
!= desired_row
->x
)
3916 rif
->cursor_to (vpos
, 0, desired_row
->y
, desired_row
->x
);
3918 if (desired_row
->used
[TEXT_AREA
])
3919 rif
->write_glyphs (desired_row
->glyphs
[TEXT_AREA
],
3920 desired_row
->used
[TEXT_AREA
]);
3922 /* Clear to end of window. */
3923 rif
->clear_end_of_line (-1);
3929 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
3930 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
3932 /* If the desired row extends its face to the text area end,
3933 make sure we write at least one glyph, so that the face
3934 extension actually takes place. */
3935 int desired_stop_pos
= (desired_row
->used
[TEXT_AREA
]
3936 - (MATRIX_ROW_EXTENDS_FACE_P (desired_row
)
3939 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
3945 /* Skip over glyphs that both rows have in common. These
3946 don't have to be written. */
3948 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3950 x
+= desired_glyph
->pixel_width
;
3951 ++desired_glyph
, ++current_glyph
, ++i
;
3954 /* Consider the case that the current row contains "xxx ppp
3955 ggg" in italic Courier font, and the desired row is "xxx
3956 ggg". The character `p' has lbearing, `g' has not. The
3957 loop above will stop in front of the first `p' in the
3958 current row. If we would start writing glyphs there, we
3959 wouldn't erase the lbearing of the `p'. The rest of the
3960 lbearing problem is then taken care of by x_draw_glyphs. */
3961 if (current_row
->contains_overlapping_glyphs_p
3963 && i
< current_row
->used
[TEXT_AREA
]
3964 && current_row
->used
[TEXT_AREA
] != desired_row
->used
[TEXT_AREA
])
3967 rif
->get_glyph_overhangs (current_glyph
, XFRAME (w
->frame
),
3969 while (left
> 0 && i
> 0)
3971 --i
, --desired_glyph
, --current_glyph
;
3972 x
-= desired_glyph
->pixel_width
;
3973 left
-= desired_glyph
->pixel_width
;
3977 /* Try to avoid writing the entire rest of the desired row
3978 by looking for a resync point. This mainly prevents
3979 mode line flickering in the case the mode line is in
3980 fixed-pitch font, which it usually will be. */
3981 if (i
< desired_row
->used
[TEXT_AREA
])
3983 int start_x
= x
, start_hpos
= i
;
3984 struct glyph
*start
= desired_glyph
;
3987 /* Find the next glyph that's equal again. */
3989 && !GLYPH_EQUAL_P (desired_glyph
, current_glyph
)
3992 x
+= desired_glyph
->pixel_width
;
3993 current_x
+= current_glyph
->pixel_width
;
3994 ++desired_glyph
, ++current_glyph
, ++i
;
3997 if (i
== start_hpos
|| x
!= current_x
)
4001 desired_glyph
= start
;
4005 rif
->cursor_to (vpos
, start_hpos
, desired_row
->y
, start_x
);
4006 rif
->write_glyphs (start
, i
- start_hpos
);
4011 /* Write the rest. */
4012 if (i
< desired_row
->used
[TEXT_AREA
])
4014 rif
->cursor_to (vpos
, i
, desired_row
->y
, x
);
4015 rif
->write_glyphs (desired_glyph
, desired_row
->used
[TEXT_AREA
] - i
);
4019 /* Maybe clear to end of line. */
4020 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
4022 /* If new row extends to the end of the text area, nothing
4023 has to be cleared, if and only if we did a write_glyphs
4024 above. This is made sure by setting desired_stop_pos
4025 appropriately above. */
4026 xassert (i
< desired_row
->used
[TEXT_AREA
]);
4028 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
4030 /* If old row extends to the end of the text area, clear. */
4031 if (i
>= desired_row
->used
[TEXT_AREA
])
4032 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4033 desired_row
->x
+ desired_row
->pixel_width
);
4034 rif
->clear_end_of_line (-1);
4037 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
4039 /* Otherwise clear to the end of the old row. Everything
4040 after that position should be clear already. */
4043 if (i
>= desired_row
->used
[TEXT_AREA
])
4044 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4045 desired_row
->x
+ desired_row
->pixel_width
);
4047 /* If cursor is displayed at the end of the line, make sure
4048 it's cleared. Nowadays we don't have a phys_cursor_glyph
4049 with which to erase the cursor (because this method
4050 doesn't work with lbearing/rbearing), so we must do it
4052 if (vpos
== w
->phys_cursor
.vpos
4053 && w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])
4055 w
->phys_cursor_on_p
= 0;
4059 x
= current_row
->x
+ current_row
->pixel_width
;
4060 rif
->clear_end_of_line (x
);
4069 /* Update row VPOS in window W. Value is non-zero if display has been
4073 update_window_line (w
, vpos
)
4077 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
4078 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
4081 xassert (desired_row
->enabled_p
);
4083 /* Set the row being updated. This is important to let xterm.c
4084 know what line height values are in effect. */
4085 updated_row
= desired_row
;
4087 /* Update display of the left margin area, if there is one. */
4088 if (!desired_row
->full_width_p
4089 && !NILP (w
->left_margin_width
))
4091 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
4095 /* Update the display of the text area. */
4096 changed_p
|= update_text_area (w
, vpos
);
4098 /* Update display of the right margin area, if there is one. */
4099 if (!desired_row
->full_width_p
4100 && !NILP (w
->right_margin_width
))
4103 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
4106 /* Draw truncation marks etc. */
4107 if (!current_row
->enabled_p
4108 || desired_row
->y
!= current_row
->y
4109 || desired_row
->visible_height
!= current_row
->visible_height
4110 || desired_row
->overlay_arrow_p
!= current_row
->overlay_arrow_p
4111 || desired_row
->truncated_on_left_p
!= current_row
->truncated_on_left_p
4112 || desired_row
->truncated_on_right_p
!= current_row
->truncated_on_right_p
4113 || desired_row
->continued_p
!= current_row
->continued_p
4114 || desired_row
->mode_line_p
!= current_row
->mode_line_p
4115 || (desired_row
->indicate_empty_line_p
4116 != current_row
->indicate_empty_line_p
)
4117 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
4118 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
4119 rif
->after_update_window_line_hook (desired_row
);
4121 /* Update current_row from desired_row. */
4122 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4128 /* Set the cursor after an update of window W. This function may only
4129 be called from update_window. */
4132 set_window_cursor_after_update (w
)
4135 struct frame
*f
= XFRAME (w
->frame
);
4136 int cx
, cy
, vpos
, hpos
;
4138 /* Not intended for frame matrix updates. */
4139 xassert (FRAME_WINDOW_P (f
));
4141 if (cursor_in_echo_area
4142 && !NILP (echo_area_buffer
[0])
4143 /* If we are showing a message instead of the mini-buffer,
4144 show the cursor for the message instead. */
4145 && XWINDOW (minibuf_window
) == w
4146 && EQ (minibuf_window
, echo_area_window
)
4147 /* These cases apply only to the frame that contains
4148 the active mini-buffer window. */
4149 && FRAME_HAS_MINIBUF_P (f
)
4150 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4152 cx
= cy
= vpos
= hpos
= 0;
4154 if (cursor_in_echo_area
>= 0)
4156 /* If the mini-buffer is several lines high, find the last
4157 line that has any text on it. Note: either all lines
4158 are enabled or none. Otherwise we wouldn't be able to
4160 struct glyph_row
*row
, *last_row
;
4161 struct glyph
*glyph
;
4162 int yb
= window_text_bottom_y (w
);
4165 for (row
= MATRIX_ROW (w
->current_matrix
, 0);
4169 if (row
->used
[TEXT_AREA
]
4170 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4173 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4179 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
4180 struct glyph
*last
= start
+ row
->used
[TEXT_AREA
] - 1;
4182 while (last
> start
&& last
->charpos
< 0)
4185 for (glyph
= start
; glyph
< last
; ++glyph
)
4187 cx
+= glyph
->pixel_width
;
4192 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4200 hpos
= w
->cursor
.hpos
;
4201 vpos
= w
->cursor
.vpos
;
4204 /* Window cursor can be out of sync for horizontally split windows. */
4205 hpos
= max (0, hpos
);
4206 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4207 vpos
= max (0, vpos
);
4208 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4209 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4213 /* Try to reuse part of the current display of W by scrolling lines.
4214 HEADER_LINE_P non-zero means W has a top mode line.
4216 The algorithm is taken from Communications of the ACM, Apr78 "A
4217 Technique for Isolating Differences Between Files." It should take
4220 A short outline of the steps of the algorithm
4222 1. Skip lines equal at the start and end of both matrices.
4224 2. Enter rows in the current and desired matrix into a symbol
4225 table, counting how often they appear in both matrices.
4227 3. Rows that appear exactly once in both matrices serve as anchors,
4228 i.e. we assume that such lines are likely to have been moved.
4230 4. Starting from anchor lines, extend regions to be scrolled both
4231 forward and backward.
4235 -1 if all rows were found to be equal.
4236 0 to indicate that we did not scroll the display, or
4237 1 if we did scroll. */
4240 scrolling_window (w
, header_line_p
)
4246 /* Number of occurrences of this line in old and new matrix. */
4247 short old_uses
, new_uses
;
4249 /* Vpos of line in new matrix. */
4250 short new_line_number
;
4252 /* The line itself. */
4253 struct glyph_row
*row
;
4255 /* Hash collision chain. */
4256 struct symbol
*next
;
4259 int SYMBOL_TABLE_SIZE
= 101;
4260 struct symbol
**table
;
4261 struct symbol
**old_line_syms
, **new_line_syms
;
4262 int i
, j
, first_old
, first_new
, last_old
, last_new
;
4266 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4267 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4268 int yb
= window_text_bottom_y (w
);
4270 /* Skip over rows equal at the start. */
4271 i
= header_line_p
? 1 : 0;
4272 while (i
< current_matrix
->nrows
- 1
4273 && MATRIX_ROW_ENABLED_P (current_matrix
, i
)
4274 && MATRIX_ROW_ENABLED_P (desired_matrix
, i
)
4275 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) < yb
4276 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) < yb
4278 MATRIX_ROW (desired_matrix
, i
),
4279 MATRIX_ROW (current_matrix
, i
)))
4281 assign_row (MATRIX_ROW (current_matrix
, i
),
4282 MATRIX_ROW (desired_matrix
, i
));
4283 MATRIX_ROW (desired_matrix
, i
)->enabled_p
= 0;
4287 /* Give up if some rows in the desired matrix are not enabled. */
4288 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4291 first_old
= first_new
= i
;
4293 /* Set last_new to the index + 1 of the last enabled row in the
4296 while (i
< desired_matrix
->nrows
- 1
4297 && MATRIX_ROW (desired_matrix
, i
)->enabled_p
4298 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) < yb
)
4301 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4306 /* Set last_old to the index + 1 of the last enabled row in the
4307 current matrix. We don't look at the enabled flag here because
4308 we plan to reuse part of the display even if other parts are
4311 while (i
< current_matrix
->nrows
- 1
4312 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) < yb
)
4316 /* Skip over rows equal at the bottom. */
4319 while (i
- 1 > first_new
4320 && j
- 1 > first_old
4321 && MATRIX_ROW (current_matrix
, i
- 1)->enabled_p
4322 && (MATRIX_ROW (current_matrix
, i
- 1)->y
4323 == MATRIX_ROW (desired_matrix
, j
- 1)->y
)
4325 MATRIX_ROW (desired_matrix
, i
- 1),
4326 MATRIX_ROW (current_matrix
, j
- 1)))
4331 /* Nothing to do if all rows are equal. */
4332 if (last_new
== first_new
)
4335 /* Allocate a hash table in which all rows will be inserted. */
4336 table
= (struct symbol
**) alloca (SYMBOL_TABLE_SIZE
* sizeof *table
);
4337 bzero (table
, SYMBOL_TABLE_SIZE
* sizeof *table
);
4339 /* For each row in the current matrix, record the symbol belonging
4340 to the row in OLD_LINE_SYMS. */
4341 old_line_syms
= (struct symbol
**) alloca (current_matrix
->nrows
4342 * sizeof *old_line_syms
);
4343 new_line_syms
= (struct symbol
**) alloca (desired_matrix
->nrows
4344 * sizeof *new_line_syms
);
4346 #define ADDSYM(ROW) \
4349 struct glyph_row *row_ = (ROW); \
4350 int i_ = row_->hash % SYMBOL_TABLE_SIZE; \
4352 while (sym && !row_equal_p (w, sym->row, row_)) \
4356 sym = (struct symbol *) alloca (sizeof *sym); \
4358 sym->old_uses = sym->new_uses = 0; \
4359 sym->next = table[i_]; \
4365 /* Add current rows to the symbol table. */
4366 for (i
= first_old
; i
< last_old
; ++i
)
4368 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4370 ADDSYM (MATRIX_ROW (current_matrix
, i
));
4371 old_line_syms
[i
] = sym
;
4375 old_line_syms
[i
] = NULL
;
4378 /* Add desired rows to the symbol table. */
4379 for (i
= first_new
; i
< last_new
; ++i
)
4381 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4382 ADDSYM (MATRIX_ROW (desired_matrix
, i
));
4384 new_line_syms
[i
] = sym
;
4385 sym
->new_line_number
= i
;
4390 /* Record in runs which moves were found, ordered by pixel
4391 height of copied areas. */
4393 runs
= (struct run
**) alloca (desired_matrix
->nrows
* sizeof *runs
);
4395 /* Identify moves based on lines that are unique and equal
4396 in both matrices. */
4397 for (i
= first_old
; i
< last_old
;)
4398 if (old_line_syms
[i
]
4399 && old_line_syms
[i
]->old_uses
== 1
4400 && old_line_syms
[i
]->new_uses
== 1)
4403 int new_line
= old_line_syms
[i
]->new_line_number
;
4404 struct run
*run
= (struct run
*) alloca (sizeof *run
);
4407 run
->current_vpos
= i
;
4408 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4409 run
->desired_vpos
= new_line
;
4410 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4412 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4414 /* Extend backward. */
4417 while (j
> first_old
4419 && old_line_syms
[j
] == new_line_syms
[k
])
4421 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4422 --run
->current_vpos
;
4423 --run
->desired_vpos
;
4426 run
->desired_y
-= h
;
4427 run
->current_y
-= h
;
4431 /* Extend forward. */
4436 && old_line_syms
[j
] == new_line_syms
[k
])
4438 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4444 /* Insert run into list of all runs. Order runs by copied
4445 pixel lines. Note that we record runs that don't have to
4446 be copied because they are already in place. This is done
4447 because we can avoid calling update_window_line in this
4449 for (j
= 0; j
< nruns
&& runs
[j
]->height
> run
->height
; ++j
)
4451 for (k
= nruns
; k
>= j
; --k
)
4452 runs
[k
] = runs
[k
- 1];
4461 /* Do the moves. Do it in a way that we don't overwrite something
4462 we want to copy later on. This is not solvable in general
4463 because there is only one display and we don't have a way to
4464 exchange areas on this display. Example:
4466 +-----------+ +-----------+
4468 +-----------+ --> +-----------+
4470 +-----------+ +-----------+
4472 Instead, prefer bigger moves, and invalidate moves that would
4473 copy from where we copied to. */
4475 for (i
= 0; i
< nruns
; ++i
)
4476 if (runs
[i
]->nrows
> 0)
4478 struct run
*r
= runs
[i
];
4480 /* Copy on the display. */
4481 if (r
->current_y
!= r
->desired_y
)
4483 rif
->scroll_run_hook (w
, r
);
4485 /* Invalidate runs that copy from where we copied to. */
4486 for (j
= i
+ 1; j
< nruns
; ++j
)
4488 struct run
*p
= runs
[j
];
4490 if ((p
->current_y
>= r
->desired_y
4491 && p
->current_y
< r
->desired_y
+ r
->height
)
4492 || (p
->current_y
+ p
->height
>= r
->desired_y
4493 && (p
->current_y
+ p
->height
4494 < r
->desired_y
+ r
->height
)))
4499 /* Assign matrix rows. */
4500 for (j
= 0; j
< r
->nrows
; ++j
)
4502 struct glyph_row
*from
, *to
;
4503 int to_overlapped_p
;
4505 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
4506 to_overlapped_p
= to
->overlapped_p
;
4507 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
4508 assign_row (to
, from
);
4509 to
->enabled_p
= 1, from
->enabled_p
= 0;
4510 to
->overlapped_p
= to_overlapped_p
;
4514 /* Value is non-zero to indicate that we scrolled the display. */
4519 /* Set WINDOW->must_be_updated_p TO ON_P for all windows WINDOW in the
4520 window tree rooted at W. */
4523 set_window_update_flags (w
, on_p
)
4529 if (!NILP (w
->hchild
))
4530 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4531 else if (!NILP (w
->vchild
))
4532 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4534 w
->must_be_updated_p
= on_p
;
4536 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4542 /************************************************************************
4544 ************************************************************************/
4546 /* Update the desired frame matrix of frame F.
4548 FORCE_P non-zero means that the update should not be stopped by
4549 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
4550 should not be tried.
4552 Value is non-zero if update was stopped due to pending input. */
4555 update_frame_1 (f
, force_p
, inhibit_id_p
)
4560 /* Frame matrices to work on. */
4561 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4562 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4565 int preempt_count
= baud_rate
/ 2400 + 1;
4566 extern int input_pending
;
4568 xassert (current_matrix
&& desired_matrix
);
4570 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
4571 calculate_costs (f
);
4573 if (preempt_count
<= 0)
4576 detect_input_pending ();
4577 if (input_pending
&& !force_p
)
4585 /* If we cannot insert/delete lines, it's no use trying it. */
4586 if (!line_ins_del_ok
)
4589 /* See if any of the desired lines are enabled; don't compute for
4590 i/d line if just want cursor motion. */
4591 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
4592 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4595 /* Try doing i/d line, if not yet inhibited. */
4596 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
4597 force_p
|= scrolling (f
);
4599 /* Update the individual lines as needed. Do bottom line first. */
4600 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
4601 update_frame_line (f
, desired_matrix
->nrows
- 1);
4603 /* Now update the rest of the lines. */
4604 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
4606 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4608 if (FRAME_TERMCAP_P (f
))
4610 /* Flush out every so many lines.
4611 Also flush out if likely to have more than 1k buffered
4612 otherwise. I'm told that some telnet connections get
4613 really screwed by more than 1k output at once. */
4614 int outq
= PENDING_OUTPUT_COUNT (stdout
);
4616 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
4619 if (preempt_count
== 1)
4621 #ifdef EMACS_OUTQSIZE
4622 if (EMACS_OUTQSIZE (0, &outq
) < 0)
4623 /* Probably not a tty. Ignore the error and reset
4624 * the outq count. */
4625 outq
= PENDING_OUTPUT_COUNT (stdout
);
4628 if (baud_rate
<= outq
&& baud_rate
> 0)
4629 sleep (outq
/ baud_rate
);
4634 if ((i
- 1) % preempt_count
== 0)
4635 detect_input_pending ();
4637 update_frame_line (f
, i
);
4641 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
4643 /* Now just clean up termcap drivers and set cursor, etc. */
4646 if ((cursor_in_echo_area
4647 /* If we are showing a message instead of the mini-buffer,
4648 show the cursor for the message instead of for the
4649 (now hidden) mini-buffer contents. */
4650 || (EQ (minibuf_window
, selected_window
)
4651 && EQ (minibuf_window
, echo_area_window
)
4652 && !NILP (echo_area_buffer
[0])))
4653 /* These cases apply only to the frame that contains
4654 the active mini-buffer window. */
4655 && FRAME_HAS_MINIBUF_P (f
)
4656 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4658 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
4661 if (cursor_in_echo_area
< 0)
4663 /* Negative value of cursor_in_echo_area means put
4664 cursor at beginning of line. */
4670 /* Positive value of cursor_in_echo_area means put
4671 cursor at the end of the prompt. If the mini-buffer
4672 is several lines high, find the last line that has
4674 row
= FRAME_HEIGHT (f
);
4680 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
4682 /* Frame rows are filled up with spaces that
4683 must be ignored here. */
4684 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
4686 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
4687 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
4690 && (last
- 1)->charpos
< 0)
4696 while (row
> top
&& col
== 0);
4698 /* Make sure COL is not out of range. */
4699 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
4701 /* If we have another row, advance cursor into it. */
4702 if (row
< FRAME_HEIGHT (f
) - 1)
4704 col
= FRAME_LEFT_SCROLL_BAR_WIDTH (f
);
4707 /* Otherwise move it back in range. */
4709 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
4713 cursor_to (row
, col
);
4717 /* We have only one cursor on terminal frames. Use it to
4718 display the cursor of the selected window. */
4719 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
4720 if (w
->cursor
.vpos
>= 0)
4722 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
4723 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
4725 if (INTEGERP (w
->left_margin_width
))
4726 x
+= XFASTINT (w
->left_margin_width
);
4728 /* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
4737 fflush (termscript
);
4742 display_completed
= !pause
;
4743 clear_desired_matrices (f
);
4748 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4752 struct frame
*frame
;
4754 int unchanged_at_top
, unchanged_at_bottom
;
4757 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4758 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4759 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4760 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4762 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
4763 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4764 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4766 if (!current_matrix
)
4769 /* Compute hash codes of all the lines. Also calculate number of
4770 changed lines, number of unchanged lines at the beginning, and
4771 number of unchanged lines at the end. */
4773 unchanged_at_top
= 0;
4774 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
4775 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
4777 /* Give up on this scrolling if some old lines are not enabled. */
4778 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
4780 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
4781 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4783 /* This line cannot be redrawn, so don't let scrolling mess it. */
4784 new_hash
[i
] = old_hash
[i
];
4785 #define INFINITY 1000000 /* Taken from scroll.c */
4786 draw_cost
[i
] = INFINITY
;
4790 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
4791 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
4794 if (old_hash
[i
] != new_hash
[i
])
4797 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
4799 else if (i
== unchanged_at_top
)
4801 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
4804 /* If changed lines are few, don't allow preemption, don't scroll. */
4805 if ((!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400)
4806 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
4809 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
4810 - unchanged_at_bottom
);
4812 if (scroll_region_ok
)
4813 free_at_end_vpos
-= unchanged_at_bottom
;
4814 else if (memory_below_frame
)
4815 free_at_end_vpos
= -1;
4817 /* If large window, fast terminal and few lines in common between
4818 current frame and desired frame, don't bother with i/d calc. */
4819 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
4821 10 * scrolling_max_lines_saved (unchanged_at_top
,
4822 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
4823 old_hash
, new_hash
, draw_cost
)))
4826 if (window_size
< 2)
4829 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
4830 draw_cost
+ unchanged_at_top
- 1,
4831 old_draw_cost
+ unchanged_at_top
- 1,
4832 old_hash
+ unchanged_at_top
- 1,
4833 new_hash
+ unchanged_at_top
- 1,
4834 free_at_end_vpos
- unchanged_at_top
);
4840 /* Count the number of blanks at the start of the vector of glyphs R
4841 which is LEN glyphs long. */
4844 count_blanks (r
, len
)
4850 for (i
= 0; i
< len
; ++i
)
4851 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
4858 /* Count the number of glyphs in common at the start of the glyph
4859 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
4860 of STR2. Value is the number of equal glyphs equal at the start. */
4863 count_match (str1
, end1
, str2
, end2
)
4864 struct glyph
*str1
, *end1
, *str2
, *end2
;
4866 struct glyph
*p1
= str1
;
4867 struct glyph
*p2
= str2
;
4871 && GLYPH_CHAR_AND_FACE_EQUAL_P (p1
, p2
))
4878 /* Char insertion/deletion cost vector, from term.c */
4880 extern int *char_ins_del_vector
;
4881 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
4884 /* Perform a frame-based update on line VPOS in frame FRAME. */
4887 update_frame_line (frame
, vpos
)
4888 register struct frame
*frame
;
4891 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
4893 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
4894 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4895 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4896 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
4897 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
4898 int must_write_whole_line_p
;
4900 if (desired_row
->inverse_p
4901 != (current_row
->enabled_p
&& current_row
->inverse_p
))
4903 int n
= current_row
->enabled_p
? current_row
->used
[TEXT_AREA
] : 0;
4904 change_line_highlight (desired_row
->inverse_p
, vpos
, vpos
, n
);
4905 current_row
->enabled_p
= 0;
4908 reassert_line_highlight (desired_row
->inverse_p
, vpos
);
4910 /* Current row not enabled means it has unknown contents. We must
4911 write the whole desired line in that case. */
4912 must_write_whole_line_p
= !current_row
->enabled_p
;
4913 if (must_write_whole_line_p
)
4920 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
4921 olen
= current_row
->used
[TEXT_AREA
];
4923 if (! current_row
->inverse_p
)
4925 /* Ignore trailing spaces, if we can. */
4926 if (!must_write_spaces
)
4927 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
4932 /* For an inverse-video line, make sure it's filled with
4933 spaces all the way to the frame edge so that the reverse
4934 video extends all the way across. */
4935 while (olen
< FRAME_WIDTH (frame
) - 1)
4936 obody
[olen
++] = space_glyph
;
4940 current_row
->enabled_p
= 1;
4941 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
4942 current_row
->inverse_p
= desired_row
->inverse_p
;
4944 /* If desired line is empty, just clear the line. */
4945 if (!desired_row
->enabled_p
)
4951 nbody
= desired_row
->glyphs
[TEXT_AREA
];
4952 nlen
= desired_row
->used
[TEXT_AREA
];
4953 nend
= nbody
+ nlen
;
4955 /* If display line has unknown contents, write the whole line. */
4956 if (must_write_whole_line_p
)
4958 /* Ignore spaces at the end, if we can. */
4959 if (!must_write_spaces
)
4960 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4963 /* Write the contents of the desired line. */
4966 cursor_to (vpos
, 0);
4967 write_glyphs (nbody
, nlen
);
4970 /* Don't call clear_end_of_line if we already wrote the whole
4971 line. The cursor will not be at the right margin in that
4972 case but in the line below. */
4973 if (nlen
< FRAME_WINDOW_WIDTH (frame
))
4975 cursor_to (vpos
, nlen
);
4976 clear_end_of_line (FRAME_WINDOW_WIDTH (frame
));
4979 /* Make sure we are in the right row, otherwise cursor movement
4980 with cmgoto might use `ch' in the wrong row. */
4981 cursor_to (vpos
, 0);
4983 make_current (desired_matrix
, current_matrix
, vpos
);
4987 /* Pretend trailing spaces are not there at all,
4988 unless for one reason or another we must write all spaces. */
4989 if (!desired_row
->inverse_p
)
4991 if (!must_write_spaces
)
4992 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4997 /* For an inverse-video line, give it extra trailing spaces all
4998 the way to the frame edge so that the reverse video extends
4999 all the way across. */
5000 while (nlen
< FRAME_WIDTH (frame
) - 1)
5001 nbody
[nlen
++] = space_glyph
;
5004 /* If there's no i/d char, quickly do the best we can without it. */
5005 if (!char_ins_del_ok
)
5009 /* Find the first glyph in desired row that doesn't agree with
5010 a glyph in the current row, and write the rest from there on. */
5011 for (i
= 0; i
< nlen
; i
++)
5013 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
5015 /* Find the end of the run of different glyphs. */
5019 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
5020 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
5023 /* Output this run of non-matching chars. */
5024 cursor_to (vpos
, i
);
5025 write_glyphs (nbody
+ i
, j
- i
);
5028 /* Now find the next non-match. */
5032 /* Clear the rest of the line, or the non-clear part of it. */
5035 cursor_to (vpos
, nlen
);
5036 clear_end_of_line (olen
);
5039 /* Make current row = desired row. */
5040 make_current (desired_matrix
, current_matrix
, vpos
);
5044 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
5045 characters in a row. */
5049 /* If current line is blank, skip over initial spaces, if
5050 possible, and write the rest. */
5051 if (must_write_spaces
|| desired_row
->inverse_p
)
5054 nsp
= count_blanks (nbody
, nlen
);
5058 cursor_to (vpos
, nsp
);
5059 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
5062 /* Exchange contents between current_frame and new_frame. */
5063 make_current (desired_matrix
, current_matrix
, vpos
);
5067 /* Compute number of leading blanks in old and new contents. */
5068 osp
= count_blanks (obody
, olen
);
5069 nsp
= desired_row
->inverse_p
? 0 : count_blanks (nbody
, nlen
);
5071 /* Compute number of matching chars starting with first non-blank. */
5072 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
5073 nbody
+ nsp
, nbody
+ nlen
);
5075 /* Spaces in new match implicit space past the end of old. */
5076 /* A bug causing this to be a no-op was fixed in 18.29. */
5077 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
5080 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
5084 /* Avoid doing insert/delete char
5085 just cause number of leading spaces differs
5086 when the following text does not match. */
5087 if (begmatch
== 0 && osp
!= nsp
)
5088 osp
= nsp
= min (osp
, nsp
);
5090 /* Find matching characters at end of line */
5093 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
5095 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
5100 endmatch
= obody
+ olen
- op1
;
5102 /* tem gets the distance to insert or delete.
5103 endmatch is how many characters we save by doing so.
5106 tem
= (nlen
- nsp
) - (olen
- osp
);
5108 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
5111 /* nsp - osp is the distance to insert or delete.
5112 If that is nonzero, begmatch is known to be nonzero also.
5113 begmatch + endmatch is how much we save by doing the ins/del.
5117 && (!char_ins_del_ok
5118 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
5122 osp
= nsp
= min (osp
, nsp
);
5125 /* Now go through the line, inserting, writing and
5126 deleting as appropriate. */
5130 cursor_to (vpos
, nsp
);
5131 delete_glyphs (osp
- nsp
);
5135 /* If going to delete chars later in line
5136 and insert earlier in the line,
5137 must delete first to avoid losing data in the insert */
5138 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
5140 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
5141 delete_glyphs (olen
+ nsp
- osp
- nlen
);
5142 olen
= nlen
- (nsp
- osp
);
5144 cursor_to (vpos
, osp
);
5145 insert_glyphs (0, nsp
- osp
);
5149 tem
= nsp
+ begmatch
+ endmatch
;
5150 if (nlen
!= tem
|| olen
!= tem
)
5152 cursor_to (vpos
, nsp
+ begmatch
);
5153 if (!endmatch
|| nlen
== olen
)
5155 /* If new text being written reaches right margin,
5156 there is no need to do clear-to-eol at the end.
5157 (and it would not be safe, since cursor is not
5158 going to be "at the margin" after the text is done) */
5159 if (nlen
== FRAME_WINDOW_WIDTH (frame
))
5161 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5163 else if (nlen
> olen
)
5165 /* Here, we used to have the following simple code:
5166 ----------------------------------------
5167 write_glyphs (nbody + nsp + begmatch, olen - tem);
5168 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5169 ----------------------------------------
5170 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5171 is a padding glyph. */
5172 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5175 /* Calculate columns we can actually overwrite. */
5176 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
])) out
--;
5177 write_glyphs (nbody
+ nsp
+ begmatch
, out
);
5178 /* If we left columns to be overwritten, we must delete them. */
5179 del
= olen
- tem
- out
;
5180 if (del
> 0) delete_glyphs (del
);
5181 /* At last, we insert columns not yet written out. */
5182 insert_glyphs (nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5185 else if (olen
> nlen
)
5187 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5188 delete_glyphs (olen
- nlen
);
5194 /* If any unerased characters remain after the new line, erase them. */
5197 cursor_to (vpos
, nlen
);
5198 clear_end_of_line (olen
);
5201 /* Exchange contents between current_frame and new_frame. */
5202 make_current (desired_matrix
, current_matrix
, vpos
);
5207 /***********************************************************************
5208 X/Y Position -> Buffer Position
5209 ***********************************************************************/
5211 /* Return the character position of the character at window relative
5212 pixel position (*X, *Y). *X and *Y are adjusted to character
5216 buffer_posn_from_coords (w
, x
, y
)
5221 struct buffer
*old_current_buffer
= current_buffer
;
5222 struct text_pos startp
;
5223 int left_area_width
;
5225 current_buffer
= XBUFFER (w
->buffer
);
5226 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5227 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5228 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5229 start_display (&it
, w
, startp
);
5231 left_area_width
= WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH (w
);
5232 move_it_to (&it
, -1, *x
+ it
.first_visible_x
- left_area_width
, *y
, -1,
5233 MOVE_TO_X
| MOVE_TO_Y
);
5235 *x
= it
.current_x
- it
.first_visible_x
+ left_area_width
;
5237 current_buffer
= old_current_buffer
;
5238 return IT_CHARPOS (it
);
5242 /* Value is the string under window-relative coordinates X/Y in the
5243 mode or top line of window W, or nil if none. MODE_LINE_P non-zero
5244 means look at the mode line. *CHARPOS is set to the position in
5245 the string returned. */
5248 mode_line_string (w
, x
, y
, mode_line_p
, charpos
)
5253 struct glyph_row
*row
;
5254 struct glyph
*glyph
, *end
;
5255 struct frame
*f
= XFRAME (w
->frame
);
5257 Lisp_Object string
= Qnil
;
5260 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5262 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
5264 if (row
->mode_line_p
&& row
->enabled_p
)
5266 /* The mode lines are displayed over scroll bars and bitmap
5267 areas, and X is window-relative. Correct X by the scroll bar
5268 and bitmap area width. */
5269 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
5270 x
+= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
5271 x
+= FRAME_LEFT_FLAGS_AREA_WIDTH (f
);
5273 /* Find the glyph under X. If we find one with a string object,
5274 it's the one we were looking for. */
5275 glyph
= row
->glyphs
[TEXT_AREA
];
5276 end
= glyph
+ row
->used
[TEXT_AREA
];
5277 for (x0
= 0; glyph
< end
; x0
+= glyph
->pixel_width
, ++glyph
)
5278 if (x
>= x0
&& x
< x0
+ glyph
->pixel_width
)
5280 string
= glyph
->object
;
5281 *charpos
= glyph
->charpos
;
5290 /***********************************************************************
5291 Changing Frame Sizes
5292 ***********************************************************************/
5297 window_change_signal (signalnum
) /* If we don't have an argument, */
5298 int signalnum
; /* some compilers complain in signal calls. */
5302 int old_errno
= errno
;
5304 get_frame_size (&width
, &height
);
5306 /* The frame size change obviously applies to a termcap-controlled
5307 frame. Find such a frame in the list, and assume it's the only
5308 one (since the redisplay code always writes to stdout, not a
5309 FILE * specified in the frame structure). Record the new size,
5310 but don't reallocate the data structures now. Let that be done
5311 later outside of the signal handler. */
5314 Lisp_Object tail
, frame
;
5316 FOR_EACH_FRAME (tail
, frame
)
5318 if (FRAME_TERMCAP_P (XFRAME (frame
)))
5320 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5326 signal (SIGWINCH
, window_change_signal
);
5329 #endif /* SIGWINCH */
5332 /* Do any change in frame size that was requested by a signal. SAFE
5333 non-zero means this function is called from a place where it is
5334 safe to change frame sizes while a redisplay is in progress. */
5337 do_pending_window_change (safe
)
5340 /* If window_change_signal should have run before, run it now. */
5341 if (redisplaying_p
&& !safe
)
5344 while (delayed_size_change
)
5346 Lisp_Object tail
, frame
;
5348 delayed_size_change
= 0;
5350 FOR_EACH_FRAME (tail
, frame
)
5352 struct frame
*f
= XFRAME (frame
);
5354 int height
= FRAME_NEW_HEIGHT (f
);
5355 int width
= FRAME_NEW_WIDTH (f
);
5357 if (height
!= 0 || width
!= 0)
5358 change_frame_size (f
, height
, width
, 0, 0, safe
);
5364 /* Change the frame height and/or width. Values may be given as zero to
5365 indicate no change is to take place.
5367 If DELAY is non-zero, then assume we're being called from a signal
5368 handler, and queue the change for later - perhaps the next
5369 redisplay. Since this tries to resize windows, we can't call it
5370 from a signal handler.
5372 SAFE non-zero means this function is called from a place where it's
5373 safe to change frame sizes while a redisplay is in progress. */
5376 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5377 register struct frame
*f
;
5378 int newheight
, newwidth
, pretend
, delay
, safe
;
5380 Lisp_Object tail
, frame
;
5382 if (! FRAME_WINDOW_P (f
))
5384 /* When using termcap, or on MS-DOS, all frames use
5385 the same screen, so a change in size affects all frames. */
5386 FOR_EACH_FRAME (tail
, frame
)
5387 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5388 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5389 pretend
, delay
, safe
);
5392 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
5396 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5397 register struct frame
*f
;
5398 int newheight
, newwidth
, pretend
, delay
, safe
;
5400 int new_frame_window_width
;
5401 int count
= specpdl_ptr
- specpdl
;
5403 /* If we can't deal with the change now, queue it for later. */
5404 if (delay
|| (redisplaying_p
&& !safe
))
5406 FRAME_NEW_HEIGHT (f
) = newheight
;
5407 FRAME_NEW_WIDTH (f
) = newwidth
;
5408 delayed_size_change
= 1;
5412 /* This size-change overrides any pending one for this frame. */
5413 FRAME_NEW_HEIGHT (f
) = 0;
5414 FRAME_NEW_WIDTH (f
) = 0;
5416 /* If an argument is zero, set it to the current value. */
5418 newheight
= FRAME_HEIGHT (f
);
5420 newwidth
= FRAME_WIDTH (f
);
5422 /* Compute width of windows in F.
5423 This is the width of the frame without vertical scroll bars. */
5424 new_frame_window_width
= FRAME_WINDOW_WIDTH_ARG (f
, newwidth
);
5426 /* Round up to the smallest acceptable size. */
5427 check_frame_size (f
, &newheight
, &newwidth
);
5429 /* If we're not changing the frame size, quit now. */
5430 if (newheight
== FRAME_HEIGHT (f
)
5431 && new_frame_window_width
== FRAME_WINDOW_WIDTH (f
))
5437 /* We only can set screen dimensions to certain values supported
5438 by our video hardware. Try to find the smallest size greater
5439 or equal to the requested dimensions. */
5440 dos_set_window_size (&newheight
, &newwidth
);
5443 if (newheight
!= FRAME_HEIGHT (f
))
5445 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
5447 /* Frame has both root and mini-buffer. */
5448 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f
))->top
,
5449 FRAME_TOP_MARGIN (f
));
5450 set_window_height (FRAME_ROOT_WINDOW (f
),
5453 - FRAME_TOP_MARGIN (f
)),
5455 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
,
5457 set_window_height (FRAME_MINIBUF_WINDOW (f
), 1, 0);
5460 /* Frame has just one top-level window. */
5461 set_window_height (FRAME_ROOT_WINDOW (f
),
5462 newheight
- FRAME_TOP_MARGIN (f
), 0);
5464 if (FRAME_TERMCAP_P (f
) && !pretend
)
5465 FrameRows
= newheight
;
5468 if (new_frame_window_width
!= FRAME_WINDOW_WIDTH (f
))
5470 set_window_width (FRAME_ROOT_WINDOW (f
), new_frame_window_width
, 0);
5471 if (FRAME_HAS_MINIBUF_P (f
))
5472 set_window_width (FRAME_MINIBUF_WINDOW (f
), new_frame_window_width
, 0);
5474 if (FRAME_TERMCAP_P (f
) && !pretend
)
5475 FrameCols
= newwidth
;
5477 if (WINDOWP (f
->tool_bar_window
))
5478 XSETFASTINT (XWINDOW (f
->tool_bar_window
)->width
, newwidth
);
5481 FRAME_HEIGHT (f
) = newheight
;
5482 SET_FRAME_WIDTH (f
, newwidth
);
5485 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5486 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
5488 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
5490 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
5491 w
->cursor
.hpos
= w
->cursor
.x
= 0;
5492 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
5493 w
->cursor
.vpos
= w
->cursor
.y
= 0;
5497 SET_FRAME_GARBAGED (f
);
5498 calculate_costs (f
);
5502 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
5504 /* This isn't quite a no-op: it runs window-configuration-change-hook. */
5505 Fset_window_buffer (FRAME_SELECTED_WINDOW (f
),
5506 XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
);
5508 unbind_to (count
, Qnil
);
5513 /***********************************************************************
5514 Terminal Related Lisp Functions
5515 ***********************************************************************/
5517 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
5518 1, 1, "FOpen termscript file: ",
5519 "Start writing all terminal output to FILE as well as the terminal.\n\
5520 FILE = nil means just close any termscript file currently open.")
5524 if (termscript
!= 0) fclose (termscript
);
5529 file
= Fexpand_file_name (file
, Qnil
);
5530 termscript
= fopen (XSTRING (file
)->data
, "w");
5531 if (termscript
== 0)
5532 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
5538 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
5539 Ssend_string_to_terminal
, 1, 1, 0,
5540 "Send STRING to the terminal without alteration.\n\
5541 Control characters in STRING will have terminal-dependent effects.")
5545 /* ??? Perhaps we should do something special for multibyte strings here. */
5546 CHECK_STRING (string
, 0);
5547 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)), stdout
);
5551 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)),
5553 fflush (termscript
);
5559 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
5560 "Beep, or flash the screen.\n\
5561 Also, unless an argument is given,\n\
5562 terminate any keyboard macro currently executing.")
5585 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
5586 error ("Keyboard macro terminated by a command ringing the bell");
5594 /***********************************************************************
5596 ***********************************************************************/
5598 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
5599 "Pause, without updating display, for SECONDS seconds.\n\
5600 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5601 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5602 additional wait period, in milliseconds; this may be useful if your\n\
5603 Emacs was built without floating point support.\n\
5604 \(Not all operating systems support waiting for a fraction of a second.)")
5605 (seconds
, milliseconds
)
5606 Lisp_Object seconds
, milliseconds
;
5610 if (NILP (milliseconds
))
5611 XSETINT (milliseconds
, 0);
5613 CHECK_NUMBER (milliseconds
, 1);
5614 usec
= XINT (milliseconds
) * 1000;
5617 double duration
= extract_float (seconds
);
5618 sec
= (int) duration
;
5619 usec
+= (duration
- sec
) * 1000000;
5622 #ifndef EMACS_HAS_USECS
5623 if (sec
== 0 && usec
!= 0)
5624 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
5627 /* Assure that 0 <= usec < 1000000. */
5630 /* We can't rely on the rounding being correct if user is negative. */
5631 if (-1000000 < usec
)
5632 sec
--, usec
+= 1000000;
5634 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
5637 sec
+= usec
/ 1000000, usec
%= 1000000;
5639 if (sec
< 0 || (sec
== 0 && usec
== 0))
5645 XSETFASTINT (zero
, 0);
5646 wait_reading_process_input (sec
, usec
, zero
, 0);
5649 /* We should always have wait_reading_process_input; we have a dummy
5650 implementation for systems which don't support subprocesses. */
5652 /* No wait_reading_process_input */
5659 /* The reason this is done this way
5660 (rather than defined (H_S) && defined (H_T))
5661 is because the VMS preprocessor doesn't grok `defined' */
5663 EMACS_GET_TIME (end_time
);
5664 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
5665 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
5669 EMACS_GET_TIME (timeout
);
5670 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
5671 if (EMACS_TIME_NEG_P (timeout
)
5672 || !select (1, 0, 0, 0, &timeout
))
5675 #else /* not HAVE_SELECT */
5677 #endif /* HAVE_SELECT */
5678 #endif /* not VMS */
5681 #endif /* no subprocesses */
5687 /* This is just like wait_reading_process_input, except that
5688 it does the redisplay.
5690 It's also much like Fsit_for, except that it can be used for
5691 waiting for input as well. */
5694 sit_for (sec
, usec
, reading
, display
, initial_display
)
5695 int sec
, usec
, reading
, display
, initial_display
;
5697 Lisp_Object read_kbd
;
5699 swallow_events (display
);
5701 if (detect_input_pending_run_timers (display
))
5704 if (initial_display
)
5705 redisplay_preserve_echo_area ();
5707 if (sec
== 0 && usec
== 0)
5714 XSETINT (read_kbd
, reading
? -1 : 1);
5715 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
5717 return detect_input_pending () ? Qnil
: Qt
;
5721 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
5722 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
5723 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5724 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5725 additional wait period, in milliseconds; this may be useful if your\n\
5726 Emacs was built without floating point support.\n\
5727 \(Not all operating systems support waiting for a fraction of a second.)\n\
5728 Optional third arg NODISP non-nil means don't redisplay, just wait for input.\n\
5729 Redisplay is preempted as always if input arrives, and does not happen\n\
5730 if input is available before it starts.\n\
5731 Value is t if waited the full time with no input arriving.")
5732 (seconds
, milliseconds
, nodisp
)
5733 Lisp_Object seconds
, milliseconds
, nodisp
;
5737 if (NILP (milliseconds
))
5738 XSETINT (milliseconds
, 0);
5740 CHECK_NUMBER (milliseconds
, 1);
5741 usec
= XINT (milliseconds
) * 1000;
5744 double duration
= extract_float (seconds
);
5745 sec
= (int) duration
;
5746 usec
+= (duration
- sec
) * 1000000;
5749 #ifndef EMACS_HAS_USECS
5750 if (usec
!= 0 && sec
== 0)
5751 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
5754 return sit_for (sec
, usec
, 0, NILP (nodisp
), NILP (nodisp
));
5759 /***********************************************************************
5760 Other Lisp Functions
5761 ***********************************************************************/
5763 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
5764 session's frames, frame names, buffers, buffer-read-only flags, and
5765 buffer-modified-flags, and a trailing sentinel (so we don't need to
5766 add length checks). */
5768 static Lisp_Object frame_and_buffer_state
;
5771 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
5772 Sframe_or_buffer_changed_p
, 0, 0, 0,
5773 "Return non-nil if the frame and buffer state appears to have changed.\n\
5774 The state variable is an internal vector containing all frames and buffers,\n\
5775 aside from buffers whose names start with space,\n\
5776 along with the buffers' read-only and modified flags, which allows a fast\n\
5777 check to see whether the menu bars might need to be recomputed.\n\
5778 If this function returns non-nil, it updates the internal vector to reflect\n\
5779 the current state.\n")
5782 Lisp_Object tail
, frame
, buf
;
5786 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5787 FOR_EACH_FRAME (tail
, frame
)
5789 if (!EQ (*vecp
++, frame
))
5791 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
5794 /* Check that the buffer info matches.
5795 No need to test for the end of the vector
5796 because the last element of the vector is lambda
5797 and that will always cause a mismatch. */
5798 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5800 buf
= XCDR (XCAR (tail
));
5801 /* Ignore buffers that aren't included in buffer lists. */
5802 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5804 if (!EQ (*vecp
++, buf
))
5806 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
5808 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
5811 /* Detect deletion of a buffer at the end of the list. */
5812 if (EQ (*vecp
, Qlambda
))
5815 /* Start with 1 so there is room for at least one lambda at the end. */
5817 FOR_EACH_FRAME (tail
, frame
)
5819 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5821 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
5822 if (n
> XVECTOR (frame_and_buffer_state
)->size
5823 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
5824 /* Add 20 extra so we grow it less often. */
5825 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
5826 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5827 FOR_EACH_FRAME (tail
, frame
)
5830 *vecp
++ = XFRAME (frame
)->name
;
5832 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5834 buf
= XCDR (XCAR (tail
));
5835 /* Ignore buffers that aren't included in buffer lists. */
5836 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5839 *vecp
++ = XBUFFER (buf
)->read_only
;
5840 *vecp
++ = Fbuffer_modified_p (buf
);
5842 /* Fill up the vector with lambdas (always at least one). */
5844 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5845 < XVECTOR (frame_and_buffer_state
)->size
)
5847 /* Make sure we didn't overflow the vector. */
5848 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5849 > XVECTOR (frame_and_buffer_state
)->size
)
5856 /***********************************************************************
5858 ***********************************************************************/
5860 char *terminal_type
;
5862 /* Initialization done when Emacs fork is started, before doing stty.
5863 Determine terminal type and set terminal_driver. Then invoke its
5864 decoding routine to set up variables in the terminal package. */
5869 #ifdef HAVE_X_WINDOWS
5870 extern int display_arg
;
5873 /* Construct the space glyph. */
5874 space_glyph
.type
= CHAR_GLYPH
;
5875 SET_CHAR_GLYPH_FROM_GLYPH (space_glyph
, ' ');
5876 space_glyph
.charpos
= -1;
5880 cursor_in_echo_area
= 0;
5881 terminal_type
= (char *) 0;
5883 /* Now is the time to initialize this; it's used by init_sys_modes
5885 Vwindow_system
= Qnil
;
5887 /* If the user wants to use a window system, we shouldn't bother
5888 initializing the terminal. This is especially important when the
5889 terminal is so dumb that emacs gives up before and doesn't bother
5890 using the window system.
5892 If the DISPLAY environment variable is set and nonempty,
5893 try to use X, and die with an error message if that doesn't work. */
5895 #ifdef HAVE_X_WINDOWS
5900 display
= getenv ("DECW$DISPLAY");
5902 display
= getenv ("DISPLAY");
5905 display_arg
= (display
!= 0 && *display
!= 0);
5908 if (!inhibit_window_system
&& display_arg
5914 Vwindow_system
= intern ("x");
5916 Vwindow_system_version
= make_number (11);
5918 Vwindow_system_version
= make_number (10);
5920 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
5921 /* In some versions of ncurses,
5922 tputs crashes if we have not called tgetent.
5924 { char b
[2044]; tgetent (b
, "xterm");}
5926 adjust_frame_glyphs_initially ();
5929 #endif /* HAVE_X_WINDOWS */
5932 if (!inhibit_window_system
)
5934 Vwindow_system
= intern ("w32");
5935 Vwindow_system_version
= make_number (1);
5936 adjust_frame_glyphs_initially ();
5939 #endif /* HAVE_NTGUI */
5941 /* If no window system has been specified, try to use the terminal. */
5944 fatal ("standard input is not a tty");
5948 /* Look at the TERM variable */
5949 terminal_type
= (char *) getenv ("TERM");
5953 fprintf (stderr
, "Please specify your terminal type.\n\
5954 For types defined in VMS, use set term /device=TYPE.\n\
5955 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
5956 \(The quotation marks are necessary since terminal types are lower case.)\n");
5958 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
5964 /* VMS DCL tends to up-case things, so down-case term type.
5965 Hardly any uppercase letters in terminal types; should be none. */
5967 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
5970 strcpy (new, terminal_type
);
5972 for (p
= new; *p
; p
++)
5976 terminal_type
= new;
5980 term_init (terminal_type
);
5983 struct frame
*sf
= SELECTED_FRAME ();
5984 int width
= FRAME_WINDOW_WIDTH (sf
);
5985 int height
= FRAME_HEIGHT (sf
);
5987 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (struct glyph
);
5989 /* If these sizes are so big they cause overflow, just ignore the
5990 change. It's not clear what better we could do. */
5991 if (total_glyphs
/ sizeof (struct glyph
) / height
!= width
+ 2)
5992 fatal ("screen size %dx%d too big", width
, height
);
5995 adjust_frame_glyphs_initially ();
5996 calculate_costs (XFRAME (selected_frame
));
6001 #endif /* CANNOT_DUMP */
6002 signal (SIGWINCH
, window_change_signal
);
6003 #endif /* SIGWINCH */
6005 /* Set up faces of the initial terminal frame of a dumped Emacs. */
6009 /* The MSDOS terminal turns on its ``window system'' relatively
6010 late into the startup, so we cannot do the frame faces'
6011 initialization just yet. It will be done later by pc-win.el
6012 and internal_terminal_init. */
6013 && (strcmp (terminal_type
, "internal") != 0 || inhibit_window_system
)
6015 && NILP (Vwindow_system
))
6017 /* For the initial frame, we don't have any way of knowing what
6018 are the foreground and background colors of the terminal. */
6019 struct frame
*sf
= SELECTED_FRAME();
6021 FRAME_FOREGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_FG_COLOR
;
6022 FRAME_BACKGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_BG_COLOR
;
6023 call0 (intern ("tty-set-up-initial-frame-faces"));
6029 /***********************************************************************
6031 ***********************************************************************/
6033 DEFUN ("internal-show-cursor", Finternal_show_cursor
,
6034 Sinternal_show_cursor
, 2, 2, 0,
6035 "Set the cursor-visibility flag of WINDOW to SHOW.\n\
6036 WINDOW nil means use the selected window. SHOW non-nil means\n\
6037 show a cursor in WINDOW in the next redisplay. SHOW nil means\n\
6038 don't show a cursor.")
6040 Lisp_Object window
, show
;
6042 /* Don't change cursor state while redisplaying. This could confuse
6044 if (!redisplaying_p
)
6047 window
= selected_window
;
6049 CHECK_WINDOW (window
, 2);
6051 XWINDOW (window
)->cursor_off_p
= NILP (show
);
6058 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p
,
6059 Sinternal_show_cursor_p
, 0, 1, 0,
6060 "Value is non-nil if next redisplay will display a cursor in WINDOW.\n\
6061 WINDOW nil or omitted means report on the selected window.")
6068 window
= selected_window
;
6070 CHECK_WINDOW (window
, 2);
6072 w
= XWINDOW (window
);
6073 return w
->cursor_off_p
? Qnil
: Qt
;
6077 /***********************************************************************
6079 ***********************************************************************/
6084 defsubr (&Sredraw_frame
);
6085 defsubr (&Sredraw_display
);
6086 defsubr (&Sframe_or_buffer_changed_p
);
6087 defsubr (&Sopen_termscript
);
6089 defsubr (&Ssit_for
);
6090 defsubr (&Ssleep_for
);
6091 defsubr (&Ssend_string_to_terminal
);
6092 defsubr (&Sinternal_show_cursor
);
6093 defsubr (&Sinternal_show_cursor_p
);
6095 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
6096 staticpro (&frame_and_buffer_state
);
6098 Qdisplay_table
= intern ("display-table");
6099 staticpro (&Qdisplay_table
);
6101 DEFVAR_INT ("baud-rate", &baud_rate
,
6102 "*The output baud rate of the terminal.\n\
6103 On most systems, changing this value will affect the amount of padding\n\
6104 and the other strategic decisions made during redisplay.");
6106 DEFVAR_BOOL ("inverse-video", &inverse_video
,
6107 "*Non-nil means invert the entire frame display.\n\
6108 This means everything is in inverse video which otherwise would not be.");
6110 DEFVAR_BOOL ("visible-bell", &visible_bell
,
6111 "*Non-nil means try to flash the frame to represent a bell.");
6113 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
6114 "*Non-nil means no need to redraw entire frame after suspending.\n\
6115 A non-nil value is useful if the terminal can automatically preserve\n\
6116 Emacs's frame display when you reenter Emacs.\n\
6117 It is up to you to set this variable if your terminal can do that.");
6119 DEFVAR_LISP ("window-system", &Vwindow_system
,
6120 "A symbol naming the window-system under which Emacs is running\n\
6121 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
6123 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
6124 "The version number of the window system in use.\n\
6125 For X windows, this is 10 or 11.");
6127 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
6128 "Non-nil means put cursor in minibuffer, at end of any message there.");
6130 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
6131 "Table defining how to output a glyph code to the frame.\n\
6132 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
6133 Each element can be:\n\
6134 integer: a glyph code which this glyph is an alias for.\n\
6135 string: output this glyph using that string (not impl. in X windows).\n\
6136 nil: this glyph mod 256 is char code to output,\n\
6137 and this glyph / 256 is face code for X windows (see `face-id').");
6138 Vglyph_table
= Qnil
;
6140 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
6141 "Display table to use for buffers that specify none.\n\
6142 See `buffer-display-table' for more information.");
6143 Vstandard_display_table
= Qnil
;
6145 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause
,
6146 "*Non-nil means update isn't paused when input is detected.");
6147 redisplay_dont_pause
= 0;
6149 /* Initialize `window-system', unless init_display already decided it. */
6154 Vwindow_system
= Qnil
;
6155 Vwindow_system_version
= Qnil
;