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_glyph_pointers
P_ ((struct glyph_row
*, struct glyph_row
*));
135 static int glyph_row_slice_p
P_ ((struct glyph_row
*, struct glyph_row
*));
136 static void fill_up_frame_row_with_spaces
P_ ((struct glyph_row
*, int));
137 static void build_frame_matrix_from_window_tree
P_ ((struct glyph_matrix
*,
139 static void build_frame_matrix_from_leaf_window
P_ ((struct glyph_matrix
*,
141 static struct glyph_pool
*new_glyph_pool
P_ ((void));
142 static void free_glyph_pool
P_ ((struct glyph_pool
*));
143 static void adjust_frame_glyphs_initially
P_ ((void));
144 static void adjust_frame_message_buffer
P_ ((struct frame
*));
145 static void adjust_decode_mode_spec_buffer
P_ ((struct frame
*));
146 static void fill_up_glyph_row_with_spaces
P_ ((struct glyph_row
*));
147 static void build_frame_matrix
P_ ((struct frame
*));
148 void clear_current_matrices
P_ ((struct frame
*));
149 void scroll_glyph_matrix_range
P_ ((struct glyph_matrix
*, int, int,
151 static void clear_window_matrices
P_ ((struct window
*, int));
152 static void fill_up_glyph_row_area_with_spaces
P_ ((struct glyph_row
*, int));
153 static int scrolling_window
P_ ((struct window
*, int));
154 static int update_window_line
P_ ((struct window
*, int));
155 static void update_marginal_area
P_ ((struct window
*, int, int));
156 static int update_text_area
P_ ((struct window
*, int));
157 static void make_current
P_ ((struct glyph_matrix
*, struct glyph_matrix
*,
159 static void mirror_make_current
P_ ((struct window
*, int));
160 void check_window_matrix_pointers
P_ ((struct window
*));
162 static void check_matrix_pointers
P_ ((struct glyph_matrix
*,
163 struct glyph_matrix
*));
165 static void mirror_line_dance
P_ ((struct window
*, int, int, int *, char *));
166 static int update_window_tree
P_ ((struct window
*, int));
167 static int update_window
P_ ((struct window
*, int));
168 static int update_frame_1
P_ ((struct frame
*, int, int));
169 static void set_window_cursor_after_update
P_ ((struct window
*));
170 static int row_equal_p
P_ ((struct window
*, struct glyph_row
*,
171 struct glyph_row
*));
172 static void adjust_frame_glyphs_for_window_redisplay
P_ ((struct frame
*));
173 static void adjust_frame_glyphs_for_frame_redisplay
P_ ((struct frame
*));
174 static void reverse_rows
P_ ((struct glyph_matrix
*, int, int));
175 static int margin_glyphs_to_reserve
P_ ((struct window
*, int, Lisp_Object
));
176 static void sync_window_with_frame_matrix_rows
P_ ((struct window
*));
177 struct window
*frame_row_to_window
P_ ((struct window
*, int));
181 /* Non-zero means don't pause redisplay for pending input. (This is
182 for debugging and for a future implementation of EDT-like
185 int redisplay_dont_pause
;
187 /* Nonzero upon entry to redisplay means do not assume anything about
188 current contents of actual terminal frame; clear and redraw it. */
192 /* Nonzero means last display completed. Zero means it was preempted. */
194 int display_completed
;
196 /* Lisp variable visible-bell; enables use of screen-flash instead of
201 /* Invert the color of the whole frame, at a low level. */
205 /* Line speed of the terminal. */
209 /* Either nil or a symbol naming the window system under which Emacs
212 Lisp_Object Vwindow_system
;
214 /* Version number of X windows: 10, 11 or nil. */
216 Lisp_Object Vwindow_system_version
;
218 /* Vector of glyph definitions. Indexed by glyph number, the contents
219 are a string which is how to output the glyph.
221 If Vglyph_table is nil, a glyph is output by using its low 8 bits
224 This is an obsolete feature that is no longer used. The variable
225 is retained for compatibility. */
227 Lisp_Object Vglyph_table
;
229 /* Display table to use for vectors that don't specify their own. */
231 Lisp_Object Vstandard_display_table
;
233 /* Nonzero means reading single-character input with prompt so put
234 cursor on mini-buffer after the prompt. positive means at end of
235 text in echo area; negative means at beginning of line. */
237 int cursor_in_echo_area
;
239 Lisp_Object Qdisplay_table
;
242 /* The currently selected frame. In a single-frame version, this
243 variable always equals the_only_frame. */
245 Lisp_Object selected_frame
;
247 /* A frame which is not just a mini-buffer, or 0 if there are no such
248 frames. This is usually the most recent such frame that was
249 selected. In a single-frame version, this variable always holds
250 the address of the_only_frame. */
252 struct frame
*last_nonminibuf_frame
;
254 /* Stdio stream being used for copy of all output. */
258 /* Structure for info on cursor positioning. */
262 /* 1 means SIGWINCH happened when not safe. */
264 int delayed_size_change
;
266 /* 1 means glyph initialization has been completed at startup. */
268 static int glyphs_initialized_initially_p
;
270 /* Updated window if != 0. Set by update_window. */
272 struct window
*updated_window
;
274 /* Glyph row updated in update_window_line, and area that is updated. */
276 struct glyph_row
*updated_row
;
279 /* A glyph for a space. */
281 struct glyph space_glyph
;
283 /* Non-zero means update has been performed directly, so that there's
284 no need for redisplay_internal to do much work. Set by
285 direct_output_for_insert. */
287 int redisplay_performed_directly_p
;
289 /* Counts of allocated structures. These counts serve to diagnose
290 memory leaks and double frees. */
292 int glyph_matrix_count
;
293 int glyph_pool_count
;
295 /* If non-null, the frame whose frame matrices are manipulated. If
296 null, window matrices are worked on. */
298 static struct frame
*frame_matrix_frame
;
300 /* Current interface for window-based redisplay. Set from init_xterm.
301 A null value means we are not using window-based redisplay. */
303 struct redisplay_interface
*rif
;
305 /* Non-zero means that fonts have been loaded since the last glyph
306 matrix adjustments. Redisplay must stop, and glyph matrices must
307 be adjusted when this flag becomes non-zero during display. The
308 reason fonts can be loaded so late is that fonts of fontsets are
313 /* Convert vpos and hpos from frame to window and vice versa.
314 This may only be used for terminal frames. */
318 static int window_to_frame_vpos
P_ ((struct window
*, int));
319 static int window_to_frame_hpos
P_ ((struct window
*, int));
320 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
321 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
323 #else /* GLYPH_DEBUG == 0 */
325 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + XFASTINT ((W)->top))
326 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + XFASTINT ((W)->left))
328 #endif /* GLYPH_DEBUG == 0 */
331 /* Like bcopy except never gets confused by overlap. Let this be the
332 first function defined in this file, or change emacs.c where the
333 address of this function is used. */
336 safe_bcopy (from
, to
, size
)
340 if (size
<= 0 || from
== to
)
343 /* If the source and destination don't overlap, then bcopy can
344 handle it. If they do overlap, but the destination is lower in
345 memory than the source, we'll assume bcopy can handle that. */
346 if (to
< from
|| from
+ size
<= to
)
347 bcopy (from
, to
, size
);
349 /* Otherwise, we'll copy from the end. */
352 register char *endf
= from
+ size
;
353 register char *endt
= to
+ size
;
355 /* If TO - FROM is large, then we should break the copy into
356 nonoverlapping chunks of TO - FROM bytes each. However, if
357 TO - FROM is small, then the bcopy function call overhead
358 makes this not worth it. The crossover point could be about
359 anywhere. Since I don't think the obvious copy loop is too
360 bad, I'm trying to err in its favor. */
365 while (endf
!= from
);
377 bcopy (endf
, endt
, to
- from
);
380 /* If SIZE wasn't a multiple of TO - FROM, there will be a
381 little left over. The amount left over is (endt + (to -
382 from)) - to, which is endt - from. */
383 bcopy (from
, to
, endt
- from
);
390 /***********************************************************************
392 ***********************************************************************/
394 /* Allocate and return a glyph_matrix structure. POOL is the glyph
395 pool from which memory for the matrix should be allocated, or null
396 for window-based redisplay where no glyph pools are used. The
397 member `pool' of the glyph matrix structure returned is set to
398 POOL, the structure is otherwise zeroed. */
400 struct glyph_matrix
*
401 new_glyph_matrix (pool
)
402 struct glyph_pool
*pool
;
404 struct glyph_matrix
*result
;
406 /* Allocate and clear. */
407 result
= (struct glyph_matrix
*) xmalloc (sizeof *result
);
408 bzero (result
, sizeof *result
);
410 /* Increment number of allocated matrices. This count is used
411 to detect memory leaks. */
412 ++glyph_matrix_count
;
414 /* Set pool and return. */
420 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
422 The global counter glyph_matrix_count is decremented when a matrix
423 is freed. If the count gets negative, more structures were freed
424 than allocated, i.e. one matrix was freed more than once or a bogus
425 pointer was passed to this function.
427 If MATRIX->pool is null, this means that the matrix manages its own
428 glyph memory---this is done for matrices on X frames. Freeing the
429 matrix also frees the glyph memory in this case. */
432 free_glyph_matrix (matrix
)
433 struct glyph_matrix
*matrix
;
439 /* Detect the case that more matrices are freed than were
441 if (--glyph_matrix_count
< 0)
444 /* Free glyph memory if MATRIX owns it. */
445 if (matrix
->pool
== NULL
)
446 for (i
= 0; i
< matrix
->rows_allocated
; ++i
)
447 xfree (matrix
->rows
[i
].glyphs
[LEFT_MARGIN_AREA
]);
449 /* Free row structures and the matrix itself. */
450 xfree (matrix
->rows
);
456 /* Return the number of glyphs to reserve for a marginal area of
457 window W. TOTAL_GLYPHS is the number of glyphs in a complete
458 display line of window W. MARGIN gives the width of the marginal
459 area in canonical character units. MARGIN should be an integer
463 margin_glyphs_to_reserve (w
, total_glyphs
, margin
)
470 if (NUMBERP (margin
))
472 int width
= XFASTINT (w
->width
);
473 double d
= max (0, XFLOATINT (margin
));
474 d
= min (width
/ 2 - 1, d
);
475 n
= (int) ((double) total_glyphs
/ width
* d
);
484 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
487 W is null if the function is called for a frame glyph matrix.
488 Otherwise it is the window MATRIX is a member of. X and Y are the
489 indices of the first column and row of MATRIX within the frame
490 matrix, if such a matrix exists. They are zero for purely
491 window-based redisplay. DIM is the needed size of the matrix.
493 In window-based redisplay, where no frame matrices exist, glyph
494 matrices manage their own glyph storage. Otherwise, they allocate
495 storage from a common frame glyph pool which can be found in
498 The reason for this memory management strategy is to avoid complete
499 frame redraws if possible. When we allocate from a common pool, a
500 change of the location or size of a sub-matrix within the pool
501 requires a complete redisplay of the frame because we cannot easily
502 make sure that the current matrices of all windows still agree with
503 what is displayed on the screen. While this is usually fast, it
504 leads to screen flickering. */
507 adjust_glyph_matrix (w
, matrix
, x
, y
, dim
)
509 struct glyph_matrix
*matrix
;
515 int marginal_areas_changed_p
= 0;
516 int header_line_changed_p
= 0;
517 int header_line_p
= 0;
518 int left
= -1, right
= -1;
519 int window_x
, window_y
, window_width
, window_height
;
521 /* See if W had a top line that has disappeared now, or vice versa. */
524 header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
525 header_line_changed_p
= header_line_p
!= matrix
->header_line_p
;
527 matrix
->header_line_p
= header_line_p
;
529 /* Do nothing if MATRIX' size, position, vscroll, and marginal areas
530 haven't changed. This optimization is important because preserving
531 the matrix means preventing redisplay. */
532 if (matrix
->pool
== NULL
)
534 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
535 left
= margin_glyphs_to_reserve (w
, dim
.width
, w
->left_margin_width
);
536 right
= margin_glyphs_to_reserve (w
, dim
.width
, w
->right_margin_width
);
537 xassert (left
>= 0 && right
>= 0);
538 marginal_areas_changed_p
= (left
!= matrix
->left_margin_glyphs
539 || right
!= matrix
->right_margin_glyphs
);
541 if (!marginal_areas_changed_p
543 && !header_line_changed_p
544 && matrix
->window_top_y
== XFASTINT (w
->top
)
545 && matrix
->window_height
== window_height
546 && matrix
->window_vscroll
== w
->vscroll
547 && matrix
->window_width
== window_width
)
551 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
552 if (matrix
->rows_allocated
< dim
.height
)
554 int size
= dim
.height
* sizeof (struct glyph_row
);
555 new_rows
= dim
.height
- matrix
->rows_allocated
;
556 matrix
->rows
= (struct glyph_row
*) xrealloc (matrix
->rows
, size
);
557 bzero (matrix
->rows
+ matrix
->rows_allocated
,
558 new_rows
* sizeof *matrix
->rows
);
559 matrix
->rows_allocated
= dim
.height
;
564 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
565 on a frame not using window-based redisplay. Set up pointers for
566 each row into the glyph pool. */
569 xassert (matrix
->pool
->glyphs
);
573 left
= margin_glyphs_to_reserve (w
, dim
.width
,
574 w
->left_margin_width
);
575 right
= margin_glyphs_to_reserve (w
, dim
.width
,
576 w
->right_margin_width
);
581 for (i
= 0; i
< dim
.height
; ++i
)
583 struct glyph_row
*row
= &matrix
->rows
[i
];
585 row
->glyphs
[LEFT_MARGIN_AREA
]
586 = (matrix
->pool
->glyphs
587 + (y
+ i
) * matrix
->pool
->ncolumns
591 || row
== matrix
->rows
+ dim
.height
- 1
592 || (row
== matrix
->rows
&& matrix
->header_line_p
))
594 row
->glyphs
[TEXT_AREA
]
595 = row
->glyphs
[LEFT_MARGIN_AREA
];
596 row
->glyphs
[RIGHT_MARGIN_AREA
]
597 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
598 row
->glyphs
[LAST_AREA
]
599 = row
->glyphs
[RIGHT_MARGIN_AREA
];
603 row
->glyphs
[TEXT_AREA
]
604 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
605 row
->glyphs
[RIGHT_MARGIN_AREA
]
606 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
607 row
->glyphs
[LAST_AREA
]
608 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
612 matrix
->left_margin_glyphs
= left
;
613 matrix
->right_margin_glyphs
= right
;
617 /* If MATRIX->pool is null, MATRIX is responsible for managing
618 its own memory. Allocate glyph memory from the heap. */
619 if (dim
.width
> matrix
->matrix_w
621 || header_line_changed_p
622 || marginal_areas_changed_p
)
624 struct glyph_row
*row
= matrix
->rows
;
625 struct glyph_row
*end
= row
+ matrix
->rows_allocated
;
629 row
->glyphs
[LEFT_MARGIN_AREA
]
630 = (struct glyph
*) xrealloc (row
->glyphs
[LEFT_MARGIN_AREA
],
632 * sizeof (struct glyph
)));
634 /* The mode line never has marginal areas. */
635 if (row
== matrix
->rows
+ dim
.height
- 1
636 || (row
== matrix
->rows
&& matrix
->header_line_p
))
638 row
->glyphs
[TEXT_AREA
]
639 = row
->glyphs
[LEFT_MARGIN_AREA
];
640 row
->glyphs
[RIGHT_MARGIN_AREA
]
641 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
642 row
->glyphs
[LAST_AREA
]
643 = row
->glyphs
[RIGHT_MARGIN_AREA
];
647 row
->glyphs
[TEXT_AREA
]
648 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
649 row
->glyphs
[RIGHT_MARGIN_AREA
]
650 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
651 row
->glyphs
[LAST_AREA
]
652 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
658 xassert (left
>= 0 && right
>= 0);
659 matrix
->left_margin_glyphs
= left
;
660 matrix
->right_margin_glyphs
= right
;
663 /* Number of rows to be used by MATRIX. */
664 matrix
->nrows
= dim
.height
;
666 /* Mark rows in a current matrix of a window as not having valid
667 contents. It's important to not do this for desired matrices.
668 When Emacs starts, it may already be building desired matrices
669 when this function runs. */
670 if (w
&& matrix
== w
->current_matrix
)
672 /* Optimize the case that only the height has changed (C-x 2,
673 upper window). Invalidate all rows that are no longer part
675 if (!marginal_areas_changed_p
676 && matrix
->window_top_y
== XFASTINT (w
->top
)
677 && matrix
->window_width
== window_width
)
680 while (matrix
->rows
[i
].enabled_p
681 && (MATRIX_ROW_BOTTOM_Y (matrix
->rows
+ i
)
682 < matrix
->window_height
))
685 /* Window end is invalid, if inside of the rows that
687 if (INTEGERP (w
->window_end_vpos
)
688 && XFASTINT (w
->window_end_vpos
) >= i
)
689 w
->window_end_valid
= Qnil
;
691 while (i
< matrix
->nrows
)
692 matrix
->rows
[i
++].enabled_p
= 0;
696 for (i
= 0; i
< matrix
->nrows
; ++i
)
697 matrix
->rows
[i
].enabled_p
= 0;
701 /* Remember last values to be able to optimize frame redraws. */
702 matrix
->matrix_x
= x
;
703 matrix
->matrix_y
= y
;
704 matrix
->matrix_w
= dim
.width
;
705 matrix
->matrix_h
= dim
.height
;
707 /* Record the top y location and height of W at the time the matrix
708 was last adjusted. This is used to optimize redisplay above. */
711 matrix
->window_top_y
= XFASTINT (w
->top
);
712 matrix
->window_height
= window_height
;
713 matrix
->window_width
= window_width
;
714 matrix
->window_vscroll
= w
->vscroll
;
719 /* Reverse the contents of rows in MATRIX between START and END. The
720 contents of the row at END - 1 end up at START, END - 2 at START +
721 1 etc. This is part of the implementation of rotate_matrix (see
725 reverse_rows (matrix
, start
, end
)
726 struct glyph_matrix
*matrix
;
731 for (i
= start
, j
= end
- 1; i
< j
; ++i
, --j
)
733 /* Non-ISO HP/UX compiler doesn't like auto struct
735 struct glyph_row temp
;
736 temp
= matrix
->rows
[i
];
737 matrix
->rows
[i
] = matrix
->rows
[j
];
738 matrix
->rows
[j
] = temp
;
743 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
744 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
745 indices. (Note: this does not copy glyphs, only glyph pointers in
746 row structures are moved around).
748 The algorithm used for rotating the vector was, I believe, first
749 described by Kernighan. See the vector R as consisting of two
750 sub-vectors AB, where A has length BY for BY >= 0. The result
751 after rotating is then BA. Reverse both sub-vectors to get ArBr
752 and reverse the result to get (ArBr)r which is BA. Similar for
756 rotate_matrix (matrix
, first
, last
, by
)
757 struct glyph_matrix
*matrix
;
762 /* Up (rotate left, i.e. towards lower indices). */
764 reverse_rows (matrix
, first
, first
+ by
);
765 reverse_rows (matrix
, first
+ by
, last
);
766 reverse_rows (matrix
, first
, last
);
770 /* Down (rotate right, i.e. towards higher indices). */
771 reverse_rows (matrix
, last
- by
, last
);
772 reverse_rows (matrix
, first
, last
- by
);
773 reverse_rows (matrix
, first
, last
);
778 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
779 with indices START <= index < END. Increment positions by DELTA/
783 increment_matrix_positions (matrix
, start
, end
, delta
, delta_bytes
)
784 struct glyph_matrix
*matrix
;
785 int start
, end
, delta
, delta_bytes
;
787 /* Check that START and END are reasonable values. */
788 xassert (start
>= 0 && start
<= matrix
->nrows
);
789 xassert (end
>= 0 && end
<= matrix
->nrows
);
790 xassert (start
<= end
);
792 for (; start
< end
; ++start
)
793 increment_row_positions (matrix
->rows
+ start
, delta
, delta_bytes
);
797 /* Enable a range of rows in glyph matrix MATRIX. START and END are
798 the row indices of the first and last + 1 row to enable. If
799 ENABLED_P is non-zero, enabled_p flags in rows will be set to 1. */
802 enable_glyph_matrix_rows (matrix
, start
, end
, enabled_p
)
803 struct glyph_matrix
*matrix
;
807 xassert (start
<= end
);
808 xassert (start
>= 0 && start
< matrix
->nrows
);
809 xassert (end
>= 0 && end
<= matrix
->nrows
);
811 for (; start
< end
; ++start
)
812 matrix
->rows
[start
].enabled_p
= enabled_p
!= 0;
818 This empties all rows in MATRIX by setting the enabled_p flag for
819 all rows of the matrix to zero. The function prepare_desired_row
820 will eventually really clear a row when it sees one with a zero
823 Resets update hints to defaults value. The only update hint
824 currently present is the flag MATRIX->no_scrolling_p. */
827 clear_glyph_matrix (matrix
)
828 struct glyph_matrix
*matrix
;
832 enable_glyph_matrix_rows (matrix
, 0, matrix
->nrows
, 0);
833 matrix
->no_scrolling_p
= 0;
838 /* Shift part of the glyph matrix MATRIX of window W up or down.
839 Increment y-positions in glyph rows between START and END by DY,
840 and recompute their visible height. */
843 shift_glyph_matrix (w
, matrix
, start
, end
, dy
)
845 struct glyph_matrix
*matrix
;
850 xassert (start
<= end
);
851 xassert (start
>= 0 && start
< matrix
->nrows
);
852 xassert (end
>= 0 && end
<= matrix
->nrows
);
854 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
855 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
857 for (; start
< end
; ++start
)
859 struct glyph_row
*row
= &matrix
->rows
[start
];
864 row
->visible_height
= row
->height
- (min_y
- row
->y
);
865 else if (row
->y
+ row
->height
> max_y
)
866 row
->visible_height
= row
->height
- (row
->y
+ row
->height
- max_y
);
868 row
->visible_height
= row
->height
;
873 /* Mark all rows in current matrices of frame F as invalid. Marking
874 invalid is done by setting enabled_p to zero for all rows in a
878 clear_current_matrices (f
)
879 register struct frame
*f
;
881 /* Clear frame current matrix, if we have one. */
882 if (f
->current_matrix
)
883 clear_glyph_matrix (f
->current_matrix
);
885 /* Clear the matrix of the menu bar window, if such a window exists.
886 The menu bar window is currently used to display menus on X when
887 no toolkit support is compiled in. */
888 if (WINDOWP (f
->menu_bar_window
))
889 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->current_matrix
);
891 /* Clear the matrix of the tool-bar window, if any. */
892 if (WINDOWP (f
->tool_bar_window
))
893 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
895 /* Clear current window matrices. */
896 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
897 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 0);
901 /* Clear out all display lines of F for a coming redisplay. */
904 clear_desired_matrices (f
)
905 register struct frame
*f
;
907 if (f
->desired_matrix
)
908 clear_glyph_matrix (f
->desired_matrix
);
910 if (WINDOWP (f
->menu_bar_window
))
911 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->desired_matrix
);
913 if (WINDOWP (f
->tool_bar_window
))
914 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->desired_matrix
);
916 /* Do it for window matrices. */
917 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
918 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
922 /* Clear matrices in window tree rooted in W. If DESIRED_P is
923 non-zero clear desired matrices, otherwise clear current matrices. */
926 clear_window_matrices (w
, desired_p
)
932 if (!NILP (w
->hchild
))
934 xassert (WINDOWP (w
->hchild
));
935 clear_window_matrices (XWINDOW (w
->hchild
), desired_p
);
937 else if (!NILP (w
->vchild
))
939 xassert (WINDOWP (w
->vchild
));
940 clear_window_matrices (XWINDOW (w
->vchild
), desired_p
);
945 clear_glyph_matrix (w
->desired_matrix
);
948 clear_glyph_matrix (w
->current_matrix
);
949 w
->window_end_valid
= Qnil
;
953 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
959 /***********************************************************************
962 See dispextern.h for an overall explanation of glyph rows.
963 ***********************************************************************/
965 /* Clear glyph row ROW. Do it in a way that makes it robust against
966 changes in the glyph_row structure, i.e. addition or removal of
967 structure members. */
970 clear_glyph_row (row
)
971 struct glyph_row
*row
;
973 struct glyph
*p
[1 + LAST_AREA
];
974 static struct glyph_row null_row
;
977 p
[LEFT_MARGIN_AREA
] = row
->glyphs
[LEFT_MARGIN_AREA
];
978 p
[TEXT_AREA
] = row
->glyphs
[TEXT_AREA
];
979 p
[RIGHT_MARGIN_AREA
] = row
->glyphs
[RIGHT_MARGIN_AREA
];
980 p
[LAST_AREA
] = row
->glyphs
[LAST_AREA
];
985 /* Restore pointers. */
986 row
->glyphs
[LEFT_MARGIN_AREA
] = p
[LEFT_MARGIN_AREA
];
987 row
->glyphs
[TEXT_AREA
] = p
[TEXT_AREA
];
988 row
->glyphs
[RIGHT_MARGIN_AREA
] = p
[RIGHT_MARGIN_AREA
];
989 row
->glyphs
[LAST_AREA
] = p
[LAST_AREA
];
993 /* Make ROW an empty, enabled row of canonical character height,
994 in window W starting at y-position Y. */
997 blank_row (w
, row
, y
)
999 struct glyph_row
*row
;
1004 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
1005 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
1007 clear_glyph_row (row
);
1009 row
->ascent
= row
->phys_ascent
= 0;
1010 row
->height
= row
->phys_height
= CANON_Y_UNIT (XFRAME (w
->frame
));
1013 row
->visible_height
= row
->height
- (min_y
- row
->y
);
1014 else if (row
->y
+ row
->height
> max_y
)
1015 row
->visible_height
= row
->height
- (row
->y
+ row
->height
- max_y
);
1017 row
->visible_height
= row
->height
;
1023 /* Increment buffer positions in glyph row ROW. DELTA and DELTA_BYTES
1024 are the amounts by which to change positions. Note that the first
1025 glyph of the text area of a row can have a buffer position even if
1026 the used count of the text area is zero. Such rows display line
1030 increment_row_positions (row
, delta
, delta_bytes
)
1031 struct glyph_row
*row
;
1032 int delta
, delta_bytes
;
1036 /* Increment start and end positions. */
1037 MATRIX_ROW_START_CHARPOS (row
) += delta
;
1038 MATRIX_ROW_START_BYTEPOS (row
) += delta_bytes
;
1039 MATRIX_ROW_END_CHARPOS (row
) += delta
;
1040 MATRIX_ROW_END_BYTEPOS (row
) += delta_bytes
;
1042 /* Increment positions in glyphs. */
1043 for (area
= 0; area
< LAST_AREA
; ++area
)
1044 for (i
= 0; i
< row
->used
[area
]; ++i
)
1045 if (BUFFERP (row
->glyphs
[area
][i
].object
)
1046 && row
->glyphs
[area
][i
].charpos
> 0)
1047 row
->glyphs
[area
][i
].charpos
+= delta
;
1049 /* Capture the case of rows displaying a line end. */
1050 if (row
->used
[TEXT_AREA
] == 0
1051 && MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1052 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
;
1097 /* Exchange pointers to glyph memory between glyph rows A and B. */
1100 swap_glyph_pointers (a
, b
)
1101 struct glyph_row
*a
, *b
;
1104 for (i
= 0; i
< LAST_AREA
+ 1; ++i
)
1106 struct glyph
*temp
= a
->glyphs
[i
];
1107 a
->glyphs
[i
] = b
->glyphs
[i
];
1108 b
->glyphs
[i
] = temp
;
1113 /* Copy glyph row structure FROM to glyph row structure TO, except
1114 that glyph pointers in the structures are left unchanged. */
1117 copy_row_except_pointers (to
, from
)
1118 struct glyph_row
*to
, *from
;
1120 struct glyph
*pointers
[1 + LAST_AREA
];
1122 /* Save glyph pointers of TO. */
1123 bcopy (to
->glyphs
, pointers
, sizeof to
->glyphs
);
1125 /* Do a structure assignment. */
1128 /* Restore original pointers of TO. */
1129 bcopy (pointers
, to
->glyphs
, sizeof to
->glyphs
);
1133 /* Copy contents of glyph row FROM to glyph row TO. Glyph pointers in
1134 TO and FROM are left unchanged. Glyph contents are copied from the
1135 glyph memory of FROM to the glyph memory of TO. Increment buffer
1136 positions in row TO by DELTA/ DELTA_BYTES. */
1139 copy_glyph_row_contents (to
, from
, delta
, delta_bytes
)
1140 struct glyph_row
*to
, *from
;
1141 int delta
, delta_bytes
;
1145 /* This is like a structure assignment TO = FROM, except that
1146 glyph pointers in the rows are left unchanged. */
1147 copy_row_except_pointers (to
, from
);
1149 /* Copy glyphs from FROM to TO. */
1150 for (area
= 0; area
< LAST_AREA
; ++area
)
1151 if (from
->used
[area
])
1152 bcopy (from
->glyphs
[area
], to
->glyphs
[area
],
1153 from
->used
[area
] * sizeof (struct glyph
));
1155 /* Increment buffer positions in TO by DELTA. */
1156 increment_row_positions (to
, delta
, delta_bytes
);
1160 /* Assign glyph row FROM to glyph row TO. This works like a structure
1161 assignment TO = FROM, except that glyph pointers are not copied but
1162 exchanged between TO and FROM. Pointers must be exchanged to avoid
1166 assign_row (to
, from
)
1167 struct glyph_row
*to
, *from
;
1169 swap_glyph_pointers (to
, from
);
1170 copy_row_except_pointers (to
, from
);
1174 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1175 a row in a window matrix, is a slice of the glyph memory of the
1176 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1177 is non-zero if the glyph memory of WINDOW_ROW is part of the glyph
1178 memory of FRAME_ROW. */
1181 glyph_row_slice_p (window_row
, frame_row
)
1182 struct glyph_row
*window_row
, *frame_row
;
1184 struct glyph
*window_glyph_start
= window_row
->glyphs
[0];
1185 struct glyph
*frame_glyph_start
= frame_row
->glyphs
[0];
1186 struct glyph
*frame_glyph_end
= frame_row
->glyphs
[LAST_AREA
];
1188 return (frame_glyph_start
<= window_glyph_start
1189 && window_glyph_start
< frame_glyph_end
);
1195 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1196 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1197 in WINDOW_MATRIX is found satisfying the condition. */
1199 static struct glyph_row
*
1200 find_glyph_row_slice (window_matrix
, frame_matrix
, row
)
1201 struct glyph_matrix
*window_matrix
, *frame_matrix
;
1206 xassert (row
>= 0 && row
< frame_matrix
->nrows
);
1208 for (i
= 0; i
< window_matrix
->nrows
; ++i
)
1209 if (glyph_row_slice_p (window_matrix
->rows
+ i
,
1210 frame_matrix
->rows
+ row
))
1213 return i
< window_matrix
->nrows
? window_matrix
->rows
+ i
: 0;
1218 /* Prepare ROW for display. Desired rows are cleared lazily,
1219 i.e. they are only marked as to be cleared by setting their
1220 enabled_p flag to zero. When a row is to be displayed, a prior
1221 call to this function really clears it. */
1224 prepare_desired_row (row
)
1225 struct glyph_row
*row
;
1227 if (!row
->enabled_p
)
1229 clear_glyph_row (row
);
1235 /* Return a hash code for glyph row ROW. */
1238 line_hash_code (row
)
1239 struct glyph_row
*row
;
1247 /* Give all highlighted lines the same hash code
1248 so as to encourage scrolling to leave them in place. */
1253 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
1254 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
1258 int c
= glyph
->u
.ch
;
1259 int face_id
= glyph
->face_id
;
1260 if (must_write_spaces
)
1262 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + c
;
1263 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + face_id
;
1276 /* Return the cost of drawing line VPOS In MATRIX. The cost equals
1277 the number of characters in the line. If must_write_spaces is
1278 zero, leading and trailing spaces are ignored. */
1281 line_draw_cost (matrix
, vpos
)
1282 struct glyph_matrix
*matrix
;
1285 struct glyph_row
*row
= matrix
->rows
+ vpos
;
1286 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
1287 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
];
1289 Lisp_Object
*glyph_table_base
= GLYPH_TABLE_BASE
;
1290 int glyph_table_len
= GLYPH_TABLE_LENGTH
;
1292 /* Ignore trailing and leading spaces if we can. */
1293 if (!must_write_spaces
)
1295 /* Skip from the end over trailing spaces. */
1296 while (end
!= beg
&& CHAR_GLYPH_SPACE_P (*end
))
1299 /* All blank line. */
1303 /* Skip over leading spaces. */
1304 while (CHAR_GLYPH_SPACE_P (*beg
))
1308 /* If we don't have a glyph-table, each glyph is one character,
1309 so return the number of glyphs. */
1310 if (glyph_table_base
== 0)
1314 /* Otherwise, scan the glyphs and accumulate their total length
1319 GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*beg
);
1322 || GLYPH_SIMPLE_P (glyph_table_base
, glyph_table_len
, g
))
1325 len
+= GLYPH_LENGTH (glyph_table_base
, g
);
1335 /* Test two glyph rows A and B for equality. Value is non-zero if A
1336 and B have equal contents. W is the window to which the glyphs
1337 rows A and B belong. It is needed here to test for partial row
1341 row_equal_p (w
, a
, b
)
1343 struct glyph_row
*a
, *b
;
1347 else if (a
->hash
!= b
->hash
)
1351 struct glyph
*a_glyph
, *b_glyph
, *a_end
;
1354 /* Compare glyphs. */
1355 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
1357 if (a
->used
[area
] != b
->used
[area
])
1360 a_glyph
= a
->glyphs
[area
];
1361 a_end
= a_glyph
+ a
->used
[area
];
1362 b_glyph
= b
->glyphs
[area
];
1364 while (a_glyph
< a_end
1365 && GLYPH_EQUAL_P (a_glyph
, b_glyph
))
1366 ++a_glyph
, ++b_glyph
;
1368 if (a_glyph
!= a_end
)
1372 if (a
->truncated_on_left_p
!= b
->truncated_on_left_p
1373 || a
->inverse_p
!= b
->inverse_p
1374 || a
->fill_line_p
!= b
->fill_line_p
1375 || a
->truncated_on_right_p
!= b
->truncated_on_right_p
1376 || a
->overlay_arrow_p
!= b
->overlay_arrow_p
1377 || a
->continued_p
!= b
->continued_p
1378 || a
->indicate_empty_line_p
!= b
->indicate_empty_line_p
1379 || a
->overlapped_p
!= b
->overlapped_p
1380 || (MATRIX_ROW_CONTINUATION_LINE_P (a
)
1381 != MATRIX_ROW_CONTINUATION_LINE_P (b
))
1382 /* Different partially visible characters on left margin. */
1384 /* Different height. */
1385 || a
->ascent
!= b
->ascent
1386 || a
->phys_ascent
!= b
->phys_ascent
1387 || a
->phys_height
!= b
->phys_height
1388 || a
->visible_height
!= b
->visible_height
)
1397 /***********************************************************************
1400 See dispextern.h for an overall explanation of glyph pools.
1401 ***********************************************************************/
1403 /* Allocate a glyph_pool structure. The structure returned is
1404 initialized with zeros. The global variable glyph_pool_count is
1405 incremented for each pool allocated. */
1407 static struct glyph_pool
*
1410 struct glyph_pool
*result
;
1412 /* Allocate a new glyph_pool and clear it. */
1413 result
= (struct glyph_pool
*) xmalloc (sizeof *result
);
1414 bzero (result
, sizeof *result
);
1416 /* For memory leak and double deletion checking. */
1423 /* Free a glyph_pool structure POOL. The function may be called with
1424 a null POOL pointer. The global variable glyph_pool_count is
1425 decremented with every pool structure freed. If this count gets
1426 negative, more structures were freed than allocated, i.e. one
1427 structure must have been freed more than once or a bogus pointer
1428 was passed to free_glyph_pool. */
1431 free_glyph_pool (pool
)
1432 struct glyph_pool
*pool
;
1436 /* More freed than allocated? */
1438 xassert (glyph_pool_count
>= 0);
1440 xfree (pool
->glyphs
);
1446 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1447 columns we need. This function never shrinks a pool. The only
1448 case in which this would make sense, would be when a frame's size
1449 is changed from a large value to a smaller one. But, if someone
1450 does it once, we can expect that he will do it again.
1452 Value is non-zero if the pool changed in a way which makes
1453 re-adjusting window glyph matrices necessary. */
1456 realloc_glyph_pool (pool
, matrix_dim
)
1457 struct glyph_pool
*pool
;
1458 struct dim matrix_dim
;
1463 changed_p
= (pool
->glyphs
== 0
1464 || matrix_dim
.height
!= pool
->nrows
1465 || matrix_dim
.width
!= pool
->ncolumns
);
1467 /* Enlarge the glyph pool. */
1468 needed
= matrix_dim
.width
* matrix_dim
.height
;
1469 if (needed
> pool
->nglyphs
)
1471 int size
= needed
* sizeof (struct glyph
);
1474 pool
->glyphs
= (struct glyph
*) xrealloc (pool
->glyphs
, size
);
1477 pool
->glyphs
= (struct glyph
*) xmalloc (size
);
1478 bzero (pool
->glyphs
, size
);
1481 pool
->nglyphs
= needed
;
1484 /* Remember the number of rows and columns because (a) we use then
1485 to do sanity checks, and (b) the number of columns determines
1486 where rows in the frame matrix start---this must be available to
1487 determine pointers to rows of window sub-matrices. */
1488 pool
->nrows
= matrix_dim
.height
;
1489 pool
->ncolumns
= matrix_dim
.width
;
1496 /***********************************************************************
1498 ***********************************************************************/
1503 /* Flush standard output. This is sometimes useful to call from
1513 /* Check that no glyph pointers have been lost in MATRIX. If a
1514 pointer has been lost, e.g. by using a structure assignment between
1515 rows, at least one pointer must occur more than once in the rows of
1519 check_matrix_pointer_lossage (matrix
)
1520 struct glyph_matrix
*matrix
;
1524 for (i
= 0; i
< matrix
->nrows
; ++i
)
1525 for (j
= 0; j
< matrix
->nrows
; ++j
)
1527 || (matrix
->rows
[i
].glyphs
[TEXT_AREA
]
1528 != matrix
->rows
[j
].glyphs
[TEXT_AREA
]));
1532 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1535 matrix_row (matrix
, row
)
1536 struct glyph_matrix
*matrix
;
1539 xassert (matrix
&& matrix
->rows
);
1540 xassert (row
>= 0 && row
< matrix
->nrows
);
1542 /* That's really too slow for normal testing because this function
1543 is called almost everywhere. Although---it's still astonishingly
1544 fast, so it is valuable to have for debugging purposes. */
1546 check_matrix_pointer_lossage (matrix
);
1549 return matrix
->rows
+ row
;
1553 #if 0 /* This function makes invalid assumptions when text is
1554 partially invisible. But it might come handy for debugging
1557 /* Check invariants that must hold for an up to date current matrix of
1561 check_matrix_invariants (w
)
1564 struct glyph_matrix
*matrix
= w
->current_matrix
;
1565 int yb
= window_text_bottom_y (w
);
1566 struct glyph_row
*row
= matrix
->rows
;
1567 struct glyph_row
*last_text_row
= NULL
;
1568 struct buffer
*saved
= current_buffer
;
1569 struct buffer
*buffer
= XBUFFER (w
->buffer
);
1572 /* This can sometimes happen for a fresh window. */
1573 if (matrix
->nrows
< 2)
1576 set_buffer_temp (buffer
);
1578 /* Note: last row is always reserved for the mode line. */
1579 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1580 && MATRIX_ROW_BOTTOM_Y (row
) < yb
)
1582 struct glyph_row
*next
= row
+ 1;
1584 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1585 last_text_row
= row
;
1587 /* Check that character and byte positions are in sync. */
1588 xassert (MATRIX_ROW_START_BYTEPOS (row
)
1589 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row
)));
1591 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1592 have such a position temporarily in case of a minibuffer
1593 displaying something like `[Sole completion]' at its end. */
1594 if (MATRIX_ROW_END_CHARPOS (row
) < BUF_ZV (current_buffer
))
1595 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1596 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row
)));
1598 /* Check that end position of `row' is equal to start position
1600 if (next
->enabled_p
&& MATRIX_ROW_DISPLAYS_TEXT_P (next
))
1602 xassert (MATRIX_ROW_END_CHARPOS (row
)
1603 == MATRIX_ROW_START_CHARPOS (next
));
1604 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1605 == MATRIX_ROW_START_BYTEPOS (next
));
1610 xassert (w
->current_matrix
->nrows
== w
->desired_matrix
->nrows
);
1611 xassert (w
->desired_matrix
->rows
!= NULL
);
1612 set_buffer_temp (saved
);
1617 #endif /* GLYPH_DEBUG != 0 */
1621 /**********************************************************************
1622 Allocating/ Adjusting Glyph Matrices
1623 **********************************************************************/
1625 /* Allocate glyph matrices over a window tree for a frame-based
1628 X and Y are column/row within the frame glyph matrix where
1629 sub-matrices for the window tree rooted at WINDOW must be
1630 allocated. CH_DIM contains the dimensions of the smallest
1631 character that could be used during display. DIM_ONLY_P non-zero
1632 means that the caller of this function is only interested in the
1633 result matrix dimension, and matrix adjustments should not be
1636 The function returns the total width/height of the sub-matrices of
1637 the window tree. If called on a frame root window, the computation
1638 will take the mini-buffer window into account.
1640 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1642 NEW_LEAF_MATRIX set if any window in the tree did not have a
1643 glyph matrices yet, and
1645 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1646 any window in the tree will be changed or have been changed (see
1649 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1652 Windows are arranged into chains of windows on the same level
1653 through the next fields of window structures. Such a level can be
1654 either a sequence of horizontally adjacent windows from left to
1655 right, or a sequence of vertically adjacent windows from top to
1656 bottom. Each window in a horizontal sequence can be either a leaf
1657 window or a vertical sequence; a window in a vertical sequence can
1658 be either a leaf or a horizontal sequence. All windows in a
1659 horizontal sequence have the same height, and all windows in a
1660 vertical sequence have the same width.
1662 This function uses, for historical reasons, a more general
1663 algorithm to determine glyph matrix dimensions that would be
1666 The matrix height of a horizontal sequence is determined by the
1667 maximum height of any matrix in the sequence. The matrix width of
1668 a horizontal sequence is computed by adding up matrix widths of
1669 windows in the sequence.
1671 |<------- result width ------->|
1672 +---------+----------+---------+ ---
1675 +---------+ | | result height
1680 The matrix width of a vertical sequence is the maximum matrix width
1681 of any window in the sequence. Its height is computed by adding up
1682 matrix heights of windows in the sequence.
1684 |<---- result width -->|
1692 +------------+---------+ |
1695 +------------+---------+ --- */
1697 /* Bit indicating that a new matrix will be allocated or has been
1700 #define NEW_LEAF_MATRIX (1 << 0)
1702 /* Bit indicating that a matrix will or has changed its location or
1705 #define CHANGED_LEAF_MATRIX (1 << 1)
1708 allocate_matrices_for_frame_redisplay (window
, x
, y
, ch_dim
,
1709 dim_only_p
, window_change_flags
)
1714 int *window_change_flags
;
1716 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1718 int wmax
= 0, hmax
= 0;
1722 int in_horz_combination_p
;
1724 /* What combination is WINDOW part of? Compute this once since the
1725 result is the same for all windows in the `next' chain. The
1726 special case of a root window (parent equal to nil) is treated
1727 like a vertical combination because a root window's `next'
1728 points to the mini-buffer window, if any, which is arranged
1729 vertically below other windows. */
1730 in_horz_combination_p
1731 = (!NILP (XWINDOW (window
)->parent
)
1732 && !NILP (XWINDOW (XWINDOW (window
)->parent
)->hchild
));
1734 /* For WINDOW and all windows on the same level. */
1737 w
= XWINDOW (window
);
1739 /* Get the dimension of the window sub-matrix for W, depending
1740 on whether this a combination or a leaf window. */
1741 if (!NILP (w
->hchild
))
1742 dim
= allocate_matrices_for_frame_redisplay (w
->hchild
, x
, y
, ch_dim
,
1744 window_change_flags
);
1745 else if (!NILP (w
->vchild
))
1746 dim
= allocate_matrices_for_frame_redisplay (w
->vchild
, x
, y
, ch_dim
,
1748 window_change_flags
);
1751 /* If not already done, allocate sub-matrix structures. */
1752 if (w
->desired_matrix
== NULL
)
1754 w
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1755 w
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1756 *window_change_flags
|= NEW_LEAF_MATRIX
;
1759 /* Width and height MUST be chosen so that there are no
1760 holes in the frame matrix. */
1761 dim
.width
= XINT (w
->width
);
1762 dim
.height
= XINT (w
->height
);
1764 /* Will matrix be re-allocated? */
1765 if (x
!= w
->desired_matrix
->matrix_x
1766 || y
!= w
->desired_matrix
->matrix_y
1767 || dim
.width
!= w
->desired_matrix
->matrix_w
1768 || dim
.height
!= w
->desired_matrix
->matrix_h
1769 || (margin_glyphs_to_reserve (w
, dim
.width
,
1770 w
->right_margin_width
)
1771 != w
->desired_matrix
->left_margin_glyphs
)
1772 || (margin_glyphs_to_reserve (w
, dim
.width
,
1773 w
->left_margin_width
)
1774 != w
->desired_matrix
->right_margin_glyphs
))
1775 *window_change_flags
|= CHANGED_LEAF_MATRIX
;
1777 /* Actually change matrices, if allowed. Do not consider
1778 CHANGED_LEAF_MATRIX computed above here because the pool
1779 may have been changed which we don't now here. We trust
1780 that we only will be called with DIM_ONLY_P != 0 when
1784 adjust_glyph_matrix (w
, w
->desired_matrix
, x
, y
, dim
);
1785 adjust_glyph_matrix (w
, w
->current_matrix
, x
, y
, dim
);
1789 /* If we are part of a horizontal combination, advance x for
1790 windows to the right of W; otherwise advance y for windows
1792 if (in_horz_combination_p
)
1797 /* Remember maximum glyph matrix dimensions. */
1798 wmax
= max (wmax
, dim
.width
);
1799 hmax
= max (hmax
, dim
.height
);
1801 /* Next window on same level. */
1804 while (!NILP (window
));
1806 /* Set `total' to the total glyph matrix dimension of this window
1807 level. In a vertical combination, the width is the width of the
1808 widest window; the height is the y we finally reached, corrected
1809 by the y we started with. In a horizontal combination, the total
1810 height is the height of the tallest window, and the width is the
1811 x we finally reached, corrected by the x we started with. */
1812 if (in_horz_combination_p
)
1814 total
.width
= x
- x0
;
1815 total
.height
= hmax
;
1820 total
.height
= y
- y0
;
1827 /* Allocate window matrices for window-based redisplay. W is the
1828 window whose matrices must be allocated/reallocated. CH_DIM is the
1829 size of the smallest character that could potentially be used on W. */
1832 allocate_matrices_for_window_redisplay (w
, ch_dim
)
1836 struct frame
*f
= XFRAME (w
->frame
);
1840 if (!NILP (w
->vchild
))
1841 allocate_matrices_for_window_redisplay (XWINDOW (w
->vchild
), ch_dim
);
1842 else if (!NILP (w
->hchild
))
1843 allocate_matrices_for_window_redisplay (XWINDOW (w
->hchild
), ch_dim
);
1846 /* W is a leaf window. */
1847 int window_pixel_width
= XFLOATINT (w
->width
) * CANON_X_UNIT (f
);
1848 int window_pixel_height
= window_box_height (w
) + abs (w
->vscroll
);
1851 /* If matrices are not yet allocated, allocate them now. */
1852 if (w
->desired_matrix
== NULL
)
1854 w
->desired_matrix
= new_glyph_matrix (NULL
);
1855 w
->current_matrix
= new_glyph_matrix (NULL
);
1858 /* Compute number of glyphs needed in a glyph row. */
1859 dim
.width
= (((window_pixel_width
+ ch_dim
.width
- 1)
1861 /* 2 partially visible columns in the text area. */
1863 /* One partially visible column at the right
1864 edge of each marginal area. */
1867 /* Compute number of glyph rows needed. */
1868 dim
.height
= (((window_pixel_height
+ ch_dim
.height
- 1)
1870 /* One partially visible line at the top and
1871 bottom of the window. */
1873 /* 2 for top and mode line. */
1876 /* Change matrices. */
1877 adjust_glyph_matrix (w
, w
->desired_matrix
, 0, 0, dim
);
1878 adjust_glyph_matrix (w
, w
->current_matrix
, 0, 0, dim
);
1881 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
1886 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
1887 do it for all frames; otherwise do it just for the given frame.
1888 This function must be called when a new frame is created, its size
1889 changes, or its window configuration changes. */
1895 /* Block input so that expose events and other events that access
1896 glyph matrices are not processed while we are changing them. */
1900 adjust_frame_glyphs (f
);
1903 Lisp_Object tail
, lisp_frame
;
1905 FOR_EACH_FRAME (tail
, lisp_frame
)
1906 adjust_frame_glyphs (XFRAME (lisp_frame
));
1913 /* Adjust frame glyphs when Emacs is initialized.
1915 To be called from init_display.
1917 We need a glyph matrix because redraw will happen soon.
1918 Unfortunately, window sizes on selected_frame are not yet set to
1919 meaningful values. I believe we can assume that there are only two
1920 windows on the frame---the mini-buffer and the root window. Frame
1921 height and width seem to be correct so far. So, set the sizes of
1922 windows to estimated values. */
1925 adjust_frame_glyphs_initially ()
1927 struct frame
*sf
= SELECTED_FRAME ();
1928 struct window
*root
= XWINDOW (sf
->root_window
);
1929 struct window
*mini
= XWINDOW (root
->next
);
1930 int frame_height
= FRAME_HEIGHT (sf
);
1931 int frame_width
= FRAME_WIDTH (sf
);
1932 int top_margin
= FRAME_TOP_MARGIN (sf
);
1934 /* Do it for the root window. */
1935 XSETFASTINT (root
->top
, top_margin
);
1936 XSETFASTINT (root
->width
, frame_width
);
1937 set_window_height (sf
->root_window
, frame_height
- 1 - top_margin
, 0);
1939 /* Do it for the mini-buffer window. */
1940 XSETFASTINT (mini
->top
, frame_height
- 1);
1941 XSETFASTINT (mini
->width
, frame_width
);
1942 set_window_height (root
->next
, 1, 0);
1944 adjust_frame_glyphs (sf
);
1945 glyphs_initialized_initially_p
= 1;
1949 /* Allocate/reallocate glyph matrices of a single frame F. */
1952 adjust_frame_glyphs (f
)
1955 if (FRAME_WINDOW_P (f
))
1956 adjust_frame_glyphs_for_window_redisplay (f
);
1958 adjust_frame_glyphs_for_frame_redisplay (f
);
1960 /* Don't forget the message buffer and the buffer for
1961 decode_mode_spec. */
1962 adjust_frame_message_buffer (f
);
1963 adjust_decode_mode_spec_buffer (f
);
1965 f
->glyphs_initialized_p
= 1;
1969 /* Allocate/reallocate glyph matrices of a single frame F for
1970 frame-based redisplay. */
1973 adjust_frame_glyphs_for_frame_redisplay (f
)
1977 struct dim matrix_dim
;
1979 int window_change_flags
;
1982 if (!FRAME_LIVE_P (f
))
1985 /* Determine the smallest character in any font for F. On
1986 console windows, all characters have dimension (1, 1). */
1987 ch_dim
.width
= ch_dim
.height
= 1;
1989 top_window_y
= FRAME_TOP_MARGIN (f
);
1991 /* Allocate glyph pool structures if not already done. */
1992 if (f
->desired_pool
== NULL
)
1994 f
->desired_pool
= new_glyph_pool ();
1995 f
->current_pool
= new_glyph_pool ();
1998 /* Allocate frames matrix structures if needed. */
1999 if (f
->desired_matrix
== NULL
)
2001 f
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
2002 f
->current_matrix
= new_glyph_matrix (f
->current_pool
);
2005 /* Compute window glyph matrices. (This takes the mini-buffer
2006 window into account). The result is the size of the frame glyph
2007 matrix needed. The variable window_change_flags is set to a bit
2008 mask indicating whether new matrices will be allocated or
2009 existing matrices change their size or location within the frame
2011 window_change_flags
= 0;
2013 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2016 &window_change_flags
);
2018 /* Add in menu bar lines, if any. */
2019 matrix_dim
.height
+= top_window_y
;
2021 /* Enlarge pools as necessary. */
2022 pool_changed_p
= realloc_glyph_pool (f
->desired_pool
, matrix_dim
);
2023 realloc_glyph_pool (f
->current_pool
, matrix_dim
);
2025 /* Set up glyph pointers within window matrices. Do this only if
2026 absolutely necessary since it requires a frame redraw. */
2027 if (pool_changed_p
|| window_change_flags
)
2029 /* Do it for window matrices. */
2030 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2031 0, top_window_y
, ch_dim
, 0,
2032 &window_change_flags
);
2034 /* Size of frame matrices must equal size of frame. Note
2035 that we are called for X frames with window widths NOT equal
2036 to the frame width (from CHANGE_FRAME_SIZE_1). */
2037 xassert (matrix_dim
.width
== FRAME_WIDTH (f
)
2038 && matrix_dim
.height
== FRAME_HEIGHT (f
));
2040 /* Resize frame matrices. */
2041 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2042 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2044 /* Since location and size of sub-matrices within the pool may
2045 have changed, and current matrices don't have meaningful
2046 contents anymore, mark the frame garbaged. */
2047 SET_FRAME_GARBAGED (f
);
2052 /* Allocate/reallocate glyph matrices of a single frame F for
2053 window-based redisplay. */
2056 adjust_frame_glyphs_for_window_redisplay (f
)
2062 xassert (FRAME_WINDOW_P (f
) && FRAME_LIVE_P (f
));
2064 /* Get minimum sizes. */
2065 #ifdef HAVE_WINDOW_SYSTEM
2066 ch_dim
.width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2067 ch_dim
.height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
2069 ch_dim
.width
= ch_dim
.height
= 1;
2072 /* Allocate/reallocate window matrices. */
2073 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f
)),
2076 /* Allocate/ reallocate matrices of the dummy window used to display
2077 the menu bar under X when no X toolkit support is available. */
2078 #ifndef USE_X_TOOLKIT
2080 /* Allocate a dummy window if not already done. */
2081 if (NILP (f
->menu_bar_window
))
2083 f
->menu_bar_window
= make_window ();
2084 w
= XWINDOW (f
->menu_bar_window
);
2085 XSETFRAME (w
->frame
, f
);
2086 w
->pseudo_window_p
= 1;
2089 w
= XWINDOW (f
->menu_bar_window
);
2091 /* Set window dimensions to frame dimensions and allocate or
2092 adjust glyph matrices of W. */
2093 XSETFASTINT (w
->top
, 0);
2094 XSETFASTINT (w
->left
, 0);
2095 XSETFASTINT (w
->height
, FRAME_MENU_BAR_LINES (f
));
2096 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2097 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2099 #endif /* not USE_X_TOOLKIT */
2101 /* Allocate/ reallocate matrices of the tool bar window. If we
2102 don't have a tool bar window yet, make one. */
2103 if (NILP (f
->tool_bar_window
))
2105 f
->tool_bar_window
= make_window ();
2106 w
= XWINDOW (f
->tool_bar_window
);
2107 XSETFRAME (w
->frame
, f
);
2108 w
->pseudo_window_p
= 1;
2111 w
= XWINDOW (f
->tool_bar_window
);
2113 XSETFASTINT (w
->top
, FRAME_MENU_BAR_LINES (f
));
2114 XSETFASTINT (w
->left
, 0);
2115 XSETFASTINT (w
->height
, FRAME_TOOL_BAR_LINES (f
));
2116 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2117 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2121 /* Adjust/ allocate message buffer of frame F.
2123 Note that the message buffer is never freed. Since I could not
2124 find a free in 19.34, I assume that freeing it would be
2125 problematic in some way and don't do it either.
2127 (Implementation note: It should be checked if we can free it
2128 eventually without causing trouble). */
2131 adjust_frame_message_buffer (f
)
2134 int size
= FRAME_MESSAGE_BUF_SIZE (f
) + 1;
2136 if (FRAME_MESSAGE_BUF (f
))
2138 char *buffer
= FRAME_MESSAGE_BUF (f
);
2139 char *new_buffer
= (char *) xrealloc (buffer
, size
);
2140 FRAME_MESSAGE_BUF (f
) = new_buffer
;
2143 FRAME_MESSAGE_BUF (f
) = (char *) xmalloc (size
);
2147 /* Re-allocate buffer for decode_mode_spec on frame F. */
2150 adjust_decode_mode_spec_buffer (f
)
2153 f
->decode_mode_spec_buffer
2154 = (char *) xrealloc (f
->decode_mode_spec_buffer
,
2155 FRAME_MESSAGE_BUF_SIZE (f
) + 1);
2160 /**********************************************************************
2161 Freeing Glyph Matrices
2162 **********************************************************************/
2164 /* Free glyph memory for a frame F. F may be null. This function can
2165 be called for the same frame more than once. The root window of
2166 F may be nil when this function is called. This is the case when
2167 the function is called when F is destroyed. */
2173 if (f
&& f
->glyphs_initialized_p
)
2175 /* Block interrupt input so that we don't get surprised by an X
2176 event while we're in an inconsistent state. */
2178 f
->glyphs_initialized_p
= 0;
2180 /* Release window sub-matrices. */
2181 if (!NILP (f
->root_window
))
2182 free_window_matrices (XWINDOW (f
->root_window
));
2184 /* Free the dummy window for menu bars without X toolkit and its
2186 if (!NILP (f
->menu_bar_window
))
2188 struct window
*w
= XWINDOW (f
->menu_bar_window
);
2189 free_glyph_matrix (w
->desired_matrix
);
2190 free_glyph_matrix (w
->current_matrix
);
2191 w
->desired_matrix
= w
->current_matrix
= NULL
;
2192 f
->menu_bar_window
= Qnil
;
2195 /* Free the tool bar window and its glyph matrices. */
2196 if (!NILP (f
->tool_bar_window
))
2198 struct window
*w
= XWINDOW (f
->tool_bar_window
);
2199 free_glyph_matrix (w
->desired_matrix
);
2200 free_glyph_matrix (w
->current_matrix
);
2201 w
->desired_matrix
= w
->current_matrix
= NULL
;
2202 f
->tool_bar_window
= Qnil
;
2205 /* Release frame glyph matrices. Reset fields to zero in
2206 case we are called a second time. */
2207 if (f
->desired_matrix
)
2209 free_glyph_matrix (f
->desired_matrix
);
2210 free_glyph_matrix (f
->current_matrix
);
2211 f
->desired_matrix
= f
->current_matrix
= NULL
;
2214 /* Release glyph pools. */
2215 if (f
->desired_pool
)
2217 free_glyph_pool (f
->desired_pool
);
2218 free_glyph_pool (f
->current_pool
);
2219 f
->desired_pool
= f
->current_pool
= NULL
;
2227 /* Free glyph sub-matrices in the window tree rooted at W. This
2228 function may be called with a null pointer, and it may be called on
2229 the same tree more than once. */
2232 free_window_matrices (w
)
2237 if (!NILP (w
->hchild
))
2238 free_window_matrices (XWINDOW (w
->hchild
));
2239 else if (!NILP (w
->vchild
))
2240 free_window_matrices (XWINDOW (w
->vchild
));
2243 /* This is a leaf window. Free its memory and reset fields
2244 to zero in case this function is called a second time for
2246 free_glyph_matrix (w
->current_matrix
);
2247 free_glyph_matrix (w
->desired_matrix
);
2248 w
->current_matrix
= w
->desired_matrix
= NULL
;
2251 /* Next window on same level. */
2252 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2257 /* Check glyph memory leaks. This function is called from
2258 shut_down_emacs. Note that frames are not destroyed when Emacs
2259 exits. We therefore free all glyph memory for all active frames
2260 explicitly and check that nothing is left allocated. */
2263 check_glyph_memory ()
2265 Lisp_Object tail
, frame
;
2267 /* Free glyph memory for all frames. */
2268 FOR_EACH_FRAME (tail
, frame
)
2269 free_glyphs (XFRAME (frame
));
2271 /* Check that nothing is left allocated. */
2272 if (glyph_matrix_count
)
2274 if (glyph_pool_count
)
2280 /**********************************************************************
2281 Building a Frame Matrix
2282 **********************************************************************/
2284 /* Most of the redisplay code works on glyph matrices attached to
2285 windows. This is a good solution most of the time, but it is not
2286 suitable for terminal code. Terminal output functions cannot rely
2287 on being able to set an arbitrary terminal window. Instead they
2288 must be provided with a view of the whole frame, i.e. the whole
2289 screen. We build such a view by constructing a frame matrix from
2290 window matrices in this section.
2292 Windows that must be updated have their must_be_update_p flag set.
2293 For all such windows, their desired matrix is made part of the
2294 desired frame matrix. For other windows, their current matrix is
2295 made part of the desired frame matrix.
2297 +-----------------+----------------+
2298 | desired | desired |
2300 +-----------------+----------------+
2303 +----------------------------------+
2305 Desired window matrices can be made part of the frame matrix in a
2306 cheap way: We exploit the fact that the desired frame matrix and
2307 desired window matrices share their glyph memory. This is not
2308 possible for current window matrices. Their glyphs are copied to
2309 the desired frame matrix. The latter is equivalent to
2310 preserve_other_columns in the old redisplay.
2312 Used glyphs counters for frame matrix rows are the result of adding
2313 up glyph lengths of the window matrices. A line in the frame
2314 matrix is enabled, if a corresponding line in a window matrix is
2317 After building the desired frame matrix, it will be passed to
2318 terminal code, which will manipulate both the desired and current
2319 frame matrix. Changes applied to the frame's current matrix have
2320 to be visible in current window matrices afterwards, of course.
2322 This problem is solved like this:
2324 1. Window and frame matrices share glyphs. Window matrices are
2325 constructed in a way that their glyph contents ARE the glyph
2326 contents needed in a frame matrix. Thus, any modification of
2327 glyphs done in terminal code will be reflected in window matrices
2330 2. Exchanges of rows in a frame matrix done by terminal code are
2331 intercepted by hook functions so that corresponding row operations
2332 on window matrices can be performed. This is necessary because we
2333 use pointers to glyphs in glyph row structures. To satisfy the
2334 assumption of point 1 above that glyphs are updated implicitly in
2335 window matrices when they are manipulated via the frame matrix,
2336 window and frame matrix must of course agree where to find the
2337 glyphs for their rows. Possible manipulations that must be
2338 mirrored are assignments of rows of the desired frame matrix to the
2339 current frame matrix and scrolling the current frame matrix. */
2341 /* Build frame F's desired matrix from window matrices. Only windows
2342 which have the flag must_be_updated_p set have to be updated. Menu
2343 bar lines of a frame are not covered by window matrices, so make
2344 sure not to touch them in this function. */
2347 build_frame_matrix (f
)
2352 /* F must have a frame matrix when this function is called. */
2353 xassert (!FRAME_WINDOW_P (f
));
2355 /* Clear all rows in the frame matrix covered by window matrices.
2356 Menu bar lines are not covered by windows. */
2357 for (i
= FRAME_TOP_MARGIN (f
); i
< f
->desired_matrix
->nrows
; ++i
)
2358 clear_glyph_row (MATRIX_ROW (f
->desired_matrix
, i
));
2360 /* Build the matrix by walking the window tree. */
2361 build_frame_matrix_from_window_tree (f
->desired_matrix
,
2362 XWINDOW (FRAME_ROOT_WINDOW (f
)));
2366 /* Walk a window tree, building a frame matrix MATRIX from window
2367 matrices. W is the root of a window tree. */
2370 build_frame_matrix_from_window_tree (matrix
, w
)
2371 struct glyph_matrix
*matrix
;
2376 if (!NILP (w
->hchild
))
2377 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->hchild
));
2378 else if (!NILP (w
->vchild
))
2379 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->vchild
));
2381 build_frame_matrix_from_leaf_window (matrix
, w
);
2383 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2388 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2389 desired frame matrix built. W is a leaf window whose desired or
2390 current matrix is to be added to FRAME_MATRIX. W's flag
2391 must_be_updated_p determines which matrix it contributes to
2392 FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix
2393 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2394 Adding a desired matrix means setting up used counters and such in
2395 frame rows, while adding a current window matrix to FRAME_MATRIX
2396 means copying glyphs. The latter case corresponds to
2397 preserve_other_columns in the old redisplay. */
2400 build_frame_matrix_from_leaf_window (frame_matrix
, w
)
2401 struct glyph_matrix
*frame_matrix
;
2404 struct glyph_matrix
*window_matrix
;
2405 int window_y
, frame_y
;
2406 /* If non-zero, a glyph to insert at the right border of W. */
2407 GLYPH right_border_glyph
= 0;
2409 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2410 if (w
->must_be_updated_p
)
2412 window_matrix
= w
->desired_matrix
;
2414 /* Decide whether we want to add a vertical border glyph. */
2415 if (!WINDOW_RIGHTMOST_P (w
))
2417 struct Lisp_Char_Table
*dp
= window_display_table (w
);
2418 right_border_glyph
= (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
2419 ? XINT (DISP_BORDER_GLYPH (dp
))
2424 window_matrix
= w
->current_matrix
;
2426 /* For all rows in the window matrix and corresponding rows in the
2429 frame_y
= window_matrix
->matrix_y
;
2430 while (window_y
< window_matrix
->nrows
)
2432 struct glyph_row
*frame_row
= frame_matrix
->rows
+ frame_y
;
2433 struct glyph_row
*window_row
= window_matrix
->rows
+ window_y
;
2435 /* Fill up the frame row with spaces up to the left margin of the
2437 fill_up_frame_row_with_spaces (frame_row
, window_matrix
->matrix_x
);
2439 /* Fill up areas in the window matrix row with spaces. */
2440 fill_up_glyph_row_with_spaces (window_row
);
2442 if (window_matrix
== w
->current_matrix
)
2444 /* We have to copy W's current matrix. Copy window
2445 row to frame row. */
2446 bcopy (window_row
->glyphs
[0],
2447 frame_row
->glyphs
[TEXT_AREA
] + window_matrix
->matrix_x
,
2448 window_matrix
->matrix_w
* sizeof (struct glyph
));
2452 /* Copy W's desired matrix. */
2454 /* Maybe insert a vertical border between horizontally adjacent
2456 if (right_border_glyph
)
2458 struct glyph
*border
= window_row
->glyphs
[LAST_AREA
] - 1;
2459 SET_CHAR_GLYPH_FROM_GLYPH (*border
, right_border_glyph
);
2462 #if 0 /* This shouldn't be necessary. Let's check it. */
2463 /* Due to hooks installed, it normally doesn't happen that
2464 window rows and frame rows of the same matrix are out of
2465 sync, i.e. have a different understanding of where to
2466 find glyphs for the row. The following is a safety-belt
2467 that doesn't cost much and makes absolutely sure that
2468 window and frame matrices are in sync. */
2469 if (!glyph_row_slice_p (window_row
, frame_row
))
2471 /* Find the row in the window being a slice. There
2472 should exist one from program logic. */
2473 struct glyph_row
*slice_row
2474 = find_glyph_row_slice (window_matrix
, frame_matrix
, frame_y
);
2475 xassert (slice_row
!= 0);
2477 /* Exchange glyphs between both window rows. */
2478 swap_glyphs_in_rows (window_row
, slice_row
);
2480 /* Exchange pointers between both rows. */
2481 swap_glyph_pointers (window_row
, slice_row
);
2485 /* Window row window_y must be a slice of frame row
2487 xassert (glyph_row_slice_p (window_row
, frame_row
));
2489 /* If rows are in sync, we don't have to copy glyphs because
2490 frame and window share glyphs. */
2493 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
2497 /* Set number of used glyphs in the frame matrix. Since we fill
2498 up with spaces, and visit leaf windows from left to right it
2499 can be done simply. */
2500 frame_row
->used
[TEXT_AREA
]
2501 = window_matrix
->matrix_x
+ window_matrix
->matrix_w
;
2504 frame_row
->enabled_p
|= window_row
->enabled_p
;
2505 frame_row
->inverse_p
|= window_row
->inverse_p
;
2514 /* Add spaces to a glyph row ROW in a window matrix.
2516 Each row has the form:
2518 +---------+-----------------------------+------------+
2519 | left | text | right |
2520 +---------+-----------------------------+------------+
2522 Left and right marginal areas are optional. This function adds
2523 spaces to areas so that there are no empty holes between areas.
2524 In other words: If the right area is not empty, the text area
2525 is filled up with spaces up to the right area. If the text area
2526 is not empty, the left area is filled up.
2528 To be called for frame-based redisplay, only. */
2531 fill_up_glyph_row_with_spaces (row
)
2532 struct glyph_row
*row
;
2534 fill_up_glyph_row_area_with_spaces (row
, LEFT_MARGIN_AREA
);
2535 fill_up_glyph_row_area_with_spaces (row
, TEXT_AREA
);
2536 fill_up_glyph_row_area_with_spaces (row
, RIGHT_MARGIN_AREA
);
2540 /* Fill area AREA of glyph row ROW with spaces. To be called for
2541 frame-based redisplay only. */
2544 fill_up_glyph_row_area_with_spaces (row
, area
)
2545 struct glyph_row
*row
;
2548 if (row
->glyphs
[area
] < row
->glyphs
[area
+ 1])
2550 struct glyph
*end
= row
->glyphs
[area
+ 1];
2551 struct glyph
*text
= row
->glyphs
[area
] + row
->used
[area
];
2554 *text
++ = space_glyph
;
2555 row
->used
[area
] = text
- row
->glyphs
[area
];
2560 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2561 reached. In frame matrices only one area, TEXT_AREA, is used. */
2564 fill_up_frame_row_with_spaces (row
, upto
)
2565 struct glyph_row
*row
;
2568 int i
= row
->used
[TEXT_AREA
];
2569 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
2572 glyph
[i
++] = space_glyph
;
2574 row
->used
[TEXT_AREA
] = i
;
2579 /**********************************************************************
2580 Mirroring operations on frame matrices in window matrices
2581 **********************************************************************/
2583 /* Set frame being updated via frame-based redisplay to F. This
2584 function must be called before updates to make explicit that we are
2585 working on frame matrices or not. */
2588 set_frame_matrix_frame (f
)
2591 frame_matrix_frame
= f
;
2595 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2596 DESIRED_MATRIX is the desired matrix corresponding to
2597 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2598 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2599 frame_matrix_frame is non-null, this indicates that the exchange is
2600 done in frame matrices, and that we have to perform analogous
2601 operations in window matrices of frame_matrix_frame. */
2604 make_current (desired_matrix
, current_matrix
, row
)
2605 struct glyph_matrix
*desired_matrix
, *current_matrix
;
2608 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, row
);
2609 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, row
);
2611 /* Do current_row = desired_row. This exchanges glyph pointers
2612 between both rows, and does a structure assignment otherwise. */
2613 assign_row (current_row
, desired_row
);
2615 /* Enable current_row to mark it as valid. */
2616 current_row
->enabled_p
= 1;
2618 /* If we are called on frame matrices, perform analogous operations
2619 for window matrices. */
2620 if (frame_matrix_frame
)
2621 mirror_make_current (XWINDOW (frame_matrix_frame
->root_window
), row
);
2625 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2626 W's frame which has been made current (by swapping pointers between
2627 current and desired matrix). Perform analogous operations in the
2628 matrices of leaf windows in the window tree rooted at W. */
2631 mirror_make_current (w
, frame_row
)
2637 if (!NILP (w
->hchild
))
2638 mirror_make_current (XWINDOW (w
->hchild
), frame_row
);
2639 else if (!NILP (w
->vchild
))
2640 mirror_make_current (XWINDOW (w
->vchild
), frame_row
);
2643 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2644 here because the checks performed in debug mode there
2645 will not allow the conversion. */
2646 int row
= frame_row
- w
->desired_matrix
->matrix_y
;
2648 /* If FRAME_ROW is within W, assign the desired row to the
2649 current row (exchanging glyph pointers). */
2650 if (row
>= 0 && row
< w
->desired_matrix
->matrix_h
)
2652 struct glyph_row
*current_row
2653 = MATRIX_ROW (w
->current_matrix
, row
);
2654 struct glyph_row
*desired_row
2655 = MATRIX_ROW (w
->desired_matrix
, row
);
2657 if (desired_row
->enabled_p
)
2658 assign_row (current_row
, desired_row
);
2660 swap_glyph_pointers (desired_row
, current_row
);
2661 current_row
->enabled_p
= 1;
2665 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2670 /* Perform row dance after scrolling. We are working on the range of
2671 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2672 including) in MATRIX. COPY_FROM is a vector containing, for each
2673 row I in the range 0 <= I < NLINES, the index of the original line
2674 to move to I. This index is relative to the row range, i.e. 0 <=
2675 index < NLINES. RETAINED_P is a vector containing zero for each
2676 row 0 <= I < NLINES which is empty.
2678 This function is called from do_scrolling and do_direct_scrolling. */
2681 mirrored_line_dance (matrix
, unchanged_at_top
, nlines
, copy_from
,
2683 struct glyph_matrix
*matrix
;
2684 int unchanged_at_top
, nlines
;
2688 /* A copy of original rows. */
2689 struct glyph_row
*old_rows
;
2691 /* Rows to assign to. */
2692 struct glyph_row
*new_rows
= MATRIX_ROW (matrix
, unchanged_at_top
);
2696 /* Make a copy of the original rows. */
2697 old_rows
= (struct glyph_row
*) alloca (nlines
* sizeof *old_rows
);
2698 bcopy (new_rows
, old_rows
, nlines
* sizeof *old_rows
);
2700 /* Assign new rows, maybe clear lines. */
2701 for (i
= 0; i
< nlines
; ++i
)
2703 int enabled_before_p
= new_rows
[i
].enabled_p
;
2705 xassert (i
+ unchanged_at_top
< matrix
->nrows
);
2706 xassert (unchanged_at_top
+ copy_from
[i
] < matrix
->nrows
);
2707 new_rows
[i
] = old_rows
[copy_from
[i
]];
2708 new_rows
[i
].enabled_p
= enabled_before_p
;
2710 /* RETAINED_P is zero for empty lines. */
2711 if (!retained_p
[copy_from
[i
]])
2712 new_rows
[i
].enabled_p
= 0;
2715 /* Do the same for window matrices, if MATRIX Is a frame matrix. */
2716 if (frame_matrix_frame
)
2717 mirror_line_dance (XWINDOW (frame_matrix_frame
->root_window
),
2718 unchanged_at_top
, nlines
, copy_from
, retained_p
);
2722 /* Synchronize glyph pointers in the current matrix of window W with
2723 the current frame matrix. W must be full-width, and be on a tty
2727 sync_window_with_frame_matrix_rows (w
)
2730 struct frame
*f
= XFRAME (w
->frame
);
2731 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
2733 /* Preconditions: W must be a leaf window and full-width. Its frame
2734 must have a frame matrix. */
2735 xassert (NILP (w
->hchild
) && NILP (w
->vchild
));
2736 xassert (WINDOW_FULL_WIDTH_P (w
));
2737 xassert (!FRAME_WINDOW_P (f
));
2739 /* If W is a full-width window, glyph pointers in W's current matrix
2740 have, by definition, to be the same as glyph pointers in the
2741 corresponding frame matrix. */
2742 window_row
= w
->current_matrix
->rows
;
2743 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
2744 frame_row
= f
->current_matrix
->rows
+ XFASTINT (w
->top
);
2745 while (window_row
< window_row_end
)
2749 for (area
= LEFT_MARGIN_AREA
; area
<= LAST_AREA
; ++area
)
2750 window_row
->glyphs
[area
] = frame_row
->glyphs
[area
];
2752 ++window_row
, ++frame_row
;
2757 /* Return the window in the window tree rooted in W containing frame
2758 row ROW. Value is null if none is found. */
2761 frame_row_to_window (w
, row
)
2765 struct window
*found
= NULL
;
2769 if (!NILP (w
->hchild
))
2770 found
= frame_row_to_window (XWINDOW (w
->hchild
), row
);
2771 else if (!NILP (w
->vchild
))
2772 found
= frame_row_to_window (XWINDOW (w
->vchild
), row
);
2773 else if (row
>= XFASTINT (w
->top
)
2774 && row
< XFASTINT (w
->top
) + XFASTINT (w
->height
))
2777 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2784 /* Perform a line dance in the window tree rooted at W, after
2785 scrolling a frame matrix in mirrored_line_dance.
2787 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
2788 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
2789 COPY_FROM is a vector containing, for each row I in the range 0 <=
2790 I < NLINES, the index of the original line to move to I. This
2791 index is relative to the row range, i.e. 0 <= index < NLINES.
2792 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
2796 mirror_line_dance (w
, unchanged_at_top
, nlines
, copy_from
, retained_p
)
2798 int unchanged_at_top
, nlines
;
2804 if (!NILP (w
->hchild
))
2805 mirror_line_dance (XWINDOW (w
->hchild
), unchanged_at_top
,
2806 nlines
, copy_from
, retained_p
);
2807 else if (!NILP (w
->vchild
))
2808 mirror_line_dance (XWINDOW (w
->vchild
), unchanged_at_top
,
2809 nlines
, copy_from
, retained_p
);
2812 /* W is a leaf window, and we are working on its current
2814 struct glyph_matrix
*m
= w
->current_matrix
;
2816 struct glyph_row
*old_rows
;
2818 /* Make a copy of the original rows of matrix m. */
2819 old_rows
= (struct glyph_row
*) alloca (m
->nrows
* sizeof *old_rows
);
2820 bcopy (m
->rows
, old_rows
, m
->nrows
* sizeof *old_rows
);
2822 for (i
= 0; i
< nlines
; ++i
)
2824 /* Frame relative line assigned to. */
2825 int frame_to
= i
+ unchanged_at_top
;
2827 /* Frame relative line assigned. */
2828 int frame_from
= copy_from
[i
] + unchanged_at_top
;
2830 /* Window relative line assigned to. */
2831 int window_to
= frame_to
- m
->matrix_y
;
2833 /* Window relative line assigned. */
2834 int window_from
= frame_from
- m
->matrix_y
;
2836 /* Is assigned line inside window? */
2837 int from_inside_window_p
2838 = window_from
>= 0 && window_from
< m
->matrix_h
;
2840 /* Is assigned to line inside window? */
2841 int to_inside_window_p
2842 = window_to
>= 0 && window_to
< m
->matrix_h
;
2844 if (from_inside_window_p
&& to_inside_window_p
)
2846 /* Enabled setting before assignment. */
2847 int enabled_before_p
;
2849 /* Do the assignment. The enabled_p flag is saved
2850 over the assignment because the old redisplay did
2852 enabled_before_p
= m
->rows
[window_to
].enabled_p
;
2853 m
->rows
[window_to
] = old_rows
[window_from
];
2854 m
->rows
[window_to
].enabled_p
= enabled_before_p
;
2856 /* If frame line is empty, window line is empty, too. */
2857 if (!retained_p
[copy_from
[i
]])
2858 m
->rows
[window_to
].enabled_p
= 0;
2860 else if (to_inside_window_p
)
2862 /* A copy between windows. This is an infrequent
2863 case not worth optimizing. */
2864 struct frame
*f
= XFRAME (w
->frame
);
2865 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
2867 struct glyph_matrix
*m2
;
2870 w2
= frame_row_to_window (root
, frame_to
);
2871 m2
= w2
->current_matrix
;
2872 m2_from
= frame_from
- m2
->matrix_y
;
2873 copy_row_except_pointers (m
->rows
+ window_to
,
2874 m2
->rows
+ m2_from
);
2876 /* If frame line is empty, window line is empty, too. */
2877 if (!retained_p
[copy_from
[i
]])
2878 m
->rows
[window_to
].enabled_p
= 0;
2881 else if (from_inside_window_p
)
2885 /* If there was a copy between windows, make sure glyph
2886 pointers are in sync with the frame matrix. */
2888 sync_window_with_frame_matrix_rows (w
);
2890 /* Check that no pointers are lost. */
2894 /* Next window on same level. */
2895 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2902 /* Check that window and frame matrices agree about their
2903 understanding where glyphs of the rows are to find. For each
2904 window in the window tree rooted at W, check that rows in the
2905 matrices of leaf window agree with their frame matrices about
2909 check_window_matrix_pointers (w
)
2914 if (!NILP (w
->hchild
))
2915 check_window_matrix_pointers (XWINDOW (w
->hchild
));
2916 else if (!NILP (w
->vchild
))
2917 check_window_matrix_pointers (XWINDOW (w
->vchild
));
2920 struct frame
*f
= XFRAME (w
->frame
);
2921 check_matrix_pointers (w
->desired_matrix
, f
->desired_matrix
);
2922 check_matrix_pointers (w
->current_matrix
, f
->current_matrix
);
2925 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2930 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
2931 a window and FRAME_MATRIX is the corresponding frame matrix. For
2932 each row in WINDOW_MATRIX check that it's a slice of the
2933 corresponding frame row. If it isn't, abort. */
2936 check_matrix_pointers (window_matrix
, frame_matrix
)
2937 struct glyph_matrix
*window_matrix
, *frame_matrix
;
2939 /* Row number in WINDOW_MATRIX. */
2942 /* Row number corresponding to I in FRAME_MATRIX. */
2943 int j
= window_matrix
->matrix_y
;
2945 /* For all rows check that the row in the window matrix is a
2946 slice of the row in the frame matrix. If it isn't we didn't
2947 mirror an operation on the frame matrix correctly. */
2948 while (i
< window_matrix
->nrows
)
2950 if (!glyph_row_slice_p (window_matrix
->rows
+ i
,
2951 frame_matrix
->rows
+ j
))
2957 #endif /* GLYPH_DEBUG != 0 */
2961 /**********************************************************************
2962 VPOS and HPOS translations
2963 **********************************************************************/
2967 /* Translate vertical position VPOS which is relative to window W to a
2968 vertical position relative to W's frame. */
2971 window_to_frame_vpos (w
, vpos
)
2975 struct frame
*f
= XFRAME (w
->frame
);
2977 xassert (!FRAME_WINDOW_P (f
));
2978 xassert (vpos
>= 0 && vpos
<= w
->desired_matrix
->nrows
);
2979 vpos
+= XFASTINT (w
->top
);
2980 xassert (vpos
>= 0 && vpos
<= FRAME_HEIGHT (f
));
2985 /* Translate horizontal position HPOS which is relative to window W to
2986 a vertical position relative to W's frame. */
2989 window_to_frame_hpos (w
, hpos
)
2993 struct frame
*f
= XFRAME (w
->frame
);
2995 xassert (!FRAME_WINDOW_P (f
));
2996 hpos
+= XFASTINT (w
->left
);
3000 #endif /* GLYPH_DEBUG */
3004 /**********************************************************************
3006 **********************************************************************/
3008 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
3009 "Clear frame FRAME and output again what is supposed to appear on it.")
3015 CHECK_LIVE_FRAME (frame
, 0);
3018 /* Ignore redraw requests, if frame has no glyphs yet.
3019 (Implementation note: It still has to be checked why we are
3020 called so early here). */
3021 if (!glyphs_initialized_initially_p
)
3025 if (FRAME_MSDOS_P (f
))
3026 set_terminal_modes ();
3028 clear_current_matrices (f
);
3031 windows_or_buffers_changed
++;
3032 /* Mark all windows as inaccurate, so that every window will have
3033 its redisplay done. */
3034 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
3035 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
3041 /* Redraw frame F. This is nothing more than a call to the Lisp
3042 function redraw-frame. */
3049 XSETFRAME (frame
, f
);
3050 Fredraw_frame (frame
);
3054 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
3055 "Clear and redisplay all visible frames.")
3058 Lisp_Object tail
, frame
;
3060 FOR_EACH_FRAME (tail
, frame
)
3061 if (FRAME_VISIBLE_P (XFRAME (frame
)))
3062 Fredraw_frame (frame
);
3068 /* This is used when frame_garbaged is set. Call Fredraw_frame on all
3069 visible frames marked as garbaged. */
3072 redraw_garbaged_frames ()
3074 Lisp_Object tail
, frame
;
3076 FOR_EACH_FRAME (tail
, frame
)
3077 if (FRAME_VISIBLE_P (XFRAME (frame
))
3078 && FRAME_GARBAGED_P (XFRAME (frame
)))
3079 Fredraw_frame (frame
);
3084 /***********************************************************************
3086 ***********************************************************************/
3088 /* Try to update display and current glyph matrix directly.
3090 This function is called after a character G has been inserted into
3091 current_buffer. It tries to update the current glyph matrix and
3092 perform appropriate screen output to reflect the insertion. If it
3093 succeeds, the global flag redisplay_performed_directly_p will be
3094 set to 1, and thereby prevent the more costly general redisplay
3095 from running (see redisplay_internal).
3097 This function is not called for `hairy' character insertions.
3098 In particular, it is not called when after or before change
3099 functions exist, like they are used by font-lock. See keyboard.c
3100 for details where this function is called. */
3103 direct_output_for_insert (g
)
3106 register struct frame
*f
= SELECTED_FRAME ();
3107 struct window
*w
= XWINDOW (selected_window
);
3109 struct glyph_row
*glyph_row
;
3110 struct glyph
*glyphs
, *glyph
, *end
;
3112 /* Non-null means that Redisplay of W is based on window matrices. */
3113 int window_redisplay_p
= FRAME_WINDOW_P (f
);
3114 /* Non-null means we are in overwrite mode. */
3115 int overwrite_p
= !NILP (current_buffer
->overwrite_mode
);
3117 struct text_pos pos
;
3118 int delta
, delta_bytes
;
3120 /* Not done directly. */
3121 redisplay_performed_directly_p
= 0;
3123 /* Quickly give up for some common cases. */
3124 if (cursor_in_echo_area
3125 /* Give up if fonts have changed. */
3127 /* Give up if face attributes have been changed. */
3128 || face_change_count
3129 /* Give up if cursor position not really known. */
3130 || !display_completed
3131 /* Give up if buffer appears in two places. */
3132 || buffer_shared
> 1
3133 /* Give up if w is mini-buffer and a message is being displayed there */
3134 || (MINI_WINDOW_P (w
) && !NILP (echo_area_buffer
[0]))
3135 /* Give up for hscrolled mini-buffer because display of the prompt
3136 is handled specially there (see display_line). */
3137 || (MINI_WINDOW_P (w
) && XFASTINT (w
->hscroll
))
3138 /* Give up if overwriting in the middle of a line. */
3141 && FETCH_BYTE (PT
) != '\n')
3142 /* Give up for tabs and line ends. */
3146 /* Give up if unable to display the cursor in the window. */
3147 || w
->cursor
.vpos
< 0
3148 || (glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
),
3149 /* Can't do it in a continued line because continuation
3150 lines would change. */
3151 (glyph_row
->continued_p
3152 /* Can't use this method if the line overlaps others or is
3153 overlapped by others because these other lines would
3154 have to be redisplayed. */
3155 || glyph_row
->overlapping_p
3156 || glyph_row
->overlapped_p
))
3157 /* Can't do it for partial width windows on terminal frames
3158 because we can't clear to eol in such a window. */
3159 || (!window_redisplay_p
&& !WINDOW_FULL_WIDTH_P (w
)))
3162 /* Set up a display iterator structure for W. Glyphs will be
3163 produced in scratch_glyph_row. Current position is W's cursor
3165 clear_glyph_row (&scratch_glyph_row
);
3166 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
3167 DEC_TEXT_POS (pos
, !NILP (current_buffer
->enable_multibyte_characters
));
3168 init_iterator (&it
, w
, CHARPOS (pos
), BYTEPOS (pos
), &scratch_glyph_row
,
3171 glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3173 /* Give up if highlighting trailing whitespace and we have trailing
3174 whitespace in glyph_row. We would have to remove the trailing
3175 whitespace face in that case. */
3176 if (!NILP (Vshow_trailing_whitespace
)
3177 && glyph_row
->used
[TEXT_AREA
])
3181 last
= glyph_row
->glyphs
[TEXT_AREA
] + glyph_row
->used
[TEXT_AREA
] - 1;
3182 if (last
->type
== STRETCH_GLYPH
3183 || (last
->type
== CHAR_GLYPH
3184 && last
->u
.ch
== ' '))
3188 /* Give up if there are overlay strings at pos. This would fail
3189 if the overlay string has newlines in it. */
3190 if (STRINGP (it
.string
))
3193 it
.hpos
= w
->cursor
.hpos
;
3194 it
.vpos
= w
->cursor
.vpos
;
3195 it
.current_x
= w
->cursor
.x
+ it
.first_visible_x
;
3196 it
.current_y
= w
->cursor
.y
;
3197 it
.end_charpos
= PT
;
3198 it
.stop_charpos
= min (PT
, it
.stop_charpos
);
3200 /* More than one display element may be returned for PT - 1 if
3201 (i) it's a control character which is translated into `\003' or
3202 `^C', or (ii) it has a display table entry, or (iii) it's a
3203 combination of both. */
3204 delta
= delta_bytes
= 0;
3205 while (get_next_display_element (&it
))
3207 PRODUCE_GLYPHS (&it
);
3209 /* Give up if glyph doesn't fit completely on the line. */
3210 if (it
.current_x
>= it
.last_visible_x
)
3213 /* Give up if new glyph has different ascent or descent than
3214 the original row, or if it is not a character glyph. */
3215 if (glyph_row
->ascent
!= it
.ascent
3216 || glyph_row
->height
!= it
.ascent
+ it
.descent
3217 || glyph_row
->phys_ascent
!= it
.phys_ascent
3218 || glyph_row
->phys_height
!= it
.phys_ascent
+ it
.phys_descent
3219 || it
.what
!= IT_CHARACTER
)
3223 delta_bytes
+= it
.len
;
3224 set_iterator_to_next (&it
);
3227 /* Give up if we hit the right edge of the window. We would have
3228 to insert truncation or continuation glyphs. */
3229 added_width
= it
.current_x
- (w
->cursor
.x
+ it
.first_visible_x
);
3230 if (glyph_row
->pixel_width
+ added_width
>= it
.last_visible_x
)
3233 /* Give up if there is a \t following in the line. */
3235 it2
.end_charpos
= ZV
;
3236 it2
.stop_charpos
= min (it2
.stop_charpos
, ZV
);
3237 while (get_next_display_element (&it2
)
3238 && !ITERATOR_AT_END_OF_LINE_P (&it2
))
3242 set_iterator_to_next (&it2
);
3245 /* Number of new glyphs produced. */
3246 n
= it
.glyph_row
->used
[TEXT_AREA
];
3248 /* Start and end of glyphs in original row. */
3249 glyphs
= glyph_row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
3250 end
= glyph_row
->glyphs
[1 + TEXT_AREA
];
3252 /* Make room for new glyphs, then insert them. */
3253 xassert (end
- glyphs
- n
>= 0);
3254 safe_bcopy ((char *) glyphs
, (char *) (glyphs
+ n
),
3255 (end
- glyphs
- n
) * sizeof (*end
));
3256 bcopy (it
.glyph_row
->glyphs
[TEXT_AREA
], glyphs
, n
* sizeof *glyphs
);
3257 glyph_row
->used
[TEXT_AREA
] = min (glyph_row
->used
[TEXT_AREA
] + n
,
3258 end
- glyph_row
->glyphs
[TEXT_AREA
]);
3260 /* Compute new line width. */
3261 glyph
= glyph_row
->glyphs
[TEXT_AREA
];
3262 end
= glyph
+ glyph_row
->used
[TEXT_AREA
];
3263 glyph_row
->pixel_width
= glyph_row
->x
;
3266 glyph_row
->pixel_width
+= glyph
->pixel_width
;
3270 /* Increment buffer positions for glyphs following the newly
3272 for (glyph
= glyphs
+ n
; glyph
< end
; ++glyph
)
3273 if (glyph
->charpos
> 0 && BUFFERP (glyph
->object
))
3274 glyph
->charpos
+= delta
;
3276 if (MATRIX_ROW_END_CHARPOS (glyph_row
) > 0)
3278 MATRIX_ROW_END_CHARPOS (glyph_row
) += delta
;
3279 MATRIX_ROW_END_BYTEPOS (glyph_row
) += delta_bytes
;
3282 /* Adjust positions in lines following the one we are in. */
3283 increment_matrix_positions (w
->current_matrix
,
3285 w
->current_matrix
->nrows
,
3286 delta
, delta_bytes
);
3288 glyph_row
->contains_overlapping_glyphs_p
3289 |= it
.glyph_row
->contains_overlapping_glyphs_p
;
3291 glyph_row
->displays_text_p
= 1;
3292 w
->window_end_vpos
= make_number (max (w
->cursor
.vpos
,
3293 XFASTINT (w
->window_end_vpos
)));
3295 if (!NILP (Vshow_trailing_whitespace
))
3296 highlight_trailing_whitespace (it
.f
, glyph_row
);
3298 /* Write glyphs. If at end of row, we can simply call write_glyphs.
3299 In the middle, we have to insert glyphs. Note that this is now
3300 implemented for X frames. The implementation uses updated_window
3302 updated_row
= glyph_row
;
3306 rif
->update_window_begin_hook (w
);
3308 if (glyphs
== end
- n
)
3309 rif
->write_glyphs (glyphs
, n
);
3311 rif
->insert_glyphs (glyphs
, n
);
3315 if (glyphs
== end
- n
)
3316 write_glyphs (glyphs
, n
);
3318 insert_glyphs (glyphs
, n
);
3321 w
->cursor
.hpos
+= n
;
3322 w
->cursor
.x
= it
.current_x
- it
.first_visible_x
;
3323 xassert (w
->cursor
.hpos
>= 0
3324 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3326 /* How to set the cursor differs depending on whether we are
3327 using a frame matrix or a window matrix. Note that when
3328 a frame matrix is used, cursor_to expects frame coordinates,
3329 and the X and Y parameters are not used. */
3330 if (window_redisplay_p
)
3331 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3332 w
->cursor
.y
, w
->cursor
.x
);
3336 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3337 + (INTEGERP (w
->left_margin_width
)
3338 ? XFASTINT (w
->left_margin_width
)
3340 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3345 rif
->update_window_end_hook (w
, 1);
3350 TRACE ((stderr
, "direct output for insert\n"));
3352 UNCHANGED_MODIFIED
= MODIFF
;
3353 BEG_UNCHANGED
= GPT
- BEG
;
3354 XSETFASTINT (w
->last_point
, PT
);
3355 w
->last_cursor
= w
->cursor
;
3356 XSETFASTINT (w
->last_modified
, MODIFF
);
3357 XSETFASTINT (w
->last_overlay_modified
, OVERLAY_MODIFF
);
3359 redisplay_performed_directly_p
= 1;
3364 /* Perform a direct display update for moving PT by N positions
3365 left or right. N < 0 means a movement backwards. This function
3366 is currently only called for N == 1 or N == -1. */
3369 direct_output_forward_char (n
)
3372 struct frame
*f
= SELECTED_FRAME ();
3373 struct window
*w
= XWINDOW (selected_window
);
3374 struct glyph_row
*row
;
3376 /* Give up if point moved out of or into a composition. */
3377 if (check_point_in_composition (current_buffer
, XINT (w
->last_point
),
3378 current_buffer
, PT
))
3381 /* Give up if face attributes have been changed. */
3382 if (face_change_count
)
3385 /* Give up if current matrix is not up to date or we are
3386 displaying a message. */
3387 if (!display_completed
|| cursor_in_echo_area
)
3390 /* Give up if the buffer's direction is reversed. */
3391 if (!NILP (XBUFFER (w
->buffer
)->direction_reversed
))
3394 /* Can't use direct output if highlighting a region. */
3395 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
3398 /* Can't use direct output if highlighting trailing whitespace. */
3399 if (!NILP (Vshow_trailing_whitespace
))
3402 /* Give up if we are showing a message or just cleared the message
3403 because we might need to resize the echo area window. */
3404 if (!NILP (echo_area_buffer
[0]) || !NILP (echo_area_buffer
[1]))
3407 /* Give up if we don't know where the cursor is. */
3408 if (w
->cursor
.vpos
< 0)
3411 row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3413 if (PT
<= MATRIX_ROW_START_BYTEPOS (row
)
3414 || PT
>= MATRIX_ROW_END_BYTEPOS (row
))
3417 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
3418 w
->last_cursor
= w
->cursor
;
3419 XSETFASTINT (w
->last_point
, PT
);
3421 xassert (w
->cursor
.hpos
>= 0
3422 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3424 if (FRAME_WINDOW_P (f
))
3425 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3426 w
->cursor
.y
, w
->cursor
.x
);
3430 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3431 + (INTEGERP (w
->left_margin_width
)
3432 ? XFASTINT (w
->left_margin_width
)
3434 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3439 redisplay_performed_directly_p
= 1;
3445 /***********************************************************************
3447 ***********************************************************************/
3449 /* Update frame F based on the data in desired matrices.
3451 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3452 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3455 Value is non-zero if redisplay was stopped due to pending input. */
3458 update_frame (f
, force_p
, inhibit_hairy_id_p
)
3461 int inhibit_hairy_id_p
;
3463 /* 1 means display has been paused because of pending input. */
3465 struct window
*root_window
= XWINDOW (f
->root_window
);
3467 if (FRAME_WINDOW_P (f
))
3469 /* We are working on window matrix basis. All windows whose
3470 flag must_be_updated_p is set have to be updated. */
3472 /* Record that we are not working on frame matrices. */
3473 set_frame_matrix_frame (NULL
);
3475 /* Update all windows in the window tree of F, maybe stopping
3476 when pending input is detected. */
3479 /* Update the menu bar on X frames that don't have toolkit
3481 if (WINDOWP (f
->menu_bar_window
))
3482 update_window (XWINDOW (f
->menu_bar_window
), 1);
3484 /* Update the tool-bar window, if present. */
3485 if (WINDOWP (f
->tool_bar_window
))
3488 struct window
*w
= XWINDOW (f
->tool_bar_window
);
3490 /* Update tool-bar window. */
3491 if (w
->must_be_updated_p
)
3493 update_window (w
, 1);
3494 w
->must_be_updated_p
= 0;
3496 /* Swap tool-bar strings. We swap because we want to
3498 tem
= f
->current_tool_bar_string
;
3499 f
->current_tool_bar_string
= f
->desired_tool_bar_string
;
3500 f
->desired_tool_bar_string
= tem
;
3501 f
->n_current_tool_bar_items
= f
->n_desired_tool_bar_items
;
3503 /* Swap tool-bar items. We swap because we want to
3505 tem
= f
->current_tool_bar_items
;
3506 f
->current_tool_bar_items
= f
->desired_tool_bar_items
;
3507 f
->desired_tool_bar_items
= tem
;
3512 /* Update windows. */
3513 paused_p
= update_window_tree (root_window
, force_p
);
3515 display_completed
= !paused_p
;
3517 /* The flush is a performance bottleneck under X. */
3519 rif
->flush_display (f
);
3524 /* We are working on frame matrix basis. Set the frame on whose
3525 frame matrix we operate. */
3526 set_frame_matrix_frame (f
);
3528 /* Build F's desired matrix from window matrices. For windows
3529 whose must_be_updated_p flag is set, desired matrices are
3530 made part of the desired frame matrix. For other windows,
3531 the current matrix is copied. */
3532 build_frame_matrix (f
);
3534 /* Do the update on the frame desired matrix. */
3535 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3537 /* Check window matrices for lost pointers. */
3538 IF_DEBUG (check_window_matrix_pointers (root_window
));
3541 /* Reset flags indicating that a window should be updated. */
3542 set_window_update_flags (root_window
, 0);
3548 /************************************************************************
3549 Window-based updates
3550 ************************************************************************/
3552 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3553 don't stop updating when input is pending. */
3556 update_window_tree (w
, force_p
)
3562 while (w
&& !paused_p
)
3564 if (!NILP (w
->hchild
))
3565 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
3566 else if (!NILP (w
->vchild
))
3567 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
3568 else if (w
->must_be_updated_p
)
3569 paused_p
|= update_window (w
, force_p
);
3571 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3578 /* Update window W if its flag must_be_updated_p is non-zero. If
3579 FORCE_P is non-zero, don't stop updating if input is pending. */
3582 update_single_window (w
, force_p
)
3586 if (w
->must_be_updated_p
)
3588 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3590 /* Record that this is not a frame-based redisplay. */
3591 set_frame_matrix_frame (NULL
);
3595 update_window (w
, force_p
);
3598 /* Reset flag in W. */
3599 w
->must_be_updated_p
= 0;
3604 /* Redraw lines from the current matrix of window W that are
3605 overlapped by other rows. YB is bottom-most y-position in W. */
3608 redraw_overlapped_rows (w
, yb
)
3613 struct glyph_row
*row
;
3615 /* If rows overlapping others have been changed, the rows being
3616 overlapped have to be redrawn. This won't draw lines that have
3617 already been drawn in update_window_line because overlapped_p in
3618 desired rows is 0, so after row assignment overlapped_p in
3619 current rows is 0. */
3620 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3622 row
= w
->current_matrix
->rows
+ i
;
3624 if (!row
->enabled_p
)
3626 else if (row
->mode_line_p
)
3629 if (row
->overlapped_p
)
3631 enum glyph_row_area area
;
3633 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3636 updated_area
= area
;
3637 rif
->cursor_to (i
, 0, row
->y
, area
== TEXT_AREA
? row
->x
: 0);
3638 if (row
->used
[area
])
3639 rif
->write_glyphs (row
->glyphs
[area
], row
->used
[area
]);
3640 rif
->clear_end_of_line (-1);
3643 row
->overlapped_p
= 0;
3646 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3653 /* Redraw lines from the current matrix of window W that overlap
3654 others. YB is bottom-most y-position in W. */
3657 redraw_overlapping_rows (w
, yb
)
3662 struct glyph_row
*row
;
3664 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3666 row
= w
->current_matrix
->rows
+ i
;
3668 if (!row
->enabled_p
)
3670 else if (row
->mode_line_p
)
3673 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3675 if (row
->overlapping_p
&& i
> 0 && bottom_y
< yb
)
3677 if (row
->used
[LEFT_MARGIN_AREA
])
3678 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
);
3680 if (row
->used
[TEXT_AREA
])
3681 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
);
3683 if (row
->used
[RIGHT_MARGIN_AREA
])
3684 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
);
3686 /* Record in neighbor rows that ROW overwrites part of their
3688 if (row
->phys_ascent
> row
->ascent
&& i
> 0)
3689 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3690 if ((row
->phys_height
- row
->phys_ascent
3691 > row
->height
- row
->ascent
)
3693 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
3702 /* Update display of window W. FORCE_P non-zero means that we should
3703 not stop when detecting pending input. */
3706 update_window (w
, force_p
)
3710 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
3712 int preempt_count
= baud_rate
/ 2400 + 1;
3713 extern int input_pending
;
3715 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3716 extern struct frame
*updating_frame
;
3719 /* Check that W's frame doesn't have glyph matrices. */
3720 xassert (FRAME_WINDOW_P (f
));
3721 xassert (updating_frame
!= NULL
);
3723 /* Check pending input the first time so that we can quickly return. */
3724 if (redisplay_dont_pause
)
3727 detect_input_pending ();
3729 /* If forced to complete the update, or if no input is pending, do
3731 if (force_p
|| !input_pending
)
3733 struct glyph_row
*row
, *end
;
3734 struct glyph_row
*mode_line_row
;
3735 struct glyph_row
*header_line_row
= NULL
;
3736 int yb
, changed_p
= 0;
3738 rif
->update_window_begin_hook (w
);
3739 yb
= window_text_bottom_y (w
);
3741 /* If window has a top line, update it before everything else.
3742 Adjust y-positions of other rows by the top line height. */
3743 row
= desired_matrix
->rows
;
3744 end
= row
+ desired_matrix
->nrows
- 1;
3745 if (row
->mode_line_p
)
3746 header_line_row
= row
++;
3748 /* Update the mode line, if necessary. */
3749 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3750 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
3752 mode_line_row
->y
= yb
;
3753 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
3758 /* Find first enabled row. Optimizations in redisplay_internal
3759 may lead to an update with only one row enabled. There may
3760 be also completely empty matrices. */
3761 while (row
< end
&& !row
->enabled_p
)
3764 /* Try reusing part of the display by inserting/deleting lines. */
3765 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
3767 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
3770 /* All rows were found to be equal. */
3779 /* Update the top mode line after scrolling because a new top
3780 line would otherwise overwrite lines at the top of the window
3781 that can be scrolled. */
3782 if (header_line_row
&& header_line_row
->enabled_p
)
3784 header_line_row
->y
= 0;
3785 update_window_line (w
, 0);
3789 /* Update the rest of the lines. */
3790 for (; row
< end
&& (force_p
|| !input_pending
); ++row
)
3792 /* A row can be completely invisible in case a desired
3793 matrix was built with a vscroll and then
3794 make_cursor_line_fully_visible shifts the matrix. */
3795 && row
->visible_height
> 0)
3797 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
3800 /* We'll Have to play a little bit with when to
3801 detect_input_pending. If it's done too often,
3802 scrolling large windows with repeated scroll-up
3803 commands will too quickly pause redisplay. */
3804 if (!force_p
&& vpos
% preempt_count
== 0)
3805 detect_input_pending ();
3807 changed_p
|= update_window_line (w
, vpos
);
3809 /* Mark all rows below the last visible one in the current
3810 matrix as invalid. This is necessary because of
3811 variable line heights. Consider the case of three
3812 successive redisplays, where the first displays 5
3813 lines, the second 3 lines, and the third 5 lines again.
3814 If the second redisplay wouldn't mark rows in the
3815 current matrix invalid, the third redisplay might be
3816 tempted to optimize redisplay based on lines displayed
3817 in the first redisplay. */
3818 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3819 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
3820 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
3823 /* Was display preempted? */
3824 paused_p
= row
< end
;
3828 /* Fix the appearance of overlapping(overlapped rows. */
3829 if (rif
->fix_overlapping_area
3830 && !w
->pseudo_window_p
3834 redraw_overlapped_rows (w
, yb
);
3835 redraw_overlapping_rows (w
, yb
);
3838 if (!paused_p
&& !w
->pseudo_window_p
)
3840 /* Make cursor visible at cursor position of W. */
3841 set_window_cursor_after_update (w
);
3844 /* Check that current matrix invariants are satisfied. This
3845 is for debugging only. See the comment around
3846 check_matrix_invariants. */
3847 IF_DEBUG (check_matrix_invariants (w
));
3852 /* Remember the redisplay method used to display the matrix. */
3853 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
3856 /* End of update of window W. */
3857 rif
->update_window_end_hook (w
, 1);
3863 clear_glyph_matrix (desired_matrix
);
3869 /* Update the display of area AREA in window W, row number VPOS.
3870 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3873 update_marginal_area (w
, area
, vpos
)
3877 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3879 /* Let functions in xterm.c know what area subsequent X positions
3880 will be relative to. */
3881 updated_area
= area
;
3883 /* Set cursor to start of glyphs, write them, and clear to the end
3884 of the area. I don't think that something more sophisticated is
3885 necessary here, since marginal areas will not be the default. */
3886 rif
->cursor_to (vpos
, 0, desired_row
->y
, 0);
3887 if (desired_row
->used
[area
])
3888 rif
->write_glyphs (desired_row
->glyphs
[area
], desired_row
->used
[area
]);
3889 rif
->clear_end_of_line (-1);
3893 /* Update the display of the text area of row VPOS in window W.
3894 Value is non-zero if display has changed. */
3897 update_text_area (w
, vpos
)
3901 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3902 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3905 /* Let functions in xterm.c know what area subsequent X positions
3906 will be relative to. */
3907 updated_area
= TEXT_AREA
;
3909 /* If rows are at different X or Y, or rows have different height,
3910 or the current row is marked invalid, write the entire line. */
3911 if (!current_row
->enabled_p
3912 || desired_row
->y
!= current_row
->y
3913 || desired_row
->ascent
!= current_row
->ascent
3914 || desired_row
->phys_ascent
!= current_row
->phys_ascent
3915 || desired_row
->phys_height
!= current_row
->phys_height
3916 || desired_row
->visible_height
!= current_row
->visible_height
3917 || current_row
->overlapped_p
3918 || current_row
->x
!= desired_row
->x
)
3920 rif
->cursor_to (vpos
, 0, desired_row
->y
, desired_row
->x
);
3922 if (desired_row
->used
[TEXT_AREA
])
3923 rif
->write_glyphs (desired_row
->glyphs
[TEXT_AREA
],
3924 desired_row
->used
[TEXT_AREA
]);
3926 /* Clear to end of window. */
3927 rif
->clear_end_of_line (-1);
3933 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
3934 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
3936 /* If the desired row extends its face to the text area end,
3937 make sure we write at least one glyph, so that the face
3938 extension actually takes place. */
3939 int desired_stop_pos
= (desired_row
->used
[TEXT_AREA
]
3940 - (MATRIX_ROW_EXTENDS_FACE_P (desired_row
)
3943 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
3949 /* Skip over glyphs that both rows have in common. These
3950 don't have to be written. */
3952 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3954 x
+= desired_glyph
->pixel_width
;
3955 ++desired_glyph
, ++current_glyph
, ++i
;
3958 /* Consider the case that the current row contains "xxx ppp
3959 ggg" in italic Courier font, and the desired row is "xxx
3960 ggg". The character `p' has lbearing, `g' has not. The
3961 loop above will stop in front of the first `p' in the
3962 current row. If we would start writing glyphs there, we
3963 wouldn't erase the lbearing of the `p'. The rest of the
3964 lbearing problem is then taken care of by x_draw_glyphs. */
3965 if (current_row
->contains_overlapping_glyphs_p
3967 && i
< current_row
->used
[TEXT_AREA
]
3968 && current_row
->used
[TEXT_AREA
] != desired_row
->used
[TEXT_AREA
])
3971 rif
->get_glyph_overhangs (current_glyph
, XFRAME (w
->frame
),
3973 while (left
> 0 && i
> 0)
3975 --i
, --desired_glyph
, --current_glyph
;
3976 x
-= desired_glyph
->pixel_width
;
3977 left
-= desired_glyph
->pixel_width
;
3981 /* Try to avoid writing the entire rest of the desired row
3982 by looking for a resync point. This mainly prevents
3983 mode line flickering in the case the mode line is in
3984 fixed-pitch font, which it usually will be. */
3985 if (i
< desired_row
->used
[TEXT_AREA
])
3987 int start_x
= x
, start_hpos
= i
;
3988 struct glyph
*start
= desired_glyph
;
3991 /* Find the next glyph that's equal again. */
3993 && !GLYPH_EQUAL_P (desired_glyph
, current_glyph
)
3996 x
+= desired_glyph
->pixel_width
;
3997 current_x
+= current_glyph
->pixel_width
;
3998 ++desired_glyph
, ++current_glyph
, ++i
;
4001 if (i
== start_hpos
|| x
!= current_x
)
4005 desired_glyph
= start
;
4009 rif
->cursor_to (vpos
, start_hpos
, desired_row
->y
, start_x
);
4010 rif
->write_glyphs (start
, i
- start_hpos
);
4015 /* Write the rest. */
4016 if (i
< desired_row
->used
[TEXT_AREA
])
4018 rif
->cursor_to (vpos
, i
, desired_row
->y
, x
);
4019 rif
->write_glyphs (desired_glyph
, desired_row
->used
[TEXT_AREA
] - i
);
4023 /* Maybe clear to end of line. */
4024 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
4026 /* If new row extends to the end of the text area, nothing
4027 has to be cleared, if and only if we did a write_glyphs
4028 above. This is made sure by setting desired_stop_pos
4029 appropriately above. */
4030 xassert (i
< desired_row
->used
[TEXT_AREA
]);
4032 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
4034 /* If old row extends to the end of the text area, clear. */
4035 if (i
>= desired_row
->used
[TEXT_AREA
])
4036 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4037 desired_row
->x
+ desired_row
->pixel_width
);
4038 rif
->clear_end_of_line (-1);
4041 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
4043 /* Otherwise clear to the end of the old row. Everything
4044 after that position should be clear already. */
4047 if (i
>= desired_row
->used
[TEXT_AREA
])
4048 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4049 desired_row
->x
+ desired_row
->pixel_width
);
4051 /* If cursor is displayed at the end of the line, make sure
4052 it's cleared. Nowadays we don't have a phys_cursor_glyph
4053 with which to erase the cursor (because this method
4054 doesn't work with lbearing/rbearing), so we must do it
4056 if (vpos
== w
->phys_cursor
.vpos
4057 && w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])
4059 w
->phys_cursor_on_p
= 0;
4063 x
= current_row
->x
+ current_row
->pixel_width
;
4064 rif
->clear_end_of_line (x
);
4073 /* Update row VPOS in window W. Value is non-zero if display has been
4077 update_window_line (w
, vpos
)
4081 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
4082 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
4085 xassert (desired_row
->enabled_p
);
4087 /* Set the row being updated. This is important to let xterm.c
4088 know what line height values are in effect. */
4089 updated_row
= desired_row
;
4091 /* Update display of the left margin area, if there is one. */
4092 if (!desired_row
->full_width_p
4093 && !NILP (w
->left_margin_width
))
4095 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
4099 /* Update the display of the text area. */
4100 changed_p
|= update_text_area (w
, vpos
);
4102 /* Update display of the right margin area, if there is one. */
4103 if (!desired_row
->full_width_p
4104 && !NILP (w
->right_margin_width
))
4107 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
4110 /* Draw truncation marks etc. */
4111 if (!current_row
->enabled_p
4112 || desired_row
->y
!= current_row
->y
4113 || desired_row
->visible_height
!= current_row
->visible_height
4114 || desired_row
->overlay_arrow_p
!= current_row
->overlay_arrow_p
4115 || desired_row
->truncated_on_left_p
!= current_row
->truncated_on_left_p
4116 || desired_row
->truncated_on_right_p
!= current_row
->truncated_on_right_p
4117 || desired_row
->continued_p
!= current_row
->continued_p
4118 || desired_row
->mode_line_p
!= current_row
->mode_line_p
4119 || (desired_row
->indicate_empty_line_p
4120 != current_row
->indicate_empty_line_p
)
4121 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
4122 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
4123 rif
->after_update_window_line_hook (desired_row
);
4125 /* Update current_row from desired_row. */
4126 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4132 /* Set the cursor after an update of window W. This function may only
4133 be called from update_window. */
4136 set_window_cursor_after_update (w
)
4139 struct frame
*f
= XFRAME (w
->frame
);
4140 int cx
, cy
, vpos
, hpos
;
4142 /* Not intended for frame matrix updates. */
4143 xassert (FRAME_WINDOW_P (f
));
4145 if (cursor_in_echo_area
4146 && !NILP (echo_area_buffer
[0])
4147 /* If we are showing a message instead of the mini-buffer,
4148 show the cursor for the message instead. */
4149 && XWINDOW (minibuf_window
) == w
4150 && EQ (minibuf_window
, echo_area_window
)
4151 /* These cases apply only to the frame that contains
4152 the active mini-buffer window. */
4153 && FRAME_HAS_MINIBUF_P (f
)
4154 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4156 cx
= cy
= vpos
= hpos
= 0;
4158 if (cursor_in_echo_area
>= 0)
4160 /* If the mini-buffer is several lines high, find the last
4161 line that has any text on it. Note: either all lines
4162 are enabled or none. Otherwise we wouldn't be able to
4164 struct glyph_row
*row
, *last_row
;
4165 struct glyph
*glyph
;
4166 int yb
= window_text_bottom_y (w
);
4169 for (row
= MATRIX_ROW (w
->current_matrix
, 0);
4173 if (row
->used
[TEXT_AREA
]
4174 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4177 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4183 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
4184 struct glyph
*last
= start
+ row
->used
[TEXT_AREA
] - 1;
4186 while (last
> start
&& last
->charpos
< 0)
4189 for (glyph
= start
; glyph
< last
; ++glyph
)
4191 cx
+= glyph
->pixel_width
;
4196 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4204 hpos
= w
->cursor
.hpos
;
4205 vpos
= w
->cursor
.vpos
;
4208 /* Window cursor can be out of sync for horizontally split windows. */
4209 hpos
= max (0, hpos
);
4210 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4211 vpos
= max (0, vpos
);
4212 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4213 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4217 /* Try to reuse part of the current display of W by scrolling lines.
4218 HEADER_LINE_P non-zero means W has a top mode line.
4220 The algorithm is taken from Communications of the ACM, Apr78 "A
4221 Technique for Isolating Differences Between Files." It should take
4224 A short outline of the steps of the algorithm
4226 1. Skip lines equal at the start and end of both matrices.
4228 2. Enter rows in the current and desired matrix into a symbol
4229 table, counting how often they appear in both matrices.
4231 3. Rows that appear exactly once in both matrices serve as anchors,
4232 i.e. we assume that such lines are likely to have been moved.
4234 4. Starting from anchor lines, extend regions to be scrolled both
4235 forward and backward.
4239 -1 if all rows were found to be equal.
4240 0 to indicate that we did not scroll the display, or
4241 1 if we did scroll. */
4244 scrolling_window (w
, header_line_p
)
4250 /* Number of occurrences of this line in old and new matrix. */
4251 short old_uses
, new_uses
;
4253 /* Vpos of line in new matrix. */
4254 short new_line_number
;
4256 /* The line itself. */
4257 struct glyph_row
*row
;
4259 /* Hash collision chain. */
4260 struct symbol
*next
;
4263 int SYMBOL_TABLE_SIZE
= 101;
4264 struct symbol
**table
;
4265 struct symbol
**old_line_syms
, **new_line_syms
;
4266 int i
, j
, first_old
, first_new
, last_old
, last_new
;
4270 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4271 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4272 int yb
= window_text_bottom_y (w
);
4274 /* Skip over rows equal at the start. */
4275 i
= header_line_p
? 1 : 0;
4276 while (i
< current_matrix
->nrows
- 1
4277 && MATRIX_ROW_ENABLED_P (current_matrix
, i
)
4278 && MATRIX_ROW_ENABLED_P (desired_matrix
, i
)
4279 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) < yb
4280 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) < yb
4282 MATRIX_ROW (desired_matrix
, i
),
4283 MATRIX_ROW (current_matrix
, i
)))
4285 assign_row (MATRIX_ROW (current_matrix
, i
),
4286 MATRIX_ROW (desired_matrix
, i
));
4287 MATRIX_ROW (desired_matrix
, i
)->enabled_p
= 0;
4291 /* Give up if some rows in the desired matrix are not enabled. */
4292 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4295 first_old
= first_new
= i
;
4297 /* Set last_new to the index + 1 of the last enabled row in the
4300 while (i
< desired_matrix
->nrows
- 1
4301 && MATRIX_ROW (desired_matrix
, i
)->enabled_p
4302 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) < yb
)
4305 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4310 /* Set last_old to the index + 1 of the last enabled row in the
4311 current matrix. We don't look at the enabled flag here because
4312 we plan to reuse part of the display even if other parts are
4315 while (i
< current_matrix
->nrows
- 1
4316 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) < yb
)
4320 /* Skip over rows equal at the bottom. */
4323 while (i
- 1 > first_new
4324 && j
- 1 > first_old
4325 && MATRIX_ROW (current_matrix
, i
- 1)->enabled_p
4326 && (MATRIX_ROW (current_matrix
, i
- 1)->y
4327 == MATRIX_ROW (desired_matrix
, j
- 1)->y
)
4329 MATRIX_ROW (desired_matrix
, i
- 1),
4330 MATRIX_ROW (current_matrix
, j
- 1)))
4335 /* Nothing to do if all rows are equal. */
4336 if (last_new
== first_new
)
4339 /* Allocate a hash table in which all rows will be inserted. */
4340 table
= (struct symbol
**) alloca (SYMBOL_TABLE_SIZE
* sizeof *table
);
4341 bzero (table
, SYMBOL_TABLE_SIZE
* sizeof *table
);
4343 /* For each row in the current matrix, record the symbol belonging
4344 to the row in OLD_LINE_SYMS. */
4345 old_line_syms
= (struct symbol
**) alloca (current_matrix
->nrows
4346 * sizeof *old_line_syms
);
4347 new_line_syms
= (struct symbol
**) alloca (desired_matrix
->nrows
4348 * sizeof *new_line_syms
);
4350 #define ADDSYM(ROW) \
4353 struct glyph_row *row_ = (ROW); \
4354 int i_ = row_->hash % SYMBOL_TABLE_SIZE; \
4356 while (sym && !row_equal_p (w, sym->row, row_)) \
4360 sym = (struct symbol *) alloca (sizeof *sym); \
4362 sym->old_uses = sym->new_uses = 0; \
4363 sym->next = table[i_]; \
4369 /* Add current rows to the symbol table. */
4370 for (i
= first_old
; i
< last_old
; ++i
)
4372 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4374 ADDSYM (MATRIX_ROW (current_matrix
, i
));
4375 old_line_syms
[i
] = sym
;
4379 old_line_syms
[i
] = NULL
;
4382 /* Add desired rows to the symbol table. */
4383 for (i
= first_new
; i
< last_new
; ++i
)
4385 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4386 ADDSYM (MATRIX_ROW (desired_matrix
, i
));
4388 new_line_syms
[i
] = sym
;
4389 sym
->new_line_number
= i
;
4394 /* Record in runs which moves were found, ordered by pixel
4395 height of copied areas. */
4397 runs
= (struct run
**) alloca (desired_matrix
->nrows
* sizeof *runs
);
4399 /* Identify moves based on lines that are unique and equal
4400 in both matrices. */
4401 for (i
= first_old
; i
< last_old
;)
4402 if (old_line_syms
[i
]
4403 && old_line_syms
[i
]->old_uses
== 1
4404 && old_line_syms
[i
]->new_uses
== 1)
4407 int new_line
= old_line_syms
[i
]->new_line_number
;
4408 struct run
*run
= (struct run
*) alloca (sizeof *run
);
4411 run
->current_vpos
= i
;
4412 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4413 run
->desired_vpos
= new_line
;
4414 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4416 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4418 /* Extend backward. */
4421 while (j
> first_old
4423 && old_line_syms
[j
] == new_line_syms
[k
])
4425 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4426 --run
->current_vpos
;
4427 --run
->desired_vpos
;
4430 run
->desired_y
-= h
;
4431 run
->current_y
-= h
;
4435 /* Extend forward. */
4440 && old_line_syms
[j
] == new_line_syms
[k
])
4442 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4448 /* Insert run into list of all runs. Order runs by copied
4449 pixel lines. Note that we record runs that don't have to
4450 be copied because they are already in place. This is done
4451 because we can avoid calling update_window_line in this
4453 for (j
= 0; j
< nruns
&& runs
[j
]->height
> run
->height
; ++j
)
4455 for (k
= nruns
; k
>= j
; --k
)
4456 runs
[k
] = runs
[k
- 1];
4465 /* Do the moves. Do it in a way that we don't overwrite something
4466 we want to copy later on. This is not solvable in general
4467 because there is only one display and we don't have a way to
4468 exchange areas on this display. Example:
4470 +-----------+ +-----------+
4472 +-----------+ --> +-----------+
4474 +-----------+ +-----------+
4476 Instead, prefer bigger moves, and invalidate moves that would
4477 copy from where we copied to. */
4479 for (i
= 0; i
< nruns
; ++i
)
4480 if (runs
[i
]->nrows
> 0)
4482 struct run
*r
= runs
[i
];
4484 /* Copy on the display. */
4485 if (r
->current_y
!= r
->desired_y
)
4487 rif
->scroll_run_hook (w
, r
);
4489 /* Invalidate runs that copy from where we copied to. */
4490 for (j
= i
+ 1; j
< nruns
; ++j
)
4492 struct run
*p
= runs
[j
];
4494 if ((p
->current_y
>= r
->desired_y
4495 && p
->current_y
< r
->desired_y
+ r
->height
)
4496 || (p
->current_y
+ p
->height
>= r
->desired_y
4497 && (p
->current_y
+ p
->height
4498 < r
->desired_y
+ r
->height
)))
4503 /* Assign matrix rows. */
4504 for (j
= 0; j
< r
->nrows
; ++j
)
4506 struct glyph_row
*from
, *to
;
4507 int to_overlapped_p
;
4509 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
4510 to_overlapped_p
= to
->overlapped_p
;
4511 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
4512 assign_row (to
, from
);
4513 to
->enabled_p
= 1, from
->enabled_p
= 0;
4514 to
->overlapped_p
= to_overlapped_p
;
4518 /* Value is non-zero to indicate that we scrolled the display. */
4523 /* Set WINDOW->must_be_updated_p TO ON_P for all windows WINDOW in the
4524 window tree rooted at W. */
4527 set_window_update_flags (w
, on_p
)
4533 if (!NILP (w
->hchild
))
4534 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4535 else if (!NILP (w
->vchild
))
4536 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4538 w
->must_be_updated_p
= on_p
;
4540 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4546 /************************************************************************
4548 ************************************************************************/
4550 /* Update the desired frame matrix of frame F.
4552 FORCE_P non-zero means that the update should not be stopped by
4553 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
4554 should not be tried.
4556 Value is non-zero if update was stopped due to pending input. */
4559 update_frame_1 (f
, force_p
, inhibit_id_p
)
4564 /* Frame matrices to work on. */
4565 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4566 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4569 int preempt_count
= baud_rate
/ 2400 + 1;
4570 extern int input_pending
;
4572 xassert (current_matrix
&& desired_matrix
);
4574 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
4575 calculate_costs (f
);
4577 if (preempt_count
<= 0)
4580 detect_input_pending ();
4581 if (input_pending
&& !force_p
)
4589 /* If we cannot insert/delete lines, it's no use trying it. */
4590 if (!line_ins_del_ok
)
4593 /* See if any of the desired lines are enabled; don't compute for
4594 i/d line if just want cursor motion. */
4595 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
4596 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4599 /* Try doing i/d line, if not yet inhibited. */
4600 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
4601 force_p
|= scrolling (f
);
4603 /* Update the individual lines as needed. Do bottom line first. */
4604 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
4605 update_frame_line (f
, desired_matrix
->nrows
- 1);
4607 /* Now update the rest of the lines. */
4608 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
4610 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4612 if (FRAME_TERMCAP_P (f
))
4614 /* Flush out every so many lines.
4615 Also flush out if likely to have more than 1k buffered
4616 otherwise. I'm told that some telnet connections get
4617 really screwed by more than 1k output at once. */
4618 int outq
= PENDING_OUTPUT_COUNT (stdout
);
4620 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
4623 if (preempt_count
== 1)
4625 #ifdef EMACS_OUTQSIZE
4626 if (EMACS_OUTQSIZE (0, &outq
) < 0)
4627 /* Probably not a tty. Ignore the error and reset
4628 * the outq count. */
4629 outq
= PENDING_OUTPUT_COUNT (stdout
);
4632 if (baud_rate
<= outq
&& baud_rate
> 0)
4633 sleep (outq
/ baud_rate
);
4638 if ((i
- 1) % preempt_count
== 0)
4639 detect_input_pending ();
4641 update_frame_line (f
, i
);
4645 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
4647 /* Now just clean up termcap drivers and set cursor, etc. */
4650 if ((cursor_in_echo_area
4651 /* If we are showing a message instead of the mini-buffer,
4652 show the cursor for the message instead of for the
4653 (now hidden) mini-buffer contents. */
4654 || (EQ (minibuf_window
, selected_window
)
4655 && EQ (minibuf_window
, echo_area_window
)
4656 && !NILP (echo_area_buffer
[0])))
4657 /* These cases apply only to the frame that contains
4658 the active mini-buffer window. */
4659 && FRAME_HAS_MINIBUF_P (f
)
4660 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4662 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
4665 if (cursor_in_echo_area
< 0)
4667 /* Negative value of cursor_in_echo_area means put
4668 cursor at beginning of line. */
4674 /* Positive value of cursor_in_echo_area means put
4675 cursor at the end of the prompt. If the mini-buffer
4676 is several lines high, find the last line that has
4678 row
= FRAME_HEIGHT (f
);
4684 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
4686 /* Frame rows are filled up with spaces that
4687 must be ignored here. */
4688 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
4690 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
4691 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
4694 && (last
- 1)->charpos
< 0)
4700 while (row
> top
&& col
== 0);
4702 /* Make sure COL is not out of range. */
4703 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
4705 /* If we have another row, advance cursor into it. */
4706 if (row
< FRAME_HEIGHT (f
) - 1)
4708 col
= FRAME_LEFT_SCROLL_BAR_WIDTH (f
);
4711 /* Otherwise move it back in range. */
4713 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
4717 cursor_to (row
, col
);
4721 /* We have only one cursor on terminal frames. Use it to
4722 display the cursor of the selected window. */
4723 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
4724 if (w
->cursor
.vpos
>= 0)
4726 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
4727 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
4729 if (INTEGERP (w
->left_margin_width
))
4730 x
+= XFASTINT (w
->left_margin_width
);
4732 /* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
4741 fflush (termscript
);
4746 display_completed
= !pause
;
4747 clear_desired_matrices (f
);
4752 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4756 struct frame
*frame
;
4758 int unchanged_at_top
, unchanged_at_bottom
;
4761 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4762 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4763 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4764 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4766 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
4767 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4768 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4770 if (!current_matrix
)
4773 /* Compute hash codes of all the lines. Also calculate number of
4774 changed lines, number of unchanged lines at the beginning, and
4775 number of unchanged lines at the end. */
4777 unchanged_at_top
= 0;
4778 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
4779 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
4781 /* Give up on this scrolling if some old lines are not enabled. */
4782 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
4784 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
4785 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4787 /* This line cannot be redrawn, so don't let scrolling mess it. */
4788 new_hash
[i
] = old_hash
[i
];
4789 #define INFINITY 1000000 /* Taken from scroll.c */
4790 draw_cost
[i
] = INFINITY
;
4794 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
4795 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
4798 if (old_hash
[i
] != new_hash
[i
])
4801 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
4803 else if (i
== unchanged_at_top
)
4805 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
4808 /* If changed lines are few, don't allow preemption, don't scroll. */
4809 if ((!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400)
4810 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
4813 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
4814 - unchanged_at_bottom
);
4816 if (scroll_region_ok
)
4817 free_at_end_vpos
-= unchanged_at_bottom
;
4818 else if (memory_below_frame
)
4819 free_at_end_vpos
= -1;
4821 /* If large window, fast terminal and few lines in common between
4822 current frame and desired frame, don't bother with i/d calc. */
4823 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
4825 10 * scrolling_max_lines_saved (unchanged_at_top
,
4826 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
4827 old_hash
, new_hash
, draw_cost
)))
4830 if (window_size
< 2)
4833 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
4834 draw_cost
+ unchanged_at_top
- 1,
4835 old_draw_cost
+ unchanged_at_top
- 1,
4836 old_hash
+ unchanged_at_top
- 1,
4837 new_hash
+ unchanged_at_top
- 1,
4838 free_at_end_vpos
- unchanged_at_top
);
4844 /* Count the number of blanks at the start of the vector of glyphs R
4845 which is LEN glyphs long. */
4848 count_blanks (r
, len
)
4854 for (i
= 0; i
< len
; ++i
)
4855 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
4862 /* Count the number of glyphs in common at the start of the glyph
4863 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
4864 of STR2. Value is the number of equal glyphs equal at the start. */
4867 count_match (str1
, end1
, str2
, end2
)
4868 struct glyph
*str1
, *end1
, *str2
, *end2
;
4870 struct glyph
*p1
= str1
;
4871 struct glyph
*p2
= str2
;
4875 && GLYPH_CHAR_AND_FACE_EQUAL_P (p1
, p2
))
4882 /* Char insertion/deletion cost vector, from term.c */
4884 extern int *char_ins_del_vector
;
4885 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
4888 /* Perform a frame-based update on line VPOS in frame FRAME. */
4891 update_frame_line (frame
, vpos
)
4892 register struct frame
*frame
;
4895 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
4897 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
4898 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4899 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4900 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
4901 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
4902 int must_write_whole_line_p
;
4904 if (desired_row
->inverse_p
4905 != (current_row
->enabled_p
&& current_row
->inverse_p
))
4907 int n
= current_row
->enabled_p
? current_row
->used
[TEXT_AREA
] : 0;
4908 change_line_highlight (desired_row
->inverse_p
, vpos
, vpos
, n
);
4909 current_row
->enabled_p
= 0;
4912 reassert_line_highlight (desired_row
->inverse_p
, vpos
);
4914 /* Current row not enabled means it has unknown contents. We must
4915 write the whole desired line in that case. */
4916 must_write_whole_line_p
= !current_row
->enabled_p
;
4917 if (must_write_whole_line_p
)
4924 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
4925 olen
= current_row
->used
[TEXT_AREA
];
4927 if (! current_row
->inverse_p
)
4929 /* Ignore trailing spaces, if we can. */
4930 if (!must_write_spaces
)
4931 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
4936 /* For an inverse-video line, make sure it's filled with
4937 spaces all the way to the frame edge so that the reverse
4938 video extends all the way across. */
4939 while (olen
< FRAME_WIDTH (frame
) - 1)
4940 obody
[olen
++] = space_glyph
;
4944 current_row
->enabled_p
= 1;
4945 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
4946 current_row
->inverse_p
= desired_row
->inverse_p
;
4948 /* If desired line is empty, just clear the line. */
4949 if (!desired_row
->enabled_p
)
4955 nbody
= desired_row
->glyphs
[TEXT_AREA
];
4956 nlen
= desired_row
->used
[TEXT_AREA
];
4957 nend
= nbody
+ nlen
;
4959 /* If display line has unknown contents, write the whole line. */
4960 if (must_write_whole_line_p
)
4962 /* Ignore spaces at the end, if we can. */
4963 if (!must_write_spaces
)
4964 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4967 /* Write the contents of the desired line. */
4970 cursor_to (vpos
, 0);
4971 write_glyphs (nbody
, nlen
);
4974 /* Don't call clear_end_of_line if we already wrote the whole
4975 line. The cursor will not be at the right margin in that
4976 case but in the line below. */
4977 if (nlen
< FRAME_WINDOW_WIDTH (frame
))
4979 cursor_to (vpos
, nlen
);
4980 clear_end_of_line (FRAME_WINDOW_WIDTH (frame
));
4983 /* Make sure we are in the right row, otherwise cursor movement
4984 with cmgoto might use `ch' in the wrong row. */
4985 cursor_to (vpos
, 0);
4987 make_current (desired_matrix
, current_matrix
, vpos
);
4991 /* Pretend trailing spaces are not there at all,
4992 unless for one reason or another we must write all spaces. */
4993 if (!desired_row
->inverse_p
)
4995 if (!must_write_spaces
)
4996 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5001 /* For an inverse-video line, give it extra trailing spaces all
5002 the way to the frame edge so that the reverse video extends
5003 all the way across. */
5004 while (nlen
< FRAME_WIDTH (frame
) - 1)
5005 nbody
[nlen
++] = space_glyph
;
5008 /* If there's no i/d char, quickly do the best we can without it. */
5009 if (!char_ins_del_ok
)
5013 /* Find the first glyph in desired row that doesn't agree with
5014 a glyph in the current row, and write the rest from there on. */
5015 for (i
= 0; i
< nlen
; i
++)
5017 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
5019 /* Find the end of the run of different glyphs. */
5023 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
5024 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
5027 /* Output this run of non-matching chars. */
5028 cursor_to (vpos
, i
);
5029 write_glyphs (nbody
+ i
, j
- i
);
5032 /* Now find the next non-match. */
5036 /* Clear the rest of the line, or the non-clear part of it. */
5039 cursor_to (vpos
, nlen
);
5040 clear_end_of_line (olen
);
5043 /* Make current row = desired row. */
5044 make_current (desired_matrix
, current_matrix
, vpos
);
5048 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
5049 characters in a row. */
5053 /* If current line is blank, skip over initial spaces, if
5054 possible, and write the rest. */
5055 if (must_write_spaces
|| desired_row
->inverse_p
)
5058 nsp
= count_blanks (nbody
, nlen
);
5062 cursor_to (vpos
, nsp
);
5063 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
5066 /* Exchange contents between current_frame and new_frame. */
5067 make_current (desired_matrix
, current_matrix
, vpos
);
5071 /* Compute number of leading blanks in old and new contents. */
5072 osp
= count_blanks (obody
, olen
);
5073 nsp
= desired_row
->inverse_p
? 0 : count_blanks (nbody
, nlen
);
5075 /* Compute number of matching chars starting with first non-blank. */
5076 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
5077 nbody
+ nsp
, nbody
+ nlen
);
5079 /* Spaces in new match implicit space past the end of old. */
5080 /* A bug causing this to be a no-op was fixed in 18.29. */
5081 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
5084 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
5088 /* Avoid doing insert/delete char
5089 just cause number of leading spaces differs
5090 when the following text does not match. */
5091 if (begmatch
== 0 && osp
!= nsp
)
5092 osp
= nsp
= min (osp
, nsp
);
5094 /* Find matching characters at end of line */
5097 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
5099 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
5104 endmatch
= obody
+ olen
- op1
;
5106 /* tem gets the distance to insert or delete.
5107 endmatch is how many characters we save by doing so.
5110 tem
= (nlen
- nsp
) - (olen
- osp
);
5112 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
5115 /* nsp - osp is the distance to insert or delete.
5116 If that is nonzero, begmatch is known to be nonzero also.
5117 begmatch + endmatch is how much we save by doing the ins/del.
5121 && (!char_ins_del_ok
5122 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
5126 osp
= nsp
= min (osp
, nsp
);
5129 /* Now go through the line, inserting, writing and
5130 deleting as appropriate. */
5134 cursor_to (vpos
, nsp
);
5135 delete_glyphs (osp
- nsp
);
5139 /* If going to delete chars later in line
5140 and insert earlier in the line,
5141 must delete first to avoid losing data in the insert */
5142 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
5144 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
5145 delete_glyphs (olen
+ nsp
- osp
- nlen
);
5146 olen
= nlen
- (nsp
- osp
);
5148 cursor_to (vpos
, osp
);
5149 insert_glyphs (0, nsp
- osp
);
5153 tem
= nsp
+ begmatch
+ endmatch
;
5154 if (nlen
!= tem
|| olen
!= tem
)
5156 cursor_to (vpos
, nsp
+ begmatch
);
5157 if (!endmatch
|| nlen
== olen
)
5159 /* If new text being written reaches right margin,
5160 there is no need to do clear-to-eol at the end.
5161 (and it would not be safe, since cursor is not
5162 going to be "at the margin" after the text is done) */
5163 if (nlen
== FRAME_WINDOW_WIDTH (frame
))
5165 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5167 else if (nlen
> olen
)
5169 /* Here, we used to have the following simple code:
5170 ----------------------------------------
5171 write_glyphs (nbody + nsp + begmatch, olen - tem);
5172 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5173 ----------------------------------------
5174 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5175 is a padding glyph. */
5176 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5179 /* Calculate columns we can actually overwrite. */
5180 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
])) out
--;
5181 write_glyphs (nbody
+ nsp
+ begmatch
, out
);
5182 /* If we left columns to be overwritten, we must delete them. */
5183 del
= olen
- tem
- out
;
5184 if (del
> 0) delete_glyphs (del
);
5185 /* At last, we insert columns not yet written out. */
5186 insert_glyphs (nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5189 else if (olen
> nlen
)
5191 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5192 delete_glyphs (olen
- nlen
);
5198 /* If any unerased characters remain after the new line, erase them. */
5201 cursor_to (vpos
, nlen
);
5202 clear_end_of_line (olen
);
5205 /* Exchange contents between current_frame and new_frame. */
5206 make_current (desired_matrix
, current_matrix
, vpos
);
5211 /***********************************************************************
5212 X/Y Position -> Buffer Position
5213 ***********************************************************************/
5215 /* Return the character position of the character at window relative
5216 pixel position (*X, *Y). *X and *Y are adjusted to character
5220 buffer_posn_from_coords (w
, x
, y
)
5225 struct buffer
*old_current_buffer
= current_buffer
;
5226 struct text_pos startp
;
5227 int left_area_width
;
5229 current_buffer
= XBUFFER (w
->buffer
);
5230 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5231 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5232 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5233 start_display (&it
, w
, startp
);
5235 left_area_width
= WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH (w
);
5236 move_it_to (&it
, -1, *x
+ it
.first_visible_x
- left_area_width
, *y
, -1,
5237 MOVE_TO_X
| MOVE_TO_Y
);
5239 *x
= it
.current_x
- it
.first_visible_x
+ left_area_width
;
5241 current_buffer
= old_current_buffer
;
5242 return IT_CHARPOS (it
);
5246 /* Value is the string under window-relative coordinates X/Y in the
5247 mode or top line of window W, or nil if none. MODE_LINE_P non-zero
5248 means look at the mode line. *CHARPOS is set to the position in
5249 the string returned. */
5252 mode_line_string (w
, x
, y
, mode_line_p
, charpos
)
5257 struct glyph_row
*row
;
5258 struct glyph
*glyph
, *end
;
5259 struct frame
*f
= XFRAME (w
->frame
);
5261 Lisp_Object string
= Qnil
;
5264 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5266 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
5268 if (row
->mode_line_p
&& row
->enabled_p
)
5270 /* The mode lines are displayed over scroll bars and bitmap
5271 areas, and X is window-relative. Correct X by the scroll bar
5272 and bitmap area width. */
5273 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
5274 x
+= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
5275 x
+= FRAME_LEFT_FLAGS_AREA_WIDTH (f
);
5277 /* Find the glyph under X. If we find one with a string object,
5278 it's the one we were looking for. */
5279 glyph
= row
->glyphs
[TEXT_AREA
];
5280 end
= glyph
+ row
->used
[TEXT_AREA
];
5281 for (x0
= 0; glyph
< end
; x0
+= glyph
->pixel_width
, ++glyph
)
5282 if (x
>= x0
&& x
< x0
+ glyph
->pixel_width
)
5284 string
= glyph
->object
;
5285 *charpos
= glyph
->charpos
;
5294 /***********************************************************************
5295 Changing Frame Sizes
5296 ***********************************************************************/
5301 window_change_signal (signalnum
) /* If we don't have an argument, */
5302 int signalnum
; /* some compilers complain in signal calls. */
5306 int old_errno
= errno
;
5308 get_frame_size (&width
, &height
);
5310 /* The frame size change obviously applies to a termcap-controlled
5311 frame. Find such a frame in the list, and assume it's the only
5312 one (since the redisplay code always writes to stdout, not a
5313 FILE * specified in the frame structure). Record the new size,
5314 but don't reallocate the data structures now. Let that be done
5315 later outside of the signal handler. */
5318 Lisp_Object tail
, frame
;
5320 FOR_EACH_FRAME (tail
, frame
)
5322 if (FRAME_TERMCAP_P (XFRAME (frame
)))
5324 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5330 signal (SIGWINCH
, window_change_signal
);
5333 #endif /* SIGWINCH */
5336 /* Do any change in frame size that was requested by a signal. SAFE
5337 non-zero means this function is called from a place where it is
5338 safe to change frame sizes while a redisplay is in progress. */
5341 do_pending_window_change (safe
)
5344 /* If window_change_signal should have run before, run it now. */
5345 if (redisplaying_p
&& !safe
)
5348 while (delayed_size_change
)
5350 Lisp_Object tail
, frame
;
5352 delayed_size_change
= 0;
5354 FOR_EACH_FRAME (tail
, frame
)
5356 struct frame
*f
= XFRAME (frame
);
5358 int height
= FRAME_NEW_HEIGHT (f
);
5359 int width
= FRAME_NEW_WIDTH (f
);
5361 if (height
!= 0 || width
!= 0)
5362 change_frame_size (f
, height
, width
, 0, 0, safe
);
5368 /* Change the frame height and/or width. Values may be given as zero to
5369 indicate no change is to take place.
5371 If DELAY is non-zero, then assume we're being called from a signal
5372 handler, and queue the change for later - perhaps the next
5373 redisplay. Since this tries to resize windows, we can't call it
5374 from a signal handler.
5376 SAFE non-zero means this function is called from a place where it's
5377 safe to change frame sizes while a redisplay is in progress. */
5380 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5381 register struct frame
*f
;
5382 int newheight
, newwidth
, pretend
, delay
, safe
;
5384 Lisp_Object tail
, frame
;
5386 if (! FRAME_WINDOW_P (f
))
5388 /* When using termcap, or on MS-DOS, all frames use
5389 the same screen, so a change in size affects all frames. */
5390 FOR_EACH_FRAME (tail
, frame
)
5391 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5392 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5393 pretend
, delay
, safe
);
5396 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
5400 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5401 register struct frame
*f
;
5402 int newheight
, newwidth
, pretend
, delay
, safe
;
5404 int new_frame_window_width
;
5405 int count
= specpdl_ptr
- specpdl
;
5407 /* If we can't deal with the change now, queue it for later. */
5408 if (delay
|| (redisplaying_p
&& !safe
))
5410 FRAME_NEW_HEIGHT (f
) = newheight
;
5411 FRAME_NEW_WIDTH (f
) = newwidth
;
5412 delayed_size_change
= 1;
5416 /* This size-change overrides any pending one for this frame. */
5417 FRAME_NEW_HEIGHT (f
) = 0;
5418 FRAME_NEW_WIDTH (f
) = 0;
5420 /* If an argument is zero, set it to the current value. */
5422 newheight
= FRAME_HEIGHT (f
);
5424 newwidth
= FRAME_WIDTH (f
);
5426 /* Compute width of windows in F.
5427 This is the width of the frame without vertical scroll bars. */
5428 new_frame_window_width
= FRAME_WINDOW_WIDTH_ARG (f
, newwidth
);
5430 /* Round up to the smallest acceptable size. */
5431 check_frame_size (f
, &newheight
, &newwidth
);
5433 /* If we're not changing the frame size, quit now. */
5434 if (newheight
== FRAME_HEIGHT (f
)
5435 && new_frame_window_width
== FRAME_WINDOW_WIDTH (f
))
5441 /* We only can set screen dimensions to certain values supported
5442 by our video hardware. Try to find the smallest size greater
5443 or equal to the requested dimensions. */
5444 dos_set_window_size (&newheight
, &newwidth
);
5447 if (newheight
!= FRAME_HEIGHT (f
))
5449 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
5451 /* Frame has both root and mini-buffer. */
5452 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f
))->top
,
5453 FRAME_TOP_MARGIN (f
));
5454 set_window_height (FRAME_ROOT_WINDOW (f
),
5457 - FRAME_TOP_MARGIN (f
)),
5459 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
,
5461 set_window_height (FRAME_MINIBUF_WINDOW (f
), 1, 0);
5464 /* Frame has just one top-level window. */
5465 set_window_height (FRAME_ROOT_WINDOW (f
),
5466 newheight
- FRAME_TOP_MARGIN (f
), 0);
5468 if (FRAME_TERMCAP_P (f
) && !pretend
)
5469 FrameRows
= newheight
;
5472 if (new_frame_window_width
!= FRAME_WINDOW_WIDTH (f
))
5474 set_window_width (FRAME_ROOT_WINDOW (f
), new_frame_window_width
, 0);
5475 if (FRAME_HAS_MINIBUF_P (f
))
5476 set_window_width (FRAME_MINIBUF_WINDOW (f
), new_frame_window_width
, 0);
5478 if (FRAME_TERMCAP_P (f
) && !pretend
)
5479 FrameCols
= newwidth
;
5481 if (WINDOWP (f
->tool_bar_window
))
5482 XSETFASTINT (XWINDOW (f
->tool_bar_window
)->width
, newwidth
);
5485 FRAME_HEIGHT (f
) = newheight
;
5486 SET_FRAME_WIDTH (f
, newwidth
);
5489 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5490 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
5492 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
5494 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
5495 w
->cursor
.hpos
= w
->cursor
.x
= 0;
5496 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
5497 w
->cursor
.vpos
= w
->cursor
.y
= 0;
5501 SET_FRAME_GARBAGED (f
);
5502 calculate_costs (f
);
5506 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
5508 /* This isn't quite a no-op: it runs window-configuration-change-hook. */
5509 Fset_window_buffer (FRAME_SELECTED_WINDOW (f
),
5510 XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
);
5512 unbind_to (count
, Qnil
);
5517 /***********************************************************************
5518 Terminal Related Lisp Functions
5519 ***********************************************************************/
5521 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
5522 1, 1, "FOpen termscript file: ",
5523 "Start writing all terminal output to FILE as well as the terminal.\n\
5524 FILE = nil means just close any termscript file currently open.")
5528 if (termscript
!= 0) fclose (termscript
);
5533 file
= Fexpand_file_name (file
, Qnil
);
5534 termscript
= fopen (XSTRING (file
)->data
, "w");
5535 if (termscript
== 0)
5536 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
5542 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
5543 Ssend_string_to_terminal
, 1, 1, 0,
5544 "Send STRING to the terminal without alteration.\n\
5545 Control characters in STRING will have terminal-dependent effects.")
5549 /* ??? Perhaps we should do something special for multibyte strings here. */
5550 CHECK_STRING (string
, 0);
5551 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)), stdout
);
5555 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)),
5557 fflush (termscript
);
5563 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
5564 "Beep, or flash the screen.\n\
5565 Also, unless an argument is given,\n\
5566 terminate any keyboard macro currently executing.")
5589 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
5590 error ("Keyboard macro terminated by a command ringing the bell");
5598 /***********************************************************************
5600 ***********************************************************************/
5602 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
5603 "Pause, without updating display, for SECONDS seconds.\n\
5604 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5605 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5606 additional wait period, in milliseconds; this may be useful if your\n\
5607 Emacs was built without floating point support.\n\
5608 \(Not all operating systems support waiting for a fraction of a second.)")
5609 (seconds
, milliseconds
)
5610 Lisp_Object seconds
, milliseconds
;
5614 if (NILP (milliseconds
))
5615 XSETINT (milliseconds
, 0);
5617 CHECK_NUMBER (milliseconds
, 1);
5618 usec
= XINT (milliseconds
) * 1000;
5621 double duration
= extract_float (seconds
);
5622 sec
= (int) duration
;
5623 usec
+= (duration
- sec
) * 1000000;
5626 #ifndef EMACS_HAS_USECS
5627 if (sec
== 0 && usec
!= 0)
5628 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
5631 /* Assure that 0 <= usec < 1000000. */
5634 /* We can't rely on the rounding being correct if user is negative. */
5635 if (-1000000 < usec
)
5636 sec
--, usec
+= 1000000;
5638 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
5641 sec
+= usec
/ 1000000, usec
%= 1000000;
5643 if (sec
< 0 || (sec
== 0 && usec
== 0))
5649 XSETFASTINT (zero
, 0);
5650 wait_reading_process_input (sec
, usec
, zero
, 0);
5653 /* We should always have wait_reading_process_input; we have a dummy
5654 implementation for systems which don't support subprocesses. */
5656 /* No wait_reading_process_input */
5663 /* The reason this is done this way
5664 (rather than defined (H_S) && defined (H_T))
5665 is because the VMS preprocessor doesn't grok `defined' */
5667 EMACS_GET_TIME (end_time
);
5668 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
5669 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
5673 EMACS_GET_TIME (timeout
);
5674 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
5675 if (EMACS_TIME_NEG_P (timeout
)
5676 || !select (1, 0, 0, 0, &timeout
))
5679 #else /* not HAVE_SELECT */
5681 #endif /* HAVE_SELECT */
5682 #endif /* not VMS */
5685 #endif /* no subprocesses */
5691 /* This is just like wait_reading_process_input, except that
5692 it does the redisplay.
5694 It's also much like Fsit_for, except that it can be used for
5695 waiting for input as well. */
5698 sit_for (sec
, usec
, reading
, display
, initial_display
)
5699 int sec
, usec
, reading
, display
, initial_display
;
5701 Lisp_Object read_kbd
;
5703 swallow_events (display
);
5705 if (detect_input_pending_run_timers (display
))
5708 if (initial_display
)
5709 redisplay_preserve_echo_area ();
5711 if (sec
== 0 && usec
== 0)
5718 XSETINT (read_kbd
, reading
? -1 : 1);
5719 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
5721 return detect_input_pending () ? Qnil
: Qt
;
5725 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
5726 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
5727 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5728 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5729 additional wait period, in milliseconds; this may be useful if your\n\
5730 Emacs was built without floating point support.\n\
5731 \(Not all operating systems support waiting for a fraction of a second.)\n\
5732 Optional third arg NODISP non-nil means don't redisplay, just wait for input.\n\
5733 Redisplay is preempted as always if input arrives, and does not happen\n\
5734 if input is available before it starts.\n\
5735 Value is t if waited the full time with no input arriving.")
5736 (seconds
, milliseconds
, nodisp
)
5737 Lisp_Object seconds
, milliseconds
, nodisp
;
5741 if (NILP (milliseconds
))
5742 XSETINT (milliseconds
, 0);
5744 CHECK_NUMBER (milliseconds
, 1);
5745 usec
= XINT (milliseconds
) * 1000;
5748 double duration
= extract_float (seconds
);
5749 sec
= (int) duration
;
5750 usec
+= (duration
- sec
) * 1000000;
5753 #ifndef EMACS_HAS_USECS
5754 if (usec
!= 0 && sec
== 0)
5755 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
5758 return sit_for (sec
, usec
, 0, NILP (nodisp
), NILP (nodisp
));
5763 /***********************************************************************
5764 Other Lisp Functions
5765 ***********************************************************************/
5767 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
5768 session's frames, frame names, buffers, buffer-read-only flags, and
5769 buffer-modified-flags, and a trailing sentinel (so we don't need to
5770 add length checks). */
5772 static Lisp_Object frame_and_buffer_state
;
5775 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
5776 Sframe_or_buffer_changed_p
, 0, 0, 0,
5777 "Return non-nil if the frame and buffer state appears to have changed.\n\
5778 The state variable is an internal vector containing all frames and buffers,\n\
5779 aside from buffers whose names start with space,\n\
5780 along with the buffers' read-only and modified flags, which allows a fast\n\
5781 check to see whether the menu bars might need to be recomputed.\n\
5782 If this function returns non-nil, it updates the internal vector to reflect\n\
5783 the current state.\n")
5786 Lisp_Object tail
, frame
, buf
;
5790 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5791 FOR_EACH_FRAME (tail
, frame
)
5793 if (!EQ (*vecp
++, frame
))
5795 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
5798 /* Check that the buffer info matches.
5799 No need to test for the end of the vector
5800 because the last element of the vector is lambda
5801 and that will always cause a mismatch. */
5802 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5804 buf
= XCDR (XCAR (tail
));
5805 /* Ignore buffers that aren't included in buffer lists. */
5806 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5808 if (!EQ (*vecp
++, buf
))
5810 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
5812 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
5815 /* Detect deletion of a buffer at the end of the list. */
5816 if (EQ (*vecp
, Qlambda
))
5819 /* Start with 1 so there is room for at least one lambda at the end. */
5821 FOR_EACH_FRAME (tail
, frame
)
5823 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5825 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
5826 if (n
> XVECTOR (frame_and_buffer_state
)->size
5827 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
5828 /* Add 20 extra so we grow it less often. */
5829 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
5830 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5831 FOR_EACH_FRAME (tail
, frame
)
5834 *vecp
++ = XFRAME (frame
)->name
;
5836 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5838 buf
= XCDR (XCAR (tail
));
5839 /* Ignore buffers that aren't included in buffer lists. */
5840 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5843 *vecp
++ = XBUFFER (buf
)->read_only
;
5844 *vecp
++ = Fbuffer_modified_p (buf
);
5846 /* Fill up the vector with lambdas (always at least one). */
5848 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5849 < XVECTOR (frame_and_buffer_state
)->size
)
5851 /* Make sure we didn't overflow the vector. */
5852 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5853 > XVECTOR (frame_and_buffer_state
)->size
)
5860 /***********************************************************************
5862 ***********************************************************************/
5864 char *terminal_type
;
5866 /* Initialization done when Emacs fork is started, before doing stty.
5867 Determine terminal type and set terminal_driver. Then invoke its
5868 decoding routine to set up variables in the terminal package. */
5873 #ifdef HAVE_X_WINDOWS
5874 extern int display_arg
;
5877 /* Construct the space glyph. */
5878 space_glyph
.type
= CHAR_GLYPH
;
5879 SET_CHAR_GLYPH_FROM_GLYPH (space_glyph
, ' ');
5880 space_glyph
.charpos
= -1;
5884 cursor_in_echo_area
= 0;
5885 terminal_type
= (char *) 0;
5887 /* Now is the time to initialize this; it's used by init_sys_modes
5889 Vwindow_system
= Qnil
;
5891 /* If the user wants to use a window system, we shouldn't bother
5892 initializing the terminal. This is especially important when the
5893 terminal is so dumb that emacs gives up before and doesn't bother
5894 using the window system.
5896 If the DISPLAY environment variable is set and nonempty,
5897 try to use X, and die with an error message if that doesn't work. */
5899 #ifdef HAVE_X_WINDOWS
5904 display
= getenv ("DECW$DISPLAY");
5906 display
= getenv ("DISPLAY");
5909 display_arg
= (display
!= 0 && *display
!= 0);
5912 if (!inhibit_window_system
&& display_arg
5918 Vwindow_system
= intern ("x");
5920 Vwindow_system_version
= make_number (11);
5922 Vwindow_system_version
= make_number (10);
5924 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
5925 /* In some versions of ncurses,
5926 tputs crashes if we have not called tgetent.
5928 { char b
[2044]; tgetent (b
, "xterm");}
5930 adjust_frame_glyphs_initially ();
5933 #endif /* HAVE_X_WINDOWS */
5936 if (!inhibit_window_system
)
5938 Vwindow_system
= intern ("w32");
5939 Vwindow_system_version
= make_number (1);
5940 adjust_frame_glyphs_initially ();
5943 #endif /* HAVE_NTGUI */
5945 /* If no window system has been specified, try to use the terminal. */
5948 fatal ("standard input is not a tty");
5952 /* Look at the TERM variable */
5953 terminal_type
= (char *) getenv ("TERM");
5957 fprintf (stderr
, "Please specify your terminal type.\n\
5958 For types defined in VMS, use set term /device=TYPE.\n\
5959 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
5960 \(The quotation marks are necessary since terminal types are lower case.)\n");
5962 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
5968 /* VMS DCL tends to up-case things, so down-case term type.
5969 Hardly any uppercase letters in terminal types; should be none. */
5971 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
5974 strcpy (new, terminal_type
);
5976 for (p
= new; *p
; p
++)
5980 terminal_type
= new;
5984 term_init (terminal_type
);
5987 struct frame
*sf
= SELECTED_FRAME ();
5988 int width
= FRAME_WINDOW_WIDTH (sf
);
5989 int height
= FRAME_HEIGHT (sf
);
5991 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (struct glyph
);
5993 /* If these sizes are so big they cause overflow, just ignore the
5994 change. It's not clear what better we could do. */
5995 if (total_glyphs
/ sizeof (struct glyph
) / height
!= width
+ 2)
5996 fatal ("screen size %dx%d too big", width
, height
);
5999 adjust_frame_glyphs_initially ();
6000 calculate_costs (XFRAME (selected_frame
));
6005 #endif /* CANNOT_DUMP */
6006 signal (SIGWINCH
, window_change_signal
);
6007 #endif /* SIGWINCH */
6009 /* Set up faces of the initial terminal frame of a dumped Emacs. */
6013 /* The MSDOS terminal turns on its ``window system'' relatively
6014 late into the startup, so we cannot do the frame faces'
6015 initialization just yet. It will be done later by pc-win.el
6016 and internal_terminal_init. */
6017 && (strcmp (terminal_type
, "internal") != 0 || inhibit_window_system
)
6019 && NILP (Vwindow_system
))
6021 /* For the initial frame, we don't have any way of knowing what
6022 are the foreground and background colors of the terminal. */
6023 struct frame
*sf
= SELECTED_FRAME();
6025 FRAME_FOREGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_FG_COLOR
;
6026 FRAME_BACKGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_BG_COLOR
;
6027 call0 (intern ("tty-set-up-initial-frame-faces"));
6033 /***********************************************************************
6035 ***********************************************************************/
6037 DEFUN ("internal-show-cursor", Finternal_show_cursor
,
6038 Sinternal_show_cursor
, 2, 2, 0,
6039 "Set the cursor-visibility flag of WINDOW to SHOW.\n\
6040 WINDOW nil means use the selected window. SHOW non-nil means\n\
6041 show a cursor in WINDOW in the next redisplay. SHOW nil means\n\
6042 don't show a cursor.")
6044 Lisp_Object window
, show
;
6046 /* Don't change cursor state while redisplaying. This could confuse
6048 if (!redisplaying_p
)
6051 window
= selected_window
;
6053 CHECK_WINDOW (window
, 2);
6055 XWINDOW (window
)->cursor_off_p
= NILP (show
);
6062 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p
,
6063 Sinternal_show_cursor_p
, 0, 1, 0,
6064 "Value is non-nil if next redisplay will display a cursor in WINDOW.\n\
6065 WINDOW nil or omitted means report on the selected window.")
6072 window
= selected_window
;
6074 CHECK_WINDOW (window
, 2);
6076 w
= XWINDOW (window
);
6077 return w
->cursor_off_p
? Qnil
: Qt
;
6081 /***********************************************************************
6083 ***********************************************************************/
6088 defsubr (&Sredraw_frame
);
6089 defsubr (&Sredraw_display
);
6090 defsubr (&Sframe_or_buffer_changed_p
);
6091 defsubr (&Sopen_termscript
);
6093 defsubr (&Ssit_for
);
6094 defsubr (&Ssleep_for
);
6095 defsubr (&Ssend_string_to_terminal
);
6096 defsubr (&Sinternal_show_cursor
);
6097 defsubr (&Sinternal_show_cursor_p
);
6099 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
6100 staticpro (&frame_and_buffer_state
);
6102 Qdisplay_table
= intern ("display-table");
6103 staticpro (&Qdisplay_table
);
6105 DEFVAR_INT ("baud-rate", &baud_rate
,
6106 "*The output baud rate of the terminal.\n\
6107 On most systems, changing this value will affect the amount of padding\n\
6108 and the other strategic decisions made during redisplay.");
6110 DEFVAR_BOOL ("inverse-video", &inverse_video
,
6111 "*Non-nil means invert the entire frame display.\n\
6112 This means everything is in inverse video which otherwise would not be.");
6114 DEFVAR_BOOL ("visible-bell", &visible_bell
,
6115 "*Non-nil means try to flash the frame to represent a bell.");
6117 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
6118 "*Non-nil means no need to redraw entire frame after suspending.\n\
6119 A non-nil value is useful if the terminal can automatically preserve\n\
6120 Emacs's frame display when you reenter Emacs.\n\
6121 It is up to you to set this variable if your terminal can do that.");
6123 DEFVAR_LISP ("window-system", &Vwindow_system
,
6124 "A symbol naming the window-system under which Emacs is running\n\
6125 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
6127 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
6128 "The version number of the window system in use.\n\
6129 For X windows, this is 10 or 11.");
6131 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
6132 "Non-nil means put cursor in minibuffer, at end of any message there.");
6134 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
6135 "Table defining how to output a glyph code to the frame.\n\
6136 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
6137 Each element can be:\n\
6138 integer: a glyph code which this glyph is an alias for.\n\
6139 string: output this glyph using that string (not impl. in X windows).\n\
6140 nil: this glyph mod 256 is char code to output,\n\
6141 and this glyph / 256 is face code for X windows (see `face-id').");
6142 Vglyph_table
= Qnil
;
6144 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
6145 "Display table to use for buffers that specify none.\n\
6146 See `buffer-display-table' for more information.");
6147 Vstandard_display_table
= Qnil
;
6149 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause
,
6150 "*Non-nil means update isn't paused when input is detected.");
6151 redisplay_dont_pause
= 0;
6153 /* Initialize `window-system', unless init_display already decided it. */
6158 Vwindow_system
= Qnil
;
6159 Vwindow_system_version
= Qnil
;