1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985,86,87,88,93,94,95,97,98,1999,2000,01,02,2003
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. */
32 #include "systty.h" /* For emacs_tty in termchar.h */
35 #include "termhooks.h"
36 /* cm.h must come after dispextern.h on Windows. */
37 #include "dispextern.h"
47 #include "intervals.h"
48 #include "blockinput.h"
51 /* I don't know why DEC Alpha OSF1 fail to compile this file if we
52 include the following file. */
53 /* #include "systty.h" */
54 #include "syssignal.h"
58 #endif /* HAVE_X_WINDOWS */
62 #endif /* HAVE_NTGUI */
68 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
73 /* To get the prototype for `sleep'. */
79 /* Get number of chars of output now in the buffer of a stdio stream.
80 This ought to be built in in stdio, but it isn't. Some s- files
81 override this because their stdio internals differ. */
83 #ifdef __GNU_LIBRARY__
85 /* The s- file might have overridden the definition with one that
86 works for the system's C library. But we are using the GNU C
87 library, so this is the right definition for every system. */
89 #ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT
90 #define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT
92 #undef PENDING_OUTPUT_COUNT
93 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
95 #else /* not __GNU_LIBRARY__ */
96 #if !defined (PENDING_OUTPUT_COUNT) && HAVE_STDIO_EXT_H && HAVE___FPENDING
97 #include <stdio_ext.h>
98 #define PENDING_OUTPUT_COUNT(FILE) __fpending (FILE)
100 #ifndef PENDING_OUTPUT_COUNT
101 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
103 #endif /* not __GNU_LIBRARY__ */
105 #if defined(HAVE_TERM_H) && defined (GNU_LINUX) && defined (HAVE_LIBNCURSES)
106 #include <term.h> /* for tgetent */
109 /* Structure to pass dimensions around. Used for character bounding
110 boxes, glyph matrix dimensions and alike. */
119 /* Function prototypes. */
121 static struct glyph_matrix
*save_current_matrix
P_ ((struct frame
*));
122 static void restore_current_matrix
P_ ((struct frame
*, struct glyph_matrix
*));
123 static void fake_current_matrices
P_ ((Lisp_Object
));
124 static void redraw_overlapping_rows
P_ ((struct window
*, int));
125 static void redraw_overlapped_rows
P_ ((struct window
*, int));
126 static int count_blanks
P_ ((struct glyph
*, int));
127 static int count_match
P_ ((struct glyph
*, struct glyph
*,
128 struct glyph
*, struct glyph
*));
129 static unsigned line_draw_cost
P_ ((struct glyph_matrix
*, int));
130 static void update_frame_line
P_ ((struct frame
*, int));
131 static struct dim allocate_matrices_for_frame_redisplay
132 P_ ((Lisp_Object
, int, int, int, int *));
133 static void allocate_matrices_for_window_redisplay
P_ ((struct window
*));
134 static int realloc_glyph_pool
P_ ((struct glyph_pool
*, struct dim
));
135 static void adjust_frame_glyphs
P_ ((struct frame
*));
136 struct glyph_matrix
*new_glyph_matrix
P_ ((struct glyph_pool
*));
137 static void free_glyph_matrix
P_ ((struct glyph_matrix
*));
138 static void adjust_glyph_matrix
P_ ((struct window
*, struct glyph_matrix
*,
139 int, int, struct dim
));
140 static void change_frame_size_1
P_ ((struct frame
*, int, int, int, int, int));
141 static void swap_glyph_pointers
P_ ((struct glyph_row
*, struct glyph_row
*));
143 static int glyph_row_slice_p
P_ ((struct glyph_row
*, struct glyph_row
*));
145 static void fill_up_frame_row_with_spaces
P_ ((struct glyph_row
*, int));
146 static void build_frame_matrix_from_window_tree
P_ ((struct glyph_matrix
*,
148 static void build_frame_matrix_from_leaf_window
P_ ((struct glyph_matrix
*,
150 static struct glyph_pool
*new_glyph_pool
P_ ((void));
151 static void free_glyph_pool
P_ ((struct glyph_pool
*));
152 static void adjust_frame_glyphs_initially
P_ ((void));
153 static void adjust_frame_message_buffer
P_ ((struct frame
*));
154 static void adjust_decode_mode_spec_buffer
P_ ((struct frame
*));
155 static void fill_up_glyph_row_with_spaces
P_ ((struct glyph_row
*));
156 static void build_frame_matrix
P_ ((struct frame
*));
157 void clear_current_matrices
P_ ((struct frame
*));
158 void scroll_glyph_matrix_range
P_ ((struct glyph_matrix
*, int, int,
160 static void clear_window_matrices
P_ ((struct window
*, int));
161 static void fill_up_glyph_row_area_with_spaces
P_ ((struct glyph_row
*, int));
162 static int scrolling_window
P_ ((struct window
*, int));
163 static int update_window_line
P_ ((struct window
*, int, int *));
164 static void update_marginal_area
P_ ((struct window
*, int, int));
165 static int update_text_area
P_ ((struct window
*, int));
166 static void make_current
P_ ((struct glyph_matrix
*, struct glyph_matrix
*,
168 static void mirror_make_current
P_ ((struct window
*, int));
169 void check_window_matrix_pointers
P_ ((struct window
*));
171 static void check_matrix_pointers
P_ ((struct glyph_matrix
*,
172 struct glyph_matrix
*));
174 static void mirror_line_dance
P_ ((struct window
*, int, int, int *, char *));
175 static int update_window_tree
P_ ((struct window
*, int));
176 static int update_window
P_ ((struct window
*, int));
177 static int update_frame_1
P_ ((struct frame
*, int, int));
178 static void set_window_cursor_after_update
P_ ((struct window
*));
179 static int row_equal_p
P_ ((struct window
*, struct glyph_row
*,
180 struct glyph_row
*, int));
181 static void adjust_frame_glyphs_for_window_redisplay
P_ ((struct frame
*));
182 static void adjust_frame_glyphs_for_frame_redisplay
P_ ((struct frame
*));
183 static void reverse_rows
P_ ((struct glyph_matrix
*, int, int));
184 static int margin_glyphs_to_reserve
P_ ((struct window
*, int, Lisp_Object
));
185 static void sync_window_with_frame_matrix_rows
P_ ((struct window
*));
186 struct window
*frame_row_to_window
P_ ((struct window
*, int));
189 /* Non-zero means don't pause redisplay for pending input. (This is
190 for debugging and for a future implementation of EDT-like
193 int redisplay_dont_pause
;
195 /* Nonzero upon entry to redisplay means do not assume anything about
196 current contents of actual terminal frame; clear and redraw it. */
200 /* Nonzero means last display completed. Zero means it was preempted. */
202 int display_completed
;
204 /* Lisp variable visible-bell; enables use of screen-flash instead of
209 /* Invert the color of the whole frame, at a low level. */
213 /* Line speed of the terminal. */
217 /* Either nil or a symbol naming the window system under which Emacs
220 Lisp_Object Vwindow_system
;
222 /* Version number of X windows: 10, 11 or nil. */
224 Lisp_Object Vwindow_system_version
;
226 /* Vector of glyph definitions. Indexed by glyph number, the contents
227 are a string which is how to output the glyph.
229 If Vglyph_table is nil, a glyph is output by using its low 8 bits
232 This is an obsolete feature that is no longer used. The variable
233 is retained for compatibility. */
235 Lisp_Object Vglyph_table
;
237 /* Display table to use for vectors that don't specify their own. */
239 Lisp_Object Vstandard_display_table
;
241 /* Nonzero means reading single-character input with prompt so put
242 cursor on mini-buffer after the prompt. Positive means at end of
243 text in echo area; negative means at beginning of line. */
245 int cursor_in_echo_area
;
247 Lisp_Object Qdisplay_table
, Qredisplay_dont_pause
;
250 /* The currently selected frame. In a single-frame version, this
251 variable always equals the_only_frame. */
253 Lisp_Object selected_frame
;
255 /* A frame which is not just a mini-buffer, or 0 if there are no such
256 frames. This is usually the most recent such frame that was
257 selected. In a single-frame version, this variable always holds
258 the address of the_only_frame. */
260 struct frame
*last_nonminibuf_frame
;
262 /* 1 means SIGWINCH happened when not safe. */
264 int delayed_size_change
;
266 /* 1 means glyph initialization has been completed at startup. */
268 static int glyphs_initialized_initially_p
;
270 /* Updated window if != 0. Set by update_window. */
272 struct window
*updated_window
;
274 /* Glyph row updated in update_window_line, and area that is updated. */
276 struct glyph_row
*updated_row
;
279 /* A glyph for a space. */
281 struct glyph space_glyph
;
283 /* Non-zero means update has been performed directly, so that there's
284 no need for redisplay_internal to do much work. Set by
285 direct_output_for_insert. */
287 int redisplay_performed_directly_p
;
289 /* Counts of allocated structures. These counts serve to diagnose
290 memory leaks and double frees. */
292 int glyph_matrix_count
;
293 int glyph_pool_count
;
295 /* If non-null, the frame whose frame matrices are manipulated. If
296 null, window matrices are worked on. */
298 static struct frame
*frame_matrix_frame
;
300 /* Current interface for window-based redisplay. Set from init_xterm.
301 A null value means we are not using window-based redisplay. */
303 struct redisplay_interface
*rif
;
305 /* Non-zero means that fonts have been loaded since the last glyph
306 matrix adjustments. Redisplay must stop, and glyph matrices must
307 be adjusted when this flag becomes non-zero during display. The
308 reason fonts can be loaded so late is that fonts of fontsets are
313 /* Convert vpos and hpos from frame to window and vice versa.
314 This may only be used for terminal frames. */
318 static int window_to_frame_vpos
P_ ((struct window
*, int));
319 static int window_to_frame_hpos
P_ ((struct window
*, int));
320 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
321 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
323 /* One element of the ring buffer containing redisplay history
326 struct redisplay_history
328 char trace
[512 + 100];
331 /* The size of the history buffer. */
333 #define REDISPLAY_HISTORY_SIZE 30
335 /* The redisplay history buffer. */
337 static struct redisplay_history redisplay_history
[REDISPLAY_HISTORY_SIZE
];
339 /* Next free entry in redisplay_history. */
341 static int history_idx
;
343 /* A tick that's incremented each time something is added to the
346 static unsigned history_tick
;
348 static void add_frame_display_history
P_ ((struct frame
*, int));
349 static void add_window_display_history
P_ ((struct window
*, char *, int));
352 /* Add to the redisplay history how window W has been displayed.
353 MSG is a trace containing the information how W's glyph matrix
354 has been constructed. PAUSED_P non-zero means that the update
355 has been interrupted for pending input. */
358 add_window_display_history (w
, msg
, paused_p
)
365 if (history_idx
>= REDISPLAY_HISTORY_SIZE
)
367 buf
= redisplay_history
[history_idx
].trace
;
370 sprintf (buf
, "%d: window %p (`%s')%s\n",
373 ((BUFFERP (w
->buffer
)
374 && STRINGP (XBUFFER (w
->buffer
)->name
))
375 ? (char *) SDATA (XBUFFER (w
->buffer
)->name
)
377 paused_p
? " ***paused***" : "");
382 /* Add to the redisplay history that frame F has been displayed.
383 PAUSED_P non-zero means that the update has been interrupted for
387 add_frame_display_history (f
, paused_p
)
393 if (history_idx
>= REDISPLAY_HISTORY_SIZE
)
395 buf
= redisplay_history
[history_idx
].trace
;
398 sprintf (buf
, "%d: update frame %p%s",
400 f
, paused_p
? " ***paused***" : "");
404 DEFUN ("dump-redisplay-history", Fdump_redisplay_history
,
405 Sdump_redisplay_history
, 0, 0, "",
406 doc
: /* Dump redisplay history to stderr. */)
411 for (i
= history_idx
- 1; i
!= history_idx
; --i
)
414 i
= REDISPLAY_HISTORY_SIZE
- 1;
415 fprintf (stderr
, "%s\n", redisplay_history
[i
].trace
);
422 #else /* GLYPH_DEBUG == 0 */
424 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + WINDOW_TOP_EDGE_LINE (W))
425 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + WINDOW_LEFT_EDGE_COL (W))
427 #endif /* GLYPH_DEBUG == 0 */
430 /* Like bcopy except never gets confused by overlap. Let this be the
431 first function defined in this file, or change emacs.c where the
432 address of this function is used. */
435 safe_bcopy (from
, to
, size
)
440 if (size
<= 0 || from
== to
)
443 /* If the source and destination don't overlap, then bcopy can
444 handle it. If they do overlap, but the destination is lower in
445 memory than the source, we'll assume bcopy can handle that. */
446 if (to
< from
|| from
+ size
<= to
)
447 bcopy (from
, to
, size
);
449 /* Otherwise, we'll copy from the end. */
452 register const char *endf
= from
+ size
;
453 register char *endt
= to
+ size
;
455 /* If TO - FROM is large, then we should break the copy into
456 nonoverlapping chunks of TO - FROM bytes each. However, if
457 TO - FROM is small, then the bcopy function call overhead
458 makes this not worth it. The crossover point could be about
459 anywhere. Since I don't think the obvious copy loop is too
460 bad, I'm trying to err in its favor. */
465 while (endf
!= from
);
477 bcopy (endf
, endt
, to
- from
);
480 /* If SIZE wasn't a multiple of TO - FROM, there will be a
481 little left over. The amount left over is (endt + (to -
482 from)) - to, which is endt - from. */
483 bcopy (from
, to
, endt
- from
);
490 /***********************************************************************
492 ***********************************************************************/
494 /* Allocate and return a glyph_matrix structure. POOL is the glyph
495 pool from which memory for the matrix should be allocated, or null
496 for window-based redisplay where no glyph pools are used. The
497 member `pool' of the glyph matrix structure returned is set to
498 POOL, the structure is otherwise zeroed. */
500 struct glyph_matrix
*
501 new_glyph_matrix (pool
)
502 struct glyph_pool
*pool
;
504 struct glyph_matrix
*result
;
506 /* Allocate and clear. */
507 result
= (struct glyph_matrix
*) xmalloc (sizeof *result
);
508 bzero (result
, sizeof *result
);
510 /* Increment number of allocated matrices. This count is used
511 to detect memory leaks. */
512 ++glyph_matrix_count
;
514 /* Set pool and return. */
520 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
522 The global counter glyph_matrix_count is decremented when a matrix
523 is freed. If the count gets negative, more structures were freed
524 than allocated, i.e. one matrix was freed more than once or a bogus
525 pointer was passed to this function.
527 If MATRIX->pool is null, this means that the matrix manages its own
528 glyph memory---this is done for matrices on X frames. Freeing the
529 matrix also frees the glyph memory in this case. */
532 free_glyph_matrix (matrix
)
533 struct glyph_matrix
*matrix
;
539 /* Detect the case that more matrices are freed than were
541 if (--glyph_matrix_count
< 0)
544 /* Free glyph memory if MATRIX owns it. */
545 if (matrix
->pool
== NULL
)
546 for (i
= 0; i
< matrix
->rows_allocated
; ++i
)
547 xfree (matrix
->rows
[i
].glyphs
[LEFT_MARGIN_AREA
]);
549 /* Free row structures and the matrix itself. */
550 xfree (matrix
->rows
);
556 /* Return the number of glyphs to reserve for a marginal area of
557 window W. TOTAL_GLYPHS is the number of glyphs in a complete
558 display line of window W. MARGIN gives the width of the marginal
559 area in canonical character units. MARGIN should be an integer
563 margin_glyphs_to_reserve (w
, total_glyphs
, margin
)
570 if (NUMBERP (margin
))
572 int width
= XFASTINT (w
->total_cols
);
573 double d
= max (0, XFLOATINT (margin
));
574 d
= min (width
/ 2 - 1, d
);
575 n
= (int) ((double) total_glyphs
/ width
* d
);
584 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
587 W is null if the function is called for a frame glyph matrix.
588 Otherwise it is the window MATRIX is a member of. X and Y are the
589 indices of the first column and row of MATRIX within the frame
590 matrix, if such a matrix exists. They are zero for purely
591 window-based redisplay. DIM is the needed size of the matrix.
593 In window-based redisplay, where no frame matrices exist, glyph
594 matrices manage their own glyph storage. Otherwise, they allocate
595 storage from a common frame glyph pool which can be found in
598 The reason for this memory management strategy is to avoid complete
599 frame redraws if possible. When we allocate from a common pool, a
600 change of the location or size of a sub-matrix within the pool
601 requires a complete redisplay of the frame because we cannot easily
602 make sure that the current matrices of all windows still agree with
603 what is displayed on the screen. While this is usually fast, it
604 leads to screen flickering. */
607 adjust_glyph_matrix (w
, matrix
, x
, y
, dim
)
609 struct glyph_matrix
*matrix
;
615 int marginal_areas_changed_p
= 0;
616 int header_line_changed_p
= 0;
617 int header_line_p
= 0;
618 int left
= -1, right
= -1;
619 int window_width
= -1, window_height
;
621 /* See if W had a header line that has disappeared now, or vice versa.
625 window_box (w
, -1, 0, 0, &window_width
, &window_height
);
627 header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
628 header_line_changed_p
= header_line_p
!= matrix
->header_line_p
;
630 matrix
->header_line_p
= header_line_p
;
632 /* If POOL is null, MATRIX is a window matrix for window-based redisplay.
633 Do nothing if MATRIX' size, position, vscroll, and marginal areas
634 haven't changed. This optimization is important because preserving
635 the matrix means preventing redisplay. */
636 if (matrix
->pool
== NULL
)
638 left
= margin_glyphs_to_reserve (w
, dim
.width
, w
->left_margin_cols
);
639 right
= margin_glyphs_to_reserve (w
, dim
.width
, w
->right_margin_cols
);
640 xassert (left
>= 0 && right
>= 0);
641 marginal_areas_changed_p
= (left
!= matrix
->left_margin_glyphs
642 || right
!= matrix
->right_margin_glyphs
);
644 if (!marginal_areas_changed_p
646 && !header_line_changed_p
647 && matrix
->window_left_col
== WINDOW_LEFT_EDGE_COL (w
)
648 && matrix
->window_top_line
== WINDOW_TOP_EDGE_LINE (w
)
649 && matrix
->window_height
== window_height
650 && matrix
->window_vscroll
== w
->vscroll
651 && matrix
->window_width
== window_width
)
655 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
656 if (matrix
->rows_allocated
< dim
.height
)
658 int size
= dim
.height
* sizeof (struct glyph_row
);
659 new_rows
= dim
.height
- matrix
->rows_allocated
;
660 matrix
->rows
= (struct glyph_row
*) xrealloc (matrix
->rows
, size
);
661 bzero (matrix
->rows
+ matrix
->rows_allocated
,
662 new_rows
* sizeof *matrix
->rows
);
663 matrix
->rows_allocated
= dim
.height
;
668 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
669 on a frame not using window-based redisplay. Set up pointers for
670 each row into the glyph pool. */
673 xassert (matrix
->pool
->glyphs
);
677 left
= margin_glyphs_to_reserve (w
, dim
.width
,
678 w
->left_margin_cols
);
679 right
= margin_glyphs_to_reserve (w
, dim
.width
,
680 w
->right_margin_cols
);
685 for (i
= 0; i
< dim
.height
; ++i
)
687 struct glyph_row
*row
= &matrix
->rows
[i
];
689 row
->glyphs
[LEFT_MARGIN_AREA
]
690 = (matrix
->pool
->glyphs
691 + (y
+ i
) * matrix
->pool
->ncolumns
695 || row
== matrix
->rows
+ dim
.height
- 1
696 || (row
== matrix
->rows
&& matrix
->header_line_p
))
698 row
->glyphs
[TEXT_AREA
]
699 = row
->glyphs
[LEFT_MARGIN_AREA
];
700 row
->glyphs
[RIGHT_MARGIN_AREA
]
701 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
702 row
->glyphs
[LAST_AREA
]
703 = row
->glyphs
[RIGHT_MARGIN_AREA
];
707 row
->glyphs
[TEXT_AREA
]
708 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
709 row
->glyphs
[RIGHT_MARGIN_AREA
]
710 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
711 row
->glyphs
[LAST_AREA
]
712 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
716 matrix
->left_margin_glyphs
= left
;
717 matrix
->right_margin_glyphs
= right
;
721 /* If MATRIX->pool is null, MATRIX is responsible for managing
722 its own memory. It is a window matrix for window-based redisplay.
723 Allocate glyph memory from the heap. */
724 if (dim
.width
> matrix
->matrix_w
726 || header_line_changed_p
727 || marginal_areas_changed_p
)
729 struct glyph_row
*row
= matrix
->rows
;
730 struct glyph_row
*end
= row
+ matrix
->rows_allocated
;
734 row
->glyphs
[LEFT_MARGIN_AREA
]
735 = (struct glyph
*) xrealloc (row
->glyphs
[LEFT_MARGIN_AREA
],
737 * sizeof (struct glyph
)));
739 /* The mode line never has marginal areas. */
740 if (row
== matrix
->rows
+ dim
.height
- 1
741 || (row
== matrix
->rows
&& matrix
->header_line_p
))
743 row
->glyphs
[TEXT_AREA
]
744 = row
->glyphs
[LEFT_MARGIN_AREA
];
745 row
->glyphs
[RIGHT_MARGIN_AREA
]
746 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
747 row
->glyphs
[LAST_AREA
]
748 = row
->glyphs
[RIGHT_MARGIN_AREA
];
752 row
->glyphs
[TEXT_AREA
]
753 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
754 row
->glyphs
[RIGHT_MARGIN_AREA
]
755 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
756 row
->glyphs
[LAST_AREA
]
757 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
763 xassert (left
>= 0 && right
>= 0);
764 matrix
->left_margin_glyphs
= left
;
765 matrix
->right_margin_glyphs
= right
;
768 /* Number of rows to be used by MATRIX. */
769 matrix
->nrows
= dim
.height
;
770 xassert (matrix
->nrows
>= 0);
774 if (matrix
== w
->current_matrix
)
776 /* Mark rows in a current matrix of a window as not having
777 valid contents. It's important to not do this for
778 desired matrices. When Emacs starts, it may already be
779 building desired matrices when this function runs. */
780 if (window_width
< 0)
781 window_width
= window_box_width (w
, -1);
783 /* Optimize the case that only the height has changed (C-x 2,
784 upper window). Invalidate all rows that are no longer part
786 if (!marginal_areas_changed_p
787 && !header_line_changed_p
789 && dim
.width
== matrix
->matrix_w
790 && matrix
->window_left_col
== WINDOW_LEFT_EDGE_COL (w
)
791 && matrix
->window_top_line
== WINDOW_TOP_EDGE_LINE (w
)
792 && matrix
->window_width
== window_width
)
794 /* Find the last row in the window. */
795 for (i
= 0; i
< matrix
->nrows
&& matrix
->rows
[i
].enabled_p
; ++i
)
796 if (MATRIX_ROW_BOTTOM_Y (matrix
->rows
+ i
) >= window_height
)
802 /* Window end is invalid, if inside of the rows that
803 are invalidated below. */
804 if (INTEGERP (w
->window_end_vpos
)
805 && XFASTINT (w
->window_end_vpos
) >= i
)
806 w
->window_end_valid
= Qnil
;
808 while (i
< matrix
->nrows
)
809 matrix
->rows
[i
++].enabled_p
= 0;
813 for (i
= 0; i
< matrix
->nrows
; ++i
)
814 matrix
->rows
[i
].enabled_p
= 0;
817 else if (matrix
== w
->desired_matrix
)
819 /* Rows in desired matrices always have to be cleared;
820 redisplay expects this is the case when it runs, so it
821 had better be the case when we adjust matrices between
823 for (i
= 0; i
< matrix
->nrows
; ++i
)
824 matrix
->rows
[i
].enabled_p
= 0;
829 /* Remember last values to be able to optimize frame redraws. */
830 matrix
->matrix_x
= x
;
831 matrix
->matrix_y
= y
;
832 matrix
->matrix_w
= dim
.width
;
833 matrix
->matrix_h
= dim
.height
;
835 /* Record the top y location and height of W at the time the matrix
836 was last adjusted. This is used to optimize redisplay above. */
839 matrix
->window_left_col
= WINDOW_LEFT_EDGE_COL (w
);
840 matrix
->window_top_line
= WINDOW_TOP_EDGE_LINE (w
);
841 matrix
->window_height
= window_height
;
842 matrix
->window_width
= window_width
;
843 matrix
->window_vscroll
= w
->vscroll
;
848 /* Reverse the contents of rows in MATRIX between START and END. The
849 contents of the row at END - 1 end up at START, END - 2 at START +
850 1 etc. This is part of the implementation of rotate_matrix (see
854 reverse_rows (matrix
, start
, end
)
855 struct glyph_matrix
*matrix
;
860 for (i
= start
, j
= end
- 1; i
< j
; ++i
, --j
)
862 /* Non-ISO HP/UX compiler doesn't like auto struct
864 struct glyph_row temp
;
865 temp
= matrix
->rows
[i
];
866 matrix
->rows
[i
] = matrix
->rows
[j
];
867 matrix
->rows
[j
] = temp
;
872 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
873 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
874 indices. (Note: this does not copy glyphs, only glyph pointers in
875 row structures are moved around).
877 The algorithm used for rotating the vector was, I believe, first
878 described by Kernighan. See the vector R as consisting of two
879 sub-vectors AB, where A has length BY for BY >= 0. The result
880 after rotating is then BA. Reverse both sub-vectors to get ArBr
881 and reverse the result to get (ArBr)r which is BA. Similar for
885 rotate_matrix (matrix
, first
, last
, by
)
886 struct glyph_matrix
*matrix
;
891 /* Up (rotate left, i.e. towards lower indices). */
893 reverse_rows (matrix
, first
, first
+ by
);
894 reverse_rows (matrix
, first
+ by
, last
);
895 reverse_rows (matrix
, first
, last
);
899 /* Down (rotate right, i.e. towards higher indices). */
900 reverse_rows (matrix
, last
- by
, last
);
901 reverse_rows (matrix
, first
, last
- by
);
902 reverse_rows (matrix
, first
, last
);
907 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
908 with indices START <= index < END. Increment positions by DELTA/
912 increment_matrix_positions (matrix
, start
, end
, delta
, delta_bytes
)
913 struct glyph_matrix
*matrix
;
914 int start
, end
, delta
, delta_bytes
;
916 /* Check that START and END are reasonable values. */
917 xassert (start
>= 0 && start
<= matrix
->nrows
);
918 xassert (end
>= 0 && end
<= matrix
->nrows
);
919 xassert (start
<= end
);
921 for (; start
< end
; ++start
)
922 increment_row_positions (matrix
->rows
+ start
, delta
, delta_bytes
);
926 /* Enable a range of rows in glyph matrix MATRIX. START and END are
927 the row indices of the first and last + 1 row to enable. If
928 ENABLED_P is non-zero, enabled_p flags in rows will be set to 1. */
931 enable_glyph_matrix_rows (matrix
, start
, end
, enabled_p
)
932 struct glyph_matrix
*matrix
;
936 xassert (start
<= end
);
937 xassert (start
>= 0 && start
< matrix
->nrows
);
938 xassert (end
>= 0 && end
<= matrix
->nrows
);
940 for (; start
< end
; ++start
)
941 matrix
->rows
[start
].enabled_p
= enabled_p
!= 0;
947 This empties all rows in MATRIX by setting the enabled_p flag for
948 all rows of the matrix to zero. The function prepare_desired_row
949 will eventually really clear a row when it sees one with a zero
952 Resets update hints to defaults value. The only update hint
953 currently present is the flag MATRIX->no_scrolling_p. */
956 clear_glyph_matrix (matrix
)
957 struct glyph_matrix
*matrix
;
961 enable_glyph_matrix_rows (matrix
, 0, matrix
->nrows
, 0);
962 matrix
->no_scrolling_p
= 0;
967 /* Shift part of the glyph matrix MATRIX of window W up or down.
968 Increment y-positions in glyph rows between START and END by DY,
969 and recompute their visible height. */
972 shift_glyph_matrix (w
, matrix
, start
, end
, dy
)
974 struct glyph_matrix
*matrix
;
979 xassert (start
<= end
);
980 xassert (start
>= 0 && start
< matrix
->nrows
);
981 xassert (end
>= 0 && end
<= matrix
->nrows
);
983 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
984 max_y
= WINDOW_BOX_HEIGHT_NO_MODE_LINE (w
);
986 for (; start
< end
; ++start
)
988 struct glyph_row
*row
= &matrix
->rows
[start
];
991 row
->visible_height
= row
->height
;
994 row
->visible_height
-= min_y
- row
->y
;
995 if (row
->y
+ row
->height
> max_y
)
996 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
1001 /* Mark all rows in current matrices of frame F as invalid. Marking
1002 invalid is done by setting enabled_p to zero for all rows in a
1006 clear_current_matrices (f
)
1007 register struct frame
*f
;
1009 /* Clear frame current matrix, if we have one. */
1010 if (f
->current_matrix
)
1011 clear_glyph_matrix (f
->current_matrix
);
1013 /* Clear the matrix of the menu bar window, if such a window exists.
1014 The menu bar window is currently used to display menus on X when
1015 no toolkit support is compiled in. */
1016 if (WINDOWP (f
->menu_bar_window
))
1017 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->current_matrix
);
1019 /* Clear the matrix of the tool-bar window, if any. */
1020 if (WINDOWP (f
->tool_bar_window
))
1021 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
1023 /* Clear current window matrices. */
1024 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
1025 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 0);
1029 /* Clear out all display lines of F for a coming redisplay. */
1032 clear_desired_matrices (f
)
1033 register struct frame
*f
;
1035 if (f
->desired_matrix
)
1036 clear_glyph_matrix (f
->desired_matrix
);
1038 if (WINDOWP (f
->menu_bar_window
))
1039 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->desired_matrix
);
1041 if (WINDOWP (f
->tool_bar_window
))
1042 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->desired_matrix
);
1044 /* Do it for window matrices. */
1045 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
1046 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
1050 /* Clear matrices in window tree rooted in W. If DESIRED_P is
1051 non-zero clear desired matrices, otherwise clear current matrices. */
1054 clear_window_matrices (w
, desired_p
)
1060 if (!NILP (w
->hchild
))
1062 xassert (WINDOWP (w
->hchild
));
1063 clear_window_matrices (XWINDOW (w
->hchild
), desired_p
);
1065 else if (!NILP (w
->vchild
))
1067 xassert (WINDOWP (w
->vchild
));
1068 clear_window_matrices (XWINDOW (w
->vchild
), desired_p
);
1073 clear_glyph_matrix (w
->desired_matrix
);
1076 clear_glyph_matrix (w
->current_matrix
);
1077 w
->window_end_valid
= Qnil
;
1081 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
1087 /***********************************************************************
1090 See dispextern.h for an overall explanation of glyph rows.
1091 ***********************************************************************/
1093 /* Clear glyph row ROW. Do it in a way that makes it robust against
1094 changes in the glyph_row structure, i.e. addition or removal of
1095 structure members. */
1097 static struct glyph_row null_row
;
1100 clear_glyph_row (row
)
1101 struct glyph_row
*row
;
1103 struct glyph
*p
[1 + LAST_AREA
];
1105 /* Save pointers. */
1106 p
[LEFT_MARGIN_AREA
] = row
->glyphs
[LEFT_MARGIN_AREA
];
1107 p
[TEXT_AREA
] = row
->glyphs
[TEXT_AREA
];
1108 p
[RIGHT_MARGIN_AREA
] = row
->glyphs
[RIGHT_MARGIN_AREA
];
1109 p
[LAST_AREA
] = row
->glyphs
[LAST_AREA
];
1114 /* Restore pointers. */
1115 row
->glyphs
[LEFT_MARGIN_AREA
] = p
[LEFT_MARGIN_AREA
];
1116 row
->glyphs
[TEXT_AREA
] = p
[TEXT_AREA
];
1117 row
->glyphs
[RIGHT_MARGIN_AREA
] = p
[RIGHT_MARGIN_AREA
];
1118 row
->glyphs
[LAST_AREA
] = p
[LAST_AREA
];
1120 #if 0 /* At some point, some bit-fields of struct glyph were not set,
1121 which made glyphs unequal when compared with GLYPH_EQUAL_P.
1122 Redisplay outputs such glyphs, and flickering effects were
1123 the result. This also depended on the contents of memory
1124 returned by xmalloc. If flickering happens again, activate
1125 the code below. If the flickering is gone with that, chances
1126 are that the flickering has the same reason as here. */
1127 bzero (p
[0], (char *) p
[LAST_AREA
] - (char *) p
[0]);
1132 /* Make ROW an empty, enabled row of canonical character height,
1133 in window W starting at y-position Y. */
1136 blank_row (w
, row
, y
)
1138 struct glyph_row
*row
;
1143 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1144 max_y
= WINDOW_BOX_HEIGHT_NO_MODE_LINE (w
);
1146 clear_glyph_row (row
);
1148 row
->ascent
= row
->phys_ascent
= 0;
1149 row
->height
= row
->phys_height
= FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
1150 row
->visible_height
= row
->height
;
1153 row
->visible_height
-= min_y
- row
->y
;
1154 if (row
->y
+ row
->height
> max_y
)
1155 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
1161 /* Increment buffer positions in glyph row ROW. DELTA and DELTA_BYTES
1162 are the amounts by which to change positions. Note that the first
1163 glyph of the text area of a row can have a buffer position even if
1164 the used count of the text area is zero. Such rows display line
1168 increment_row_positions (row
, delta
, delta_bytes
)
1169 struct glyph_row
*row
;
1170 int delta
, delta_bytes
;
1174 /* Increment start and end positions. */
1175 MATRIX_ROW_START_CHARPOS (row
) += delta
;
1176 MATRIX_ROW_START_BYTEPOS (row
) += delta_bytes
;
1177 MATRIX_ROW_END_CHARPOS (row
) += delta
;
1178 MATRIX_ROW_END_BYTEPOS (row
) += delta_bytes
;
1180 /* Increment positions in glyphs. */
1181 for (area
= 0; area
< LAST_AREA
; ++area
)
1182 for (i
= 0; i
< row
->used
[area
]; ++i
)
1183 if (BUFFERP (row
->glyphs
[area
][i
].object
)
1184 && row
->glyphs
[area
][i
].charpos
> 0)
1185 row
->glyphs
[area
][i
].charpos
+= delta
;
1187 /* Capture the case of rows displaying a line end. */
1188 if (row
->used
[TEXT_AREA
] == 0
1189 && MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1190 row
->glyphs
[TEXT_AREA
]->charpos
+= delta
;
1195 /* Swap glyphs between two glyph rows A and B. This exchanges glyph
1196 contents, i.e. glyph structure contents are exchanged between A and
1197 B without changing glyph pointers in A and B. */
1200 swap_glyphs_in_rows (a
, b
)
1201 struct glyph_row
*a
, *b
;
1205 for (area
= 0; area
< LAST_AREA
; ++area
)
1207 /* Number of glyphs to swap. */
1208 int max_used
= max (a
->used
[area
], b
->used
[area
]);
1210 /* Start of glyphs in area of row A. */
1211 struct glyph
*glyph_a
= a
->glyphs
[area
];
1213 /* End + 1 of glyphs in area of row A. */
1214 struct glyph
*glyph_a_end
= a
->glyphs
[max_used
];
1216 /* Start of glyphs in area of row B. */
1217 struct glyph
*glyph_b
= b
->glyphs
[area
];
1219 while (glyph_a
< glyph_a_end
)
1221 /* Non-ISO HP/UX compiler doesn't like auto struct
1225 *glyph_a
= *glyph_b
;
1235 /* Exchange pointers to glyph memory between glyph rows A and B. */
1238 swap_glyph_pointers (a
, b
)
1239 struct glyph_row
*a
, *b
;
1242 for (i
= 0; i
< LAST_AREA
+ 1; ++i
)
1244 struct glyph
*temp
= a
->glyphs
[i
];
1245 a
->glyphs
[i
] = b
->glyphs
[i
];
1246 b
->glyphs
[i
] = temp
;
1251 /* Copy glyph row structure FROM to glyph row structure TO, except
1252 that glyph pointers in the structures are left unchanged. */
1255 copy_row_except_pointers (to
, from
)
1256 struct glyph_row
*to
, *from
;
1258 struct glyph
*pointers
[1 + LAST_AREA
];
1260 /* Save glyph pointers of TO. */
1261 bcopy (to
->glyphs
, pointers
, sizeof to
->glyphs
);
1263 /* Do a structure assignment. */
1266 /* Restore original pointers of TO. */
1267 bcopy (pointers
, to
->glyphs
, sizeof to
->glyphs
);
1271 /* Copy contents of glyph row FROM to glyph row TO. Glyph pointers in
1272 TO and FROM are left unchanged. Glyph contents are copied from the
1273 glyph memory of FROM to the glyph memory of TO. Increment buffer
1274 positions in row TO by DELTA/ DELTA_BYTES. */
1277 copy_glyph_row_contents (to
, from
, delta
, delta_bytes
)
1278 struct glyph_row
*to
, *from
;
1279 int delta
, delta_bytes
;
1283 /* This is like a structure assignment TO = FROM, except that
1284 glyph pointers in the rows are left unchanged. */
1285 copy_row_except_pointers (to
, from
);
1287 /* Copy glyphs from FROM to TO. */
1288 for (area
= 0; area
< LAST_AREA
; ++area
)
1289 if (from
->used
[area
])
1290 bcopy (from
->glyphs
[area
], to
->glyphs
[area
],
1291 from
->used
[area
] * sizeof (struct glyph
));
1293 /* Increment buffer positions in TO by DELTA. */
1294 increment_row_positions (to
, delta
, delta_bytes
);
1298 /* Assign glyph row FROM to glyph row TO. This works like a structure
1299 assignment TO = FROM, except that glyph pointers are not copied but
1300 exchanged between TO and FROM. Pointers must be exchanged to avoid
1304 assign_row (to
, from
)
1305 struct glyph_row
*to
, *from
;
1307 swap_glyph_pointers (to
, from
);
1308 copy_row_except_pointers (to
, from
);
1312 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1313 a row in a window matrix, is a slice of the glyph memory of the
1314 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1315 is non-zero if the glyph memory of WINDOW_ROW is part of the glyph
1316 memory of FRAME_ROW. */
1321 glyph_row_slice_p (window_row
, frame_row
)
1322 struct glyph_row
*window_row
, *frame_row
;
1324 struct glyph
*window_glyph_start
= window_row
->glyphs
[0];
1325 struct glyph
*frame_glyph_start
= frame_row
->glyphs
[0];
1326 struct glyph
*frame_glyph_end
= frame_row
->glyphs
[LAST_AREA
];
1328 return (frame_glyph_start
<= window_glyph_start
1329 && window_glyph_start
< frame_glyph_end
);
1332 #endif /* GLYPH_DEBUG */
1336 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1337 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1338 in WINDOW_MATRIX is found satisfying the condition. */
1340 static struct glyph_row
*
1341 find_glyph_row_slice (window_matrix
, frame_matrix
, row
)
1342 struct glyph_matrix
*window_matrix
, *frame_matrix
;
1347 xassert (row
>= 0 && row
< frame_matrix
->nrows
);
1349 for (i
= 0; i
< window_matrix
->nrows
; ++i
)
1350 if (glyph_row_slice_p (window_matrix
->rows
+ i
,
1351 frame_matrix
->rows
+ row
))
1354 return i
< window_matrix
->nrows
? window_matrix
->rows
+ i
: 0;
1359 /* Prepare ROW for display. Desired rows are cleared lazily,
1360 i.e. they are only marked as to be cleared by setting their
1361 enabled_p flag to zero. When a row is to be displayed, a prior
1362 call to this function really clears it. */
1365 prepare_desired_row (row
)
1366 struct glyph_row
*row
;
1368 if (!row
->enabled_p
)
1370 clear_glyph_row (row
);
1376 /* Return a hash code for glyph row ROW. */
1379 line_hash_code (row
)
1380 struct glyph_row
*row
;
1386 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
1387 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
1391 int c
= glyph
->u
.ch
;
1392 int face_id
= glyph
->face_id
;
1393 if (TTY_MUST_WRITE_SPACES (CURTTY ()))
1395 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + c
;
1396 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + face_id
;
1408 /* Return the cost of drawing line VPOS in MATRIX. The cost equals
1409 the number of characters in the line. If must_write_spaces is
1410 zero, leading and trailing spaces are ignored. */
1413 line_draw_cost (matrix
, vpos
)
1414 struct glyph_matrix
*matrix
;
1417 struct glyph_row
*row
= matrix
->rows
+ vpos
;
1418 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
1419 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
];
1421 Lisp_Object
*glyph_table_base
= GLYPH_TABLE_BASE
;
1422 int glyph_table_len
= GLYPH_TABLE_LENGTH
;
1424 /* Ignore trailing and leading spaces if we can. */
1425 if (!TTY_MUST_WRITE_SPACES (CURTTY ()))
1427 /* Skip from the end over trailing spaces. */
1428 while (end
> beg
&& CHAR_GLYPH_SPACE_P (*(end
- 1)))
1431 /* All blank line. */
1435 /* Skip over leading spaces. */
1436 while (CHAR_GLYPH_SPACE_P (*beg
))
1440 /* If we don't have a glyph-table, each glyph is one character,
1441 so return the number of glyphs. */
1442 if (glyph_table_base
== 0)
1446 /* Otherwise, scan the glyphs and accumulate their total length
1451 GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*beg
);
1454 || GLYPH_SIMPLE_P (glyph_table_base
, glyph_table_len
, g
))
1457 len
+= GLYPH_LENGTH (glyph_table_base
, g
);
1467 /* Test two glyph rows A and B for equality. Value is non-zero if A
1468 and B have equal contents. W is the window to which the glyphs
1469 rows A and B belong. It is needed here to test for partial row
1470 visibility. MOUSE_FACE_P non-zero means compare the mouse_face_p
1471 flags of A and B, too. */
1474 row_equal_p (w
, a
, b
, mouse_face_p
)
1476 struct glyph_row
*a
, *b
;
1481 else if (a
->hash
!= b
->hash
)
1485 struct glyph
*a_glyph
, *b_glyph
, *a_end
;
1488 if (mouse_face_p
&& a
->mouse_face_p
!= b
->mouse_face_p
)
1491 /* Compare glyphs. */
1492 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
1494 if (a
->used
[area
] != b
->used
[area
])
1497 a_glyph
= a
->glyphs
[area
];
1498 a_end
= a_glyph
+ a
->used
[area
];
1499 b_glyph
= b
->glyphs
[area
];
1501 while (a_glyph
< a_end
1502 && GLYPH_EQUAL_P (a_glyph
, b_glyph
))
1503 ++a_glyph
, ++b_glyph
;
1505 if (a_glyph
!= a_end
)
1509 if (a
->truncated_on_left_p
!= b
->truncated_on_left_p
1510 || a
->fill_line_p
!= b
->fill_line_p
1511 || a
->truncated_on_right_p
!= b
->truncated_on_right_p
1512 || a
->overlay_arrow_p
!= b
->overlay_arrow_p
1513 || a
->continued_p
!= b
->continued_p
1514 || a
->indicate_empty_line_p
!= b
->indicate_empty_line_p
1515 || a
->overlapped_p
!= b
->overlapped_p
1516 || (MATRIX_ROW_CONTINUATION_LINE_P (a
)
1517 != MATRIX_ROW_CONTINUATION_LINE_P (b
))
1518 /* Different partially visible characters on left margin. */
1520 /* Different height. */
1521 || a
->ascent
!= b
->ascent
1522 || a
->phys_ascent
!= b
->phys_ascent
1523 || a
->phys_height
!= b
->phys_height
1524 || a
->visible_height
!= b
->visible_height
)
1533 /***********************************************************************
1536 See dispextern.h for an overall explanation of glyph pools.
1537 ***********************************************************************/
1539 /* Allocate a glyph_pool structure. The structure returned is
1540 initialized with zeros. The global variable glyph_pool_count is
1541 incremented for each pool allocated. */
1543 static struct glyph_pool
*
1546 struct glyph_pool
*result
;
1548 /* Allocate a new glyph_pool and clear it. */
1549 result
= (struct glyph_pool
*) xmalloc (sizeof *result
);
1550 bzero (result
, sizeof *result
);
1552 /* For memory leak and double deletion checking. */
1559 /* Free a glyph_pool structure POOL. The function may be called with
1560 a null POOL pointer. The global variable glyph_pool_count is
1561 decremented with every pool structure freed. If this count gets
1562 negative, more structures were freed than allocated, i.e. one
1563 structure must have been freed more than once or a bogus pointer
1564 was passed to free_glyph_pool. */
1567 free_glyph_pool (pool
)
1568 struct glyph_pool
*pool
;
1572 /* More freed than allocated? */
1574 xassert (glyph_pool_count
>= 0);
1576 xfree (pool
->glyphs
);
1582 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1583 columns we need. This function never shrinks a pool. The only
1584 case in which this would make sense, would be when a frame's size
1585 is changed from a large value to a smaller one. But, if someone
1586 does it once, we can expect that he will do it again.
1588 Value is non-zero if the pool changed in a way which makes
1589 re-adjusting window glyph matrices necessary. */
1592 realloc_glyph_pool (pool
, matrix_dim
)
1593 struct glyph_pool
*pool
;
1594 struct dim matrix_dim
;
1599 changed_p
= (pool
->glyphs
== 0
1600 || matrix_dim
.height
!= pool
->nrows
1601 || matrix_dim
.width
!= pool
->ncolumns
);
1603 /* Enlarge the glyph pool. */
1604 needed
= matrix_dim
.width
* matrix_dim
.height
;
1605 if (needed
> pool
->nglyphs
)
1607 int size
= needed
* sizeof (struct glyph
);
1610 pool
->glyphs
= (struct glyph
*) xrealloc (pool
->glyphs
, size
);
1613 pool
->glyphs
= (struct glyph
*) xmalloc (size
);
1614 bzero (pool
->glyphs
, size
);
1617 pool
->nglyphs
= needed
;
1620 /* Remember the number of rows and columns because (a) we use them
1621 to do sanity checks, and (b) the number of columns determines
1622 where rows in the frame matrix start---this must be available to
1623 determine pointers to rows of window sub-matrices. */
1624 pool
->nrows
= matrix_dim
.height
;
1625 pool
->ncolumns
= matrix_dim
.width
;
1632 /***********************************************************************
1634 ***********************************************************************/
1639 /* Flush standard output. This is sometimes useful to call from the debugger.
1640 XXX Maybe this should be changed to flush the current terminal instead of
1651 /* Check that no glyph pointers have been lost in MATRIX. If a
1652 pointer has been lost, e.g. by using a structure assignment between
1653 rows, at least one pointer must occur more than once in the rows of
1657 check_matrix_pointer_lossage (matrix
)
1658 struct glyph_matrix
*matrix
;
1662 for (i
= 0; i
< matrix
->nrows
; ++i
)
1663 for (j
= 0; j
< matrix
->nrows
; ++j
)
1665 || (matrix
->rows
[i
].glyphs
[TEXT_AREA
]
1666 != matrix
->rows
[j
].glyphs
[TEXT_AREA
]));
1670 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1673 matrix_row (matrix
, row
)
1674 struct glyph_matrix
*matrix
;
1677 xassert (matrix
&& matrix
->rows
);
1678 xassert (row
>= 0 && row
< matrix
->nrows
);
1680 /* That's really too slow for normal testing because this function
1681 is called almost everywhere. Although---it's still astonishingly
1682 fast, so it is valuable to have for debugging purposes. */
1684 check_matrix_pointer_lossage (matrix
);
1687 return matrix
->rows
+ row
;
1691 #if 0 /* This function makes invalid assumptions when text is
1692 partially invisible. But it might come handy for debugging
1695 /* Check invariants that must hold for an up to date current matrix of
1699 check_matrix_invariants (w
)
1702 struct glyph_matrix
*matrix
= w
->current_matrix
;
1703 int yb
= window_text_bottom_y (w
);
1704 struct glyph_row
*row
= matrix
->rows
;
1705 struct glyph_row
*last_text_row
= NULL
;
1706 struct buffer
*saved
= current_buffer
;
1707 struct buffer
*buffer
= XBUFFER (w
->buffer
);
1710 /* This can sometimes happen for a fresh window. */
1711 if (matrix
->nrows
< 2)
1714 set_buffer_temp (buffer
);
1716 /* Note: last row is always reserved for the mode line. */
1717 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1718 && MATRIX_ROW_BOTTOM_Y (row
) < yb
)
1720 struct glyph_row
*next
= row
+ 1;
1722 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1723 last_text_row
= row
;
1725 /* Check that character and byte positions are in sync. */
1726 xassert (MATRIX_ROW_START_BYTEPOS (row
)
1727 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row
)));
1729 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1730 have such a position temporarily in case of a minibuffer
1731 displaying something like `[Sole completion]' at its end. */
1732 if (MATRIX_ROW_END_CHARPOS (row
) < BUF_ZV (current_buffer
))
1733 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1734 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row
)));
1736 /* Check that end position of `row' is equal to start position
1738 if (next
->enabled_p
&& MATRIX_ROW_DISPLAYS_TEXT_P (next
))
1740 xassert (MATRIX_ROW_END_CHARPOS (row
)
1741 == MATRIX_ROW_START_CHARPOS (next
));
1742 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1743 == MATRIX_ROW_START_BYTEPOS (next
));
1748 xassert (w
->current_matrix
->nrows
== w
->desired_matrix
->nrows
);
1749 xassert (w
->desired_matrix
->rows
!= NULL
);
1750 set_buffer_temp (saved
);
1755 #endif /* GLYPH_DEBUG != 0 */
1759 /**********************************************************************
1760 Allocating/ Adjusting Glyph Matrices
1761 **********************************************************************/
1763 /* Allocate glyph matrices over a window tree for a frame-based
1766 X and Y are column/row within the frame glyph matrix where
1767 sub-matrices for the window tree rooted at WINDOW must be
1768 allocated. CH_DIM contains the dimensions of the smallest
1769 character that could be used during display. DIM_ONLY_P non-zero
1770 means that the caller of this function is only interested in the
1771 result matrix dimension, and matrix adjustments should not be
1774 The function returns the total width/height of the sub-matrices of
1775 the window tree. If called on a frame root window, the computation
1776 will take the mini-buffer window into account.
1778 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1780 NEW_LEAF_MATRIX set if any window in the tree did not have a
1781 glyph matrices yet, and
1783 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1784 any window in the tree will be changed or have been changed (see
1787 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1790 Windows are arranged into chains of windows on the same level
1791 through the next fields of window structures. Such a level can be
1792 either a sequence of horizontally adjacent windows from left to
1793 right, or a sequence of vertically adjacent windows from top to
1794 bottom. Each window in a horizontal sequence can be either a leaf
1795 window or a vertical sequence; a window in a vertical sequence can
1796 be either a leaf or a horizontal sequence. All windows in a
1797 horizontal sequence have the same height, and all windows in a
1798 vertical sequence have the same width.
1800 This function uses, for historical reasons, a more general
1801 algorithm to determine glyph matrix dimensions that would be
1804 The matrix height of a horizontal sequence is determined by the
1805 maximum height of any matrix in the sequence. The matrix width of
1806 a horizontal sequence is computed by adding up matrix widths of
1807 windows in the sequence.
1809 |<------- result width ------->|
1810 +---------+----------+---------+ ---
1813 +---------+ | | result height
1818 The matrix width of a vertical sequence is the maximum matrix width
1819 of any window in the sequence. Its height is computed by adding up
1820 matrix heights of windows in the sequence.
1822 |<---- result width -->|
1830 +------------+---------+ |
1833 +------------+---------+ --- */
1835 /* Bit indicating that a new matrix will be allocated or has been
1838 #define NEW_LEAF_MATRIX (1 << 0)
1840 /* Bit indicating that a matrix will or has changed its location or
1843 #define CHANGED_LEAF_MATRIX (1 << 1)
1846 allocate_matrices_for_frame_redisplay (window
, x
, y
, dim_only_p
,
1847 window_change_flags
)
1851 int *window_change_flags
;
1853 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1855 int wmax
= 0, hmax
= 0;
1859 int in_horz_combination_p
;
1861 /* What combination is WINDOW part of? Compute this once since the
1862 result is the same for all windows in the `next' chain. The
1863 special case of a root window (parent equal to nil) is treated
1864 like a vertical combination because a root window's `next'
1865 points to the mini-buffer window, if any, which is arranged
1866 vertically below other windows. */
1867 in_horz_combination_p
1868 = (!NILP (XWINDOW (window
)->parent
)
1869 && !NILP (XWINDOW (XWINDOW (window
)->parent
)->hchild
));
1871 /* For WINDOW and all windows on the same level. */
1874 w
= XWINDOW (window
);
1876 /* Get the dimension of the window sub-matrix for W, depending
1877 on whether this is a combination or a leaf window. */
1878 if (!NILP (w
->hchild
))
1879 dim
= allocate_matrices_for_frame_redisplay (w
->hchild
, x
, y
,
1881 window_change_flags
);
1882 else if (!NILP (w
->vchild
))
1883 dim
= allocate_matrices_for_frame_redisplay (w
->vchild
, x
, y
,
1885 window_change_flags
);
1888 /* If not already done, allocate sub-matrix structures. */
1889 if (w
->desired_matrix
== NULL
)
1891 w
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1892 w
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1893 *window_change_flags
|= NEW_LEAF_MATRIX
;
1896 /* Width and height MUST be chosen so that there are no
1897 holes in the frame matrix. */
1898 dim
.width
= required_matrix_width (w
);
1899 dim
.height
= required_matrix_height (w
);
1901 /* Will matrix be re-allocated? */
1902 if (x
!= w
->desired_matrix
->matrix_x
1903 || y
!= w
->desired_matrix
->matrix_y
1904 || dim
.width
!= w
->desired_matrix
->matrix_w
1905 || dim
.height
!= w
->desired_matrix
->matrix_h
1906 || (margin_glyphs_to_reserve (w
, dim
.width
,
1907 w
->right_margin_cols
)
1908 != w
->desired_matrix
->left_margin_glyphs
)
1909 || (margin_glyphs_to_reserve (w
, dim
.width
,
1910 w
->left_margin_cols
)
1911 != w
->desired_matrix
->right_margin_glyphs
))
1912 *window_change_flags
|= CHANGED_LEAF_MATRIX
;
1914 /* Actually change matrices, if allowed. Do not consider
1915 CHANGED_LEAF_MATRIX computed above here because the pool
1916 may have been changed which we don't now here. We trust
1917 that we only will be called with DIM_ONLY_P != 0 when
1921 adjust_glyph_matrix (w
, w
->desired_matrix
, x
, y
, dim
);
1922 adjust_glyph_matrix (w
, w
->current_matrix
, x
, y
, dim
);
1926 /* If we are part of a horizontal combination, advance x for
1927 windows to the right of W; otherwise advance y for windows
1929 if (in_horz_combination_p
)
1934 /* Remember maximum glyph matrix dimensions. */
1935 wmax
= max (wmax
, dim
.width
);
1936 hmax
= max (hmax
, dim
.height
);
1938 /* Next window on same level. */
1941 while (!NILP (window
));
1943 /* Set `total' to the total glyph matrix dimension of this window
1944 level. In a vertical combination, the width is the width of the
1945 widest window; the height is the y we finally reached, corrected
1946 by the y we started with. In a horizontal combination, the total
1947 height is the height of the tallest window, and the width is the
1948 x we finally reached, corrected by the x we started with. */
1949 if (in_horz_combination_p
)
1951 total
.width
= x
- x0
;
1952 total
.height
= hmax
;
1957 total
.height
= y
- y0
;
1964 /* Return the required height of glyph matrices for window W. */
1967 required_matrix_height (w
)
1970 #ifdef HAVE_WINDOW_SYSTEM
1971 struct frame
*f
= XFRAME (w
->frame
);
1973 if (FRAME_WINDOW_P (f
))
1975 int ch_height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
1976 int window_pixel_height
= window_box_height (w
) + abs (w
->vscroll
);
1977 return (((window_pixel_height
+ ch_height
- 1)
1979 /* One partially visible line at the top and
1980 bottom of the window. */
1982 /* 2 for header and mode line. */
1985 #endif /* HAVE_WINDOW_SYSTEM */
1987 return WINDOW_TOTAL_LINES (w
);
1991 /* Return the required width of glyph matrices for window W. */
1994 required_matrix_width (w
)
1997 #ifdef HAVE_WINDOW_SYSTEM
1998 struct frame
*f
= XFRAME (w
->frame
);
1999 if (FRAME_WINDOW_P (f
))
2001 int ch_width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2002 int window_pixel_width
= WINDOW_TOTAL_WIDTH (w
);
2004 /* Compute number of glyphs needed in a glyph row. */
2005 return (((window_pixel_width
+ ch_width
- 1)
2007 /* 2 partially visible columns in the text area. */
2009 /* One partially visible column at the right
2010 edge of each marginal area. */
2013 #endif /* HAVE_WINDOW_SYSTEM */
2015 return XINT (w
->total_cols
);
2019 /* Allocate window matrices for window-based redisplay. W is the
2020 window whose matrices must be allocated/reallocated. CH_DIM is the
2021 size of the smallest character that could potentially be used on W. */
2024 allocate_matrices_for_window_redisplay (w
)
2029 if (!NILP (w
->vchild
))
2030 allocate_matrices_for_window_redisplay (XWINDOW (w
->vchild
));
2031 else if (!NILP (w
->hchild
))
2032 allocate_matrices_for_window_redisplay (XWINDOW (w
->hchild
));
2035 /* W is a leaf window. */
2038 /* If matrices are not yet allocated, allocate them now. */
2039 if (w
->desired_matrix
== NULL
)
2041 w
->desired_matrix
= new_glyph_matrix (NULL
);
2042 w
->current_matrix
= new_glyph_matrix (NULL
);
2045 dim
.width
= required_matrix_width (w
);
2046 dim
.height
= required_matrix_height (w
);
2047 adjust_glyph_matrix (w
, w
->desired_matrix
, 0, 0, dim
);
2048 adjust_glyph_matrix (w
, w
->current_matrix
, 0, 0, dim
);
2051 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
2056 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
2057 do it for all frames; otherwise do it just for the given frame.
2058 This function must be called when a new frame is created, its size
2059 changes, or its window configuration changes. */
2065 /* Block input so that expose events and other events that access
2066 glyph matrices are not processed while we are changing them. */
2070 adjust_frame_glyphs (f
);
2073 Lisp_Object tail
, lisp_frame
;
2075 FOR_EACH_FRAME (tail
, lisp_frame
)
2076 adjust_frame_glyphs (XFRAME (lisp_frame
));
2083 /* Adjust frame glyphs when Emacs is initialized.
2085 To be called from init_display.
2087 We need a glyph matrix because redraw will happen soon.
2088 Unfortunately, window sizes on selected_frame are not yet set to
2089 meaningful values. I believe we can assume that there are only two
2090 windows on the frame---the mini-buffer and the root window. Frame
2091 height and width seem to be correct so far. So, set the sizes of
2092 windows to estimated values. */
2095 adjust_frame_glyphs_initially ()
2097 struct frame
*sf
= SELECTED_FRAME ();
2098 struct window
*root
= XWINDOW (sf
->root_window
);
2099 struct window
*mini
= XWINDOW (root
->next
);
2100 int frame_lines
= FRAME_LINES (sf
);
2101 int frame_cols
= FRAME_COLS (sf
);
2102 int top_margin
= FRAME_TOP_MARGIN (sf
);
2104 /* Do it for the root window. */
2105 XSETFASTINT (root
->top_line
, top_margin
);
2106 XSETFASTINT (root
->total_cols
, frame_cols
);
2107 set_window_height (sf
->root_window
, frame_lines
- 1 - top_margin
, 0);
2109 /* Do it for the mini-buffer window. */
2110 XSETFASTINT (mini
->top_line
, frame_lines
- 1);
2111 XSETFASTINT (mini
->total_cols
, frame_cols
);
2112 set_window_height (root
->next
, 1, 0);
2114 adjust_frame_glyphs (sf
);
2115 glyphs_initialized_initially_p
= 1;
2119 /* Allocate/reallocate glyph matrices of a single frame F. */
2122 adjust_frame_glyphs (f
)
2125 if (FRAME_WINDOW_P (f
))
2126 adjust_frame_glyphs_for_window_redisplay (f
);
2128 adjust_frame_glyphs_for_frame_redisplay (f
);
2130 /* Don't forget the message buffer and the buffer for
2131 decode_mode_spec. */
2132 adjust_frame_message_buffer (f
);
2133 adjust_decode_mode_spec_buffer (f
);
2135 f
->glyphs_initialized_p
= 1;
2139 /* In the window tree with root W, build current matrices of leaf
2140 windows from the frame's current matrix. */
2143 fake_current_matrices (window
)
2148 for (; !NILP (window
); window
= w
->next
)
2150 w
= XWINDOW (window
);
2152 if (!NILP (w
->hchild
))
2153 fake_current_matrices (w
->hchild
);
2154 else if (!NILP (w
->vchild
))
2155 fake_current_matrices (w
->vchild
);
2159 struct frame
*f
= XFRAME (w
->frame
);
2160 struct glyph_matrix
*m
= w
->current_matrix
;
2161 struct glyph_matrix
*fm
= f
->current_matrix
;
2163 xassert (m
->matrix_h
== WINDOW_TOTAL_LINES (w
));
2164 xassert (m
->matrix_w
== WINDOW_TOTAL_COLS (w
));
2166 for (i
= 0; i
< m
->matrix_h
; ++i
)
2168 struct glyph_row
*r
= m
->rows
+ i
;
2169 struct glyph_row
*fr
= fm
->rows
+ i
+ WINDOW_TOP_EDGE_LINE (w
);
2171 xassert (r
->glyphs
[TEXT_AREA
] >= fr
->glyphs
[TEXT_AREA
]
2172 && r
->glyphs
[LAST_AREA
] <= fr
->glyphs
[LAST_AREA
]);
2174 r
->enabled_p
= fr
->enabled_p
;
2177 r
->used
[LEFT_MARGIN_AREA
] = m
->left_margin_glyphs
;
2178 r
->used
[RIGHT_MARGIN_AREA
] = m
->right_margin_glyphs
;
2179 r
->used
[TEXT_AREA
] = (m
->matrix_w
2180 - r
->used
[LEFT_MARGIN_AREA
]
2181 - r
->used
[RIGHT_MARGIN_AREA
]);
2190 /* Save away the contents of frame F's current frame matrix. Value is
2191 a glyph matrix holding the contents of F's current frame matrix. */
2193 static struct glyph_matrix
*
2194 save_current_matrix (f
)
2198 struct glyph_matrix
*saved
;
2200 saved
= (struct glyph_matrix
*) xmalloc (sizeof *saved
);
2201 bzero (saved
, sizeof *saved
);
2202 saved
->nrows
= f
->current_matrix
->nrows
;
2203 saved
->rows
= (struct glyph_row
*) xmalloc (saved
->nrows
2204 * sizeof *saved
->rows
);
2205 bzero (saved
->rows
, saved
->nrows
* sizeof *saved
->rows
);
2207 for (i
= 0; i
< saved
->nrows
; ++i
)
2209 struct glyph_row
*from
= f
->current_matrix
->rows
+ i
;
2210 struct glyph_row
*to
= saved
->rows
+ i
;
2211 size_t nbytes
= from
->used
[TEXT_AREA
] * sizeof (struct glyph
);
2212 to
->glyphs
[TEXT_AREA
] = (struct glyph
*) xmalloc (nbytes
);
2213 bcopy (from
->glyphs
[TEXT_AREA
], to
->glyphs
[TEXT_AREA
], nbytes
);
2214 to
->used
[TEXT_AREA
] = from
->used
[TEXT_AREA
];
2221 /* Restore the contents of frame F's current frame matrix from SAVED,
2222 and free memory associated with SAVED. */
2225 restore_current_matrix (f
, saved
)
2227 struct glyph_matrix
*saved
;
2231 for (i
= 0; i
< saved
->nrows
; ++i
)
2233 struct glyph_row
*from
= saved
->rows
+ i
;
2234 struct glyph_row
*to
= f
->current_matrix
->rows
+ i
;
2235 size_t nbytes
= from
->used
[TEXT_AREA
] * sizeof (struct glyph
);
2236 bcopy (from
->glyphs
[TEXT_AREA
], to
->glyphs
[TEXT_AREA
], nbytes
);
2237 to
->used
[TEXT_AREA
] = from
->used
[TEXT_AREA
];
2238 xfree (from
->glyphs
[TEXT_AREA
]);
2241 xfree (saved
->rows
);
2247 /* Allocate/reallocate glyph matrices of a single frame F for
2248 frame-based redisplay. */
2251 adjust_frame_glyphs_for_frame_redisplay (f
)
2255 struct dim matrix_dim
;
2257 int window_change_flags
;
2260 if (!FRAME_LIVE_P (f
))
2263 /* Determine the smallest character in any font for F. On
2264 console windows, all characters have dimension (1, 1). */
2265 ch_dim
.width
= ch_dim
.height
= 1;
2267 top_window_y
= FRAME_TOP_MARGIN (f
);
2269 /* Allocate glyph pool structures if not already done. */
2270 if (f
->desired_pool
== NULL
)
2272 f
->desired_pool
= new_glyph_pool ();
2273 f
->current_pool
= new_glyph_pool ();
2276 /* Allocate frames matrix structures if needed. */
2277 if (f
->desired_matrix
== NULL
)
2279 f
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
2280 f
->current_matrix
= new_glyph_matrix (f
->current_pool
);
2283 /* Compute window glyph matrices. (This takes the mini-buffer
2284 window into account). The result is the size of the frame glyph
2285 matrix needed. The variable window_change_flags is set to a bit
2286 mask indicating whether new matrices will be allocated or
2287 existing matrices change their size or location within the frame
2289 window_change_flags
= 0;
2291 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2294 &window_change_flags
);
2296 /* Add in menu bar lines, if any. */
2297 matrix_dim
.height
+= top_window_y
;
2299 /* Enlarge pools as necessary. */
2300 pool_changed_p
= realloc_glyph_pool (f
->desired_pool
, matrix_dim
);
2301 realloc_glyph_pool (f
->current_pool
, matrix_dim
);
2303 /* Set up glyph pointers within window matrices. Do this only if
2304 absolutely necessary since it requires a frame redraw. */
2305 if (pool_changed_p
|| window_change_flags
)
2307 /* Do it for window matrices. */
2308 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2310 &window_change_flags
);
2312 /* Size of frame matrices must equal size of frame. Note
2313 that we are called for X frames with window widths NOT equal
2314 to the frame width (from CHANGE_FRAME_SIZE_1). */
2315 xassert (matrix_dim
.width
== FRAME_COLS (f
)
2316 && matrix_dim
.height
== FRAME_LINES (f
));
2318 /* Pointers to glyph memory in glyph rows are exchanged during
2319 the update phase of redisplay, which means in general that a
2320 frame's current matrix consists of pointers into both the
2321 desired and current glyph pool of the frame. Adjusting a
2322 matrix sets the frame matrix up so that pointers are all into
2323 the same pool. If we want to preserve glyph contents of the
2324 current matrix over a call to adjust_glyph_matrix, we must
2325 make a copy of the current glyphs, and restore the current
2326 matrix' contents from that copy. */
2327 if (display_completed
2328 && !FRAME_GARBAGED_P (f
)
2329 && matrix_dim
.width
== f
->current_matrix
->matrix_w
2330 && matrix_dim
.height
== f
->current_matrix
->matrix_h
)
2332 struct glyph_matrix
*copy
= save_current_matrix (f
);
2333 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2334 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2335 restore_current_matrix (f
, copy
);
2336 fake_current_matrices (FRAME_ROOT_WINDOW (f
));
2340 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2341 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2342 SET_FRAME_GARBAGED (f
);
2348 /* Allocate/reallocate glyph matrices of a single frame F for
2349 window-based redisplay. */
2352 adjust_frame_glyphs_for_window_redisplay (f
)
2358 xassert (FRAME_WINDOW_P (f
) && FRAME_LIVE_P (f
));
2360 /* Get minimum sizes. */
2361 #ifdef HAVE_WINDOW_SYSTEM
2362 ch_dim
.width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2363 ch_dim
.height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
2365 ch_dim
.width
= ch_dim
.height
= 1;
2368 /* Allocate/reallocate window matrices. */
2369 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2371 /* Allocate/ reallocate matrices of the dummy window used to display
2372 the menu bar under X when no X toolkit support is available. */
2373 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
2375 /* Allocate a dummy window if not already done. */
2376 if (NILP (f
->menu_bar_window
))
2378 f
->menu_bar_window
= make_window ();
2379 w
= XWINDOW (f
->menu_bar_window
);
2380 XSETFRAME (w
->frame
, f
);
2381 w
->pseudo_window_p
= 1;
2384 w
= XWINDOW (f
->menu_bar_window
);
2386 /* Set window dimensions to frame dimensions and allocate or
2387 adjust glyph matrices of W. */
2388 XSETFASTINT (w
->top_line
, 0);
2389 XSETFASTINT (w
->left_col
, 0);
2390 XSETFASTINT (w
->total_lines
, FRAME_MENU_BAR_LINES (f
));
2391 XSETFASTINT (w
->total_cols
, FRAME_TOTAL_COLS (f
));
2392 allocate_matrices_for_window_redisplay (w
);
2394 #endif /* not USE_X_TOOLKIT */
2397 /* Allocate/ reallocate matrices of the tool bar window. If we
2398 don't have a tool bar window yet, make one. */
2399 if (NILP (f
->tool_bar_window
))
2401 f
->tool_bar_window
= make_window ();
2402 w
= XWINDOW (f
->tool_bar_window
);
2403 XSETFRAME (w
->frame
, f
);
2404 w
->pseudo_window_p
= 1;
2407 w
= XWINDOW (f
->tool_bar_window
);
2409 XSETFASTINT (w
->top_line
, FRAME_MENU_BAR_LINES (f
));
2410 XSETFASTINT (w
->left_col
, 0);
2411 XSETFASTINT (w
->total_lines
, FRAME_TOOL_BAR_LINES (f
));
2412 XSETFASTINT (w
->total_cols
, FRAME_TOTAL_COLS (f
));
2413 allocate_matrices_for_window_redisplay (w
);
2418 /* Adjust/ allocate message buffer of frame F.
2420 Note that the message buffer is never freed. Since I could not
2421 find a free in 19.34, I assume that freeing it would be
2422 problematic in some way and don't do it either.
2424 (Implementation note: It should be checked if we can free it
2425 eventually without causing trouble). */
2428 adjust_frame_message_buffer (f
)
2431 int size
= FRAME_MESSAGE_BUF_SIZE (f
) + 1;
2433 if (FRAME_MESSAGE_BUF (f
))
2435 char *buffer
= FRAME_MESSAGE_BUF (f
);
2436 char *new_buffer
= (char *) xrealloc (buffer
, size
);
2437 FRAME_MESSAGE_BUF (f
) = new_buffer
;
2440 FRAME_MESSAGE_BUF (f
) = (char *) xmalloc (size
);
2444 /* Re-allocate buffer for decode_mode_spec on frame F. */
2447 adjust_decode_mode_spec_buffer (f
)
2450 f
->decode_mode_spec_buffer
2451 = (char *) xrealloc (f
->decode_mode_spec_buffer
,
2452 FRAME_MESSAGE_BUF_SIZE (f
) + 1);
2457 /**********************************************************************
2458 Freeing Glyph Matrices
2459 **********************************************************************/
2461 /* Free glyph memory for a frame F. F may be null. This function can
2462 be called for the same frame more than once. The root window of
2463 F may be nil when this function is called. This is the case when
2464 the function is called when F is destroyed. */
2470 if (f
&& f
->glyphs_initialized_p
)
2472 /* Block interrupt input so that we don't get surprised by an X
2473 event while we're in an inconsistent state. */
2475 f
->glyphs_initialized_p
= 0;
2477 /* Release window sub-matrices. */
2478 if (!NILP (f
->root_window
))
2479 free_window_matrices (XWINDOW (f
->root_window
));
2481 /* Free the dummy window for menu bars without X toolkit and its
2483 if (!NILP (f
->menu_bar_window
))
2485 struct window
*w
= XWINDOW (f
->menu_bar_window
);
2486 free_glyph_matrix (w
->desired_matrix
);
2487 free_glyph_matrix (w
->current_matrix
);
2488 w
->desired_matrix
= w
->current_matrix
= NULL
;
2489 f
->menu_bar_window
= Qnil
;
2492 /* Free the tool bar window and its glyph matrices. */
2493 if (!NILP (f
->tool_bar_window
))
2495 struct window
*w
= XWINDOW (f
->tool_bar_window
);
2496 free_glyph_matrix (w
->desired_matrix
);
2497 free_glyph_matrix (w
->current_matrix
);
2498 w
->desired_matrix
= w
->current_matrix
= NULL
;
2499 f
->tool_bar_window
= Qnil
;
2502 /* Release frame glyph matrices. Reset fields to zero in
2503 case we are called a second time. */
2504 if (f
->desired_matrix
)
2506 free_glyph_matrix (f
->desired_matrix
);
2507 free_glyph_matrix (f
->current_matrix
);
2508 f
->desired_matrix
= f
->current_matrix
= NULL
;
2511 /* Release glyph pools. */
2512 if (f
->desired_pool
)
2514 free_glyph_pool (f
->desired_pool
);
2515 free_glyph_pool (f
->current_pool
);
2516 f
->desired_pool
= f
->current_pool
= NULL
;
2524 /* Free glyph sub-matrices in the window tree rooted at W. This
2525 function may be called with a null pointer, and it may be called on
2526 the same tree more than once. */
2529 free_window_matrices (w
)
2534 if (!NILP (w
->hchild
))
2535 free_window_matrices (XWINDOW (w
->hchild
));
2536 else if (!NILP (w
->vchild
))
2537 free_window_matrices (XWINDOW (w
->vchild
));
2540 /* This is a leaf window. Free its memory and reset fields
2541 to zero in case this function is called a second time for
2543 free_glyph_matrix (w
->current_matrix
);
2544 free_glyph_matrix (w
->desired_matrix
);
2545 w
->current_matrix
= w
->desired_matrix
= NULL
;
2548 /* Next window on same level. */
2549 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2554 /* Check glyph memory leaks. This function is called from
2555 shut_down_emacs. Note that frames are not destroyed when Emacs
2556 exits. We therefore free all glyph memory for all active frames
2557 explicitly and check that nothing is left allocated. */
2560 check_glyph_memory ()
2562 Lisp_Object tail
, frame
;
2564 /* Free glyph memory for all frames. */
2565 FOR_EACH_FRAME (tail
, frame
)
2566 free_glyphs (XFRAME (frame
));
2568 /* Check that nothing is left allocated. */
2569 if (glyph_matrix_count
)
2571 if (glyph_pool_count
)
2577 /**********************************************************************
2578 Building a Frame Matrix
2579 **********************************************************************/
2581 /* Most of the redisplay code works on glyph matrices attached to
2582 windows. This is a good solution most of the time, but it is not
2583 suitable for terminal code. Terminal output functions cannot rely
2584 on being able to set an arbitrary terminal window. Instead they
2585 must be provided with a view of the whole frame, i.e. the whole
2586 screen. We build such a view by constructing a frame matrix from
2587 window matrices in this section.
2589 Windows that must be updated have their must_be_update_p flag set.
2590 For all such windows, their desired matrix is made part of the
2591 desired frame matrix. For other windows, their current matrix is
2592 made part of the desired frame matrix.
2594 +-----------------+----------------+
2595 | desired | desired |
2597 +-----------------+----------------+
2600 +----------------------------------+
2602 Desired window matrices can be made part of the frame matrix in a
2603 cheap way: We exploit the fact that the desired frame matrix and
2604 desired window matrices share their glyph memory. This is not
2605 possible for current window matrices. Their glyphs are copied to
2606 the desired frame matrix. The latter is equivalent to
2607 preserve_other_columns in the old redisplay.
2609 Used glyphs counters for frame matrix rows are the result of adding
2610 up glyph lengths of the window matrices. A line in the frame
2611 matrix is enabled, if a corresponding line in a window matrix is
2614 After building the desired frame matrix, it will be passed to
2615 terminal code, which will manipulate both the desired and current
2616 frame matrix. Changes applied to the frame's current matrix have
2617 to be visible in current window matrices afterwards, of course.
2619 This problem is solved like this:
2621 1. Window and frame matrices share glyphs. Window matrices are
2622 constructed in a way that their glyph contents ARE the glyph
2623 contents needed in a frame matrix. Thus, any modification of
2624 glyphs done in terminal code will be reflected in window matrices
2627 2. Exchanges of rows in a frame matrix done by terminal code are
2628 intercepted by hook functions so that corresponding row operations
2629 on window matrices can be performed. This is necessary because we
2630 use pointers to glyphs in glyph row structures. To satisfy the
2631 assumption of point 1 above that glyphs are updated implicitly in
2632 window matrices when they are manipulated via the frame matrix,
2633 window and frame matrix must of course agree where to find the
2634 glyphs for their rows. Possible manipulations that must be
2635 mirrored are assignments of rows of the desired frame matrix to the
2636 current frame matrix and scrolling the current frame matrix. */
2638 /* Build frame F's desired matrix from window matrices. Only windows
2639 which have the flag must_be_updated_p set have to be updated. Menu
2640 bar lines of a frame are not covered by window matrices, so make
2641 sure not to touch them in this function. */
2644 build_frame_matrix (f
)
2649 /* F must have a frame matrix when this function is called. */
2650 xassert (!FRAME_WINDOW_P (f
));
2652 /* Clear all rows in the frame matrix covered by window matrices.
2653 Menu bar lines are not covered by windows. */
2654 for (i
= FRAME_TOP_MARGIN (f
); i
< f
->desired_matrix
->nrows
; ++i
)
2655 clear_glyph_row (MATRIX_ROW (f
->desired_matrix
, i
));
2657 /* Build the matrix by walking the window tree. */
2658 build_frame_matrix_from_window_tree (f
->desired_matrix
,
2659 XWINDOW (FRAME_ROOT_WINDOW (f
)));
2663 /* Walk a window tree, building a frame matrix MATRIX from window
2664 matrices. W is the root of a window tree. */
2667 build_frame_matrix_from_window_tree (matrix
, w
)
2668 struct glyph_matrix
*matrix
;
2673 if (!NILP (w
->hchild
))
2674 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->hchild
));
2675 else if (!NILP (w
->vchild
))
2676 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->vchild
));
2678 build_frame_matrix_from_leaf_window (matrix
, w
);
2680 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2685 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2686 desired frame matrix built. W is a leaf window whose desired or
2687 current matrix is to be added to FRAME_MATRIX. W's flag
2688 must_be_updated_p determines which matrix it contributes to
2689 FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix
2690 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2691 Adding a desired matrix means setting up used counters and such in
2692 frame rows, while adding a current window matrix to FRAME_MATRIX
2693 means copying glyphs. The latter case corresponds to
2694 preserve_other_columns in the old redisplay. */
2697 build_frame_matrix_from_leaf_window (frame_matrix
, w
)
2698 struct glyph_matrix
*frame_matrix
;
2701 struct glyph_matrix
*window_matrix
;
2702 int window_y
, frame_y
;
2703 /* If non-zero, a glyph to insert at the right border of W. */
2704 GLYPH right_border_glyph
= 0;
2706 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2707 if (w
->must_be_updated_p
)
2709 window_matrix
= w
->desired_matrix
;
2711 /* Decide whether we want to add a vertical border glyph. */
2712 if (!WINDOW_RIGHTMOST_P (w
))
2714 struct Lisp_Char_Table
*dp
= window_display_table (w
);
2715 right_border_glyph
= (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
2716 ? XINT (DISP_BORDER_GLYPH (dp
))
2721 window_matrix
= w
->current_matrix
;
2723 /* For all rows in the window matrix and corresponding rows in the
2726 frame_y
= window_matrix
->matrix_y
;
2727 while (window_y
< window_matrix
->nrows
)
2729 struct glyph_row
*frame_row
= frame_matrix
->rows
+ frame_y
;
2730 struct glyph_row
*window_row
= window_matrix
->rows
+ window_y
;
2731 int current_row_p
= window_matrix
== w
->current_matrix
;
2733 /* Fill up the frame row with spaces up to the left margin of the
2735 fill_up_frame_row_with_spaces (frame_row
, window_matrix
->matrix_x
);
2737 /* Fill up areas in the window matrix row with spaces. */
2738 fill_up_glyph_row_with_spaces (window_row
);
2740 /* If only part of W's desired matrix has been built, and
2741 window_row wasn't displayed, use the corresponding current
2743 if (window_matrix
== w
->desired_matrix
2744 && !window_row
->enabled_p
)
2746 window_row
= w
->current_matrix
->rows
+ window_y
;
2752 /* Copy window row to frame row. */
2753 bcopy (window_row
->glyphs
[0],
2754 frame_row
->glyphs
[TEXT_AREA
] + window_matrix
->matrix_x
,
2755 window_matrix
->matrix_w
* sizeof (struct glyph
));
2759 xassert (window_row
->enabled_p
);
2761 /* Only when a desired row has been displayed, we want
2762 the corresponding frame row to be updated. */
2763 frame_row
->enabled_p
= 1;
2765 /* Maybe insert a vertical border between horizontally adjacent
2767 if (right_border_glyph
)
2769 struct glyph
*border
= window_row
->glyphs
[LAST_AREA
] - 1;
2770 SET_CHAR_GLYPH_FROM_GLYPH (*border
, right_border_glyph
);
2773 /* Window row window_y must be a slice of frame row
2775 xassert (glyph_row_slice_p (window_row
, frame_row
));
2777 /* If rows are in sync, we don't have to copy glyphs because
2778 frame and window share glyphs. */
2781 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
2782 add_window_display_history (w
, w
->current_matrix
->method
, 0);
2786 /* Set number of used glyphs in the frame matrix. Since we fill
2787 up with spaces, and visit leaf windows from left to right it
2788 can be done simply. */
2789 frame_row
->used
[TEXT_AREA
]
2790 = window_matrix
->matrix_x
+ window_matrix
->matrix_w
;
2799 /* Add spaces to a glyph row ROW in a window matrix.
2801 Each row has the form:
2803 +---------+-----------------------------+------------+
2804 | left | text | right |
2805 +---------+-----------------------------+------------+
2807 Left and right marginal areas are optional. This function adds
2808 spaces to areas so that there are no empty holes between areas.
2809 In other words: If the right area is not empty, the text area
2810 is filled up with spaces up to the right area. If the text area
2811 is not empty, the left area is filled up.
2813 To be called for frame-based redisplay, only. */
2816 fill_up_glyph_row_with_spaces (row
)
2817 struct glyph_row
*row
;
2819 fill_up_glyph_row_area_with_spaces (row
, LEFT_MARGIN_AREA
);
2820 fill_up_glyph_row_area_with_spaces (row
, TEXT_AREA
);
2821 fill_up_glyph_row_area_with_spaces (row
, RIGHT_MARGIN_AREA
);
2825 /* Fill area AREA of glyph row ROW with spaces. To be called for
2826 frame-based redisplay only. */
2829 fill_up_glyph_row_area_with_spaces (row
, area
)
2830 struct glyph_row
*row
;
2833 if (row
->glyphs
[area
] < row
->glyphs
[area
+ 1])
2835 struct glyph
*end
= row
->glyphs
[area
+ 1];
2836 struct glyph
*text
= row
->glyphs
[area
] + row
->used
[area
];
2839 *text
++ = space_glyph
;
2840 row
->used
[area
] = text
- row
->glyphs
[area
];
2845 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2846 reached. In frame matrices only one area, TEXT_AREA, is used. */
2849 fill_up_frame_row_with_spaces (row
, upto
)
2850 struct glyph_row
*row
;
2853 int i
= row
->used
[TEXT_AREA
];
2854 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
2857 glyph
[i
++] = space_glyph
;
2859 row
->used
[TEXT_AREA
] = i
;
2864 /**********************************************************************
2865 Mirroring operations on frame matrices in window matrices
2866 **********************************************************************/
2868 /* Set frame being updated via frame-based redisplay to F. This
2869 function must be called before updates to make explicit that we are
2870 working on frame matrices or not. */
2873 set_frame_matrix_frame (f
)
2876 frame_matrix_frame
= f
;
2880 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2881 DESIRED_MATRIX is the desired matrix corresponding to
2882 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2883 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2884 frame_matrix_frame is non-null, this indicates that the exchange is
2885 done in frame matrices, and that we have to perform analogous
2886 operations in window matrices of frame_matrix_frame. */
2889 make_current (desired_matrix
, current_matrix
, row
)
2890 struct glyph_matrix
*desired_matrix
, *current_matrix
;
2893 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, row
);
2894 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, row
);
2895 int mouse_face_p
= current_row
->mouse_face_p
;
2897 /* Do current_row = desired_row. This exchanges glyph pointers
2898 between both rows, and does a structure assignment otherwise. */
2899 assign_row (current_row
, desired_row
);
2901 /* Enable current_row to mark it as valid. */
2902 current_row
->enabled_p
= 1;
2903 current_row
->mouse_face_p
= mouse_face_p
;
2905 /* If we are called on frame matrices, perform analogous operations
2906 for window matrices. */
2907 if (frame_matrix_frame
)
2908 mirror_make_current (XWINDOW (frame_matrix_frame
->root_window
), row
);
2912 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2913 W's frame which has been made current (by swapping pointers between
2914 current and desired matrix). Perform analogous operations in the
2915 matrices of leaf windows in the window tree rooted at W. */
2918 mirror_make_current (w
, frame_row
)
2924 if (!NILP (w
->hchild
))
2925 mirror_make_current (XWINDOW (w
->hchild
), frame_row
);
2926 else if (!NILP (w
->vchild
))
2927 mirror_make_current (XWINDOW (w
->vchild
), frame_row
);
2930 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2931 here because the checks performed in debug mode there
2932 will not allow the conversion. */
2933 int row
= frame_row
- w
->desired_matrix
->matrix_y
;
2935 /* If FRAME_ROW is within W, assign the desired row to the
2936 current row (exchanging glyph pointers). */
2937 if (row
>= 0 && row
< w
->desired_matrix
->matrix_h
)
2939 struct glyph_row
*current_row
2940 = MATRIX_ROW (w
->current_matrix
, row
);
2941 struct glyph_row
*desired_row
2942 = MATRIX_ROW (w
->desired_matrix
, row
);
2944 if (desired_row
->enabled_p
)
2945 assign_row (current_row
, desired_row
);
2947 swap_glyph_pointers (desired_row
, current_row
);
2948 current_row
->enabled_p
= 1;
2952 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2957 /* Perform row dance after scrolling. We are working on the range of
2958 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2959 including) in MATRIX. COPY_FROM is a vector containing, for each
2960 row I in the range 0 <= I < NLINES, the index of the original line
2961 to move to I. This index is relative to the row range, i.e. 0 <=
2962 index < NLINES. RETAINED_P is a vector containing zero for each
2963 row 0 <= I < NLINES which is empty.
2965 This function is called from do_scrolling and do_direct_scrolling. */
2968 mirrored_line_dance (matrix
, unchanged_at_top
, nlines
, copy_from
,
2970 struct glyph_matrix
*matrix
;
2971 int unchanged_at_top
, nlines
;
2975 /* A copy of original rows. */
2976 struct glyph_row
*old_rows
;
2978 /* Rows to assign to. */
2979 struct glyph_row
*new_rows
= MATRIX_ROW (matrix
, unchanged_at_top
);
2983 /* Make a copy of the original rows. */
2984 old_rows
= (struct glyph_row
*) alloca (nlines
* sizeof *old_rows
);
2985 bcopy (new_rows
, old_rows
, nlines
* sizeof *old_rows
);
2987 /* Assign new rows, maybe clear lines. */
2988 for (i
= 0; i
< nlines
; ++i
)
2990 int enabled_before_p
= new_rows
[i
].enabled_p
;
2992 xassert (i
+ unchanged_at_top
< matrix
->nrows
);
2993 xassert (unchanged_at_top
+ copy_from
[i
] < matrix
->nrows
);
2994 new_rows
[i
] = old_rows
[copy_from
[i
]];
2995 new_rows
[i
].enabled_p
= enabled_before_p
;
2997 /* RETAINED_P is zero for empty lines. */
2998 if (!retained_p
[copy_from
[i
]])
2999 new_rows
[i
].enabled_p
= 0;
3002 /* Do the same for window matrices, if MATRIX is a frame matrix. */
3003 if (frame_matrix_frame
)
3004 mirror_line_dance (XWINDOW (frame_matrix_frame
->root_window
),
3005 unchanged_at_top
, nlines
, copy_from
, retained_p
);
3009 /* Synchronize glyph pointers in the current matrix of window W with
3010 the current frame matrix. */
3013 sync_window_with_frame_matrix_rows (w
)
3016 struct frame
*f
= XFRAME (w
->frame
);
3017 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
3018 int left
, right
, x
, width
;
3020 /* Preconditions: W must be a leaf window on a tty frame. */
3021 xassert (NILP (w
->hchild
) && NILP (w
->vchild
));
3022 xassert (!FRAME_WINDOW_P (f
));
3024 left
= margin_glyphs_to_reserve (w
, 1, w
->left_margin_cols
);
3025 right
= margin_glyphs_to_reserve (w
, 1, w
->right_margin_cols
);
3026 x
= w
->current_matrix
->matrix_x
;
3027 width
= w
->current_matrix
->matrix_w
;
3029 window_row
= w
->current_matrix
->rows
;
3030 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
3031 frame_row
= f
->current_matrix
->rows
+ WINDOW_TOP_EDGE_LINE (w
);
3033 for (; window_row
< window_row_end
; ++window_row
, ++frame_row
)
3035 window_row
->glyphs
[LEFT_MARGIN_AREA
]
3036 = frame_row
->glyphs
[0] + x
;
3037 window_row
->glyphs
[TEXT_AREA
]
3038 = window_row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
3039 window_row
->glyphs
[LAST_AREA
]
3040 = window_row
->glyphs
[LEFT_MARGIN_AREA
] + width
;
3041 window_row
->glyphs
[RIGHT_MARGIN_AREA
]
3042 = window_row
->glyphs
[LAST_AREA
] - right
;
3047 /* Return the window in the window tree rooted in W containing frame
3048 row ROW. Value is null if none is found. */
3051 frame_row_to_window (w
, row
)
3055 struct window
*found
= NULL
;
3059 if (!NILP (w
->hchild
))
3060 found
= frame_row_to_window (XWINDOW (w
->hchild
), row
);
3061 else if (!NILP (w
->vchild
))
3062 found
= frame_row_to_window (XWINDOW (w
->vchild
), row
);
3063 else if (row
>= WINDOW_TOP_EDGE_LINE (w
)
3064 && row
< WINDOW_BOTTOM_EDGE_LINE (w
))
3067 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3074 /* Perform a line dance in the window tree rooted at W, after
3075 scrolling a frame matrix in mirrored_line_dance.
3077 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
3078 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
3079 COPY_FROM is a vector containing, for each row I in the range 0 <=
3080 I < NLINES, the index of the original line to move to I. This
3081 index is relative to the row range, i.e. 0 <= index < NLINES.
3082 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
3086 mirror_line_dance (w
, unchanged_at_top
, nlines
, copy_from
, retained_p
)
3088 int unchanged_at_top
, nlines
;
3094 if (!NILP (w
->hchild
))
3095 mirror_line_dance (XWINDOW (w
->hchild
), unchanged_at_top
,
3096 nlines
, copy_from
, retained_p
);
3097 else if (!NILP (w
->vchild
))
3098 mirror_line_dance (XWINDOW (w
->vchild
), unchanged_at_top
,
3099 nlines
, copy_from
, retained_p
);
3102 /* W is a leaf window, and we are working on its current
3104 struct glyph_matrix
*m
= w
->current_matrix
;
3106 struct glyph_row
*old_rows
;
3108 /* Make a copy of the original rows of matrix m. */
3109 old_rows
= (struct glyph_row
*) alloca (m
->nrows
* sizeof *old_rows
);
3110 bcopy (m
->rows
, old_rows
, m
->nrows
* sizeof *old_rows
);
3112 for (i
= 0; i
< nlines
; ++i
)
3114 /* Frame relative line assigned to. */
3115 int frame_to
= i
+ unchanged_at_top
;
3117 /* Frame relative line assigned. */
3118 int frame_from
= copy_from
[i
] + unchanged_at_top
;
3120 /* Window relative line assigned to. */
3121 int window_to
= frame_to
- m
->matrix_y
;
3123 /* Window relative line assigned. */
3124 int window_from
= frame_from
- m
->matrix_y
;
3126 /* Is assigned line inside window? */
3127 int from_inside_window_p
3128 = window_from
>= 0 && window_from
< m
->matrix_h
;
3130 /* Is assigned to line inside window? */
3131 int to_inside_window_p
3132 = window_to
>= 0 && window_to
< m
->matrix_h
;
3134 if (from_inside_window_p
&& to_inside_window_p
)
3136 /* Enabled setting before assignment. */
3137 int enabled_before_p
;
3139 /* Do the assignment. The enabled_p flag is saved
3140 over the assignment because the old redisplay did
3142 enabled_before_p
= m
->rows
[window_to
].enabled_p
;
3143 m
->rows
[window_to
] = old_rows
[window_from
];
3144 m
->rows
[window_to
].enabled_p
= enabled_before_p
;
3146 /* If frame line is empty, window line is empty, too. */
3147 if (!retained_p
[copy_from
[i
]])
3148 m
->rows
[window_to
].enabled_p
= 0;
3150 else if (to_inside_window_p
)
3152 /* A copy between windows. This is an infrequent
3153 case not worth optimizing. */
3154 struct frame
*f
= XFRAME (w
->frame
);
3155 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3157 struct glyph_matrix
*m2
;
3160 w2
= frame_row_to_window (root
, frame_to
);
3161 m2
= w2
->current_matrix
;
3162 m2_from
= frame_from
- m2
->matrix_y
;
3163 copy_row_except_pointers (m
->rows
+ window_to
,
3164 m2
->rows
+ m2_from
);
3166 /* If frame line is empty, window line is empty, too. */
3167 if (!retained_p
[copy_from
[i
]])
3168 m
->rows
[window_to
].enabled_p
= 0;
3171 else if (from_inside_window_p
)
3175 /* If there was a copy between windows, make sure glyph
3176 pointers are in sync with the frame matrix. */
3178 sync_window_with_frame_matrix_rows (w
);
3180 /* Check that no pointers are lost. */
3184 /* Next window on same level. */
3185 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3192 /* Check that window and frame matrices agree about their
3193 understanding where glyphs of the rows are to find. For each
3194 window in the window tree rooted at W, check that rows in the
3195 matrices of leaf window agree with their frame matrices about
3199 check_window_matrix_pointers (w
)
3204 if (!NILP (w
->hchild
))
3205 check_window_matrix_pointers (XWINDOW (w
->hchild
));
3206 else if (!NILP (w
->vchild
))
3207 check_window_matrix_pointers (XWINDOW (w
->vchild
));
3210 struct frame
*f
= XFRAME (w
->frame
);
3211 check_matrix_pointers (w
->desired_matrix
, f
->desired_matrix
);
3212 check_matrix_pointers (w
->current_matrix
, f
->current_matrix
);
3215 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3220 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
3221 a window and FRAME_MATRIX is the corresponding frame matrix. For
3222 each row in WINDOW_MATRIX check that it's a slice of the
3223 corresponding frame row. If it isn't, abort. */
3226 check_matrix_pointers (window_matrix
, frame_matrix
)
3227 struct glyph_matrix
*window_matrix
, *frame_matrix
;
3229 /* Row number in WINDOW_MATRIX. */
3232 /* Row number corresponding to I in FRAME_MATRIX. */
3233 int j
= window_matrix
->matrix_y
;
3235 /* For all rows check that the row in the window matrix is a
3236 slice of the row in the frame matrix. If it isn't we didn't
3237 mirror an operation on the frame matrix correctly. */
3238 while (i
< window_matrix
->nrows
)
3240 if (!glyph_row_slice_p (window_matrix
->rows
+ i
,
3241 frame_matrix
->rows
+ j
))
3247 #endif /* GLYPH_DEBUG != 0 */
3251 /**********************************************************************
3252 VPOS and HPOS translations
3253 **********************************************************************/
3257 /* Translate vertical position VPOS which is relative to window W to a
3258 vertical position relative to W's frame. */
3261 window_to_frame_vpos (w
, vpos
)
3265 struct frame
*f
= XFRAME (w
->frame
);
3267 xassert (!FRAME_WINDOW_P (f
));
3268 xassert (vpos
>= 0 && vpos
<= w
->desired_matrix
->nrows
);
3269 vpos
+= WINDOW_TOP_EDGE_LINE (w
);
3270 xassert (vpos
>= 0 && vpos
<= FRAME_LINES (f
));
3275 /* Translate horizontal position HPOS which is relative to window W to
3276 a horizontal position relative to W's frame. */
3279 window_to_frame_hpos (w
, hpos
)
3283 struct frame
*f
= XFRAME (w
->frame
);
3285 xassert (!FRAME_WINDOW_P (f
));
3286 hpos
+= WINDOW_LEFT_EDGE_COL (w
);
3290 #endif /* GLYPH_DEBUG */
3294 /**********************************************************************
3296 **********************************************************************/
3298 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
3299 doc
: /* Clear frame FRAME and output again what is supposed to appear on it. */)
3305 CHECK_LIVE_FRAME (frame
);
3308 /* Ignore redraw requests, if frame has no glyphs yet.
3309 (Implementation note: It still has to be checked why we are
3310 called so early here). */
3311 if (!glyphs_initialized_initially_p
)
3315 if (FRAME_MSDOS_P (f
))
3316 set_terminal_modes ();
3318 clear_current_matrices (f
);
3320 fflush (TTY_OUTPUT (FRAME_TTY (f
)));
3321 windows_or_buffers_changed
++;
3322 /* Mark all windows as inaccurate, so that every window will have
3323 its redisplay done. */
3324 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
3325 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
3331 /* Redraw frame F. This is nothing more than a call to the Lisp
3332 function redraw-frame. */
3339 XSETFRAME (frame
, f
);
3340 Fredraw_frame (frame
);
3344 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
3345 doc
: /* Clear and redisplay all visible frames. */)
3348 Lisp_Object tail
, frame
;
3350 FOR_EACH_FRAME (tail
, frame
)
3351 if (FRAME_VISIBLE_P (XFRAME (frame
)))
3352 Fredraw_frame (frame
);
3358 /* This is used when frame_garbaged is set. Call Fredraw_frame on all
3359 visible frames marked as garbaged. */
3362 redraw_garbaged_frames ()
3364 Lisp_Object tail
, frame
;
3366 FOR_EACH_FRAME (tail
, frame
)
3367 if (FRAME_VISIBLE_P (XFRAME (frame
))
3368 && FRAME_GARBAGED_P (XFRAME (frame
)))
3369 Fredraw_frame (frame
);
3374 /***********************************************************************
3376 ***********************************************************************/
3378 /* Try to update display and current glyph matrix directly.
3380 This function is called after a character G has been inserted into
3381 current_buffer. It tries to update the current glyph matrix and
3382 perform appropriate screen output to reflect the insertion. If it
3383 succeeds, the global flag redisplay_performed_directly_p will be
3384 set to 1, and thereby prevent the more costly general redisplay
3385 from running (see redisplay_internal).
3387 This function is not called for `hairy' character insertions.
3388 In particular, it is not called when after or before change
3389 functions exist, like they are used by font-lock. See keyboard.c
3390 for details where this function is called. */
3393 direct_output_for_insert (g
)
3396 register struct frame
*f
= SELECTED_FRAME ();
3397 struct window
*w
= XWINDOW (selected_window
);
3399 struct glyph_row
*glyph_row
;
3400 struct glyph
*glyphs
, *glyph
, *end
;
3402 /* Non-null means that redisplay of W is based on window matrices. */
3403 int window_redisplay_p
= FRAME_WINDOW_P (f
);
3404 /* Non-null means we are in overwrite mode. */
3405 int overwrite_p
= !NILP (current_buffer
->overwrite_mode
);
3407 struct text_pos pos
;
3408 int delta
, delta_bytes
;
3410 /* Not done directly. */
3411 redisplay_performed_directly_p
= 0;
3413 /* Quickly give up for some common cases. */
3414 if (cursor_in_echo_area
3415 /* Give up if fonts have changed. */
3417 /* Give up if face attributes have been changed. */
3418 || face_change_count
3419 /* Give up if cursor position not really known. */
3420 || !display_completed
3421 /* Give up if buffer appears in two places. */
3422 || buffer_shared
> 1
3423 /* Give up if currently displaying a message instead of the
3424 minibuffer contents. */
3425 || (EQ (selected_window
, minibuf_window
)
3426 && EQ (minibuf_window
, echo_area_window
))
3427 /* Give up for hscrolled mini-buffer because display of the prompt
3428 is handled specially there (see display_line). */
3429 || (MINI_WINDOW_P (w
) && XFASTINT (w
->hscroll
))
3430 /* Give up if overwriting in the middle of a line. */
3433 && FETCH_BYTE (PT
) != '\n')
3434 /* Give up for tabs and line ends. */
3438 /* Give up if unable to display the cursor in the window. */
3439 || w
->cursor
.vpos
< 0
3440 /* Give up if we are showing a message or just cleared the message
3441 because we might need to resize the echo area window. */
3442 || !NILP (echo_area_buffer
[0])
3443 || !NILP (echo_area_buffer
[1])
3444 || (glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
),
3445 /* Can't do it in a continued line because continuation
3446 lines would change. */
3447 (glyph_row
->continued_p
3448 /* Can't use this method if the line overlaps others or is
3449 overlapped by others because these other lines would
3450 have to be redisplayed. */
3451 || glyph_row
->overlapping_p
3452 || glyph_row
->overlapped_p
))
3453 /* Can't do it for partial width windows on terminal frames
3454 because we can't clear to eol in such a window. */
3455 || (!window_redisplay_p
&& !WINDOW_FULL_WIDTH_P (w
)))
3458 /* If we can't insert glyphs, we can use this method only
3459 at the end of a line. */
3460 if (!TTY_CHAR_INS_DEL_OK (FRAME_TTY (f
)))
3461 if (PT
!= ZV
&& FETCH_BYTE (PT_BYTE
) != '\n')
3464 /* Set up a display iterator structure for W. Glyphs will be
3465 produced in scratch_glyph_row. Current position is W's cursor
3467 clear_glyph_row (&scratch_glyph_row
);
3468 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
3469 DEC_TEXT_POS (pos
, !NILP (current_buffer
->enable_multibyte_characters
));
3470 init_iterator (&it
, w
, CHARPOS (pos
), BYTEPOS (pos
), &scratch_glyph_row
,
3473 glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3474 if (glyph_row
->mouse_face_p
)
3477 /* Give up if highlighting trailing whitespace and we have trailing
3478 whitespace in glyph_row. We would have to remove the trailing
3479 whitespace face in that case. */
3480 if (!NILP (Vshow_trailing_whitespace
)
3481 && glyph_row
->used
[TEXT_AREA
])
3485 last
= glyph_row
->glyphs
[TEXT_AREA
] + glyph_row
->used
[TEXT_AREA
] - 1;
3486 if (last
->type
== STRETCH_GLYPH
3487 || (last
->type
== CHAR_GLYPH
3488 && last
->u
.ch
== ' '))
3492 /* Give up if there are overlay strings at pos. This would fail
3493 if the overlay string has newlines in it. */
3494 if (STRINGP (it
.string
))
3497 it
.hpos
= w
->cursor
.hpos
;
3498 it
.vpos
= w
->cursor
.vpos
;
3499 it
.current_x
= w
->cursor
.x
+ it
.first_visible_x
;
3500 it
.current_y
= w
->cursor
.y
;
3501 it
.end_charpos
= PT
;
3502 it
.stop_charpos
= min (PT
, it
.stop_charpos
);
3503 it
.stop_charpos
= max (IT_CHARPOS (it
), it
.stop_charpos
);
3505 /* More than one display element may be returned for PT - 1 if
3506 (i) it's a control character which is translated into `\003' or
3507 `^C', or (ii) it has a display table entry, or (iii) it's a
3508 combination of both. */
3509 delta
= delta_bytes
= 0;
3510 while (get_next_display_element (&it
))
3512 PRODUCE_GLYPHS (&it
);
3514 /* Give up if glyph doesn't fit completely on the line. */
3515 if (it
.current_x
>= it
.last_visible_x
)
3518 /* Give up if new glyph has different ascent or descent than
3519 the original row, or if it is not a character glyph. */
3520 if (glyph_row
->ascent
!= it
.ascent
3521 || glyph_row
->height
!= it
.ascent
+ it
.descent
3522 || glyph_row
->phys_ascent
!= it
.phys_ascent
3523 || glyph_row
->phys_height
!= it
.phys_ascent
+ it
.phys_descent
3524 || it
.what
!= IT_CHARACTER
)
3528 delta_bytes
+= it
.len
;
3529 set_iterator_to_next (&it
, 1);
3532 /* Give up if we hit the right edge of the window. We would have
3533 to insert truncation or continuation glyphs. */
3534 added_width
= it
.current_x
- (w
->cursor
.x
+ it
.first_visible_x
);
3535 if (glyph_row
->pixel_width
+ added_width
>= it
.last_visible_x
)
3538 /* Give up if there is a \t following in the line. */
3540 it2
.end_charpos
= ZV
;
3541 it2
.stop_charpos
= min (it2
.stop_charpos
, ZV
);
3542 while (get_next_display_element (&it2
)
3543 && !ITERATOR_AT_END_OF_LINE_P (&it2
))
3547 set_iterator_to_next (&it2
, 1);
3550 /* Number of new glyphs produced. */
3551 n
= it
.glyph_row
->used
[TEXT_AREA
];
3553 /* Start and end of glyphs in original row. */
3554 glyphs
= glyph_row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
3555 end
= glyph_row
->glyphs
[1 + TEXT_AREA
];
3557 /* Make room for new glyphs, then insert them. */
3558 xassert (end
- glyphs
- n
>= 0);
3559 safe_bcopy ((char *) glyphs
, (char *) (glyphs
+ n
),
3560 (end
- glyphs
- n
) * sizeof (*end
));
3561 bcopy (it
.glyph_row
->glyphs
[TEXT_AREA
], glyphs
, n
* sizeof *glyphs
);
3562 glyph_row
->used
[TEXT_AREA
] = min (glyph_row
->used
[TEXT_AREA
] + n
,
3563 end
- glyph_row
->glyphs
[TEXT_AREA
]);
3565 /* Compute new line width. */
3566 glyph
= glyph_row
->glyphs
[TEXT_AREA
];
3567 end
= glyph
+ glyph_row
->used
[TEXT_AREA
];
3568 glyph_row
->pixel_width
= glyph_row
->x
;
3571 glyph_row
->pixel_width
+= glyph
->pixel_width
;
3575 /* Increment buffer positions for glyphs following the newly
3577 for (glyph
= glyphs
+ n
; glyph
< end
; ++glyph
)
3578 if (glyph
->charpos
> 0 && BUFFERP (glyph
->object
))
3579 glyph
->charpos
+= delta
;
3581 if (MATRIX_ROW_END_CHARPOS (glyph_row
) > 0)
3583 MATRIX_ROW_END_CHARPOS (glyph_row
) += delta
;
3584 MATRIX_ROW_END_BYTEPOS (glyph_row
) += delta_bytes
;
3587 /* Adjust positions in lines following the one we are in. */
3588 increment_matrix_positions (w
->current_matrix
,
3590 w
->current_matrix
->nrows
,
3591 delta
, delta_bytes
);
3593 glyph_row
->contains_overlapping_glyphs_p
3594 |= it
.glyph_row
->contains_overlapping_glyphs_p
;
3596 glyph_row
->displays_text_p
= 1;
3597 w
->window_end_vpos
= make_number (max (w
->cursor
.vpos
,
3598 XFASTINT (w
->window_end_vpos
)));
3600 if (!NILP (Vshow_trailing_whitespace
))
3601 highlight_trailing_whitespace (it
.f
, glyph_row
);
3603 /* Write glyphs. If at end of row, we can simply call write_glyphs.
3604 In the middle, we have to insert glyphs. Note that this is now
3605 implemented for X frames. The implementation uses updated_window
3607 updated_row
= glyph_row
;
3608 updated_area
= TEXT_AREA
;
3612 rif
->update_window_begin_hook (w
);
3614 if (glyphs
== end
- n
3615 /* In front of a space added by append_space. */
3616 || (glyphs
== end
- n
- 1
3617 && (end
- n
)->charpos
<= 0))
3618 rif
->write_glyphs (glyphs
, n
);
3620 rif
->insert_glyphs (glyphs
, n
);
3624 if (glyphs
== end
- n
)
3625 write_glyphs (glyphs
, n
);
3627 insert_glyphs (glyphs
, n
);
3630 w
->cursor
.hpos
+= n
;
3631 w
->cursor
.x
= it
.current_x
- it
.first_visible_x
;
3632 xassert (w
->cursor
.hpos
>= 0
3633 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3635 /* How to set the cursor differs depending on whether we are
3636 using a frame matrix or a window matrix. Note that when
3637 a frame matrix is used, cursor_to expects frame coordinates,
3638 and the X and Y parameters are not used. */
3639 if (window_redisplay_p
)
3640 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3641 w
->cursor
.y
, w
->cursor
.x
);
3645 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3646 + (INTEGERP (w
->left_margin_cols
)
3647 ? XFASTINT (w
->left_margin_cols
)
3649 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3654 rif
->update_window_end_hook (w
, 1, 0);
3657 fflush (TTY_OUTPUT (CURTTY ()));
3659 TRACE ((stderr
, "direct output for insert\n"));
3660 mark_window_display_accurate (it
.window
, 1);
3661 redisplay_performed_directly_p
= 1;
3666 /* Perform a direct display update for moving PT by N positions
3667 left or right. N < 0 means a movement backwards. This function
3668 is currently only called for N == 1 or N == -1. */
3671 direct_output_forward_char (n
)
3674 struct frame
*f
= SELECTED_FRAME ();
3675 struct window
*w
= XWINDOW (selected_window
);
3676 struct glyph_row
*row
;
3678 /* Give up if point moved out of or into a composition. */
3679 if (check_point_in_composition (current_buffer
, XINT (w
->last_point
),
3680 current_buffer
, PT
))
3683 /* Give up if face attributes have been changed. */
3684 if (face_change_count
)
3687 /* Give up if current matrix is not up to date or we are
3688 displaying a message. */
3689 if (!display_completed
|| cursor_in_echo_area
)
3692 /* Give up if the buffer's direction is reversed. */
3693 if (!NILP (XBUFFER (w
->buffer
)->direction_reversed
))
3696 /* Can't use direct output if highlighting a region. */
3697 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
3700 /* Can't use direct output if highlighting trailing whitespace. */
3701 if (!NILP (Vshow_trailing_whitespace
))
3704 /* Give up if we are showing a message or just cleared the message
3705 because we might need to resize the echo area window. */
3706 if (!NILP (echo_area_buffer
[0]) || !NILP (echo_area_buffer
[1]))
3709 /* Give up if currently displaying a message instead of the
3710 minibuffer contents. */
3711 if (XWINDOW (minibuf_window
) == w
3712 && EQ (minibuf_window
, echo_area_window
))
3715 /* Give up if we don't know where the cursor is. */
3716 if (w
->cursor
.vpos
< 0)
3719 row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3721 /* Give up if PT is outside of the last known cursor row. */
3722 if (PT
<= MATRIX_ROW_START_CHARPOS (row
)
3723 || PT
>= MATRIX_ROW_END_CHARPOS (row
))
3726 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
3728 w
->last_cursor
= w
->cursor
;
3729 XSETFASTINT (w
->last_point
, PT
);
3731 xassert (w
->cursor
.hpos
>= 0
3732 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3734 if (FRAME_WINDOW_P (f
))
3735 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3736 w
->cursor
.y
, w
->cursor
.x
);
3740 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3741 + (INTEGERP (w
->left_margin_cols
)
3742 ? XFASTINT (w
->left_margin_cols
)
3744 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3748 fflush (TTY_OUTPUT (CURTTY ()));
3749 redisplay_performed_directly_p
= 1;
3755 /***********************************************************************
3757 ***********************************************************************/
3759 /* Update frame F based on the data in desired matrices.
3761 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3762 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3765 Value is non-zero if redisplay was stopped due to pending input. */
3768 update_frame (f
, force_p
, inhibit_hairy_id_p
)
3771 int inhibit_hairy_id_p
;
3773 /* 1 means display has been paused because of pending input. */
3775 struct window
*root_window
= XWINDOW (f
->root_window
);
3777 if (FRAME_WINDOW_P (f
))
3779 /* We are working on window matrix basis. All windows whose
3780 flag must_be_updated_p is set have to be updated. */
3782 /* Record that we are not working on frame matrices. */
3783 set_frame_matrix_frame (NULL
);
3785 /* Update all windows in the window tree of F, maybe stopping
3786 when pending input is detected. */
3789 /* Update the menu bar on X frames that don't have toolkit
3791 if (WINDOWP (f
->menu_bar_window
))
3792 update_window (XWINDOW (f
->menu_bar_window
), 1);
3794 /* Update the tool-bar window, if present. */
3795 if (WINDOWP (f
->tool_bar_window
))
3797 struct window
*w
= XWINDOW (f
->tool_bar_window
);
3799 /* Update tool-bar window. */
3800 if (w
->must_be_updated_p
)
3804 update_window (w
, 1);
3805 w
->must_be_updated_p
= 0;
3807 /* Swap tool-bar strings. We swap because we want to
3809 tem
= f
->current_tool_bar_string
;
3810 f
->current_tool_bar_string
= f
->desired_tool_bar_string
;
3811 f
->desired_tool_bar_string
= tem
;
3816 /* Update windows. */
3817 paused_p
= update_window_tree (root_window
, force_p
);
3820 #if 0 /* This flush is a performance bottleneck under X,
3821 and it doesn't seem to be necessary anyway. */
3822 rif
->flush_display (f
);
3827 /* We are working on frame matrix basis. Set the frame on whose
3828 frame matrix we operate. */
3829 set_frame_matrix_frame (f
);
3831 /* Build F's desired matrix from window matrices. */
3832 build_frame_matrix (f
);
3834 /* Update the display */
3836 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3839 if (TTY_TERMSCRIPT (FRAME_TTY (f
)))
3840 fflush (TTY_TERMSCRIPT (FRAME_TTY (f
)));
3841 fflush (TTY_OUTPUT (FRAME_TTY (f
)));
3843 /* Check window matrices for lost pointers. */
3845 check_window_matrix_pointers (root_window
);
3846 add_frame_display_history (f
, paused_p
);
3850 /* Reset flags indicating that a window should be updated. */
3851 set_window_update_flags (root_window
, 0);
3853 display_completed
= !paused_p
;
3859 /************************************************************************
3860 Window-based updates
3861 ************************************************************************/
3863 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3864 don't stop updating when input is pending. */
3867 update_window_tree (w
, force_p
)
3873 while (w
&& !paused_p
)
3875 if (!NILP (w
->hchild
))
3876 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
3877 else if (!NILP (w
->vchild
))
3878 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
3879 else if (w
->must_be_updated_p
)
3880 paused_p
|= update_window (w
, force_p
);
3882 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3889 /* Update window W if its flag must_be_updated_p is non-zero. If
3890 FORCE_P is non-zero, don't stop updating if input is pending. */
3893 update_single_window (w
, force_p
)
3897 if (w
->must_be_updated_p
)
3899 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3901 /* Record that this is not a frame-based redisplay. */
3902 set_frame_matrix_frame (NULL
);
3906 update_window (w
, force_p
);
3909 /* Reset flag in W. */
3910 w
->must_be_updated_p
= 0;
3915 /* Redraw lines from the current matrix of window W that are
3916 overlapped by other rows. YB is bottom-most y-position in W. */
3919 redraw_overlapped_rows (w
, yb
)
3925 /* If rows overlapping others have been changed, the rows being
3926 overlapped have to be redrawn. This won't draw lines that have
3927 already been drawn in update_window_line because overlapped_p in
3928 desired rows is 0, so after row assignment overlapped_p in
3929 current rows is 0. */
3930 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3932 struct glyph_row
*row
= w
->current_matrix
->rows
+ i
;
3934 if (!row
->enabled_p
)
3936 else if (row
->mode_line_p
)
3939 if (row
->overlapped_p
)
3941 enum glyph_row_area area
;
3943 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3946 updated_area
= area
;
3947 rif
->cursor_to (i
, 0, row
->y
, area
== TEXT_AREA
? row
->x
: 0);
3948 if (row
->used
[area
])
3949 rif
->write_glyphs (row
->glyphs
[area
], row
->used
[area
]);
3950 rif
->clear_end_of_line (-1);
3953 row
->overlapped_p
= 0;
3956 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3962 /* Redraw lines from the current matrix of window W that overlap
3963 others. YB is bottom-most y-position in W. */
3966 redraw_overlapping_rows (w
, yb
)
3971 struct glyph_row
*row
;
3973 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3975 row
= w
->current_matrix
->rows
+ i
;
3977 if (!row
->enabled_p
)
3979 else if (row
->mode_line_p
)
3982 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3984 if (row
->overlapping_p
&& i
> 0 && bottom_y
< yb
)
3986 if (row
->used
[LEFT_MARGIN_AREA
])
3987 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
);
3989 if (row
->used
[TEXT_AREA
])
3990 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
);
3992 if (row
->used
[RIGHT_MARGIN_AREA
])
3993 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
);
3995 /* Record in neighbour rows that ROW overwrites part of their
3997 if (row
->phys_ascent
> row
->ascent
&& i
> 0)
3998 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3999 if ((row
->phys_height
- row
->phys_ascent
4000 > row
->height
- row
->ascent
)
4002 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
4013 /* Check that no row in the current matrix of window W is enabled
4014 which is below what's displayed in the window. */
4017 check_current_matrix_flags (w
)
4020 int last_seen_p
= 0;
4021 int i
, yb
= window_text_bottom_y (w
);
4023 for (i
= 0; i
< w
->current_matrix
->nrows
- 1; ++i
)
4025 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
4026 if (!last_seen_p
&& MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4028 else if (last_seen_p
&& row
->enabled_p
)
4033 #endif /* GLYPH_DEBUG */
4036 /* Update display of window W. FORCE_P non-zero means that we should
4037 not stop when detecting pending input. */
4040 update_window (w
, force_p
)
4044 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4046 int preempt_count
= baud_rate
/ 2400 + 1;
4047 extern int input_pending
;
4048 extern Lisp_Object do_mouse_tracking
;
4050 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4053 /* Check that W's frame doesn't have glyph matrices. */
4054 xassert (FRAME_WINDOW_P (f
));
4055 xassert (updating_frame
!= NULL
);
4057 /* Check pending input the first time so that we can quickly return. */
4058 if (redisplay_dont_pause
)
4061 detect_input_pending ();
4063 /* If forced to complete the update, or if no input is pending, do
4065 if (force_p
|| !input_pending
|| !NILP (do_mouse_tracking
))
4067 struct glyph_row
*row
, *end
;
4068 struct glyph_row
*mode_line_row
;
4069 struct glyph_row
*header_line_row
;
4070 int yb
, changed_p
= 0, mouse_face_overwritten_p
= 0, n_updated
;
4072 rif
->update_window_begin_hook (w
);
4073 yb
= window_text_bottom_y (w
);
4075 /* If window has a header line, update it before everything else.
4076 Adjust y-positions of other rows by the header line height. */
4077 row
= desired_matrix
->rows
;
4078 end
= row
+ desired_matrix
->nrows
- 1;
4080 if (row
->mode_line_p
)
4082 header_line_row
= row
;
4086 header_line_row
= NULL
;
4088 /* Update the mode line, if necessary. */
4089 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
4090 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
4092 mode_line_row
->y
= yb
;
4093 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
4095 &mouse_face_overwritten_p
);
4099 /* Find first enabled row. Optimizations in redisplay_internal
4100 may lead to an update with only one row enabled. There may
4101 be also completely empty matrices. */
4102 while (row
< end
&& !row
->enabled_p
)
4105 /* Try reusing part of the display by copying. */
4106 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
4108 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
4111 /* All rows were found to be equal. */
4116 /* We've scrolled the display. */
4121 /* Update the header line after scrolling because a new header
4122 line would otherwise overwrite lines at the top of the window
4123 that can be scrolled. */
4124 if (header_line_row
&& header_line_row
->enabled_p
)
4126 header_line_row
->y
= 0;
4127 update_window_line (w
, 0, &mouse_face_overwritten_p
);
4131 /* Update the rest of the lines. */
4132 for (n_updated
= 0; row
< end
&& (force_p
|| !input_pending
); ++row
)
4135 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
4138 /* We'll have to play a little bit with when to
4139 detect_input_pending. If it's done too often,
4140 scrolling large windows with repeated scroll-up
4141 commands will too quickly pause redisplay. */
4142 if (!force_p
&& ++n_updated
% preempt_count
== 0)
4143 detect_input_pending ();
4145 changed_p
|= update_window_line (w
, vpos
,
4146 &mouse_face_overwritten_p
);
4148 /* Mark all rows below the last visible one in the current
4149 matrix as invalid. This is necessary because of
4150 variable line heights. Consider the case of three
4151 successive redisplays, where the first displays 5
4152 lines, the second 3 lines, and the third 5 lines again.
4153 If the second redisplay wouldn't mark rows in the
4154 current matrix invalid, the third redisplay might be
4155 tempted to optimize redisplay based on lines displayed
4156 in the first redisplay. */
4157 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4158 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
4159 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
4162 /* Was display preempted? */
4163 paused_p
= row
< end
;
4167 /* Fix the appearance of overlapping/overlapped rows. */
4168 if (!paused_p
&& !w
->pseudo_window_p
)
4170 if (changed_p
&& rif
->fix_overlapping_area
)
4172 redraw_overlapped_rows (w
, yb
);
4173 redraw_overlapping_rows (w
, yb
);
4176 /* Make cursor visible at cursor position of W. */
4177 set_window_cursor_after_update (w
);
4179 #if 0 /* Check that current matrix invariants are satisfied. This is
4180 for debugging only. See the comment of check_matrix_invariants. */
4181 IF_DEBUG (check_matrix_invariants (w
));
4186 /* Remember the redisplay method used to display the matrix. */
4187 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
4190 /* End the update of window W. Don't set the cursor if we
4191 paused updating the display because in this case,
4192 set_window_cursor_after_update hasn't been called, and
4193 output_cursor doesn't contain the cursor location. */
4194 rif
->update_window_end_hook (w
, !paused_p
, mouse_face_overwritten_p
);
4200 /* check_current_matrix_flags (w); */
4201 add_window_display_history (w
, w
->current_matrix
->method
, paused_p
);
4204 clear_glyph_matrix (desired_matrix
);
4210 /* Update the display of area AREA in window W, row number VPOS.
4211 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
4214 update_marginal_area (w
, area
, vpos
)
4218 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
4220 /* Let functions in xterm.c know what area subsequent X positions
4221 will be relative to. */
4222 updated_area
= area
;
4224 /* Set cursor to start of glyphs, write them, and clear to the end
4225 of the area. I don't think that something more sophisticated is
4226 necessary here, since marginal areas will not be the default. */
4227 rif
->cursor_to (vpos
, 0, desired_row
->y
, 0);
4228 if (desired_row
->used
[area
])
4229 rif
->write_glyphs (desired_row
->glyphs
[area
], desired_row
->used
[area
]);
4230 rif
->clear_end_of_line (-1);
4234 /* Update the display of the text area of row VPOS in window W.
4235 Value is non-zero if display has changed. */
4238 update_text_area (w
, vpos
)
4242 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
4243 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
4246 /* Let functions in xterm.c know what area subsequent X positions
4247 will be relative to. */
4248 updated_area
= TEXT_AREA
;
4250 /* If rows are at different X or Y, or rows have different height,
4251 or the current row is marked invalid, write the entire line. */
4252 if (!current_row
->enabled_p
4253 || desired_row
->y
!= current_row
->y
4254 || desired_row
->ascent
!= current_row
->ascent
4255 || desired_row
->phys_ascent
!= current_row
->phys_ascent
4256 || desired_row
->phys_height
!= current_row
->phys_height
4257 || desired_row
->visible_height
!= current_row
->visible_height
4258 || current_row
->overlapped_p
4259 || current_row
->mouse_face_p
4260 || current_row
->x
!= desired_row
->x
)
4262 rif
->cursor_to (vpos
, 0, desired_row
->y
, desired_row
->x
);
4264 if (desired_row
->used
[TEXT_AREA
])
4265 rif
->write_glyphs (desired_row
->glyphs
[TEXT_AREA
],
4266 desired_row
->used
[TEXT_AREA
]);
4268 /* Clear to end of window. */
4269 rif
->clear_end_of_line (-1);
4272 /* This erases the cursor. We do this here because
4273 notice_overwritten_cursor cannot easily check this, which
4274 might indicate that the whole functionality of
4275 notice_overwritten_cursor would better be implemented here.
4276 On the other hand, we need notice_overwritten_cursor as long
4277 as mouse highlighting is done asynchronously outside of
4279 if (vpos
== w
->phys_cursor
.vpos
)
4280 w
->phys_cursor_on_p
= 0;
4285 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
4286 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
4287 int overlapping_glyphs_p
= current_row
->contains_overlapping_glyphs_p
;
4288 int desired_stop_pos
= desired_row
->used
[TEXT_AREA
];
4290 /* If the desired row extends its face to the text area end,
4291 make sure we write at least one glyph, so that the face
4292 extension actually takes place. */
4293 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
4296 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
4300 /* Loop over glyphs that current and desired row may have
4306 /* Skip over glyphs that both rows have in common. These
4307 don't have to be written. We can't skip if the last
4308 current glyph overlaps the glyph to its right. For
4309 example, consider a current row of `if ' with the `f' in
4310 Courier bold so that it overlaps the ` ' to its right.
4311 If the desired row is ` ', we would skip over the space
4312 after the `if' and there would remain a pixel from the
4313 `f' on the screen. */
4314 if (overlapping_glyphs_p
&& i
> 0)
4316 struct glyph
*glyph
= ¤t_row
->glyphs
[TEXT_AREA
][i
- 1];
4319 rif
->get_glyph_overhangs (glyph
, XFRAME (w
->frame
),
4321 can_skip_p
= right
== 0;
4327 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
4329 x
+= desired_glyph
->pixel_width
;
4330 ++desired_glyph
, ++current_glyph
, ++i
;
4333 /* Consider the case that the current row contains "xxx
4334 ppp ggg" in italic Courier font, and the desired row
4335 is "xxx ggg". The character `p' has lbearing, `g'
4336 has not. The loop above will stop in front of the
4337 first `p' in the current row. If we would start
4338 writing glyphs there, we wouldn't erase the lbearing
4339 of the `p'. The rest of the lbearing problem is then
4340 taken care of by draw_glyphs. */
4341 if (overlapping_glyphs_p
4343 && i
< current_row
->used
[TEXT_AREA
]
4344 && (current_row
->used
[TEXT_AREA
]
4345 != desired_row
->used
[TEXT_AREA
]))
4349 rif
->get_glyph_overhangs (current_glyph
, XFRAME (w
->frame
),
4351 while (left
> 0 && i
> 0)
4353 --i
, --desired_glyph
, --current_glyph
;
4354 x
-= desired_glyph
->pixel_width
;
4355 left
-= desired_glyph
->pixel_width
;
4360 /* Try to avoid writing the entire rest of the desired row
4361 by looking for a resync point. This mainly prevents
4362 mode line flickering in the case the mode line is in
4363 fixed-pitch font, which it usually will be. */
4364 if (i
< desired_row
->used
[TEXT_AREA
])
4366 int start_x
= x
, start_hpos
= i
;
4367 struct glyph
*start
= desired_glyph
;
4369 int skip_first_p
= !can_skip_p
;
4371 /* Find the next glyph that's equal again. */
4374 || !GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
4377 x
+= desired_glyph
->pixel_width
;
4378 current_x
+= current_glyph
->pixel_width
;
4379 ++desired_glyph
, ++current_glyph
, ++i
;
4383 if (i
== start_hpos
|| x
!= current_x
)
4387 desired_glyph
= start
;
4391 rif
->cursor_to (vpos
, start_hpos
, desired_row
->y
, start_x
);
4392 rif
->write_glyphs (start
, i
- start_hpos
);
4397 /* Write the rest. */
4398 if (i
< desired_row
->used
[TEXT_AREA
])
4400 rif
->cursor_to (vpos
, i
, desired_row
->y
, x
);
4401 rif
->write_glyphs (desired_glyph
, desired_row
->used
[TEXT_AREA
] - i
);
4405 /* Maybe clear to end of line. */
4406 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
4408 /* If new row extends to the end of the text area, nothing
4409 has to be cleared, if and only if we did a write_glyphs
4410 above. This is made sure by setting desired_stop_pos
4411 appropriately above. */
4412 xassert (i
< desired_row
->used
[TEXT_AREA
]);
4414 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
4416 /* If old row extends to the end of the text area, clear. */
4417 if (i
>= desired_row
->used
[TEXT_AREA
])
4418 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4419 desired_row
->pixel_width
);
4420 rif
->clear_end_of_line (-1);
4423 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
4425 /* Otherwise clear to the end of the old row. Everything
4426 after that position should be clear already. */
4429 if (i
>= desired_row
->used
[TEXT_AREA
])
4430 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4431 desired_row
->pixel_width
);
4433 /* If cursor is displayed at the end of the line, make sure
4434 it's cleared. Nowadays we don't have a phys_cursor_glyph
4435 with which to erase the cursor (because this method
4436 doesn't work with lbearing/rbearing), so we must do it
4438 if (vpos
== w
->phys_cursor
.vpos
4439 && w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])
4441 w
->phys_cursor_on_p
= 0;
4445 x
= current_row
->pixel_width
;
4446 rif
->clear_end_of_line (x
);
4455 /* Update row VPOS in window W. Value is non-zero if display has been
4459 update_window_line (w
, vpos
, mouse_face_overwritten_p
)
4461 int vpos
, *mouse_face_overwritten_p
;
4463 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
4464 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
4467 /* Set the row being updated. This is important to let xterm.c
4468 know what line height values are in effect. */
4469 updated_row
= desired_row
;
4471 /* A row can be completely invisible in case a desired matrix was
4472 built with a vscroll and then make_cursor_line_fully_visible shifts
4473 the matrix. Make sure to make such rows current anyway, since
4474 we need the correct y-position, for example, in the current matrix. */
4475 if (desired_row
->mode_line_p
4476 || desired_row
->visible_height
> 0)
4478 xassert (desired_row
->enabled_p
);
4480 /* Update display of the left margin area, if there is one. */
4481 if (!desired_row
->full_width_p
4482 && !NILP (w
->left_margin_cols
))
4485 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
4488 /* Update the display of the text area. */
4489 if (update_text_area (w
, vpos
))
4492 if (current_row
->mouse_face_p
)
4493 *mouse_face_overwritten_p
= 1;
4496 /* Update display of the right margin area, if there is one. */
4497 if (!desired_row
->full_width_p
4498 && !NILP (w
->right_margin_cols
))
4501 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
4504 /* Draw truncation marks etc. */
4505 if (!current_row
->enabled_p
4506 || desired_row
->y
!= current_row
->y
4507 || desired_row
->visible_height
!= current_row
->visible_height
4508 || desired_row
->overlay_arrow_p
!= current_row
->overlay_arrow_p
4509 || desired_row
->truncated_on_left_p
!= current_row
->truncated_on_left_p
4510 || desired_row
->truncated_on_right_p
!= current_row
->truncated_on_right_p
4511 || desired_row
->continued_p
!= current_row
->continued_p
4512 || desired_row
->mode_line_p
!= current_row
->mode_line_p
4513 || (desired_row
->indicate_empty_line_p
4514 != current_row
->indicate_empty_line_p
)
4515 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
4516 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
4517 rif
->after_update_window_line_hook (desired_row
);
4520 /* Update current_row from desired_row. */
4521 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4527 /* Set the cursor after an update of window W. This function may only
4528 be called from update_window. */
4531 set_window_cursor_after_update (w
)
4534 struct frame
*f
= XFRAME (w
->frame
);
4535 int cx
, cy
, vpos
, hpos
;
4537 /* Not intended for frame matrix updates. */
4538 xassert (FRAME_WINDOW_P (f
));
4540 if (cursor_in_echo_area
4541 && !NILP (echo_area_buffer
[0])
4542 /* If we are showing a message instead of the mini-buffer,
4543 show the cursor for the message instead. */
4544 && XWINDOW (minibuf_window
) == w
4545 && EQ (minibuf_window
, echo_area_window
)
4546 /* These cases apply only to the frame that contains
4547 the active mini-buffer window. */
4548 && FRAME_HAS_MINIBUF_P (f
)
4549 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4551 cx
= cy
= vpos
= hpos
= 0;
4553 if (cursor_in_echo_area
>= 0)
4555 /* If the mini-buffer is several lines high, find the last
4556 line that has any text on it. Note: either all lines
4557 are enabled or none. Otherwise we wouldn't be able to
4559 struct glyph_row
*row
, *last_row
;
4560 struct glyph
*glyph
;
4561 int yb
= window_text_bottom_y (w
);
4564 row
= w
->current_matrix
->rows
;
4565 while (row
->enabled_p
4566 && (last_row
== NULL
4567 || MATRIX_ROW_BOTTOM_Y (row
) <= yb
))
4569 if (row
->used
[TEXT_AREA
]
4570 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4577 struct glyph
*start
= last_row
->glyphs
[TEXT_AREA
];
4578 struct glyph
*last
= start
+ last_row
->used
[TEXT_AREA
] - 1;
4580 while (last
> start
&& last
->charpos
< 0)
4583 for (glyph
= start
; glyph
< last
; ++glyph
)
4585 cx
+= glyph
->pixel_width
;
4590 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4598 hpos
= w
->cursor
.hpos
;
4599 vpos
= w
->cursor
.vpos
;
4602 /* Window cursor can be out of sync for horizontally split windows. */
4603 hpos
= max (0, hpos
);
4604 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4605 vpos
= max (0, vpos
);
4606 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4607 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4611 /* Set WINDOW->must_be_updated_p to ON_P for all windows in the window
4612 tree rooted at W. */
4615 set_window_update_flags (w
, on_p
)
4621 if (!NILP (w
->hchild
))
4622 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4623 else if (!NILP (w
->vchild
))
4624 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4626 w
->must_be_updated_p
= on_p
;
4628 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4634 /***********************************************************************
4635 Window-Based Scrolling
4636 ***********************************************************************/
4638 /* Structure describing rows in scrolling_window. */
4642 /* Number of occurrences of this row in desired and current matrix. */
4643 int old_uses
, new_uses
;
4645 /* Vpos of row in new matrix. */
4646 int new_line_number
;
4648 /* Bucket index of this row_entry in the hash table row_table. */
4651 /* The row described by this entry. */
4652 struct glyph_row
*row
;
4654 /* Hash collision chain. */
4655 struct row_entry
*next
;
4658 /* A pool to allocate row_entry structures from, and the size of the
4659 pool. The pool is reallocated in scrolling_window when we find
4660 that we need a larger one. */
4662 static struct row_entry
*row_entry_pool
;
4663 static int row_entry_pool_size
;
4665 /* Index of next free entry in row_entry_pool. */
4667 static int row_entry_idx
;
4669 /* The hash table used during scrolling, and the table's size. This
4670 table is used to quickly identify equal rows in the desired and
4673 static struct row_entry
**row_table
;
4674 static int row_table_size
;
4676 /* Vectors of pointers to row_entry structures belonging to the
4677 current and desired matrix, and the size of the vectors. */
4679 static struct row_entry
**old_lines
, **new_lines
;
4680 static int old_lines_size
, new_lines_size
;
4682 /* A pool to allocate run structures from, and its size. */
4684 static struct run
*run_pool
;
4685 static int runs_size
;
4687 /* A vector of runs of lines found during scrolling. */
4689 static struct run
**runs
;
4691 /* Add glyph row ROW to the scrolling hash table during the scrolling
4694 static INLINE
struct row_entry
*
4695 add_row_entry (w
, row
)
4697 struct glyph_row
*row
;
4699 struct row_entry
*entry
;
4700 int i
= row
->hash
% row_table_size
;
4702 entry
= row_table
[i
];
4703 while (entry
&& !row_equal_p (w
, entry
->row
, row
, 1))
4704 entry
= entry
->next
;
4708 entry
= row_entry_pool
+ row_entry_idx
++;
4710 entry
->old_uses
= entry
->new_uses
= 0;
4711 entry
->new_line_number
= 0;
4713 entry
->next
= row_table
[i
];
4714 row_table
[i
] = entry
;
4721 /* Try to reuse part of the current display of W by scrolling lines.
4722 HEADER_LINE_P non-zero means W has a header line.
4724 The algorithm is taken from Communications of the ACM, Apr78 "A
4725 Technique for Isolating Differences Between Files." It should take
4728 A short outline of the steps of the algorithm
4730 1. Skip lines equal at the start and end of both matrices.
4732 2. Enter rows in the current and desired matrix into a symbol
4733 table, counting how often they appear in both matrices.
4735 3. Rows that appear exactly once in both matrices serve as anchors,
4736 i.e. we assume that such lines are likely to have been moved.
4738 4. Starting from anchor lines, extend regions to be scrolled both
4739 forward and backward.
4743 -1 if all rows were found to be equal.
4744 0 to indicate that we did not scroll the display, or
4745 1 if we did scroll. */
4748 scrolling_window (w
, header_line_p
)
4752 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4753 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4754 int yb
= window_text_bottom_y (w
);
4755 int i
, j
, first_old
, first_new
, last_old
, last_new
;
4756 int nruns
, nbytes
, n
, run_idx
;
4757 struct row_entry
*entry
;
4759 /* Skip over rows equal at the start. */
4760 for (i
= header_line_p
? 1 : 0; i
< current_matrix
->nrows
- 1; ++i
)
4762 struct glyph_row
*d
= MATRIX_ROW (desired_matrix
, i
);
4763 struct glyph_row
*c
= MATRIX_ROW (current_matrix
, i
);
4768 && MATRIX_ROW_BOTTOM_Y (c
) <= yb
4769 && MATRIX_ROW_BOTTOM_Y (d
) <= yb
4770 && row_equal_p (w
, c
, d
, 1))
4779 /* Give up if some rows in the desired matrix are not enabled. */
4780 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4783 first_old
= first_new
= i
;
4785 /* Set last_new to the index + 1 of the last enabled row in the
4788 while (i
< desired_matrix
->nrows
- 1
4789 && MATRIX_ROW (desired_matrix
, i
)->enabled_p
4790 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) <= yb
)
4793 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4798 /* Set last_old to the index + 1 of the last enabled row in the
4799 current matrix. We don't look at the enabled flag here because
4800 we plan to reuse part of the display even if other parts are
4803 while (i
< current_matrix
->nrows
- 1)
4805 int bottom
= MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
));
4814 /* Skip over rows equal at the bottom. */
4817 while (i
- 1 > first_new
4818 && j
- 1 > first_old
4819 && MATRIX_ROW (current_matrix
, i
- 1)->enabled_p
4820 && (MATRIX_ROW (current_matrix
, i
- 1)->y
4821 == MATRIX_ROW (desired_matrix
, j
- 1)->y
)
4823 MATRIX_ROW (desired_matrix
, i
- 1),
4824 MATRIX_ROW (current_matrix
, j
- 1), 1))
4829 /* Nothing to do if all rows are equal. */
4830 if (last_new
== first_new
)
4833 /* Reallocate vectors, tables etc. if necessary. */
4835 if (current_matrix
->nrows
> old_lines_size
)
4837 old_lines_size
= current_matrix
->nrows
;
4838 nbytes
= old_lines_size
* sizeof *old_lines
;
4839 old_lines
= (struct row_entry
**) xrealloc (old_lines
, nbytes
);
4842 if (desired_matrix
->nrows
> new_lines_size
)
4844 new_lines_size
= desired_matrix
->nrows
;
4845 nbytes
= new_lines_size
* sizeof *new_lines
;
4846 new_lines
= (struct row_entry
**) xrealloc (new_lines
, nbytes
);
4849 n
= desired_matrix
->nrows
+ current_matrix
->nrows
;
4850 if (3 * n
> row_table_size
)
4852 row_table_size
= next_almost_prime (3 * n
);
4853 nbytes
= row_table_size
* sizeof *row_table
;
4854 row_table
= (struct row_entry
**) xrealloc (row_table
, nbytes
);
4855 bzero (row_table
, nbytes
);
4858 if (n
> row_entry_pool_size
)
4860 row_entry_pool_size
= n
;
4861 nbytes
= row_entry_pool_size
* sizeof *row_entry_pool
;
4862 row_entry_pool
= (struct row_entry
*) xrealloc (row_entry_pool
, nbytes
);
4865 if (desired_matrix
->nrows
> runs_size
)
4867 runs_size
= desired_matrix
->nrows
;
4868 nbytes
= runs_size
* sizeof *runs
;
4869 runs
= (struct run
**) xrealloc (runs
, nbytes
);
4870 nbytes
= runs_size
* sizeof *run_pool
;
4871 run_pool
= (struct run
*) xrealloc (run_pool
, nbytes
);
4874 nruns
= run_idx
= 0;
4877 /* Add rows from the current and desired matrix to the hash table
4878 row_hash_table to be able to find equal ones quickly. */
4880 for (i
= first_old
; i
< last_old
; ++i
)
4882 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4884 entry
= add_row_entry (w
, MATRIX_ROW (current_matrix
, i
));
4885 old_lines
[i
] = entry
;
4889 old_lines
[i
] = NULL
;
4892 for (i
= first_new
; i
< last_new
; ++i
)
4894 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4895 entry
= add_row_entry (w
, MATRIX_ROW (desired_matrix
, i
));
4897 entry
->new_line_number
= i
;
4898 new_lines
[i
] = entry
;
4901 /* Identify moves based on lines that are unique and equal
4902 in both matrices. */
4903 for (i
= first_old
; i
< last_old
;)
4905 && old_lines
[i
]->old_uses
== 1
4906 && old_lines
[i
]->new_uses
== 1)
4909 int new_line
= old_lines
[i
]->new_line_number
;
4910 struct run
*run
= run_pool
+ run_idx
++;
4913 run
->current_vpos
= i
;
4914 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4915 run
->desired_vpos
= new_line
;
4916 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4918 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4920 /* Extend backward. */
4923 while (j
> first_old
4925 && old_lines
[j
] == new_lines
[k
])
4927 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4928 --run
->current_vpos
;
4929 --run
->desired_vpos
;
4932 run
->desired_y
-= h
;
4933 run
->current_y
-= h
;
4937 /* Extend forward. */
4942 && old_lines
[j
] == new_lines
[k
])
4944 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4950 /* Insert run into list of all runs. Order runs by copied
4951 pixel lines. Note that we record runs that don't have to
4952 be copied because they are already in place. This is done
4953 because we can avoid calling update_window_line in this
4955 for (j
= 0; j
< nruns
&& runs
[j
]->height
> run
->height
; ++j
)
4957 for (k
= nruns
; k
> j
; --k
)
4958 runs
[k
] = runs
[k
- 1];
4967 /* Do the moves. Do it in a way that we don't overwrite something
4968 we want to copy later on. This is not solvable in general
4969 because there is only one display and we don't have a way to
4970 exchange areas on this display. Example:
4972 +-----------+ +-----------+
4974 +-----------+ --> +-----------+
4976 +-----------+ +-----------+
4978 Instead, prefer bigger moves, and invalidate moves that would
4979 copy from where we copied to. */
4981 for (i
= 0; i
< nruns
; ++i
)
4982 if (runs
[i
]->nrows
> 0)
4984 struct run
*r
= runs
[i
];
4986 /* Copy on the display. */
4987 if (r
->current_y
!= r
->desired_y
)
4989 rif
->scroll_run_hook (w
, r
);
4991 /* Invalidate runs that copy from where we copied to. */
4992 for (j
= i
+ 1; j
< nruns
; ++j
)
4994 struct run
*p
= runs
[j
];
4996 if ((p
->current_y
>= r
->desired_y
4997 && p
->current_y
< r
->desired_y
+ r
->height
)
4998 || (p
->current_y
+ p
->height
>= r
->desired_y
4999 && (p
->current_y
+ p
->height
5000 < r
->desired_y
+ r
->height
)))
5005 /* Assign matrix rows. */
5006 for (j
= 0; j
< r
->nrows
; ++j
)
5008 struct glyph_row
*from
, *to
;
5009 int to_overlapped_p
;
5011 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
5012 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
5013 to_overlapped_p
= to
->overlapped_p
;
5014 assign_row (to
, from
);
5015 to
->enabled_p
= 1, from
->enabled_p
= 0;
5016 to
->overlapped_p
= to_overlapped_p
;
5020 /* Clear the hash table, for the next time. */
5021 for (i
= 0; i
< row_entry_idx
; ++i
)
5022 row_table
[row_entry_pool
[i
].bucket
] = NULL
;
5024 /* Value is non-zero to indicate that we scrolled the display. */
5030 /************************************************************************
5032 ************************************************************************/
5034 /* Update the desired frame matrix of frame F.
5036 FORCE_P non-zero means that the update should not be stopped by
5037 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
5038 should not be tried.
5040 Value is non-zero if update was stopped due to pending input. */
5043 update_frame_1 (f
, force_p
, inhibit_id_p
)
5048 /* Frame matrices to work on. */
5049 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
5050 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
5053 int preempt_count
= baud_rate
/ 2400 + 1;
5054 extern int input_pending
;
5056 xassert (current_matrix
&& desired_matrix
);
5058 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
5059 calculate_costs (f
);
5061 if (preempt_count
<= 0)
5064 if (redisplay_dont_pause
)
5066 else if (!force_p
&& detect_input_pending ())
5072 /* If we cannot insert/delete lines, it's no use trying it. */
5073 if (!TTY_LINE_INS_DEL_OK (FRAME_TTY (f
)))
5076 /* See if any of the desired lines are enabled; don't compute for
5077 i/d line if just want cursor motion. */
5078 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
5079 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
5082 /* Try doing i/d line, if not yet inhibited. */
5083 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
5084 force_p
|= scrolling (f
);
5086 /* Update the individual lines as needed. Do bottom line first. */
5087 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
5088 update_frame_line (f
, desired_matrix
->nrows
- 1);
5090 /* Now update the rest of the lines. */
5091 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
5093 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
5095 if (FRAME_TERMCAP_P (f
))
5097 /* Flush out every so many lines.
5098 Also flush out if likely to have more than 1k buffered
5099 otherwise. I'm told that some telnet connections get
5100 really screwed by more than 1k output at once. */
5101 int outq
= PENDING_OUTPUT_COUNT (TTY_OUTPUT (FRAME_TTY (f
)));
5103 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
5105 fflush (TTY_OUTPUT (FRAME_TTY (f
)));
5106 if (preempt_count
== 1)
5108 #ifdef EMACS_OUTQSIZE
5109 if (EMACS_OUTQSIZE (0, &outq
) < 0)
5110 /* Probably not a tty. Ignore the error and reset
5112 outq
= PENDING_OUTPUT_COUNT (TTY_OUTPUT (FRAME_TTY (f
)));
5115 if (baud_rate
<= outq
&& baud_rate
> 0)
5116 sleep (outq
/ baud_rate
);
5121 if ((i
- 1) % preempt_count
== 0)
5122 detect_input_pending ();
5124 update_frame_line (f
, i
);
5128 pause
= (i
< FRAME_LINES (f
) - 1) ? i
: 0;
5130 /* Now just clean up termcap drivers and set cursor, etc. */
5133 if ((cursor_in_echo_area
5134 /* If we are showing a message instead of the mini-buffer,
5135 show the cursor for the message instead of for the
5136 (now hidden) mini-buffer contents. */
5137 || (EQ (minibuf_window
, selected_window
)
5138 && EQ (minibuf_window
, echo_area_window
)
5139 && !NILP (echo_area_buffer
[0])))
5140 /* These cases apply only to the frame that contains
5141 the active mini-buffer window. */
5142 && FRAME_HAS_MINIBUF_P (f
)
5143 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
5145 int top
= WINDOW_TOP_EDGE_LINE (XWINDOW (FRAME_MINIBUF_WINDOW (f
)));
5148 if (cursor_in_echo_area
< 0)
5150 /* Negative value of cursor_in_echo_area means put
5151 cursor at beginning of line. */
5157 /* Positive value of cursor_in_echo_area means put
5158 cursor at the end of the prompt. If the mini-buffer
5159 is several lines high, find the last line that has
5161 row
= FRAME_LINES (f
);
5167 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
5169 /* Frame rows are filled up with spaces that
5170 must be ignored here. */
5171 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
5173 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
5174 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
5177 && (last
- 1)->charpos
< 0)
5183 while (row
> top
&& col
== 0);
5185 /* Make sure COL is not out of range. */
5186 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
5188 /* If we have another row, advance cursor into it. */
5189 if (row
< FRAME_LINES (f
) - 1)
5191 col
= FRAME_LEFT_SCROLL_BAR_COLS (f
);
5194 /* Otherwise move it back in range. */
5196 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
5200 cursor_to (row
, col
);
5204 /* We have only one cursor on terminal frames. Use it to
5205 display the cursor of the selected window. */
5206 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5207 if (w
->cursor
.vpos
>= 0
5208 /* The cursor vpos may be temporarily out of bounds
5209 in the following situation: There is one window,
5210 with the cursor in the lower half of it. The window
5211 is split, and a message causes a redisplay before
5212 a new cursor position has been computed. */
5213 && w
->cursor
.vpos
< WINDOW_TOTAL_LINES (w
))
5215 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
5216 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
5218 if (INTEGERP (w
->left_margin_cols
))
5219 x
+= XFASTINT (w
->left_margin_cols
);
5221 /* x = max (min (x, FRAME_TOTAL_COLS (f) - 1), 0); */
5229 clear_desired_matrices (f
);
5234 /* Do line insertions/deletions on frame F for frame-based redisplay. */
5238 struct frame
*frame
;
5240 int unchanged_at_top
, unchanged_at_bottom
;
5243 int *old_hash
= (int *) alloca (FRAME_LINES (frame
) * sizeof (int));
5244 int *new_hash
= (int *) alloca (FRAME_LINES (frame
) * sizeof (int));
5245 int *draw_cost
= (int *) alloca (FRAME_LINES (frame
) * sizeof (int));
5246 int *old_draw_cost
= (int *) alloca (FRAME_LINES (frame
) * sizeof (int));
5248 int free_at_end_vpos
= FRAME_LINES (frame
);
5249 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
5250 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
5252 if (!current_matrix
)
5255 /* Compute hash codes of all the lines. Also calculate number of
5256 changed lines, number of unchanged lines at the beginning, and
5257 number of unchanged lines at the end. */
5259 unchanged_at_top
= 0;
5260 unchanged_at_bottom
= FRAME_LINES (frame
);
5261 for (i
= 0; i
< FRAME_LINES (frame
); i
++)
5263 /* Give up on this scrolling if some old lines are not enabled. */
5264 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
5266 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
5267 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
5269 /* This line cannot be redrawn, so don't let scrolling mess it. */
5270 new_hash
[i
] = old_hash
[i
];
5271 #define INFINITY 1000000 /* Taken from scroll.c */
5272 draw_cost
[i
] = INFINITY
;
5276 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
5277 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
5280 if (old_hash
[i
] != new_hash
[i
])
5283 unchanged_at_bottom
= FRAME_LINES (frame
) - i
- 1;
5285 else if (i
== unchanged_at_top
)
5287 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
5290 /* If changed lines are few, don't allow preemption, don't scroll. */
5291 if ((!TTY_SCROLL_REGION_OK (FRAME_TTY (frame
))
5292 && changed_lines
< baud_rate
/ 2400)
5293 || unchanged_at_bottom
== FRAME_LINES (frame
))
5296 window_size
= (FRAME_LINES (frame
) - unchanged_at_top
5297 - unchanged_at_bottom
);
5299 if (TTY_SCROLL_REGION_OK (FRAME_TTY (frame
)))
5300 free_at_end_vpos
-= unchanged_at_bottom
;
5301 else if (TTY_MEMORY_BELOW_FRAME (FRAME_TTY (frame
)))
5302 free_at_end_vpos
= -1;
5304 /* If large window, fast terminal and few lines in common between
5305 current frame and desired frame, don't bother with i/d calc. */
5306 if (!TTY_SCROLL_REGION_OK (FRAME_TTY (frame
))
5307 && window_size
>= 18 && baud_rate
> 2400
5309 10 * scrolling_max_lines_saved (unchanged_at_top
,
5310 FRAME_LINES (frame
) - unchanged_at_bottom
,
5311 old_hash
, new_hash
, draw_cost
)))
5314 if (window_size
< 2)
5317 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
5318 draw_cost
+ unchanged_at_top
- 1,
5319 old_draw_cost
+ unchanged_at_top
- 1,
5320 old_hash
+ unchanged_at_top
- 1,
5321 new_hash
+ unchanged_at_top
- 1,
5322 free_at_end_vpos
- unchanged_at_top
);
5328 /* Count the number of blanks at the start of the vector of glyphs R
5329 which is LEN glyphs long. */
5332 count_blanks (r
, len
)
5338 for (i
= 0; i
< len
; ++i
)
5339 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
5346 /* Count the number of glyphs in common at the start of the glyph
5347 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
5348 of STR2. Value is the number of equal glyphs equal at the start. */
5351 count_match (str1
, end1
, str2
, end2
)
5352 struct glyph
*str1
, *end1
, *str2
, *end2
;
5354 struct glyph
*p1
= str1
;
5355 struct glyph
*p2
= str2
;
5359 && GLYPH_CHAR_AND_FACE_EQUAL_P (p1
, p2
))
5366 /* Char insertion/deletion cost vector, from term.c */
5368 extern int *char_ins_del_vector
;
5369 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_TOTAL_COLS((f))])
5372 /* Perform a frame-based update on line VPOS in frame FRAME. */
5375 update_frame_line (f
, vpos
)
5379 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
5381 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
5382 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
5383 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
5384 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
5385 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
5386 int must_write_whole_line_p
;
5387 int write_spaces_p
= TTY_MUST_WRITE_SPACES (FRAME_TTY (f
));
5388 int colored_spaces_p
= (FACE_FROM_ID (f
, DEFAULT_FACE_ID
)->background
5389 != FACE_TTY_DEFAULT_BG_COLOR
);
5391 if (colored_spaces_p
)
5394 /* Current row not enabled means it has unknown contents. We must
5395 write the whole desired line in that case. */
5396 must_write_whole_line_p
= !current_row
->enabled_p
;
5397 if (must_write_whole_line_p
)
5404 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
5405 olen
= current_row
->used
[TEXT_AREA
];
5407 /* Ignore trailing spaces, if we can. */
5408 if (!write_spaces_p
)
5409 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
5413 current_row
->enabled_p
= 1;
5414 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
5416 /* If desired line is empty, just clear the line. */
5417 if (!desired_row
->enabled_p
)
5423 nbody
= desired_row
->glyphs
[TEXT_AREA
];
5424 nlen
= desired_row
->used
[TEXT_AREA
];
5425 nend
= nbody
+ nlen
;
5427 /* If display line has unknown contents, write the whole line. */
5428 if (must_write_whole_line_p
)
5430 /* Ignore spaces at the end, if we can. */
5431 if (!write_spaces_p
)
5432 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5435 /* Write the contents of the desired line. */
5438 cursor_to (vpos
, 0);
5439 write_glyphs (nbody
, nlen
);
5442 /* Don't call clear_end_of_line if we already wrote the whole
5443 line. The cursor will not be at the right margin in that
5444 case but in the line below. */
5445 if (nlen
< FRAME_TOTAL_COLS (f
))
5447 cursor_to (vpos
, nlen
);
5448 clear_end_of_line (FRAME_TOTAL_COLS (f
));
5451 /* Make sure we are in the right row, otherwise cursor movement
5452 with cmgoto might use `ch' in the wrong row. */
5453 cursor_to (vpos
, 0);
5455 make_current (desired_matrix
, current_matrix
, vpos
);
5459 /* Pretend trailing spaces are not there at all,
5460 unless for one reason or another we must write all spaces. */
5461 if (!write_spaces_p
)
5462 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5465 /* If there's no i/d char, quickly do the best we can without it. */
5466 if (!TTY_CHAR_INS_DEL_OK (FRAME_TTY (f
)))
5470 /* Find the first glyph in desired row that doesn't agree with
5471 a glyph in the current row, and write the rest from there on. */
5472 for (i
= 0; i
< nlen
; i
++)
5474 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
5476 /* Find the end of the run of different glyphs. */
5480 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
5481 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
5484 /* Output this run of non-matching chars. */
5485 cursor_to (vpos
, i
);
5486 write_glyphs (nbody
+ i
, j
- i
);
5489 /* Now find the next non-match. */
5493 /* Clear the rest of the line, or the non-clear part of it. */
5496 cursor_to (vpos
, nlen
);
5497 clear_end_of_line (olen
);
5500 /* Make current row = desired row. */
5501 make_current (desired_matrix
, current_matrix
, vpos
);
5505 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
5506 characters in a row. */
5510 /* If current line is blank, skip over initial spaces, if
5511 possible, and write the rest. */
5515 nsp
= count_blanks (nbody
, nlen
);
5519 cursor_to (vpos
, nsp
);
5520 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
5523 /* Exchange contents between current_frame and new_frame. */
5524 make_current (desired_matrix
, current_matrix
, vpos
);
5528 /* Compute number of leading blanks in old and new contents. */
5529 osp
= count_blanks (obody
, olen
);
5530 nsp
= (colored_spaces_p
? 0 : count_blanks (nbody
, nlen
));
5532 /* Compute number of matching chars starting with first non-blank. */
5533 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
5534 nbody
+ nsp
, nbody
+ nlen
);
5536 /* Spaces in new match implicit space past the end of old. */
5537 /* A bug causing this to be a no-op was fixed in 18.29. */
5538 if (!write_spaces_p
&& osp
+ begmatch
== olen
)
5541 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
5545 /* Avoid doing insert/delete char
5546 just cause number of leading spaces differs
5547 when the following text does not match. */
5548 if (begmatch
== 0 && osp
!= nsp
)
5549 osp
= nsp
= min (osp
, nsp
);
5551 /* Find matching characters at end of line */
5554 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
5556 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
5561 endmatch
= obody
+ olen
- op1
;
5563 /* tem gets the distance to insert or delete.
5564 endmatch is how many characters we save by doing so.
5567 tem
= (nlen
- nsp
) - (olen
- osp
);
5569 && (!TTY_CHAR_INS_DEL_OK (FRAME_TTY (f
))
5570 || endmatch
<= char_ins_del_cost (f
)[tem
]))
5573 /* nsp - osp is the distance to insert or delete.
5574 If that is nonzero, begmatch is known to be nonzero also.
5575 begmatch + endmatch is how much we save by doing the ins/del.
5579 && (!TTY_CHAR_INS_DEL_OK (FRAME_TTY (f
))
5580 || begmatch
+ endmatch
<= char_ins_del_cost (f
)[nsp
- osp
]))
5584 osp
= nsp
= min (osp
, nsp
);
5587 /* Now go through the line, inserting, writing and
5588 deleting as appropriate. */
5592 cursor_to (vpos
, nsp
);
5593 delete_glyphs (osp
- nsp
);
5597 /* If going to delete chars later in line
5598 and insert earlier in the line,
5599 must delete first to avoid losing data in the insert */
5600 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
5602 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
5603 delete_glyphs (olen
+ nsp
- osp
- nlen
);
5604 olen
= nlen
- (nsp
- osp
);
5606 cursor_to (vpos
, osp
);
5607 insert_glyphs (0, nsp
- osp
);
5611 tem
= nsp
+ begmatch
+ endmatch
;
5612 if (nlen
!= tem
|| olen
!= tem
)
5614 if (!endmatch
|| nlen
== olen
)
5616 /* If new text being written reaches right margin, there is
5617 no need to do clear-to-eol at the end of this function
5618 (and it would not be safe, since cursor is not going to
5619 be "at the margin" after the text is done). */
5620 if (nlen
== FRAME_TOTAL_COLS (f
))
5623 /* Function write_glyphs is prepared to do nothing
5624 if passed a length <= 0. Check it here to avoid
5625 unnecessary cursor movement. */
5628 cursor_to (vpos
, nsp
+ begmatch
);
5629 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5632 else if (nlen
> olen
)
5634 /* Here, we used to have the following simple code:
5635 ----------------------------------------
5636 write_glyphs (nbody + nsp + begmatch, olen - tem);
5637 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5638 ----------------------------------------
5639 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5640 is a padding glyph. */
5641 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5644 cursor_to (vpos
, nsp
+ begmatch
);
5646 /* Calculate columns we can actually overwrite. */
5647 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
]))
5649 write_glyphs (nbody
+ nsp
+ begmatch
, out
);
5651 /* If we left columns to be overwritten, we must delete them. */
5652 del
= olen
- tem
- out
;
5654 delete_glyphs (del
);
5656 /* At last, we insert columns not yet written out. */
5657 insert_glyphs (nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5660 else if (olen
> nlen
)
5662 cursor_to (vpos
, nsp
+ begmatch
);
5663 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5664 delete_glyphs (olen
- nlen
);
5670 /* If any unerased characters remain after the new line, erase them. */
5673 cursor_to (vpos
, nlen
);
5674 clear_end_of_line (olen
);
5677 /* Exchange contents between current_frame and new_frame. */
5678 make_current (desired_matrix
, current_matrix
, vpos
);
5683 /***********************************************************************
5684 X/Y Position -> Buffer Position
5685 ***********************************************************************/
5687 /* Determine what's under window-relative pixel position (*X, *Y).
5688 Return in *OBJECT the object (string or buffer) that's there.
5689 Return in *POS the position in that object. Adjust *X and *Y
5690 to character positions. */
5693 buffer_posn_from_coords (w
, x
, y
, dx
, dy
, object
, pos
)
5697 Lisp_Object
*object
;
5698 struct display_pos
*pos
;
5701 struct buffer
*old_current_buffer
= current_buffer
;
5702 struct text_pos startp
;
5705 current_buffer
= XBUFFER (w
->buffer
);
5706 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5707 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5708 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5709 start_display (&it
, w
, startp
);
5711 x0
= *x
- WINDOW_LEFT_MARGIN_WIDTH (w
);
5712 move_it_to (&it
, -1, x0
+ it
.first_visible_x
, *y
, -1,
5713 MOVE_TO_X
| MOVE_TO_Y
);
5715 current_buffer
= old_current_buffer
;
5717 *dx
= x0
+ it
.first_visible_x
- it
.current_x
;
5718 *dy
= *y
- it
.current_y
;
5720 *object
= w
->buffer
;
5722 #ifdef HAVE_WINDOW_SYSTEM
5723 if (it
.what
== IT_IMAGE
)
5726 if ((img
= IMAGE_FROM_ID (it
.f
, it
.image_id
)) != NULL
5727 && !NILP (img
->spec
))
5729 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, it
.vpos
);
5730 struct glyph
*glyph
;
5732 if (it
.hpos
< row
->used
[TEXT_AREA
]
5733 && (glyph
= row
->glyphs
[TEXT_AREA
] + it
.hpos
,
5734 glyph
->type
== IMAGE_GLYPH
))
5736 *dy
-= row
->ascent
- glyph
->ascent
;
5737 *object
= img
->spec
;
5743 if (STRINGP (it
.string
))
5744 *object
= it
.string
;
5748 /* Add extra (default width) columns if clicked after EOL. */
5749 x1
= max(0, it
.current_x
+ it
.pixel_width
- it
.first_visible_x
);
5751 it
.hpos
+= (x0
- x1
) / WINDOW_FRAME_COLUMN_WIDTH (w
);
5758 /* Value is the string under window-relative coordinates X/Y in the
5759 mode or header line of window W, or nil if none. MODE_LINE_P non-zero
5760 means look at the mode line. *CHARPOS is set to the position in
5761 the string returned. */
5764 mode_line_string (w
, x
, y
, dx
, dy
, part
, charpos
)
5768 enum window_part part
;
5771 struct glyph_row
*row
;
5772 struct glyph
*glyph
, *end
;
5774 Lisp_Object string
= Qnil
;
5776 if (part
== ON_MODE_LINE
)
5777 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5779 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
5781 *y
= row
- MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
5783 if (row
->mode_line_p
&& row
->enabled_p
)
5785 /* Find the glyph under X. If we find one with a string object,
5786 it's the one we were looking for. */
5787 glyph
= row
->glyphs
[TEXT_AREA
];
5788 end
= glyph
+ row
->used
[TEXT_AREA
];
5789 for (x0
= *x
; glyph
< end
&& x0
> glyph
->pixel_width
; ++glyph
)
5790 x0
-= glyph
->pixel_width
;
5791 *x
= glyph
- row
->glyphs
[TEXT_AREA
];
5794 string
= glyph
->object
;
5795 *charpos
= glyph
->charpos
;
5798 /* Add extra (default width) columns if clicked after EOL. */
5799 *x
+= x0
/ WINDOW_FRAME_COLUMN_WIDTH (w
);
5817 /* Value is the string under window-relative coordinates X/Y in either
5818 marginal area, or nil if none. *CHARPOS is set to the position in
5819 the string returned. */
5822 marginal_area_string (w
, x
, y
, dx
, dy
, part
, charpos
)
5826 enum window_part part
;
5829 struct glyph_row
*row
= w
->current_matrix
->rows
;
5830 struct glyph
*glyph
, *end
;
5831 int x0
, y0
, i
, wy
= *y
;
5833 Lisp_Object string
= Qnil
;
5835 if (part
== ON_LEFT_MARGIN
)
5836 area
= LEFT_MARGIN_AREA
;
5837 else if (part
== ON_RIGHT_MARGIN
)
5838 area
= RIGHT_MARGIN_AREA
;
5842 for (i
= 0; row
->enabled_p
&& i
< w
->current_matrix
->nrows
; ++i
, ++row
)
5843 if (wy
>= row
->y
&& wy
< MATRIX_ROW_BOTTOM_Y (row
))
5846 *y
= row
- MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
5850 /* Find the glyph under X. If we find one with a string object,
5851 it's the one we were looking for. */
5852 if (area
== RIGHT_MARGIN_AREA
)
5853 x0
= ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5854 ? WINDOW_LEFT_FRINGE_WIDTH (w
)
5855 : WINDOW_TOTAL_FRINGE_WIDTH (w
))
5856 + window_box_width (w
, LEFT_MARGIN_AREA
)
5857 + window_box_width (w
, TEXT_AREA
));
5859 x0
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5860 ? WINDOW_LEFT_FRINGE_WIDTH (w
)
5863 glyph
= row
->glyphs
[area
];
5864 end
= glyph
+ row
->used
[area
];
5865 for (x0
= *x
- x0
; glyph
< end
&& x0
> glyph
->pixel_width
; ++glyph
)
5866 x0
-= glyph
->pixel_width
;
5867 *x
= glyph
- row
->glyphs
[area
];
5870 string
= glyph
->object
;
5871 *charpos
= glyph
->charpos
;
5872 #ifdef HAVE_WINDOW_SYSTEM
5873 if (glyph
->type
== IMAGE_GLYPH
)
5876 img
= IMAGE_FROM_ID (WINDOW_XFRAME (w
), glyph
->u
.img_id
);
5879 y0
-= row
->ascent
- glyph
->ascent
;
5884 /* Add extra (default width) columns if clicked after EOL. */
5885 *x
+= x0
/ WINDOW_FRAME_COLUMN_WIDTH (w
);
5903 /***********************************************************************
5904 Changing Frame Sizes
5905 ***********************************************************************/
5910 window_change_signal (signalnum
) /* If we don't have an argument, */
5911 int signalnum
; /* some compilers complain in signal calls. */
5917 int old_errno
= errno
;
5919 struct tty_display_info
*tty
;
5921 /* The frame size change obviously applies to a single
5922 termcap-controlled terminal, but we can't decide which.
5923 Therefore, we resize the frames corresponding to each tty.
5925 for (tty
= tty_list
; tty
; tty
= tty
->next
) {
5927 if (! tty
->term_initted
)
5930 get_tty_size (fileno (TTY_INPUT (tty
)), &width
, &height
);
5933 Lisp_Object tail
, frame
;
5935 FOR_EACH_FRAME (tail
, frame
)
5937 if (FRAME_TERMCAP_P (XFRAME (frame
)) && FRAME_TTY (XFRAME (frame
)) == tty
)
5939 /* Record the new sizes, but don't reallocate the data structures
5940 now. Let that be done later outside of the signal handler. */
5941 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5948 signal (SIGWINCH
, window_change_signal
);
5951 #endif /* SIGWINCH */
5954 /* Do any change in frame size that was requested by a signal. SAFE
5955 non-zero means this function is called from a place where it is
5956 safe to change frame sizes while a redisplay is in progress. */
5959 do_pending_window_change (safe
)
5962 /* If window_change_signal should have run before, run it now. */
5963 if (redisplaying_p
&& !safe
)
5966 while (delayed_size_change
)
5968 Lisp_Object tail
, frame
;
5970 delayed_size_change
= 0;
5972 FOR_EACH_FRAME (tail
, frame
)
5974 struct frame
*f
= XFRAME (frame
);
5976 if (f
->new_text_lines
!= 0 || f
->new_text_cols
!= 0)
5977 change_frame_size (f
, f
->new_text_lines
, f
->new_text_cols
,
5984 /* Change the frame height and/or width. Values may be given as zero to
5985 indicate no change is to take place.
5987 If DELAY is non-zero, then assume we're being called from a signal
5988 handler, and queue the change for later - perhaps the next
5989 redisplay. Since this tries to resize windows, we can't call it
5990 from a signal handler.
5992 SAFE non-zero means this function is called from a place where it's
5993 safe to change frame sizes while a redisplay is in progress. */
5996 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5997 register struct frame
*f
;
5998 int newheight
, newwidth
, pretend
, delay
, safe
;
6000 Lisp_Object tail
, frame
;
6002 if (FRAME_MSDOS_P (f
))
6004 /* On MS-DOS, all frames use the same screen, so a change in
6005 size affects all frames. Termcap now supports multiple
6007 FOR_EACH_FRAME (tail
, frame
)
6008 if (! FRAME_WINDOW_P (XFRAME (frame
)))
6009 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
6010 pretend
, delay
, safe
);
6013 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
6017 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
)
6018 register struct frame
*f
;
6019 int newheight
, newwidth
, pretend
, delay
, safe
;
6021 int new_frame_total_cols
;
6022 int count
= SPECPDL_INDEX ();
6024 /* If we can't deal with the change now, queue it for later. */
6025 if (delay
|| (redisplaying_p
&& !safe
))
6027 f
->new_text_lines
= newheight
;
6028 f
->new_text_cols
= newwidth
;
6029 delayed_size_change
= 1;
6033 /* This size-change overrides any pending one for this frame. */
6034 f
->new_text_lines
= 0;
6035 f
->new_text_cols
= 0;
6037 /* If an argument is zero, set it to the current value. */
6039 newheight
= FRAME_LINES (f
);
6041 newwidth
= FRAME_COLS (f
);
6043 /* Compute width of windows in F.
6044 This is the width of the frame without vertical scroll bars. */
6045 new_frame_total_cols
= FRAME_TOTAL_COLS_ARG (f
, newwidth
);
6047 /* Round up to the smallest acceptable size. */
6048 check_frame_size (f
, &newheight
, &newwidth
);
6050 /* If we're not changing the frame size, quit now. */
6051 if (newheight
== FRAME_LINES (f
)
6052 && new_frame_total_cols
== FRAME_TOTAL_COLS (f
))
6058 /* We only can set screen dimensions to certain values supported
6059 by our video hardware. Try to find the smallest size greater
6060 or equal to the requested dimensions. */
6061 dos_set_window_size (&newheight
, &newwidth
);
6064 if (newheight
!= FRAME_LINES (f
))
6066 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
6068 /* Frame has both root and mini-buffer. */
6069 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f
))->top_line
,
6070 FRAME_TOP_MARGIN (f
));
6071 set_window_height (FRAME_ROOT_WINDOW (f
),
6074 - FRAME_TOP_MARGIN (f
)),
6076 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top_line
,
6078 set_window_height (FRAME_MINIBUF_WINDOW (f
), 1, 0);
6081 /* Frame has just one top-level window. */
6082 set_window_height (FRAME_ROOT_WINDOW (f
),
6083 newheight
- FRAME_TOP_MARGIN (f
), 0);
6085 if (FRAME_TERMCAP_P (f
) && !pretend
)
6086 FrameRows (FRAME_TTY (f
)) = newheight
;
6089 if (new_frame_total_cols
!= FRAME_TOTAL_COLS (f
))
6091 set_window_width (FRAME_ROOT_WINDOW (f
), new_frame_total_cols
, 0);
6092 if (FRAME_HAS_MINIBUF_P (f
))
6093 set_window_width (FRAME_MINIBUF_WINDOW (f
), new_frame_total_cols
, 0);
6095 if (FRAME_TERMCAP_P (f
) && !pretend
)
6096 FrameCols (FRAME_TTY (f
)) = newwidth
;
6098 if (WINDOWP (f
->tool_bar_window
))
6099 XSETFASTINT (XWINDOW (f
->tool_bar_window
)->total_cols
, newwidth
);
6102 FRAME_LINES (f
) = newheight
;
6103 SET_FRAME_COLS (f
, newwidth
);
6106 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
6107 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
6109 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
6111 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
6112 w
->cursor
.hpos
= w
->cursor
.x
= 0;
6113 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
6114 w
->cursor
.vpos
= w
->cursor
.y
= 0;
6118 calculate_costs (f
);
6119 SET_FRAME_GARBAGED (f
);
6124 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
6126 /* This isn't quite a no-op: it runs window-configuration-change-hook. */
6127 Fset_window_buffer (FRAME_SELECTED_WINDOW (f
),
6128 XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
, Qt
);
6130 unbind_to (count
, Qnil
);
6135 /***********************************************************************
6136 Terminal Related Lisp Functions
6137 ***********************************************************************/
6139 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
6140 1, 1, "FOpen termscript file: ",
6141 doc
: /* Start writing all terminal output to FILE as well as the terminal.
6142 FILE = nil means just close any termscript file currently open. */)
6146 if (TTY_TERMSCRIPT (CURTTY ()) != 0)
6147 fclose (TTY_TERMSCRIPT (CURTTY ()));
6148 TTY_TERMSCRIPT (CURTTY ()) = 0;
6152 file
= Fexpand_file_name (file
, Qnil
);
6153 TTY_TERMSCRIPT (CURTTY ()) = fopen (SDATA (file
), "w");
6154 if (TTY_TERMSCRIPT (CURTTY ()) == 0)
6155 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
6161 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
6162 Ssend_string_to_terminal
, 1, 1, 0,
6163 doc
: /* Send STRING to the terminal without alteration.
6164 Control characters in STRING will have terminal-dependent effects. */)
6168 /* ??? Perhaps we should do something special for multibyte strings here. */
6169 CHECK_STRING (string
);
6170 if (TTY_TERMSCRIPT (CURTTY ()))
6172 fwrite (SDATA (string
), 1, SBYTES (string
),
6173 TTY_TERMSCRIPT (CURTTY ()));
6174 fflush (TTY_TERMSCRIPT (CURTTY ()));
6176 fwrite (SDATA (string
), 1, SBYTES (string
),
6177 TTY_OUTPUT (CURTTY ()));
6178 fflush (TTY_OUTPUT (CURTTY ()));
6183 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
6184 doc
: /* Beep, or flash the screen.
6185 Also, unless an argument is given,
6186 terminate any keyboard macro currently executing. */)
6196 fflush (TTY_OUTPUT (CURTTY ()));
6209 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
6210 error ("Keyboard macro terminated by a command ringing the bell");
6213 fflush (TTY_OUTPUT (CURTTY ()));
6218 /***********************************************************************
6220 ***********************************************************************/
6222 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
6223 doc
: /* Pause, without updating display, for SECONDS seconds.
6224 SECONDS may be a floating-point value, meaning that you can wait for a
6225 fraction of a second. Optional second arg MILLISECONDS specifies an
6226 additional wait period, in milliseconds; this may be useful if your
6227 Emacs was built without floating point support.
6228 \(Not all operating systems support waiting for a fraction of a second.) */)
6229 (seconds
, milliseconds
)
6230 Lisp_Object seconds
, milliseconds
;
6234 if (NILP (milliseconds
))
6235 XSETINT (milliseconds
, 0);
6237 CHECK_NUMBER (milliseconds
);
6238 usec
= XINT (milliseconds
) * 1000;
6241 double duration
= extract_float (seconds
);
6242 sec
= (int) duration
;
6243 usec
+= (duration
- sec
) * 1000000;
6246 #ifndef EMACS_HAS_USECS
6247 if (sec
== 0 && usec
!= 0)
6248 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
6251 /* Assure that 0 <= usec < 1000000. */
6254 /* We can't rely on the rounding being correct if usec is negative. */
6255 if (-1000000 < usec
)
6256 sec
--, usec
+= 1000000;
6258 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
6261 sec
+= usec
/ 1000000, usec
%= 1000000;
6263 if (sec
< 0 || (sec
== 0 && usec
== 0))
6269 XSETFASTINT (zero
, 0);
6270 wait_reading_process_input (sec
, usec
, zero
, 0);
6273 /* We should always have wait_reading_process_input; we have a dummy
6274 implementation for systems which don't support subprocesses. */
6276 /* No wait_reading_process_input */
6283 /* The reason this is done this way
6284 (rather than defined (H_S) && defined (H_T))
6285 is because the VMS preprocessor doesn't grok `defined'. */
6287 EMACS_GET_TIME (end_time
);
6288 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
6289 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
6293 EMACS_GET_TIME (timeout
);
6294 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
6295 if (EMACS_TIME_NEG_P (timeout
)
6296 || !select (1, 0, 0, 0, &timeout
))
6299 #else /* not HAVE_SELECT */
6301 #endif /* HAVE_SELECT */
6302 #endif /* not VMS */
6305 #endif /* no subprocesses */
6311 /* This is just like wait_reading_process_input, except that
6312 it does the redisplay.
6314 It's also much like Fsit_for, except that it can be used for
6315 waiting for input as well. */
6318 sit_for (sec
, usec
, reading
, display
, initial_display
)
6319 int sec
, usec
, reading
, display
, initial_display
;
6321 Lisp_Object read_kbd
;
6323 swallow_events (display
);
6325 if (detect_input_pending_run_timers (display
) || !NILP (Vexecuting_macro
))
6328 if (initial_display
)
6329 redisplay_preserve_echo_area (2);
6331 if (sec
== 0 && usec
== 0)
6338 XSETINT (read_kbd
, reading
? -1 : 1);
6339 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
6341 return detect_input_pending () ? Qnil
: Qt
;
6345 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
6346 doc
: /* Perform redisplay, then wait for SECONDS seconds or until input is available.
6347 SECONDS may be a floating-point value, meaning that you can wait for a
6348 fraction of a second.
6349 \(Not all operating systems support waiting for a fraction of a second.)
6350 Optional arg NODISP non-nil means don't redisplay, just wait for input.
6351 Redisplay is preempted as always if input arrives, and does not happen
6352 if input is available before it starts.
6353 Value is t if waited the full time with no input arriving.
6355 An obsolete but still supported form is
6356 \(sit-for SECONDS &optional MILLISECONDS NODISP)
6357 Where the optional arg MILLISECONDS specifies an additional wait period,
6358 in milliseconds; this was useful when Emacs was built without
6359 floating point support.
6360 usage: (sit-for SECONDS &optional NODISP OLD-NODISP) */)
6362 /* The `old-nodisp' stuff is there so that the arglist has the correct
6363 length. Otherwise, `defdvice' will redefine it with fewer args. */
6364 (seconds
, milliseconds
, nodisp
)
6365 Lisp_Object seconds
, milliseconds
, nodisp
;
6369 if (NILP (nodisp
) && !NUMBERP (milliseconds
))
6371 nodisp
= milliseconds
;
6372 milliseconds
= Qnil
;
6375 if (NILP (milliseconds
))
6376 XSETINT (milliseconds
, 0);
6378 CHECK_NUMBER (milliseconds
);
6379 usec
= XINT (milliseconds
) * 1000;
6382 double duration
= extract_float (seconds
);
6383 sec
= (int) duration
;
6384 usec
+= (duration
- sec
) * 1000000;
6387 #ifndef EMACS_HAS_USECS
6388 if (usec
!= 0 && sec
== 0)
6389 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
6392 return sit_for (sec
, usec
, 0, NILP (nodisp
), NILP (nodisp
));
6397 /***********************************************************************
6398 Other Lisp Functions
6399 ***********************************************************************/
6401 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
6402 session's frames, frame names, buffers, buffer-read-only flags, and
6403 buffer-modified-flags, and a trailing sentinel (so we don't need to
6404 add length checks). */
6406 static Lisp_Object frame_and_buffer_state
;
6409 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
6410 Sframe_or_buffer_changed_p
, 0, 0, 0,
6411 doc
: /* Return non-nil if the frame and buffer state appears to have changed.
6412 The state variable is an internal vector containing all frames and buffers,
6413 aside from buffers whose names start with space,
6414 along with the buffers' read-only and modified flags, which allows a fast
6415 check to see whether the menu bars might need to be recomputed.
6416 If this function returns non-nil, it updates the internal vector to reflect
6417 the current state. */)
6420 Lisp_Object tail
, frame
, buf
;
6424 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
6425 FOR_EACH_FRAME (tail
, frame
)
6427 if (!EQ (*vecp
++, frame
))
6429 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
6432 /* Check that the buffer info matches.
6433 No need to test for the end of the vector
6434 because the last element of the vector is lambda
6435 and that will always cause a mismatch. */
6436 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
6438 buf
= XCDR (XCAR (tail
));
6439 /* Ignore buffers that aren't included in buffer lists. */
6440 if (SREF (XBUFFER (buf
)->name
, 0) == ' ')
6442 if (!EQ (*vecp
++, buf
))
6444 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
6446 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
6449 /* Detect deletion of a buffer at the end of the list. */
6450 if (EQ (*vecp
, Qlambda
))
6453 /* Start with 1 so there is room for at least one lambda at the end. */
6455 FOR_EACH_FRAME (tail
, frame
)
6457 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
6459 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
6460 if (n
> XVECTOR (frame_and_buffer_state
)->size
6461 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
6462 /* Add 20 extra so we grow it less often. */
6463 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
6464 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
6465 FOR_EACH_FRAME (tail
, frame
)
6468 *vecp
++ = XFRAME (frame
)->name
;
6470 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
6472 buf
= XCDR (XCAR (tail
));
6473 /* Ignore buffers that aren't included in buffer lists. */
6474 if (SREF (XBUFFER (buf
)->name
, 0) == ' ')
6477 *vecp
++ = XBUFFER (buf
)->read_only
;
6478 *vecp
++ = Fbuffer_modified_p (buf
);
6480 /* Fill up the vector with lambdas (always at least one). */
6482 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
6483 < XVECTOR (frame_and_buffer_state
)->size
)
6485 /* Make sure we didn't overflow the vector. */
6486 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
6487 > XVECTOR (frame_and_buffer_state
)->size
)
6494 /***********************************************************************
6496 ***********************************************************************/
6498 /* Initialization done when Emacs fork is started, before doing stty.
6499 Determine terminal type and set terminal_driver. Then invoke its
6500 decoding routine to set up variables in the terminal package. */
6505 char *terminal_type
;
6507 #ifdef HAVE_X_WINDOWS
6508 extern int display_arg
;
6511 /* Construct the space glyph. */
6512 space_glyph
.type
= CHAR_GLYPH
;
6513 SET_CHAR_GLYPH_FROM_GLYPH (space_glyph
, ' ');
6514 space_glyph
.charpos
= -1;
6517 cursor_in_echo_area
= 0;
6518 terminal_type
= (char *) 0;
6520 /* Now is the time to initialize this; it's used by init_sys_modes
6522 Vwindow_system
= Qnil
;
6524 /* If the user wants to use a window system, we shouldn't bother
6525 initializing the terminal. This is especially important when the
6526 terminal is so dumb that emacs gives up before and doesn't bother
6527 using the window system.
6529 If the DISPLAY environment variable is set and nonempty,
6530 try to use X, and die with an error message if that doesn't work. */
6532 #ifdef HAVE_X_WINDOWS
6537 display
= getenv ("DECW$DISPLAY");
6539 display
= getenv ("DISPLAY");
6542 display_arg
= (display
!= 0 && *display
!= 0);
6545 if (!inhibit_window_system
&& display_arg
6551 Vwindow_system
= intern ("x");
6553 Vwindow_system_version
= make_number (11);
6555 Vwindow_system_version
= make_number (10);
6557 #if defined (GNU_LINUX) && defined (HAVE_LIBNCURSES)
6558 /* In some versions of ncurses,
6559 tputs crashes if we have not called tgetent.
6561 { char b
[2044]; tgetent (b
, "xterm");}
6563 adjust_frame_glyphs_initially ();
6566 #endif /* HAVE_X_WINDOWS */
6569 if (!inhibit_window_system
)
6571 Vwindow_system
= intern ("w32");
6572 Vwindow_system_version
= make_number (1);
6573 adjust_frame_glyphs_initially ();
6576 #endif /* HAVE_NTGUI */
6579 if (!inhibit_window_system
)
6581 Vwindow_system
= intern ("mac");
6582 Vwindow_system_version
= make_number (1);
6583 adjust_frame_glyphs_initially ();
6588 /* If no window system has been specified, try to use the terminal. */
6591 fatal ("standard input is not a tty");
6595 /* Look at the TERM variable. */
6596 terminal_type
= (char *) getenv ("TERM");
6600 fprintf (stderr
, "Please specify your terminal type.\n\
6601 For types defined in VMS, use set term /device=TYPE.\n\
6602 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
6603 \(The quotation marks are necessary since terminal types are lower case.)\n");
6605 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
6611 /* VMS DCL tends to up-case things, so down-case term type.
6612 Hardly any uppercase letters in terminal types; should be none. */
6614 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
6617 strcpy (new, terminal_type
);
6619 for (p
= new; *p
; p
++)
6623 terminal_type
= new;
6628 struct tty_display_info
*tty
;
6630 tty
= term_init (selected_frame
, 0, terminal_type
);
6631 change_frame_size (XFRAME (selected_frame
), FrameRows (tty
), FrameCols (tty
), 0, 0, 0);
6635 struct frame
*sf
= SELECTED_FRAME ();
6636 int width
= FRAME_TOTAL_COLS (sf
);
6637 int height
= FRAME_LINES (sf
);
6639 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (struct glyph
);
6641 /* If these sizes are so big they cause overflow, just ignore the
6642 change. It's not clear what better we could do. */
6643 if (total_glyphs
/ sizeof (struct glyph
) / height
!= width
+ 2)
6644 fatal ("screen size %dx%d too big", width
, height
);
6647 adjust_frame_glyphs_initially ();
6648 calculate_costs (XFRAME (selected_frame
));
6653 #endif /* CANNOT_DUMP */
6654 signal (SIGWINCH
, window_change_signal
);
6655 #endif /* SIGWINCH */
6657 /* Set up faces of the initial terminal frame of a dumped Emacs. */
6661 /* The MSDOS terminal turns on its ``window system'' relatively
6662 late into the startup, so we cannot do the frame faces'
6663 initialization just yet. It will be done later by pc-win.el
6664 and internal_terminal_init. */
6665 && (strcmp (terminal_type
, "internal") != 0 || inhibit_window_system
)
6667 && NILP (Vwindow_system
))
6669 /* For the initial frame, we don't have any way of knowing what
6670 are the foreground and background colors of the terminal. */
6671 struct frame
*sf
= SELECTED_FRAME();
6673 FRAME_FOREGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_FG_COLOR
;
6674 FRAME_BACKGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_BG_COLOR
;
6675 call0 (intern ("tty-set-up-initial-frame-faces"));
6681 /***********************************************************************
6683 ***********************************************************************/
6685 DEFUN ("internal-show-cursor", Finternal_show_cursor
,
6686 Sinternal_show_cursor
, 2, 2, 0,
6687 doc
: /* Set the cursor-visibility flag of WINDOW to SHOW.
6688 WINDOW nil means use the selected window. SHOW non-nil means
6689 show a cursor in WINDOW in the next redisplay. SHOW nil means
6690 don't show a cursor. */)
6692 Lisp_Object window
, show
;
6694 /* Don't change cursor state while redisplaying. This could confuse
6696 if (!redisplaying_p
)
6699 window
= selected_window
;
6701 CHECK_WINDOW (window
);
6703 XWINDOW (window
)->cursor_off_p
= NILP (show
);
6710 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p
,
6711 Sinternal_show_cursor_p
, 0, 1, 0,
6712 doc
: /* Value is non-nil if next redisplay will display a cursor in WINDOW.
6713 WINDOW nil or omitted means report on the selected window. */)
6720 window
= selected_window
;
6722 CHECK_WINDOW (window
);
6724 w
= XWINDOW (window
);
6725 return w
->cursor_off_p
? Qnil
: Qt
;
6729 /***********************************************************************
6731 ***********************************************************************/
6736 defsubr (&Sredraw_frame
);
6737 defsubr (&Sredraw_display
);
6738 defsubr (&Sframe_or_buffer_changed_p
);
6739 defsubr (&Sopen_termscript
);
6741 defsubr (&Ssit_for
);
6742 defsubr (&Ssleep_for
);
6743 defsubr (&Ssend_string_to_terminal
);
6744 defsubr (&Sinternal_show_cursor
);
6745 defsubr (&Sinternal_show_cursor_p
);
6748 defsubr (&Sdump_redisplay_history
);
6751 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
6752 staticpro (&frame_and_buffer_state
);
6754 Qdisplay_table
= intern ("display-table");
6755 staticpro (&Qdisplay_table
);
6756 Qredisplay_dont_pause
= intern ("redisplay-dont-pause");
6757 staticpro (&Qredisplay_dont_pause
);
6759 DEFVAR_INT ("baud-rate", &baud_rate
,
6760 doc
: /* *The output baud rate of the terminal.
6761 On most systems, changing this value will affect the amount of padding
6762 and the other strategic decisions made during redisplay. */);
6764 DEFVAR_BOOL ("inverse-video", &inverse_video
,
6765 doc
: /* *Non-nil means invert the entire frame display.
6766 This means everything is in inverse video which otherwise would not be. */);
6768 DEFVAR_BOOL ("visible-bell", &visible_bell
,
6769 doc
: /* *Non-nil means try to flash the frame to represent a bell.
6771 See also `ring-bell-function'. */);
6773 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
6774 doc
: /* *Non-nil means no need to redraw entire frame after suspending.
6775 A non-nil value is useful if the terminal can automatically preserve
6776 Emacs's frame display when you reenter Emacs.
6777 It is up to you to set this variable if your terminal can do that. */);
6779 DEFVAR_LISP ("window-system", &Vwindow_system
,
6780 doc
: /* Name of window system that Emacs is displaying through.
6781 The value is a symbol--for instance, `x' for X windows.
6782 The value is nil if Emacs is using a text-only terminal. */);
6784 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
6785 doc
: /* The version number of the window system in use.
6786 For X windows, this is 10 or 11. */);
6788 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
6789 doc
: /* Non-nil means put cursor in minibuffer, at end of any message there. */);
6791 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
6792 doc
: /* Table defining how to output a glyph code to the frame.
6793 If not nil, this is a vector indexed by glyph code to define the glyph.
6794 Each element can be:
6795 integer: a glyph code which this glyph is an alias for.
6796 string: output this glyph using that string (not impl. in X windows).
6797 nil: this glyph mod 524288 is the code of a character to output,
6798 and this glyph / 524288 is the face number (see `face-id') to use
6799 while outputting it. */);
6800 Vglyph_table
= Qnil
;
6802 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
6803 doc
: /* Display table to use for buffers that specify none.
6804 See `buffer-display-table' for more information. */);
6805 Vstandard_display_table
= Qnil
;
6807 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause
,
6808 doc
: /* *Non-nil means update isn't paused when input is detected. */);
6809 redisplay_dont_pause
= 0;
6811 /* Initialize `window-system', unless init_display already decided it. */
6816 Vwindow_system
= Qnil
;
6817 Vwindow_system_version
= Qnil
;
6821 /* arch-tag: 8d812b1f-04a2-4195-a9c4-381f8457a413
6822 (do not change this comment) */