1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 97, 98, 1999
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
34 #include "termhooks.h"
35 /* cm.h must come after dispextern.h on Windows. */
36 #include "dispextern.h"
45 #include "intervals.h"
46 #include "blockinput.h"
50 /* I don't know why DEC Alpha OSF1 fail to compile this file if we
51 include the following file. */
52 /* #include "systty.h" */
53 #include "syssignal.h"
57 #endif /* HAVE_X_WINDOWS */
61 #endif /* HAVE_NTGUI */
63 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
68 /* To get the prototype for `sleep'. */
74 #define max(a, b) ((a) > (b) ? (a) : (b))
75 #define min(a, b) ((a) < (b) ? (a) : (b))
77 /* Get number of chars of output now in the buffer of a stdio stream.
78 This ought to be built in in stdio, but it isn't. Some s- files
79 override this because their stdio internals differ. */
81 #ifdef __GNU_LIBRARY__
83 /* The s- file might have overridden the definition with one that
84 works for the system's C library. But we are using the GNU C
85 library, so this is the right definition for every system. */
87 #ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT
88 #define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT
90 #undef PENDING_OUTPUT_COUNT
91 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
93 #else /* not __GNU_LIBRARY__ */
94 #if !defined (PENDING_OUTPUT_COUNT) && HAVE_STDIO_EXT_H && HAVE___FPENDING
95 #include <stdio_ext.h>
96 #define PENDING_OUTPUT_COUNT(FILE) __fpending (FILE)
98 #ifndef PENDING_OUTPUT_COUNT
99 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
101 #endif /* not __GNU_LIBRARY__ */
103 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
104 #include <term.h> /* for tgetent */
107 /* Structure to pass dimensions around. Used for character bounding
108 boxes, glyph matrix dimensions and alike. */
117 /* Function prototypes. */
119 static void redraw_overlapping_rows
P_ ((struct window
*, int));
120 static void redraw_overlapped_rows
P_ ((struct window
*, int));
121 static int count_blanks
P_ ((struct glyph
*, int));
122 static int count_match
P_ ((struct glyph
*, struct glyph
*,
123 struct glyph
*, struct glyph
*));
124 static unsigned line_draw_cost
P_ ((struct glyph_matrix
*, int));
125 static void update_frame_line
P_ ((struct frame
*, int));
126 static struct dim allocate_matrices_for_frame_redisplay
127 P_ ((Lisp_Object
, int, int, struct dim
, int, int *));
128 static void allocate_matrices_for_window_redisplay
P_ ((struct window
*,
130 static int realloc_glyph_pool
P_ ((struct glyph_pool
*, struct dim
));
131 static void adjust_frame_glyphs
P_ ((struct frame
*));
132 struct glyph_matrix
*new_glyph_matrix
P_ ((struct glyph_pool
*));
133 static void free_glyph_matrix
P_ ((struct glyph_matrix
*));
134 static void adjust_glyph_matrix
P_ ((struct window
*, struct glyph_matrix
*,
135 int, int, struct dim
));
136 static void change_frame_size_1
P_ ((struct frame
*, int, int, int, int, int));
137 static void swap_glyph_pointers
P_ ((struct glyph_row
*, struct glyph_row
*));
138 static int glyph_row_slice_p
P_ ((struct glyph_row
*, struct glyph_row
*));
139 static void fill_up_frame_row_with_spaces
P_ ((struct glyph_row
*, int));
140 static void build_frame_matrix_from_window_tree
P_ ((struct glyph_matrix
*,
142 static void build_frame_matrix_from_leaf_window
P_ ((struct glyph_matrix
*,
144 static struct glyph_pool
*new_glyph_pool
P_ ((void));
145 static void free_glyph_pool
P_ ((struct glyph_pool
*));
146 static void adjust_frame_glyphs_initially
P_ ((void));
147 static void adjust_frame_message_buffer
P_ ((struct frame
*));
148 static void adjust_decode_mode_spec_buffer
P_ ((struct frame
*));
149 static void fill_up_glyph_row_with_spaces
P_ ((struct glyph_row
*));
150 static void build_frame_matrix
P_ ((struct frame
*));
151 void clear_current_matrices
P_ ((struct frame
*));
152 void scroll_glyph_matrix_range
P_ ((struct glyph_matrix
*, int, int,
154 static void clear_window_matrices
P_ ((struct window
*, int));
155 static void fill_up_glyph_row_area_with_spaces
P_ ((struct glyph_row
*, int));
156 static int scrolling_window
P_ ((struct window
*, int));
157 static int update_window_line
P_ ((struct window
*, int));
158 static void update_marginal_area
P_ ((struct window
*, int, int));
159 static int update_text_area
P_ ((struct window
*, int));
160 static void make_current
P_ ((struct glyph_matrix
*, struct glyph_matrix
*,
162 static void mirror_make_current
P_ ((struct window
*, int));
163 void check_window_matrix_pointers
P_ ((struct window
*));
165 static void check_matrix_pointers
P_ ((struct glyph_matrix
*,
166 struct glyph_matrix
*));
168 static void mirror_line_dance
P_ ((struct window
*, int, int, int *, char *));
169 static int update_window_tree
P_ ((struct window
*, int));
170 static int update_window
P_ ((struct window
*, int));
171 static int update_frame_1
P_ ((struct frame
*, int, int));
172 static void set_window_cursor_after_update
P_ ((struct window
*));
173 static int row_equal_p
P_ ((struct window
*, struct glyph_row
*,
174 struct glyph_row
*));
175 static void adjust_frame_glyphs_for_window_redisplay
P_ ((struct frame
*));
176 static void adjust_frame_glyphs_for_frame_redisplay
P_ ((struct frame
*));
177 static void reverse_rows
P_ ((struct glyph_matrix
*, int, int));
178 static int margin_glyphs_to_reserve
P_ ((struct window
*, int, Lisp_Object
));
179 static void sync_window_with_frame_matrix_rows
P_ ((struct window
*));
180 struct window
*frame_row_to_window
P_ ((struct window
*, int));
184 /* Non-zero means don't pause redisplay for pending input. (This is
185 for debugging and for a future implementation of EDT-like
188 int redisplay_dont_pause
;
190 /* Nonzero upon entry to redisplay means do not assume anything about
191 current contents of actual terminal frame; clear and redraw it. */
195 /* Nonzero means last display completed. Zero means it was preempted. */
197 int display_completed
;
199 /* Lisp variable visible-bell; enables use of screen-flash instead of
204 /* Invert the color of the whole frame, at a low level. */
208 /* Line speed of the terminal. */
212 /* Either nil or a symbol naming the window system under which Emacs
215 Lisp_Object Vwindow_system
;
217 /* Version number of X windows: 10, 11 or nil. */
219 Lisp_Object Vwindow_system_version
;
221 /* Vector of glyph definitions. Indexed by glyph number, the contents
222 are a string which is how to output the glyph.
224 If Vglyph_table is nil, a glyph is output by using its low 8 bits
227 This is an obsolete feature that is no longer used. The variable
228 is retained for compatibility. */
230 Lisp_Object Vglyph_table
;
232 /* Display table to use for vectors that don't specify their own. */
234 Lisp_Object Vstandard_display_table
;
236 /* Nonzero means reading single-character input with prompt so put
237 cursor on mini-buffer after the prompt. positive means at end of
238 text in echo area; negative means at beginning of line. */
240 int cursor_in_echo_area
;
242 Lisp_Object Qdisplay_table
;
245 /* The currently selected frame. In a single-frame version, this
246 variable always equals the_only_frame. */
248 Lisp_Object selected_frame
;
250 /* A frame which is not just a mini-buffer, or 0 if there are no such
251 frames. This is usually the most recent such frame that was
252 selected. In a single-frame version, this variable always holds
253 the address of the_only_frame. */
255 struct frame
*last_nonminibuf_frame
;
257 /* Stdio stream being used for copy of all output. */
261 /* Structure for info on cursor positioning. */
265 /* 1 means SIGWINCH happened when not safe. */
267 int delayed_size_change
;
269 /* 1 means glyph initialization has been completed at startup. */
271 static int glyphs_initialized_initially_p
;
273 /* Updated window if != 0. Set by update_window. */
275 struct window
*updated_window
;
277 /* Glyph row updated in update_window_line, and area that is updated. */
279 struct glyph_row
*updated_row
;
282 /* A glyph for a space. */
284 struct glyph space_glyph
;
286 /* Non-zero means update has been performed directly, so that there's
287 no need for redisplay_internal to do much work. Set by
288 direct_output_for_insert. */
290 int redisplay_performed_directly_p
;
292 /* Counts of allocated structures. These counts serve to diagnose
293 memory leaks and double frees. */
295 int glyph_matrix_count
;
296 int glyph_pool_count
;
298 /* If non-null, the frame whose frame matrices are manipulated. If
299 null, window matrices are worked on. */
301 static struct frame
*frame_matrix_frame
;
303 /* Current interface for window-based redisplay. Set from init_xterm.
304 A null value means we are not using window-based redisplay. */
306 struct redisplay_interface
*rif
;
308 /* Non-zero means that fonts have been loaded since the last glyph
309 matrix adjustments. Redisplay must stop, and glyph matrices must
310 be adjusted when this flag becomes non-zero during display. The
311 reason fonts can be loaded so late is that fonts of fontsets are
316 /* Convert vpos and hpos from frame to window and vice versa.
317 This may only be used for terminal frames. */
321 static int window_to_frame_vpos
P_ ((struct window
*, int));
322 static int window_to_frame_hpos
P_ ((struct window
*, int));
323 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
324 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
326 #else /* GLYPH_DEBUG == 0 */
328 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + XFASTINT ((W)->top))
329 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + XFASTINT ((W)->left))
331 #endif /* GLYPH_DEBUG == 0 */
334 /* Like bcopy except never gets confused by overlap. Let this be the
335 first function defined in this file, or change emacs.c where the
336 address of this function is used. */
339 safe_bcopy (from
, to
, size
)
343 if (size
<= 0 || from
== to
)
346 /* If the source and destination don't overlap, then bcopy can
347 handle it. If they do overlap, but the destination is lower in
348 memory than the source, we'll assume bcopy can handle that. */
349 if (to
< from
|| from
+ size
<= to
)
350 bcopy (from
, to
, size
);
352 /* Otherwise, we'll copy from the end. */
355 register char *endf
= from
+ size
;
356 register char *endt
= to
+ size
;
358 /* If TO - FROM is large, then we should break the copy into
359 nonoverlapping chunks of TO - FROM bytes each. However, if
360 TO - FROM is small, then the bcopy function call overhead
361 makes this not worth it. The crossover point could be about
362 anywhere. Since I don't think the obvious copy loop is too
363 bad, I'm trying to err in its favor. */
368 while (endf
!= from
);
380 bcopy (endf
, endt
, to
- from
);
383 /* If SIZE wasn't a multiple of TO - FROM, there will be a
384 little left over. The amount left over is (endt + (to -
385 from)) - to, which is endt - from. */
386 bcopy (from
, to
, endt
- from
);
393 /***********************************************************************
395 ***********************************************************************/
397 /* Allocate and return a glyph_matrix structure. POOL is the glyph
398 pool from which memory for the matrix should be allocated, or null
399 for window-based redisplay where no glyph pools are used. The
400 member `pool' of the glyph matrix structure returned is set to
401 POOL, the structure is otherwise zeroed. */
403 struct glyph_matrix
*
404 new_glyph_matrix (pool
)
405 struct glyph_pool
*pool
;
407 struct glyph_matrix
*result
;
409 /* Allocate and clear. */
410 result
= (struct glyph_matrix
*) xmalloc (sizeof *result
);
411 bzero (result
, sizeof *result
);
413 /* Increment number of allocated matrices. This count is used
414 to detect memory leaks. */
415 ++glyph_matrix_count
;
417 /* Set pool and return. */
423 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
425 The global counter glyph_matrix_count is decremented when a matrix
426 is freed. If the count gets negative, more structures were freed
427 than allocated, i.e. one matrix was freed more than once or a bogus
428 pointer was passed to this function.
430 If MATRIX->pool is null, this means that the matrix manages its own
431 glyph memory---this is done for matrices on X frames. Freeing the
432 matrix also frees the glyph memory in this case. */
435 free_glyph_matrix (matrix
)
436 struct glyph_matrix
*matrix
;
442 /* Detect the case that more matrices are freed than were
444 if (--glyph_matrix_count
< 0)
447 /* Free glyph memory if MATRIX owns it. */
448 if (matrix
->pool
== NULL
)
449 for (i
= 0; i
< matrix
->rows_allocated
; ++i
)
450 xfree (matrix
->rows
[i
].glyphs
[LEFT_MARGIN_AREA
]);
452 /* Free row structures and the matrix itself. */
453 xfree (matrix
->rows
);
459 /* Return the number of glyphs to reserve for a marginal area of
460 window W. TOTAL_GLYPHS is the number of glyphs in a complete
461 display line of window W. MARGIN gives the width of the marginal
462 area in canonical character units. MARGIN should be an integer
466 margin_glyphs_to_reserve (w
, total_glyphs
, margin
)
473 if (NUMBERP (margin
))
475 int width
= XFASTINT (w
->width
);
476 double d
= max (0, XFLOATINT (margin
));
477 d
= min (width
/ 2 - 1, d
);
478 n
= (int) ((double) total_glyphs
/ width
* d
);
487 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
490 W is null if the function is called for a frame glyph matrix.
491 Otherwise it is the window MATRIX is a member of. X and Y are the
492 indices of the first column and row of MATRIX within the frame
493 matrix, if such a matrix exists. They are zero for purely
494 window-based redisplay. DIM is the needed size of the matrix.
496 In window-based redisplay, where no frame matrices exist, glyph
497 matrices manage their own glyph storage. Otherwise, they allocate
498 storage from a common frame glyph pool which can be found in
501 The reason for this memory management strategy is to avoid complete
502 frame redraws if possible. When we allocate from a common pool, a
503 change of the location or size of a sub-matrix within the pool
504 requires a complete redisplay of the frame because we cannot easily
505 make sure that the current matrices of all windows still agree with
506 what is displayed on the screen. While this is usually fast, it
507 leads to screen flickering. */
510 adjust_glyph_matrix (w
, matrix
, x
, y
, dim
)
512 struct glyph_matrix
*matrix
;
518 int marginal_areas_changed_p
= 0;
519 int header_line_changed_p
= 0;
520 int header_line_p
= 0;
521 int left
= -1, right
= -1;
522 int window_x
, window_y
, window_width
, window_height
;
524 /* See if W had a top line that has disappeared now, or vice versa. */
527 header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
528 header_line_changed_p
= header_line_p
!= matrix
->header_line_p
;
530 matrix
->header_line_p
= header_line_p
;
532 /* Do nothing if MATRIX' size, position, vscroll, and marginal areas
533 haven't changed. This optimization is important because preserving
534 the matrix means preventing redisplay. */
535 if (matrix
->pool
== NULL
)
537 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
538 left
= margin_glyphs_to_reserve (w
, dim
.width
, w
->left_margin_width
);
539 right
= margin_glyphs_to_reserve (w
, dim
.width
, w
->right_margin_width
);
540 xassert (left
>= 0 && right
>= 0);
541 marginal_areas_changed_p
= (left
!= matrix
->left_margin_glyphs
542 || right
!= matrix
->right_margin_glyphs
);
544 if (!marginal_areas_changed_p
546 && !header_line_changed_p
547 && matrix
->window_top_y
== XFASTINT (w
->top
)
548 && matrix
->window_height
== window_height
549 && matrix
->window_vscroll
== w
->vscroll
550 && matrix
->window_width
== window_width
)
554 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
555 if (matrix
->rows_allocated
< dim
.height
)
557 int size
= dim
.height
* sizeof (struct glyph_row
);
558 new_rows
= dim
.height
- matrix
->rows_allocated
;
559 matrix
->rows
= (struct glyph_row
*) xrealloc (matrix
->rows
, size
);
560 bzero (matrix
->rows
+ matrix
->rows_allocated
,
561 new_rows
* sizeof *matrix
->rows
);
562 matrix
->rows_allocated
= dim
.height
;
567 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
568 on a frame not using window-based redisplay. Set up pointers for
569 each row into the glyph pool. */
572 xassert (matrix
->pool
->glyphs
);
576 left
= margin_glyphs_to_reserve (w
, dim
.width
,
577 w
->left_margin_width
);
578 right
= margin_glyphs_to_reserve (w
, dim
.width
,
579 w
->right_margin_width
);
584 for (i
= 0; i
< dim
.height
; ++i
)
586 struct glyph_row
*row
= &matrix
->rows
[i
];
588 row
->glyphs
[LEFT_MARGIN_AREA
]
589 = (matrix
->pool
->glyphs
590 + (y
+ i
) * matrix
->pool
->ncolumns
594 || row
== matrix
->rows
+ dim
.height
- 1
595 || (row
== matrix
->rows
&& matrix
->header_line_p
))
597 row
->glyphs
[TEXT_AREA
]
598 = row
->glyphs
[LEFT_MARGIN_AREA
];
599 row
->glyphs
[RIGHT_MARGIN_AREA
]
600 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
601 row
->glyphs
[LAST_AREA
]
602 = row
->glyphs
[RIGHT_MARGIN_AREA
];
606 row
->glyphs
[TEXT_AREA
]
607 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
608 row
->glyphs
[RIGHT_MARGIN_AREA
]
609 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
610 row
->glyphs
[LAST_AREA
]
611 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
615 matrix
->left_margin_glyphs
= left
;
616 matrix
->right_margin_glyphs
= right
;
620 /* If MATRIX->pool is null, MATRIX is responsible for managing
621 its own memory. Allocate glyph memory from the heap. */
622 if (dim
.width
> matrix
->matrix_w
624 || header_line_changed_p
625 || marginal_areas_changed_p
)
627 struct glyph_row
*row
= matrix
->rows
;
628 struct glyph_row
*end
= row
+ matrix
->rows_allocated
;
632 row
->glyphs
[LEFT_MARGIN_AREA
]
633 = (struct glyph
*) xrealloc (row
->glyphs
[LEFT_MARGIN_AREA
],
635 * sizeof (struct glyph
)));
637 /* The mode line never has marginal areas. */
638 if (row
== matrix
->rows
+ dim
.height
- 1
639 || (row
== matrix
->rows
&& matrix
->header_line_p
))
641 row
->glyphs
[TEXT_AREA
]
642 = row
->glyphs
[LEFT_MARGIN_AREA
];
643 row
->glyphs
[RIGHT_MARGIN_AREA
]
644 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
645 row
->glyphs
[LAST_AREA
]
646 = row
->glyphs
[RIGHT_MARGIN_AREA
];
650 row
->glyphs
[TEXT_AREA
]
651 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
652 row
->glyphs
[RIGHT_MARGIN_AREA
]
653 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
654 row
->glyphs
[LAST_AREA
]
655 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
661 xassert (left
>= 0 && right
>= 0);
662 matrix
->left_margin_glyphs
= left
;
663 matrix
->right_margin_glyphs
= right
;
666 /* Number of rows to be used by MATRIX. */
667 matrix
->nrows
= dim
.height
;
669 /* Mark rows in a current matrix of a window as not having valid
670 contents. It's important to not do this for desired matrices.
671 When Emacs starts, it may already be building desired matrices
672 when this function runs. */
673 if (w
&& matrix
== w
->current_matrix
)
675 /* Optimize the case that only the height has changed (C-x 2,
676 upper window). Invalidate all rows that are no longer part
678 if (!marginal_areas_changed_p
679 && matrix
->window_top_y
== XFASTINT (w
->top
)
680 && matrix
->window_width
== window_width
)
683 while (matrix
->rows
[i
].enabled_p
684 && (MATRIX_ROW_BOTTOM_Y (matrix
->rows
+ i
)
685 < matrix
->window_height
))
688 /* Window end is invalid, if inside of the rows that
690 if (INTEGERP (w
->window_end_vpos
)
691 && XFASTINT (w
->window_end_vpos
) >= i
)
692 w
->window_end_valid
= Qnil
;
694 while (i
< matrix
->nrows
)
695 matrix
->rows
[i
++].enabled_p
= 0;
699 for (i
= 0; i
< matrix
->nrows
; ++i
)
700 matrix
->rows
[i
].enabled_p
= 0;
704 /* Remember last values to be able to optimize frame redraws. */
705 matrix
->matrix_x
= x
;
706 matrix
->matrix_y
= y
;
707 matrix
->matrix_w
= dim
.width
;
708 matrix
->matrix_h
= dim
.height
;
710 /* Record the top y location and height of W at the time the matrix
711 was last adjusted. This is used to optimize redisplay above. */
714 matrix
->window_top_y
= XFASTINT (w
->top
);
715 matrix
->window_height
= window_height
;
716 matrix
->window_width
= window_width
;
717 matrix
->window_vscroll
= w
->vscroll
;
722 /* Reverse the contents of rows in MATRIX between START and END. The
723 contents of the row at END - 1 end up at START, END - 2 at START +
724 1 etc. This is part of the implementation of rotate_matrix (see
728 reverse_rows (matrix
, start
, end
)
729 struct glyph_matrix
*matrix
;
734 for (i
= start
, j
= end
- 1; i
< j
; ++i
, --j
)
736 /* Non-ISO HP/UX compiler doesn't like auto struct
738 struct glyph_row temp
;
739 temp
= matrix
->rows
[i
];
740 matrix
->rows
[i
] = matrix
->rows
[j
];
741 matrix
->rows
[j
] = temp
;
746 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
747 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
748 indices. (Note: this does not copy glyphs, only glyph pointers in
749 row structures are moved around).
751 The algorithm used for rotating the vector was, I believe, first
752 described by Kernighan. See the vector R as consisting of two
753 sub-vectors AB, where A has length BY for BY >= 0. The result
754 after rotating is then BA. Reverse both sub-vectors to get ArBr
755 and reverse the result to get (ArBr)r which is BA. Similar for
759 rotate_matrix (matrix
, first
, last
, by
)
760 struct glyph_matrix
*matrix
;
765 /* Up (rotate left, i.e. towards lower indices). */
767 reverse_rows (matrix
, first
, first
+ by
);
768 reverse_rows (matrix
, first
+ by
, last
);
769 reverse_rows (matrix
, first
, last
);
773 /* Down (rotate right, i.e. towards higher indices). */
774 reverse_rows (matrix
, last
- by
, last
);
775 reverse_rows (matrix
, first
, last
- by
);
776 reverse_rows (matrix
, first
, last
);
781 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
782 with indices START <= index < END. Increment positions by DELTA/
786 increment_matrix_positions (matrix
, start
, end
, delta
, delta_bytes
)
787 struct glyph_matrix
*matrix
;
788 int start
, end
, delta
, delta_bytes
;
790 /* Check that START and END are reasonable values. */
791 xassert (start
>= 0 && start
<= matrix
->nrows
);
792 xassert (end
>= 0 && end
<= matrix
->nrows
);
793 xassert (start
<= end
);
795 for (; start
< end
; ++start
)
796 increment_row_positions (matrix
->rows
+ start
, delta
, delta_bytes
);
800 /* Enable a range of rows in glyph matrix MATRIX. START and END are
801 the row indices of the first and last + 1 row to enable. If
802 ENABLED_P is non-zero, enabled_p flags in rows will be set to 1. */
805 enable_glyph_matrix_rows (matrix
, start
, end
, enabled_p
)
806 struct glyph_matrix
*matrix
;
810 xassert (start
<= end
);
811 xassert (start
>= 0 && start
< matrix
->nrows
);
812 xassert (end
>= 0 && end
<= matrix
->nrows
);
814 for (; start
< end
; ++start
)
815 matrix
->rows
[start
].enabled_p
= enabled_p
!= 0;
821 This empties all rows in MATRIX by setting the enabled_p flag for
822 all rows of the matrix to zero. The function prepare_desired_row
823 will eventually really clear a row when it sees one with a zero
826 Resets update hints to defaults value. The only update hint
827 currently present is the flag MATRIX->no_scrolling_p. */
830 clear_glyph_matrix (matrix
)
831 struct glyph_matrix
*matrix
;
835 enable_glyph_matrix_rows (matrix
, 0, matrix
->nrows
, 0);
836 matrix
->no_scrolling_p
= 0;
841 /* Shift part of the glyph matrix MATRIX of window W up or down.
842 Increment y-positions in glyph rows between START and END by DY,
843 and recompute their visible height. */
846 shift_glyph_matrix (w
, matrix
, start
, end
, dy
)
848 struct glyph_matrix
*matrix
;
853 xassert (start
<= end
);
854 xassert (start
>= 0 && start
< matrix
->nrows
);
855 xassert (end
>= 0 && end
<= matrix
->nrows
);
857 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
858 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
860 for (; start
< end
; ++start
)
862 struct glyph_row
*row
= &matrix
->rows
[start
];
867 row
->visible_height
= row
->height
- (min_y
- row
->y
);
868 else if (row
->y
+ row
->height
> max_y
)
869 row
->visible_height
= row
->height
- (row
->y
+ row
->height
- max_y
);
871 row
->visible_height
= row
->height
;
876 /* Mark all rows in current matrices of frame F as invalid. Marking
877 invalid is done by setting enabled_p to zero for all rows in a
881 clear_current_matrices (f
)
882 register struct frame
*f
;
884 /* Clear frame current matrix, if we have one. */
885 if (f
->current_matrix
)
886 clear_glyph_matrix (f
->current_matrix
);
888 /* Clear the matrix of the menu bar window, if such a window exists.
889 The menu bar window is currently used to display menus on X when
890 no toolkit support is compiled in. */
891 if (WINDOWP (f
->menu_bar_window
))
892 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->current_matrix
);
894 /* Clear the matrix of the tool-bar window, if any. */
895 if (WINDOWP (f
->tool_bar_window
))
896 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
898 /* Clear current window matrices. */
899 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
900 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 0);
904 /* Clear out all display lines of F for a coming redisplay. */
907 clear_desired_matrices (f
)
908 register struct frame
*f
;
910 if (f
->desired_matrix
)
911 clear_glyph_matrix (f
->desired_matrix
);
913 if (WINDOWP (f
->menu_bar_window
))
914 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->desired_matrix
);
916 if (WINDOWP (f
->tool_bar_window
))
917 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->desired_matrix
);
919 /* Do it for window matrices. */
920 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
921 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
925 /* Clear matrices in window tree rooted in W. If DESIRED_P is
926 non-zero clear desired matrices, otherwise clear current matrices. */
929 clear_window_matrices (w
, desired_p
)
935 if (!NILP (w
->hchild
))
937 xassert (WINDOWP (w
->hchild
));
938 clear_window_matrices (XWINDOW (w
->hchild
), desired_p
);
940 else if (!NILP (w
->vchild
))
942 xassert (WINDOWP (w
->vchild
));
943 clear_window_matrices (XWINDOW (w
->vchild
), desired_p
);
948 clear_glyph_matrix (w
->desired_matrix
);
951 clear_glyph_matrix (w
->current_matrix
);
952 w
->window_end_valid
= Qnil
;
956 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
962 /***********************************************************************
965 See dispextern.h for an overall explanation of glyph rows.
966 ***********************************************************************/
968 /* Clear glyph row ROW. Do it in a way that makes it robust against
969 changes in the glyph_row structure, i.e. addition or removal of
970 structure members. */
973 clear_glyph_row (row
)
974 struct glyph_row
*row
;
976 struct glyph
*p
[1 + LAST_AREA
];
977 static struct glyph_row null_row
;
980 p
[LEFT_MARGIN_AREA
] = row
->glyphs
[LEFT_MARGIN_AREA
];
981 p
[TEXT_AREA
] = row
->glyphs
[TEXT_AREA
];
982 p
[RIGHT_MARGIN_AREA
] = row
->glyphs
[RIGHT_MARGIN_AREA
];
983 p
[LAST_AREA
] = row
->glyphs
[LAST_AREA
];
988 /* Restore pointers. */
989 row
->glyphs
[LEFT_MARGIN_AREA
] = p
[LEFT_MARGIN_AREA
];
990 row
->glyphs
[TEXT_AREA
] = p
[TEXT_AREA
];
991 row
->glyphs
[RIGHT_MARGIN_AREA
] = p
[RIGHT_MARGIN_AREA
];
992 row
->glyphs
[LAST_AREA
] = p
[LAST_AREA
];
994 #if 0 /* At some point, some bit-fields of struct glyph were not set,
995 which made glyphs unequal when compared with GLYPH_EQUAL_P.
996 Redisplay outputs such glyphs, and flickering effects were
997 the result. This also depended on the contents of memory
998 returned by xmalloc. If flickering happens again, activate
999 the code below If the flickering is gone with that, chances
1000 are that the flickering has the same reason as here. */
1001 bzero (p
[0], (char *) p
[LAST_AREA
] - (char *) p
[0]);
1006 /* Make ROW an empty, enabled row of canonical character height,
1007 in window W starting at y-position Y. */
1010 blank_row (w
, row
, y
)
1012 struct glyph_row
*row
;
1017 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
1018 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
1020 clear_glyph_row (row
);
1022 row
->ascent
= row
->phys_ascent
= 0;
1023 row
->height
= row
->phys_height
= CANON_Y_UNIT (XFRAME (w
->frame
));
1026 row
->visible_height
= row
->height
- (min_y
- row
->y
);
1027 else if (row
->y
+ row
->height
> max_y
)
1028 row
->visible_height
= row
->height
- (row
->y
+ row
->height
- max_y
);
1030 row
->visible_height
= row
->height
;
1036 /* Increment buffer positions in glyph row ROW. DELTA and DELTA_BYTES
1037 are the amounts by which to change positions. Note that the first
1038 glyph of the text area of a row can have a buffer position even if
1039 the used count of the text area is zero. Such rows display line
1043 increment_row_positions (row
, delta
, delta_bytes
)
1044 struct glyph_row
*row
;
1045 int delta
, delta_bytes
;
1049 /* Increment start and end positions. */
1050 MATRIX_ROW_START_CHARPOS (row
) += delta
;
1051 MATRIX_ROW_START_BYTEPOS (row
) += delta_bytes
;
1052 MATRIX_ROW_END_CHARPOS (row
) += delta
;
1053 MATRIX_ROW_END_BYTEPOS (row
) += delta_bytes
;
1055 /* Increment positions in glyphs. */
1056 for (area
= 0; area
< LAST_AREA
; ++area
)
1057 for (i
= 0; i
< row
->used
[area
]; ++i
)
1058 if (BUFFERP (row
->glyphs
[area
][i
].object
)
1059 && row
->glyphs
[area
][i
].charpos
> 0)
1060 row
->glyphs
[area
][i
].charpos
+= delta
;
1062 /* Capture the case of rows displaying a line end. */
1063 if (row
->used
[TEXT_AREA
] == 0
1064 && MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1065 row
->glyphs
[TEXT_AREA
]->charpos
+= delta
;
1070 /* Swap glyphs between two glyph rows A and B. This exchanges glyph
1071 contents, i.e. glyph structure contents are exchanged between A and
1072 B without changing glyph pointers in A and B. */
1075 swap_glyphs_in_rows (a
, b
)
1076 struct glyph_row
*a
, *b
;
1080 for (area
= 0; area
< LAST_AREA
; ++area
)
1082 /* Number of glyphs to swap. */
1083 int max_used
= max (a
->used
[area
], b
->used
[area
]);
1085 /* Start of glyphs in area of row A. */
1086 struct glyph
*glyph_a
= a
->glyphs
[area
];
1088 /* End + 1 of glyphs in area of row A. */
1089 struct glyph
*glyph_a_end
= a
->glyphs
[max_used
];
1091 /* Start of glyphs in area of row B. */
1092 struct glyph
*glyph_b
= b
->glyphs
[area
];
1094 while (glyph_a
< glyph_a_end
)
1096 /* Non-ISO HP/UX compiler doesn't like auto struct
1100 *glyph_a
= *glyph_b
;
1110 /* Exchange pointers to glyph memory between glyph rows A and B. */
1113 swap_glyph_pointers (a
, b
)
1114 struct glyph_row
*a
, *b
;
1117 for (i
= 0; i
< LAST_AREA
+ 1; ++i
)
1119 struct glyph
*temp
= a
->glyphs
[i
];
1120 a
->glyphs
[i
] = b
->glyphs
[i
];
1121 b
->glyphs
[i
] = temp
;
1126 /* Copy glyph row structure FROM to glyph row structure TO, except
1127 that glyph pointers in the structures are left unchanged. */
1130 copy_row_except_pointers (to
, from
)
1131 struct glyph_row
*to
, *from
;
1133 struct glyph
*pointers
[1 + LAST_AREA
];
1135 /* Save glyph pointers of TO. */
1136 bcopy (to
->glyphs
, pointers
, sizeof to
->glyphs
);
1138 /* Do a structure assignment. */
1141 /* Restore original pointers of TO. */
1142 bcopy (pointers
, to
->glyphs
, sizeof to
->glyphs
);
1146 /* Copy contents of glyph row FROM to glyph row TO. Glyph pointers in
1147 TO and FROM are left unchanged. Glyph contents are copied from the
1148 glyph memory of FROM to the glyph memory of TO. Increment buffer
1149 positions in row TO by DELTA/ DELTA_BYTES. */
1152 copy_glyph_row_contents (to
, from
, delta
, delta_bytes
)
1153 struct glyph_row
*to
, *from
;
1154 int delta
, delta_bytes
;
1158 /* This is like a structure assignment TO = FROM, except that
1159 glyph pointers in the rows are left unchanged. */
1160 copy_row_except_pointers (to
, from
);
1162 /* Copy glyphs from FROM to TO. */
1163 for (area
= 0; area
< LAST_AREA
; ++area
)
1164 if (from
->used
[area
])
1165 bcopy (from
->glyphs
[area
], to
->glyphs
[area
],
1166 from
->used
[area
] * sizeof (struct glyph
));
1168 /* Increment buffer positions in TO by DELTA. */
1169 increment_row_positions (to
, delta
, delta_bytes
);
1173 /* Assign glyph row FROM to glyph row TO. This works like a structure
1174 assignment TO = FROM, except that glyph pointers are not copied but
1175 exchanged between TO and FROM. Pointers must be exchanged to avoid
1179 assign_row (to
, from
)
1180 struct glyph_row
*to
, *from
;
1182 swap_glyph_pointers (to
, from
);
1183 copy_row_except_pointers (to
, from
);
1187 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1188 a row in a window matrix, is a slice of the glyph memory of the
1189 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1190 is non-zero if the glyph memory of WINDOW_ROW is part of the glyph
1191 memory of FRAME_ROW. */
1194 glyph_row_slice_p (window_row
, frame_row
)
1195 struct glyph_row
*window_row
, *frame_row
;
1197 struct glyph
*window_glyph_start
= window_row
->glyphs
[0];
1198 struct glyph
*frame_glyph_start
= frame_row
->glyphs
[0];
1199 struct glyph
*frame_glyph_end
= frame_row
->glyphs
[LAST_AREA
];
1201 return (frame_glyph_start
<= window_glyph_start
1202 && window_glyph_start
< frame_glyph_end
);
1208 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1209 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1210 in WINDOW_MATRIX is found satisfying the condition. */
1212 static struct glyph_row
*
1213 find_glyph_row_slice (window_matrix
, frame_matrix
, row
)
1214 struct glyph_matrix
*window_matrix
, *frame_matrix
;
1219 xassert (row
>= 0 && row
< frame_matrix
->nrows
);
1221 for (i
= 0; i
< window_matrix
->nrows
; ++i
)
1222 if (glyph_row_slice_p (window_matrix
->rows
+ i
,
1223 frame_matrix
->rows
+ row
))
1226 return i
< window_matrix
->nrows
? window_matrix
->rows
+ i
: 0;
1231 /* Prepare ROW for display. Desired rows are cleared lazily,
1232 i.e. they are only marked as to be cleared by setting their
1233 enabled_p flag to zero. When a row is to be displayed, a prior
1234 call to this function really clears it. */
1237 prepare_desired_row (row
)
1238 struct glyph_row
*row
;
1240 if (!row
->enabled_p
)
1242 clear_glyph_row (row
);
1248 /* Return a hash code for glyph row ROW. */
1251 line_hash_code (row
)
1252 struct glyph_row
*row
;
1260 /* Give all highlighted lines the same hash code
1261 so as to encourage scrolling to leave them in place. */
1266 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
1267 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
1271 int c
= glyph
->u
.ch
;
1272 int face_id
= glyph
->face_id
;
1273 if (must_write_spaces
)
1275 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + c
;
1276 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + face_id
;
1289 /* Return the cost of drawing line VPOS In MATRIX. The cost equals
1290 the number of characters in the line. If must_write_spaces is
1291 zero, leading and trailing spaces are ignored. */
1294 line_draw_cost (matrix
, vpos
)
1295 struct glyph_matrix
*matrix
;
1298 struct glyph_row
*row
= matrix
->rows
+ vpos
;
1299 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
1300 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
];
1302 Lisp_Object
*glyph_table_base
= GLYPH_TABLE_BASE
;
1303 int glyph_table_len
= GLYPH_TABLE_LENGTH
;
1305 /* Ignore trailing and leading spaces if we can. */
1306 if (!must_write_spaces
)
1308 /* Skip from the end over trailing spaces. */
1309 while (end
!= beg
&& CHAR_GLYPH_SPACE_P (*end
))
1312 /* All blank line. */
1316 /* Skip over leading spaces. */
1317 while (CHAR_GLYPH_SPACE_P (*beg
))
1321 /* If we don't have a glyph-table, each glyph is one character,
1322 so return the number of glyphs. */
1323 if (glyph_table_base
== 0)
1327 /* Otherwise, scan the glyphs and accumulate their total length
1332 GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*beg
);
1335 || GLYPH_SIMPLE_P (glyph_table_base
, glyph_table_len
, g
))
1338 len
+= GLYPH_LENGTH (glyph_table_base
, g
);
1348 /* Test two glyph rows A and B for equality. Value is non-zero if A
1349 and B have equal contents. W is the window to which the glyphs
1350 rows A and B belong. It is needed here to test for partial row
1354 row_equal_p (w
, a
, b
)
1356 struct glyph_row
*a
, *b
;
1360 else if (a
->hash
!= b
->hash
)
1364 struct glyph
*a_glyph
, *b_glyph
, *a_end
;
1367 /* Compare glyphs. */
1368 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
1370 if (a
->used
[area
] != b
->used
[area
])
1373 a_glyph
= a
->glyphs
[area
];
1374 a_end
= a_glyph
+ a
->used
[area
];
1375 b_glyph
= b
->glyphs
[area
];
1377 while (a_glyph
< a_end
1378 && GLYPH_EQUAL_P (a_glyph
, b_glyph
))
1379 ++a_glyph
, ++b_glyph
;
1381 if (a_glyph
!= a_end
)
1385 if (a
->truncated_on_left_p
!= b
->truncated_on_left_p
1386 || a
->inverse_p
!= b
->inverse_p
1387 || a
->fill_line_p
!= b
->fill_line_p
1388 || a
->truncated_on_right_p
!= b
->truncated_on_right_p
1389 || a
->overlay_arrow_p
!= b
->overlay_arrow_p
1390 || a
->continued_p
!= b
->continued_p
1391 || a
->indicate_empty_line_p
!= b
->indicate_empty_line_p
1392 || a
->overlapped_p
!= b
->overlapped_p
1393 || (MATRIX_ROW_CONTINUATION_LINE_P (a
)
1394 != MATRIX_ROW_CONTINUATION_LINE_P (b
))
1395 /* Different partially visible characters on left margin. */
1397 /* Different height. */
1398 || a
->ascent
!= b
->ascent
1399 || a
->phys_ascent
!= b
->phys_ascent
1400 || a
->phys_height
!= b
->phys_height
1401 || a
->visible_height
!= b
->visible_height
)
1410 /***********************************************************************
1413 See dispextern.h for an overall explanation of glyph pools.
1414 ***********************************************************************/
1416 /* Allocate a glyph_pool structure. The structure returned is
1417 initialized with zeros. The global variable glyph_pool_count is
1418 incremented for each pool allocated. */
1420 static struct glyph_pool
*
1423 struct glyph_pool
*result
;
1425 /* Allocate a new glyph_pool and clear it. */
1426 result
= (struct glyph_pool
*) xmalloc (sizeof *result
);
1427 bzero (result
, sizeof *result
);
1429 /* For memory leak and double deletion checking. */
1436 /* Free a glyph_pool structure POOL. The function may be called with
1437 a null POOL pointer. The global variable glyph_pool_count is
1438 decremented with every pool structure freed. If this count gets
1439 negative, more structures were freed than allocated, i.e. one
1440 structure must have been freed more than once or a bogus pointer
1441 was passed to free_glyph_pool. */
1444 free_glyph_pool (pool
)
1445 struct glyph_pool
*pool
;
1449 /* More freed than allocated? */
1451 xassert (glyph_pool_count
>= 0);
1453 xfree (pool
->glyphs
);
1459 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1460 columns we need. This function never shrinks a pool. The only
1461 case in which this would make sense, would be when a frame's size
1462 is changed from a large value to a smaller one. But, if someone
1463 does it once, we can expect that he will do it again.
1465 Value is non-zero if the pool changed in a way which makes
1466 re-adjusting window glyph matrices necessary. */
1469 realloc_glyph_pool (pool
, matrix_dim
)
1470 struct glyph_pool
*pool
;
1471 struct dim matrix_dim
;
1476 changed_p
= (pool
->glyphs
== 0
1477 || matrix_dim
.height
!= pool
->nrows
1478 || matrix_dim
.width
!= pool
->ncolumns
);
1480 /* Enlarge the glyph pool. */
1481 needed
= matrix_dim
.width
* matrix_dim
.height
;
1482 if (needed
> pool
->nglyphs
)
1484 int size
= needed
* sizeof (struct glyph
);
1487 pool
->glyphs
= (struct glyph
*) xrealloc (pool
->glyphs
, size
);
1490 pool
->glyphs
= (struct glyph
*) xmalloc (size
);
1491 bzero (pool
->glyphs
, size
);
1494 pool
->nglyphs
= needed
;
1497 /* Remember the number of rows and columns because (a) we use then
1498 to do sanity checks, and (b) the number of columns determines
1499 where rows in the frame matrix start---this must be available to
1500 determine pointers to rows of window sub-matrices. */
1501 pool
->nrows
= matrix_dim
.height
;
1502 pool
->ncolumns
= matrix_dim
.width
;
1509 /***********************************************************************
1511 ***********************************************************************/
1516 /* Flush standard output. This is sometimes useful to call from
1526 /* Check that no glyph pointers have been lost in MATRIX. If a
1527 pointer has been lost, e.g. by using a structure assignment between
1528 rows, at least one pointer must occur more than once in the rows of
1532 check_matrix_pointer_lossage (matrix
)
1533 struct glyph_matrix
*matrix
;
1537 for (i
= 0; i
< matrix
->nrows
; ++i
)
1538 for (j
= 0; j
< matrix
->nrows
; ++j
)
1540 || (matrix
->rows
[i
].glyphs
[TEXT_AREA
]
1541 != matrix
->rows
[j
].glyphs
[TEXT_AREA
]));
1545 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1548 matrix_row (matrix
, row
)
1549 struct glyph_matrix
*matrix
;
1552 xassert (matrix
&& matrix
->rows
);
1553 xassert (row
>= 0 && row
< matrix
->nrows
);
1555 /* That's really too slow for normal testing because this function
1556 is called almost everywhere. Although---it's still astonishingly
1557 fast, so it is valuable to have for debugging purposes. */
1559 check_matrix_pointer_lossage (matrix
);
1562 return matrix
->rows
+ row
;
1566 #if 0 /* This function makes invalid assumptions when text is
1567 partially invisible. But it might come handy for debugging
1570 /* Check invariants that must hold for an up to date current matrix of
1574 check_matrix_invariants (w
)
1577 struct glyph_matrix
*matrix
= w
->current_matrix
;
1578 int yb
= window_text_bottom_y (w
);
1579 struct glyph_row
*row
= matrix
->rows
;
1580 struct glyph_row
*last_text_row
= NULL
;
1581 struct buffer
*saved
= current_buffer
;
1582 struct buffer
*buffer
= XBUFFER (w
->buffer
);
1585 /* This can sometimes happen for a fresh window. */
1586 if (matrix
->nrows
< 2)
1589 set_buffer_temp (buffer
);
1591 /* Note: last row is always reserved for the mode line. */
1592 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1593 && MATRIX_ROW_BOTTOM_Y (row
) < yb
)
1595 struct glyph_row
*next
= row
+ 1;
1597 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1598 last_text_row
= row
;
1600 /* Check that character and byte positions are in sync. */
1601 xassert (MATRIX_ROW_START_BYTEPOS (row
)
1602 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row
)));
1604 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1605 have such a position temporarily in case of a minibuffer
1606 displaying something like `[Sole completion]' at its end. */
1607 if (MATRIX_ROW_END_CHARPOS (row
) < BUF_ZV (current_buffer
))
1608 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1609 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row
)));
1611 /* Check that end position of `row' is equal to start position
1613 if (next
->enabled_p
&& MATRIX_ROW_DISPLAYS_TEXT_P (next
))
1615 xassert (MATRIX_ROW_END_CHARPOS (row
)
1616 == MATRIX_ROW_START_CHARPOS (next
));
1617 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1618 == MATRIX_ROW_START_BYTEPOS (next
));
1623 xassert (w
->current_matrix
->nrows
== w
->desired_matrix
->nrows
);
1624 xassert (w
->desired_matrix
->rows
!= NULL
);
1625 set_buffer_temp (saved
);
1630 #endif /* GLYPH_DEBUG != 0 */
1634 /**********************************************************************
1635 Allocating/ Adjusting Glyph Matrices
1636 **********************************************************************/
1638 /* Allocate glyph matrices over a window tree for a frame-based
1641 X and Y are column/row within the frame glyph matrix where
1642 sub-matrices for the window tree rooted at WINDOW must be
1643 allocated. CH_DIM contains the dimensions of the smallest
1644 character that could be used during display. DIM_ONLY_P non-zero
1645 means that the caller of this function is only interested in the
1646 result matrix dimension, and matrix adjustments should not be
1649 The function returns the total width/height of the sub-matrices of
1650 the window tree. If called on a frame root window, the computation
1651 will take the mini-buffer window into account.
1653 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1655 NEW_LEAF_MATRIX set if any window in the tree did not have a
1656 glyph matrices yet, and
1658 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1659 any window in the tree will be changed or have been changed (see
1662 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1665 Windows are arranged into chains of windows on the same level
1666 through the next fields of window structures. Such a level can be
1667 either a sequence of horizontally adjacent windows from left to
1668 right, or a sequence of vertically adjacent windows from top to
1669 bottom. Each window in a horizontal sequence can be either a leaf
1670 window or a vertical sequence; a window in a vertical sequence can
1671 be either a leaf or a horizontal sequence. All windows in a
1672 horizontal sequence have the same height, and all windows in a
1673 vertical sequence have the same width.
1675 This function uses, for historical reasons, a more general
1676 algorithm to determine glyph matrix dimensions that would be
1679 The matrix height of a horizontal sequence is determined by the
1680 maximum height of any matrix in the sequence. The matrix width of
1681 a horizontal sequence is computed by adding up matrix widths of
1682 windows in the sequence.
1684 |<------- result width ------->|
1685 +---------+----------+---------+ ---
1688 +---------+ | | result height
1693 The matrix width of a vertical sequence is the maximum matrix width
1694 of any window in the sequence. Its height is computed by adding up
1695 matrix heights of windows in the sequence.
1697 |<---- result width -->|
1705 +------------+---------+ |
1708 +------------+---------+ --- */
1710 /* Bit indicating that a new matrix will be allocated or has been
1713 #define NEW_LEAF_MATRIX (1 << 0)
1715 /* Bit indicating that a matrix will or has changed its location or
1718 #define CHANGED_LEAF_MATRIX (1 << 1)
1721 allocate_matrices_for_frame_redisplay (window
, x
, y
, ch_dim
,
1722 dim_only_p
, window_change_flags
)
1727 int *window_change_flags
;
1729 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1731 int wmax
= 0, hmax
= 0;
1735 int in_horz_combination_p
;
1737 /* What combination is WINDOW part of? Compute this once since the
1738 result is the same for all windows in the `next' chain. The
1739 special case of a root window (parent equal to nil) is treated
1740 like a vertical combination because a root window's `next'
1741 points to the mini-buffer window, if any, which is arranged
1742 vertically below other windows. */
1743 in_horz_combination_p
1744 = (!NILP (XWINDOW (window
)->parent
)
1745 && !NILP (XWINDOW (XWINDOW (window
)->parent
)->hchild
));
1747 /* For WINDOW and all windows on the same level. */
1750 w
= XWINDOW (window
);
1752 /* Get the dimension of the window sub-matrix for W, depending
1753 on whether this a combination or a leaf window. */
1754 if (!NILP (w
->hchild
))
1755 dim
= allocate_matrices_for_frame_redisplay (w
->hchild
, x
, y
, ch_dim
,
1757 window_change_flags
);
1758 else if (!NILP (w
->vchild
))
1759 dim
= allocate_matrices_for_frame_redisplay (w
->vchild
, x
, y
, ch_dim
,
1761 window_change_flags
);
1764 /* If not already done, allocate sub-matrix structures. */
1765 if (w
->desired_matrix
== NULL
)
1767 w
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1768 w
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1769 *window_change_flags
|= NEW_LEAF_MATRIX
;
1772 /* Width and height MUST be chosen so that there are no
1773 holes in the frame matrix. */
1774 dim
.width
= XINT (w
->width
);
1775 dim
.height
= XINT (w
->height
);
1777 /* Will matrix be re-allocated? */
1778 if (x
!= w
->desired_matrix
->matrix_x
1779 || y
!= w
->desired_matrix
->matrix_y
1780 || dim
.width
!= w
->desired_matrix
->matrix_w
1781 || dim
.height
!= w
->desired_matrix
->matrix_h
1782 || (margin_glyphs_to_reserve (w
, dim
.width
,
1783 w
->right_margin_width
)
1784 != w
->desired_matrix
->left_margin_glyphs
)
1785 || (margin_glyphs_to_reserve (w
, dim
.width
,
1786 w
->left_margin_width
)
1787 != w
->desired_matrix
->right_margin_glyphs
))
1788 *window_change_flags
|= CHANGED_LEAF_MATRIX
;
1790 /* Actually change matrices, if allowed. Do not consider
1791 CHANGED_LEAF_MATRIX computed above here because the pool
1792 may have been changed which we don't now here. We trust
1793 that we only will be called with DIM_ONLY_P != 0 when
1797 adjust_glyph_matrix (w
, w
->desired_matrix
, x
, y
, dim
);
1798 adjust_glyph_matrix (w
, w
->current_matrix
, x
, y
, dim
);
1802 /* If we are part of a horizontal combination, advance x for
1803 windows to the right of W; otherwise advance y for windows
1805 if (in_horz_combination_p
)
1810 /* Remember maximum glyph matrix dimensions. */
1811 wmax
= max (wmax
, dim
.width
);
1812 hmax
= max (hmax
, dim
.height
);
1814 /* Next window on same level. */
1817 while (!NILP (window
));
1819 /* Set `total' to the total glyph matrix dimension of this window
1820 level. In a vertical combination, the width is the width of the
1821 widest window; the height is the y we finally reached, corrected
1822 by the y we started with. In a horizontal combination, the total
1823 height is the height of the tallest window, and the width is the
1824 x we finally reached, corrected by the x we started with. */
1825 if (in_horz_combination_p
)
1827 total
.width
= x
- x0
;
1828 total
.height
= hmax
;
1833 total
.height
= y
- y0
;
1840 /* Allocate window matrices for window-based redisplay. W is the
1841 window whose matrices must be allocated/reallocated. CH_DIM is the
1842 size of the smallest character that could potentially be used on W. */
1845 allocate_matrices_for_window_redisplay (w
, ch_dim
)
1849 struct frame
*f
= XFRAME (w
->frame
);
1853 if (!NILP (w
->vchild
))
1854 allocate_matrices_for_window_redisplay (XWINDOW (w
->vchild
), ch_dim
);
1855 else if (!NILP (w
->hchild
))
1856 allocate_matrices_for_window_redisplay (XWINDOW (w
->hchild
), ch_dim
);
1859 /* W is a leaf window. */
1860 int window_pixel_width
= XFLOATINT (w
->width
) * CANON_X_UNIT (f
);
1861 int window_pixel_height
= window_box_height (w
) + abs (w
->vscroll
);
1864 /* If matrices are not yet allocated, allocate them now. */
1865 if (w
->desired_matrix
== NULL
)
1867 w
->desired_matrix
= new_glyph_matrix (NULL
);
1868 w
->current_matrix
= new_glyph_matrix (NULL
);
1871 /* Compute number of glyphs needed in a glyph row. */
1872 dim
.width
= (((window_pixel_width
+ ch_dim
.width
- 1)
1874 /* 2 partially visible columns in the text area. */
1876 /* One partially visible column at the right
1877 edge of each marginal area. */
1880 /* Compute number of glyph rows needed. */
1881 dim
.height
= (((window_pixel_height
+ ch_dim
.height
- 1)
1883 /* One partially visible line at the top and
1884 bottom of the window. */
1886 /* 2 for top and mode line. */
1889 /* Change matrices. */
1890 adjust_glyph_matrix (w
, w
->desired_matrix
, 0, 0, dim
);
1891 adjust_glyph_matrix (w
, w
->current_matrix
, 0, 0, dim
);
1894 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
1899 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
1900 do it for all frames; otherwise do it just for the given frame.
1901 This function must be called when a new frame is created, its size
1902 changes, or its window configuration changes. */
1908 /* Block input so that expose events and other events that access
1909 glyph matrices are not processed while we are changing them. */
1913 adjust_frame_glyphs (f
);
1916 Lisp_Object tail
, lisp_frame
;
1918 FOR_EACH_FRAME (tail
, lisp_frame
)
1919 adjust_frame_glyphs (XFRAME (lisp_frame
));
1926 /* Adjust frame glyphs when Emacs is initialized.
1928 To be called from init_display.
1930 We need a glyph matrix because redraw will happen soon.
1931 Unfortunately, window sizes on selected_frame are not yet set to
1932 meaningful values. I believe we can assume that there are only two
1933 windows on the frame---the mini-buffer and the root window. Frame
1934 height and width seem to be correct so far. So, set the sizes of
1935 windows to estimated values. */
1938 adjust_frame_glyphs_initially ()
1940 struct frame
*sf
= SELECTED_FRAME ();
1941 struct window
*root
= XWINDOW (sf
->root_window
);
1942 struct window
*mini
= XWINDOW (root
->next
);
1943 int frame_height
= FRAME_HEIGHT (sf
);
1944 int frame_width
= FRAME_WIDTH (sf
);
1945 int top_margin
= FRAME_TOP_MARGIN (sf
);
1947 /* Do it for the root window. */
1948 XSETFASTINT (root
->top
, top_margin
);
1949 XSETFASTINT (root
->width
, frame_width
);
1950 set_window_height (sf
->root_window
, frame_height
- 1 - top_margin
, 0);
1952 /* Do it for the mini-buffer window. */
1953 XSETFASTINT (mini
->top
, frame_height
- 1);
1954 XSETFASTINT (mini
->width
, frame_width
);
1955 set_window_height (root
->next
, 1, 0);
1957 adjust_frame_glyphs (sf
);
1958 glyphs_initialized_initially_p
= 1;
1962 /* Allocate/reallocate glyph matrices of a single frame F. */
1965 adjust_frame_glyphs (f
)
1968 if (FRAME_WINDOW_P (f
))
1969 adjust_frame_glyphs_for_window_redisplay (f
);
1971 adjust_frame_glyphs_for_frame_redisplay (f
);
1973 /* Don't forget the message buffer and the buffer for
1974 decode_mode_spec. */
1975 adjust_frame_message_buffer (f
);
1976 adjust_decode_mode_spec_buffer (f
);
1978 f
->glyphs_initialized_p
= 1;
1982 /* Allocate/reallocate glyph matrices of a single frame F for
1983 frame-based redisplay. */
1986 adjust_frame_glyphs_for_frame_redisplay (f
)
1990 struct dim matrix_dim
;
1992 int window_change_flags
;
1995 if (!FRAME_LIVE_P (f
))
1998 /* Determine the smallest character in any font for F. On
1999 console windows, all characters have dimension (1, 1). */
2000 ch_dim
.width
= ch_dim
.height
= 1;
2002 top_window_y
= FRAME_TOP_MARGIN (f
);
2004 /* Allocate glyph pool structures if not already done. */
2005 if (f
->desired_pool
== NULL
)
2007 f
->desired_pool
= new_glyph_pool ();
2008 f
->current_pool
= new_glyph_pool ();
2011 /* Allocate frames matrix structures if needed. */
2012 if (f
->desired_matrix
== NULL
)
2014 f
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
2015 f
->current_matrix
= new_glyph_matrix (f
->current_pool
);
2018 /* Compute window glyph matrices. (This takes the mini-buffer
2019 window into account). The result is the size of the frame glyph
2020 matrix needed. The variable window_change_flags is set to a bit
2021 mask indicating whether new matrices will be allocated or
2022 existing matrices change their size or location within the frame
2024 window_change_flags
= 0;
2026 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2029 &window_change_flags
);
2031 /* Add in menu bar lines, if any. */
2032 matrix_dim
.height
+= top_window_y
;
2034 /* Enlarge pools as necessary. */
2035 pool_changed_p
= realloc_glyph_pool (f
->desired_pool
, matrix_dim
);
2036 realloc_glyph_pool (f
->current_pool
, matrix_dim
);
2038 /* Set up glyph pointers within window matrices. Do this only if
2039 absolutely necessary since it requires a frame redraw. */
2040 if (pool_changed_p
|| window_change_flags
)
2042 /* Do it for window matrices. */
2043 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2044 0, top_window_y
, ch_dim
, 0,
2045 &window_change_flags
);
2047 /* Size of frame matrices must equal size of frame. Note
2048 that we are called for X frames with window widths NOT equal
2049 to the frame width (from CHANGE_FRAME_SIZE_1). */
2050 xassert (matrix_dim
.width
== FRAME_WIDTH (f
)
2051 && matrix_dim
.height
== FRAME_HEIGHT (f
));
2053 /* Resize frame matrices. */
2054 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2055 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2057 /* Since location and size of sub-matrices within the pool may
2058 have changed, and current matrices don't have meaningful
2059 contents anymore, mark the frame garbaged. */
2060 SET_FRAME_GARBAGED (f
);
2065 /* Allocate/reallocate glyph matrices of a single frame F for
2066 window-based redisplay. */
2069 adjust_frame_glyphs_for_window_redisplay (f
)
2075 xassert (FRAME_WINDOW_P (f
) && FRAME_LIVE_P (f
));
2077 /* Get minimum sizes. */
2078 #ifdef HAVE_WINDOW_SYSTEM
2079 ch_dim
.width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2080 ch_dim
.height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
2082 ch_dim
.width
= ch_dim
.height
= 1;
2085 /* Allocate/reallocate window matrices. */
2086 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f
)),
2089 /* Allocate/ reallocate matrices of the dummy window used to display
2090 the menu bar under X when no X toolkit support is available. */
2091 #ifndef USE_X_TOOLKIT
2093 /* Allocate a dummy window if not already done. */
2094 if (NILP (f
->menu_bar_window
))
2096 f
->menu_bar_window
= make_window ();
2097 w
= XWINDOW (f
->menu_bar_window
);
2098 XSETFRAME (w
->frame
, f
);
2099 w
->pseudo_window_p
= 1;
2102 w
= XWINDOW (f
->menu_bar_window
);
2104 /* Set window dimensions to frame dimensions and allocate or
2105 adjust glyph matrices of W. */
2106 XSETFASTINT (w
->top
, 0);
2107 XSETFASTINT (w
->left
, 0);
2108 XSETFASTINT (w
->height
, FRAME_MENU_BAR_LINES (f
));
2109 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2110 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2112 #endif /* not USE_X_TOOLKIT */
2114 /* Allocate/ reallocate matrices of the tool bar window. If we
2115 don't have a tool bar window yet, make one. */
2116 if (NILP (f
->tool_bar_window
))
2118 f
->tool_bar_window
= make_window ();
2119 w
= XWINDOW (f
->tool_bar_window
);
2120 XSETFRAME (w
->frame
, f
);
2121 w
->pseudo_window_p
= 1;
2124 w
= XWINDOW (f
->tool_bar_window
);
2126 XSETFASTINT (w
->top
, FRAME_MENU_BAR_LINES (f
));
2127 XSETFASTINT (w
->left
, 0);
2128 XSETFASTINT (w
->height
, FRAME_TOOL_BAR_LINES (f
));
2129 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2130 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2134 /* Adjust/ allocate message buffer of frame F.
2136 Note that the message buffer is never freed. Since I could not
2137 find a free in 19.34, I assume that freeing it would be
2138 problematic in some way and don't do it either.
2140 (Implementation note: It should be checked if we can free it
2141 eventually without causing trouble). */
2144 adjust_frame_message_buffer (f
)
2147 int size
= FRAME_MESSAGE_BUF_SIZE (f
) + 1;
2149 if (FRAME_MESSAGE_BUF (f
))
2151 char *buffer
= FRAME_MESSAGE_BUF (f
);
2152 char *new_buffer
= (char *) xrealloc (buffer
, size
);
2153 FRAME_MESSAGE_BUF (f
) = new_buffer
;
2156 FRAME_MESSAGE_BUF (f
) = (char *) xmalloc (size
);
2160 /* Re-allocate buffer for decode_mode_spec on frame F. */
2163 adjust_decode_mode_spec_buffer (f
)
2166 f
->decode_mode_spec_buffer
2167 = (char *) xrealloc (f
->decode_mode_spec_buffer
,
2168 FRAME_MESSAGE_BUF_SIZE (f
) + 1);
2173 /**********************************************************************
2174 Freeing Glyph Matrices
2175 **********************************************************************/
2177 /* Free glyph memory for a frame F. F may be null. This function can
2178 be called for the same frame more than once. The root window of
2179 F may be nil when this function is called. This is the case when
2180 the function is called when F is destroyed. */
2186 if (f
&& f
->glyphs_initialized_p
)
2188 /* Block interrupt input so that we don't get surprised by an X
2189 event while we're in an inconsistent state. */
2191 f
->glyphs_initialized_p
= 0;
2193 /* Release window sub-matrices. */
2194 if (!NILP (f
->root_window
))
2195 free_window_matrices (XWINDOW (f
->root_window
));
2197 /* Free the dummy window for menu bars without X toolkit and its
2199 if (!NILP (f
->menu_bar_window
))
2201 struct window
*w
= XWINDOW (f
->menu_bar_window
);
2202 free_glyph_matrix (w
->desired_matrix
);
2203 free_glyph_matrix (w
->current_matrix
);
2204 w
->desired_matrix
= w
->current_matrix
= NULL
;
2205 f
->menu_bar_window
= Qnil
;
2208 /* Free the tool bar window and its glyph matrices. */
2209 if (!NILP (f
->tool_bar_window
))
2211 struct window
*w
= XWINDOW (f
->tool_bar_window
);
2212 free_glyph_matrix (w
->desired_matrix
);
2213 free_glyph_matrix (w
->current_matrix
);
2214 w
->desired_matrix
= w
->current_matrix
= NULL
;
2215 f
->tool_bar_window
= Qnil
;
2218 /* Release frame glyph matrices. Reset fields to zero in
2219 case we are called a second time. */
2220 if (f
->desired_matrix
)
2222 free_glyph_matrix (f
->desired_matrix
);
2223 free_glyph_matrix (f
->current_matrix
);
2224 f
->desired_matrix
= f
->current_matrix
= NULL
;
2227 /* Release glyph pools. */
2228 if (f
->desired_pool
)
2230 free_glyph_pool (f
->desired_pool
);
2231 free_glyph_pool (f
->current_pool
);
2232 f
->desired_pool
= f
->current_pool
= NULL
;
2240 /* Free glyph sub-matrices in the window tree rooted at W. This
2241 function may be called with a null pointer, and it may be called on
2242 the same tree more than once. */
2245 free_window_matrices (w
)
2250 if (!NILP (w
->hchild
))
2251 free_window_matrices (XWINDOW (w
->hchild
));
2252 else if (!NILP (w
->vchild
))
2253 free_window_matrices (XWINDOW (w
->vchild
));
2256 /* This is a leaf window. Free its memory and reset fields
2257 to zero in case this function is called a second time for
2259 free_glyph_matrix (w
->current_matrix
);
2260 free_glyph_matrix (w
->desired_matrix
);
2261 w
->current_matrix
= w
->desired_matrix
= NULL
;
2264 /* Next window on same level. */
2265 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2270 /* Check glyph memory leaks. This function is called from
2271 shut_down_emacs. Note that frames are not destroyed when Emacs
2272 exits. We therefore free all glyph memory for all active frames
2273 explicitly and check that nothing is left allocated. */
2276 check_glyph_memory ()
2278 Lisp_Object tail
, frame
;
2280 /* Free glyph memory for all frames. */
2281 FOR_EACH_FRAME (tail
, frame
)
2282 free_glyphs (XFRAME (frame
));
2284 /* Check that nothing is left allocated. */
2285 if (glyph_matrix_count
)
2287 if (glyph_pool_count
)
2293 /**********************************************************************
2294 Building a Frame Matrix
2295 **********************************************************************/
2297 /* Most of the redisplay code works on glyph matrices attached to
2298 windows. This is a good solution most of the time, but it is not
2299 suitable for terminal code. Terminal output functions cannot rely
2300 on being able to set an arbitrary terminal window. Instead they
2301 must be provided with a view of the whole frame, i.e. the whole
2302 screen. We build such a view by constructing a frame matrix from
2303 window matrices in this section.
2305 Windows that must be updated have their must_be_update_p flag set.
2306 For all such windows, their desired matrix is made part of the
2307 desired frame matrix. For other windows, their current matrix is
2308 made part of the desired frame matrix.
2310 +-----------------+----------------+
2311 | desired | desired |
2313 +-----------------+----------------+
2316 +----------------------------------+
2318 Desired window matrices can be made part of the frame matrix in a
2319 cheap way: We exploit the fact that the desired frame matrix and
2320 desired window matrices share their glyph memory. This is not
2321 possible for current window matrices. Their glyphs are copied to
2322 the desired frame matrix. The latter is equivalent to
2323 preserve_other_columns in the old redisplay.
2325 Used glyphs counters for frame matrix rows are the result of adding
2326 up glyph lengths of the window matrices. A line in the frame
2327 matrix is enabled, if a corresponding line in a window matrix is
2330 After building the desired frame matrix, it will be passed to
2331 terminal code, which will manipulate both the desired and current
2332 frame matrix. Changes applied to the frame's current matrix have
2333 to be visible in current window matrices afterwards, of course.
2335 This problem is solved like this:
2337 1. Window and frame matrices share glyphs. Window matrices are
2338 constructed in a way that their glyph contents ARE the glyph
2339 contents needed in a frame matrix. Thus, any modification of
2340 glyphs done in terminal code will be reflected in window matrices
2343 2. Exchanges of rows in a frame matrix done by terminal code are
2344 intercepted by hook functions so that corresponding row operations
2345 on window matrices can be performed. This is necessary because we
2346 use pointers to glyphs in glyph row structures. To satisfy the
2347 assumption of point 1 above that glyphs are updated implicitly in
2348 window matrices when they are manipulated via the frame matrix,
2349 window and frame matrix must of course agree where to find the
2350 glyphs for their rows. Possible manipulations that must be
2351 mirrored are assignments of rows of the desired frame matrix to the
2352 current frame matrix and scrolling the current frame matrix. */
2354 /* Build frame F's desired matrix from window matrices. Only windows
2355 which have the flag must_be_updated_p set have to be updated. Menu
2356 bar lines of a frame are not covered by window matrices, so make
2357 sure not to touch them in this function. */
2360 build_frame_matrix (f
)
2365 /* F must have a frame matrix when this function is called. */
2366 xassert (!FRAME_WINDOW_P (f
));
2368 /* Clear all rows in the frame matrix covered by window matrices.
2369 Menu bar lines are not covered by windows. */
2370 for (i
= FRAME_TOP_MARGIN (f
); i
< f
->desired_matrix
->nrows
; ++i
)
2371 clear_glyph_row (MATRIX_ROW (f
->desired_matrix
, i
));
2373 /* Build the matrix by walking the window tree. */
2374 build_frame_matrix_from_window_tree (f
->desired_matrix
,
2375 XWINDOW (FRAME_ROOT_WINDOW (f
)));
2379 /* Walk a window tree, building a frame matrix MATRIX from window
2380 matrices. W is the root of a window tree. */
2383 build_frame_matrix_from_window_tree (matrix
, w
)
2384 struct glyph_matrix
*matrix
;
2389 if (!NILP (w
->hchild
))
2390 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->hchild
));
2391 else if (!NILP (w
->vchild
))
2392 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->vchild
));
2394 build_frame_matrix_from_leaf_window (matrix
, w
);
2396 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2401 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2402 desired frame matrix built. W is a leaf window whose desired or
2403 current matrix is to be added to FRAME_MATRIX. W's flag
2404 must_be_updated_p determines which matrix it contributes to
2405 FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix
2406 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2407 Adding a desired matrix means setting up used counters and such in
2408 frame rows, while adding a current window matrix to FRAME_MATRIX
2409 means copying glyphs. The latter case corresponds to
2410 preserve_other_columns in the old redisplay. */
2413 build_frame_matrix_from_leaf_window (frame_matrix
, w
)
2414 struct glyph_matrix
*frame_matrix
;
2417 struct glyph_matrix
*window_matrix
;
2418 int window_y
, frame_y
;
2419 /* If non-zero, a glyph to insert at the right border of W. */
2420 GLYPH right_border_glyph
= 0;
2422 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2423 if (w
->must_be_updated_p
)
2425 window_matrix
= w
->desired_matrix
;
2427 /* Decide whether we want to add a vertical border glyph. */
2428 if (!WINDOW_RIGHTMOST_P (w
))
2430 struct Lisp_Char_Table
*dp
= window_display_table (w
);
2431 right_border_glyph
= (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
2432 ? XINT (DISP_BORDER_GLYPH (dp
))
2437 window_matrix
= w
->current_matrix
;
2439 /* For all rows in the window matrix and corresponding rows in the
2442 frame_y
= window_matrix
->matrix_y
;
2443 while (window_y
< window_matrix
->nrows
)
2445 struct glyph_row
*frame_row
= frame_matrix
->rows
+ frame_y
;
2446 struct glyph_row
*window_row
= window_matrix
->rows
+ window_y
;
2448 /* Fill up the frame row with spaces up to the left margin of the
2450 fill_up_frame_row_with_spaces (frame_row
, window_matrix
->matrix_x
);
2452 /* Fill up areas in the window matrix row with spaces. */
2453 fill_up_glyph_row_with_spaces (window_row
);
2455 if (window_matrix
== w
->current_matrix
)
2457 /* We have to copy W's current matrix. Copy window
2458 row to frame row. */
2459 bcopy (window_row
->glyphs
[0],
2460 frame_row
->glyphs
[TEXT_AREA
] + window_matrix
->matrix_x
,
2461 window_matrix
->matrix_w
* sizeof (struct glyph
));
2465 /* Copy W's desired matrix. */
2467 /* Maybe insert a vertical border between horizontally adjacent
2469 if (right_border_glyph
)
2471 struct glyph
*border
= window_row
->glyphs
[LAST_AREA
] - 1;
2472 SET_CHAR_GLYPH_FROM_GLYPH (*border
, right_border_glyph
);
2475 #if 0 /* This shouldn't be necessary. Let's check it. */
2476 /* Due to hooks installed, it normally doesn't happen that
2477 window rows and frame rows of the same matrix are out of
2478 sync, i.e. have a different understanding of where to
2479 find glyphs for the row. The following is a safety-belt
2480 that doesn't cost much and makes absolutely sure that
2481 window and frame matrices are in sync. */
2482 if (!glyph_row_slice_p (window_row
, frame_row
))
2484 /* Find the row in the window being a slice. There
2485 should exist one from program logic. */
2486 struct glyph_row
*slice_row
2487 = find_glyph_row_slice (window_matrix
, frame_matrix
, frame_y
);
2488 xassert (slice_row
!= 0);
2490 /* Exchange glyphs between both window rows. */
2491 swap_glyphs_in_rows (window_row
, slice_row
);
2493 /* Exchange pointers between both rows. */
2494 swap_glyph_pointers (window_row
, slice_row
);
2498 /* Window row window_y must be a slice of frame row
2500 xassert (glyph_row_slice_p (window_row
, frame_row
));
2502 /* If rows are in sync, we don't have to copy glyphs because
2503 frame and window share glyphs. */
2506 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
2510 /* Set number of used glyphs in the frame matrix. Since we fill
2511 up with spaces, and visit leaf windows from left to right it
2512 can be done simply. */
2513 frame_row
->used
[TEXT_AREA
]
2514 = window_matrix
->matrix_x
+ window_matrix
->matrix_w
;
2517 frame_row
->enabled_p
|= window_row
->enabled_p
;
2518 frame_row
->inverse_p
|= window_row
->inverse_p
;
2527 /* Add spaces to a glyph row ROW in a window matrix.
2529 Each row has the form:
2531 +---------+-----------------------------+------------+
2532 | left | text | right |
2533 +---------+-----------------------------+------------+
2535 Left and right marginal areas are optional. This function adds
2536 spaces to areas so that there are no empty holes between areas.
2537 In other words: If the right area is not empty, the text area
2538 is filled up with spaces up to the right area. If the text area
2539 is not empty, the left area is filled up.
2541 To be called for frame-based redisplay, only. */
2544 fill_up_glyph_row_with_spaces (row
)
2545 struct glyph_row
*row
;
2547 fill_up_glyph_row_area_with_spaces (row
, LEFT_MARGIN_AREA
);
2548 fill_up_glyph_row_area_with_spaces (row
, TEXT_AREA
);
2549 fill_up_glyph_row_area_with_spaces (row
, RIGHT_MARGIN_AREA
);
2553 /* Fill area AREA of glyph row ROW with spaces. To be called for
2554 frame-based redisplay only. */
2557 fill_up_glyph_row_area_with_spaces (row
, area
)
2558 struct glyph_row
*row
;
2561 if (row
->glyphs
[area
] < row
->glyphs
[area
+ 1])
2563 struct glyph
*end
= row
->glyphs
[area
+ 1];
2564 struct glyph
*text
= row
->glyphs
[area
] + row
->used
[area
];
2567 *text
++ = space_glyph
;
2568 row
->used
[area
] = text
- row
->glyphs
[area
];
2573 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2574 reached. In frame matrices only one area, TEXT_AREA, is used. */
2577 fill_up_frame_row_with_spaces (row
, upto
)
2578 struct glyph_row
*row
;
2581 int i
= row
->used
[TEXT_AREA
];
2582 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
2585 glyph
[i
++] = space_glyph
;
2587 row
->used
[TEXT_AREA
] = i
;
2592 /**********************************************************************
2593 Mirroring operations on frame matrices in window matrices
2594 **********************************************************************/
2596 /* Set frame being updated via frame-based redisplay to F. This
2597 function must be called before updates to make explicit that we are
2598 working on frame matrices or not. */
2601 set_frame_matrix_frame (f
)
2604 frame_matrix_frame
= f
;
2608 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2609 DESIRED_MATRIX is the desired matrix corresponding to
2610 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2611 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2612 frame_matrix_frame is non-null, this indicates that the exchange is
2613 done in frame matrices, and that we have to perform analogous
2614 operations in window matrices of frame_matrix_frame. */
2617 make_current (desired_matrix
, current_matrix
, row
)
2618 struct glyph_matrix
*desired_matrix
, *current_matrix
;
2621 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, row
);
2622 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, row
);
2624 /* Do current_row = desired_row. This exchanges glyph pointers
2625 between both rows, and does a structure assignment otherwise. */
2626 assign_row (current_row
, desired_row
);
2628 /* Enable current_row to mark it as valid. */
2629 current_row
->enabled_p
= 1;
2631 /* If we are called on frame matrices, perform analogous operations
2632 for window matrices. */
2633 if (frame_matrix_frame
)
2634 mirror_make_current (XWINDOW (frame_matrix_frame
->root_window
), row
);
2638 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2639 W's frame which has been made current (by swapping pointers between
2640 current and desired matrix). Perform analogous operations in the
2641 matrices of leaf windows in the window tree rooted at W. */
2644 mirror_make_current (w
, frame_row
)
2650 if (!NILP (w
->hchild
))
2651 mirror_make_current (XWINDOW (w
->hchild
), frame_row
);
2652 else if (!NILP (w
->vchild
))
2653 mirror_make_current (XWINDOW (w
->vchild
), frame_row
);
2656 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2657 here because the checks performed in debug mode there
2658 will not allow the conversion. */
2659 int row
= frame_row
- w
->desired_matrix
->matrix_y
;
2661 /* If FRAME_ROW is within W, assign the desired row to the
2662 current row (exchanging glyph pointers). */
2663 if (row
>= 0 && row
< w
->desired_matrix
->matrix_h
)
2665 struct glyph_row
*current_row
2666 = MATRIX_ROW (w
->current_matrix
, row
);
2667 struct glyph_row
*desired_row
2668 = MATRIX_ROW (w
->desired_matrix
, row
);
2670 if (desired_row
->enabled_p
)
2671 assign_row (current_row
, desired_row
);
2673 swap_glyph_pointers (desired_row
, current_row
);
2674 current_row
->enabled_p
= 1;
2678 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2683 /* Perform row dance after scrolling. We are working on the range of
2684 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2685 including) in MATRIX. COPY_FROM is a vector containing, for each
2686 row I in the range 0 <= I < NLINES, the index of the original line
2687 to move to I. This index is relative to the row range, i.e. 0 <=
2688 index < NLINES. RETAINED_P is a vector containing zero for each
2689 row 0 <= I < NLINES which is empty.
2691 This function is called from do_scrolling and do_direct_scrolling. */
2694 mirrored_line_dance (matrix
, unchanged_at_top
, nlines
, copy_from
,
2696 struct glyph_matrix
*matrix
;
2697 int unchanged_at_top
, nlines
;
2701 /* A copy of original rows. */
2702 struct glyph_row
*old_rows
;
2704 /* Rows to assign to. */
2705 struct glyph_row
*new_rows
= MATRIX_ROW (matrix
, unchanged_at_top
);
2709 /* Make a copy of the original rows. */
2710 old_rows
= (struct glyph_row
*) alloca (nlines
* sizeof *old_rows
);
2711 bcopy (new_rows
, old_rows
, nlines
* sizeof *old_rows
);
2713 /* Assign new rows, maybe clear lines. */
2714 for (i
= 0; i
< nlines
; ++i
)
2716 int enabled_before_p
= new_rows
[i
].enabled_p
;
2718 xassert (i
+ unchanged_at_top
< matrix
->nrows
);
2719 xassert (unchanged_at_top
+ copy_from
[i
] < matrix
->nrows
);
2720 new_rows
[i
] = old_rows
[copy_from
[i
]];
2721 new_rows
[i
].enabled_p
= enabled_before_p
;
2723 /* RETAINED_P is zero for empty lines. */
2724 if (!retained_p
[copy_from
[i
]])
2725 new_rows
[i
].enabled_p
= 0;
2728 /* Do the same for window matrices, if MATRIX Is a frame matrix. */
2729 if (frame_matrix_frame
)
2730 mirror_line_dance (XWINDOW (frame_matrix_frame
->root_window
),
2731 unchanged_at_top
, nlines
, copy_from
, retained_p
);
2735 /* Synchronize glyph pointers in the current matrix of window W with
2736 the current frame matrix. W must be full-width, and be on a tty
2740 sync_window_with_frame_matrix_rows (w
)
2743 struct frame
*f
= XFRAME (w
->frame
);
2744 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
2746 /* Preconditions: W must be a leaf window and full-width. Its frame
2747 must have a frame matrix. */
2748 xassert (NILP (w
->hchild
) && NILP (w
->vchild
));
2749 xassert (WINDOW_FULL_WIDTH_P (w
));
2750 xassert (!FRAME_WINDOW_P (f
));
2752 /* If W is a full-width window, glyph pointers in W's current matrix
2753 have, by definition, to be the same as glyph pointers in the
2754 corresponding frame matrix. */
2755 window_row
= w
->current_matrix
->rows
;
2756 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
2757 frame_row
= f
->current_matrix
->rows
+ XFASTINT (w
->top
);
2758 while (window_row
< window_row_end
)
2762 for (area
= LEFT_MARGIN_AREA
; area
<= LAST_AREA
; ++area
)
2763 window_row
->glyphs
[area
] = frame_row
->glyphs
[area
];
2765 ++window_row
, ++frame_row
;
2770 /* Return the window in the window tree rooted in W containing frame
2771 row ROW. Value is null if none is found. */
2774 frame_row_to_window (w
, row
)
2778 struct window
*found
= NULL
;
2782 if (!NILP (w
->hchild
))
2783 found
= frame_row_to_window (XWINDOW (w
->hchild
), row
);
2784 else if (!NILP (w
->vchild
))
2785 found
= frame_row_to_window (XWINDOW (w
->vchild
), row
);
2786 else if (row
>= XFASTINT (w
->top
)
2787 && row
< XFASTINT (w
->top
) + XFASTINT (w
->height
))
2790 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2797 /* Perform a line dance in the window tree rooted at W, after
2798 scrolling a frame matrix in mirrored_line_dance.
2800 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
2801 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
2802 COPY_FROM is a vector containing, for each row I in the range 0 <=
2803 I < NLINES, the index of the original line to move to I. This
2804 index is relative to the row range, i.e. 0 <= index < NLINES.
2805 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
2809 mirror_line_dance (w
, unchanged_at_top
, nlines
, copy_from
, retained_p
)
2811 int unchanged_at_top
, nlines
;
2817 if (!NILP (w
->hchild
))
2818 mirror_line_dance (XWINDOW (w
->hchild
), unchanged_at_top
,
2819 nlines
, copy_from
, retained_p
);
2820 else if (!NILP (w
->vchild
))
2821 mirror_line_dance (XWINDOW (w
->vchild
), unchanged_at_top
,
2822 nlines
, copy_from
, retained_p
);
2825 /* W is a leaf window, and we are working on its current
2827 struct glyph_matrix
*m
= w
->current_matrix
;
2829 struct glyph_row
*old_rows
;
2831 /* Make a copy of the original rows of matrix m. */
2832 old_rows
= (struct glyph_row
*) alloca (m
->nrows
* sizeof *old_rows
);
2833 bcopy (m
->rows
, old_rows
, m
->nrows
* sizeof *old_rows
);
2835 for (i
= 0; i
< nlines
; ++i
)
2837 /* Frame relative line assigned to. */
2838 int frame_to
= i
+ unchanged_at_top
;
2840 /* Frame relative line assigned. */
2841 int frame_from
= copy_from
[i
] + unchanged_at_top
;
2843 /* Window relative line assigned to. */
2844 int window_to
= frame_to
- m
->matrix_y
;
2846 /* Window relative line assigned. */
2847 int window_from
= frame_from
- m
->matrix_y
;
2849 /* Is assigned line inside window? */
2850 int from_inside_window_p
2851 = window_from
>= 0 && window_from
< m
->matrix_h
;
2853 /* Is assigned to line inside window? */
2854 int to_inside_window_p
2855 = window_to
>= 0 && window_to
< m
->matrix_h
;
2857 if (from_inside_window_p
&& to_inside_window_p
)
2859 /* Enabled setting before assignment. */
2860 int enabled_before_p
;
2862 /* Do the assignment. The enabled_p flag is saved
2863 over the assignment because the old redisplay did
2865 enabled_before_p
= m
->rows
[window_to
].enabled_p
;
2866 m
->rows
[window_to
] = old_rows
[window_from
];
2867 m
->rows
[window_to
].enabled_p
= enabled_before_p
;
2869 /* If frame line is empty, window line is empty, too. */
2870 if (!retained_p
[copy_from
[i
]])
2871 m
->rows
[window_to
].enabled_p
= 0;
2873 else if (to_inside_window_p
)
2875 /* A copy between windows. This is an infrequent
2876 case not worth optimizing. */
2877 struct frame
*f
= XFRAME (w
->frame
);
2878 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
2880 struct glyph_matrix
*m2
;
2883 w2
= frame_row_to_window (root
, frame_to
);
2884 m2
= w2
->current_matrix
;
2885 m2_from
= frame_from
- m2
->matrix_y
;
2886 copy_row_except_pointers (m
->rows
+ window_to
,
2887 m2
->rows
+ m2_from
);
2889 /* If frame line is empty, window line is empty, too. */
2890 if (!retained_p
[copy_from
[i
]])
2891 m
->rows
[window_to
].enabled_p
= 0;
2894 else if (from_inside_window_p
)
2898 /* If there was a copy between windows, make sure glyph
2899 pointers are in sync with the frame matrix. */
2901 sync_window_with_frame_matrix_rows (w
);
2903 /* Check that no pointers are lost. */
2907 /* Next window on same level. */
2908 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2915 /* Check that window and frame matrices agree about their
2916 understanding where glyphs of the rows are to find. For each
2917 window in the window tree rooted at W, check that rows in the
2918 matrices of leaf window agree with their frame matrices about
2922 check_window_matrix_pointers (w
)
2927 if (!NILP (w
->hchild
))
2928 check_window_matrix_pointers (XWINDOW (w
->hchild
));
2929 else if (!NILP (w
->vchild
))
2930 check_window_matrix_pointers (XWINDOW (w
->vchild
));
2933 struct frame
*f
= XFRAME (w
->frame
);
2934 check_matrix_pointers (w
->desired_matrix
, f
->desired_matrix
);
2935 check_matrix_pointers (w
->current_matrix
, f
->current_matrix
);
2938 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2943 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
2944 a window and FRAME_MATRIX is the corresponding frame matrix. For
2945 each row in WINDOW_MATRIX check that it's a slice of the
2946 corresponding frame row. If it isn't, abort. */
2949 check_matrix_pointers (window_matrix
, frame_matrix
)
2950 struct glyph_matrix
*window_matrix
, *frame_matrix
;
2952 /* Row number in WINDOW_MATRIX. */
2955 /* Row number corresponding to I in FRAME_MATRIX. */
2956 int j
= window_matrix
->matrix_y
;
2958 /* For all rows check that the row in the window matrix is a
2959 slice of the row in the frame matrix. If it isn't we didn't
2960 mirror an operation on the frame matrix correctly. */
2961 while (i
< window_matrix
->nrows
)
2963 if (!glyph_row_slice_p (window_matrix
->rows
+ i
,
2964 frame_matrix
->rows
+ j
))
2970 #endif /* GLYPH_DEBUG != 0 */
2974 /**********************************************************************
2975 VPOS and HPOS translations
2976 **********************************************************************/
2980 /* Translate vertical position VPOS which is relative to window W to a
2981 vertical position relative to W's frame. */
2984 window_to_frame_vpos (w
, vpos
)
2988 struct frame
*f
= XFRAME (w
->frame
);
2990 xassert (!FRAME_WINDOW_P (f
));
2991 xassert (vpos
>= 0 && vpos
<= w
->desired_matrix
->nrows
);
2992 vpos
+= XFASTINT (w
->top
);
2993 xassert (vpos
>= 0 && vpos
<= FRAME_HEIGHT (f
));
2998 /* Translate horizontal position HPOS which is relative to window W to
2999 a vertical position relative to W's frame. */
3002 window_to_frame_hpos (w
, hpos
)
3006 struct frame
*f
= XFRAME (w
->frame
);
3008 xassert (!FRAME_WINDOW_P (f
));
3009 hpos
+= XFASTINT (w
->left
);
3013 #endif /* GLYPH_DEBUG */
3017 /**********************************************************************
3019 **********************************************************************/
3021 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
3022 "Clear frame FRAME and output again what is supposed to appear on it.")
3028 CHECK_LIVE_FRAME (frame
, 0);
3031 /* Ignore redraw requests, if frame has no glyphs yet.
3032 (Implementation note: It still has to be checked why we are
3033 called so early here). */
3034 if (!glyphs_initialized_initially_p
)
3038 if (FRAME_MSDOS_P (f
))
3039 set_terminal_modes ();
3041 clear_current_matrices (f
);
3044 windows_or_buffers_changed
++;
3045 /* Mark all windows as inaccurate, so that every window will have
3046 its redisplay done. */
3047 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
3048 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
3054 /* Redraw frame F. This is nothing more than a call to the Lisp
3055 function redraw-frame. */
3062 XSETFRAME (frame
, f
);
3063 Fredraw_frame (frame
);
3067 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
3068 "Clear and redisplay all visible frames.")
3071 Lisp_Object tail
, frame
;
3073 FOR_EACH_FRAME (tail
, frame
)
3074 if (FRAME_VISIBLE_P (XFRAME (frame
)))
3075 Fredraw_frame (frame
);
3081 /* This is used when frame_garbaged is set. Call Fredraw_frame on all
3082 visible frames marked as garbaged. */
3085 redraw_garbaged_frames ()
3087 Lisp_Object tail
, frame
;
3089 FOR_EACH_FRAME (tail
, frame
)
3090 if (FRAME_VISIBLE_P (XFRAME (frame
))
3091 && FRAME_GARBAGED_P (XFRAME (frame
)))
3092 Fredraw_frame (frame
);
3097 /***********************************************************************
3099 ***********************************************************************/
3101 /* Try to update display and current glyph matrix directly.
3103 This function is called after a character G has been inserted into
3104 current_buffer. It tries to update the current glyph matrix and
3105 perform appropriate screen output to reflect the insertion. If it
3106 succeeds, the global flag redisplay_performed_directly_p will be
3107 set to 1, and thereby prevent the more costly general redisplay
3108 from running (see redisplay_internal).
3110 This function is not called for `hairy' character insertions.
3111 In particular, it is not called when after or before change
3112 functions exist, like they are used by font-lock. See keyboard.c
3113 for details where this function is called. */
3116 direct_output_for_insert (g
)
3119 register struct frame
*f
= SELECTED_FRAME ();
3120 struct window
*w
= XWINDOW (selected_window
);
3122 struct glyph_row
*glyph_row
;
3123 struct glyph
*glyphs
, *glyph
, *end
;
3125 /* Non-null means that Redisplay of W is based on window matrices. */
3126 int window_redisplay_p
= FRAME_WINDOW_P (f
);
3127 /* Non-null means we are in overwrite mode. */
3128 int overwrite_p
= !NILP (current_buffer
->overwrite_mode
);
3130 struct text_pos pos
;
3131 int delta
, delta_bytes
;
3133 /* Not done directly. */
3134 redisplay_performed_directly_p
= 0;
3136 /* Quickly give up for some common cases. */
3137 if (cursor_in_echo_area
3138 /* Give up if fonts have changed. */
3140 /* Give up if face attributes have been changed. */
3141 || face_change_count
3142 /* Give up if cursor position not really known. */
3143 || !display_completed
3144 /* Give up if buffer appears in two places. */
3145 || buffer_shared
> 1
3146 /* Give up if w is mini-buffer and a message is being displayed there */
3147 || (MINI_WINDOW_P (w
) && !NILP (echo_area_buffer
[0]))
3148 /* Give up for hscrolled mini-buffer because display of the prompt
3149 is handled specially there (see display_line). */
3150 || (MINI_WINDOW_P (w
) && XFASTINT (w
->hscroll
))
3151 /* Give up if overwriting in the middle of a line. */
3154 && FETCH_BYTE (PT
) != '\n')
3155 /* Give up for tabs and line ends. */
3159 /* Give up if unable to display the cursor in the window. */
3160 || w
->cursor
.vpos
< 0
3161 || (glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
),
3162 /* Can't do it in a continued line because continuation
3163 lines would change. */
3164 (glyph_row
->continued_p
3165 /* Can't use this method if the line overlaps others or is
3166 overlapped by others because these other lines would
3167 have to be redisplayed. */
3168 || glyph_row
->overlapping_p
3169 || glyph_row
->overlapped_p
))
3170 /* Can't do it for partial width windows on terminal frames
3171 because we can't clear to eol in such a window. */
3172 || (!window_redisplay_p
&& !WINDOW_FULL_WIDTH_P (w
)))
3175 /* Set up a display iterator structure for W. Glyphs will be
3176 produced in scratch_glyph_row. Current position is W's cursor
3178 clear_glyph_row (&scratch_glyph_row
);
3179 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
3180 DEC_TEXT_POS (pos
, !NILP (current_buffer
->enable_multibyte_characters
));
3181 init_iterator (&it
, w
, CHARPOS (pos
), BYTEPOS (pos
), &scratch_glyph_row
,
3184 glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3186 /* Give up if highlighting trailing whitespace and we have trailing
3187 whitespace in glyph_row. We would have to remove the trailing
3188 whitespace face in that case. */
3189 if (!NILP (Vshow_trailing_whitespace
)
3190 && glyph_row
->used
[TEXT_AREA
])
3194 last
= glyph_row
->glyphs
[TEXT_AREA
] + glyph_row
->used
[TEXT_AREA
] - 1;
3195 if (last
->type
== STRETCH_GLYPH
3196 || (last
->type
== CHAR_GLYPH
3197 && last
->u
.ch
== ' '))
3201 /* Give up if there are overlay strings at pos. This would fail
3202 if the overlay string has newlines in it. */
3203 if (STRINGP (it
.string
))
3206 it
.hpos
= w
->cursor
.hpos
;
3207 it
.vpos
= w
->cursor
.vpos
;
3208 it
.current_x
= w
->cursor
.x
+ it
.first_visible_x
;
3209 it
.current_y
= w
->cursor
.y
;
3210 it
.end_charpos
= PT
;
3211 it
.stop_charpos
= min (PT
, it
.stop_charpos
);
3213 /* More than one display element may be returned for PT - 1 if
3214 (i) it's a control character which is translated into `\003' or
3215 `^C', or (ii) it has a display table entry, or (iii) it's a
3216 combination of both. */
3217 delta
= delta_bytes
= 0;
3218 while (get_next_display_element (&it
))
3220 PRODUCE_GLYPHS (&it
);
3222 /* Give up if glyph doesn't fit completely on the line. */
3223 if (it
.current_x
>= it
.last_visible_x
)
3226 /* Give up if new glyph has different ascent or descent than
3227 the original row, or if it is not a character glyph. */
3228 if (glyph_row
->ascent
!= it
.ascent
3229 || glyph_row
->height
!= it
.ascent
+ it
.descent
3230 || glyph_row
->phys_ascent
!= it
.phys_ascent
3231 || glyph_row
->phys_height
!= it
.phys_ascent
+ it
.phys_descent
3232 || it
.what
!= IT_CHARACTER
)
3236 delta_bytes
+= it
.len
;
3237 set_iterator_to_next (&it
);
3240 /* Give up if we hit the right edge of the window. We would have
3241 to insert truncation or continuation glyphs. */
3242 added_width
= it
.current_x
- (w
->cursor
.x
+ it
.first_visible_x
);
3243 if (glyph_row
->pixel_width
+ added_width
>= it
.last_visible_x
)
3246 /* Give up if there is a \t following in the line. */
3248 it2
.end_charpos
= ZV
;
3249 it2
.stop_charpos
= min (it2
.stop_charpos
, ZV
);
3250 while (get_next_display_element (&it2
)
3251 && !ITERATOR_AT_END_OF_LINE_P (&it2
))
3255 set_iterator_to_next (&it2
);
3258 /* Number of new glyphs produced. */
3259 n
= it
.glyph_row
->used
[TEXT_AREA
];
3261 /* Start and end of glyphs in original row. */
3262 glyphs
= glyph_row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
3263 end
= glyph_row
->glyphs
[1 + TEXT_AREA
];
3265 /* Make room for new glyphs, then insert them. */
3266 xassert (end
- glyphs
- n
>= 0);
3267 safe_bcopy ((char *) glyphs
, (char *) (glyphs
+ n
),
3268 (end
- glyphs
- n
) * sizeof (*end
));
3269 bcopy (it
.glyph_row
->glyphs
[TEXT_AREA
], glyphs
, n
* sizeof *glyphs
);
3270 glyph_row
->used
[TEXT_AREA
] = min (glyph_row
->used
[TEXT_AREA
] + n
,
3271 end
- glyph_row
->glyphs
[TEXT_AREA
]);
3273 /* Compute new line width. */
3274 glyph
= glyph_row
->glyphs
[TEXT_AREA
];
3275 end
= glyph
+ glyph_row
->used
[TEXT_AREA
];
3276 glyph_row
->pixel_width
= glyph_row
->x
;
3279 glyph_row
->pixel_width
+= glyph
->pixel_width
;
3283 /* Increment buffer positions for glyphs following the newly
3285 for (glyph
= glyphs
+ n
; glyph
< end
; ++glyph
)
3286 if (glyph
->charpos
> 0 && BUFFERP (glyph
->object
))
3287 glyph
->charpos
+= delta
;
3289 if (MATRIX_ROW_END_CHARPOS (glyph_row
) > 0)
3291 MATRIX_ROW_END_CHARPOS (glyph_row
) += delta
;
3292 MATRIX_ROW_END_BYTEPOS (glyph_row
) += delta_bytes
;
3295 /* Adjust positions in lines following the one we are in. */
3296 increment_matrix_positions (w
->current_matrix
,
3298 w
->current_matrix
->nrows
,
3299 delta
, delta_bytes
);
3301 glyph_row
->contains_overlapping_glyphs_p
3302 |= it
.glyph_row
->contains_overlapping_glyphs_p
;
3304 glyph_row
->displays_text_p
= 1;
3305 w
->window_end_vpos
= make_number (max (w
->cursor
.vpos
,
3306 XFASTINT (w
->window_end_vpos
)));
3308 if (!NILP (Vshow_trailing_whitespace
))
3309 highlight_trailing_whitespace (it
.f
, glyph_row
);
3311 /* Write glyphs. If at end of row, we can simply call write_glyphs.
3312 In the middle, we have to insert glyphs. Note that this is now
3313 implemented for X frames. The implementation uses updated_window
3315 updated_row
= glyph_row
;
3319 rif
->update_window_begin_hook (w
);
3321 if (glyphs
== end
- n
)
3322 rif
->write_glyphs (glyphs
, n
);
3324 rif
->insert_glyphs (glyphs
, n
);
3328 if (glyphs
== end
- n
)
3329 write_glyphs (glyphs
, n
);
3331 insert_glyphs (glyphs
, n
);
3334 w
->cursor
.hpos
+= n
;
3335 w
->cursor
.x
= it
.current_x
- it
.first_visible_x
;
3336 xassert (w
->cursor
.hpos
>= 0
3337 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3339 /* How to set the cursor differs depending on whether we are
3340 using a frame matrix or a window matrix. Note that when
3341 a frame matrix is used, cursor_to expects frame coordinates,
3342 and the X and Y parameters are not used. */
3343 if (window_redisplay_p
)
3344 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3345 w
->cursor
.y
, w
->cursor
.x
);
3349 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3350 + (INTEGERP (w
->left_margin_width
)
3351 ? XFASTINT (w
->left_margin_width
)
3353 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3358 rif
->update_window_end_hook (w
, 1);
3363 TRACE ((stderr
, "direct output for insert\n"));
3365 UNCHANGED_MODIFIED
= MODIFF
;
3366 BEG_UNCHANGED
= GPT
- BEG
;
3367 XSETFASTINT (w
->last_point
, PT
);
3368 w
->last_cursor
= w
->cursor
;
3369 XSETFASTINT (w
->last_modified
, MODIFF
);
3370 XSETFASTINT (w
->last_overlay_modified
, OVERLAY_MODIFF
);
3372 redisplay_performed_directly_p
= 1;
3377 /* Perform a direct display update for moving PT by N positions
3378 left or right. N < 0 means a movement backwards. This function
3379 is currently only called for N == 1 or N == -1. */
3382 direct_output_forward_char (n
)
3385 struct frame
*f
= SELECTED_FRAME ();
3386 struct window
*w
= XWINDOW (selected_window
);
3387 struct glyph_row
*row
;
3389 /* Give up if point moved out of or into a composition. */
3390 if (check_point_in_composition (current_buffer
, XINT (w
->last_point
),
3391 current_buffer
, PT
))
3394 /* Give up if face attributes have been changed. */
3395 if (face_change_count
)
3398 /* Give up if current matrix is not up to date or we are
3399 displaying a message. */
3400 if (!display_completed
|| cursor_in_echo_area
)
3403 /* Give up if the buffer's direction is reversed. */
3404 if (!NILP (XBUFFER (w
->buffer
)->direction_reversed
))
3407 /* Can't use direct output if highlighting a region. */
3408 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
3411 /* Can't use direct output if highlighting trailing whitespace. */
3412 if (!NILP (Vshow_trailing_whitespace
))
3415 /* Give up if we are showing a message or just cleared the message
3416 because we might need to resize the echo area window. */
3417 if (!NILP (echo_area_buffer
[0]) || !NILP (echo_area_buffer
[1]))
3420 /* Give up if we don't know where the cursor is. */
3421 if (w
->cursor
.vpos
< 0)
3424 row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3426 if (PT
<= MATRIX_ROW_START_BYTEPOS (row
)
3427 || PT
>= MATRIX_ROW_END_BYTEPOS (row
))
3430 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
3431 w
->last_cursor
= w
->cursor
;
3432 XSETFASTINT (w
->last_point
, PT
);
3434 xassert (w
->cursor
.hpos
>= 0
3435 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3437 if (FRAME_WINDOW_P (f
))
3438 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3439 w
->cursor
.y
, w
->cursor
.x
);
3443 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3444 + (INTEGERP (w
->left_margin_width
)
3445 ? XFASTINT (w
->left_margin_width
)
3447 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3452 redisplay_performed_directly_p
= 1;
3458 /***********************************************************************
3460 ***********************************************************************/
3462 /* Update frame F based on the data in desired matrices.
3464 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3465 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3468 Value is non-zero if redisplay was stopped due to pending input. */
3471 update_frame (f
, force_p
, inhibit_hairy_id_p
)
3474 int inhibit_hairy_id_p
;
3476 /* 1 means display has been paused because of pending input. */
3478 struct window
*root_window
= XWINDOW (f
->root_window
);
3480 if (FRAME_WINDOW_P (f
))
3482 /* We are working on window matrix basis. All windows whose
3483 flag must_be_updated_p is set have to be updated. */
3485 /* Record that we are not working on frame matrices. */
3486 set_frame_matrix_frame (NULL
);
3488 /* Update all windows in the window tree of F, maybe stopping
3489 when pending input is detected. */
3492 /* Update the menu bar on X frames that don't have toolkit
3494 if (WINDOWP (f
->menu_bar_window
))
3495 update_window (XWINDOW (f
->menu_bar_window
), 1);
3497 /* Update the tool-bar window, if present. */
3498 if (WINDOWP (f
->tool_bar_window
))
3501 struct window
*w
= XWINDOW (f
->tool_bar_window
);
3503 /* Update tool-bar window. */
3504 if (w
->must_be_updated_p
)
3506 update_window (w
, 1);
3507 w
->must_be_updated_p
= 0;
3509 /* Swap tool-bar strings. We swap because we want to
3511 tem
= f
->current_tool_bar_string
;
3512 f
->current_tool_bar_string
= f
->desired_tool_bar_string
;
3513 f
->desired_tool_bar_string
= tem
;
3514 f
->n_current_tool_bar_items
= f
->n_desired_tool_bar_items
;
3516 /* Swap tool-bar items. We swap because we want to
3518 tem
= f
->current_tool_bar_items
;
3519 f
->current_tool_bar_items
= f
->desired_tool_bar_items
;
3520 f
->desired_tool_bar_items
= tem
;
3525 /* Update windows. */
3526 paused_p
= update_window_tree (root_window
, force_p
);
3528 display_completed
= !paused_p
;
3530 /* The flush is a performance bottleneck under X. */
3532 rif
->flush_display (f
);
3537 /* We are working on frame matrix basis. Set the frame on whose
3538 frame matrix we operate. */
3539 set_frame_matrix_frame (f
);
3541 /* Build F's desired matrix from window matrices. For windows
3542 whose must_be_updated_p flag is set, desired matrices are
3543 made part of the desired frame matrix. For other windows,
3544 the current matrix is copied. */
3545 build_frame_matrix (f
);
3547 /* Do the update on the frame desired matrix. */
3548 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3550 /* Check window matrices for lost pointers. */
3551 IF_DEBUG (check_window_matrix_pointers (root_window
));
3554 /* Reset flags indicating that a window should be updated. */
3555 set_window_update_flags (root_window
, 0);
3561 /************************************************************************
3562 Window-based updates
3563 ************************************************************************/
3565 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3566 don't stop updating when input is pending. */
3569 update_window_tree (w
, force_p
)
3575 while (w
&& !paused_p
)
3577 if (!NILP (w
->hchild
))
3578 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
3579 else if (!NILP (w
->vchild
))
3580 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
3581 else if (w
->must_be_updated_p
)
3582 paused_p
|= update_window (w
, force_p
);
3584 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3591 /* Update window W if its flag must_be_updated_p is non-zero. If
3592 FORCE_P is non-zero, don't stop updating if input is pending. */
3595 update_single_window (w
, force_p
)
3599 if (w
->must_be_updated_p
)
3601 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3603 /* Record that this is not a frame-based redisplay. */
3604 set_frame_matrix_frame (NULL
);
3608 update_window (w
, force_p
);
3611 /* Reset flag in W. */
3612 w
->must_be_updated_p
= 0;
3617 /* Redraw lines from the current matrix of window W that are
3618 overlapped by other rows. YB is bottom-most y-position in W. */
3621 redraw_overlapped_rows (w
, yb
)
3626 struct glyph_row
*row
;
3628 /* If rows overlapping others have been changed, the rows being
3629 overlapped have to be redrawn. This won't draw lines that have
3630 already been drawn in update_window_line because overlapped_p in
3631 desired rows is 0, so after row assignment overlapped_p in
3632 current rows is 0. */
3633 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3635 row
= w
->current_matrix
->rows
+ i
;
3637 if (!row
->enabled_p
)
3639 else if (row
->mode_line_p
)
3642 if (row
->overlapped_p
)
3644 enum glyph_row_area area
;
3646 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3649 updated_area
= area
;
3650 rif
->cursor_to (i
, 0, row
->y
, area
== TEXT_AREA
? row
->x
: 0);
3651 if (row
->used
[area
])
3652 rif
->write_glyphs (row
->glyphs
[area
], row
->used
[area
]);
3653 rif
->clear_end_of_line (-1);
3656 row
->overlapped_p
= 0;
3659 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3666 /* Redraw lines from the current matrix of window W that overlap
3667 others. YB is bottom-most y-position in W. */
3670 redraw_overlapping_rows (w
, yb
)
3675 struct glyph_row
*row
;
3677 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3679 row
= w
->current_matrix
->rows
+ i
;
3681 if (!row
->enabled_p
)
3683 else if (row
->mode_line_p
)
3686 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3688 if (row
->overlapping_p
&& i
> 0 && bottom_y
< yb
)
3690 if (row
->used
[LEFT_MARGIN_AREA
])
3691 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
);
3693 if (row
->used
[TEXT_AREA
])
3694 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
);
3696 if (row
->used
[RIGHT_MARGIN_AREA
])
3697 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
);
3699 /* Record in neighbor rows that ROW overwrites part of their
3701 if (row
->phys_ascent
> row
->ascent
&& i
> 0)
3702 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3703 if ((row
->phys_height
- row
->phys_ascent
3704 > row
->height
- row
->ascent
)
3706 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
3715 /* Update display of window W. FORCE_P non-zero means that we should
3716 not stop when detecting pending input. */
3719 update_window (w
, force_p
)
3723 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
3725 int preempt_count
= baud_rate
/ 2400 + 1;
3726 extern int input_pending
;
3728 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3729 extern struct frame
*updating_frame
;
3732 /* Check that W's frame doesn't have glyph matrices. */
3733 xassert (FRAME_WINDOW_P (f
));
3734 xassert (updating_frame
!= NULL
);
3736 /* Check pending input the first time so that we can quickly return. */
3737 if (redisplay_dont_pause
)
3740 detect_input_pending ();
3742 /* If forced to complete the update, or if no input is pending, do
3744 if (force_p
|| !input_pending
)
3746 struct glyph_row
*row
, *end
;
3747 struct glyph_row
*mode_line_row
;
3748 struct glyph_row
*header_line_row
= NULL
;
3749 int yb
, changed_p
= 0;
3751 rif
->update_window_begin_hook (w
);
3752 yb
= window_text_bottom_y (w
);
3754 /* If window has a top line, update it before everything else.
3755 Adjust y-positions of other rows by the top line height. */
3756 row
= desired_matrix
->rows
;
3757 end
= row
+ desired_matrix
->nrows
- 1;
3758 if (row
->mode_line_p
)
3759 header_line_row
= row
++;
3761 /* Update the mode line, if necessary. */
3762 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3763 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
3765 mode_line_row
->y
= yb
;
3766 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
3771 /* Find first enabled row. Optimizations in redisplay_internal
3772 may lead to an update with only one row enabled. There may
3773 be also completely empty matrices. */
3774 while (row
< end
&& !row
->enabled_p
)
3777 /* Try reusing part of the display by inserting/deleting lines. */
3778 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
3780 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
3783 /* All rows were found to be equal. */
3792 /* Update the top mode line after scrolling because a new top
3793 line would otherwise overwrite lines at the top of the window
3794 that can be scrolled. */
3795 if (header_line_row
&& header_line_row
->enabled_p
)
3797 header_line_row
->y
= 0;
3798 update_window_line (w
, 0);
3802 /* Update the rest of the lines. */
3803 for (; row
< end
&& (force_p
|| !input_pending
); ++row
)
3805 /* A row can be completely invisible in case a desired
3806 matrix was built with a vscroll and then
3807 make_cursor_line_fully_visible shifts the matrix. */
3808 && row
->visible_height
> 0)
3810 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
3813 /* We'll Have to play a little bit with when to
3814 detect_input_pending. If it's done too often,
3815 scrolling large windows with repeated scroll-up
3816 commands will too quickly pause redisplay. */
3817 if (!force_p
&& vpos
% preempt_count
== 0)
3818 detect_input_pending ();
3820 changed_p
|= update_window_line (w
, vpos
);
3822 /* Mark all rows below the last visible one in the current
3823 matrix as invalid. This is necessary because of
3824 variable line heights. Consider the case of three
3825 successive redisplays, where the first displays 5
3826 lines, the second 3 lines, and the third 5 lines again.
3827 If the second redisplay wouldn't mark rows in the
3828 current matrix invalid, the third redisplay might be
3829 tempted to optimize redisplay based on lines displayed
3830 in the first redisplay. */
3831 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3832 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
3833 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
3836 /* Was display preempted? */
3837 paused_p
= row
< end
;
3841 /* Fix the appearance of overlapping(overlapped rows. */
3842 if (rif
->fix_overlapping_area
3843 && !w
->pseudo_window_p
3847 redraw_overlapped_rows (w
, yb
);
3848 redraw_overlapping_rows (w
, yb
);
3851 if (!paused_p
&& !w
->pseudo_window_p
)
3853 /* Make cursor visible at cursor position of W. */
3854 set_window_cursor_after_update (w
);
3857 /* Check that current matrix invariants are satisfied. This
3858 is for debugging only. See the comment around
3859 check_matrix_invariants. */
3860 IF_DEBUG (check_matrix_invariants (w
));
3865 /* Remember the redisplay method used to display the matrix. */
3866 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
3869 /* End of update of window W. */
3870 rif
->update_window_end_hook (w
, 1);
3876 clear_glyph_matrix (desired_matrix
);
3882 /* Update the display of area AREA in window W, row number VPOS.
3883 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3886 update_marginal_area (w
, area
, vpos
)
3890 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3892 /* Let functions in xterm.c know what area subsequent X positions
3893 will be relative to. */
3894 updated_area
= area
;
3896 /* Set cursor to start of glyphs, write them, and clear to the end
3897 of the area. I don't think that something more sophisticated is
3898 necessary here, since marginal areas will not be the default. */
3899 rif
->cursor_to (vpos
, 0, desired_row
->y
, 0);
3900 if (desired_row
->used
[area
])
3901 rif
->write_glyphs (desired_row
->glyphs
[area
], desired_row
->used
[area
]);
3902 rif
->clear_end_of_line (-1);
3906 /* Update the display of the text area of row VPOS in window W.
3907 Value is non-zero if display has changed. */
3910 update_text_area (w
, vpos
)
3914 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3915 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3918 /* Let functions in xterm.c know what area subsequent X positions
3919 will be relative to. */
3920 updated_area
= TEXT_AREA
;
3922 /* If rows are at different X or Y, or rows have different height,
3923 or the current row is marked invalid, write the entire line. */
3924 if (!current_row
->enabled_p
3925 || desired_row
->y
!= current_row
->y
3926 || desired_row
->ascent
!= current_row
->ascent
3927 || desired_row
->phys_ascent
!= current_row
->phys_ascent
3928 || desired_row
->phys_height
!= current_row
->phys_height
3929 || desired_row
->visible_height
!= current_row
->visible_height
3930 || current_row
->overlapped_p
3931 || current_row
->x
!= desired_row
->x
)
3933 rif
->cursor_to (vpos
, 0, desired_row
->y
, desired_row
->x
);
3935 if (desired_row
->used
[TEXT_AREA
])
3936 rif
->write_glyphs (desired_row
->glyphs
[TEXT_AREA
],
3937 desired_row
->used
[TEXT_AREA
]);
3939 /* Clear to end of window. */
3940 rif
->clear_end_of_line (-1);
3946 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
3947 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
3949 /* If the desired row extends its face to the text area end,
3950 make sure we write at least one glyph, so that the face
3951 extension actually takes place. */
3952 int desired_stop_pos
= (desired_row
->used
[TEXT_AREA
]
3953 - (MATRIX_ROW_EXTENDS_FACE_P (desired_row
)
3956 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
3962 /* Skip over glyphs that both rows have in common. These
3963 don't have to be written. */
3965 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3967 x
+= desired_glyph
->pixel_width
;
3968 ++desired_glyph
, ++current_glyph
, ++i
;
3971 /* Consider the case that the current row contains "xxx ppp
3972 ggg" in italic Courier font, and the desired row is "xxx
3973 ggg". The character `p' has lbearing, `g' has not. The
3974 loop above will stop in front of the first `p' in the
3975 current row. If we would start writing glyphs there, we
3976 wouldn't erase the lbearing of the `p'. The rest of the
3977 lbearing problem is then taken care of by x_draw_glyphs. */
3978 if (current_row
->contains_overlapping_glyphs_p
3980 && i
< current_row
->used
[TEXT_AREA
]
3981 && current_row
->used
[TEXT_AREA
] != desired_row
->used
[TEXT_AREA
])
3984 rif
->get_glyph_overhangs (current_glyph
, XFRAME (w
->frame
),
3986 while (left
> 0 && i
> 0)
3988 --i
, --desired_glyph
, --current_glyph
;
3989 x
-= desired_glyph
->pixel_width
;
3990 left
-= desired_glyph
->pixel_width
;
3994 /* Try to avoid writing the entire rest of the desired row
3995 by looking for a resync point. This mainly prevents
3996 mode line flickering in the case the mode line is in
3997 fixed-pitch font, which it usually will be. */
3998 if (i
< desired_row
->used
[TEXT_AREA
])
4000 int start_x
= x
, start_hpos
= i
;
4001 struct glyph
*start
= desired_glyph
;
4004 /* Find the next glyph that's equal again. */
4006 && !GLYPH_EQUAL_P (desired_glyph
, current_glyph
)
4009 x
+= desired_glyph
->pixel_width
;
4010 current_x
+= current_glyph
->pixel_width
;
4011 ++desired_glyph
, ++current_glyph
, ++i
;
4014 if (i
== start_hpos
|| x
!= current_x
)
4018 desired_glyph
= start
;
4022 rif
->cursor_to (vpos
, start_hpos
, desired_row
->y
, start_x
);
4023 rif
->write_glyphs (start
, i
- start_hpos
);
4028 /* Write the rest. */
4029 if (i
< desired_row
->used
[TEXT_AREA
])
4031 rif
->cursor_to (vpos
, i
, desired_row
->y
, x
);
4032 rif
->write_glyphs (desired_glyph
, desired_row
->used
[TEXT_AREA
] - i
);
4036 /* Maybe clear to end of line. */
4037 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
4039 /* If new row extends to the end of the text area, nothing
4040 has to be cleared, if and only if we did a write_glyphs
4041 above. This is made sure by setting desired_stop_pos
4042 appropriately above. */
4043 xassert (i
< desired_row
->used
[TEXT_AREA
]);
4045 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
4047 /* If old row extends to the end of the text area, clear. */
4048 if (i
>= desired_row
->used
[TEXT_AREA
])
4049 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4050 desired_row
->x
+ desired_row
->pixel_width
);
4051 rif
->clear_end_of_line (-1);
4054 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
4056 /* Otherwise clear to the end of the old row. Everything
4057 after that position should be clear already. */
4060 if (i
>= desired_row
->used
[TEXT_AREA
])
4061 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4062 desired_row
->x
+ desired_row
->pixel_width
);
4064 /* If cursor is displayed at the end of the line, make sure
4065 it's cleared. Nowadays we don't have a phys_cursor_glyph
4066 with which to erase the cursor (because this method
4067 doesn't work with lbearing/rbearing), so we must do it
4069 if (vpos
== w
->phys_cursor
.vpos
4070 && w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])
4072 w
->phys_cursor_on_p
= 0;
4076 x
= current_row
->x
+ current_row
->pixel_width
;
4077 rif
->clear_end_of_line (x
);
4086 /* Update row VPOS in window W. Value is non-zero if display has been
4090 update_window_line (w
, vpos
)
4094 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
4095 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
4098 xassert (desired_row
->enabled_p
);
4100 /* Set the row being updated. This is important to let xterm.c
4101 know what line height values are in effect. */
4102 updated_row
= desired_row
;
4104 /* Update display of the left margin area, if there is one. */
4105 if (!desired_row
->full_width_p
4106 && !NILP (w
->left_margin_width
))
4108 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
4112 /* Update the display of the text area. */
4113 changed_p
|= update_text_area (w
, vpos
);
4115 /* Update display of the right margin area, if there is one. */
4116 if (!desired_row
->full_width_p
4117 && !NILP (w
->right_margin_width
))
4120 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
4123 /* Draw truncation marks etc. */
4124 if (!current_row
->enabled_p
4125 || desired_row
->y
!= current_row
->y
4126 || desired_row
->visible_height
!= current_row
->visible_height
4127 || desired_row
->overlay_arrow_p
!= current_row
->overlay_arrow_p
4128 || desired_row
->truncated_on_left_p
!= current_row
->truncated_on_left_p
4129 || desired_row
->truncated_on_right_p
!= current_row
->truncated_on_right_p
4130 || desired_row
->continued_p
!= current_row
->continued_p
4131 || desired_row
->mode_line_p
!= current_row
->mode_line_p
4132 || (desired_row
->indicate_empty_line_p
4133 != current_row
->indicate_empty_line_p
)
4134 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
4135 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
4136 rif
->after_update_window_line_hook (desired_row
);
4138 /* Update current_row from desired_row. */
4139 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4145 /* Set the cursor after an update of window W. This function may only
4146 be called from update_window. */
4149 set_window_cursor_after_update (w
)
4152 struct frame
*f
= XFRAME (w
->frame
);
4153 int cx
, cy
, vpos
, hpos
;
4155 /* Not intended for frame matrix updates. */
4156 xassert (FRAME_WINDOW_P (f
));
4158 if (cursor_in_echo_area
4159 && !NILP (echo_area_buffer
[0])
4160 /* If we are showing a message instead of the mini-buffer,
4161 show the cursor for the message instead. */
4162 && XWINDOW (minibuf_window
) == w
4163 && EQ (minibuf_window
, echo_area_window
)
4164 /* These cases apply only to the frame that contains
4165 the active mini-buffer window. */
4166 && FRAME_HAS_MINIBUF_P (f
)
4167 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4169 cx
= cy
= vpos
= hpos
= 0;
4171 if (cursor_in_echo_area
>= 0)
4173 /* If the mini-buffer is several lines high, find the last
4174 line that has any text on it. Note: either all lines
4175 are enabled or none. Otherwise we wouldn't be able to
4177 struct glyph_row
*row
, *last_row
;
4178 struct glyph
*glyph
;
4179 int yb
= window_text_bottom_y (w
);
4182 for (row
= MATRIX_ROW (w
->current_matrix
, 0);
4186 if (row
->used
[TEXT_AREA
]
4187 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4190 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4196 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
4197 struct glyph
*last
= start
+ row
->used
[TEXT_AREA
] - 1;
4199 while (last
> start
&& last
->charpos
< 0)
4202 for (glyph
= start
; glyph
< last
; ++glyph
)
4204 cx
+= glyph
->pixel_width
;
4209 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4217 hpos
= w
->cursor
.hpos
;
4218 vpos
= w
->cursor
.vpos
;
4221 /* Window cursor can be out of sync for horizontally split windows. */
4222 hpos
= max (0, hpos
);
4223 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4224 vpos
= max (0, vpos
);
4225 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4226 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4230 /* Set WINDOW->must_be_updated_p to ON_P for all windows in the window
4231 tree rooted at W. */
4234 set_window_update_flags (w
, on_p
)
4240 if (!NILP (w
->hchild
))
4241 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4242 else if (!NILP (w
->vchild
))
4243 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4245 w
->must_be_updated_p
= on_p
;
4247 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4253 /***********************************************************************
4254 Window-Based Scrolling
4255 ***********************************************************************/
4257 /* Structure describing rows in scrolling_window. */
4261 /* Number of occurrences of this row in desired and current matrix. */
4262 int old_uses
, new_uses
;
4264 /* Vpos of row in new matrix. */
4265 int new_line_number
;
4267 /* Bucket index of this row_entry in the hash table row_table. */
4270 /* The row described by this entry. */
4271 struct glyph_row
*row
;
4273 /* Hash collision chain. */
4274 struct row_entry
*next
;
4277 /* A pool to allocate row_entry structures from, and the size of the
4278 pool. The pool is reallocated in scrolling_window when we find
4279 that we need a larger one. */
4281 static struct row_entry
*row_entry_pool
;
4282 static int row_entry_pool_size
;
4284 /* Index of next free entry in row_entry_pool. */
4286 static int row_entry_idx
;
4288 /* The hash table used during scrolling, and the table's size. This
4289 table is used to quickly identify equal rows in the desired and
4292 static struct row_entry
**row_table
;
4293 static int row_table_size
;
4295 /* Vectors of pointers to row_entry structures belonging to the
4296 current and desired matrix, and the size of the vectors. */
4298 static struct row_entry
**old_lines
, **new_lines
;
4299 static int old_lines_size
, new_lines_size
;
4301 /* A pool to allocate run structures from, and its size. */
4303 static struct run
*run_pool
;
4304 static int runs_size
;
4306 /* A vector of runs of lines found during scrolling. */
4308 static struct run
**runs
;
4310 static struct row_entry
*add_row_entry
P_ ((struct window
*,
4311 struct glyph_row
*));
4314 /* Add glyph row ROW to the scrolling hash table during the scrolling
4317 static INLINE
struct row_entry
*
4318 add_row_entry (w
, row
)
4320 struct glyph_row
*row
;
4322 struct row_entry
*entry
;
4323 int i
= row
->hash
% row_table_size
;
4325 entry
= row_table
[i
];
4326 while (entry
&& !row_equal_p (w
, entry
->row
, row
))
4327 entry
= entry
->next
;
4331 entry
= row_entry_pool
+ row_entry_idx
++;
4333 entry
->old_uses
= entry
->new_uses
= 0;
4334 entry
->new_line_number
= 0;
4336 entry
->next
= row_table
[i
];
4337 row_table
[i
] = entry
;
4344 /* Try to reuse part of the current display of W by scrolling lines.
4345 HEADER_LINE_P non-zero means W has a top mode line.
4347 The algorithm is taken from Communications of the ACM, Apr78 "A
4348 Technique for Isolating Differences Between Files." It should take
4351 A short outline of the steps of the algorithm
4353 1. Skip lines equal at the start and end of both matrices.
4355 2. Enter rows in the current and desired matrix into a symbol
4356 table, counting how often they appear in both matrices.
4358 3. Rows that appear exactly once in both matrices serve as anchors,
4359 i.e. we assume that such lines are likely to have been moved.
4361 4. Starting from anchor lines, extend regions to be scrolled both
4362 forward and backward.
4366 -1 if all rows were found to be equal.
4367 0 to indicate that we did not scroll the display, or
4368 1 if we did scroll. */
4371 scrolling_window (w
, header_line_p
)
4375 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4376 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4377 int yb
= window_text_bottom_y (w
);
4378 int i
, j
, first_old
, first_new
, last_old
, last_new
;
4379 int nruns
, nbytes
, n
, run_idx
;
4380 struct row_entry
*entry
;
4382 /* Skip over rows equal at the start. */
4383 i
= header_line_p
? 1 : 0;
4384 while (i
< current_matrix
->nrows
- 1
4385 && MATRIX_ROW_ENABLED_P (current_matrix
, i
)
4386 && MATRIX_ROW_ENABLED_P (desired_matrix
, i
)
4387 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) <= yb
4388 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) <= yb
4390 MATRIX_ROW (desired_matrix
, i
),
4391 MATRIX_ROW (current_matrix
, i
)))
4393 assign_row (MATRIX_ROW (current_matrix
, i
),
4394 MATRIX_ROW (desired_matrix
, i
));
4395 MATRIX_ROW (desired_matrix
, i
)->enabled_p
= 0;
4399 /* Give up if some rows in the desired matrix are not enabled. */
4400 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4403 first_old
= first_new
= i
;
4405 /* Set last_new to the index + 1 of the last enabled row in the
4408 while (i
< desired_matrix
->nrows
- 1
4409 && MATRIX_ROW (desired_matrix
, i
)->enabled_p
4410 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) <= yb
)
4413 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4418 /* Set last_old to the index + 1 of the last enabled row in the
4419 current matrix. We don't look at the enabled flag here because
4420 we plan to reuse part of the display even if other parts are
4423 while (i
< current_matrix
->nrows
- 1
4424 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) <= yb
)
4428 /* Skip over rows equal at the bottom. */
4431 while (i
- 1 > first_new
4432 && j
- 1 > first_old
4433 && MATRIX_ROW (current_matrix
, i
- 1)->enabled_p
4434 && (MATRIX_ROW (current_matrix
, i
- 1)->y
4435 == MATRIX_ROW (desired_matrix
, j
- 1)->y
)
4437 MATRIX_ROW (desired_matrix
, i
- 1),
4438 MATRIX_ROW (current_matrix
, j
- 1)))
4443 /* Nothing to do if all rows are equal. */
4444 if (last_new
== first_new
)
4447 /* Reallocate vectors, tables etc. if necessary. */
4449 if (current_matrix
->nrows
> old_lines_size
)
4451 old_lines_size
= current_matrix
->nrows
;
4452 nbytes
= old_lines_size
* sizeof *old_lines
;
4453 old_lines
= (struct row_entry
**) xrealloc (old_lines
, nbytes
);
4456 if (desired_matrix
->nrows
> new_lines_size
)
4458 new_lines_size
= desired_matrix
->nrows
;
4459 nbytes
= new_lines_size
* sizeof *new_lines
;
4460 new_lines
= (struct row_entry
**) xrealloc (new_lines
, nbytes
);
4463 n
= desired_matrix
->nrows
+ current_matrix
->nrows
;
4464 if (3 * n
> row_table_size
)
4466 row_table_size
= next_almost_prime (3 * n
);
4467 nbytes
= row_table_size
* sizeof *row_table
;
4468 row_table
= (struct row_entry
**) xrealloc (row_table
, nbytes
);
4469 bzero (row_table
, nbytes
);
4472 if (n
> row_entry_pool_size
)
4474 row_entry_pool_size
= n
;
4475 nbytes
= row_entry_pool_size
* sizeof *row_entry_pool
;
4476 row_entry_pool
= (struct row_entry
*) xrealloc (row_entry_pool
, nbytes
);
4479 if (desired_matrix
->nrows
> runs_size
)
4481 runs_size
= desired_matrix
->nrows
;
4482 nbytes
= runs_size
* sizeof *runs
;
4483 runs
= (struct run
**) xrealloc (runs
, nbytes
);
4484 nbytes
= runs_size
* sizeof *run_pool
;
4485 run_pool
= (struct run
*) xrealloc (run_pool
, nbytes
);
4488 nruns
= run_idx
= 0;
4491 /* Add rows from the current and desired matrix to the hash table
4492 row_hash_table to be able to find equal ones quickly. */
4494 for (i
= first_old
; i
< last_old
; ++i
)
4496 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4498 entry
= add_row_entry (w
, MATRIX_ROW (current_matrix
, i
));
4499 old_lines
[i
] = entry
;
4503 old_lines
[i
] = NULL
;
4506 for (i
= first_new
; i
< last_new
; ++i
)
4508 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4509 entry
= add_row_entry (w
, MATRIX_ROW (desired_matrix
, i
));
4511 entry
->new_line_number
= i
;
4512 new_lines
[i
] = entry
;
4515 /* Identify moves based on lines that are unique and equal
4516 in both matrices. */
4517 for (i
= first_old
; i
< last_old
;)
4519 && old_lines
[i
]->old_uses
== 1
4520 && old_lines
[i
]->new_uses
== 1)
4523 int new_line
= old_lines
[i
]->new_line_number
;
4524 struct run
*run
= run_pool
+ run_idx
++;
4527 run
->current_vpos
= i
;
4528 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4529 run
->desired_vpos
= new_line
;
4530 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4532 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4534 /* Extend backward. */
4537 while (j
> first_old
4539 && old_lines
[j
] == new_lines
[k
])
4541 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4542 --run
->current_vpos
;
4543 --run
->desired_vpos
;
4546 run
->desired_y
-= h
;
4547 run
->current_y
-= h
;
4551 /* Extend forward. */
4556 && old_lines
[j
] == new_lines
[k
])
4558 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4564 /* Insert run into list of all runs. Order runs by copied
4565 pixel lines. Note that we record runs that don't have to
4566 be copied because they are already in place. This is done
4567 because we can avoid calling update_window_line in this
4569 for (j
= 0; j
< nruns
&& runs
[j
]->height
> run
->height
; ++j
)
4571 for (k
= nruns
; k
>= j
; --k
)
4572 runs
[k
] = runs
[k
- 1];
4581 /* Do the moves. Do it in a way that we don't overwrite something
4582 we want to copy later on. This is not solvable in general
4583 because there is only one display and we don't have a way to
4584 exchange areas on this display. Example:
4586 +-----------+ +-----------+
4588 +-----------+ --> +-----------+
4590 +-----------+ +-----------+
4592 Instead, prefer bigger moves, and invalidate moves that would
4593 copy from where we copied to. */
4595 for (i
= 0; i
< nruns
; ++i
)
4596 if (runs
[i
]->nrows
> 0)
4598 struct run
*r
= runs
[i
];
4600 /* Copy on the display. */
4601 if (r
->current_y
!= r
->desired_y
)
4603 rif
->scroll_run_hook (w
, r
);
4605 /* Invalidate runs that copy from where we copied to. */
4606 for (j
= i
+ 1; j
< nruns
; ++j
)
4608 struct run
*p
= runs
[j
];
4610 if ((p
->current_y
>= r
->desired_y
4611 && p
->current_y
< r
->desired_y
+ r
->height
)
4612 || (p
->current_y
+ p
->height
>= r
->desired_y
4613 && (p
->current_y
+ p
->height
4614 < r
->desired_y
+ r
->height
)))
4619 /* Assign matrix rows. */
4620 for (j
= 0; j
< r
->nrows
; ++j
)
4622 struct glyph_row
*from
, *to
;
4623 int to_overlapped_p
;
4625 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
4626 to_overlapped_p
= to
->overlapped_p
;
4627 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
4628 assign_row (to
, from
);
4629 to
->enabled_p
= 1, from
->enabled_p
= 0;
4630 to
->overlapped_p
= to_overlapped_p
;
4634 /* Clear the hash table, for the next time. */
4635 for (i
= 0; i
< row_entry_idx
; ++i
)
4636 row_table
[row_entry_pool
[i
].bucket
] = NULL
;
4638 /* Value is non-zero to indicate that we scrolled the display. */
4644 /************************************************************************
4646 ************************************************************************/
4648 /* Update the desired frame matrix of frame F.
4650 FORCE_P non-zero means that the update should not be stopped by
4651 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
4652 should not be tried.
4654 Value is non-zero if update was stopped due to pending input. */
4657 update_frame_1 (f
, force_p
, inhibit_id_p
)
4662 /* Frame matrices to work on. */
4663 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4664 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4667 int preempt_count
= baud_rate
/ 2400 + 1;
4668 extern int input_pending
;
4670 xassert (current_matrix
&& desired_matrix
);
4672 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
4673 calculate_costs (f
);
4675 if (preempt_count
<= 0)
4678 detect_input_pending ();
4679 if (input_pending
&& !force_p
)
4687 /* If we cannot insert/delete lines, it's no use trying it. */
4688 if (!line_ins_del_ok
)
4691 /* See if any of the desired lines are enabled; don't compute for
4692 i/d line if just want cursor motion. */
4693 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
4694 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4697 /* Try doing i/d line, if not yet inhibited. */
4698 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
4699 force_p
|= scrolling (f
);
4701 /* Update the individual lines as needed. Do bottom line first. */
4702 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
4703 update_frame_line (f
, desired_matrix
->nrows
- 1);
4705 /* Now update the rest of the lines. */
4706 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
4708 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4710 if (FRAME_TERMCAP_P (f
))
4712 /* Flush out every so many lines.
4713 Also flush out if likely to have more than 1k buffered
4714 otherwise. I'm told that some telnet connections get
4715 really screwed by more than 1k output at once. */
4716 int outq
= PENDING_OUTPUT_COUNT (stdout
);
4718 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
4721 if (preempt_count
== 1)
4723 #ifdef EMACS_OUTQSIZE
4724 if (EMACS_OUTQSIZE (0, &outq
) < 0)
4725 /* Probably not a tty. Ignore the error and reset
4726 * the outq count. */
4727 outq
= PENDING_OUTPUT_COUNT (stdout
);
4730 if (baud_rate
<= outq
&& baud_rate
> 0)
4731 sleep (outq
/ baud_rate
);
4736 if ((i
- 1) % preempt_count
== 0)
4737 detect_input_pending ();
4739 update_frame_line (f
, i
);
4743 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
4745 /* Now just clean up termcap drivers and set cursor, etc. */
4748 if ((cursor_in_echo_area
4749 /* If we are showing a message instead of the mini-buffer,
4750 show the cursor for the message instead of for the
4751 (now hidden) mini-buffer contents. */
4752 || (EQ (minibuf_window
, selected_window
)
4753 && EQ (minibuf_window
, echo_area_window
)
4754 && !NILP (echo_area_buffer
[0])))
4755 /* These cases apply only to the frame that contains
4756 the active mini-buffer window. */
4757 && FRAME_HAS_MINIBUF_P (f
)
4758 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4760 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
4763 if (cursor_in_echo_area
< 0)
4765 /* Negative value of cursor_in_echo_area means put
4766 cursor at beginning of line. */
4772 /* Positive value of cursor_in_echo_area means put
4773 cursor at the end of the prompt. If the mini-buffer
4774 is several lines high, find the last line that has
4776 row
= FRAME_HEIGHT (f
);
4782 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
4784 /* Frame rows are filled up with spaces that
4785 must be ignored here. */
4786 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
4788 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
4789 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
4792 && (last
- 1)->charpos
< 0)
4798 while (row
> top
&& col
== 0);
4800 /* Make sure COL is not out of range. */
4801 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
4803 /* If we have another row, advance cursor into it. */
4804 if (row
< FRAME_HEIGHT (f
) - 1)
4806 col
= FRAME_LEFT_SCROLL_BAR_WIDTH (f
);
4809 /* Otherwise move it back in range. */
4811 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
4815 cursor_to (row
, col
);
4819 /* We have only one cursor on terminal frames. Use it to
4820 display the cursor of the selected window. */
4821 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
4822 if (w
->cursor
.vpos
>= 0
4823 /* The cursor vpos may be temporarily out of bounds
4824 in the following situation: There is one window,
4825 with the cursor in the lower half of it. The window
4826 is split, and a message causes a redisplay before
4827 a new cursor position has been computed. */
4828 && w
->cursor
.vpos
< XFASTINT (w
->height
))
4830 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
4831 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
4833 if (INTEGERP (w
->left_margin_width
))
4834 x
+= XFASTINT (w
->left_margin_width
);
4836 /* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
4845 fflush (termscript
);
4850 display_completed
= !pause
;
4851 clear_desired_matrices (f
);
4856 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4860 struct frame
*frame
;
4862 int unchanged_at_top
, unchanged_at_bottom
;
4865 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4866 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4867 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4868 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4870 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
4871 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4872 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4874 if (!current_matrix
)
4877 /* Compute hash codes of all the lines. Also calculate number of
4878 changed lines, number of unchanged lines at the beginning, and
4879 number of unchanged lines at the end. */
4881 unchanged_at_top
= 0;
4882 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
4883 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
4885 /* Give up on this scrolling if some old lines are not enabled. */
4886 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
4888 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
4889 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4891 /* This line cannot be redrawn, so don't let scrolling mess it. */
4892 new_hash
[i
] = old_hash
[i
];
4893 #define INFINITY 1000000 /* Taken from scroll.c */
4894 draw_cost
[i
] = INFINITY
;
4898 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
4899 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
4902 if (old_hash
[i
] != new_hash
[i
])
4905 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
4907 else if (i
== unchanged_at_top
)
4909 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
4912 /* If changed lines are few, don't allow preemption, don't scroll. */
4913 if ((!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400)
4914 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
4917 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
4918 - unchanged_at_bottom
);
4920 if (scroll_region_ok
)
4921 free_at_end_vpos
-= unchanged_at_bottom
;
4922 else if (memory_below_frame
)
4923 free_at_end_vpos
= -1;
4925 /* If large window, fast terminal and few lines in common between
4926 current frame and desired frame, don't bother with i/d calc. */
4927 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
4929 10 * scrolling_max_lines_saved (unchanged_at_top
,
4930 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
4931 old_hash
, new_hash
, draw_cost
)))
4934 if (window_size
< 2)
4937 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
4938 draw_cost
+ unchanged_at_top
- 1,
4939 old_draw_cost
+ unchanged_at_top
- 1,
4940 old_hash
+ unchanged_at_top
- 1,
4941 new_hash
+ unchanged_at_top
- 1,
4942 free_at_end_vpos
- unchanged_at_top
);
4948 /* Count the number of blanks at the start of the vector of glyphs R
4949 which is LEN glyphs long. */
4952 count_blanks (r
, len
)
4958 for (i
= 0; i
< len
; ++i
)
4959 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
4966 /* Count the number of glyphs in common at the start of the glyph
4967 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
4968 of STR2. Value is the number of equal glyphs equal at the start. */
4971 count_match (str1
, end1
, str2
, end2
)
4972 struct glyph
*str1
, *end1
, *str2
, *end2
;
4974 struct glyph
*p1
= str1
;
4975 struct glyph
*p2
= str2
;
4979 && GLYPH_CHAR_AND_FACE_EQUAL_P (p1
, p2
))
4986 /* Char insertion/deletion cost vector, from term.c */
4988 extern int *char_ins_del_vector
;
4989 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
4992 /* Perform a frame-based update on line VPOS in frame FRAME. */
4995 update_frame_line (frame
, vpos
)
4996 register struct frame
*frame
;
4999 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
5001 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
5002 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
5003 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
5004 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
5005 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
5006 int must_write_whole_line_p
;
5008 if (desired_row
->inverse_p
5009 != (current_row
->enabled_p
&& current_row
->inverse_p
))
5011 int n
= current_row
->enabled_p
? current_row
->used
[TEXT_AREA
] : 0;
5012 change_line_highlight (desired_row
->inverse_p
, vpos
, vpos
, n
);
5013 current_row
->enabled_p
= 0;
5016 reassert_line_highlight (desired_row
->inverse_p
, vpos
);
5018 /* Current row not enabled means it has unknown contents. We must
5019 write the whole desired line in that case. */
5020 must_write_whole_line_p
= !current_row
->enabled_p
;
5021 if (must_write_whole_line_p
)
5028 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
5029 olen
= current_row
->used
[TEXT_AREA
];
5031 if (! current_row
->inverse_p
)
5033 /* Ignore trailing spaces, if we can. */
5034 if (!must_write_spaces
)
5035 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
5040 /* For an inverse-video line, make sure it's filled with
5041 spaces all the way to the frame edge so that the reverse
5042 video extends all the way across. */
5043 while (olen
< FRAME_WIDTH (frame
) - 1)
5044 obody
[olen
++] = space_glyph
;
5048 current_row
->enabled_p
= 1;
5049 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
5050 current_row
->inverse_p
= desired_row
->inverse_p
;
5052 /* If desired line is empty, just clear the line. */
5053 if (!desired_row
->enabled_p
)
5059 nbody
= desired_row
->glyphs
[TEXT_AREA
];
5060 nlen
= desired_row
->used
[TEXT_AREA
];
5061 nend
= nbody
+ nlen
;
5063 /* If display line has unknown contents, write the whole line. */
5064 if (must_write_whole_line_p
)
5066 /* Ignore spaces at the end, if we can. */
5067 if (!must_write_spaces
)
5068 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5071 /* Write the contents of the desired line. */
5074 cursor_to (vpos
, 0);
5075 write_glyphs (nbody
, nlen
);
5078 /* Don't call clear_end_of_line if we already wrote the whole
5079 line. The cursor will not be at the right margin in that
5080 case but in the line below. */
5081 if (nlen
< FRAME_WINDOW_WIDTH (frame
))
5083 cursor_to (vpos
, nlen
);
5084 clear_end_of_line (FRAME_WINDOW_WIDTH (frame
));
5087 /* Make sure we are in the right row, otherwise cursor movement
5088 with cmgoto might use `ch' in the wrong row. */
5089 cursor_to (vpos
, 0);
5091 make_current (desired_matrix
, current_matrix
, vpos
);
5095 /* Pretend trailing spaces are not there at all,
5096 unless for one reason or another we must write all spaces. */
5097 if (!desired_row
->inverse_p
)
5099 if (!must_write_spaces
)
5100 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5105 /* For an inverse-video line, give it extra trailing spaces all
5106 the way to the frame edge so that the reverse video extends
5107 all the way across. */
5108 while (nlen
< FRAME_WIDTH (frame
) - 1)
5109 nbody
[nlen
++] = space_glyph
;
5112 /* If there's no i/d char, quickly do the best we can without it. */
5113 if (!char_ins_del_ok
)
5117 /* Find the first glyph in desired row that doesn't agree with
5118 a glyph in the current row, and write the rest from there on. */
5119 for (i
= 0; i
< nlen
; i
++)
5121 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
5123 /* Find the end of the run of different glyphs. */
5127 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
5128 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
5131 /* Output this run of non-matching chars. */
5132 cursor_to (vpos
, i
);
5133 write_glyphs (nbody
+ i
, j
- i
);
5136 /* Now find the next non-match. */
5140 /* Clear the rest of the line, or the non-clear part of it. */
5143 cursor_to (vpos
, nlen
);
5144 clear_end_of_line (olen
);
5147 /* Make current row = desired row. */
5148 make_current (desired_matrix
, current_matrix
, vpos
);
5152 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
5153 characters in a row. */
5157 /* If current line is blank, skip over initial spaces, if
5158 possible, and write the rest. */
5159 if (must_write_spaces
|| desired_row
->inverse_p
)
5162 nsp
= count_blanks (nbody
, nlen
);
5166 cursor_to (vpos
, nsp
);
5167 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
5170 /* Exchange contents between current_frame and new_frame. */
5171 make_current (desired_matrix
, current_matrix
, vpos
);
5175 /* Compute number of leading blanks in old and new contents. */
5176 osp
= count_blanks (obody
, olen
);
5177 nsp
= desired_row
->inverse_p
? 0 : count_blanks (nbody
, nlen
);
5179 /* Compute number of matching chars starting with first non-blank. */
5180 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
5181 nbody
+ nsp
, nbody
+ nlen
);
5183 /* Spaces in new match implicit space past the end of old. */
5184 /* A bug causing this to be a no-op was fixed in 18.29. */
5185 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
5188 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
5192 /* Avoid doing insert/delete char
5193 just cause number of leading spaces differs
5194 when the following text does not match. */
5195 if (begmatch
== 0 && osp
!= nsp
)
5196 osp
= nsp
= min (osp
, nsp
);
5198 /* Find matching characters at end of line */
5201 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
5203 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
5208 endmatch
= obody
+ olen
- op1
;
5210 /* tem gets the distance to insert or delete.
5211 endmatch is how many characters we save by doing so.
5214 tem
= (nlen
- nsp
) - (olen
- osp
);
5216 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
5219 /* nsp - osp is the distance to insert or delete.
5220 If that is nonzero, begmatch is known to be nonzero also.
5221 begmatch + endmatch is how much we save by doing the ins/del.
5225 && (!char_ins_del_ok
5226 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
5230 osp
= nsp
= min (osp
, nsp
);
5233 /* Now go through the line, inserting, writing and
5234 deleting as appropriate. */
5238 cursor_to (vpos
, nsp
);
5239 delete_glyphs (osp
- nsp
);
5243 /* If going to delete chars later in line
5244 and insert earlier in the line,
5245 must delete first to avoid losing data in the insert */
5246 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
5248 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
5249 delete_glyphs (olen
+ nsp
- osp
- nlen
);
5250 olen
= nlen
- (nsp
- osp
);
5252 cursor_to (vpos
, osp
);
5253 insert_glyphs (0, nsp
- osp
);
5257 tem
= nsp
+ begmatch
+ endmatch
;
5258 if (nlen
!= tem
|| olen
!= tem
)
5260 cursor_to (vpos
, nsp
+ begmatch
);
5261 if (!endmatch
|| nlen
== olen
)
5263 /* If new text being written reaches right margin,
5264 there is no need to do clear-to-eol at the end.
5265 (and it would not be safe, since cursor is not
5266 going to be "at the margin" after the text is done) */
5267 if (nlen
== FRAME_WINDOW_WIDTH (frame
))
5269 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5271 else if (nlen
> olen
)
5273 /* Here, we used to have the following simple code:
5274 ----------------------------------------
5275 write_glyphs (nbody + nsp + begmatch, olen - tem);
5276 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5277 ----------------------------------------
5278 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5279 is a padding glyph. */
5280 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5283 /* Calculate columns we can actually overwrite. */
5284 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
])) out
--;
5285 write_glyphs (nbody
+ nsp
+ begmatch
, out
);
5286 /* If we left columns to be overwritten, we must delete them. */
5287 del
= olen
- tem
- out
;
5288 if (del
> 0) delete_glyphs (del
);
5289 /* At last, we insert columns not yet written out. */
5290 insert_glyphs (nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5293 else if (olen
> nlen
)
5295 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5296 delete_glyphs (olen
- nlen
);
5302 /* If any unerased characters remain after the new line, erase them. */
5305 cursor_to (vpos
, nlen
);
5306 clear_end_of_line (olen
);
5309 /* Exchange contents between current_frame and new_frame. */
5310 make_current (desired_matrix
, current_matrix
, vpos
);
5315 /***********************************************************************
5316 X/Y Position -> Buffer Position
5317 ***********************************************************************/
5319 /* Return the character position of the character at window relative
5320 pixel position (*X, *Y). *X and *Y are adjusted to character
5324 buffer_posn_from_coords (w
, x
, y
)
5329 struct buffer
*old_current_buffer
= current_buffer
;
5330 struct text_pos startp
;
5331 int left_area_width
;
5333 current_buffer
= XBUFFER (w
->buffer
);
5334 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5335 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5336 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5337 start_display (&it
, w
, startp
);
5339 left_area_width
= WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH (w
);
5340 move_it_to (&it
, -1, *x
+ it
.first_visible_x
- left_area_width
, *y
, -1,
5341 MOVE_TO_X
| MOVE_TO_Y
);
5343 *x
= it
.current_x
- it
.first_visible_x
+ left_area_width
;
5345 current_buffer
= old_current_buffer
;
5346 return IT_CHARPOS (it
);
5350 /* Value is the string under window-relative coordinates X/Y in the
5351 mode or top line of window W, or nil if none. MODE_LINE_P non-zero
5352 means look at the mode line. *CHARPOS is set to the position in
5353 the string returned. */
5356 mode_line_string (w
, x
, y
, mode_line_p
, charpos
)
5361 struct glyph_row
*row
;
5362 struct glyph
*glyph
, *end
;
5363 struct frame
*f
= XFRAME (w
->frame
);
5365 Lisp_Object string
= Qnil
;
5368 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5370 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
5372 if (row
->mode_line_p
&& row
->enabled_p
)
5374 /* The mode lines are displayed over scroll bars and bitmap
5375 areas, and X is window-relative. Correct X by the scroll bar
5376 and bitmap area width. */
5377 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
5378 x
+= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
5379 x
+= FRAME_LEFT_FLAGS_AREA_WIDTH (f
);
5381 /* Find the glyph under X. If we find one with a string object,
5382 it's the one we were looking for. */
5383 glyph
= row
->glyphs
[TEXT_AREA
];
5384 end
= glyph
+ row
->used
[TEXT_AREA
];
5385 for (x0
= 0; glyph
< end
; x0
+= glyph
->pixel_width
, ++glyph
)
5386 if (x
>= x0
&& x
< x0
+ glyph
->pixel_width
)
5388 string
= glyph
->object
;
5389 *charpos
= glyph
->charpos
;
5398 /***********************************************************************
5399 Changing Frame Sizes
5400 ***********************************************************************/
5405 window_change_signal (signalnum
) /* If we don't have an argument, */
5406 int signalnum
; /* some compilers complain in signal calls. */
5410 int old_errno
= errno
;
5412 get_frame_size (&width
, &height
);
5414 /* The frame size change obviously applies to a termcap-controlled
5415 frame. Find such a frame in the list, and assume it's the only
5416 one (since the redisplay code always writes to stdout, not a
5417 FILE * specified in the frame structure). Record the new size,
5418 but don't reallocate the data structures now. Let that be done
5419 later outside of the signal handler. */
5422 Lisp_Object tail
, frame
;
5424 FOR_EACH_FRAME (tail
, frame
)
5426 if (FRAME_TERMCAP_P (XFRAME (frame
)))
5428 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5434 signal (SIGWINCH
, window_change_signal
);
5437 #endif /* SIGWINCH */
5440 /* Do any change in frame size that was requested by a signal. SAFE
5441 non-zero means this function is called from a place where it is
5442 safe to change frame sizes while a redisplay is in progress. */
5445 do_pending_window_change (safe
)
5448 /* If window_change_signal should have run before, run it now. */
5449 if (redisplaying_p
&& !safe
)
5452 while (delayed_size_change
)
5454 Lisp_Object tail
, frame
;
5456 delayed_size_change
= 0;
5458 FOR_EACH_FRAME (tail
, frame
)
5460 struct frame
*f
= XFRAME (frame
);
5462 int height
= FRAME_NEW_HEIGHT (f
);
5463 int width
= FRAME_NEW_WIDTH (f
);
5465 if (height
!= 0 || width
!= 0)
5466 change_frame_size (f
, height
, width
, 0, 0, safe
);
5472 /* Change the frame height and/or width. Values may be given as zero to
5473 indicate no change is to take place.
5475 If DELAY is non-zero, then assume we're being called from a signal
5476 handler, and queue the change for later - perhaps the next
5477 redisplay. Since this tries to resize windows, we can't call it
5478 from a signal handler.
5480 SAFE non-zero means this function is called from a place where it's
5481 safe to change frame sizes while a redisplay is in progress. */
5484 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5485 register struct frame
*f
;
5486 int newheight
, newwidth
, pretend
, delay
, safe
;
5488 Lisp_Object tail
, frame
;
5490 if (! FRAME_WINDOW_P (f
))
5492 /* When using termcap, or on MS-DOS, all frames use
5493 the same screen, so a change in size affects all frames. */
5494 FOR_EACH_FRAME (tail
, frame
)
5495 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5496 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5497 pretend
, delay
, safe
);
5500 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
5504 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5505 register struct frame
*f
;
5506 int newheight
, newwidth
, pretend
, delay
, safe
;
5508 int new_frame_window_width
;
5509 int count
= specpdl_ptr
- specpdl
;
5511 /* If we can't deal with the change now, queue it for later. */
5512 if (delay
|| (redisplaying_p
&& !safe
))
5514 FRAME_NEW_HEIGHT (f
) = newheight
;
5515 FRAME_NEW_WIDTH (f
) = newwidth
;
5516 delayed_size_change
= 1;
5520 /* This size-change overrides any pending one for this frame. */
5521 FRAME_NEW_HEIGHT (f
) = 0;
5522 FRAME_NEW_WIDTH (f
) = 0;
5524 /* If an argument is zero, set it to the current value. */
5526 newheight
= FRAME_HEIGHT (f
);
5528 newwidth
= FRAME_WIDTH (f
);
5530 /* Compute width of windows in F.
5531 This is the width of the frame without vertical scroll bars. */
5532 new_frame_window_width
= FRAME_WINDOW_WIDTH_ARG (f
, newwidth
);
5534 /* Round up to the smallest acceptable size. */
5535 check_frame_size (f
, &newheight
, &newwidth
);
5537 /* If we're not changing the frame size, quit now. */
5538 if (newheight
== FRAME_HEIGHT (f
)
5539 && new_frame_window_width
== FRAME_WINDOW_WIDTH (f
))
5545 /* We only can set screen dimensions to certain values supported
5546 by our video hardware. Try to find the smallest size greater
5547 or equal to the requested dimensions. */
5548 dos_set_window_size (&newheight
, &newwidth
);
5551 if (newheight
!= FRAME_HEIGHT (f
))
5553 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
5555 /* Frame has both root and mini-buffer. */
5556 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f
))->top
,
5557 FRAME_TOP_MARGIN (f
));
5558 set_window_height (FRAME_ROOT_WINDOW (f
),
5561 - FRAME_TOP_MARGIN (f
)),
5563 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
,
5565 set_window_height (FRAME_MINIBUF_WINDOW (f
), 1, 0);
5568 /* Frame has just one top-level window. */
5569 set_window_height (FRAME_ROOT_WINDOW (f
),
5570 newheight
- FRAME_TOP_MARGIN (f
), 0);
5572 if (FRAME_TERMCAP_P (f
) && !pretend
)
5573 FrameRows
= newheight
;
5576 if (new_frame_window_width
!= FRAME_WINDOW_WIDTH (f
))
5578 set_window_width (FRAME_ROOT_WINDOW (f
), new_frame_window_width
, 0);
5579 if (FRAME_HAS_MINIBUF_P (f
))
5580 set_window_width (FRAME_MINIBUF_WINDOW (f
), new_frame_window_width
, 0);
5582 if (FRAME_TERMCAP_P (f
) && !pretend
)
5583 FrameCols
= newwidth
;
5585 if (WINDOWP (f
->tool_bar_window
))
5586 XSETFASTINT (XWINDOW (f
->tool_bar_window
)->width
, newwidth
);
5589 FRAME_HEIGHT (f
) = newheight
;
5590 SET_FRAME_WIDTH (f
, newwidth
);
5593 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5594 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
5596 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
5598 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
5599 w
->cursor
.hpos
= w
->cursor
.x
= 0;
5600 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
5601 w
->cursor
.vpos
= w
->cursor
.y
= 0;
5605 SET_FRAME_GARBAGED (f
);
5606 calculate_costs (f
);
5610 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
5612 /* This isn't quite a no-op: it runs window-configuration-change-hook. */
5613 Fset_window_buffer (FRAME_SELECTED_WINDOW (f
),
5614 XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
);
5616 unbind_to (count
, Qnil
);
5621 /***********************************************************************
5622 Terminal Related Lisp Functions
5623 ***********************************************************************/
5625 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
5626 1, 1, "FOpen termscript file: ",
5627 "Start writing all terminal output to FILE as well as the terminal.\n\
5628 FILE = nil means just close any termscript file currently open.")
5632 if (termscript
!= 0) fclose (termscript
);
5637 file
= Fexpand_file_name (file
, Qnil
);
5638 termscript
= fopen (XSTRING (file
)->data
, "w");
5639 if (termscript
== 0)
5640 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
5646 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
5647 Ssend_string_to_terminal
, 1, 1, 0,
5648 "Send STRING to the terminal without alteration.\n\
5649 Control characters in STRING will have terminal-dependent effects.")
5653 /* ??? Perhaps we should do something special for multibyte strings here. */
5654 CHECK_STRING (string
, 0);
5655 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)), stdout
);
5659 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)),
5661 fflush (termscript
);
5667 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
5668 "Beep, or flash the screen.\n\
5669 Also, unless an argument is given,\n\
5670 terminate any keyboard macro currently executing.")
5693 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
5694 error ("Keyboard macro terminated by a command ringing the bell");
5702 /***********************************************************************
5704 ***********************************************************************/
5706 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
5707 "Pause, without updating display, for SECONDS seconds.\n\
5708 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5709 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5710 additional wait period, in milliseconds; this may be useful if your\n\
5711 Emacs was built without floating point support.\n\
5712 \(Not all operating systems support waiting for a fraction of a second.)")
5713 (seconds
, milliseconds
)
5714 Lisp_Object seconds
, milliseconds
;
5718 if (NILP (milliseconds
))
5719 XSETINT (milliseconds
, 0);
5721 CHECK_NUMBER (milliseconds
, 1);
5722 usec
= XINT (milliseconds
) * 1000;
5725 double duration
= extract_float (seconds
);
5726 sec
= (int) duration
;
5727 usec
+= (duration
- sec
) * 1000000;
5730 #ifndef EMACS_HAS_USECS
5731 if (sec
== 0 && usec
!= 0)
5732 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
5735 /* Assure that 0 <= usec < 1000000. */
5738 /* We can't rely on the rounding being correct if user is negative. */
5739 if (-1000000 < usec
)
5740 sec
--, usec
+= 1000000;
5742 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
5745 sec
+= usec
/ 1000000, usec
%= 1000000;
5747 if (sec
< 0 || (sec
== 0 && usec
== 0))
5753 XSETFASTINT (zero
, 0);
5754 wait_reading_process_input (sec
, usec
, zero
, 0);
5757 /* We should always have wait_reading_process_input; we have a dummy
5758 implementation for systems which don't support subprocesses. */
5760 /* No wait_reading_process_input */
5767 /* The reason this is done this way
5768 (rather than defined (H_S) && defined (H_T))
5769 is because the VMS preprocessor doesn't grok `defined' */
5771 EMACS_GET_TIME (end_time
);
5772 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
5773 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
5777 EMACS_GET_TIME (timeout
);
5778 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
5779 if (EMACS_TIME_NEG_P (timeout
)
5780 || !select (1, 0, 0, 0, &timeout
))
5783 #else /* not HAVE_SELECT */
5785 #endif /* HAVE_SELECT */
5786 #endif /* not VMS */
5789 #endif /* no subprocesses */
5795 /* This is just like wait_reading_process_input, except that
5796 it does the redisplay.
5798 It's also much like Fsit_for, except that it can be used for
5799 waiting for input as well. */
5802 sit_for (sec
, usec
, reading
, display
, initial_display
)
5803 int sec
, usec
, reading
, display
, initial_display
;
5805 Lisp_Object read_kbd
;
5807 swallow_events (display
);
5809 if (detect_input_pending_run_timers (display
))
5812 if (initial_display
)
5813 redisplay_preserve_echo_area ();
5815 if (sec
== 0 && usec
== 0)
5822 XSETINT (read_kbd
, reading
? -1 : 1);
5823 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
5825 return detect_input_pending () ? Qnil
: Qt
;
5829 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
5830 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
5831 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5832 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5833 additional wait period, in milliseconds; this may be useful if your\n\
5834 Emacs was built without floating point support.\n\
5835 \(Not all operating systems support waiting for a fraction of a second.)\n\
5836 Optional third arg NODISP non-nil means don't redisplay, just wait for input.\n\
5837 Redisplay is preempted as always if input arrives, and does not happen\n\
5838 if input is available before it starts.\n\
5839 Value is t if waited the full time with no input arriving.")
5840 (seconds
, milliseconds
, nodisp
)
5841 Lisp_Object seconds
, milliseconds
, nodisp
;
5845 if (NILP (milliseconds
))
5846 XSETINT (milliseconds
, 0);
5848 CHECK_NUMBER (milliseconds
, 1);
5849 usec
= XINT (milliseconds
) * 1000;
5852 double duration
= extract_float (seconds
);
5853 sec
= (int) duration
;
5854 usec
+= (duration
- sec
) * 1000000;
5857 #ifndef EMACS_HAS_USECS
5858 if (usec
!= 0 && sec
== 0)
5859 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
5862 return sit_for (sec
, usec
, 0, NILP (nodisp
), NILP (nodisp
));
5867 /***********************************************************************
5868 Other Lisp Functions
5869 ***********************************************************************/
5871 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
5872 session's frames, frame names, buffers, buffer-read-only flags, and
5873 buffer-modified-flags, and a trailing sentinel (so we don't need to
5874 add length checks). */
5876 static Lisp_Object frame_and_buffer_state
;
5879 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
5880 Sframe_or_buffer_changed_p
, 0, 0, 0,
5881 "Return non-nil if the frame and buffer state appears to have changed.\n\
5882 The state variable is an internal vector containing all frames and buffers,\n\
5883 aside from buffers whose names start with space,\n\
5884 along with the buffers' read-only and modified flags, which allows a fast\n\
5885 check to see whether the menu bars might need to be recomputed.\n\
5886 If this function returns non-nil, it updates the internal vector to reflect\n\
5887 the current state.\n")
5890 Lisp_Object tail
, frame
, buf
;
5894 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5895 FOR_EACH_FRAME (tail
, frame
)
5897 if (!EQ (*vecp
++, frame
))
5899 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
5902 /* Check that the buffer info matches.
5903 No need to test for the end of the vector
5904 because the last element of the vector is lambda
5905 and that will always cause a mismatch. */
5906 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5908 buf
= XCDR (XCAR (tail
));
5909 /* Ignore buffers that aren't included in buffer lists. */
5910 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5912 if (!EQ (*vecp
++, buf
))
5914 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
5916 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
5919 /* Detect deletion of a buffer at the end of the list. */
5920 if (EQ (*vecp
, Qlambda
))
5923 /* Start with 1 so there is room for at least one lambda at the end. */
5925 FOR_EACH_FRAME (tail
, frame
)
5927 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5929 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
5930 if (n
> XVECTOR (frame_and_buffer_state
)->size
5931 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
5932 /* Add 20 extra so we grow it less often. */
5933 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
5934 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5935 FOR_EACH_FRAME (tail
, frame
)
5938 *vecp
++ = XFRAME (frame
)->name
;
5940 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5942 buf
= XCDR (XCAR (tail
));
5943 /* Ignore buffers that aren't included in buffer lists. */
5944 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5947 *vecp
++ = XBUFFER (buf
)->read_only
;
5948 *vecp
++ = Fbuffer_modified_p (buf
);
5950 /* Fill up the vector with lambdas (always at least one). */
5952 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5953 < XVECTOR (frame_and_buffer_state
)->size
)
5955 /* Make sure we didn't overflow the vector. */
5956 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5957 > XVECTOR (frame_and_buffer_state
)->size
)
5964 /***********************************************************************
5966 ***********************************************************************/
5968 char *terminal_type
;
5970 /* Initialization done when Emacs fork is started, before doing stty.
5971 Determine terminal type and set terminal_driver. Then invoke its
5972 decoding routine to set up variables in the terminal package. */
5977 #ifdef HAVE_X_WINDOWS
5978 extern int display_arg
;
5981 /* Construct the space glyph. */
5982 space_glyph
.type
= CHAR_GLYPH
;
5983 SET_CHAR_GLYPH_FROM_GLYPH (space_glyph
, ' ');
5984 space_glyph
.charpos
= -1;
5988 cursor_in_echo_area
= 0;
5989 terminal_type
= (char *) 0;
5991 /* Now is the time to initialize this; it's used by init_sys_modes
5993 Vwindow_system
= Qnil
;
5995 /* If the user wants to use a window system, we shouldn't bother
5996 initializing the terminal. This is especially important when the
5997 terminal is so dumb that emacs gives up before and doesn't bother
5998 using the window system.
6000 If the DISPLAY environment variable is set and nonempty,
6001 try to use X, and die with an error message if that doesn't work. */
6003 #ifdef HAVE_X_WINDOWS
6008 display
= getenv ("DECW$DISPLAY");
6010 display
= getenv ("DISPLAY");
6013 display_arg
= (display
!= 0 && *display
!= 0);
6016 if (!inhibit_window_system
&& display_arg
6022 Vwindow_system
= intern ("x");
6024 Vwindow_system_version
= make_number (11);
6026 Vwindow_system_version
= make_number (10);
6028 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
6029 /* In some versions of ncurses,
6030 tputs crashes if we have not called tgetent.
6032 { char b
[2044]; tgetent (b
, "xterm");}
6034 adjust_frame_glyphs_initially ();
6037 #endif /* HAVE_X_WINDOWS */
6040 if (!inhibit_window_system
)
6042 Vwindow_system
= intern ("w32");
6043 Vwindow_system_version
= make_number (1);
6044 adjust_frame_glyphs_initially ();
6047 #endif /* HAVE_NTGUI */
6049 /* If no window system has been specified, try to use the terminal. */
6052 fatal ("standard input is not a tty");
6056 /* Look at the TERM variable */
6057 terminal_type
= (char *) getenv ("TERM");
6061 fprintf (stderr
, "Please specify your terminal type.\n\
6062 For types defined in VMS, use set term /device=TYPE.\n\
6063 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
6064 \(The quotation marks are necessary since terminal types are lower case.)\n");
6066 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
6072 /* VMS DCL tends to up-case things, so down-case term type.
6073 Hardly any uppercase letters in terminal types; should be none. */
6075 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
6078 strcpy (new, terminal_type
);
6080 for (p
= new; *p
; p
++)
6084 terminal_type
= new;
6088 term_init (terminal_type
);
6091 struct frame
*sf
= SELECTED_FRAME ();
6092 int width
= FRAME_WINDOW_WIDTH (sf
);
6093 int height
= FRAME_HEIGHT (sf
);
6095 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (struct glyph
);
6097 /* If these sizes are so big they cause overflow, just ignore the
6098 change. It's not clear what better we could do. */
6099 if (total_glyphs
/ sizeof (struct glyph
) / height
!= width
+ 2)
6100 fatal ("screen size %dx%d too big", width
, height
);
6103 adjust_frame_glyphs_initially ();
6104 calculate_costs (XFRAME (selected_frame
));
6109 #endif /* CANNOT_DUMP */
6110 signal (SIGWINCH
, window_change_signal
);
6111 #endif /* SIGWINCH */
6113 /* Set up faces of the initial terminal frame of a dumped Emacs. */
6117 /* The MSDOS terminal turns on its ``window system'' relatively
6118 late into the startup, so we cannot do the frame faces'
6119 initialization just yet. It will be done later by pc-win.el
6120 and internal_terminal_init. */
6121 && (strcmp (terminal_type
, "internal") != 0 || inhibit_window_system
)
6123 && NILP (Vwindow_system
))
6125 /* For the initial frame, we don't have any way of knowing what
6126 are the foreground and background colors of the terminal. */
6127 struct frame
*sf
= SELECTED_FRAME();
6129 FRAME_FOREGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_FG_COLOR
;
6130 FRAME_BACKGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_BG_COLOR
;
6131 call0 (intern ("tty-set-up-initial-frame-faces"));
6137 /***********************************************************************
6139 ***********************************************************************/
6141 DEFUN ("internal-show-cursor", Finternal_show_cursor
,
6142 Sinternal_show_cursor
, 2, 2, 0,
6143 "Set the cursor-visibility flag of WINDOW to SHOW.\n\
6144 WINDOW nil means use the selected window. SHOW non-nil means\n\
6145 show a cursor in WINDOW in the next redisplay. SHOW nil means\n\
6146 don't show a cursor.")
6148 Lisp_Object window
, show
;
6150 /* Don't change cursor state while redisplaying. This could confuse
6152 if (!redisplaying_p
)
6155 window
= selected_window
;
6157 CHECK_WINDOW (window
, 2);
6159 XWINDOW (window
)->cursor_off_p
= NILP (show
);
6166 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p
,
6167 Sinternal_show_cursor_p
, 0, 1, 0,
6168 "Value is non-nil if next redisplay will display a cursor in WINDOW.\n\
6169 WINDOW nil or omitted means report on the selected window.")
6176 window
= selected_window
;
6178 CHECK_WINDOW (window
, 2);
6180 w
= XWINDOW (window
);
6181 return w
->cursor_off_p
? Qnil
: Qt
;
6185 /***********************************************************************
6187 ***********************************************************************/
6192 defsubr (&Sredraw_frame
);
6193 defsubr (&Sredraw_display
);
6194 defsubr (&Sframe_or_buffer_changed_p
);
6195 defsubr (&Sopen_termscript
);
6197 defsubr (&Ssit_for
);
6198 defsubr (&Ssleep_for
);
6199 defsubr (&Ssend_string_to_terminal
);
6200 defsubr (&Sinternal_show_cursor
);
6201 defsubr (&Sinternal_show_cursor_p
);
6203 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
6204 staticpro (&frame_and_buffer_state
);
6206 Qdisplay_table
= intern ("display-table");
6207 staticpro (&Qdisplay_table
);
6209 DEFVAR_INT ("baud-rate", &baud_rate
,
6210 "*The output baud rate of the terminal.\n\
6211 On most systems, changing this value will affect the amount of padding\n\
6212 and the other strategic decisions made during redisplay.");
6214 DEFVAR_BOOL ("inverse-video", &inverse_video
,
6215 "*Non-nil means invert the entire frame display.\n\
6216 This means everything is in inverse video which otherwise would not be.");
6218 DEFVAR_BOOL ("visible-bell", &visible_bell
,
6219 "*Non-nil means try to flash the frame to represent a bell.");
6221 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
6222 "*Non-nil means no need to redraw entire frame after suspending.\n\
6223 A non-nil value is useful if the terminal can automatically preserve\n\
6224 Emacs's frame display when you reenter Emacs.\n\
6225 It is up to you to set this variable if your terminal can do that.");
6227 DEFVAR_LISP ("window-system", &Vwindow_system
,
6228 "A symbol naming the window-system under which Emacs is running\n\
6229 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
6231 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
6232 "The version number of the window system in use.\n\
6233 For X windows, this is 10 or 11.");
6235 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
6236 "Non-nil means put cursor in minibuffer, at end of any message there.");
6238 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
6239 "Table defining how to output a glyph code to the frame.\n\
6240 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
6241 Each element can be:\n\
6242 integer: a glyph code which this glyph is an alias for.\n\
6243 string: output this glyph using that string (not impl. in X windows).\n\
6244 nil: this glyph mod 256 is char code to output,\n\
6245 and this glyph / 256 is face code for X windows (see `face-id').");
6246 Vglyph_table
= Qnil
;
6248 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
6249 "Display table to use for buffers that specify none.\n\
6250 See `buffer-display-table' for more information.");
6251 Vstandard_display_table
= Qnil
;
6253 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause
,
6254 "*Non-nil means update isn't paused when input is detected.");
6255 redisplay_dont_pause
= 0;
6257 /* Initialize `window-system', unless init_display already decided it. */
6262 Vwindow_system
= Qnil
;
6263 Vwindow_system_version
= Qnil
;