1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 97, 1998
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 #ifndef PENDING_OUTPUT_COUNT
95 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
97 #endif /* not __GNU_LIBRARY__ */
100 /* Structure to pass dimensions around. Used for character bounding
101 boxes, glyph matrix dimensions and alike. */
110 /* Function prototypes. */
112 static void redraw_overlapping_rows
P_ ((struct window
*, int));
113 static void redraw_overlapped_rows
P_ ((struct window
*, int));
114 static int count_blanks
P_ ((struct glyph
*, int));
115 static int count_match
P_ ((struct glyph
*, struct glyph
*,
116 struct glyph
*, struct glyph
*));
117 static unsigned line_draw_cost
P_ ((struct glyph_matrix
*, int));
118 static void update_frame_line
P_ ((struct frame
*, int));
119 static struct dim allocate_matrices_for_frame_redisplay
120 P_ ((Lisp_Object
, int, int, struct dim
, int, int *));
121 static void allocate_matrices_for_window_redisplay
P_ ((struct window
*,
123 static int realloc_glyph_pool
P_ ((struct glyph_pool
*, struct dim
));
124 static void adjust_frame_glyphs
P_ ((struct frame
*));
125 struct glyph_matrix
*new_glyph_matrix
P_ ((struct glyph_pool
*));
126 static void free_glyph_matrix
P_ ((struct glyph_matrix
*));
127 static void adjust_glyph_matrix
P_ ((struct window
*, struct glyph_matrix
*,
128 int, int, struct dim
));
129 static void change_frame_size_1
P_ ((struct frame
*, int, int, int, int));
130 static void swap_glyphs_in_rows
P_ ((struct glyph_row
*, struct glyph_row
*));
131 static void swap_glyph_pointers
P_ ((struct glyph_row
*, struct glyph_row
*));
132 static int glyph_row_slice_p
P_ ((struct glyph_row
*, struct glyph_row
*));
133 static void fill_up_frame_row_with_spaces
P_ ((struct glyph_row
*, int));
134 static void build_frame_matrix_from_window_tree
P_ ((struct glyph_matrix
*,
136 static void build_frame_matrix_from_leaf_window
P_ ((struct glyph_matrix
*,
138 static struct glyph_pool
*new_glyph_pool
P_ ((void));
139 static void free_glyph_pool
P_ ((struct glyph_pool
*));
140 static void adjust_frame_glyphs_initially
P_ ((void));
141 static void adjust_frame_message_buffer
P_ ((struct frame
*));
142 static void adjust_decode_mode_spec_buffer
P_ ((struct frame
*));
143 static void fill_up_glyph_row_with_spaces
P_ ((struct glyph_row
*));
144 static void build_frame_matrix
P_ ((struct frame
*));
145 void clear_current_matrices
P_ ((struct frame
*));
146 void scroll_glyph_matrix_range
P_ ((struct glyph_matrix
*, int, int,
148 static void clear_window_matrices
P_ ((struct window
*, int));
149 static void fill_up_glyph_row_area_with_spaces
P_ ((struct glyph_row
*, int));
150 static int scrolling_window
P_ ((struct window
*, int));
151 static int update_window_line
P_ ((struct window
*, int));
152 static void update_marginal_area
P_ ((struct window
*, int, int));
153 static int update_text_area
P_ ((struct window
*, int));
154 static void make_current
P_ ((struct glyph_matrix
*, struct glyph_matrix
*,
156 static void mirror_make_current
P_ ((struct window
*, int));
157 void check_window_matrix_pointers
P_ ((struct window
*));
158 static void check_matrix_pointers
P_ ((struct glyph_matrix
*,
159 struct glyph_matrix
*));
160 static void mirror_line_dance
P_ ((struct window
*, int, int, int *, char *));
161 static int update_window_tree
P_ ((struct window
*, int));
162 static int update_window
P_ ((struct window
*, int));
163 static int update_frame_1
P_ ((struct frame
*, int, int));
164 static void set_window_cursor_after_update
P_ ((struct window
*));
165 static int row_equal_p
P_ ((struct window
*, struct glyph_row
*,
166 struct glyph_row
*));
167 static void adjust_frame_glyphs_for_window_redisplay
P_ ((struct frame
*));
168 static void adjust_frame_glyphs_for_frame_redisplay
P_ ((struct frame
*));
169 static void reverse_rows
P_ ((struct glyph_matrix
*, int, int));
170 static int margin_glyphs_to_reserve
P_ ((struct window
*, int, Lisp_Object
));
174 /* Non-zero means don't pause redisplay for pending input. (This is
175 for debugging and for a future implementation of EDT-like
178 int redisplay_dont_pause
;
180 /* Nonzero upon entry to redisplay means do not assume anything about
181 current contents of actual terminal frame; clear and redraw it. */
185 /* Nonzero means last display completed. Zero means it was preempted. */
187 int display_completed
;
189 /* Lisp variable visible-bell; enables use of screen-flash instead of
194 /* Invert the color of the whole frame, at a low level. */
198 /* Line speed of the terminal. */
202 /* Either nil or a symbol naming the window system under which Emacs
205 Lisp_Object Vwindow_system
;
207 /* Version number of X windows: 10, 11 or nil. */
209 Lisp_Object Vwindow_system_version
;
211 /* Vector of glyph definitions. Indexed by glyph number, the contents
212 are a string which is how to output the glyph.
214 If Vglyph_table is nil, a glyph is output by using its low 8 bits
217 This is an obsolete feature that is no longer used. The variable
218 is retained for compatibility. */
220 Lisp_Object Vglyph_table
;
222 /* Display table to use for vectors that don't specify their own. */
224 Lisp_Object Vstandard_display_table
;
226 /* Nonzero means reading single-character input with prompt so put
227 cursor on mini-buffer after the prompt. positive means at end of
228 text in echo area; negative means at beginning of line. */
230 int cursor_in_echo_area
;
232 Lisp_Object Qdisplay_table
;
235 /* The currently selected frame. In a single-frame version, this
236 variable always holds the address of the_only_frame. */
238 struct frame
*selected_frame
;
240 /* A frame which is not just a mini-buffer, or 0 if there are no such
241 frames. This is usually the most recent such frame that was
242 selected. In a single-frame version, this variable always holds
243 the address of the_only_frame. */
245 struct frame
*last_nonminibuf_frame
;
247 /* Stdio stream being used for copy of all output. */
251 /* Structure for info on cursor positioning. */
255 /* 1 means SIGWINCH happened when not safe. */
257 int delayed_size_change
;
259 /* 1 means glyph initialization has been completed at startup. */
261 static int glyphs_initialized_initially_p
;
263 /* Updated window if != 0. Set by update_window. */
265 struct window
*updated_window
;
267 /* Glyph row updated in update_window_line, and area that is updated. */
269 struct glyph_row
*updated_row
;
272 /* A glyph for a space. */
274 struct glyph space_glyph
;
276 /* Non-zero means update has been performed directly, so that there's
277 no need for redisplay_internal to do much work. Set by
278 direct_output_for_insert. */
280 int redisplay_performed_directly_p
;
282 /* Counts of allocated structures. These counts serve to diagnose
283 memory leaks and double frees. */
285 int glyph_matrix_count
;
286 int glyph_pool_count
;
288 /* If non-null, the frame whose frame matrices are manipulated. If
289 null, window matrices are worked on. */
291 static struct frame
*frame_matrix_frame
;
293 /* Current interface for window-based redisplay. Set from init_xterm.
294 A null value means we are not using window-based redisplay. */
296 struct redisplay_interface
*rif
;
298 /* Non-zero means that fonts have been loaded since the last glyph
299 matrix adjustments. Redisplay must stop, and glyph matrices must
300 be adjusted when this flag becomes non-zero during display. The
301 reason fonts can be loaded so late is that fonts of fontsets are
306 /* Convert vpos and hpos from frame to window and vice versa.
307 This may only be used for terminal frames. */
311 static int window_to_frame_vpos
P_ ((struct window
*, int));
312 static int window_to_frame_hpos
P_ ((struct window
*, int));
313 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
314 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
316 #else /* GLYPH_DEBUG == 0 */
318 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + XFASTINT ((W)->top))
319 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + XFASTINT ((W)->left))
321 #endif /* GLYPH_DEBUG == 0 */
324 /* Like bcopy except never gets confused by overlap. Let this be the
325 first function defined in this file, or change emacs.c where the
326 address of this function is used. */
329 safe_bcopy (from
, to
, size
)
333 if (size
<= 0 || from
== to
)
336 /* If the source and destination don't overlap, then bcopy can
337 handle it. If they do overlap, but the destination is lower in
338 memory than the source, we'll assume bcopy can handle that. */
339 if (to
< from
|| from
+ size
<= to
)
340 bcopy (from
, to
, size
);
342 /* Otherwise, we'll copy from the end. */
345 register char *endf
= from
+ size
;
346 register char *endt
= to
+ size
;
348 /* If TO - FROM is large, then we should break the copy into
349 nonoverlapping chunks of TO - FROM bytes each. However, if
350 TO - FROM is small, then the bcopy function call overhead
351 makes this not worth it. The crossover point could be about
352 anywhere. Since I don't think the obvious copy loop is too
353 bad, I'm trying to err in its favor. */
358 while (endf
!= from
);
370 bcopy (endf
, endt
, to
- from
);
373 /* If SIZE wasn't a multiple of TO - FROM, there will be a
374 little left over. The amount left over is (endt + (to -
375 from)) - to, which is endt - from. */
376 bcopy (from
, to
, endt
- from
);
383 /***********************************************************************
385 ***********************************************************************/
387 /* Allocate and return a glyph_matrix structure. POOL is the glyph
388 pool from which memory for the matrix should be allocated, or null
389 for window-based redisplay where no glyph pools are used. The
390 member `pool' of the glyph matrix structure returned is set to
391 POOL, the structure is otherwise zeroed. */
393 struct glyph_matrix
*
394 new_glyph_matrix (pool
)
395 struct glyph_pool
*pool
;
397 struct glyph_matrix
*result
;
399 /* Allocate and clear. */
400 result
= (struct glyph_matrix
*) xmalloc (sizeof *result
);
401 bzero (result
, sizeof *result
);
403 /* Increment number of allocated matrices. This count is used
404 to detect memory leaks. */
405 ++glyph_matrix_count
;
407 /* Set pool and return. */
413 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
415 The global counter glyph_matrix_count is decremented when a matrix
416 is freed. If the count gets negative, more structures were freed
417 than allocated, i.e. one matrix was freed more than once or a bogus
418 pointer was passed to this function.
420 If MATRIX->pool is null, this means that the matrix manages its own
421 glyph memory---this is done for matrices on X frames. Freeing the
422 matrix also frees the glyph memory in this case. */
425 free_glyph_matrix (matrix
)
426 struct glyph_matrix
*matrix
;
432 /* Detect the case that more matrices are freed than were
434 if (--glyph_matrix_count
< 0)
437 /* Free glyph memory if MATRIX owns it. */
438 if (matrix
->pool
== NULL
)
439 for (i
= 0; i
< matrix
->rows_allocated
; ++i
)
440 xfree (matrix
->rows
[i
].glyphs
[LEFT_MARGIN_AREA
]);
442 /* Free row structures and the matrix itself. */
443 xfree (matrix
->rows
);
449 /* Return the number of glyphs to reserve for a marginal area of
450 window W. TOTAL_GLYPHS is the number of glyphs in a complete
451 display line of window W. MARGIN gives the width of the marginal
452 area in canonical character units. MARGIN should be an integer
456 margin_glyphs_to_reserve (w
, total_glyphs
, margin
)
463 if (NUMBERP (margin
))
465 int width
= XFASTINT (w
->width
);
466 double d
= max (0, XFLOATINT (margin
));
467 d
= min (width
/ 2 - 1, d
);
468 n
= (int) ((double) total_glyphs
/ width
* d
);
477 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
480 W is null if the function is called for a frame glyph matrix.
481 Otherwise it is the window MATRIX is a member of. X and Y are the
482 indices of the first column and row of MATRIX within the frame
483 matrix, if such a matrix exists. They are zero for purely
484 window-based redisplay. DIM is the needed size of the matrix.
486 In window-based redisplay, where no frame matrices exist, glyph
487 matrices manage their own glyph storage. Otherwise, they allocate
488 storage from a common frame glyph pool which can be found in
491 The reason for this memory management strategy is to avoid complete
492 frame redraws if possible. When we allocate from a common pool, a
493 change of the location or size of a sub-matrix within the pool
494 requires a complete redisplay of the frame because we cannot easily
495 make sure that the current matrices of all windows still agree with
496 what is displayed on the screen. While this is usually fast, it
497 leads to screen flickering. */
500 adjust_glyph_matrix (w
, matrix
, x
, y
, dim
)
502 struct glyph_matrix
*matrix
;
508 int marginal_areas_changed_p
= 0;
509 int top_line_changed_p
= 0;
511 int left
= -1, right
= -1;
512 int window_x
, window_y
, window_width
, window_height
;
514 /* See if W had a top line that has disappeared now, or vice versa. */
517 top_line_p
= WINDOW_WANTS_TOP_LINE_P (w
);
518 top_line_changed_p
= top_line_p
!= matrix
->top_line_p
;
520 matrix
->top_line_p
= top_line_p
;
522 /* Do nothing if MATRIX' size, position, vscroll, and marginal areas
523 haven't changed. This optimization is important because preserving
524 the matrix means preventing redisplay. */
525 if (matrix
->pool
== NULL
)
527 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
528 left
= margin_glyphs_to_reserve (w
, dim
.width
, w
->left_margin_width
);
529 right
= margin_glyphs_to_reserve (w
, dim
.width
, w
->right_margin_width
);
530 xassert (left
>= 0 && right
>= 0);
531 marginal_areas_changed_p
= (left
!= matrix
->left_margin_glyphs
532 || right
!= matrix
->right_margin_glyphs
);
534 if (!marginal_areas_changed_p
536 && !top_line_changed_p
537 && matrix
->window_top_y
== XFASTINT (w
->top
)
538 && matrix
->window_height
== window_height
539 && matrix
->window_vscroll
== w
->vscroll
540 && matrix
->window_width
== window_width
)
544 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
545 if (matrix
->rows_allocated
< dim
.height
)
547 int size
= dim
.height
* sizeof (struct glyph_row
);
548 new_rows
= dim
.height
- matrix
->rows_allocated
;
549 matrix
->rows
= (struct glyph_row
*) xrealloc (matrix
->rows
, size
);
550 bzero (matrix
->rows
+ matrix
->rows_allocated
,
551 new_rows
* sizeof *matrix
->rows
);
552 matrix
->rows_allocated
= dim
.height
;
557 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
558 on a frame not using window-based redisplay. Set up pointers for
559 each row into the glyph pool. */
562 xassert (matrix
->pool
->glyphs
);
566 left
= margin_glyphs_to_reserve (w
, dim
.width
,
567 w
->left_margin_width
);
568 right
= margin_glyphs_to_reserve (w
, dim
.width
,
569 w
->right_margin_width
);
574 for (i
= 0; i
< dim
.height
; ++i
)
576 struct glyph_row
*row
= &matrix
->rows
[i
];
578 row
->glyphs
[LEFT_MARGIN_AREA
]
579 = (matrix
->pool
->glyphs
580 + (y
+ i
) * matrix
->pool
->ncolumns
584 || row
== matrix
->rows
+ dim
.height
- 1
585 || (row
== matrix
->rows
&& matrix
->top_line_p
))
587 row
->glyphs
[TEXT_AREA
]
588 = row
->glyphs
[LEFT_MARGIN_AREA
];
589 row
->glyphs
[RIGHT_MARGIN_AREA
]
590 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
591 row
->glyphs
[LAST_AREA
]
592 = row
->glyphs
[RIGHT_MARGIN_AREA
];
596 row
->glyphs
[TEXT_AREA
]
597 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
598 row
->glyphs
[RIGHT_MARGIN_AREA
]
599 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
600 row
->glyphs
[LAST_AREA
]
601 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
605 matrix
->left_margin_glyphs
= left
;
606 matrix
->right_margin_glyphs
= right
;
610 /* If MATRIX->pool is null, MATRIX is responsible for managing
611 its own memory. Allocate glyph memory from the heap. */
612 if (dim
.width
> matrix
->matrix_w
614 || top_line_changed_p
615 || marginal_areas_changed_p
)
617 struct glyph_row
*row
= matrix
->rows
;
618 struct glyph_row
*end
= row
+ matrix
->rows_allocated
;
622 row
->glyphs
[LEFT_MARGIN_AREA
]
623 = (struct glyph
*) xrealloc (row
->glyphs
[LEFT_MARGIN_AREA
],
625 * sizeof (struct glyph
)));
627 /* The mode line never has marginal areas. */
628 if (row
== matrix
->rows
+ dim
.height
- 1
629 || (row
== matrix
->rows
&& matrix
->top_line_p
))
631 row
->glyphs
[TEXT_AREA
]
632 = row
->glyphs
[LEFT_MARGIN_AREA
];
633 row
->glyphs
[RIGHT_MARGIN_AREA
]
634 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
635 row
->glyphs
[LAST_AREA
]
636 = row
->glyphs
[RIGHT_MARGIN_AREA
];
640 row
->glyphs
[TEXT_AREA
]
641 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
642 row
->glyphs
[RIGHT_MARGIN_AREA
]
643 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
644 row
->glyphs
[LAST_AREA
]
645 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
651 xassert (left
>= 0 && right
>= 0);
652 matrix
->left_margin_glyphs
= left
;
653 matrix
->right_margin_glyphs
= right
;
656 /* Number of rows to be used by MATRIX. */
657 matrix
->nrows
= dim
.height
;
659 /* Mark rows in a current matrix of a window as not having valid
660 contents. It's important to not do this for desired matrices.
661 When Emacs starts, it may already be building desired matrices
662 when this function runs. */
663 if (w
&& matrix
== w
->current_matrix
)
665 /* Optimize the case that only the height has changed (C-x 2,
666 upper window). Invalidate all rows that are no longer part
668 if (!marginal_areas_changed_p
669 && matrix
->window_top_y
== XFASTINT (w
->top
)
670 && matrix
->window_width
== window_width
)
673 while (matrix
->rows
[i
].enabled_p
674 && (MATRIX_ROW_BOTTOM_Y (matrix
->rows
+ i
)
675 < matrix
->window_height
))
678 /* Window end is invalid, if inside of the rows that
680 if (INTEGERP (w
->window_end_vpos
)
681 && XFASTINT (w
->window_end_vpos
) >= i
)
682 w
->window_end_valid
= Qnil
;
684 while (i
< matrix
->nrows
)
685 matrix
->rows
[i
++].enabled_p
= 0;
689 for (i
= 0; i
< matrix
->nrows
; ++i
)
690 matrix
->rows
[i
].enabled_p
= 0;
694 /* Remember last values to be able to optimize frame redraws. */
695 matrix
->matrix_x
= x
;
696 matrix
->matrix_y
= y
;
697 matrix
->matrix_w
= dim
.width
;
698 matrix
->matrix_h
= dim
.height
;
700 /* Record the top y location and height of W at the time the matrix
701 was last adjusted. This is used to optimize redisplay above. */
704 matrix
->window_top_y
= XFASTINT (w
->top
);
705 matrix
->window_height
= window_height
;
706 matrix
->window_width
= window_width
;
707 matrix
->window_vscroll
= w
->vscroll
;
712 /* Reverse the contents of rows in MATRIX between START and END. The
713 contents of the row at END - 1 end up at START, END - 2 at START +
714 1 etc. This is part of the implementation of rotate_matrix (see
718 reverse_rows (matrix
, start
, end
)
719 struct glyph_matrix
*matrix
;
724 for (i
= start
, j
= end
- 1; i
< j
; ++i
, --j
)
726 /* Non-ISO HP/UX compiler doesn't like auto struct
728 struct glyph_row temp
;
729 temp
= matrix
->rows
[i
];
730 matrix
->rows
[i
] = matrix
->rows
[j
];
731 matrix
->rows
[j
] = temp
;
736 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
737 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
738 indices. (Note: this does not copy glyphs, only glyph pointers in
739 row structures are moved around).
741 The algorithm used for rotating the vector was, I believe, first
742 described by Kernighan. See the vector R as consisting of two
743 sub-vectors AB, where A has length BY for BY >= 0. The result
744 after rotating is then BA. Reverse both sub-vectors to get ArBr
745 and reverse the result to get (ArBr)r which is BA. Similar for
749 rotate_matrix (matrix
, first
, last
, by
)
750 struct glyph_matrix
*matrix
;
755 /* Up (rotate left, i.e. towards lower indices). */
757 reverse_rows (matrix
, first
, first
+ by
);
758 reverse_rows (matrix
, first
+ by
, last
);
759 reverse_rows (matrix
, first
, last
);
763 /* Down (rotate right, i.e. towards higher indices). */
764 reverse_rows (matrix
, last
- by
, last
);
765 reverse_rows (matrix
, first
, last
- by
);
766 reverse_rows (matrix
, first
, last
);
771 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
772 with indices START <= index < END. Increment positions by DELTA/
776 increment_glyph_matrix_buffer_positions (matrix
, start
, end
, delta
,
778 struct glyph_matrix
*matrix
;
779 int start
, end
, delta
, delta_bytes
;
781 /* Check that START and END are reasonable values. */
782 xassert (start
>= 0 && start
<= matrix
->nrows
);
783 xassert (end
>= 0 && end
<= matrix
->nrows
);
784 xassert (start
<= end
);
786 for (; start
< end
; ++start
)
787 increment_glyph_row_buffer_positions (matrix
->rows
+ start
,
792 /* Enable a range of rows in glyph matrix MATRIX. START and END are
793 the row indices of the first and last + 1 row to enable. If
794 ENABLED_P is non-zero, enabled_p flags in rows will be set to 1. */
797 enable_glyph_matrix_rows (matrix
, start
, end
, enabled_p
)
798 struct glyph_matrix
*matrix
;
802 xassert (start
<= end
);
803 xassert (start
>= 0 && start
< matrix
->nrows
);
804 xassert (end
>= 0 && end
<= matrix
->nrows
);
806 for (; start
< end
; ++start
)
807 matrix
->rows
[start
].enabled_p
= enabled_p
!= 0;
813 This empties all rows in MATRIX by setting the enabled_p flag for
814 all rows of the matrix to zero. The function prepare_desired_row
815 will eventually really clear a row when it sees one with a zero
818 Resets update hints to defaults value. The only update hint
819 currently present is the flag MATRIX->no_scrolling_p. */
822 clear_glyph_matrix (matrix
)
823 struct glyph_matrix
*matrix
;
827 enable_glyph_matrix_rows (matrix
, 0, matrix
->nrows
, 0);
828 matrix
->no_scrolling_p
= 0;
833 /* Shift part of the glyph matrix MATRIX of window W up or down.
834 Increment y-positions in glyph rows between START and END by DY,
835 and recompute their visible height. */
838 shift_glyph_matrix (w
, matrix
, start
, end
, dy
)
840 struct glyph_matrix
*matrix
;
845 xassert (start
<= end
);
846 xassert (start
>= 0 && start
< matrix
->nrows
);
847 xassert (end
>= 0 && end
<= matrix
->nrows
);
849 min_y
= WINDOW_DISPLAY_TOP_LINE_HEIGHT (w
);
850 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
852 for (; start
< end
; ++start
)
854 struct glyph_row
*row
= &matrix
->rows
[start
];
859 row
->visible_height
= row
->height
- (min_y
- row
->y
);
860 else if (row
->y
+ row
->height
> max_y
)
861 row
->visible_height
= row
->height
- (row
->y
+ row
->height
- max_y
);
863 row
->visible_height
= row
->height
;
868 /* Mark all rows in current matrices of frame F as invalid. Marking
869 invalid is done by setting enabled_p to zero for all rows in a
873 clear_current_matrices (f
)
874 register struct frame
*f
;
876 /* Clear frame current matrix, if we have one. */
877 if (f
->current_matrix
)
878 clear_glyph_matrix (f
->current_matrix
);
880 /* Clear the matrix of the menu bar window, if such a window exists.
881 The menu bar window is currently used to display menus on X when
882 no toolkit support is compiled in. */
883 if (WINDOWP (f
->menu_bar_window
))
884 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->current_matrix
);
886 /* Clear the matrix of the toolbar window, if any. */
887 if (WINDOWP (f
->toolbar_window
))
888 clear_glyph_matrix (XWINDOW (f
->toolbar_window
)->current_matrix
);
890 /* Clear current window matrices. */
891 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
892 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 0);
896 /* Clear out all display lines of F for a coming redisplay. */
899 clear_desired_matrices (f
)
900 register struct frame
*f
;
902 if (f
->desired_matrix
)
903 clear_glyph_matrix (f
->desired_matrix
);
905 if (WINDOWP (f
->menu_bar_window
))
906 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->desired_matrix
);
908 if (WINDOWP (f
->toolbar_window
))
909 clear_glyph_matrix (XWINDOW (f
->toolbar_window
)->desired_matrix
);
911 /* Do it for window matrices. */
912 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
913 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
917 /* Clear matrices in window tree rooted in W. If DESIRED_P is
918 non-zero clear desired matrices, otherwise clear current matrices. */
921 clear_window_matrices (w
, desired_p
)
927 if (!NILP (w
->hchild
))
929 xassert (WINDOWP (w
->hchild
));
930 clear_window_matrices (XWINDOW (w
->hchild
), desired_p
);
932 else if (!NILP (w
->vchild
))
934 xassert (WINDOWP (w
->vchild
));
935 clear_window_matrices (XWINDOW (w
->vchild
), desired_p
);
940 clear_glyph_matrix (w
->desired_matrix
);
943 clear_glyph_matrix (w
->current_matrix
);
944 w
->window_end_valid
= Qnil
;
948 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
954 /***********************************************************************
957 See dispextern.h for an overall explanation of glyph rows.
958 ***********************************************************************/
960 /* Clear glyph row ROW. Do it in a way that makes it robust against
961 changes in the glyph_row structure, i.e. addition or removal of
962 structure members. */
965 clear_glyph_row (row
)
966 struct glyph_row
*row
;
968 struct glyph
*p
[1 + LAST_AREA
];
969 static struct glyph_row null_row
;
972 p
[LEFT_MARGIN_AREA
] = row
->glyphs
[LEFT_MARGIN_AREA
];
973 p
[TEXT_AREA
] = row
->glyphs
[TEXT_AREA
];
974 p
[RIGHT_MARGIN_AREA
] = row
->glyphs
[RIGHT_MARGIN_AREA
];
975 p
[LAST_AREA
] = row
->glyphs
[LAST_AREA
];
980 /* Restore pointers. */
981 row
->glyphs
[LEFT_MARGIN_AREA
] = p
[LEFT_MARGIN_AREA
];
982 row
->glyphs
[TEXT_AREA
] = p
[TEXT_AREA
];
983 row
->glyphs
[RIGHT_MARGIN_AREA
] = p
[RIGHT_MARGIN_AREA
];
984 row
->glyphs
[LAST_AREA
] = p
[LAST_AREA
];
988 /* Make ROW an empty, enabled row of canonical character height,
989 in window W starting at y-position Y. */
992 blank_row (w
, row
, y
)
994 struct glyph_row
*row
;
999 min_y
= WINDOW_DISPLAY_TOP_LINE_HEIGHT (w
);
1000 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
1002 clear_glyph_row (row
);
1004 row
->ascent
= row
->phys_ascent
= 0;
1005 row
->height
= row
->phys_height
= CANON_Y_UNIT (XFRAME (w
->frame
));
1008 row
->visible_height
= row
->height
- (min_y
- row
->y
);
1009 else if (row
->y
+ row
->height
> max_y
)
1010 row
->visible_height
= row
->height
- (row
->y
+ row
->height
- max_y
);
1012 row
->visible_height
= row
->height
;
1018 /* Increment buffer positions in glyph row ROW. DELTA and DELTA_BYTES
1019 are the amounts by which to change positions. Note that the first
1020 glyph of the text area of a row can have a buffer position even if
1021 the used count of the text area is zero. Such rows display line
1025 increment_glyph_row_buffer_positions (row
, delta
, delta_bytes
)
1026 struct glyph_row
*row
;
1027 int delta
, delta_bytes
;
1031 /* Increment start and end positions. */
1032 MATRIX_ROW_START_CHARPOS (row
) += delta
;
1033 MATRIX_ROW_START_BYTEPOS (row
) += delta_bytes
;
1034 MATRIX_ROW_END_CHARPOS (row
) += delta
;
1035 MATRIX_ROW_END_BYTEPOS (row
) += delta_bytes
;
1037 /* Increment positions in glyphs. */
1038 for (area
= 0; area
< LAST_AREA
; ++area
)
1039 for (i
= 0; i
< row
->used
[area
]; ++i
)
1040 if (BUFFERP (row
->glyphs
[area
][i
].object
)
1041 && row
->glyphs
[area
][i
].charpos
> 0)
1042 row
->glyphs
[area
][i
].charpos
+= delta
;
1044 /* Capture the case of rows displaying a line end. */
1045 if (row
->used
[TEXT_AREA
] == 0
1046 && MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1047 row
->glyphs
[TEXT_AREA
]->charpos
+= delta
;
1051 /* Swap glyphs between two glyph rows A and B. This exchanges glyph
1052 contents, i.e. glyph structure contents are exchanged between A and
1053 B without changing glyph pointers in A and B. */
1056 swap_glyphs_in_rows (a
, b
)
1057 struct glyph_row
*a
, *b
;
1061 for (area
= 0; area
< LAST_AREA
; ++area
)
1063 /* Number of glyphs to swap. */
1064 int max_used
= max (a
->used
[area
], b
->used
[area
]);
1066 /* Start of glyphs in area of row A. */
1067 struct glyph
*glyph_a
= a
->glyphs
[area
];
1069 /* End + 1 of glyphs in area of row A. */
1070 struct glyph
*glyph_a_end
= a
->glyphs
[max_used
];
1072 /* Start of glyphs in area of row B. */
1073 struct glyph
*glyph_b
= b
->glyphs
[area
];
1075 while (glyph_a
< glyph_a_end
)
1077 /* Non-ISO HP/UX compiler doesn't like auto struct
1081 *glyph_a
= *glyph_b
;
1090 /* Exchange pointers to glyph memory between glyph rows A and B. */
1093 swap_glyph_pointers (a
, b
)
1094 struct glyph_row
*a
, *b
;
1097 for (i
= 0; i
< LAST_AREA
+ 1; ++i
)
1099 struct glyph
*temp
= a
->glyphs
[i
];
1100 a
->glyphs
[i
] = b
->glyphs
[i
];
1101 b
->glyphs
[i
] = temp
;
1106 /* Copy glyph row structure FROM to glyph row structure TO, except
1107 that glyph pointers in the structures are left unchanged. */
1110 copy_row_except_pointers (to
, from
)
1111 struct glyph_row
*to
, *from
;
1113 struct glyph
*pointers
[1 + LAST_AREA
];
1115 /* Save glyph pointers of TO. */
1116 bcopy (to
->glyphs
, pointers
, sizeof to
->glyphs
);
1118 /* Do a structure assignment. */
1121 /* Restore original pointers of TO. */
1122 bcopy (pointers
, to
->glyphs
, sizeof to
->glyphs
);
1126 /* Copy contents of glyph row FROM to glyph row TO. Glyph pointers in
1127 TO and FROM are left unchanged. Glyph contents are copied from the
1128 glyph memory of FROM to the glyph memory of TO. Increment buffer
1129 positions in row TO by DELTA/ DELTA_BYTES. */
1132 copy_glyph_row_contents (to
, from
, delta
, delta_bytes
)
1133 struct glyph_row
*to
, *from
;
1134 int delta
, delta_bytes
;
1138 /* This is like a structure assignment TO = FROM, except that
1139 glyph pointers in the rows are left unchanged. */
1140 copy_row_except_pointers (to
, from
);
1142 /* Copy glyphs from FROM to TO. */
1143 for (area
= 0; area
< LAST_AREA
; ++area
)
1144 if (from
->used
[area
])
1145 bcopy (from
->glyphs
[area
], to
->glyphs
[area
],
1146 from
->used
[area
] * sizeof (struct glyph
));
1148 /* Increment buffer positions in TO by DELTA. */
1149 increment_glyph_row_buffer_positions (to
, delta
, delta_bytes
);
1153 /* Assign glyph row FROM to glyph row TO. This works like a structure
1154 assignment TO = FROM, except that glyph pointers are not copied but
1155 exchanged between TO and FROM. Pointers must be exchanged to avoid
1159 assign_row (to
, from
)
1160 struct glyph_row
*to
, *from
;
1162 swap_glyph_pointers (to
, from
);
1163 copy_row_except_pointers (to
, from
);
1167 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1168 a row in a window matrix, is a slice of the glyph memory of the
1169 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1170 is non-zero if the glyph memory of WINDOW_ROW is part of the glyph
1171 memory of FRAME_ROW. */
1174 glyph_row_slice_p (window_row
, frame_row
)
1175 struct glyph_row
*window_row
, *frame_row
;
1177 struct glyph
*window_glyph_start
= window_row
->glyphs
[0];
1178 struct glyph
*frame_glyph_start
= frame_row
->glyphs
[0];
1179 struct glyph
*frame_glyph_end
= frame_row
->glyphs
[LAST_AREA
];
1181 return (frame_glyph_start
<= window_glyph_start
1182 && window_glyph_start
< frame_glyph_end
);
1186 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1187 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1188 in WINDOW_MATRIX is found satisfying the condition. */
1190 static struct glyph_row
*
1191 find_glyph_row_slice (window_matrix
, frame_matrix
, row
)
1192 struct glyph_matrix
*window_matrix
, *frame_matrix
;
1197 xassert (row
>= 0 && row
< frame_matrix
->nrows
);
1199 for (i
= 0; i
< window_matrix
->nrows
; ++i
)
1200 if (glyph_row_slice_p (window_matrix
->rows
+ i
,
1201 frame_matrix
->rows
+ row
))
1204 return i
< window_matrix
->nrows
? window_matrix
->rows
+ i
: 0;
1208 /* Prepare ROW for display. Desired rows are cleared lazily,
1209 i.e. they are only marked as to be cleared by setting their
1210 enabled_p flag to zero. When a row is to be displayed, a prior
1211 call to this function really clears it. */
1214 prepare_desired_row (row
)
1215 struct glyph_row
*row
;
1217 if (!row
->enabled_p
)
1219 clear_glyph_row (row
);
1225 /* Return a hash code for glyph row ROW. */
1228 line_hash_code (row
)
1229 struct glyph_row
*row
;
1237 /* Give all highlighted lines the same hash code
1238 so as to encourage scrolling to leave them in place. */
1243 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
1244 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
1248 GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*glyph
);
1249 if (must_write_spaces
)
1251 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + g
;
1264 /* Return the cost of drawing line VPOS In MATRIX. The cost equals
1265 the number of characters in the line. If must_write_spaces is
1266 zero, leading and trailing spaces are ignored. */
1269 line_draw_cost (matrix
, vpos
)
1270 struct glyph_matrix
*matrix
;
1273 struct glyph_row
*row
= matrix
->rows
+ vpos
;
1274 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
1275 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
];
1277 Lisp_Object
*glyph_table_base
= GLYPH_TABLE_BASE
;
1278 int glyph_table_len
= GLYPH_TABLE_LENGTH
;
1280 /* Ignore trailing and leading spaces if we can. */
1281 if (!must_write_spaces
)
1283 /* Skip from the end over trailing spaces. */
1284 while (end
!= beg
&& CHAR_GLYPH_SPACE_P (*end
))
1287 /* All blank line. */
1291 /* Skip over leading spaces. */
1292 while (CHAR_GLYPH_SPACE_P (*beg
))
1296 /* If we don't have a glyph-table, each glyph is one character,
1297 so return the number of glyphs. */
1298 if (glyph_table_base
== 0)
1302 /* Otherwise, scan the glyphs and accumulate their total length
1307 GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*beg
);
1309 if (GLYPH_SIMPLE_P (glyph_table_base
, glyph_table_len
, g
))
1312 len
+= GLYPH_LENGTH (glyph_table_base
, g
);
1322 /* Test two glyph rows A and B for equality. Value is non-zero if A
1323 and B have equal contents. W is the window to which the glyphs
1324 rows A and B belong. It is needed here to test for partial row
1328 row_equal_p (w
, a
, b
)
1330 struct glyph_row
*a
, *b
;
1334 else if (a
->hash
!= b
->hash
)
1338 struct glyph
*a_glyph
, *b_glyph
, *a_end
;
1341 /* Compare glyphs. */
1342 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
1344 if (a
->used
[area
] != b
->used
[area
])
1347 a_glyph
= a
->glyphs
[area
];
1348 a_end
= a_glyph
+ a
->used
[area
];
1349 b_glyph
= b
->glyphs
[area
];
1351 while (a_glyph
< a_end
1352 && GLYPH_EQUAL_P (a_glyph
, b_glyph
))
1353 ++a_glyph
, ++b_glyph
;
1355 if (a_glyph
!= a_end
)
1359 if (a
->truncated_on_left_p
!= b
->truncated_on_left_p
1360 || a
->inverse_p
!= b
->inverse_p
1361 || a
->fill_line_p
!= b
->fill_line_p
1362 || a
->truncated_on_right_p
!= b
->truncated_on_right_p
1363 || a
->overlay_arrow_p
!= b
->overlay_arrow_p
1364 || a
->continued_p
!= b
->continued_p
1365 || a
->indicate_empty_line_p
!= b
->indicate_empty_line_p
1366 || a
->overlapped_p
!= b
->overlapped_p
1367 || (MATRIX_ROW_CONTINUATION_LINE_P (a
)
1368 != MATRIX_ROW_CONTINUATION_LINE_P (b
))
1369 /* Different partially visible characters on left margin. */
1371 /* Different height. */
1372 || a
->ascent
!= b
->ascent
1373 || a
->phys_ascent
!= b
->phys_ascent
1374 || a
->phys_height
!= b
->phys_height
1375 || a
->visible_height
!= b
->visible_height
)
1384 /***********************************************************************
1387 See dispextern.h for an overall explanation of glyph pools.
1388 ***********************************************************************/
1390 /* Allocate a glyph_pool structure. The structure returned is
1391 initialized with zeros. The global variable glyph_pool_count is
1392 incremented for each pool allocated. */
1394 static struct glyph_pool
*
1397 struct glyph_pool
*result
;
1399 /* Allocate a new glyph_pool and clear it. */
1400 result
= (struct glyph_pool
*) xmalloc (sizeof *result
);
1401 bzero (result
, sizeof *result
);
1403 /* For memory leak and double deletion checking. */
1410 /* Free a glyph_pool structure POOL. The function may be called with
1411 a null POOL pointer. The global variable glyph_pool_count is
1412 decremented with every pool structure freed. If this count gets
1413 negative, more structures were freed than allocated, i.e. one
1414 structure must have been freed more than once or a bogus pointer
1415 was passed to free_glyph_pool. */
1418 free_glyph_pool (pool
)
1419 struct glyph_pool
*pool
;
1423 /* More freed than allocated? */
1425 xassert (glyph_pool_count
>= 0);
1427 xfree (pool
->glyphs
);
1433 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1434 columns we need. This function never shrinks a pool. The only
1435 case in which this would make sense, would be when a frame's size
1436 is changed from a large value to a smaller one. But, if someone
1437 does it once, we can expect that he will do it again.
1439 Value is non-zero if the pool changed in a way which makes
1440 re-adjusting window glyph matrices necessary. */
1443 realloc_glyph_pool (pool
, matrix_dim
)
1444 struct glyph_pool
*pool
;
1445 struct dim matrix_dim
;
1450 changed_p
= (pool
->glyphs
== 0
1451 || matrix_dim
.height
!= pool
->nrows
1452 || matrix_dim
.width
!= pool
->ncolumns
);
1454 /* Enlarge the glyph pool. */
1455 needed
= matrix_dim
.width
* matrix_dim
.height
;
1456 if (needed
> pool
->nglyphs
)
1458 int size
= needed
* sizeof (struct glyph
);
1461 pool
->glyphs
= (struct glyph
*) xrealloc (pool
->glyphs
, size
);
1464 pool
->glyphs
= (struct glyph
*) xmalloc (size
);
1465 bzero (pool
->glyphs
, size
);
1468 pool
->nglyphs
= needed
;
1471 /* Remember the number of rows and columns because (a) we use then
1472 to do sanity checks, and (b) the number of columns determines
1473 where rows in the frame matrix start---this must be available to
1474 determine pointers to rows of window sub-matrices. */
1475 pool
->nrows
= matrix_dim
.height
;
1476 pool
->ncolumns
= matrix_dim
.width
;
1483 /***********************************************************************
1485 ***********************************************************************/
1489 /* Check that no glyph pointers have been lost in MATRIX. If a
1490 pointer has been lost, e.g. by using a structure assignment between
1491 rows, at least one pointer must occur more than once in the rows of
1495 check_matrix_pointer_lossage (matrix
)
1496 struct glyph_matrix
*matrix
;
1500 for (i
= 0; i
< matrix
->nrows
; ++i
)
1501 for (j
= 0; j
< matrix
->nrows
; ++j
)
1503 || (matrix
->rows
[i
].glyphs
[TEXT_AREA
]
1504 != matrix
->rows
[j
].glyphs
[TEXT_AREA
]));
1508 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1511 matrix_row (matrix
, row
)
1512 struct glyph_matrix
*matrix
;
1515 xassert (matrix
&& matrix
->rows
);
1516 xassert (row
>= 0 && row
< matrix
->nrows
);
1518 /* That's really too slow for normal testing because this function
1519 is called almost everywhere. Although---it's still astonishingly
1520 fast, so it is valuable to have for debugging purposes. */
1522 check_matrix_pointer_lossage (matrix
);
1525 return matrix
->rows
+ row
;
1529 #if 0 /* This function makes invalid assumptions when text is
1530 partially invisible. But it might come handy for debugging
1533 /* Check invariants that must hold for an up to date current matrix of
1537 check_matrix_invariants (w
)
1540 struct glyph_matrix
*matrix
= w
->current_matrix
;
1541 int yb
= window_text_bottom_y (w
);
1542 struct glyph_row
*row
= matrix
->rows
;
1543 struct glyph_row
*last_text_row
= NULL
;
1544 struct buffer
*saved
= current_buffer
;
1545 struct buffer
*buffer
= XBUFFER (w
->buffer
);
1548 /* This can sometimes happen for a fresh window. */
1549 if (matrix
->nrows
< 2)
1552 set_buffer_temp (buffer
);
1554 /* Note: last row is always reserved for the mode line. */
1555 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1556 && MATRIX_ROW_BOTTOM_Y (row
) < yb
)
1558 struct glyph_row
*next
= row
+ 1;
1560 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1561 last_text_row
= row
;
1563 /* Check that character and byte positions are in sync. */
1564 xassert (MATRIX_ROW_START_BYTEPOS (row
)
1565 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row
)));
1567 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1568 have such a position temporarily in case of a minibuffer
1569 displaying something like `[Sole completion]' at its end. */
1570 if (MATRIX_ROW_END_CHARPOS (row
) < BUF_ZV (current_buffer
))
1571 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1572 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row
)));
1574 /* Check that end position of `row' is equal to start position
1576 if (next
->enabled_p
&& MATRIX_ROW_DISPLAYS_TEXT_P (next
))
1578 xassert (MATRIX_ROW_END_CHARPOS (row
)
1579 == MATRIX_ROW_START_CHARPOS (next
));
1580 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1581 == MATRIX_ROW_START_BYTEPOS (next
));
1586 xassert (w
->current_matrix
->nrows
== w
->desired_matrix
->nrows
);
1587 xassert (w
->desired_matrix
->rows
!= NULL
);
1588 set_buffer_temp (saved
);
1593 #endif /* GLYPH_DEBUG != 0 */
1597 /**********************************************************************
1598 Allocating/ Adjusting Glyph Matrices
1599 **********************************************************************/
1601 /* Allocate glyph matrices over a window tree for a frame-based
1604 X and Y are column/row within the frame glyph matrix where
1605 sub-matrices for the window tree rooted at WINDOW must be
1606 allocated. CH_DIM contains the dimensions of the smallest
1607 character that could be used during display. DIM_ONLY_P non-zero
1608 means that the caller of this function is only interested in the
1609 result matrix dimension, and matrix adjustments should not be
1612 The function returns the total width/height of the sub-matrices of
1613 the window tree. If called on a frame root window, the computation
1614 will take the mini-buffer window into account.
1616 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1618 NEW_LEAF_MATRIX set if any window in the tree did not have a
1619 glyph matrices yet, and
1621 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1622 any window in the tree will be changed or have been changed (see
1625 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1628 Windows are arranged into chains of windows on the same level
1629 through the next fields of window structures. Such a level can be
1630 either a sequence of horizontally adjacent windows from left to
1631 right, or a sequence of vertically adjacent windows from top to
1632 bottom. Each window in a horizontal sequence can be either a leaf
1633 window or a vertical sequence; a window in a vertical sequence can
1634 be either a leaf or a horizontal sequence. All windows in a
1635 horizontal sequence have the same height, and all windows in a
1636 vertical sequence have the same width.
1638 This function uses, for historical reasons, a more general
1639 algorithm to determine glyph matrix dimensions that would be
1642 The matrix height of a horizontal sequence is determined by the
1643 maximum height of any matrix in the sequence. The matrix width of
1644 a horizontal sequence is computed by adding up matrix widths of
1645 windows in the sequence.
1647 |<------- result width ------->|
1648 +---------+----------+---------+ ---
1651 +---------+ | | result height
1656 The matrix width of a vertical sequence is the maximum matrix width
1657 of any window in the sequence. Its height is computed by adding up
1658 matrix heights of windows in the sequence.
1660 |<---- result width -->|
1668 +------------+---------+ |
1671 +------------+---------+ --- */
1673 /* Bit indicating that a new matrix will be allocated or has been
1676 #define NEW_LEAF_MATRIX (1 << 0)
1678 /* Bit indicating that a matrix will or has changed its location or
1681 #define CHANGED_LEAF_MATRIX (1 << 1)
1684 allocate_matrices_for_frame_redisplay (window
, x
, y
, ch_dim
,
1685 dim_only_p
, window_change_flags
)
1690 int *window_change_flags
;
1692 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1694 int wmax
= 0, hmax
= 0;
1698 int in_horz_combination_p
;
1700 /* What combination is WINDOW part of? Compute this once since the
1701 result is the same for all windows in the `next' chain. The
1702 special case of a root window (parent equal to nil) is treated
1703 like a vertical combination because a root window's `next'
1704 points to the mini-buffer window, if any, which is arranged
1705 vertically below other windows. */
1706 in_horz_combination_p
1707 = (!NILP (XWINDOW (window
)->parent
)
1708 && !NILP (XWINDOW (XWINDOW (window
)->parent
)->hchild
));
1710 /* For WINDOW and all windows on the same level. */
1713 w
= XWINDOW (window
);
1715 /* Get the dimension of the window sub-matrix for W, depending
1716 on whether this a combination or a leaf window. */
1717 if (!NILP (w
->hchild
))
1718 dim
= allocate_matrices_for_frame_redisplay (w
->hchild
, x
, y
, ch_dim
,
1720 window_change_flags
);
1721 else if (!NILP (w
->vchild
))
1722 dim
= allocate_matrices_for_frame_redisplay (w
->vchild
, x
, y
, ch_dim
,
1724 window_change_flags
);
1727 /* If not already done, allocate sub-matrix structures. */
1728 if (w
->desired_matrix
== NULL
)
1730 w
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1731 w
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1732 *window_change_flags
|= NEW_LEAF_MATRIX
;
1735 /* Width and height MUST be chosen so that there are no
1736 holes in the frame matrix. */
1737 dim
.width
= w
->width
;
1738 dim
.height
= w
->height
;
1740 /* Will matrix be re-allocated? */
1741 if (x
!= w
->desired_matrix
->matrix_x
1742 || y
!= w
->desired_matrix
->matrix_y
1743 || dim
.width
!= w
->desired_matrix
->matrix_w
1744 || dim
.height
!= w
->desired_matrix
->matrix_h
1745 || (margin_glyphs_to_reserve (w
, dim
.width
,
1746 w
->right_margin_width
)
1747 != w
->desired_matrix
->left_margin_glyphs
)
1748 || (margin_glyphs_to_reserve (w
, dim
.width
,
1749 w
->left_margin_width
)
1750 != w
->desired_matrix
->right_margin_glyphs
))
1751 *window_change_flags
|= CHANGED_LEAF_MATRIX
;
1753 /* Actually change matrices, if allowed. Do not consider
1754 CHANGED_LEAF_MATRIX computed above here because the pool
1755 may have been changed which we don't now here. We trust
1756 that we only will be called with DIM_ONLY_P != 0 when
1760 adjust_glyph_matrix (w
, w
->desired_matrix
, x
, y
, dim
);
1761 adjust_glyph_matrix (w
, w
->current_matrix
, x
, y
, dim
);
1765 /* If we are part of a horizontal combination, advance x for
1766 windows to the right of W; otherwise advance y for windows
1768 if (in_horz_combination_p
)
1773 /* Remember maximum glyph matrix dimensions. */
1774 wmax
= max (wmax
, dim
.width
);
1775 hmax
= max (hmax
, dim
.height
);
1777 /* Next window on same level. */
1780 while (!NILP (window
));
1782 /* Set `total' to the total glyph matrix dimension of this window
1783 level. In a vertical combination, the width is the width of the
1784 widest window; the height is the y we finally reached, corrected
1785 by the y we started with. In a horizontal combination, the total
1786 height is the height of the tallest window, and the width is the
1787 x we finally reached, corrected by the x we started with. */
1788 if (in_horz_combination_p
)
1790 total
.width
= x
- x0
;
1791 total
.height
= hmax
;
1796 total
.height
= y
- y0
;
1803 /* Allocate window matrices for window-based redisplay. W is the
1804 window whose matrices must be allocated/reallocated. CH_DIM is the
1805 size of the smallest character that could potentially be used on W. */
1808 allocate_matrices_for_window_redisplay (w
, ch_dim
)
1812 struct frame
*f
= XFRAME (w
->frame
);
1816 if (!NILP (w
->vchild
))
1817 allocate_matrices_for_window_redisplay (XWINDOW (w
->vchild
), ch_dim
);
1818 else if (!NILP (w
->hchild
))
1819 allocate_matrices_for_window_redisplay (XWINDOW (w
->hchild
), ch_dim
);
1822 /* W is a leaf window. */
1823 int window_pixel_width
= XFLOATINT (w
->width
) * CANON_X_UNIT (f
);
1824 int window_pixel_height
= window_box_height (w
) + abs (w
->vscroll
);
1827 /* If matrices are not yet allocated, allocate them now. */
1828 if (w
->desired_matrix
== NULL
)
1830 w
->desired_matrix
= new_glyph_matrix (NULL
);
1831 w
->current_matrix
= new_glyph_matrix (NULL
);
1834 /* Compute number of glyphs needed in a glyph row. */
1835 dim
.width
= (((window_pixel_width
+ ch_dim
.width
- 1)
1837 /* 2 partially visible columns in the text area. */
1839 /* One partially visible column at the right
1840 edge of each marginal area. */
1843 /* Compute number of glyph rows needed. */
1844 dim
.height
= (((window_pixel_height
+ ch_dim
.height
- 1)
1846 /* One partially visible line at the top and
1847 bottom of the window. */
1849 /* 2 for top and mode line. */
1852 /* Change matrices. */
1853 adjust_glyph_matrix (w
, w
->desired_matrix
, 0, 0, dim
);
1854 adjust_glyph_matrix (w
, w
->current_matrix
, 0, 0, dim
);
1857 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
1862 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
1863 do it for all frames; otherwise do it just for the given frame.
1864 This function must be called when a new frame is created, its size
1865 changes, or its window configuration changes. */
1871 /* Block input so that expose events and other events that access
1872 glyph matrices are not processed while we are changing them. */
1876 adjust_frame_glyphs (f
);
1879 Lisp_Object tail
, lisp_frame
;
1881 FOR_EACH_FRAME (tail
, lisp_frame
)
1882 adjust_frame_glyphs (XFRAME (lisp_frame
));
1889 /* Adjust frame glyphs when Emacs is initialized.
1891 To be called from init_display.
1893 We need a glyph matrix because redraw will happen soon.
1894 Unfortunately, window sizes on selected_frame are not yet set to
1895 meaningful values. I believe we can assume that there are only two
1896 windows on the frame---the mini-buffer and the root window. Frame
1897 height and width seem to be correct so far. So, set the sizes of
1898 windows to estimated values. */
1901 adjust_frame_glyphs_initially ()
1903 struct window
*root
= XWINDOW (selected_frame
->root_window
);
1904 struct window
*mini
= XWINDOW (root
->next
);
1905 int frame_height
= FRAME_HEIGHT (selected_frame
);
1906 int frame_width
= FRAME_WIDTH (selected_frame
);
1907 int top_margin
= FRAME_TOP_MARGIN (selected_frame
);
1909 /* Do it for the root window. */
1910 XSETFASTINT (root
->top
, top_margin
);
1911 XSETFASTINT (root
->width
, frame_width
);
1912 set_window_height (selected_frame
->root_window
,
1913 frame_height
- 1 - top_margin
, 0);
1915 /* Do it for the mini-buffer window. */
1916 XSETFASTINT (mini
->top
, frame_height
- 1);
1917 XSETFASTINT (mini
->width
, frame_width
);
1918 set_window_height (root
->next
, 1, 0);
1920 adjust_frame_glyphs (selected_frame
);
1921 glyphs_initialized_initially_p
= 1;
1925 /* Allocate/reallocate glyph matrices of a single frame F. */
1928 adjust_frame_glyphs (f
)
1931 if (FRAME_WINDOW_P (f
))
1932 adjust_frame_glyphs_for_window_redisplay (f
);
1934 adjust_frame_glyphs_for_frame_redisplay (f
);
1936 /* Don't forget the message buffer and the buffer for
1937 decode_mode_spec. */
1938 adjust_frame_message_buffer (f
);
1939 adjust_decode_mode_spec_buffer (f
);
1941 f
->glyphs_initialized_p
= 1;
1945 /* Allocate/reallocate glyph matrices of a single frame F for
1946 frame-based redisplay. */
1949 adjust_frame_glyphs_for_frame_redisplay (f
)
1953 struct dim matrix_dim
;
1955 int window_change_flags
;
1958 if (!FRAME_LIVE_P (f
))
1961 /* Determine the smallest character in any font for F. On
1962 console windows, all characters have dimension (1, 1). */
1963 ch_dim
.width
= ch_dim
.height
= 1;
1965 top_window_y
= FRAME_TOP_MARGIN (f
);
1967 /* Allocate glyph pool structures if not already done. */
1968 if (f
->desired_pool
== NULL
)
1970 f
->desired_pool
= new_glyph_pool ();
1971 f
->current_pool
= new_glyph_pool ();
1974 /* Allocate frames matrix structures if needed. */
1975 if (f
->desired_matrix
== NULL
)
1977 f
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1978 f
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1981 /* Compute window glyph matrices. (This takes the mini-buffer
1982 window into account). The result is the size of the frame glyph
1983 matrix needed. The variable window_change_flags is set to a bit
1984 mask indicating whether new matrices will be allocated or
1985 existing matrices change their size or location within the frame
1987 window_change_flags
= 0;
1989 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
1992 &window_change_flags
);
1994 /* Add in menu bar lines, if any. */
1995 matrix_dim
.height
+= top_window_y
;
1997 /* Enlarge pools as necessary. */
1998 pool_changed_p
= realloc_glyph_pool (f
->desired_pool
, matrix_dim
);
1999 realloc_glyph_pool (f
->current_pool
, matrix_dim
);
2001 /* Set up glyph pointers within window matrices. Do this only if
2002 absolutely necessary since it requires a frame redraw. */
2003 if (pool_changed_p
|| window_change_flags
)
2005 /* Do it for window matrices. */
2006 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2007 0, top_window_y
, ch_dim
, 0,
2008 &window_change_flags
);
2010 /* Size of frame matrices must equal size of frame. Note
2011 that we are called for X frames with window widths NOT equal
2012 to the frame width (from CHANGE_FRAME_SIZE_1). */
2013 xassert (matrix_dim
.width
== FRAME_WIDTH (f
)
2014 && matrix_dim
.height
== FRAME_HEIGHT (f
));
2016 /* Resize frame matrices. */
2017 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2018 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2020 /* Since location and size of sub-matrices within the pool may
2021 have changed, and current matrices don't have meaningful
2022 contents anymore, mark the frame garbaged. */
2023 SET_FRAME_GARBAGED (f
);
2028 /* Allocate/reallocate glyph matrices of a single frame F for
2029 window-based redisplay. */
2032 adjust_frame_glyphs_for_window_redisplay (f
)
2038 xassert (FRAME_WINDOW_P (f
) && FRAME_LIVE_P (f
));
2040 /* Get minimum sizes. */
2041 #ifdef HAVE_WINDOW_SYSTEM
2042 ch_dim
.width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2043 ch_dim
.height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
2045 ch_dim
.width
= ch_dim
.height
= 1;
2048 /* Allocate/reallocate window matrices. */
2049 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f
)),
2052 /* Allocate/ reallocate matrices of the dummy window used to display
2053 the menu bar under X when no X toolkit support is available. */
2054 #ifndef USE_X_TOOLKIT
2056 /* Allocate a dummy window if not already done. */
2057 if (NILP (f
->menu_bar_window
))
2059 f
->menu_bar_window
= make_window ();
2060 w
= XWINDOW (f
->menu_bar_window
);
2061 XSETFRAME (w
->frame
, f
);
2062 w
->pseudo_window_p
= 1;
2065 w
= XWINDOW (f
->menu_bar_window
);
2067 /* Set window dimensions to frame dimensions and allocate or
2068 adjust glyph matrices of W. */
2069 XSETFASTINT (w
->top
, 0);
2070 XSETFASTINT (w
->left
, 0);
2071 XSETFASTINT (w
->height
, FRAME_MENU_BAR_LINES (f
));
2072 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2073 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2075 #endif /* not USE_X_TOOLKIT */
2077 /* Allocate/ reallocate matrices of the toolbar window. If we don't
2078 have a toolbar window yet, make one. */
2079 if (NILP (f
->toolbar_window
))
2081 f
->toolbar_window
= make_window ();
2082 w
= XWINDOW (f
->toolbar_window
);
2083 XSETFRAME (w
->frame
, f
);
2084 w
->pseudo_window_p
= 1;
2087 w
= XWINDOW (f
->toolbar_window
);
2089 XSETFASTINT (w
->top
, FRAME_MENU_BAR_LINES (f
));
2090 XSETFASTINT (w
->left
, 0);
2091 XSETFASTINT (w
->height
, FRAME_TOOLBAR_LINES (f
));
2092 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2093 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2097 /* Adjust/ allocate message buffer of frame F.
2099 The global variables echo_area_glyphs and previous_echo_area_glyphs
2100 may be pointing to the frames message buffer and must be relocated
2101 if the buffer is reallocated.
2103 Note that the message buffer is never freed. Since I could not
2104 find a free in 19.34, I assume that freeing it would be
2105 problematic in some way and don't do it either.
2107 (Implementation note: It should be checked if we can free it
2108 eventually without causing trouble). */
2111 adjust_frame_message_buffer (f
)
2114 int size
= FRAME_MESSAGE_BUF_SIZE (f
) + 1;
2116 if (FRAME_MESSAGE_BUF (f
))
2118 char *buffer
= FRAME_MESSAGE_BUF (f
);
2119 char *new_buffer
= (char *) xrealloc (buffer
, size
);
2121 if (buffer
== echo_area_glyphs
)
2122 echo_area_glyphs
= new_buffer
;
2123 if (buffer
== previous_echo_glyphs
)
2124 previous_echo_glyphs
= new_buffer
;
2126 FRAME_MESSAGE_BUF (f
) = new_buffer
;
2129 FRAME_MESSAGE_BUF (f
) = (char *) xmalloc (size
);
2133 /* Re-allocate buffer for decode_mode_spec on frame F. */
2136 adjust_decode_mode_spec_buffer (f
)
2139 f
->decode_mode_spec_buffer
2140 = (char *) xrealloc (f
->decode_mode_spec_buffer
,
2141 FRAME_MESSAGE_BUF_SIZE (f
) + 1);
2146 /**********************************************************************
2147 Freeing Glyph Matrices
2148 **********************************************************************/
2150 /* Free glyph memory for a frame F. F may be null. This function can
2151 be called for the same frame more than once. The root window of
2152 F may be nil when this function is called. This is the case when
2153 the function is called when F is destroyed. */
2159 if (f
&& f
->glyphs_initialized_p
)
2161 f
->glyphs_initialized_p
= 0;
2163 /* Release window sub-matrices. */
2164 if (!NILP (f
->root_window
))
2165 free_window_matrices (XWINDOW (f
->root_window
));
2167 /* Free the dummy window for menu bars without X toolkit and its
2169 if (!NILP (f
->menu_bar_window
))
2171 struct window
*w
= XWINDOW (f
->menu_bar_window
);
2172 free_glyph_matrix (w
->desired_matrix
);
2173 free_glyph_matrix (w
->current_matrix
);
2174 w
->desired_matrix
= w
->current_matrix
= NULL
;
2175 f
->menu_bar_window
= Qnil
;
2178 /* Free the toolbar window and its glyph matrices. */
2179 if (!NILP (f
->toolbar_window
))
2181 struct window
*w
= XWINDOW (f
->toolbar_window
);
2182 free_glyph_matrix (w
->desired_matrix
);
2183 free_glyph_matrix (w
->current_matrix
);
2184 w
->desired_matrix
= w
->current_matrix
= NULL
;
2185 f
->toolbar_window
= Qnil
;
2188 /* Release frame glyph matrices. Reset fields to zero in
2189 case we are called a second time. */
2190 if (f
->desired_matrix
)
2192 free_glyph_matrix (f
->desired_matrix
);
2193 free_glyph_matrix (f
->current_matrix
);
2194 f
->desired_matrix
= f
->current_matrix
= NULL
;
2197 /* Release glyph pools. */
2198 if (f
->desired_pool
)
2200 free_glyph_pool (f
->desired_pool
);
2201 free_glyph_pool (f
->current_pool
);
2202 f
->desired_pool
= f
->current_pool
= NULL
;
2208 /* Free glyph sub-matrices in the window tree rooted at W. This
2209 function may be called with a null pointer, and it may be called on
2210 the same tree more than once. */
2213 free_window_matrices (w
)
2218 if (!NILP (w
->hchild
))
2219 free_window_matrices (XWINDOW (w
->hchild
));
2220 else if (!NILP (w
->vchild
))
2221 free_window_matrices (XWINDOW (w
->vchild
));
2224 /* This is a leaf window. Free its memory and reset fields
2225 to zero in case this function is called a second time for
2227 free_glyph_matrix (w
->current_matrix
);
2228 free_glyph_matrix (w
->desired_matrix
);
2229 w
->current_matrix
= w
->desired_matrix
= NULL
;
2232 /* Next window on same level. */
2233 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2238 /* Check glyph memory leaks. This function is called from
2239 shut_down_emacs. Note that frames are not destroyed when Emacs
2240 exits. We therefore free all glyph memory for all active frames
2241 explicitly and check that nothing is left allocated. */
2244 check_glyph_memory ()
2246 Lisp_Object tail
, frame
;
2248 /* Free glyph memory for all frames. */
2249 FOR_EACH_FRAME (tail
, frame
)
2250 free_glyphs (XFRAME (frame
));
2252 /* Check that nothing is left allocated. */
2253 if (glyph_matrix_count
)
2255 if (glyph_pool_count
)
2261 /**********************************************************************
2262 Building a Frame Matrix
2263 **********************************************************************/
2265 /* Most of the redisplay code works on glyph matrices attached to
2266 windows. This is a good solution most of the time, but it is not
2267 suitable for terminal code. Terminal output functions cannot rely
2268 on being able to set an arbitrary terminal window. Instead they
2269 must be provided with a view of the whole frame, i.e. the whole
2270 screen. We build such a view by constructing a frame matrix from
2271 window matrices in this section.
2273 Windows that must be updated have their must_be_update_p flag set.
2274 For all such windows, their desired matrix is made part of the
2275 desired frame matrix. For other windows, their current matrix is
2276 made part of the desired frame matrix.
2278 +-----------------+----------------+
2279 | desired | desired |
2281 +-----------------+----------------+
2284 +----------------------------------+
2286 Desired window matrices can be made part of the frame matrix in a
2287 cheap way: We exploit the fact that the desired frame matrix and
2288 desired window matrices share their glyph memory. This is not
2289 possible for current window matrices. Their glyphs are copied to
2290 the desired frame matrix. The latter is equivalent to
2291 preserve_other_columns in the old redisplay.
2293 Used glyphs counters for frame matrix rows are the result of adding
2294 up glyph lengths of the window matrices. A line in the frame
2295 matrix is enabled, if a corresponding line in a window matrix is
2298 After building the desired frame matrix, it will be passed to
2299 terminal code, which will manipulate both the desired and current
2300 frame matrix. Changes applied to the frame's current matrix have
2301 to be visible in current window matrices afterwards, of course.
2303 This problem is solved like this:
2305 1. Window and frame matrices share glyphs. Window matrices are
2306 constructed in a way that their glyph contents ARE the glyph
2307 contents needed in a frame matrix. Thus, any modification of
2308 glyphs done in terminal code will be reflected in window matrices
2311 2. Exchanges of rows in a frame matrix done by terminal code are
2312 intercepted by hook functions so that corresponding row operations
2313 on window matrices can be performed. This is necessary because we
2314 use pointers to glyphs in glyph row structures. To satisfy the
2315 assumption of point 1 above that glyphs are updated implicitly in
2316 window matrices when they are manipulated via the frame matrix,
2317 window and frame matrix must of course agree where to find the
2318 glyphs for their rows. Possible manipulations that must be
2319 mirrored are assignments of rows of the desired frame matrix to the
2320 current frame matrix and scrolling the current frame matrix. */
2322 /* Build frame F's desired matrix from window matrices. Only windows
2323 which have the flag must_be_updated_p set have to be updated. Menu
2324 bar lines of a frame are not covered by window matrices, so make
2325 sure not to touch them in this function. */
2328 build_frame_matrix (f
)
2333 /* F must have a frame matrix when this function is called. */
2334 xassert (!FRAME_WINDOW_P (f
));
2336 /* Clear all rows in the frame matrix covered by window matrices.
2337 Menu bar lines are not covered by windows. */
2338 for (i
= FRAME_TOP_MARGIN (f
); i
< f
->desired_matrix
->nrows
; ++i
)
2339 clear_glyph_row (MATRIX_ROW (f
->desired_matrix
, i
));
2341 /* Build the matrix by walking the window tree. */
2342 build_frame_matrix_from_window_tree (f
->desired_matrix
,
2343 XWINDOW (FRAME_ROOT_WINDOW (f
)));
2347 /* Walk a window tree, building a frame matrix MATRIX from window
2348 matrices. W is the root of a window tree. */
2351 build_frame_matrix_from_window_tree (matrix
, w
)
2352 struct glyph_matrix
*matrix
;
2357 if (!NILP (w
->hchild
))
2358 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->hchild
));
2359 else if (!NILP (w
->vchild
))
2360 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->vchild
));
2362 build_frame_matrix_from_leaf_window (matrix
, w
);
2364 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2369 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2370 desired frame matrix built. W is a leaf window whose desired or
2371 current matrix is to be added to FRAME_MATRIX. W's flag
2372 must_be_updated_p determines which matrix it contributes to
2373 FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix
2374 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2375 Adding a desired matrix means setting up used counters and such in
2376 frame rows, while adding a current window matrix to FRAME_MATRIX
2377 means copying glyphs. The latter case corresponds to
2378 preserve_other_columns in the old redisplay. */
2381 build_frame_matrix_from_leaf_window (frame_matrix
, w
)
2382 struct glyph_matrix
*frame_matrix
;
2385 struct glyph_matrix
*window_matrix
;
2386 int window_y
, frame_y
;
2387 /* If non-zero, a glyph to insert at the right border of W. */
2388 GLYPH right_border_glyph
= 0;
2390 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2391 if (w
->must_be_updated_p
)
2393 window_matrix
= w
->desired_matrix
;
2395 /* Decide whether we want to add a vertical border glyph. */
2396 if (!WINDOW_RIGHTMOST_P (w
))
2398 struct Lisp_Char_Table
*dp
= window_display_table (w
);
2399 right_border_glyph
= (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
2400 ? XINT (DISP_BORDER_GLYPH (dp
))
2405 window_matrix
= w
->current_matrix
;
2407 /* For all rows in the window matrix and corresponding rows in the
2410 frame_y
= window_matrix
->matrix_y
;
2411 while (window_y
< window_matrix
->nrows
)
2413 struct glyph_row
*frame_row
= frame_matrix
->rows
+ frame_y
;
2414 struct glyph_row
*window_row
= window_matrix
->rows
+ window_y
;
2416 /* Fill up the frame row with spaces up to the left margin of the
2418 fill_up_frame_row_with_spaces (frame_row
, window_matrix
->matrix_x
);
2420 /* Fill up areas in the window matrix row with spaces. */
2421 fill_up_glyph_row_with_spaces (window_row
);
2423 if (window_matrix
== w
->current_matrix
)
2425 /* We have to copy W's current matrix. Copy window
2426 row to frame row. */
2427 bcopy (window_row
->glyphs
[0],
2428 frame_row
->glyphs
[TEXT_AREA
] + window_matrix
->matrix_x
,
2429 window_matrix
->matrix_w
* sizeof (struct glyph
));
2433 /* Copy W's desired matrix. */
2435 /* Maybe insert a vertical border between horizontally adjacent
2437 if (right_border_glyph
)
2439 struct glyph
*border
= window_row
->glyphs
[LAST_AREA
] - 1;
2440 SET_CHAR_GLYPH_FROM_GLYPH (*border
, right_border_glyph
);
2443 /* Due to hooks installed, it normally doesn't happen that
2444 window rows and frame rows of the same matrix are out of
2445 sync, i.e. have a different understanding of where to
2446 find glyphs for the row. The following is a safety-belt
2447 that doesn't cost much and makes absolutely sure that
2448 window and frame matrices are in sync. */
2449 if (!glyph_row_slice_p (window_row
, frame_row
))
2451 /* Find the row in the window being a slice. There
2452 should exist one from program logic. */
2453 struct glyph_row
*slice_row
2454 = find_glyph_row_slice (window_matrix
, frame_matrix
, frame_y
);
2455 xassert (slice_row
!= 0);
2457 /* Exchange glyphs between both window rows. */
2458 swap_glyphs_in_rows (window_row
, slice_row
);
2460 /* Exchange pointers between both rows. */
2461 swap_glyph_pointers (window_row
, slice_row
);
2464 /* Now, we are sure that window row window_y is a slice of
2465 the frame row frame_y. But, lets check that assumption. */
2466 xassert (glyph_row_slice_p (window_row
, frame_row
));
2468 /* If rows are in sync, we don't have to copy glyphs because
2469 frame and window share glyphs. */
2472 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
2476 /* Set number of used glyphs in the frame matrix. Since we fill
2477 up with spaces, and visit leaf windows from left to right it
2478 can be done simply. */
2479 frame_row
->used
[TEXT_AREA
]
2480 = window_matrix
->matrix_x
+ window_matrix
->matrix_w
;
2483 frame_row
->enabled_p
|= window_row
->enabled_p
;
2484 frame_row
->inverse_p
|= window_row
->inverse_p
;
2493 /* Add spaces to a glyph row ROW in a window matrix.
2495 Each row has the form:
2497 +---------+-----------------------------+------------+
2498 | left | text | right |
2499 +---------+-----------------------------+------------+
2501 Left and right marginal areas are optional. This function adds
2502 spaces to areas so that there are no empty holes between areas.
2503 In other words: If the right area is not empty, the text area
2504 is filled up with spaces up to the right area. If the text area
2505 is not empty, the left area is filled up.
2507 To be called for frame-based redisplay, only. */
2510 fill_up_glyph_row_with_spaces (row
)
2511 struct glyph_row
*row
;
2513 fill_up_glyph_row_area_with_spaces (row
, LEFT_MARGIN_AREA
);
2514 fill_up_glyph_row_area_with_spaces (row
, TEXT_AREA
);
2515 fill_up_glyph_row_area_with_spaces (row
, RIGHT_MARGIN_AREA
);
2519 /* Fill area AREA of glyph row ROW with spaces. To be called for
2520 frame-based redisplay only. */
2523 fill_up_glyph_row_area_with_spaces (row
, area
)
2524 struct glyph_row
*row
;
2527 if (row
->glyphs
[area
] < row
->glyphs
[area
+ 1])
2529 struct glyph
*end
= row
->glyphs
[area
+ 1];
2530 struct glyph
*text
= row
->glyphs
[area
] + row
->used
[area
];
2533 *text
++ = space_glyph
;
2534 row
->used
[area
] = text
- row
->glyphs
[area
];
2539 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2540 reached. In frame matrices only one area, TEXT_AREA, is used. */
2543 fill_up_frame_row_with_spaces (row
, upto
)
2544 struct glyph_row
*row
;
2547 int i
= row
->used
[TEXT_AREA
];
2548 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
2551 glyph
[i
++] = space_glyph
;
2553 row
->used
[TEXT_AREA
] = i
;
2558 /**********************************************************************
2559 Mirroring operations on frame matrices in window matrices
2560 **********************************************************************/
2562 /* Set frame being updated via frame-based redisplay to F. This
2563 function must be called before updates to make explicit that we are
2564 working on frame matrices or not. */
2567 set_frame_matrix_frame (f
)
2570 frame_matrix_frame
= f
;
2574 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2575 DESIRED_MATRIX is the desired matrix corresponding to
2576 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2577 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2578 frame_matrix_frame is non-null, this indicates that the exchange is
2579 done in frame matrices, and that we have to perform analogous
2580 operations in window matrices of frame_matrix_frame. */
2583 make_current (desired_matrix
, current_matrix
, row
)
2584 struct glyph_matrix
*desired_matrix
, *current_matrix
;
2587 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, row
);
2588 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, row
);
2590 /* Do current_row = desired_row. This exchanges glyph pointers
2591 between both rows, and does a structure assignment otherwise. */
2592 assign_row (current_row
, desired_row
);
2594 /* Enable current_row to mark it as valid. */
2595 current_row
->enabled_p
= 1;
2597 /* If we are called on frame matrices, perform analogous operations
2598 for window matrices. */
2599 if (frame_matrix_frame
)
2600 mirror_make_current (XWINDOW (frame_matrix_frame
->root_window
), row
);
2604 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2605 W's frame which has been made current (by swapping pointers between
2606 current and desired matrix). Perform analogous operations in the
2607 matrices of leaf windows in the window tree rooted at W. */
2610 mirror_make_current (w
, frame_row
)
2616 if (!NILP (w
->hchild
))
2617 mirror_make_current (XWINDOW (w
->hchild
), frame_row
);
2618 else if (!NILP (w
->vchild
))
2619 mirror_make_current (XWINDOW (w
->vchild
), frame_row
);
2622 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2623 here because the checks performed in debug mode there
2624 will not allow the conversion. */
2625 int row
= frame_row
- w
->desired_matrix
->matrix_y
;
2627 /* If FRAME_ROW is within W, assign the desired row to the
2628 current row (exchanging glyph pointers). */
2629 if (row
>= 0 && row
< w
->desired_matrix
->matrix_h
)
2631 struct glyph_row
*current_row
2632 = MATRIX_ROW (w
->current_matrix
, row
);
2633 struct glyph_row
*desired_row
2634 = MATRIX_ROW (w
->desired_matrix
, row
);
2636 if (desired_row
->enabled_p
)
2637 assign_row (current_row
, desired_row
);
2639 swap_glyph_pointers (desired_row
, current_row
);
2640 current_row
->enabled_p
= 1;
2644 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2649 /* Perform row dance after scrolling. We are working on the range of
2650 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2651 including) in MATRIX. COPY_FROM is a vector containing, for each
2652 row I in the range 0 <= I < NLINES, the index of the original line
2653 to move to I. This index is relative to the row range, i.e. 0 <=
2654 index < NLINES. RETAINED_P is a vector containing zero for each
2655 row 0 <= I < NLINES which is empty.
2657 This function is called from do_scrolling and do_direct_scrolling. */
2660 mirrored_line_dance (matrix
, unchanged_at_top
, nlines
, copy_from
,
2662 struct glyph_matrix
*matrix
;
2663 int unchanged_at_top
, nlines
;
2667 /* A copy of original rows. */
2668 struct glyph_row
*old_rows
;
2670 /* Rows to assign to. */
2671 struct glyph_row
*new_rows
= MATRIX_ROW (matrix
, unchanged_at_top
);
2675 /* Make a copy of the original rows. */
2676 old_rows
= (struct glyph_row
*) alloca (nlines
* sizeof *old_rows
);
2677 bcopy (new_rows
, old_rows
, nlines
* sizeof *old_rows
);
2679 /* Assign new rows, maybe clear lines. */
2680 for (i
= 0; i
< nlines
; ++i
)
2682 int enabled_before_p
= new_rows
[i
].enabled_p
;
2684 xassert (i
+ unchanged_at_top
< matrix
->nrows
);
2685 xassert (unchanged_at_top
+ copy_from
[i
] < matrix
->nrows
);
2686 new_rows
[i
] = old_rows
[copy_from
[i
]];
2687 new_rows
[i
].enabled_p
= enabled_before_p
;
2689 /* RETAINED_P is zero for empty lines. */
2690 if (!retained_p
[copy_from
[i
]])
2691 new_rows
[i
].enabled_p
= 0;
2694 /* Do the same for window matrices, if MATRIX Is a frame matrix. */
2695 if (frame_matrix_frame
)
2696 mirror_line_dance (XWINDOW (frame_matrix_frame
->root_window
),
2697 unchanged_at_top
, nlines
, copy_from
, retained_p
);
2701 /* Perform a line dance in the window tree rooted at W, after
2702 scrolling a frame matrix in mirrored_line_dance.
2704 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
2705 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
2706 COPY_FROM is a vector containing, for each row I in the range 0 <=
2707 I < NLINES, the index of the original line to move to I. This
2708 index is relative to the row range, i.e. 0 <= index < NLINES.
2709 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
2713 mirror_line_dance (w
, unchanged_at_top
, nlines
, copy_from
, retained_p
)
2715 int unchanged_at_top
, nlines
;
2721 if (!NILP (w
->hchild
))
2722 mirror_line_dance (XWINDOW (w
->hchild
), unchanged_at_top
,
2723 nlines
, copy_from
, retained_p
);
2724 else if (!NILP (w
->vchild
))
2725 mirror_line_dance (XWINDOW (w
->vchild
), unchanged_at_top
,
2726 nlines
, copy_from
, retained_p
);
2729 /* W is a leaf window, and we are working on its current
2731 struct glyph_matrix
*m
= w
->current_matrix
;
2735 struct glyph_row
*old_rows
;
2737 /* Make a copy of the original rows of matrix m. */
2738 old_rows
= (struct glyph_row
*) alloca (m
->nrows
* sizeof *old_rows
);
2739 bcopy (m
->rows
, old_rows
, m
->nrows
* sizeof *old_rows
);
2741 for (i
= 0; i
< nlines
; ++i
)
2743 /* Frame relative line assigned to. */
2744 int frame_to
= i
+ unchanged_at_top
;
2746 /* Frame relative line assigned. */
2747 int frame_from
= copy_from
[i
] + unchanged_at_top
;
2749 /* Window relative line assigned to. */
2750 int window_to
= frame_to
- m
->matrix_y
;
2752 /* Window relative line assigned. */
2753 int window_from
= frame_from
- m
->matrix_y
;
2755 /* Is assigned line inside window? */
2756 int from_inside_window_p
2757 = window_from
>= 0 && window_from
< m
->matrix_h
;
2759 if (from_inside_window_p
)
2762 /* Is assigned to line inside window? */
2763 int to_inside_window_p
2764 = window_to
>= 0 && window_to
< m
->matrix_h
;
2767 /* Enabled setting before assignment. */
2768 int enabled_before_p
;
2770 /* If not both lines inside the window, we have a
2772 xassert (to_inside_window_p
);
2774 /* Do the assignment. The enabled_p flag is saved
2775 over the assignment because the old redisplay did
2777 enabled_before_p
= m
->rows
[window_to
].enabled_p
;
2778 m
->rows
[window_to
] = old_rows
[window_from
];
2779 m
->rows
[window_to
].enabled_p
= enabled_before_p
;
2781 /* If frame line is empty, window line is empty, too. */
2782 if (!retained_p
[copy_from
[i
]])
2783 m
->rows
[window_to
].enabled_p
= 0;
2787 /* Check that no pointers are lost. */
2791 /* Next window on same level. */
2792 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2799 /* Check that window and frame matrices agree about their
2800 understanding where glyphs of the rows are to find. For each
2801 window in the window tree rooted at W, check that rows in the
2802 matrices of leaf window agree with their frame matrices about
2806 check_window_matrix_pointers (w
)
2811 if (!NILP (w
->hchild
))
2812 check_window_matrix_pointers (XWINDOW (w
->hchild
));
2813 else if (!NILP (w
->vchild
))
2814 check_window_matrix_pointers (XWINDOW (w
->vchild
));
2817 struct frame
*f
= XFRAME (w
->frame
);
2818 check_matrix_pointers (w
->desired_matrix
, f
->desired_matrix
);
2819 check_matrix_pointers (w
->current_matrix
, f
->current_matrix
);
2822 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2827 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
2828 a window and FRAME_MATRIX is the corresponding frame matrix. For
2829 each row in WINDOW_MATRIX check that it's a slice of the
2830 corresponding frame row. If it isn't, abort. */
2833 check_matrix_pointers (window_matrix
, frame_matrix
)
2834 struct glyph_matrix
*window_matrix
, *frame_matrix
;
2836 /* Row number in WINDOW_MATRIX. */
2839 /* Row number corresponding to I in FRAME_MATRIX. */
2840 int j
= window_matrix
->matrix_y
;
2842 /* For all rows check that the row in the window matrix is a
2843 slice of the row in the frame matrix. If it isn't we didn't
2844 mirror an operation on the frame matrix correctly. */
2845 while (i
< window_matrix
->nrows
)
2847 if (!glyph_row_slice_p (window_matrix
->rows
+ i
,
2848 frame_matrix
->rows
+ j
))
2854 #endif /* GLYPH_DEBUG != 0 */
2858 /**********************************************************************
2859 VPOS and HPOS translations
2860 **********************************************************************/
2864 /* Translate vertical position VPOS which is relative to window W to a
2865 vertical position relative to W's frame. */
2868 window_to_frame_vpos (w
, vpos
)
2872 struct frame
*f
= XFRAME (w
->frame
);
2874 xassert (!FRAME_WINDOW_P (f
));
2875 xassert (vpos
>= 0 && vpos
<= w
->desired_matrix
->nrows
);
2876 vpos
+= XFASTINT (w
->top
);
2877 xassert (vpos
>= 0 && vpos
<= FRAME_HEIGHT (f
));
2882 /* Translate horizontal position HPOS which is relative to window W to
2883 a vertical position relative to W's frame. */
2886 window_to_frame_hpos (w
, hpos
)
2890 struct frame
*f
= XFRAME (w
->frame
);
2892 xassert (!FRAME_WINDOW_P (f
));
2893 hpos
+= XFASTINT (w
->left
);
2897 #endif /* GLYPH_DEBUG */
2901 /**********************************************************************
2903 **********************************************************************/
2905 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
2906 "Clear frame FRAME and output again what is supposed to appear on it.")
2912 CHECK_LIVE_FRAME (frame
, 0);
2915 /* Ignore redraw requests, if frame has no glyphs yet.
2916 (Implementation note: It still has to be checked why we are
2917 called so early here). */
2918 if (!glyphs_initialized_initially_p
)
2922 if (FRAME_MSDOS_P (f
))
2923 set_terminal_modes ();
2925 clear_current_matrices (f
);
2928 windows_or_buffers_changed
++;
2929 /* Mark all windows as inaccurate, so that every window will have
2930 its redisplay done. */
2931 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
2932 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
2938 /* Redraw frame F. This is nothing more than a call to the Lisp
2939 function redraw-frame. */
2946 XSETFRAME (frame
, f
);
2947 Fredraw_frame (frame
);
2951 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
2952 "Clear and redisplay all visible frames.")
2955 Lisp_Object tail
, frame
;
2957 FOR_EACH_FRAME (tail
, frame
)
2958 if (FRAME_VISIBLE_P (XFRAME (frame
)))
2959 Fredraw_frame (frame
);
2965 /* This is used when frame_garbaged is set. Call Fredraw_frame on all
2966 visible frames marked as garbaged. */
2969 redraw_garbaged_frames ()
2971 Lisp_Object tail
, frame
;
2973 FOR_EACH_FRAME (tail
, frame
)
2974 if (FRAME_VISIBLE_P (XFRAME (frame
))
2975 && FRAME_GARBAGED_P (XFRAME (frame
)))
2976 Fredraw_frame (frame
);
2981 /***********************************************************************
2983 ***********************************************************************/
2985 /* Try to update display and current glyph matrix directly.
2987 This function is called after a character G has been inserted into
2988 current_buffer. It tries to update the current glyph matrix and
2989 perform appropriate screen output to reflect the insertion. If it
2990 succeeds, the global flag redisplay_performed_directly_p will be
2991 set to 1, and thereby prevent the more costly general redisplay
2992 from running (see redisplay_internal).
2994 This function is not called for `hairy' character insertions.
2995 In particular, it is not called when after or before change
2996 functions exist, like they are used by font-lock. See keyboard.c
2997 for details where this function is called. */
3000 direct_output_for_insert (g
)
3003 register struct frame
*f
= selected_frame
;
3004 struct window
*w
= XWINDOW (selected_window
);
3006 struct glyph_row
*glyph_row
;
3007 struct glyph
*glyphs
, *glyph
, *end
;
3009 /* Non-null means that Redisplay of W is based on window matrices. */
3010 int window_redisplay_p
= FRAME_WINDOW_P (f
);
3011 /* Non-null means we are in overwrite mode. */
3012 int overwrite_p
= !NILP (current_buffer
->overwrite_mode
);
3014 struct text_pos pos
;
3015 int delta
, delta_bytes
;
3017 /* Not done directly. */
3018 redisplay_performed_directly_p
= 0;
3020 /* Quickly give up for some common cases. */
3021 if (cursor_in_echo_area
3022 /* Give up if fonts have changed. */
3024 /* Give up if face attributes have been changed. */
3025 || face_change_count
3026 /* Give up if cursor position not really known. */
3027 || !display_completed
3028 /* Give up if buffer appears in two places. */
3029 || buffer_shared
> 1
3030 /* Give up if w is mini-buffer and a message is being displayed there */
3031 || (MINI_WINDOW_P (w
)
3032 && (echo_area_glyphs
|| STRINGP (echo_area_message
)))
3033 /* Give up for hscrolled mini-buffer because display of the prompt
3034 is handled specially there (see display_line). */
3035 || (MINI_WINDOW_P (w
) && XFASTINT (w
->hscroll
))
3036 /* Give up if overwriting in the middle of a line. */
3039 && FETCH_BYTE (PT
) != '\n')
3040 /* Give up for tabs and line ends. */
3044 /* Give up if unable to display the cursor in the window. */
3045 || w
->cursor
.vpos
< 0
3046 || (glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
),
3047 /* Can't do it in a continued line because continuation
3048 lines would change. */
3049 (glyph_row
->continued_p
3050 /* Can't use this method if the line overlaps others or is
3051 overlapped by others because these other lines would
3052 have to be redisplayed. */
3053 || glyph_row
->overlapping_p
3054 || glyph_row
->overlapped_p
))
3055 /* Can't do it for partial width windows on terminal frames
3056 because we can't clear to eol in such a window. */
3057 || (!window_redisplay_p
&& !WINDOW_FULL_WIDTH_P (w
)))
3060 /* Set up a display iterator structure for W. Glyphs will be
3061 produced in scratch_glyph_row. Current position is W's cursor
3063 clear_glyph_row (&scratch_glyph_row
);
3064 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
3066 init_iterator (&it
, w
, CHARPOS (pos
), BYTEPOS (pos
), &scratch_glyph_row
,
3069 glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3071 /* Give up if highlighting trailing whitespace and we have trailing
3072 whitespace in glyph_row. We would have to remove the trailing
3073 whitespace face in that case. */
3074 if (!NILP (Vshow_trailing_whitespace
)
3075 && glyph_row
->used
[TEXT_AREA
])
3079 last
= glyph_row
->glyphs
[TEXT_AREA
] + glyph_row
->used
[TEXT_AREA
] - 1;
3080 if (last
->type
== STRETCH_GLYPH
3081 || (last
->type
== CHAR_GLYPH
3082 && last
->u
.ch
.code
== ' '))
3086 /* Give up if there are overlay strings at pos. This would fail
3087 if the overlay string has newlines in it. */
3088 if (STRINGP (it
.string
))
3091 it
.hpos
= w
->cursor
.hpos
;
3092 it
.vpos
= w
->cursor
.vpos
;
3093 it
.current_x
= w
->cursor
.x
+ it
.first_visible_x
;
3094 it
.current_y
= w
->cursor
.y
;
3095 it
.end_charpos
= PT
;
3096 it
.stop_charpos
= min (PT
, it
.stop_charpos
);
3098 /* More than one display element may be returned for PT - 1 if
3099 (i) it's a control character which is translated into `\003' or
3100 `^C', or (ii) it has a display table entry, or (iii) it's a
3101 combination of both. */
3102 delta
= delta_bytes
= 0;
3103 while (get_next_display_element (&it
))
3105 PRODUCE_GLYPHS (&it
);
3107 /* Give up if glyph doesn't fit completely on the line. */
3108 if (it
.current_x
>= it
.last_visible_x
)
3111 /* Give up if new glyph has different ascent or descent than
3112 the original row, or if it is not a character glyph. */
3113 if (glyph_row
->ascent
!= it
.ascent
3114 || glyph_row
->height
!= it
.ascent
+ it
.descent
3115 || glyph_row
->phys_ascent
!= it
.phys_ascent
3116 || glyph_row
->phys_height
!= it
.phys_ascent
+ it
.phys_descent
3117 || it
.what
!= IT_CHARACTER
)
3121 delta_bytes
+= it
.len
;
3122 set_iterator_to_next (&it
);
3125 /* Give up if we hit the right edge of the window. We would have
3126 to insert truncation or continuation glyphs. */
3127 added_width
= it
.current_x
- (w
->cursor
.x
+ it
.first_visible_x
);
3128 if (glyph_row
->pixel_width
+ added_width
>= it
.last_visible_x
)
3131 /* Give up if there is a \t following in the line. */
3133 it2
.end_charpos
= ZV
;
3134 it2
.stop_charpos
= min (it2
.stop_charpos
, ZV
);
3135 while (get_next_display_element (&it2
)
3136 && !ITERATOR_AT_END_OF_LINE_P (&it2
))
3140 set_iterator_to_next (&it2
);
3143 /* Number of new glyphs produced. */
3144 n
= it
.glyph_row
->used
[TEXT_AREA
];
3146 /* Start and end of glyphs in original row. */
3147 glyphs
= glyph_row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
3148 end
= glyph_row
->glyphs
[1 + TEXT_AREA
];
3150 /* Make room for new glyphs, then insert them. */
3151 xassert (end
- glyphs
- n
>= 0);
3152 safe_bcopy (glyphs
, glyphs
+ n
, (end
- glyphs
- n
) * sizeof (*end
));
3153 bcopy (it
.glyph_row
->glyphs
[TEXT_AREA
], glyphs
, n
* sizeof *glyphs
);
3154 glyph_row
->used
[TEXT_AREA
] = min (glyph_row
->used
[TEXT_AREA
] + n
,
3155 end
- glyph_row
->glyphs
[TEXT_AREA
]);
3157 /* Compute new line width. */
3158 glyph
= glyph_row
->glyphs
[TEXT_AREA
];
3159 end
= glyph
+ glyph_row
->used
[TEXT_AREA
];
3160 glyph_row
->pixel_width
= glyph_row
->x
;
3163 glyph_row
->pixel_width
+= glyph
->pixel_width
;
3167 /* Increment buffer positions for glyphs following the newly
3169 for (glyph
= glyphs
+ n
; glyph
< end
; ++glyph
)
3170 if (glyph
->charpos
> 0)
3171 glyph
->charpos
+= delta
;
3173 if (MATRIX_ROW_END_CHARPOS (glyph_row
) > 0)
3175 MATRIX_ROW_END_CHARPOS (glyph_row
) += delta
;
3176 MATRIX_ROW_END_BYTEPOS (glyph_row
) += delta_bytes
;
3179 /* Adjust positions in lines following the one we are in. */
3180 increment_glyph_matrix_buffer_positions (w
->current_matrix
,
3182 w
->current_matrix
->nrows
,
3183 delta
, delta_bytes
);
3185 glyph_row
->contains_overlapping_glyphs_p
3186 |= it
.glyph_row
->contains_overlapping_glyphs_p
;
3188 if (!NILP (Vshow_trailing_whitespace
))
3189 highlight_trailing_whitespace (it
.f
, glyph_row
);
3191 /* Write glyphs. If at end of row, we can simply call write_glyphs.
3192 In the middle, we have to insert glyphs. Note that this is now
3193 implemented for X frames. The implementation uses updated_window
3195 updated_row
= glyph_row
;
3199 rif
->update_window_begin_hook (w
);
3201 if (glyphs
== end
- n
)
3202 rif
->write_glyphs (glyphs
, n
);
3204 rif
->insert_glyphs (glyphs
, n
);
3208 if (glyphs
== end
- n
)
3209 write_glyphs (glyphs
, n
);
3211 insert_glyphs (glyphs
, n
);
3214 w
->cursor
.hpos
+= n
;
3215 w
->cursor
.x
= it
.current_x
- it
.first_visible_x
;
3216 xassert (w
->cursor
.hpos
>= 0
3217 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3219 /* How to set the cursor differs depending on whether we are
3220 using a frame matrix or a window matrix. Note that when
3221 a frame matrix is used, cursor_to expects frame coordinates,
3222 and the X and Y parameters are not used. */
3223 if (window_redisplay_p
)
3224 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3225 w
->cursor
.y
, w
->cursor
.x
);
3229 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3230 + (INTEGERP (w
->left_margin_width
)
3231 ? XFASTINT (w
->left_margin_width
)
3233 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3238 rif
->update_window_end_hook (w
, 1);
3243 TRACE ((stderr
, "direct output for insert\n"));
3245 unchanged_modified
= MODIFF
;
3246 beg_unchanged
= GPT
- BEG
;
3247 XSETFASTINT (w
->last_point
, PT
);
3248 w
->last_cursor
= w
->cursor
;
3249 XSETFASTINT (w
->last_modified
, MODIFF
);
3250 XSETFASTINT (w
->last_overlay_modified
, OVERLAY_MODIFF
);
3252 redisplay_performed_directly_p
= 1;
3257 /* Perform a direct display update for moving PT by N positions
3258 left or right. N < 0 means a movement backwards. This function
3259 is currently only called for N == 1 or N == -1. */
3262 direct_output_forward_char (n
)
3265 struct frame
*f
= selected_frame
;
3266 struct window
*w
= XWINDOW (selected_window
);
3267 struct glyph_row
*row
;
3269 /* Give up if face attributes have been changed. */
3270 if (face_change_count
)
3273 /* Give up if current matrix is not up to date or we are
3274 displaying a message. */
3275 if (!display_completed
|| cursor_in_echo_area
)
3278 /* Give up if the buffer's direction is reversed. */
3279 if (!NILP (XBUFFER (w
->buffer
)->direction_reversed
))
3282 /* Can't use direct output if highlighting a region. */
3283 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
3286 /* Can't use direct output if highlighting trailing whitespace. */
3287 if (!NILP (Vshow_trailing_whitespace
))
3290 row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3292 if (PT
<= MATRIX_ROW_START_BYTEPOS (row
)
3293 || PT
>= MATRIX_ROW_END_BYTEPOS (row
))
3296 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
3297 w
->last_cursor
= w
->cursor
;
3298 XSETFASTINT (w
->last_point
, PT
);
3300 xassert (w
->cursor
.hpos
>= 0
3301 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3303 if (FRAME_WINDOW_P (f
))
3304 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3305 w
->cursor
.y
, w
->cursor
.x
);
3309 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3310 + (INTEGERP (w
->left_margin_width
)
3311 ? XFASTINT (w
->left_margin_width
)
3313 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3318 redisplay_performed_directly_p
= 1;
3324 /***********************************************************************
3326 ***********************************************************************/
3328 /* Update frame F based on the data in desired matrices.
3330 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3331 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3334 Value is non-zero if redisplay was stopped due to pending input. */
3337 update_frame (f
, force_p
, inhibit_hairy_id_p
)
3340 int inhibit_hairy_id_p
;
3342 /* 1 means display has been paused because of pending input. */
3344 struct window
*root_window
= XWINDOW (f
->root_window
);
3346 if (FRAME_WINDOW_P (f
))
3348 /* We are working on window matrix basis. All windows whose
3349 flag must_be_updated_p is set have to be updated. */
3351 /* Record that we are not working on frame matrices. */
3352 set_frame_matrix_frame (NULL
);
3354 /* Update all windows in the window tree of F, maybe stopping
3355 when pending input is detected. */
3358 /* Update the menu bar on X frames that don't have toolkit
3360 if (WINDOWP (f
->menu_bar_window
))
3361 update_window (XWINDOW (f
->menu_bar_window
), 1);
3363 /* Update the tool-bar window, if present. */
3364 if (WINDOWP (f
->toolbar_window
))
3367 struct window
*w
= XWINDOW (f
->toolbar_window
);
3369 /* Update tool-bar window. */
3370 if (w
->must_be_updated_p
)
3372 update_window (w
, 1);
3373 w
->must_be_updated_p
= 0;
3375 /* Swap tool-bar strings. We swap because we want to
3377 tem
= f
->current_toolbar_string
;
3378 f
->current_toolbar_string
= f
->desired_toolbar_string
;
3379 f
->desired_toolbar_string
= tem
;
3380 f
->n_current_toolbar_items
= f
->n_desired_toolbar_items
;
3382 /* Swap tool-bar items. We swap because we want to
3384 tem
= f
->current_toolbar_items
;
3385 f
->current_toolbar_items
= f
->desired_toolbar_items
;
3386 f
->desired_toolbar_items
= tem
;
3391 /* Update windows. */
3392 paused_p
= update_window_tree (root_window
, force_p
);
3394 display_completed
= !paused_p
;
3396 /* The flush is a performance bottleneck under X. */
3398 rif
->flush_display (f
);
3403 /* We are working on frame matrix basis. Set the frame on whose
3404 frame matrix we operate. */
3405 set_frame_matrix_frame (f
);
3407 /* Build F's desired matrix from window matrices. For windows
3408 whose must_be_updated_p flag is set, desired matrices are
3409 made part of the desired frame matrix. For other windows,
3410 the current matrix is copied. */
3411 build_frame_matrix (f
);
3413 /* Do the update on the frame desired matrix. */
3414 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3416 /* Check window matrices for lost pointers. */
3417 IF_DEBUG (check_window_matrix_pointers (root_window
));
3420 /* Reset flags indicating that a window should be updated. */
3421 set_window_update_flags (root_window
, 0);
3427 /************************************************************************
3428 Window-based updates
3429 ************************************************************************/
3431 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3432 don't stop updating when input is pending. */
3435 update_window_tree (w
, force_p
)
3441 while (w
&& !paused_p
)
3443 if (!NILP (w
->hchild
))
3444 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
3445 else if (!NILP (w
->vchild
))
3446 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
3447 else if (w
->must_be_updated_p
)
3448 paused_p
|= update_window (w
, force_p
);
3450 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3457 /* Update window W if its flag must_be_updated_p is non-zero. If
3458 FORCE_P is non-zero, don't stop updating if input is pending. */
3461 update_single_window (w
, force_p
)
3465 if (w
->must_be_updated_p
)
3467 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3469 /* Record that this is not a frame-based redisplay. */
3470 set_frame_matrix_frame (NULL
);
3474 update_window (w
, force_p
);
3477 /* Reset flag in W. */
3478 w
->must_be_updated_p
= 0;
3483 /* Redraw lines from the current matrix of window W that are
3484 overlapped by other rows. YB is bottom-most y-position in W. */
3487 redraw_overlapped_rows (w
, yb
)
3492 struct glyph_row
*row
;
3494 /* If rows overlapping others have been changed, the rows being
3495 overlapped have to be redrawn. This won't draw lines that have
3496 already been drawn in update_window_line because overlapped_p in
3497 desired rows is 0, so after row assignment overlapped_p in
3498 current rows is 0. */
3499 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3501 row
= w
->current_matrix
->rows
+ i
;
3503 if (!row
->enabled_p
)
3505 else if (row
->mode_line_p
)
3508 if (row
->overlapped_p
)
3510 enum glyph_row_area area
;
3512 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3515 updated_area
= area
;
3516 rif
->cursor_to (i
, 0, row
->y
, area
== TEXT_AREA
? row
->x
: 0);
3517 if (row
->used
[area
])
3518 rif
->write_glyphs (row
->glyphs
[area
], row
->used
[area
]);
3519 rif
->clear_end_of_line (-1);
3522 row
->overlapped_p
= 0;
3525 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3532 /* Redraw lines from the current matrix of window W that overlap
3533 others. YB is bottom-most y-position in W. */
3536 redraw_overlapping_rows (w
, yb
)
3541 struct glyph_row
*row
;
3543 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3545 row
= w
->current_matrix
->rows
+ i
;
3547 if (!row
->enabled_p
)
3549 else if (row
->mode_line_p
)
3552 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3554 if (row
->overlapping_p
&& i
> 0 && bottom_y
< yb
)
3556 if (row
->used
[LEFT_MARGIN_AREA
])
3557 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
);
3559 if (row
->used
[TEXT_AREA
])
3560 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
);
3562 if (row
->used
[RIGHT_MARGIN_AREA
])
3563 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
);
3565 /* Record in neighbor rows that ROW overwrites part of their
3567 if (row
->phys_ascent
> row
->ascent
&& i
> 0)
3568 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3569 if ((row
->phys_height
- row
->phys_ascent
3570 > row
->height
- row
->ascent
)
3572 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
3581 /* Update display of window W. FORCE_P non-zero means that we should
3582 not stop when detecting pending input. */
3585 update_window (w
, force_p
)
3589 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3590 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
3592 int preempt_count
= baud_rate
/ 2400 + 1;
3593 extern int input_pending
;
3594 extern struct frame
*updating_frame
;
3596 /* Check that W's frame doesn't have glyph matrices. */
3597 xassert (FRAME_WINDOW_P (f
));
3598 xassert (updating_frame
!= NULL
);
3600 /* Check pending input the first time so that we can quickly return. */
3601 if (redisplay_dont_pause
)
3604 detect_input_pending ();
3606 /* If forced to complete the update, or if no input is pending, do
3608 if (force_p
|| !input_pending
)
3610 struct glyph_row
*row
, *end
;
3611 struct glyph_row
*mode_line_row
;
3612 struct glyph_row
*top_line_row
= NULL
;
3613 int yb
, changed_p
= 0;
3615 rif
->update_window_begin_hook (w
);
3616 yb
= window_text_bottom_y (w
);
3618 /* If window has a top line, update it before everything else.
3619 Adjust y-positions of other rows by the top line height. */
3620 row
= desired_matrix
->rows
;
3621 end
= row
+ desired_matrix
->nrows
- 1;
3622 if (row
->mode_line_p
)
3623 top_line_row
= row
++;
3625 /* Update the mode line, if necessary. */
3626 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3627 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
3629 mode_line_row
->y
= yb
;
3630 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
3635 /* Find first enabled row. Optimizations in redisplay_internal
3636 may lead to an update with only one row enabled. There may
3637 be also completely empty matrices. */
3638 while (row
< end
&& !row
->enabled_p
)
3641 /* Try reusing part of the display by inserting/deleting lines. */
3642 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
3644 int rc
= scrolling_window (w
, top_line_row
!= NULL
);
3647 /* All rows were found to be equal. */
3656 /* Update the top mode line after scrolling because a new top
3657 line would otherwise overwrite lines at the top of the window
3658 that can be scrolled. */
3659 if (top_line_row
&& top_line_row
->enabled_p
)
3661 top_line_row
->y
= 0;
3662 update_window_line (w
, 0);
3666 /* Update the rest of the lines. */
3667 for (; row
< end
&& (force_p
|| !input_pending
); ++row
)
3669 /* A row can be completely invisible in case a desired
3670 matrix was built with a vscroll and then
3671 make_cursor_line_fully_visible shifts the matrix. */
3672 && row
->visible_height
> 0)
3674 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
3677 /* We'll Have to play a little bit with when to
3678 detect_input_pending. If it's done too often,
3679 scrolling large windows with repeated scroll-up
3680 commands will too quickly pause redisplay. */
3681 if (!force_p
&& vpos
% preempt_count
== 0)
3682 detect_input_pending ();
3684 changed_p
|= update_window_line (w
, vpos
);
3686 /* Mark all rows below the last visible one in the current
3687 matrix as invalid. This is necessary because of
3688 variable line heights. Consider the case of three
3689 successive redisplays, where the first displays 5
3690 lines, the second 3 lines, and the third 5 lines again.
3691 If the second redisplay wouldn't mark rows in the
3692 current matrix invalid, the third redisplay might be
3693 tempted to optimize redisplay based on lines displayed
3694 in the first redisplay. */
3695 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3696 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
3697 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
3700 /* Was display preempted? */
3701 paused_p
= row
< end
;
3705 /* Fix the appearance of overlapping(overlapped rows. */
3706 if (rif
->fix_overlapping_area
3707 && !w
->pseudo_window_p
3711 redraw_overlapped_rows (w
, yb
);
3712 redraw_overlapping_rows (w
, yb
);
3715 if (!paused_p
&& !w
->pseudo_window_p
)
3717 /* Make cursor visible at cursor position of W. */
3718 set_window_cursor_after_update (w
);
3721 /* Check that current matrix invariants are satisfied. This
3722 is for debugging only. See the comment around
3723 check_matrix_invariants. */
3724 IF_DEBUG (check_matrix_invariants (w
));
3729 /* Remember the redisplay method used to display the matrix. */
3730 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
3733 /* End of update of window W. */
3734 rif
->update_window_end_hook (w
, 1);
3740 clear_glyph_matrix (desired_matrix
);
3746 /* Update the display of area AREA in window W, row number VPOS.
3747 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3750 update_marginal_area (w
, area
, vpos
)
3754 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3756 /* Let functions in xterm.c know what area subsequent X positions
3757 will be relative to. */
3758 updated_area
= area
;
3760 /* Set cursor to start of glyphs, write them, and clear to the end
3761 of the area. I don't think that something more sophisticated is
3762 necessary here, since marginal areas will not be the default. */
3763 rif
->cursor_to (vpos
, 0, desired_row
->y
, 0);
3764 if (desired_row
->used
[area
])
3765 rif
->write_glyphs (desired_row
->glyphs
[area
], desired_row
->used
[area
]);
3766 rif
->clear_end_of_line (-1);
3770 /* Update the display of the text area of row VPOS in window W.
3771 Value is non-zero if display has changed. */
3774 update_text_area (w
, vpos
)
3778 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3779 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3782 /* Let functions in xterm.c know what area subsequent X positions
3783 will be relative to. */
3784 updated_area
= TEXT_AREA
;
3786 /* If rows are at different X or Y, or rows have different height,
3787 or the current row is marked invalid, write the entire line. */
3788 if (!current_row
->enabled_p
3789 || desired_row
->y
!= current_row
->y
3790 || desired_row
->ascent
!= current_row
->ascent
3791 || desired_row
->phys_ascent
!= current_row
->phys_ascent
3792 || desired_row
->phys_height
!= current_row
->phys_height
3793 || desired_row
->visible_height
!= current_row
->visible_height
3794 || current_row
->overlapped_p
3795 || current_row
->x
!= desired_row
->x
)
3797 rif
->cursor_to (vpos
, 0, desired_row
->y
, desired_row
->x
);
3799 if (desired_row
->used
[TEXT_AREA
])
3800 rif
->write_glyphs (desired_row
->glyphs
[TEXT_AREA
],
3801 desired_row
->used
[TEXT_AREA
]);
3803 /* Clear to end of window. */
3804 rif
->clear_end_of_line (-1);
3810 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
3811 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
3813 /* If the desired row extends its face to the text area end,
3814 make sure we write at least one glyph, so that the face
3815 extension actually takes place. */
3816 int desired_stop_pos
= (desired_row
->used
[TEXT_AREA
]
3817 - (MATRIX_ROW_EXTENDS_FACE_P (desired_row
)
3820 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
3826 /* Skip over glyphs that both rows have in common. These
3827 don't have to be written. */
3829 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3831 x
+= desired_glyph
->pixel_width
;
3832 ++desired_glyph
, ++current_glyph
, ++i
;
3835 /* Consider the case that the current row contains "xxx ppp
3836 ggg" in italic Courier font, and the desired row is "xxx
3837 ggg". The character `p' has lbearing, `g' has not. The
3838 loop above will stop in front of the first `p' in the
3839 current row. If we would start writing glyphs there, we
3840 wouldn't erase the lbearing of the `p'. The rest of the
3841 lbearing problem is then taken care of by x_draw_glyphs. */
3842 if (current_row
->contains_overlapping_glyphs_p
3844 && i
< current_row
->used
[TEXT_AREA
]
3845 && current_row
->used
[TEXT_AREA
] != desired_row
->used
[TEXT_AREA
])
3848 rif
->get_glyph_overhangs (current_glyph
, XFRAME (w
->frame
),
3850 while (left
> 0 && i
> 0)
3852 --i
, --desired_glyph
, --current_glyph
;
3853 x
-= desired_glyph
->pixel_width
;
3854 left
-= desired_glyph
->pixel_width
;
3858 /* Try to avoid writing the entire rest of the desired row
3859 by looking for a resync point. This mainly prevents
3860 mode line flickering in the case the mode line is in
3861 fixed-pitch font, which it usually will be. */
3862 if (i
< desired_row
->used
[TEXT_AREA
])
3864 int start_x
= x
, start_hpos
= i
;
3865 struct glyph
*start
= desired_glyph
;
3868 /* Find the next glyph that's equal again. */
3870 && !GLYPH_EQUAL_P (desired_glyph
, current_glyph
)
3873 x
+= desired_glyph
->pixel_width
;
3874 current_x
+= current_glyph
->pixel_width
;
3875 ++desired_glyph
, ++current_glyph
, ++i
;
3878 if (i
== start_hpos
|| x
!= current_x
)
3882 desired_glyph
= start
;
3886 rif
->cursor_to (vpos
, start_hpos
, desired_row
->y
, start_x
);
3887 rif
->write_glyphs (start
, i
- start_hpos
);
3892 /* Write the rest. */
3893 if (i
< desired_row
->used
[TEXT_AREA
])
3895 rif
->cursor_to (vpos
, i
, desired_row
->y
, x
);
3896 rif
->write_glyphs (desired_glyph
, desired_row
->used
[TEXT_AREA
] - i
);
3900 /* Maybe clear to end of line. */
3901 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
3903 /* If new row extends to the end of the text area, nothing
3904 has to be cleared, if and only if we did a write_glyphs
3905 above. This is made sure by setting desired_stop_pos
3906 appropriately above. */
3907 xassert (i
< desired_row
->used
[TEXT_AREA
]);
3909 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
3911 /* If old row extends to the end of the text area, clear. */
3912 if (i
>= desired_row
->used
[TEXT_AREA
])
3913 rif
->cursor_to (vpos
, i
, desired_row
->y
,
3914 desired_row
->x
+ desired_row
->pixel_width
);
3915 rif
->clear_end_of_line (-1);
3918 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
3920 /* Otherwise clear to the end of the old row. Everything
3921 after that position should be clear already. */
3924 if (i
>= desired_row
->used
[TEXT_AREA
])
3925 rif
->cursor_to (vpos
, i
, desired_row
->y
,
3926 desired_row
->x
+ desired_row
->pixel_width
);
3928 /* If cursor is displayed at the end of the line, make sure
3929 it's cleared. Nowadays we don't have a phys_cursor_glyph
3930 with which to erase the cursor (because this method
3931 doesn't work with lbearing/rbearing), so we must do it
3933 if (vpos
== w
->phys_cursor
.vpos
3934 && w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])
3936 w
->phys_cursor_on_p
= 0;
3940 x
= current_row
->x
+ current_row
->pixel_width
;
3941 rif
->clear_end_of_line (x
);
3950 /* Update row VPOS in window W. Value is non-zero if display has been
3954 update_window_line (w
, vpos
)
3958 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3959 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3962 xassert (desired_row
->enabled_p
);
3964 /* Set the row being updated. This is important to let xterm.c
3965 know what line height values are in effect. */
3966 updated_row
= desired_row
;
3968 /* Update display of the left margin area, if there is one. */
3969 if (!desired_row
->full_width_p
3970 && !NILP (w
->left_margin_width
))
3972 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
3976 /* Update the display of the text area. */
3977 changed_p
|= update_text_area (w
, vpos
);
3979 /* Update display of the right margin area, if there is one. */
3980 if (!desired_row
->full_width_p
3981 && !NILP (w
->right_margin_width
))
3984 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
3987 /* Draw truncation marks etc. */
3988 if (!current_row
->enabled_p
3989 || desired_row
->y
!= current_row
->y
3990 || desired_row
->visible_height
!= current_row
->visible_height
3991 || desired_row
->overlay_arrow_p
!= current_row
->overlay_arrow_p
3992 || desired_row
->truncated_on_left_p
!= current_row
->truncated_on_left_p
3993 || desired_row
->truncated_on_right_p
!= current_row
->truncated_on_right_p
3994 || desired_row
->continued_p
!= current_row
->continued_p
3995 || desired_row
->mode_line_p
!= current_row
->mode_line_p
3996 || (desired_row
->indicate_empty_line_p
3997 != current_row
->indicate_empty_line_p
)
3998 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
3999 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
4000 rif
->after_update_window_line_hook (desired_row
);
4002 /* Update current_row from desired_row. */
4003 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4009 /* Set the cursor after an update of window W. This function may only
4010 be called from update_window. */
4013 set_window_cursor_after_update (w
)
4016 struct frame
*f
= XFRAME (w
->frame
);
4017 int cx
, cy
, vpos
, hpos
;
4019 /* Not intended for frame matrix updates. */
4020 xassert (FRAME_WINDOW_P (f
));
4022 if ((cursor_in_echo_area
4023 /* If we are showing a message instead of the mini-buffer,
4024 show the cursor for the message instead of for the
4025 (now hidden) mini-buffer contents. */
4026 || (XWINDOW (minibuf_window
) == w
4027 && EQ (minibuf_window
, echo_area_window
)
4028 && (echo_area_glyphs
|| STRINGP (echo_area_message
))))
4029 /* These cases apply only to the frame that contains
4030 the active mini-buffer window. */
4031 && FRAME_HAS_MINIBUF_P (f
)
4032 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4034 cx
= cy
= vpos
= hpos
= 0;
4036 if (cursor_in_echo_area
>= 0)
4038 /* If the mini-buffer is several lines high, find the last
4039 line that has any text on it. Note: either all lines
4040 are enabled or none. Otherwise we wouldn't be able to
4042 struct glyph_row
*row
, *last_row
;
4043 struct glyph
*glyph
;
4044 int yb
= window_text_bottom_y (w
);
4047 for (row
= MATRIX_ROW (w
->current_matrix
, 0);; ++row
)
4049 if (row
->used
[TEXT_AREA
]
4050 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4053 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4059 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
4060 struct glyph
*last
= start
+ row
->used
[TEXT_AREA
];
4062 while (last
> start
&& (last
- 1)->charpos
< 0)
4065 for (glyph
= start
; glyph
< last
; ++glyph
)
4067 cx
+= glyph
->pixel_width
;
4072 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4080 hpos
= w
->cursor
.hpos
;
4081 vpos
= w
->cursor
.vpos
;
4084 /* Window cursor can be out of sync for horizontally split windows. */
4085 hpos
= max (0, hpos
);
4086 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4087 vpos
= max (0, vpos
);
4088 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4089 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4093 /* Try to reuse part of the current display of W by scrolling lines.
4094 TOP_LINE_P non-zero means W has a top mode line.
4096 The algorithm is taken from Communications of the ACM, Apr78 "A
4097 Technique for Isolating Differences Between Files." It should take
4100 A short outline of the steps of the algorithm
4102 1. Skip lines equal at the start and end of both matrices.
4104 2. Enter rows in the current and desired matrix into a symbol
4105 table, counting how often they appear in both matrices.
4107 3. Rows that appear exactly once in both matrices serve as anchors,
4108 i.e. we assume that such lines are likely to have been moved.
4110 4. Starting from anchor lines, extend regions to be scrolled both
4111 forward and backward.
4115 -1 if all rows were found to be equal.
4116 0 to indicate that we did not scroll the display, or
4117 1 if we did scroll. */
4120 scrolling_window (w
, top_line_p
)
4126 /* Number of occurrences of this line in old and new matrix. */
4127 short old_uses
, new_uses
;
4129 /* Vpos of line in new matrix. */
4130 short new_line_number
;
4132 /* The line itself. */
4133 struct glyph_row
*row
;
4135 /* Hash collision chain. */
4136 struct symbol
*next
;
4139 int SYMBOL_TABLE_SIZE
= 101;
4140 struct symbol
**table
;
4141 struct symbol
**old_line_syms
, **new_line_syms
;
4142 int i
, j
, first_old
, first_new
, last_old
, last_new
;
4146 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4147 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4148 int yb
= window_text_bottom_y (w
);
4150 /* Skip over rows equal at the start. */
4151 i
= top_line_p
? 1 : 0;
4152 while (i
< current_matrix
->nrows
- 1
4153 && MATRIX_ROW_ENABLED_P (current_matrix
, i
)
4154 && MATRIX_ROW_ENABLED_P (desired_matrix
, i
)
4155 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) < yb
4156 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) < yb
4158 MATRIX_ROW (desired_matrix
, i
),
4159 MATRIX_ROW (current_matrix
, i
)))
4161 assign_row (MATRIX_ROW (current_matrix
, i
),
4162 MATRIX_ROW (desired_matrix
, i
));
4163 MATRIX_ROW (desired_matrix
, i
)->enabled_p
= 0;
4167 /* Give up if some rows in the desired matrix are not enabled. */
4168 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4171 first_old
= first_new
= i
;
4173 /* Set last_new to the index + 1 of the last enabled row in the
4176 while (i
< desired_matrix
->nrows
- 1
4177 && MATRIX_ROW (desired_matrix
, i
)->enabled_p
4178 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) < yb
)
4181 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4186 /* Set last_old to the index + 1 of the last enabled row in the
4187 current matrix. We don't look at the enabled flag here because
4188 we plan to reuse part of the display even if other parts are
4191 while (i
< current_matrix
->nrows
- 1
4192 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) < yb
)
4196 /* Skip over rows equal at the bottom. */
4199 while (i
- 1 > first_new
4200 && j
- 1 > first_old
4201 && MATRIX_ROW (current_matrix
, i
- 1)->enabled_p
4202 && (MATRIX_ROW (current_matrix
, i
- 1)->y
4203 == MATRIX_ROW (desired_matrix
, j
- 1)->y
)
4205 MATRIX_ROW (desired_matrix
, i
- 1),
4206 MATRIX_ROW (current_matrix
, j
- 1)))
4211 /* Nothing to do if all rows are equal. */
4212 if (last_new
== first_new
)
4215 /* Allocate a hash table in which all rows will be inserted. */
4216 table
= (struct symbol
**) alloca (SYMBOL_TABLE_SIZE
* sizeof *table
);
4217 bzero (table
, SYMBOL_TABLE_SIZE
* sizeof *table
);
4219 /* For each row in the current matrix, record the symbol belonging
4220 to the row in OLD_LINE_SYMS. */
4221 old_line_syms
= (struct symbol
**) alloca (current_matrix
->nrows
4222 * sizeof *old_line_syms
);
4223 new_line_syms
= (struct symbol
**) alloca (desired_matrix
->nrows
4224 * sizeof *new_line_syms
);
4226 #define ADDSYM(ROW) \
4229 struct glyph_row *row_ = (ROW); \
4230 int i_ = row_->hash % SYMBOL_TABLE_SIZE; \
4232 while (sym && !row_equal_p (w, sym->row, row_)) \
4236 sym = (struct symbol *) alloca (sizeof *sym); \
4238 sym->old_uses = sym->new_uses = 0; \
4239 sym->next = table[i_]; \
4245 /* Add current rows to the symbol table. */
4246 for (i
= first_old
; i
< last_old
; ++i
)
4248 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4250 ADDSYM (MATRIX_ROW (current_matrix
, i
));
4251 old_line_syms
[i
] = sym
;
4255 old_line_syms
[i
] = NULL
;
4258 /* Add desired rows to the symbol table. */
4259 for (i
= first_new
; i
< last_new
; ++i
)
4261 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4262 ADDSYM (MATRIX_ROW (desired_matrix
, i
));
4264 new_line_syms
[i
] = sym
;
4265 sym
->new_line_number
= i
;
4270 /* Record in runs which moves were found, ordered by pixel
4271 height of copied areas. */
4273 runs
= (struct run
**) alloca (desired_matrix
->nrows
* sizeof *runs
);
4275 /* Identify moves based on lines that are unique and equal
4276 in both matrices. */
4277 for (i
= first_old
; i
< last_old
;)
4278 if (old_line_syms
[i
]
4279 && old_line_syms
[i
]->old_uses
== 1
4280 && old_line_syms
[i
]->new_uses
== 1)
4283 int new_line
= old_line_syms
[i
]->new_line_number
;
4284 struct run
*run
= (struct run
*) alloca (sizeof *run
);
4287 run
->current_vpos
= i
;
4288 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4289 run
->desired_vpos
= new_line
;
4290 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4292 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4294 /* Extend backward. */
4297 while (j
> first_old
4299 && old_line_syms
[j
] == new_line_syms
[k
])
4301 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4302 --run
->current_vpos
;
4303 --run
->desired_vpos
;
4306 run
->desired_y
-= h
;
4307 run
->current_y
-= h
;
4311 /* Extend forward. */
4316 && old_line_syms
[j
] == new_line_syms
[k
])
4318 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4324 /* Insert run into list of all runs. Order runs by copied
4325 pixel lines. Note that we record runs that don't have to
4326 be copied because they are already in place. This is done
4327 because we can avoid calling update_window_line in this
4329 for (j
= 0; j
< nruns
&& runs
[j
]->height
> run
->height
; ++j
)
4331 for (k
= nruns
; k
>= j
; --k
)
4332 runs
[k
] = runs
[k
- 1];
4341 /* Do the moves. Do it in a way that we don't overwrite something
4342 we want to copy later on. This is not solvable in general
4343 because there is only one display and we don't have a way to
4344 exchange areas on this display. Example:
4346 +-----------+ +-----------+
4348 +-----------+ --> +-----------+
4350 +-----------+ +-----------+
4352 Instead, prefer bigger moves, and invalidate moves that would
4353 copy from where we copied to. */
4355 for (i
= 0; i
< nruns
; ++i
)
4356 if (runs
[i
]->nrows
> 0)
4358 struct run
*r
= runs
[i
];
4360 /* Copy on the display. */
4361 if (r
->current_y
!= r
->desired_y
)
4363 rif
->scroll_run_hook (w
, r
);
4365 /* Invalidate runs that copy from where we copied to. */
4366 for (j
= i
+ 1; j
< nruns
; ++j
)
4368 struct run
*p
= runs
[j
];
4370 if ((p
->current_y
>= r
->desired_y
4371 && p
->current_y
< r
->desired_y
+ r
->height
)
4372 || (p
->current_y
+ p
->height
>= r
->desired_y
4373 && (p
->current_y
+ p
->height
4374 < r
->desired_y
+ r
->height
)))
4379 /* Assign matrix rows. */
4380 for (j
= 0; j
< r
->nrows
; ++j
)
4382 struct glyph_row
*from
, *to
;
4383 int to_overlapped_p
;
4385 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
4386 to_overlapped_p
= to
->overlapped_p
;
4387 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
4388 assign_row (to
, from
);
4389 to
->enabled_p
= 1, from
->enabled_p
= 0;
4390 to
->overlapped_p
= to_overlapped_p
;
4394 /* Value is non-zero to indicate that we scrolled the display. */
4399 /* Set WINDOW->must_be_updated_p TO ON_P for all windows WINDOW in the
4400 window tree rooted at W. */
4403 set_window_update_flags (w
, on_p
)
4409 if (!NILP (w
->hchild
))
4410 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4411 else if (!NILP (w
->vchild
))
4412 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4414 w
->must_be_updated_p
= on_p
;
4416 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4422 /************************************************************************
4424 ************************************************************************/
4426 /* Update the desired frame matrix of frame F.
4428 FORCE_P non-zero means that the update should not be stopped by
4429 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
4430 should not be tried.
4432 Value is non-zero if update was stopped due to pending input. */
4435 update_frame_1 (f
, force_p
, inhibit_id_p
)
4440 /* Frame matrices to work on. */
4441 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4442 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4445 int preempt_count
= baud_rate
/ 2400 + 1;
4446 extern int input_pending
;
4448 xassert (current_matrix
&& desired_matrix
);
4450 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
4451 calculate_costs (f
);
4453 if (preempt_count
<= 0)
4456 detect_input_pending ();
4457 if (input_pending
&& !force_p
)
4465 /* If we cannot insert/delete lines, it's no use trying it. */
4466 if (!line_ins_del_ok
)
4469 /* See if any of the desired lines are enabled; don't compute for
4470 i/d line if just want cursor motion. */
4471 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
4472 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4475 /* Try doing i/d line, if not yet inhibited. */
4476 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
4477 force_p
|= scrolling (f
);
4479 /* Update the individual lines as needed. Do bottom line first. */
4480 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
4481 update_frame_line (f
, desired_matrix
->nrows
- 1);
4483 /* Now update the rest of the lines. */
4484 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
4486 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4488 if (FRAME_TERMCAP_P (f
))
4490 /* Flush out every so many lines.
4491 Also flush out if likely to have more than 1k buffered
4492 otherwise. I'm told that some telnet connections get
4493 really screwed by more than 1k output at once. */
4494 int outq
= PENDING_OUTPUT_COUNT (stdout
);
4496 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
4499 if (preempt_count
== 1)
4501 #ifdef EMACS_OUTQSIZE
4502 if (EMACS_OUTQSIZE (0, &outq
) < 0)
4503 /* Probably not a tty. Ignore the error and reset
4504 * the outq count. */
4505 outq
= PENDING_OUTPUT_COUNT (stdout
);
4508 if (baud_rate
<= outq
&& baud_rate
> 0)
4509 sleep (outq
/ baud_rate
);
4514 if ((i
- 1) % preempt_count
== 0)
4515 detect_input_pending ();
4517 update_frame_line (f
, i
);
4521 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
4523 /* Now just clean up termcap drivers and set cursor, etc. */
4526 if ((cursor_in_echo_area
4527 /* If we are showing a message instead of the mini-buffer,
4528 show the cursor for the message instead of for the
4529 (now hidden) mini-buffer contents. */
4530 || (EQ (minibuf_window
, selected_window
)
4531 && EQ (minibuf_window
, echo_area_window
)
4532 && (echo_area_glyphs
|| STRINGP (echo_area_message
))))
4533 /* These cases apply only to the frame that contains
4534 the active mini-buffer window. */
4535 && FRAME_HAS_MINIBUF_P (f
)
4536 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4538 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
4541 if (cursor_in_echo_area
< 0)
4543 /* Negative value of cursor_in_echo_area means put
4544 cursor at beginning of line. */
4550 /* Positive value of cursor_in_echo_area means put
4551 cursor at the end of the prompt. If the mini-buffer
4552 is several lines high, find the last line that has
4554 row
= FRAME_HEIGHT (f
);
4560 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
4562 /* Frame rows are filled up with spaces that
4563 must be ignored here. */
4565 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
4567 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
4568 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
4571 && (last
- 1)->charpos
< 0)
4577 while (row
> top
&& col
== 0);
4579 /* Make sure COL is not out of range. */
4580 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
4582 /* If we have another row, advance cursor into it. */
4583 if (row
< FRAME_HEIGHT (f
) - 1)
4585 col
= FRAME_LEFT_SCROLL_BAR_WIDTH (f
);
4588 /* Otherwise move it back in range. */
4590 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
4594 cursor_to (row
, col
);
4598 /* We have only one cursor on terminal frames. Use it to
4599 display the cursor of the selected window. */
4600 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
4601 if (w
->cursor
.vpos
>= 0)
4603 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
4604 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
4606 if (INTEGERP (w
->left_margin_width
))
4607 x
+= XFASTINT (w
->left_margin_width
);
4609 /* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
4618 fflush (termscript
);
4623 display_completed
= !pause
;
4624 clear_desired_matrices (f
);
4629 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4633 struct frame
*frame
;
4635 int unchanged_at_top
, unchanged_at_bottom
;
4638 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4639 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4640 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4641 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4643 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
4644 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4645 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4647 if (!current_matrix
)
4650 /* Compute hash codes of all the lines. Also calculate number of
4651 changed lines, number of unchanged lines at the beginning, and
4652 number of unchanged lines at the end. */
4654 unchanged_at_top
= 0;
4655 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
4656 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
4658 /* Give up on this scrolling if some old lines are not enabled. */
4659 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
4661 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
4662 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4664 /* This line cannot be redrawn, so don't let scrolling mess it. */
4665 new_hash
[i
] = old_hash
[i
];
4666 #define INFINITY 1000000 /* Taken from scroll.c */
4667 draw_cost
[i
] = INFINITY
;
4671 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
4672 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
4675 if (old_hash
[i
] != new_hash
[i
])
4678 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
4680 else if (i
== unchanged_at_top
)
4682 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
4685 /* If changed lines are few, don't allow preemption, don't scroll. */
4686 if ((!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400)
4687 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
4690 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
4691 - unchanged_at_bottom
);
4693 if (scroll_region_ok
)
4694 free_at_end_vpos
-= unchanged_at_bottom
;
4695 else if (memory_below_frame
)
4696 free_at_end_vpos
= -1;
4698 /* If large window, fast terminal and few lines in common between
4699 current frame and desired frame, don't bother with i/d calc. */
4700 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
4702 10 * scrolling_max_lines_saved (unchanged_at_top
,
4703 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
4704 old_hash
, new_hash
, draw_cost
)))
4707 if (window_size
< 2)
4710 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
4711 draw_cost
+ unchanged_at_top
- 1,
4712 old_draw_cost
+ unchanged_at_top
- 1,
4713 old_hash
+ unchanged_at_top
- 1,
4714 new_hash
+ unchanged_at_top
- 1,
4715 free_at_end_vpos
- unchanged_at_top
);
4721 /* Count the number of blanks at the start of the vector of glyphs R
4722 which is LEN glyphs long. */
4725 count_blanks (r
, len
)
4731 for (i
= 0; i
< len
; ++i
)
4732 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
4739 /* Count the number of glyphs in common at the start of the glyph
4740 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
4741 of STR2. Value is the number of equal glyphs equal at the start. */
4744 count_match (str1
, end1
, str2
, end2
)
4745 struct glyph
*str1
, *end1
, *str2
, *end2
;
4747 struct glyph
*p1
= str1
;
4748 struct glyph
*p2
= str2
;
4752 && GLYPH_FROM_CHAR_GLYPH (*p1
) == GLYPH_FROM_CHAR_GLYPH (*p2
))
4759 /* Char insertion/deletion cost vector, from term.c */
4761 extern int *char_ins_del_vector
;
4762 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
4765 /* Perform a frame-based update on line VPOS in frame FRAME. */
4768 update_frame_line (frame
, vpos
)
4769 register struct frame
*frame
;
4772 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
4774 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
4775 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4776 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4777 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
4778 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
4779 int must_write_whole_line_p
;
4781 if (desired_row
->inverse_p
4782 != (current_row
->enabled_p
&& current_row
->inverse_p
))
4784 int n
= current_row
->enabled_p
? current_row
->used
[TEXT_AREA
] : 0;
4785 change_line_highlight (desired_row
->inverse_p
, vpos
, vpos
, n
);
4786 current_row
->enabled_p
= 0;
4789 reassert_line_highlight (desired_row
->inverse_p
, vpos
);
4791 must_write_whole_line_p
= !current_row
->enabled_p
;
4792 if (must_write_whole_line_p
)
4794 /* A line that is not enabled is empty. */
4800 /* A line not empty in the current matrix. */
4801 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
4802 olen
= current_row
->used
[TEXT_AREA
];
4804 if (! current_row
->inverse_p
)
4806 /* Ignore trailing spaces. */
4807 if (!must_write_spaces
)
4808 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
4813 /* For an inverse-video line, remember we gave it spaces all
4814 the way to the frame edge so that the reverse video
4815 extends all the way across. */
4816 while (olen
< FRAME_WIDTH (frame
) - 1)
4817 obody
[olen
++] = space_glyph
;
4821 current_row
->enabled_p
= 1;
4822 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
4823 current_row
->inverse_p
= desired_row
->inverse_p
;
4825 /* If desired line is empty, just clear the line. */
4826 if (!desired_row
->enabled_p
)
4832 nbody
= desired_row
->glyphs
[TEXT_AREA
];
4833 nlen
= desired_row
->used
[TEXT_AREA
];
4834 nend
= nbody
+ nlen
;
4836 /* If display line has unknown contents, write the whole line. */
4837 if (must_write_whole_line_p
)
4839 cursor_to (vpos
, 0);
4840 write_glyphs (nbody
, nlen
);
4841 cursor_to (vpos
, nlen
);
4842 clear_end_of_line (-1);
4843 make_current (desired_matrix
, current_matrix
, vpos
);
4847 /* Pretend trailing spaces are not there at all,
4848 unless for one reason or another we must write all spaces. */
4849 if (!desired_row
->inverse_p
)
4851 if (!must_write_spaces
)
4852 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4857 /* For an inverse-video line, give it extra trailing spaces all
4858 the way to the frame edge so that the reverse video extends
4859 all the way across. */
4860 while (nlen
< FRAME_WIDTH (frame
) - 1)
4861 nbody
[nlen
++] = space_glyph
;
4864 /* If there's no i/d char, quickly do the best we can without it. */
4865 if (!char_ins_del_ok
)
4869 /* Find the first glyph in desired row that doesn't agree with
4870 a glyph in the current row, and write the rest from there on. */
4871 for (i
= 0; i
< nlen
; i
++)
4873 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
4875 /* Find the end of the run of different glyphs. */
4879 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
4880 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
4883 /* Output this run of non-matching chars. */
4884 cursor_to (vpos
, i
);
4885 write_glyphs (nbody
+ i
, j
- i
);
4888 /* Now find the next non-match. */
4892 /* Clear the rest of the line, or the non-clear part of it. */
4895 cursor_to (vpos
, nlen
);
4896 clear_end_of_line (olen
);
4899 /* Make current row = desired row. */
4900 make_current (desired_matrix
, current_matrix
, vpos
);
4904 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
4905 characters in a row. */
4909 /* If current line is blank, skip over initial spaces, if
4910 possible, and write the rest. */
4911 if (must_write_spaces
|| desired_row
->inverse_p
)
4914 nsp
= count_blanks (nbody
, nlen
);
4918 cursor_to (vpos
, nsp
);
4919 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
4922 /* Exchange contents between current_frame and new_frame. */
4923 make_current (desired_matrix
, current_matrix
, vpos
);
4927 /* Compute number of leading blanks in old and new contents. */
4928 osp
= count_blanks (obody
, olen
);
4929 nsp
= desired_row
->inverse_p
? 0 : count_blanks (nbody
, nlen
);
4931 /* Compute number of matching chars starting with first non-blank. */
4932 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
4933 nbody
+ nsp
, nbody
+ nlen
);
4935 /* Spaces in new match implicit space past the end of old. */
4936 /* A bug causing this to be a no-op was fixed in 18.29. */
4937 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
4940 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
4944 /* Avoid doing insert/delete char
4945 just cause number of leading spaces differs
4946 when the following text does not match. */
4947 if (begmatch
== 0 && osp
!= nsp
)
4948 osp
= nsp
= min (osp
, nsp
);
4950 /* Find matching characters at end of line */
4953 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
4955 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
4960 endmatch
= obody
+ olen
- op1
;
4962 /* tem gets the distance to insert or delete.
4963 endmatch is how many characters we save by doing so.
4966 tem
= (nlen
- nsp
) - (olen
- osp
);
4968 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
4971 /* nsp - osp is the distance to insert or delete.
4972 If that is nonzero, begmatch is known to be nonzero also.
4973 begmatch + endmatch is how much we save by doing the ins/del.
4977 && (!char_ins_del_ok
4978 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
4982 osp
= nsp
= min (osp
, nsp
);
4985 /* Now go through the line, inserting, writing and
4986 deleting as appropriate. */
4990 cursor_to (vpos
, nsp
);
4991 delete_glyphs (osp
- nsp
);
4995 /* If going to delete chars later in line
4996 and insert earlier in the line,
4997 must delete first to avoid losing data in the insert */
4998 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
5000 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
5001 delete_glyphs (olen
+ nsp
- osp
- nlen
);
5002 olen
= nlen
- (nsp
- osp
);
5004 cursor_to (vpos
, osp
);
5005 insert_glyphs (0, nsp
- osp
);
5009 tem
= nsp
+ begmatch
+ endmatch
;
5010 if (nlen
!= tem
|| olen
!= tem
)
5012 cursor_to (vpos
, nsp
+ begmatch
);
5013 if (!endmatch
|| nlen
== olen
)
5015 /* If new text being written reaches right margin,
5016 there is no need to do clear-to-eol at the end.
5017 (and it would not be safe, since cursor is not
5018 going to be "at the margin" after the text is done) */
5019 if (nlen
== FRAME_WINDOW_WIDTH (frame
))
5021 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5023 else if (nlen
> olen
)
5025 /* Here, we used to have the following simple code:
5026 ----------------------------------------
5027 write_glyphs (nbody + nsp + begmatch, olen - tem);
5028 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5029 ----------------------------------------
5030 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5031 is a padding glyph. */
5032 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5035 /* Calculate columns we can actually overwrite. */
5036 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
])) out
--;
5037 write_glyphs (nbody
+ nsp
+ begmatch
, out
);
5038 /* If we left columns to be overwritten, we must delete them. */
5039 del
= olen
- tem
- out
;
5040 if (del
> 0) delete_glyphs (del
);
5041 /* At last, we insert columns not yet written out. */
5042 insert_glyphs (nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5045 else if (olen
> nlen
)
5047 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5048 delete_glyphs (olen
- nlen
);
5054 /* If any unerased characters remain after the new line, erase them. */
5057 cursor_to (vpos
, nlen
);
5058 clear_end_of_line (olen
);
5061 /* Exchange contents between current_frame and new_frame. */
5062 make_current (desired_matrix
, current_matrix
, vpos
);
5067 /***********************************************************************
5068 X/Y Position -> Buffer Position
5069 ***********************************************************************/
5071 /* Return the character position of the character at window relative
5072 pixel position (*X, *Y). *X and *Y are adjusted to character
5076 buffer_posn_from_coords (w
, x
, y
)
5081 struct buffer
*old_current_buffer
= current_buffer
;
5082 struct text_pos startp
;
5083 int left_area_width
;
5085 current_buffer
= XBUFFER (w
->buffer
);
5086 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5087 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5088 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5089 start_display (&it
, w
, startp
);
5091 left_area_width
= WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH (w
);
5092 move_it_to (&it
, -1, *x
+ it
.first_visible_x
- left_area_width
, *y
, -1,
5093 MOVE_TO_X
| MOVE_TO_Y
);
5095 *x
= it
.current_x
- it
.first_visible_x
+ left_area_width
;
5097 current_buffer
= old_current_buffer
;
5098 return IT_CHARPOS (it
);
5102 /* Value is the string under window-relative coordinates X/Y in the
5103 mode or top line of window W, or nil if none. MODE_LINE_P non-zero
5104 means look at the mode line. *CHARPOS is set to the position in
5105 the string returned. */
5108 mode_line_string (w
, x
, y
, mode_line_p
, charpos
)
5113 struct glyph_row
*row
;
5114 struct glyph
*glyph
, *end
;
5115 struct frame
*f
= XFRAME (w
->frame
);
5117 Lisp_Object string
= Qnil
;
5119 /* Only do this for frames under a window system. */
5120 if (!FRAME_WINDOW_P (f
))
5124 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5126 row
= MATRIX_TOP_LINE_ROW (w
->current_matrix
);
5128 if (row
->mode_line_p
&& row
->enabled_p
)
5130 /* The mode lines are displayed over scroll bars and bitmap
5131 areas, and X is window-relative. Correct X by the scroll bar
5132 and bitmap area width. */
5133 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
5134 x
+= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
5135 x
+= FRAME_FLAGS_AREA_WIDTH (f
);
5137 /* Find the glyph under X. If we find one with a string object,
5138 it's the one we were looking for. */
5139 glyph
= row
->glyphs
[TEXT_AREA
];
5140 end
= glyph
+ row
->used
[TEXT_AREA
];
5141 for (x0
= 0; glyph
< end
; x0
+= glyph
->pixel_width
, ++glyph
)
5142 if (x
>= x0
&& x
< x0
+ glyph
->pixel_width
)
5144 string
= glyph
->object
;
5145 *charpos
= glyph
->charpos
;
5154 /***********************************************************************
5155 Changing Frame Sizes
5156 ***********************************************************************/
5161 window_change_signal (signalnum
) /* If we don't have an argument, */
5162 int signalnum
; /* some compilers complain in signal calls. */
5166 int old_errno
= errno
;
5168 get_frame_size (&width
, &height
);
5170 /* The frame size change obviously applies to a termcap-controlled
5171 frame. Find such a frame in the list, and assume it's the only
5172 one (since the redisplay code always writes to stdout, not a
5173 FILE * specified in the frame structure). Record the new size,
5174 but don't reallocate the data structures now. Let that be done
5175 later outside of the signal handler. */
5178 Lisp_Object tail
, frame
;
5180 FOR_EACH_FRAME (tail
, frame
)
5182 if (FRAME_TERMCAP_P (XFRAME (frame
)))
5184 change_frame_size (XFRAME (frame
), height
, width
, 0, 1);
5190 signal (SIGWINCH
, window_change_signal
);
5193 #endif /* SIGWINCH */
5196 /* Do any change in frame size that was requested by a signal. */
5199 do_pending_window_change ()
5201 /* If window_change_signal should have run before, run it now. */
5202 while (delayed_size_change
)
5204 Lisp_Object tail
, frame
;
5206 delayed_size_change
= 0;
5208 FOR_EACH_FRAME (tail
, frame
)
5210 struct frame
*f
= XFRAME (frame
);
5212 int height
= FRAME_NEW_HEIGHT (f
);
5213 int width
= FRAME_NEW_WIDTH (f
);
5215 if (height
!= 0 || width
!= 0)
5216 change_frame_size (f
, height
, width
, 0, 0);
5222 /* Change the frame height and/or width. Values may be given as zero to
5223 indicate no change is to take place.
5225 If DELAY is non-zero, then assume we're being called from a signal
5226 handler, and queue the change for later - perhaps the next
5227 redisplay. Since this tries to resize windows, we can't call it
5228 from a signal handler. */
5231 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
)
5232 register struct frame
*f
;
5233 int newheight
, newwidth
, pretend
, delay
;
5235 Lisp_Object tail
, frame
;
5237 if (! FRAME_WINDOW_P (f
))
5239 /* When using termcap, or on MS-DOS, all frames use
5240 the same screen, so a change in size affects all frames. */
5241 FOR_EACH_FRAME (tail
, frame
)
5242 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5243 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5247 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
);
5251 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
)
5252 register struct frame
*f
;
5253 int newheight
, newwidth
, pretend
, delay
;
5255 int new_frame_window_width
;
5256 unsigned int total_glyphs
;
5257 int count
= specpdl_ptr
- specpdl
;
5259 /* If we can't deal with the change now, queue it for later. */
5262 FRAME_NEW_HEIGHT (f
) = newheight
;
5263 FRAME_NEW_WIDTH (f
) = newwidth
;
5264 delayed_size_change
= 1;
5268 /* This size-change overrides any pending one for this frame. */
5269 FRAME_NEW_HEIGHT (f
) = 0;
5270 FRAME_NEW_WIDTH (f
) = 0;
5272 /* If an argument is zero, set it to the current value. */
5274 newheight
= FRAME_HEIGHT (f
);
5276 newwidth
= FRAME_WIDTH (f
);
5278 /* Compute width of windows in F.
5279 This is the width of the frame without vertical scroll bars. */
5280 new_frame_window_width
= FRAME_WINDOW_WIDTH_ARG (f
, newwidth
);
5282 /* Round up to the smallest acceptable size. */
5283 check_frame_size (f
, &newheight
, &newwidth
);
5285 /* If we're not changing the frame size, quit now. */
5286 if (newheight
== FRAME_HEIGHT (f
)
5287 && new_frame_window_width
== FRAME_WINDOW_WIDTH (f
))
5293 /* We only can set screen dimensions to certain values supported
5294 by our video hardware. Try to find the smallest size greater
5295 or equal to the requested dimensions. */
5296 dos_set_window_size (&newheight
, &newwidth
);
5299 if (newheight
!= FRAME_HEIGHT (f
))
5301 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
5303 /* Frame has both root and mini-buffer. */
5304 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f
))->top
,
5305 FRAME_TOP_MARGIN (f
));
5306 set_window_height (FRAME_ROOT_WINDOW (f
),
5309 - FRAME_TOP_MARGIN (f
)),
5311 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
,
5313 set_window_height (FRAME_MINIBUF_WINDOW (f
), 1, 0);
5316 /* Frame has just one top-level window. */
5317 set_window_height (FRAME_ROOT_WINDOW (f
),
5318 newheight
- FRAME_TOP_MARGIN (f
), 0);
5320 if (FRAME_TERMCAP_P (f
) && !pretend
)
5321 FrameRows
= newheight
;
5324 if (new_frame_window_width
!= FRAME_WINDOW_WIDTH (f
))
5326 set_window_width (FRAME_ROOT_WINDOW (f
), new_frame_window_width
, 0);
5327 if (FRAME_HAS_MINIBUF_P (f
))
5328 set_window_width (FRAME_MINIBUF_WINDOW (f
), new_frame_window_width
, 0);
5330 if (FRAME_TERMCAP_P (f
) && !pretend
)
5331 FrameCols
= newwidth
;
5333 if (WINDOWP (f
->toolbar_window
))
5334 XSETFASTINT (XWINDOW (f
->toolbar_window
)->width
, newwidth
);
5337 FRAME_HEIGHT (f
) = newheight
;
5338 SET_FRAME_WIDTH (f
, newwidth
);
5341 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5342 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
5344 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
5346 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
5347 w
->cursor
.hpos
= w
->cursor
.x
= 0;
5348 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
5349 w
->cursor
.vpos
= w
->cursor
.y
= 0;
5353 SET_FRAME_GARBAGED (f
);
5354 calculate_costs (f
);
5358 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
5360 /* This isn't quite a no-op: it runs window-configuration-change-hook. */
5361 Fset_window_buffer (FRAME_SELECTED_WINDOW (f
),
5362 XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
);
5364 unbind_to (count
, Qnil
);
5369 /***********************************************************************
5370 Terminal Related Lisp Functions
5371 ***********************************************************************/
5373 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
5374 1, 1, "FOpen termscript file: ",
5375 "Start writing all terminal output to FILE as well as the terminal.\n\
5376 FILE = nil means just close any termscript file currently open.")
5380 if (termscript
!= 0) fclose (termscript
);
5385 file
= Fexpand_file_name (file
, Qnil
);
5386 termscript
= fopen (XSTRING (file
)->data
, "w");
5387 if (termscript
== 0)
5388 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
5394 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
5395 Ssend_string_to_terminal
, 1, 1, 0,
5396 "Send STRING to the terminal without alteration.\n\
5397 Control characters in STRING will have terminal-dependent effects.")
5401 /* ??? Perhaps we should do something special for multibyte strings here. */
5402 CHECK_STRING (string
, 0);
5403 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)), stdout
);
5407 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)),
5409 fflush (termscript
);
5415 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
5416 "Beep, or flash the screen.\n\
5417 Also, unless an argument is given,\n\
5418 terminate any keyboard macro currently executing.")
5441 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
5442 error ("Keyboard macro terminated by a command ringing the bell");
5450 /***********************************************************************
5452 ***********************************************************************/
5454 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
5455 "Pause, without updating display, for SECONDS seconds.\n\
5456 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5457 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5458 additional wait period, in milliseconds; this may be useful if your\n\
5459 Emacs was built without floating point support.\n\
5460 \(Not all operating systems support waiting for a fraction of a second.)")
5461 (seconds
, milliseconds
)
5462 Lisp_Object seconds
, milliseconds
;
5466 if (NILP (milliseconds
))
5467 XSETINT (milliseconds
, 0);
5469 CHECK_NUMBER (milliseconds
, 1);
5470 usec
= XINT (milliseconds
) * 1000;
5472 #ifdef LISP_FLOAT_TYPE
5474 double duration
= extract_float (seconds
);
5475 sec
= (int) duration
;
5476 usec
+= (duration
- sec
) * 1000000;
5479 CHECK_NUMBER (seconds
, 0);
5480 sec
= XINT (seconds
);
5483 #ifndef EMACS_HAS_USECS
5484 if (sec
== 0 && usec
!= 0)
5485 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
5488 /* Assure that 0 <= usec < 1000000. */
5491 /* We can't rely on the rounding being correct if user is negative. */
5492 if (-1000000 < usec
)
5493 sec
--, usec
+= 1000000;
5495 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
5498 sec
+= usec
/ 1000000, usec
%= 1000000;
5500 if (sec
< 0 || (sec
== 0 && usec
== 0))
5506 XSETFASTINT (zero
, 0);
5507 wait_reading_process_input (sec
, usec
, zero
, 0);
5510 /* We should always have wait_reading_process_input; we have a dummy
5511 implementation for systems which don't support subprocesses. */
5513 /* No wait_reading_process_input */
5520 /* The reason this is done this way
5521 (rather than defined (H_S) && defined (H_T))
5522 is because the VMS preprocessor doesn't grok `defined' */
5524 EMACS_GET_TIME (end_time
);
5525 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
5526 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
5530 EMACS_GET_TIME (timeout
);
5531 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
5532 if (EMACS_TIME_NEG_P (timeout
)
5533 || !select (1, 0, 0, 0, &timeout
))
5536 #else /* not HAVE_SELECT */
5538 #endif /* HAVE_SELECT */
5539 #endif /* not VMS */
5542 #endif /* no subprocesses */
5548 /* This is just like wait_reading_process_input, except that
5549 it does the redisplay.
5551 It's also much like Fsit_for, except that it can be used for
5552 waiting for input as well. */
5555 sit_for (sec
, usec
, reading
, display
, initial_display
)
5556 int sec
, usec
, reading
, display
, initial_display
;
5558 Lisp_Object read_kbd
;
5560 swallow_events (display
);
5562 if (detect_input_pending_run_timers (display
))
5565 if (initial_display
)
5566 redisplay_preserve_echo_area ();
5568 if (sec
== 0 && usec
== 0)
5575 XSETINT (read_kbd
, reading
? -1 : 1);
5576 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
5578 return detect_input_pending () ? Qnil
: Qt
;
5582 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
5583 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
5584 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5585 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5586 additional wait period, in milliseconds; this may be useful if your\n\
5587 Emacs was built without floating point support.\n\
5588 \(Not all operating systems support waiting for a fraction of a second.)\n\
5589 Optional third arg NODISP non-nil means don't redisplay, just wait for input.\n\
5590 Redisplay is preempted as always if input arrives, and does not happen\n\
5591 if input is available before it starts.\n\
5592 Value is t if waited the full time with no input arriving.")
5593 (seconds
, milliseconds
, nodisp
)
5594 Lisp_Object seconds
, milliseconds
, nodisp
;
5598 if (NILP (milliseconds
))
5599 XSETINT (milliseconds
, 0);
5601 CHECK_NUMBER (milliseconds
, 1);
5602 usec
= XINT (milliseconds
) * 1000;
5604 #ifdef LISP_FLOAT_TYPE
5606 double duration
= extract_float (seconds
);
5607 sec
= (int) duration
;
5608 usec
+= (duration
- sec
) * 1000000;
5611 CHECK_NUMBER (seconds
, 0);
5612 sec
= XINT (seconds
);
5615 #ifndef EMACS_HAS_USECS
5616 if (usec
!= 0 && sec
== 0)
5617 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
5620 return sit_for (sec
, usec
, 0, NILP (nodisp
), NILP (nodisp
));
5625 /***********************************************************************
5626 Other Lisp Functions
5627 ***********************************************************************/
5629 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
5630 session's frames, frame names, buffers, buffer-read-only flags, and
5631 buffer-modified-flags, and a trailing sentinel (so we don't need to
5632 add length checks). */
5634 static Lisp_Object frame_and_buffer_state
;
5637 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
5638 Sframe_or_buffer_changed_p
, 0, 0, 0,
5639 "Return non-nil if the frame and buffer state appears to have changed.\n\
5640 The state variable is an internal vector containing all frames and buffers,\n\
5641 aside from buffers whose names start with space,\n\
5642 along with the buffers' read-only and modified flags, which allows a fast\n\
5643 check to see whether the menu bars might need to be recomputed.\n\
5644 If this function returns non-nil, it updates the internal vector to reflect\n\
5645 the current state.\n")
5648 Lisp_Object tail
, frame
, buf
;
5652 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5653 FOR_EACH_FRAME (tail
, frame
)
5655 if (!EQ (*vecp
++, frame
))
5657 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
5660 /* Check that the buffer info matches.
5661 No need to test for the end of the vector
5662 because the last element of the vector is lambda
5663 and that will always cause a mismatch. */
5664 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5666 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
5667 /* Ignore buffers that aren't included in buffer lists. */
5668 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5670 if (!EQ (*vecp
++, buf
))
5672 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
5674 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
5677 /* Detect deletion of a buffer at the end of the list. */
5678 if (EQ (*vecp
, Qlambda
))
5681 /* Start with 1 so there is room for at least one lambda at the end. */
5683 FOR_EACH_FRAME (tail
, frame
)
5685 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5687 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
5688 if (n
> XVECTOR (frame_and_buffer_state
)->size
5689 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
5690 /* Add 20 extra so we grow it less often. */
5691 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
5692 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5693 FOR_EACH_FRAME (tail
, frame
)
5696 *vecp
++ = XFRAME (frame
)->name
;
5698 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5700 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
5701 /* Ignore buffers that aren't included in buffer lists. */
5702 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5705 *vecp
++ = XBUFFER (buf
)->read_only
;
5706 *vecp
++ = Fbuffer_modified_p (buf
);
5708 /* Fill up the vector with lambdas (always at least one). */
5710 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5711 < XVECTOR (frame_and_buffer_state
)->size
)
5713 /* Make sure we didn't overflow the vector. */
5714 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5715 > XVECTOR (frame_and_buffer_state
)->size
)
5722 /***********************************************************************
5724 ***********************************************************************/
5726 char *terminal_type
;
5728 /* Initialization done when Emacs fork is started, before doing stty.
5729 Determine terminal type and set terminal_driver. Then invoke its
5730 decoding routine to set up variables in the terminal package. */
5735 #ifdef HAVE_X_WINDOWS
5736 extern int display_arg
;
5739 /* Construct the space glyph. */
5740 space_glyph
.type
= CHAR_GLYPH
;
5741 SET_CHAR_GLYPH_FROM_GLYPH (space_glyph
, ' ');
5742 space_glyph
.charpos
= -1;
5746 cursor_in_echo_area
= 0;
5747 terminal_type
= (char *) 0;
5749 /* Now is the time to initialize this; it's used by init_sys_modes
5751 Vwindow_system
= Qnil
;
5753 /* If the user wants to use a window system, we shouldn't bother
5754 initializing the terminal. This is especially important when the
5755 terminal is so dumb that emacs gives up before and doesn't bother
5756 using the window system.
5758 If the DISPLAY environment variable is set and nonempty,
5759 try to use X, and die with an error message if that doesn't work. */
5761 #ifdef HAVE_X_WINDOWS
5766 display
= getenv ("DECW$DISPLAY");
5768 display
= getenv ("DISPLAY");
5771 display_arg
= (display
!= 0 && *display
!= 0);
5774 if (!inhibit_window_system
&& display_arg
5780 Vwindow_system
= intern ("x");
5782 Vwindow_system_version
= make_number (11);
5784 Vwindow_system_version
= make_number (10);
5786 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
5787 /* In some versions of ncurses,
5788 tputs crashes if we have not called tgetent.
5790 { char b
[2044]; tgetent (b
, "xterm");}
5792 adjust_frame_glyphs_initially ();
5795 #endif /* HAVE_X_WINDOWS */
5798 if (!inhibit_window_system
)
5800 Vwindow_system
= intern ("w32");
5801 Vwindow_system_version
= make_number (1);
5802 adjust_frame_glyphs_initially ();
5805 #endif /* HAVE_NTGUI */
5807 /* If no window system has been specified, try to use the terminal. */
5810 fatal ("standard input is not a tty");
5814 /* Look at the TERM variable */
5815 terminal_type
= (char *) getenv ("TERM");
5819 fprintf (stderr
, "Please specify your terminal type.\n\
5820 For types defined in VMS, use set term /device=TYPE.\n\
5821 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
5822 \(The quotation marks are necessary since terminal types are lower case.)\n");
5824 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
5830 /* VMS DCL tends to up-case things, so down-case term type.
5831 Hardly any uppercase letters in terminal types; should be none. */
5833 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
5836 strcpy (new, terminal_type
);
5838 for (p
= new; *p
; p
++)
5842 terminal_type
= new;
5846 term_init (terminal_type
);
5849 int width
= FRAME_WINDOW_WIDTH (selected_frame
);
5850 int height
= FRAME_HEIGHT (selected_frame
);
5852 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (struct glyph
);
5854 /* If these sizes are so big they cause overflow, just ignore the
5855 change. It's not clear what better we could do. */
5856 if (total_glyphs
/ sizeof (struct glyph
) / height
!= width
+ 2)
5857 fatal ("screen size %dx%d too big", width
, height
);
5860 adjust_frame_glyphs_initially ();
5861 calculate_costs (selected_frame
);
5866 #endif /* CANNOT_DUMP */
5867 signal (SIGWINCH
, window_change_signal
);
5868 #endif /* SIGWINCH */
5870 /* Set up faces of the initial terminal frame of a dumped Emacs. */
5874 /* The MSDOS terminal turns on its ``window system'' relatively
5875 late into the startup, so we cannot do the frame faces'
5876 initialization just yet. It will be done later by pc-win.el
5877 and internal_terminal_init. */
5878 && (strcmp (terminal_type
, "internal") != 0 || inhibit_window_system
)
5880 && NILP (Vwindow_system
))
5881 call0 (intern ("tty-set-up-initial-frame-faces"));
5886 /***********************************************************************
5888 ***********************************************************************/
5890 DEFUN ("show-cursor", Fshow_cursor
, Sshow_cursor
, 0, 2, 0,
5891 "Change visibility flag of the text cursor of WINDOW.\n\
5892 ON_P nil means toggle the flag. Otherwise, ON_P must be an integer,\n\
5893 and the flag is set according to the value of ON_P. WINDOW nil or\n\
5894 omitted means use the selected window. The new cursor state takes effect\n\
5895 with the next redisplay.")
5897 Lisp_Object on_p
, window
;
5901 /* Don't change cursor state while redisplaying. This could confuse
5903 if (!redisplaying_p
)
5906 window
= selected_window
;
5908 CHECK_WINDOW (window
, 2);
5909 w
= XWINDOW (window
);
5912 w
->cursor_off_p
= !w
->cursor_off_p
;
5915 CHECK_NUMBER (on_p
, 1);
5916 w
->cursor_off_p
= XINT (on_p
) != 0;
5925 /***********************************************************************
5927 ***********************************************************************/
5932 defsubr (&Sredraw_frame
);
5933 defsubr (&Sredraw_display
);
5934 defsubr (&Sframe_or_buffer_changed_p
);
5935 defsubr (&Sopen_termscript
);
5937 defsubr (&Ssit_for
);
5938 defsubr (&Ssleep_for
);
5939 defsubr (&Ssend_string_to_terminal
);
5940 defsubr (&Sshow_cursor
);
5942 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
5943 staticpro (&frame_and_buffer_state
);
5945 Qdisplay_table
= intern ("display-table");
5946 staticpro (&Qdisplay_table
);
5948 DEFVAR_INT ("baud-rate", &baud_rate
,
5949 "*The output baud rate of the terminal.\n\
5950 On most systems, changing this value will affect the amount of padding\n\
5951 and the other strategic decisions made during redisplay.");
5953 DEFVAR_BOOL ("inverse-video", &inverse_video
,
5954 "*Non-nil means invert the entire frame display.\n\
5955 This means everything is in inverse video which otherwise would not be.");
5957 DEFVAR_BOOL ("visible-bell", &visible_bell
,
5958 "*Non-nil means try to flash the frame to represent a bell.");
5960 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
5961 "*Non-nil means no need to redraw entire frame after suspending.\n\
5962 A non-nil value is useful if the terminal can automatically preserve\n\
5963 Emacs's frame display when you reenter Emacs.\n\
5964 It is up to you to set this variable if your terminal can do that.");
5966 DEFVAR_LISP ("window-system", &Vwindow_system
,
5967 "A symbol naming the window-system under which Emacs is running\n\
5968 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
5970 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
5971 "The version number of the window system in use.\n\
5972 For X windows, this is 10 or 11.");
5974 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
5975 "Non-nil means put cursor in minibuffer, at end of any message there.");
5977 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
5978 "Table defining how to output a glyph code to the frame.\n\
5979 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
5980 Each element can be:\n\
5981 integer: a glyph code which this glyph is an alias for.\n\
5982 string: output this glyph using that string (not impl. in X windows).\n\
5983 nil: this glyph mod 256 is char code to output,\n\
5984 and this glyph / 256 is face code for X windows (see `face-id').");
5985 Vglyph_table
= Qnil
;
5987 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
5988 "Display table to use for buffers that specify none.\n\
5989 See `buffer-display-table' for more information.");
5990 Vstandard_display_table
= Qnil
;
5992 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause
,
5993 "*Non-nil means update isn't paused when input is detected.");
5994 redisplay_dont_pause
= 0;
5996 /* Initialize `window-system', unless init_display already decided it. */
6001 Vwindow_system
= Qnil
;
6002 Vwindow_system_version
= Qnil
;