1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 97, 98, 1999, 2000
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"
46 #include "intervals.h"
47 #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 */
65 #endif /* macintosh */
67 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
72 /* To get the prototype for `sleep'. */
78 #define max(a, b) ((a) > (b) ? (a) : (b))
79 #define min(a, b) ((a) < (b) ? (a) : (b))
81 /* Get number of chars of output now in the buffer of a stdio stream.
82 This ought to be built in in stdio, but it isn't. Some s- files
83 override this because their stdio internals differ. */
85 #ifdef __GNU_LIBRARY__
87 /* The s- file might have overridden the definition with one that
88 works for the system's C library. But we are using the GNU C
89 library, so this is the right definition for every system. */
91 #ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT
92 #define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT
94 #undef PENDING_OUTPUT_COUNT
95 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
97 #else /* not __GNU_LIBRARY__ */
98 #if !defined (PENDING_OUTPUT_COUNT) && HAVE_STDIO_EXT_H && HAVE___FPENDING
99 #include <stdio_ext.h>
100 #define PENDING_OUTPUT_COUNT(FILE) __fpending (FILE)
102 #ifndef PENDING_OUTPUT_COUNT
103 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
105 #endif /* not __GNU_LIBRARY__ */
107 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
108 #include <term.h> /* for tgetent */
111 /* Structure to pass dimensions around. Used for character bounding
112 boxes, glyph matrix dimensions and alike. */
121 /* Function prototypes. */
123 static void redraw_overlapping_rows
P_ ((struct window
*, int));
124 static void redraw_overlapped_rows
P_ ((struct window
*, int));
125 static int count_blanks
P_ ((struct glyph
*, int));
126 static int count_match
P_ ((struct glyph
*, struct glyph
*,
127 struct glyph
*, struct glyph
*));
128 static unsigned line_draw_cost
P_ ((struct glyph_matrix
*, int));
129 static void update_frame_line
P_ ((struct frame
*, int));
130 static struct dim allocate_matrices_for_frame_redisplay
131 P_ ((Lisp_Object
, int, int, struct dim
, int, int *));
132 static void allocate_matrices_for_window_redisplay
P_ ((struct window
*,
134 static int realloc_glyph_pool
P_ ((struct glyph_pool
*, struct dim
));
135 static void adjust_frame_glyphs
P_ ((struct frame
*));
136 struct glyph_matrix
*new_glyph_matrix
P_ ((struct glyph_pool
*));
137 static void free_glyph_matrix
P_ ((struct glyph_matrix
*));
138 static void adjust_glyph_matrix
P_ ((struct window
*, struct glyph_matrix
*,
139 int, int, struct dim
));
140 static void change_frame_size_1
P_ ((struct frame
*, int, int, int, int, int));
141 static void swap_glyph_pointers
P_ ((struct glyph_row
*, struct glyph_row
*));
143 static int glyph_row_slice_p
P_ ((struct glyph_row
*, struct glyph_row
*));
145 static void fill_up_frame_row_with_spaces
P_ ((struct glyph_row
*, int));
146 static void build_frame_matrix_from_window_tree
P_ ((struct glyph_matrix
*,
148 static void build_frame_matrix_from_leaf_window
P_ ((struct glyph_matrix
*,
150 static struct glyph_pool
*new_glyph_pool
P_ ((void));
151 static void free_glyph_pool
P_ ((struct glyph_pool
*));
152 static void adjust_frame_glyphs_initially
P_ ((void));
153 static void adjust_frame_message_buffer
P_ ((struct frame
*));
154 static void adjust_decode_mode_spec_buffer
P_ ((struct frame
*));
155 static void fill_up_glyph_row_with_spaces
P_ ((struct glyph_row
*));
156 static void build_frame_matrix
P_ ((struct frame
*));
157 void clear_current_matrices
P_ ((struct frame
*));
158 void scroll_glyph_matrix_range
P_ ((struct glyph_matrix
*, int, int,
160 static void clear_window_matrices
P_ ((struct window
*, int));
161 static void fill_up_glyph_row_area_with_spaces
P_ ((struct glyph_row
*, int));
162 static int scrolling_window
P_ ((struct window
*, int));
163 static int update_window_line
P_ ((struct window
*, int, int *));
164 static void update_marginal_area
P_ ((struct window
*, int, int));
165 static int update_text_area
P_ ((struct window
*, int));
166 static void make_current
P_ ((struct glyph_matrix
*, struct glyph_matrix
*,
168 static void mirror_make_current
P_ ((struct window
*, int));
169 void check_window_matrix_pointers
P_ ((struct window
*));
171 static void check_matrix_pointers
P_ ((struct glyph_matrix
*,
172 struct glyph_matrix
*));
174 static void mirror_line_dance
P_ ((struct window
*, int, int, int *, char *));
175 static int update_window_tree
P_ ((struct window
*, int));
176 static int update_window
P_ ((struct window
*, int));
177 static int update_frame_1
P_ ((struct frame
*, int, int));
178 static void set_window_cursor_after_update
P_ ((struct window
*));
179 static int row_equal_p
P_ ((struct window
*, struct glyph_row
*,
180 struct glyph_row
*, int));
181 static void adjust_frame_glyphs_for_window_redisplay
P_ ((struct frame
*));
182 static void adjust_frame_glyphs_for_frame_redisplay
P_ ((struct frame
*));
183 static void reverse_rows
P_ ((struct glyph_matrix
*, int, int));
184 static int margin_glyphs_to_reserve
P_ ((struct window
*, int, Lisp_Object
));
185 static void sync_window_with_frame_matrix_rows
P_ ((struct window
*));
186 struct window
*frame_row_to_window
P_ ((struct window
*, int));
190 /* Non-zero means don't pause redisplay for pending input. (This is
191 for debugging and for a future implementation of EDT-like
194 int redisplay_dont_pause
;
196 /* Nonzero upon entry to redisplay means do not assume anything about
197 current contents of actual terminal frame; clear and redraw it. */
201 /* Nonzero means last display completed. Zero means it was preempted. */
203 int display_completed
;
205 /* Lisp variable visible-bell; enables use of screen-flash instead of
210 /* Invert the color of the whole frame, at a low level. */
214 /* Line speed of the terminal. */
218 /* Either nil or a symbol naming the window system under which Emacs
221 Lisp_Object Vwindow_system
;
223 /* Version number of X windows: 10, 11 or nil. */
225 Lisp_Object Vwindow_system_version
;
227 /* Vector of glyph definitions. Indexed by glyph number, the contents
228 are a string which is how to output the glyph.
230 If Vglyph_table is nil, a glyph is output by using its low 8 bits
233 This is an obsolete feature that is no longer used. The variable
234 is retained for compatibility. */
236 Lisp_Object Vglyph_table
;
238 /* Display table to use for vectors that don't specify their own. */
240 Lisp_Object Vstandard_display_table
;
242 /* Nonzero means reading single-character input with prompt so put
243 cursor on mini-buffer after the prompt. positive means at end of
244 text in echo area; negative means at beginning of line. */
246 int cursor_in_echo_area
;
248 Lisp_Object Qdisplay_table
, Qredisplay_dont_pause
;
251 /* The currently selected frame. In a single-frame version, this
252 variable always equals the_only_frame. */
254 Lisp_Object selected_frame
;
256 /* A frame which is not just a mini-buffer, or 0 if there are no such
257 frames. This is usually the most recent such frame that was
258 selected. In a single-frame version, this variable always holds
259 the address of the_only_frame. */
261 struct frame
*last_nonminibuf_frame
;
263 /* Stdio stream being used for copy of all output. */
267 /* Structure for info on cursor positioning. */
271 /* 1 means SIGWINCH happened when not safe. */
273 int delayed_size_change
;
275 /* 1 means glyph initialization has been completed at startup. */
277 static int glyphs_initialized_initially_p
;
279 /* Updated window if != 0. Set by update_window. */
281 struct window
*updated_window
;
283 /* Glyph row updated in update_window_line, and area that is updated. */
285 struct glyph_row
*updated_row
;
288 /* A glyph for a space. */
290 struct glyph space_glyph
;
292 /* Non-zero means update has been performed directly, so that there's
293 no need for redisplay_internal to do much work. Set by
294 direct_output_for_insert. */
296 int redisplay_performed_directly_p
;
298 /* Counts of allocated structures. These counts serve to diagnose
299 memory leaks and double frees. */
301 int glyph_matrix_count
;
302 int glyph_pool_count
;
304 /* If non-null, the frame whose frame matrices are manipulated. If
305 null, window matrices are worked on. */
307 static struct frame
*frame_matrix_frame
;
309 /* Current interface for window-based redisplay. Set from init_xterm.
310 A null value means we are not using window-based redisplay. */
312 struct redisplay_interface
*rif
;
314 /* Non-zero means that fonts have been loaded since the last glyph
315 matrix adjustments. Redisplay must stop, and glyph matrices must
316 be adjusted when this flag becomes non-zero during display. The
317 reason fonts can be loaded so late is that fonts of fontsets are
322 /* Convert vpos and hpos from frame to window and vice versa.
323 This may only be used for terminal frames. */
327 static int window_to_frame_vpos
P_ ((struct window
*, int));
328 static int window_to_frame_hpos
P_ ((struct window
*, int));
329 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
330 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
332 #else /* GLYPH_DEBUG == 0 */
334 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + XFASTINT ((W)->top))
335 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + XFASTINT ((W)->left))
337 #endif /* GLYPH_DEBUG == 0 */
340 /* Like bcopy except never gets confused by overlap. Let this be the
341 first function defined in this file, or change emacs.c where the
342 address of this function is used. */
345 safe_bcopy (from
, to
, size
)
349 if (size
<= 0 || from
== to
)
352 /* If the source and destination don't overlap, then bcopy can
353 handle it. If they do overlap, but the destination is lower in
354 memory than the source, we'll assume bcopy can handle that. */
355 if (to
< from
|| from
+ size
<= to
)
356 bcopy (from
, to
, size
);
358 /* Otherwise, we'll copy from the end. */
361 register char *endf
= from
+ size
;
362 register char *endt
= to
+ size
;
364 /* If TO - FROM is large, then we should break the copy into
365 nonoverlapping chunks of TO - FROM bytes each. However, if
366 TO - FROM is small, then the bcopy function call overhead
367 makes this not worth it. The crossover point could be about
368 anywhere. Since I don't think the obvious copy loop is too
369 bad, I'm trying to err in its favor. */
374 while (endf
!= from
);
386 bcopy (endf
, endt
, to
- from
);
389 /* If SIZE wasn't a multiple of TO - FROM, there will be a
390 little left over. The amount left over is (endt + (to -
391 from)) - to, which is endt - from. */
392 bcopy (from
, to
, endt
- from
);
399 /***********************************************************************
401 ***********************************************************************/
403 /* Allocate and return a glyph_matrix structure. POOL is the glyph
404 pool from which memory for the matrix should be allocated, or null
405 for window-based redisplay where no glyph pools are used. The
406 member `pool' of the glyph matrix structure returned is set to
407 POOL, the structure is otherwise zeroed. */
409 struct glyph_matrix
*
410 new_glyph_matrix (pool
)
411 struct glyph_pool
*pool
;
413 struct glyph_matrix
*result
;
415 /* Allocate and clear. */
416 result
= (struct glyph_matrix
*) xmalloc (sizeof *result
);
417 bzero (result
, sizeof *result
);
419 /* Increment number of allocated matrices. This count is used
420 to detect memory leaks. */
421 ++glyph_matrix_count
;
423 /* Set pool and return. */
429 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
431 The global counter glyph_matrix_count is decremented when a matrix
432 is freed. If the count gets negative, more structures were freed
433 than allocated, i.e. one matrix was freed more than once or a bogus
434 pointer was passed to this function.
436 If MATRIX->pool is null, this means that the matrix manages its own
437 glyph memory---this is done for matrices on X frames. Freeing the
438 matrix also frees the glyph memory in this case. */
441 free_glyph_matrix (matrix
)
442 struct glyph_matrix
*matrix
;
448 /* Detect the case that more matrices are freed than were
450 if (--glyph_matrix_count
< 0)
453 /* Free glyph memory if MATRIX owns it. */
454 if (matrix
->pool
== NULL
)
455 for (i
= 0; i
< matrix
->rows_allocated
; ++i
)
456 xfree (matrix
->rows
[i
].glyphs
[LEFT_MARGIN_AREA
]);
458 /* Free row structures and the matrix itself. */
459 xfree (matrix
->rows
);
465 /* Return the number of glyphs to reserve for a marginal area of
466 window W. TOTAL_GLYPHS is the number of glyphs in a complete
467 display line of window W. MARGIN gives the width of the marginal
468 area in canonical character units. MARGIN should be an integer
472 margin_glyphs_to_reserve (w
, total_glyphs
, margin
)
479 if (NUMBERP (margin
))
481 int width
= XFASTINT (w
->width
);
482 double d
= max (0, XFLOATINT (margin
));
483 d
= min (width
/ 2 - 1, d
);
484 n
= (int) ((double) total_glyphs
/ width
* d
);
493 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
496 W is null if the function is called for a frame glyph matrix.
497 Otherwise it is the window MATRIX is a member of. X and Y are the
498 indices of the first column and row of MATRIX within the frame
499 matrix, if such a matrix exists. They are zero for purely
500 window-based redisplay. DIM is the needed size of the matrix.
502 In window-based redisplay, where no frame matrices exist, glyph
503 matrices manage their own glyph storage. Otherwise, they allocate
504 storage from a common frame glyph pool which can be found in
507 The reason for this memory management strategy is to avoid complete
508 frame redraws if possible. When we allocate from a common pool, a
509 change of the location or size of a sub-matrix within the pool
510 requires a complete redisplay of the frame because we cannot easily
511 make sure that the current matrices of all windows still agree with
512 what is displayed on the screen. While this is usually fast, it
513 leads to screen flickering. */
516 adjust_glyph_matrix (w
, matrix
, x
, y
, dim
)
518 struct glyph_matrix
*matrix
;
524 int marginal_areas_changed_p
= 0;
525 int header_line_changed_p
= 0;
526 int header_line_p
= 0;
527 int left
= -1, right
= -1;
528 int window_x
, window_y
, window_width
= -1, window_height
;
530 /* See if W had a top line that has disappeared now, or vice versa. */
533 header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
534 header_line_changed_p
= header_line_p
!= matrix
->header_line_p
;
536 matrix
->header_line_p
= header_line_p
;
538 /* Do nothing if MATRIX' size, position, vscroll, and marginal areas
539 haven't changed. This optimization is important because preserving
540 the matrix means preventing redisplay. */
541 if (matrix
->pool
== NULL
)
543 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
544 left
= margin_glyphs_to_reserve (w
, dim
.width
, w
->left_margin_width
);
545 right
= margin_glyphs_to_reserve (w
, dim
.width
, w
->right_margin_width
);
546 xassert (left
>= 0 && right
>= 0);
547 marginal_areas_changed_p
= (left
!= matrix
->left_margin_glyphs
548 || right
!= matrix
->right_margin_glyphs
);
550 if (!marginal_areas_changed_p
552 && !header_line_changed_p
553 && matrix
->window_top_y
== XFASTINT (w
->top
)
554 && matrix
->window_height
== window_height
555 && matrix
->window_vscroll
== w
->vscroll
556 && matrix
->window_width
== window_width
)
560 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
561 if (matrix
->rows_allocated
< dim
.height
)
563 int size
= dim
.height
* sizeof (struct glyph_row
);
564 new_rows
= dim
.height
- matrix
->rows_allocated
;
565 matrix
->rows
= (struct glyph_row
*) xrealloc (matrix
->rows
, size
);
566 bzero (matrix
->rows
+ matrix
->rows_allocated
,
567 new_rows
* sizeof *matrix
->rows
);
568 matrix
->rows_allocated
= dim
.height
;
573 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
574 on a frame not using window-based redisplay. Set up pointers for
575 each row into the glyph pool. */
578 xassert (matrix
->pool
->glyphs
);
582 left
= margin_glyphs_to_reserve (w
, dim
.width
,
583 w
->left_margin_width
);
584 right
= margin_glyphs_to_reserve (w
, dim
.width
,
585 w
->right_margin_width
);
590 for (i
= 0; i
< dim
.height
; ++i
)
592 struct glyph_row
*row
= &matrix
->rows
[i
];
594 row
->glyphs
[LEFT_MARGIN_AREA
]
595 = (matrix
->pool
->glyphs
596 + (y
+ i
) * matrix
->pool
->ncolumns
600 || row
== matrix
->rows
+ dim
.height
- 1
601 || (row
== matrix
->rows
&& matrix
->header_line_p
))
603 row
->glyphs
[TEXT_AREA
]
604 = row
->glyphs
[LEFT_MARGIN_AREA
];
605 row
->glyphs
[RIGHT_MARGIN_AREA
]
606 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
607 row
->glyphs
[LAST_AREA
]
608 = row
->glyphs
[RIGHT_MARGIN_AREA
];
612 row
->glyphs
[TEXT_AREA
]
613 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
614 row
->glyphs
[RIGHT_MARGIN_AREA
]
615 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
616 row
->glyphs
[LAST_AREA
]
617 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
621 matrix
->left_margin_glyphs
= left
;
622 matrix
->right_margin_glyphs
= right
;
626 /* If MATRIX->pool is null, MATRIX is responsible for managing
627 its own memory. Allocate glyph memory from the heap. */
628 if (dim
.width
> matrix
->matrix_w
630 || header_line_changed_p
631 || marginal_areas_changed_p
)
633 struct glyph_row
*row
= matrix
->rows
;
634 struct glyph_row
*end
= row
+ matrix
->rows_allocated
;
638 row
->glyphs
[LEFT_MARGIN_AREA
]
639 = (struct glyph
*) xrealloc (row
->glyphs
[LEFT_MARGIN_AREA
],
641 * sizeof (struct glyph
)));
643 /* The mode line never has marginal areas. */
644 if (row
== matrix
->rows
+ dim
.height
- 1
645 || (row
== matrix
->rows
&& matrix
->header_line_p
))
647 row
->glyphs
[TEXT_AREA
]
648 = row
->glyphs
[LEFT_MARGIN_AREA
];
649 row
->glyphs
[RIGHT_MARGIN_AREA
]
650 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
651 row
->glyphs
[LAST_AREA
]
652 = row
->glyphs
[RIGHT_MARGIN_AREA
];
656 row
->glyphs
[TEXT_AREA
]
657 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
658 row
->glyphs
[RIGHT_MARGIN_AREA
]
659 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
660 row
->glyphs
[LAST_AREA
]
661 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
667 xassert (left
>= 0 && right
>= 0);
668 matrix
->left_margin_glyphs
= left
;
669 matrix
->right_margin_glyphs
= right
;
672 /* Number of rows to be used by MATRIX. */
673 matrix
->nrows
= dim
.height
;
674 xassert (matrix
->nrows
>= 0);
676 /* Mark rows in a current matrix of a window as not having valid
677 contents. It's important to not do this for desired matrices.
678 When Emacs starts, it may already be building desired matrices
679 when this function runs. */
680 if (w
&& matrix
== w
->current_matrix
)
682 if (window_width
< 0)
683 window_width
= window_box_width (w
, -1);
685 /* Optimize the case that only the height has changed (C-x 2,
686 upper window). Invalidate all rows that are no longer part
688 if (!marginal_areas_changed_p
689 && matrix
->window_top_y
== XFASTINT (w
->top
)
690 && matrix
->window_width
== window_box_width (w
, -1))
693 while (matrix
->rows
[i
].enabled_p
694 && (MATRIX_ROW_BOTTOM_Y (matrix
->rows
+ i
)
695 < matrix
->window_height
))
698 /* Window end is invalid, if inside of the rows that
700 if (INTEGERP (w
->window_end_vpos
)
701 && XFASTINT (w
->window_end_vpos
) >= i
)
702 w
->window_end_valid
= Qnil
;
704 while (i
< matrix
->nrows
)
705 matrix
->rows
[i
++].enabled_p
= 0;
709 for (i
= 0; i
< matrix
->nrows
; ++i
)
710 matrix
->rows
[i
].enabled_p
= 0;
714 /* Remember last values to be able to optimize frame redraws. */
715 matrix
->matrix_x
= x
;
716 matrix
->matrix_y
= y
;
717 matrix
->matrix_w
= dim
.width
;
718 matrix
->matrix_h
= dim
.height
;
720 /* Record the top y location and height of W at the time the matrix
721 was last adjusted. This is used to optimize redisplay above. */
724 matrix
->window_top_y
= XFASTINT (w
->top
);
725 matrix
->window_height
= window_height
;
726 matrix
->window_width
= window_width
;
727 matrix
->window_vscroll
= w
->vscroll
;
732 /* Reverse the contents of rows in MATRIX between START and END. The
733 contents of the row at END - 1 end up at START, END - 2 at START +
734 1 etc. This is part of the implementation of rotate_matrix (see
738 reverse_rows (matrix
, start
, end
)
739 struct glyph_matrix
*matrix
;
744 for (i
= start
, j
= end
- 1; i
< j
; ++i
, --j
)
746 /* Non-ISO HP/UX compiler doesn't like auto struct
748 struct glyph_row temp
;
749 temp
= matrix
->rows
[i
];
750 matrix
->rows
[i
] = matrix
->rows
[j
];
751 matrix
->rows
[j
] = temp
;
756 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
757 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
758 indices. (Note: this does not copy glyphs, only glyph pointers in
759 row structures are moved around).
761 The algorithm used for rotating the vector was, I believe, first
762 described by Kernighan. See the vector R as consisting of two
763 sub-vectors AB, where A has length BY for BY >= 0. The result
764 after rotating is then BA. Reverse both sub-vectors to get ArBr
765 and reverse the result to get (ArBr)r which is BA. Similar for
769 rotate_matrix (matrix
, first
, last
, by
)
770 struct glyph_matrix
*matrix
;
775 /* Up (rotate left, i.e. towards lower indices). */
777 reverse_rows (matrix
, first
, first
+ by
);
778 reverse_rows (matrix
, first
+ by
, last
);
779 reverse_rows (matrix
, first
, last
);
783 /* Down (rotate right, i.e. towards higher indices). */
784 reverse_rows (matrix
, last
- by
, last
);
785 reverse_rows (matrix
, first
, last
- by
);
786 reverse_rows (matrix
, first
, last
);
791 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
792 with indices START <= index < END. Increment positions by DELTA/
796 increment_matrix_positions (matrix
, start
, end
, delta
, delta_bytes
)
797 struct glyph_matrix
*matrix
;
798 int start
, end
, delta
, delta_bytes
;
800 /* Check that START and END are reasonable values. */
801 xassert (start
>= 0 && start
<= matrix
->nrows
);
802 xassert (end
>= 0 && end
<= matrix
->nrows
);
803 xassert (start
<= end
);
805 for (; start
< end
; ++start
)
806 increment_row_positions (matrix
->rows
+ start
, delta
, delta_bytes
);
810 /* Enable a range of rows in glyph matrix MATRIX. START and END are
811 the row indices of the first and last + 1 row to enable. If
812 ENABLED_P is non-zero, enabled_p flags in rows will be set to 1. */
815 enable_glyph_matrix_rows (matrix
, start
, end
, enabled_p
)
816 struct glyph_matrix
*matrix
;
820 xassert (start
<= end
);
821 xassert (start
>= 0 && start
< matrix
->nrows
);
822 xassert (end
>= 0 && end
<= matrix
->nrows
);
824 for (; start
< end
; ++start
)
825 matrix
->rows
[start
].enabled_p
= enabled_p
!= 0;
831 This empties all rows in MATRIX by setting the enabled_p flag for
832 all rows of the matrix to zero. The function prepare_desired_row
833 will eventually really clear a row when it sees one with a zero
836 Resets update hints to defaults value. The only update hint
837 currently present is the flag MATRIX->no_scrolling_p. */
840 clear_glyph_matrix (matrix
)
841 struct glyph_matrix
*matrix
;
845 enable_glyph_matrix_rows (matrix
, 0, matrix
->nrows
, 0);
846 matrix
->no_scrolling_p
= 0;
851 /* Shift part of the glyph matrix MATRIX of window W up or down.
852 Increment y-positions in glyph rows between START and END by DY,
853 and recompute their visible height. */
856 shift_glyph_matrix (w
, matrix
, start
, end
, dy
)
858 struct glyph_matrix
*matrix
;
863 xassert (start
<= end
);
864 xassert (start
>= 0 && start
< matrix
->nrows
);
865 xassert (end
>= 0 && end
<= matrix
->nrows
);
867 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
868 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
870 for (; start
< end
; ++start
)
872 struct glyph_row
*row
= &matrix
->rows
[start
];
877 row
->visible_height
= row
->height
- (min_y
- row
->y
);
878 else if (row
->y
+ row
->height
> max_y
)
879 row
->visible_height
= row
->height
- (row
->y
+ row
->height
- max_y
);
881 row
->visible_height
= row
->height
;
886 /* Mark all rows in current matrices of frame F as invalid. Marking
887 invalid is done by setting enabled_p to zero for all rows in a
891 clear_current_matrices (f
)
892 register struct frame
*f
;
894 /* Clear frame current matrix, if we have one. */
895 if (f
->current_matrix
)
896 clear_glyph_matrix (f
->current_matrix
);
898 /* Clear the matrix of the menu bar window, if such a window exists.
899 The menu bar window is currently used to display menus on X when
900 no toolkit support is compiled in. */
901 if (WINDOWP (f
->menu_bar_window
))
902 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->current_matrix
);
904 /* Clear the matrix of the tool-bar window, if any. */
905 if (WINDOWP (f
->tool_bar_window
))
906 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
908 /* Clear current window matrices. */
909 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
910 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 0);
914 /* Clear out all display lines of F for a coming redisplay. */
917 clear_desired_matrices (f
)
918 register struct frame
*f
;
920 if (f
->desired_matrix
)
921 clear_glyph_matrix (f
->desired_matrix
);
923 if (WINDOWP (f
->menu_bar_window
))
924 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->desired_matrix
);
926 if (WINDOWP (f
->tool_bar_window
))
927 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->desired_matrix
);
929 /* Do it for window matrices. */
930 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
931 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
935 /* Clear matrices in window tree rooted in W. If DESIRED_P is
936 non-zero clear desired matrices, otherwise clear current matrices. */
939 clear_window_matrices (w
, desired_p
)
945 if (!NILP (w
->hchild
))
947 xassert (WINDOWP (w
->hchild
));
948 clear_window_matrices (XWINDOW (w
->hchild
), desired_p
);
950 else if (!NILP (w
->vchild
))
952 xassert (WINDOWP (w
->vchild
));
953 clear_window_matrices (XWINDOW (w
->vchild
), desired_p
);
958 clear_glyph_matrix (w
->desired_matrix
);
961 clear_glyph_matrix (w
->current_matrix
);
962 w
->window_end_valid
= Qnil
;
966 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
972 /***********************************************************************
975 See dispextern.h for an overall explanation of glyph rows.
976 ***********************************************************************/
978 /* Clear glyph row ROW. Do it in a way that makes it robust against
979 changes in the glyph_row structure, i.e. addition or removal of
980 structure members. */
982 static struct glyph_row null_row
;
985 clear_glyph_row (row
)
986 struct glyph_row
*row
;
988 struct glyph
*p
[1 + LAST_AREA
];
991 p
[LEFT_MARGIN_AREA
] = row
->glyphs
[LEFT_MARGIN_AREA
];
992 p
[TEXT_AREA
] = row
->glyphs
[TEXT_AREA
];
993 p
[RIGHT_MARGIN_AREA
] = row
->glyphs
[RIGHT_MARGIN_AREA
];
994 p
[LAST_AREA
] = row
->glyphs
[LAST_AREA
];
999 /* Restore pointers. */
1000 row
->glyphs
[LEFT_MARGIN_AREA
] = p
[LEFT_MARGIN_AREA
];
1001 row
->glyphs
[TEXT_AREA
] = p
[TEXT_AREA
];
1002 row
->glyphs
[RIGHT_MARGIN_AREA
] = p
[RIGHT_MARGIN_AREA
];
1003 row
->glyphs
[LAST_AREA
] = p
[LAST_AREA
];
1005 #if 0 /* At some point, some bit-fields of struct glyph were not set,
1006 which made glyphs unequal when compared with GLYPH_EQUAL_P.
1007 Redisplay outputs such glyphs, and flickering effects were
1008 the result. This also depended on the contents of memory
1009 returned by xmalloc. If flickering happens again, activate
1010 the code below If the flickering is gone with that, chances
1011 are that the flickering has the same reason as here. */
1012 bzero (p
[0], (char *) p
[LAST_AREA
] - (char *) p
[0]);
1017 /* Make ROW an empty, enabled row of canonical character height,
1018 in window W starting at y-position Y. */
1021 blank_row (w
, row
, y
)
1023 struct glyph_row
*row
;
1028 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
1029 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
1031 clear_glyph_row (row
);
1033 row
->ascent
= row
->phys_ascent
= 0;
1034 row
->height
= row
->phys_height
= CANON_Y_UNIT (XFRAME (w
->frame
));
1037 row
->visible_height
= row
->height
- (min_y
- row
->y
);
1038 else if (row
->y
+ row
->height
> max_y
)
1039 row
->visible_height
= row
->height
- (row
->y
+ row
->height
- max_y
);
1041 row
->visible_height
= row
->height
;
1047 /* Increment buffer positions in glyph row ROW. DELTA and DELTA_BYTES
1048 are the amounts by which to change positions. Note that the first
1049 glyph of the text area of a row can have a buffer position even if
1050 the used count of the text area is zero. Such rows display line
1054 increment_row_positions (row
, delta
, delta_bytes
)
1055 struct glyph_row
*row
;
1056 int delta
, delta_bytes
;
1060 /* Increment start and end positions. */
1061 MATRIX_ROW_START_CHARPOS (row
) += delta
;
1062 MATRIX_ROW_START_BYTEPOS (row
) += delta_bytes
;
1063 MATRIX_ROW_END_CHARPOS (row
) += delta
;
1064 MATRIX_ROW_END_BYTEPOS (row
) += delta_bytes
;
1066 /* Increment positions in glyphs. */
1067 for (area
= 0; area
< LAST_AREA
; ++area
)
1068 for (i
= 0; i
< row
->used
[area
]; ++i
)
1069 if (BUFFERP (row
->glyphs
[area
][i
].object
)
1070 && row
->glyphs
[area
][i
].charpos
> 0)
1071 row
->glyphs
[area
][i
].charpos
+= delta
;
1073 /* Capture the case of rows displaying a line end. */
1074 if (row
->used
[TEXT_AREA
] == 0
1075 && MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1076 row
->glyphs
[TEXT_AREA
]->charpos
+= delta
;
1081 /* Swap glyphs between two glyph rows A and B. This exchanges glyph
1082 contents, i.e. glyph structure contents are exchanged between A and
1083 B without changing glyph pointers in A and B. */
1086 swap_glyphs_in_rows (a
, b
)
1087 struct glyph_row
*a
, *b
;
1091 for (area
= 0; area
< LAST_AREA
; ++area
)
1093 /* Number of glyphs to swap. */
1094 int max_used
= max (a
->used
[area
], b
->used
[area
]);
1096 /* Start of glyphs in area of row A. */
1097 struct glyph
*glyph_a
= a
->glyphs
[area
];
1099 /* End + 1 of glyphs in area of row A. */
1100 struct glyph
*glyph_a_end
= a
->glyphs
[max_used
];
1102 /* Start of glyphs in area of row B. */
1103 struct glyph
*glyph_b
= b
->glyphs
[area
];
1105 while (glyph_a
< glyph_a_end
)
1107 /* Non-ISO HP/UX compiler doesn't like auto struct
1111 *glyph_a
= *glyph_b
;
1121 /* Exchange pointers to glyph memory between glyph rows A and B. */
1124 swap_glyph_pointers (a
, b
)
1125 struct glyph_row
*a
, *b
;
1128 for (i
= 0; i
< LAST_AREA
+ 1; ++i
)
1130 struct glyph
*temp
= a
->glyphs
[i
];
1131 a
->glyphs
[i
] = b
->glyphs
[i
];
1132 b
->glyphs
[i
] = temp
;
1137 /* Copy glyph row structure FROM to glyph row structure TO, except
1138 that glyph pointers in the structures are left unchanged. */
1141 copy_row_except_pointers (to
, from
)
1142 struct glyph_row
*to
, *from
;
1144 struct glyph
*pointers
[1 + LAST_AREA
];
1146 /* Save glyph pointers of TO. */
1147 bcopy (to
->glyphs
, pointers
, sizeof to
->glyphs
);
1149 /* Do a structure assignment. */
1152 /* Restore original pointers of TO. */
1153 bcopy (pointers
, to
->glyphs
, sizeof to
->glyphs
);
1157 /* Copy contents of glyph row FROM to glyph row TO. Glyph pointers in
1158 TO and FROM are left unchanged. Glyph contents are copied from the
1159 glyph memory of FROM to the glyph memory of TO. Increment buffer
1160 positions in row TO by DELTA/ DELTA_BYTES. */
1163 copy_glyph_row_contents (to
, from
, delta
, delta_bytes
)
1164 struct glyph_row
*to
, *from
;
1165 int delta
, delta_bytes
;
1169 /* This is like a structure assignment TO = FROM, except that
1170 glyph pointers in the rows are left unchanged. */
1171 copy_row_except_pointers (to
, from
);
1173 /* Copy glyphs from FROM to TO. */
1174 for (area
= 0; area
< LAST_AREA
; ++area
)
1175 if (from
->used
[area
])
1176 bcopy (from
->glyphs
[area
], to
->glyphs
[area
],
1177 from
->used
[area
] * sizeof (struct glyph
));
1179 /* Increment buffer positions in TO by DELTA. */
1180 increment_row_positions (to
, delta
, delta_bytes
);
1184 /* Assign glyph row FROM to glyph row TO. This works like a structure
1185 assignment TO = FROM, except that glyph pointers are not copied but
1186 exchanged between TO and FROM. Pointers must be exchanged to avoid
1190 assign_row (to
, from
)
1191 struct glyph_row
*to
, *from
;
1193 swap_glyph_pointers (to
, from
);
1194 copy_row_except_pointers (to
, from
);
1198 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1199 a row in a window matrix, is a slice of the glyph memory of the
1200 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1201 is non-zero if the glyph memory of WINDOW_ROW is part of the glyph
1202 memory of FRAME_ROW. */
1207 glyph_row_slice_p (window_row
, frame_row
)
1208 struct glyph_row
*window_row
, *frame_row
;
1210 struct glyph
*window_glyph_start
= window_row
->glyphs
[0];
1211 struct glyph
*frame_glyph_start
= frame_row
->glyphs
[0];
1212 struct glyph
*frame_glyph_end
= frame_row
->glyphs
[LAST_AREA
];
1214 return (frame_glyph_start
<= window_glyph_start
1215 && window_glyph_start
< frame_glyph_end
);
1218 #endif /* GLYPH_DEBUG */
1222 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1223 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1224 in WINDOW_MATRIX is found satisfying the condition. */
1226 static struct glyph_row
*
1227 find_glyph_row_slice (window_matrix
, frame_matrix
, row
)
1228 struct glyph_matrix
*window_matrix
, *frame_matrix
;
1233 xassert (row
>= 0 && row
< frame_matrix
->nrows
);
1235 for (i
= 0; i
< window_matrix
->nrows
; ++i
)
1236 if (glyph_row_slice_p (window_matrix
->rows
+ i
,
1237 frame_matrix
->rows
+ row
))
1240 return i
< window_matrix
->nrows
? window_matrix
->rows
+ i
: 0;
1245 /* Prepare ROW for display. Desired rows are cleared lazily,
1246 i.e. they are only marked as to be cleared by setting their
1247 enabled_p flag to zero. When a row is to be displayed, a prior
1248 call to this function really clears it. */
1251 prepare_desired_row (row
)
1252 struct glyph_row
*row
;
1254 if (!row
->enabled_p
)
1256 clear_glyph_row (row
);
1262 /* Return a hash code for glyph row ROW. */
1265 line_hash_code (row
)
1266 struct glyph_row
*row
;
1274 /* Give all highlighted lines the same hash code
1275 so as to encourage scrolling to leave them in place. */
1280 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
1281 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
1285 int c
= glyph
->u
.ch
;
1286 int face_id
= glyph
->face_id
;
1287 if (must_write_spaces
)
1289 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + c
;
1290 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + face_id
;
1303 /* Return the cost of drawing line VPOS In MATRIX. The cost equals
1304 the number of characters in the line. If must_write_spaces is
1305 zero, leading and trailing spaces are ignored. */
1308 line_draw_cost (matrix
, vpos
)
1309 struct glyph_matrix
*matrix
;
1312 struct glyph_row
*row
= matrix
->rows
+ vpos
;
1313 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
1314 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
];
1316 Lisp_Object
*glyph_table_base
= GLYPH_TABLE_BASE
;
1317 int glyph_table_len
= GLYPH_TABLE_LENGTH
;
1319 /* Ignore trailing and leading spaces if we can. */
1320 if (!must_write_spaces
)
1322 /* Skip from the end over trailing spaces. */
1323 while (end
> beg
&& CHAR_GLYPH_SPACE_P (*(end
- 1)))
1326 /* All blank line. */
1330 /* Skip over leading spaces. */
1331 while (CHAR_GLYPH_SPACE_P (*beg
))
1335 /* If we don't have a glyph-table, each glyph is one character,
1336 so return the number of glyphs. */
1337 if (glyph_table_base
== 0)
1341 /* Otherwise, scan the glyphs and accumulate their total length
1346 GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*beg
);
1349 || GLYPH_SIMPLE_P (glyph_table_base
, glyph_table_len
, g
))
1352 len
+= GLYPH_LENGTH (glyph_table_base
, g
);
1362 /* Test two glyph rows A and B for equality. Value is non-zero if A
1363 and B have equal contents. W is the window to which the glyphs
1364 rows A and B belong. It is needed here to test for partial row
1365 visibility. MOUSE_FACE_P non-zero means compare the mouse_face_p
1366 flags of A and B, too. */
1369 row_equal_p (w
, a
, b
, mouse_face_p
)
1371 struct glyph_row
*a
, *b
;
1376 else if (a
->hash
!= b
->hash
)
1380 struct glyph
*a_glyph
, *b_glyph
, *a_end
;
1383 if (mouse_face_p
&& a
->mouse_face_p
!= b
->mouse_face_p
)
1386 /* Compare glyphs. */
1387 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
1389 if (a
->used
[area
] != b
->used
[area
])
1392 a_glyph
= a
->glyphs
[area
];
1393 a_end
= a_glyph
+ a
->used
[area
];
1394 b_glyph
= b
->glyphs
[area
];
1396 while (a_glyph
< a_end
1397 && GLYPH_EQUAL_P (a_glyph
, b_glyph
))
1398 ++a_glyph
, ++b_glyph
;
1400 if (a_glyph
!= a_end
)
1404 if (a
->truncated_on_left_p
!= b
->truncated_on_left_p
1405 || a
->inverse_p
!= b
->inverse_p
1406 || a
->fill_line_p
!= b
->fill_line_p
1407 || a
->truncated_on_right_p
!= b
->truncated_on_right_p
1408 || a
->overlay_arrow_p
!= b
->overlay_arrow_p
1409 || a
->continued_p
!= b
->continued_p
1410 || a
->indicate_empty_line_p
!= b
->indicate_empty_line_p
1411 || a
->overlapped_p
!= b
->overlapped_p
1412 || (MATRIX_ROW_CONTINUATION_LINE_P (a
)
1413 != MATRIX_ROW_CONTINUATION_LINE_P (b
))
1414 /* Different partially visible characters on left margin. */
1416 /* Different height. */
1417 || a
->ascent
!= b
->ascent
1418 || a
->phys_ascent
!= b
->phys_ascent
1419 || a
->phys_height
!= b
->phys_height
1420 || a
->visible_height
!= b
->visible_height
)
1429 /***********************************************************************
1432 See dispextern.h for an overall explanation of glyph pools.
1433 ***********************************************************************/
1435 /* Allocate a glyph_pool structure. The structure returned is
1436 initialized with zeros. The global variable glyph_pool_count is
1437 incremented for each pool allocated. */
1439 static struct glyph_pool
*
1442 struct glyph_pool
*result
;
1444 /* Allocate a new glyph_pool and clear it. */
1445 result
= (struct glyph_pool
*) xmalloc (sizeof *result
);
1446 bzero (result
, sizeof *result
);
1448 /* For memory leak and double deletion checking. */
1455 /* Free a glyph_pool structure POOL. The function may be called with
1456 a null POOL pointer. The global variable glyph_pool_count is
1457 decremented with every pool structure freed. If this count gets
1458 negative, more structures were freed than allocated, i.e. one
1459 structure must have been freed more than once or a bogus pointer
1460 was passed to free_glyph_pool. */
1463 free_glyph_pool (pool
)
1464 struct glyph_pool
*pool
;
1468 /* More freed than allocated? */
1470 xassert (glyph_pool_count
>= 0);
1472 xfree (pool
->glyphs
);
1478 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1479 columns we need. This function never shrinks a pool. The only
1480 case in which this would make sense, would be when a frame's size
1481 is changed from a large value to a smaller one. But, if someone
1482 does it once, we can expect that he will do it again.
1484 Value is non-zero if the pool changed in a way which makes
1485 re-adjusting window glyph matrices necessary. */
1488 realloc_glyph_pool (pool
, matrix_dim
)
1489 struct glyph_pool
*pool
;
1490 struct dim matrix_dim
;
1495 changed_p
= (pool
->glyphs
== 0
1496 || matrix_dim
.height
!= pool
->nrows
1497 || matrix_dim
.width
!= pool
->ncolumns
);
1499 /* Enlarge the glyph pool. */
1500 needed
= matrix_dim
.width
* matrix_dim
.height
;
1501 if (needed
> pool
->nglyphs
)
1503 int size
= needed
* sizeof (struct glyph
);
1506 pool
->glyphs
= (struct glyph
*) xrealloc (pool
->glyphs
, size
);
1509 pool
->glyphs
= (struct glyph
*) xmalloc (size
);
1510 bzero (pool
->glyphs
, size
);
1513 pool
->nglyphs
= needed
;
1516 /* Remember the number of rows and columns because (a) we use then
1517 to do sanity checks, and (b) the number of columns determines
1518 where rows in the frame matrix start---this must be available to
1519 determine pointers to rows of window sub-matrices. */
1520 pool
->nrows
= matrix_dim
.height
;
1521 pool
->ncolumns
= matrix_dim
.width
;
1528 /***********************************************************************
1530 ***********************************************************************/
1535 /* Flush standard output. This is sometimes useful to call from
1545 /* Check that no glyph pointers have been lost in MATRIX. If a
1546 pointer has been lost, e.g. by using a structure assignment between
1547 rows, at least one pointer must occur more than once in the rows of
1551 check_matrix_pointer_lossage (matrix
)
1552 struct glyph_matrix
*matrix
;
1556 for (i
= 0; i
< matrix
->nrows
; ++i
)
1557 for (j
= 0; j
< matrix
->nrows
; ++j
)
1559 || (matrix
->rows
[i
].glyphs
[TEXT_AREA
]
1560 != matrix
->rows
[j
].glyphs
[TEXT_AREA
]));
1564 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1567 matrix_row (matrix
, row
)
1568 struct glyph_matrix
*matrix
;
1571 xassert (matrix
&& matrix
->rows
);
1572 xassert (row
>= 0 && row
< matrix
->nrows
);
1574 /* That's really too slow for normal testing because this function
1575 is called almost everywhere. Although---it's still astonishingly
1576 fast, so it is valuable to have for debugging purposes. */
1578 check_matrix_pointer_lossage (matrix
);
1581 return matrix
->rows
+ row
;
1585 #if 0 /* This function makes invalid assumptions when text is
1586 partially invisible. But it might come handy for debugging
1589 /* Check invariants that must hold for an up to date current matrix of
1593 check_matrix_invariants (w
)
1596 struct glyph_matrix
*matrix
= w
->current_matrix
;
1597 int yb
= window_text_bottom_y (w
);
1598 struct glyph_row
*row
= matrix
->rows
;
1599 struct glyph_row
*last_text_row
= NULL
;
1600 struct buffer
*saved
= current_buffer
;
1601 struct buffer
*buffer
= XBUFFER (w
->buffer
);
1604 /* This can sometimes happen for a fresh window. */
1605 if (matrix
->nrows
< 2)
1608 set_buffer_temp (buffer
);
1610 /* Note: last row is always reserved for the mode line. */
1611 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1612 && MATRIX_ROW_BOTTOM_Y (row
) < yb
)
1614 struct glyph_row
*next
= row
+ 1;
1616 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1617 last_text_row
= row
;
1619 /* Check that character and byte positions are in sync. */
1620 xassert (MATRIX_ROW_START_BYTEPOS (row
)
1621 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row
)));
1623 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1624 have such a position temporarily in case of a minibuffer
1625 displaying something like `[Sole completion]' at its end. */
1626 if (MATRIX_ROW_END_CHARPOS (row
) < BUF_ZV (current_buffer
))
1627 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1628 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row
)));
1630 /* Check that end position of `row' is equal to start position
1632 if (next
->enabled_p
&& MATRIX_ROW_DISPLAYS_TEXT_P (next
))
1634 xassert (MATRIX_ROW_END_CHARPOS (row
)
1635 == MATRIX_ROW_START_CHARPOS (next
));
1636 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1637 == MATRIX_ROW_START_BYTEPOS (next
));
1642 xassert (w
->current_matrix
->nrows
== w
->desired_matrix
->nrows
);
1643 xassert (w
->desired_matrix
->rows
!= NULL
);
1644 set_buffer_temp (saved
);
1649 #endif /* GLYPH_DEBUG != 0 */
1653 /**********************************************************************
1654 Allocating/ Adjusting Glyph Matrices
1655 **********************************************************************/
1657 /* Allocate glyph matrices over a window tree for a frame-based
1660 X and Y are column/row within the frame glyph matrix where
1661 sub-matrices for the window tree rooted at WINDOW must be
1662 allocated. CH_DIM contains the dimensions of the smallest
1663 character that could be used during display. DIM_ONLY_P non-zero
1664 means that the caller of this function is only interested in the
1665 result matrix dimension, and matrix adjustments should not be
1668 The function returns the total width/height of the sub-matrices of
1669 the window tree. If called on a frame root window, the computation
1670 will take the mini-buffer window into account.
1672 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1674 NEW_LEAF_MATRIX set if any window in the tree did not have a
1675 glyph matrices yet, and
1677 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1678 any window in the tree will be changed or have been changed (see
1681 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1684 Windows are arranged into chains of windows on the same level
1685 through the next fields of window structures. Such a level can be
1686 either a sequence of horizontally adjacent windows from left to
1687 right, or a sequence of vertically adjacent windows from top to
1688 bottom. Each window in a horizontal sequence can be either a leaf
1689 window or a vertical sequence; a window in a vertical sequence can
1690 be either a leaf or a horizontal sequence. All windows in a
1691 horizontal sequence have the same height, and all windows in a
1692 vertical sequence have the same width.
1694 This function uses, for historical reasons, a more general
1695 algorithm to determine glyph matrix dimensions that would be
1698 The matrix height of a horizontal sequence is determined by the
1699 maximum height of any matrix in the sequence. The matrix width of
1700 a horizontal sequence is computed by adding up matrix widths of
1701 windows in the sequence.
1703 |<------- result width ------->|
1704 +---------+----------+---------+ ---
1707 +---------+ | | result height
1712 The matrix width of a vertical sequence is the maximum matrix width
1713 of any window in the sequence. Its height is computed by adding up
1714 matrix heights of windows in the sequence.
1716 |<---- result width -->|
1724 +------------+---------+ |
1727 +------------+---------+ --- */
1729 /* Bit indicating that a new matrix will be allocated or has been
1732 #define NEW_LEAF_MATRIX (1 << 0)
1734 /* Bit indicating that a matrix will or has changed its location or
1737 #define CHANGED_LEAF_MATRIX (1 << 1)
1740 allocate_matrices_for_frame_redisplay (window
, x
, y
, ch_dim
,
1741 dim_only_p
, window_change_flags
)
1746 int *window_change_flags
;
1748 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1750 int wmax
= 0, hmax
= 0;
1754 int in_horz_combination_p
;
1756 /* What combination is WINDOW part of? Compute this once since the
1757 result is the same for all windows in the `next' chain. The
1758 special case of a root window (parent equal to nil) is treated
1759 like a vertical combination because a root window's `next'
1760 points to the mini-buffer window, if any, which is arranged
1761 vertically below other windows. */
1762 in_horz_combination_p
1763 = (!NILP (XWINDOW (window
)->parent
)
1764 && !NILP (XWINDOW (XWINDOW (window
)->parent
)->hchild
));
1766 /* For WINDOW and all windows on the same level. */
1769 w
= XWINDOW (window
);
1771 /* Get the dimension of the window sub-matrix for W, depending
1772 on whether this a combination or a leaf window. */
1773 if (!NILP (w
->hchild
))
1774 dim
= allocate_matrices_for_frame_redisplay (w
->hchild
, x
, y
, ch_dim
,
1776 window_change_flags
);
1777 else if (!NILP (w
->vchild
))
1778 dim
= allocate_matrices_for_frame_redisplay (w
->vchild
, x
, y
, ch_dim
,
1780 window_change_flags
);
1783 /* If not already done, allocate sub-matrix structures. */
1784 if (w
->desired_matrix
== NULL
)
1786 w
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1787 w
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1788 *window_change_flags
|= NEW_LEAF_MATRIX
;
1791 /* Width and height MUST be chosen so that there are no
1792 holes in the frame matrix. */
1793 dim
.width
= XINT (w
->width
);
1794 dim
.height
= XINT (w
->height
);
1796 /* Will matrix be re-allocated? */
1797 if (x
!= w
->desired_matrix
->matrix_x
1798 || y
!= w
->desired_matrix
->matrix_y
1799 || dim
.width
!= w
->desired_matrix
->matrix_w
1800 || dim
.height
!= w
->desired_matrix
->matrix_h
1801 || (margin_glyphs_to_reserve (w
, dim
.width
,
1802 w
->right_margin_width
)
1803 != w
->desired_matrix
->left_margin_glyphs
)
1804 || (margin_glyphs_to_reserve (w
, dim
.width
,
1805 w
->left_margin_width
)
1806 != w
->desired_matrix
->right_margin_glyphs
))
1807 *window_change_flags
|= CHANGED_LEAF_MATRIX
;
1809 /* Actually change matrices, if allowed. Do not consider
1810 CHANGED_LEAF_MATRIX computed above here because the pool
1811 may have been changed which we don't now here. We trust
1812 that we only will be called with DIM_ONLY_P != 0 when
1816 adjust_glyph_matrix (w
, w
->desired_matrix
, x
, y
, dim
);
1817 adjust_glyph_matrix (w
, w
->current_matrix
, x
, y
, dim
);
1821 /* If we are part of a horizontal combination, advance x for
1822 windows to the right of W; otherwise advance y for windows
1824 if (in_horz_combination_p
)
1829 /* Remember maximum glyph matrix dimensions. */
1830 wmax
= max (wmax
, dim
.width
);
1831 hmax
= max (hmax
, dim
.height
);
1833 /* Next window on same level. */
1836 while (!NILP (window
));
1838 /* Set `total' to the total glyph matrix dimension of this window
1839 level. In a vertical combination, the width is the width of the
1840 widest window; the height is the y we finally reached, corrected
1841 by the y we started with. In a horizontal combination, the total
1842 height is the height of the tallest window, and the width is the
1843 x we finally reached, corrected by the x we started with. */
1844 if (in_horz_combination_p
)
1846 total
.width
= x
- x0
;
1847 total
.height
= hmax
;
1852 total
.height
= y
- y0
;
1859 /* Allocate window matrices for window-based redisplay. W is the
1860 window whose matrices must be allocated/reallocated. CH_DIM is the
1861 size of the smallest character that could potentially be used on W. */
1864 allocate_matrices_for_window_redisplay (w
, ch_dim
)
1868 struct frame
*f
= XFRAME (w
->frame
);
1872 if (!NILP (w
->vchild
))
1873 allocate_matrices_for_window_redisplay (XWINDOW (w
->vchild
), ch_dim
);
1874 else if (!NILP (w
->hchild
))
1875 allocate_matrices_for_window_redisplay (XWINDOW (w
->hchild
), ch_dim
);
1878 /* W is a leaf window. */
1879 int window_pixel_width
= XFLOATINT (w
->width
) * CANON_X_UNIT (f
);
1880 int window_pixel_height
= window_box_height (w
) + abs (w
->vscroll
);
1883 /* If matrices are not yet allocated, allocate them now. */
1884 if (w
->desired_matrix
== NULL
)
1886 w
->desired_matrix
= new_glyph_matrix (NULL
);
1887 w
->current_matrix
= new_glyph_matrix (NULL
);
1890 /* Compute number of glyphs needed in a glyph row. */
1891 dim
.width
= (((window_pixel_width
+ ch_dim
.width
- 1)
1893 /* 2 partially visible columns in the text area. */
1895 /* One partially visible column at the right
1896 edge of each marginal area. */
1899 /* Compute number of glyph rows needed. */
1900 dim
.height
= (((window_pixel_height
+ ch_dim
.height
- 1)
1902 /* One partially visible line at the top and
1903 bottom of the window. */
1905 /* 2 for top and mode line. */
1908 /* Change matrices. */
1909 adjust_glyph_matrix (w
, w
->desired_matrix
, 0, 0, dim
);
1910 adjust_glyph_matrix (w
, w
->current_matrix
, 0, 0, dim
);
1913 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
1918 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
1919 do it for all frames; otherwise do it just for the given frame.
1920 This function must be called when a new frame is created, its size
1921 changes, or its window configuration changes. */
1927 /* Block input so that expose events and other events that access
1928 glyph matrices are not processed while we are changing them. */
1932 adjust_frame_glyphs (f
);
1935 Lisp_Object tail
, lisp_frame
;
1937 FOR_EACH_FRAME (tail
, lisp_frame
)
1938 adjust_frame_glyphs (XFRAME (lisp_frame
));
1945 /* Adjust frame glyphs when Emacs is initialized.
1947 To be called from init_display.
1949 We need a glyph matrix because redraw will happen soon.
1950 Unfortunately, window sizes on selected_frame are not yet set to
1951 meaningful values. I believe we can assume that there are only two
1952 windows on the frame---the mini-buffer and the root window. Frame
1953 height and width seem to be correct so far. So, set the sizes of
1954 windows to estimated values. */
1957 adjust_frame_glyphs_initially ()
1959 struct frame
*sf
= SELECTED_FRAME ();
1960 struct window
*root
= XWINDOW (sf
->root_window
);
1961 struct window
*mini
= XWINDOW (root
->next
);
1962 int frame_height
= FRAME_HEIGHT (sf
);
1963 int frame_width
= FRAME_WIDTH (sf
);
1964 int top_margin
= FRAME_TOP_MARGIN (sf
);
1966 /* Do it for the root window. */
1967 XSETFASTINT (root
->top
, top_margin
);
1968 XSETFASTINT (root
->width
, frame_width
);
1969 set_window_height (sf
->root_window
, frame_height
- 1 - top_margin
, 0);
1971 /* Do it for the mini-buffer window. */
1972 XSETFASTINT (mini
->top
, frame_height
- 1);
1973 XSETFASTINT (mini
->width
, frame_width
);
1974 set_window_height (root
->next
, 1, 0);
1976 adjust_frame_glyphs (sf
);
1977 glyphs_initialized_initially_p
= 1;
1981 /* Allocate/reallocate glyph matrices of a single frame F. */
1984 adjust_frame_glyphs (f
)
1987 if (FRAME_WINDOW_P (f
))
1988 adjust_frame_glyphs_for_window_redisplay (f
);
1990 adjust_frame_glyphs_for_frame_redisplay (f
);
1992 /* Don't forget the message buffer and the buffer for
1993 decode_mode_spec. */
1994 adjust_frame_message_buffer (f
);
1995 adjust_decode_mode_spec_buffer (f
);
1997 f
->glyphs_initialized_p
= 1;
2001 /* Allocate/reallocate glyph matrices of a single frame F for
2002 frame-based redisplay. */
2005 adjust_frame_glyphs_for_frame_redisplay (f
)
2009 struct dim matrix_dim
;
2011 int window_change_flags
;
2014 if (!FRAME_LIVE_P (f
))
2017 /* Determine the smallest character in any font for F. On
2018 console windows, all characters have dimension (1, 1). */
2019 ch_dim
.width
= ch_dim
.height
= 1;
2021 top_window_y
= FRAME_TOP_MARGIN (f
);
2023 /* Allocate glyph pool structures if not already done. */
2024 if (f
->desired_pool
== NULL
)
2026 f
->desired_pool
= new_glyph_pool ();
2027 f
->current_pool
= new_glyph_pool ();
2030 /* Allocate frames matrix structures if needed. */
2031 if (f
->desired_matrix
== NULL
)
2033 f
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
2034 f
->current_matrix
= new_glyph_matrix (f
->current_pool
);
2037 /* Compute window glyph matrices. (This takes the mini-buffer
2038 window into account). The result is the size of the frame glyph
2039 matrix needed. The variable window_change_flags is set to a bit
2040 mask indicating whether new matrices will be allocated or
2041 existing matrices change their size or location within the frame
2043 window_change_flags
= 0;
2045 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2048 &window_change_flags
);
2050 /* Add in menu bar lines, if any. */
2051 matrix_dim
.height
+= top_window_y
;
2053 /* Enlarge pools as necessary. */
2054 pool_changed_p
= realloc_glyph_pool (f
->desired_pool
, matrix_dim
);
2055 realloc_glyph_pool (f
->current_pool
, matrix_dim
);
2057 /* Set up glyph pointers within window matrices. Do this only if
2058 absolutely necessary since it requires a frame redraw. */
2059 if (pool_changed_p
|| window_change_flags
)
2061 /* Do it for window matrices. */
2062 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2063 0, top_window_y
, ch_dim
, 0,
2064 &window_change_flags
);
2066 /* Size of frame matrices must equal size of frame. Note
2067 that we are called for X frames with window widths NOT equal
2068 to the frame width (from CHANGE_FRAME_SIZE_1). */
2069 xassert (matrix_dim
.width
== FRAME_WIDTH (f
)
2070 && matrix_dim
.height
== FRAME_HEIGHT (f
));
2072 /* Resize frame matrices. */
2073 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2074 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2076 /* Since location and size of sub-matrices within the pool may
2077 have changed, and current matrices don't have meaningful
2078 contents anymore, mark the frame garbaged. */
2079 SET_FRAME_GARBAGED (f
);
2084 /* Allocate/reallocate glyph matrices of a single frame F for
2085 window-based redisplay. */
2088 adjust_frame_glyphs_for_window_redisplay (f
)
2094 xassert (FRAME_WINDOW_P (f
) && FRAME_LIVE_P (f
));
2096 /* Get minimum sizes. */
2097 #ifdef HAVE_WINDOW_SYSTEM
2098 ch_dim
.width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2099 ch_dim
.height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
2101 ch_dim
.width
= ch_dim
.height
= 1;
2104 /* Allocate/reallocate window matrices. */
2105 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f
)),
2108 /* Allocate/ reallocate matrices of the dummy window used to display
2109 the menu bar under X when no X toolkit support is available. */
2110 #ifndef USE_X_TOOLKIT
2112 /* Allocate a dummy window if not already done. */
2113 if (NILP (f
->menu_bar_window
))
2115 f
->menu_bar_window
= make_window ();
2116 w
= XWINDOW (f
->menu_bar_window
);
2117 XSETFRAME (w
->frame
, f
);
2118 w
->pseudo_window_p
= 1;
2121 w
= XWINDOW (f
->menu_bar_window
);
2123 /* Set window dimensions to frame dimensions and allocate or
2124 adjust glyph matrices of W. */
2125 XSETFASTINT (w
->top
, 0);
2126 XSETFASTINT (w
->left
, 0);
2127 XSETFASTINT (w
->height
, FRAME_MENU_BAR_LINES (f
));
2128 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2129 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2131 #endif /* not USE_X_TOOLKIT */
2133 /* Allocate/ reallocate matrices of the tool bar window. If we
2134 don't have a tool bar window yet, make one. */
2135 if (NILP (f
->tool_bar_window
))
2137 f
->tool_bar_window
= make_window ();
2138 w
= XWINDOW (f
->tool_bar_window
);
2139 XSETFRAME (w
->frame
, f
);
2140 w
->pseudo_window_p
= 1;
2143 w
= XWINDOW (f
->tool_bar_window
);
2145 XSETFASTINT (w
->top
, FRAME_MENU_BAR_LINES (f
));
2146 XSETFASTINT (w
->left
, 0);
2147 XSETFASTINT (w
->height
, FRAME_TOOL_BAR_LINES (f
));
2148 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2149 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2153 /* Adjust/ allocate message buffer of frame F.
2155 Note that the message buffer is never freed. Since I could not
2156 find a free in 19.34, I assume that freeing it would be
2157 problematic in some way and don't do it either.
2159 (Implementation note: It should be checked if we can free it
2160 eventually without causing trouble). */
2163 adjust_frame_message_buffer (f
)
2166 int size
= FRAME_MESSAGE_BUF_SIZE (f
) + 1;
2168 if (FRAME_MESSAGE_BUF (f
))
2170 char *buffer
= FRAME_MESSAGE_BUF (f
);
2171 char *new_buffer
= (char *) xrealloc (buffer
, size
);
2172 FRAME_MESSAGE_BUF (f
) = new_buffer
;
2175 FRAME_MESSAGE_BUF (f
) = (char *) xmalloc (size
);
2179 /* Re-allocate buffer for decode_mode_spec on frame F. */
2182 adjust_decode_mode_spec_buffer (f
)
2185 f
->decode_mode_spec_buffer
2186 = (char *) xrealloc (f
->decode_mode_spec_buffer
,
2187 FRAME_MESSAGE_BUF_SIZE (f
) + 1);
2192 /**********************************************************************
2193 Freeing Glyph Matrices
2194 **********************************************************************/
2196 /* Free glyph memory for a frame F. F may be null. This function can
2197 be called for the same frame more than once. The root window of
2198 F may be nil when this function is called. This is the case when
2199 the function is called when F is destroyed. */
2205 if (f
&& f
->glyphs_initialized_p
)
2207 /* Block interrupt input so that we don't get surprised by an X
2208 event while we're in an inconsistent state. */
2210 f
->glyphs_initialized_p
= 0;
2212 /* Release window sub-matrices. */
2213 if (!NILP (f
->root_window
))
2214 free_window_matrices (XWINDOW (f
->root_window
));
2216 /* Free the dummy window for menu bars without X toolkit and its
2218 if (!NILP (f
->menu_bar_window
))
2220 struct window
*w
= XWINDOW (f
->menu_bar_window
);
2221 free_glyph_matrix (w
->desired_matrix
);
2222 free_glyph_matrix (w
->current_matrix
);
2223 w
->desired_matrix
= w
->current_matrix
= NULL
;
2224 f
->menu_bar_window
= Qnil
;
2227 /* Free the tool bar window and its glyph matrices. */
2228 if (!NILP (f
->tool_bar_window
))
2230 struct window
*w
= XWINDOW (f
->tool_bar_window
);
2231 free_glyph_matrix (w
->desired_matrix
);
2232 free_glyph_matrix (w
->current_matrix
);
2233 w
->desired_matrix
= w
->current_matrix
= NULL
;
2234 f
->tool_bar_window
= Qnil
;
2237 /* Release frame glyph matrices. Reset fields to zero in
2238 case we are called a second time. */
2239 if (f
->desired_matrix
)
2241 free_glyph_matrix (f
->desired_matrix
);
2242 free_glyph_matrix (f
->current_matrix
);
2243 f
->desired_matrix
= f
->current_matrix
= NULL
;
2246 /* Release glyph pools. */
2247 if (f
->desired_pool
)
2249 free_glyph_pool (f
->desired_pool
);
2250 free_glyph_pool (f
->current_pool
);
2251 f
->desired_pool
= f
->current_pool
= NULL
;
2259 /* Free glyph sub-matrices in the window tree rooted at W. This
2260 function may be called with a null pointer, and it may be called on
2261 the same tree more than once. */
2264 free_window_matrices (w
)
2269 if (!NILP (w
->hchild
))
2270 free_window_matrices (XWINDOW (w
->hchild
));
2271 else if (!NILP (w
->vchild
))
2272 free_window_matrices (XWINDOW (w
->vchild
));
2275 /* This is a leaf window. Free its memory and reset fields
2276 to zero in case this function is called a second time for
2278 free_glyph_matrix (w
->current_matrix
);
2279 free_glyph_matrix (w
->desired_matrix
);
2280 w
->current_matrix
= w
->desired_matrix
= NULL
;
2283 /* Next window on same level. */
2284 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2289 /* Check glyph memory leaks. This function is called from
2290 shut_down_emacs. Note that frames are not destroyed when Emacs
2291 exits. We therefore free all glyph memory for all active frames
2292 explicitly and check that nothing is left allocated. */
2295 check_glyph_memory ()
2297 Lisp_Object tail
, frame
;
2299 /* Free glyph memory for all frames. */
2300 FOR_EACH_FRAME (tail
, frame
)
2301 free_glyphs (XFRAME (frame
));
2303 /* Check that nothing is left allocated. */
2304 if (glyph_matrix_count
)
2306 if (glyph_pool_count
)
2312 /**********************************************************************
2313 Building a Frame Matrix
2314 **********************************************************************/
2316 /* Most of the redisplay code works on glyph matrices attached to
2317 windows. This is a good solution most of the time, but it is not
2318 suitable for terminal code. Terminal output functions cannot rely
2319 on being able to set an arbitrary terminal window. Instead they
2320 must be provided with a view of the whole frame, i.e. the whole
2321 screen. We build such a view by constructing a frame matrix from
2322 window matrices in this section.
2324 Windows that must be updated have their must_be_update_p flag set.
2325 For all such windows, their desired matrix is made part of the
2326 desired frame matrix. For other windows, their current matrix is
2327 made part of the desired frame matrix.
2329 +-----------------+----------------+
2330 | desired | desired |
2332 +-----------------+----------------+
2335 +----------------------------------+
2337 Desired window matrices can be made part of the frame matrix in a
2338 cheap way: We exploit the fact that the desired frame matrix and
2339 desired window matrices share their glyph memory. This is not
2340 possible for current window matrices. Their glyphs are copied to
2341 the desired frame matrix. The latter is equivalent to
2342 preserve_other_columns in the old redisplay.
2344 Used glyphs counters for frame matrix rows are the result of adding
2345 up glyph lengths of the window matrices. A line in the frame
2346 matrix is enabled, if a corresponding line in a window matrix is
2349 After building the desired frame matrix, it will be passed to
2350 terminal code, which will manipulate both the desired and current
2351 frame matrix. Changes applied to the frame's current matrix have
2352 to be visible in current window matrices afterwards, of course.
2354 This problem is solved like this:
2356 1. Window and frame matrices share glyphs. Window matrices are
2357 constructed in a way that their glyph contents ARE the glyph
2358 contents needed in a frame matrix. Thus, any modification of
2359 glyphs done in terminal code will be reflected in window matrices
2362 2. Exchanges of rows in a frame matrix done by terminal code are
2363 intercepted by hook functions so that corresponding row operations
2364 on window matrices can be performed. This is necessary because we
2365 use pointers to glyphs in glyph row structures. To satisfy the
2366 assumption of point 1 above that glyphs are updated implicitly in
2367 window matrices when they are manipulated via the frame matrix,
2368 window and frame matrix must of course agree where to find the
2369 glyphs for their rows. Possible manipulations that must be
2370 mirrored are assignments of rows of the desired frame matrix to the
2371 current frame matrix and scrolling the current frame matrix. */
2373 /* Build frame F's desired matrix from window matrices. Only windows
2374 which have the flag must_be_updated_p set have to be updated. Menu
2375 bar lines of a frame are not covered by window matrices, so make
2376 sure not to touch them in this function. */
2379 build_frame_matrix (f
)
2384 /* F must have a frame matrix when this function is called. */
2385 xassert (!FRAME_WINDOW_P (f
));
2387 /* Clear all rows in the frame matrix covered by window matrices.
2388 Menu bar lines are not covered by windows. */
2389 for (i
= FRAME_TOP_MARGIN (f
); i
< f
->desired_matrix
->nrows
; ++i
)
2390 clear_glyph_row (MATRIX_ROW (f
->desired_matrix
, i
));
2392 /* Build the matrix by walking the window tree. */
2393 build_frame_matrix_from_window_tree (f
->desired_matrix
,
2394 XWINDOW (FRAME_ROOT_WINDOW (f
)));
2398 /* Walk a window tree, building a frame matrix MATRIX from window
2399 matrices. W is the root of a window tree. */
2402 build_frame_matrix_from_window_tree (matrix
, w
)
2403 struct glyph_matrix
*matrix
;
2408 if (!NILP (w
->hchild
))
2409 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->hchild
));
2410 else if (!NILP (w
->vchild
))
2411 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->vchild
));
2413 build_frame_matrix_from_leaf_window (matrix
, w
);
2415 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2420 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2421 desired frame matrix built. W is a leaf window whose desired or
2422 current matrix is to be added to FRAME_MATRIX. W's flag
2423 must_be_updated_p determines which matrix it contributes to
2424 FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix
2425 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2426 Adding a desired matrix means setting up used counters and such in
2427 frame rows, while adding a current window matrix to FRAME_MATRIX
2428 means copying glyphs. The latter case corresponds to
2429 preserve_other_columns in the old redisplay. */
2432 build_frame_matrix_from_leaf_window (frame_matrix
, w
)
2433 struct glyph_matrix
*frame_matrix
;
2436 struct glyph_matrix
*window_matrix
;
2437 int window_y
, frame_y
;
2438 /* If non-zero, a glyph to insert at the right border of W. */
2439 GLYPH right_border_glyph
= 0;
2441 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2442 if (w
->must_be_updated_p
)
2444 window_matrix
= w
->desired_matrix
;
2446 /* Decide whether we want to add a vertical border glyph. */
2447 if (!WINDOW_RIGHTMOST_P (w
))
2449 struct Lisp_Char_Table
*dp
= window_display_table (w
);
2450 right_border_glyph
= (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
2451 ? XINT (DISP_BORDER_GLYPH (dp
))
2456 window_matrix
= w
->current_matrix
;
2458 /* For all rows in the window matrix and corresponding rows in the
2461 frame_y
= window_matrix
->matrix_y
;
2462 while (window_y
< window_matrix
->nrows
)
2464 struct glyph_row
*frame_row
= frame_matrix
->rows
+ frame_y
;
2465 struct glyph_row
*window_row
= window_matrix
->rows
+ window_y
;
2466 int current_row_p
= window_matrix
== w
->current_matrix
;
2468 /* Fill up the frame row with spaces up to the left margin of the
2470 fill_up_frame_row_with_spaces (frame_row
, window_matrix
->matrix_x
);
2472 /* Fill up areas in the window matrix row with spaces. */
2473 fill_up_glyph_row_with_spaces (window_row
);
2475 /* If only part of W's desired matrix has been built, and
2476 window_row wasn't displayed, use the corresponding current
2478 if (window_matrix
== w
->desired_matrix
2479 && !window_row
->enabled_p
)
2481 window_row
= w
->current_matrix
->rows
+ window_y
;
2487 /* Copy window row to frame row. */
2488 bcopy (window_row
->glyphs
[0],
2489 frame_row
->glyphs
[TEXT_AREA
] + window_matrix
->matrix_x
,
2490 window_matrix
->matrix_w
* sizeof (struct glyph
));
2494 xassert (window_row
->enabled_p
);
2496 /* Only when a desired row has been displayed, we want
2497 the corresponding frame row to be updated. */
2498 frame_row
->enabled_p
= 1;
2500 /* Maybe insert a vertical border between horizontally adjacent
2502 if (right_border_glyph
)
2504 struct glyph
*border
= window_row
->glyphs
[LAST_AREA
] - 1;
2505 SET_CHAR_GLYPH_FROM_GLYPH (*border
, right_border_glyph
);
2508 #if 0 /* This shouldn't be necessary. Let's check it. */
2509 /* Due to hooks installed, it normally doesn't happen that
2510 window rows and frame rows of the same matrix are out of
2511 sync, i.e. have a different understanding of where to
2512 find glyphs for the row. The following is a safety-belt
2513 that doesn't cost much and makes absolutely sure that
2514 window and frame matrices are in sync. */
2515 if (!glyph_row_slice_p (window_row
, frame_row
))
2517 /* Find the row in the window being a slice. There
2518 should exist one from program logic. */
2519 struct glyph_row
*slice_row
2520 = find_glyph_row_slice (window_matrix
, frame_matrix
, frame_y
);
2521 xassert (slice_row
!= 0);
2523 /* Exchange glyphs between both window rows. */
2524 swap_glyphs_in_rows (window_row
, slice_row
);
2526 /* Exchange pointers between both rows. */
2527 swap_glyph_pointers (window_row
, slice_row
);
2531 /* Window row window_y must be a slice of frame row
2533 xassert (glyph_row_slice_p (window_row
, frame_row
));
2535 /* If rows are in sync, we don't have to copy glyphs because
2536 frame and window share glyphs. */
2539 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
2543 /* Set number of used glyphs in the frame matrix. Since we fill
2544 up with spaces, and visit leaf windows from left to right it
2545 can be done simply. */
2546 frame_row
->used
[TEXT_AREA
]
2547 = window_matrix
->matrix_x
+ window_matrix
->matrix_w
;
2549 /* Or in other flags. */
2550 frame_row
->inverse_p
|= window_row
->inverse_p
;
2559 /* Add spaces to a glyph row ROW in a window matrix.
2561 Each row has the form:
2563 +---------+-----------------------------+------------+
2564 | left | text | right |
2565 +---------+-----------------------------+------------+
2567 Left and right marginal areas are optional. This function adds
2568 spaces to areas so that there are no empty holes between areas.
2569 In other words: If the right area is not empty, the text area
2570 is filled up with spaces up to the right area. If the text area
2571 is not empty, the left area is filled up.
2573 To be called for frame-based redisplay, only. */
2576 fill_up_glyph_row_with_spaces (row
)
2577 struct glyph_row
*row
;
2579 fill_up_glyph_row_area_with_spaces (row
, LEFT_MARGIN_AREA
);
2580 fill_up_glyph_row_area_with_spaces (row
, TEXT_AREA
);
2581 fill_up_glyph_row_area_with_spaces (row
, RIGHT_MARGIN_AREA
);
2585 /* Fill area AREA of glyph row ROW with spaces. To be called for
2586 frame-based redisplay only. */
2589 fill_up_glyph_row_area_with_spaces (row
, area
)
2590 struct glyph_row
*row
;
2593 if (row
->glyphs
[area
] < row
->glyphs
[area
+ 1])
2595 struct glyph
*end
= row
->glyphs
[area
+ 1];
2596 struct glyph
*text
= row
->glyphs
[area
] + row
->used
[area
];
2599 *text
++ = space_glyph
;
2600 row
->used
[area
] = text
- row
->glyphs
[area
];
2605 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2606 reached. In frame matrices only one area, TEXT_AREA, is used. */
2609 fill_up_frame_row_with_spaces (row
, upto
)
2610 struct glyph_row
*row
;
2613 int i
= row
->used
[TEXT_AREA
];
2614 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
2617 glyph
[i
++] = space_glyph
;
2619 row
->used
[TEXT_AREA
] = i
;
2624 /**********************************************************************
2625 Mirroring operations on frame matrices in window matrices
2626 **********************************************************************/
2628 /* Set frame being updated via frame-based redisplay to F. This
2629 function must be called before updates to make explicit that we are
2630 working on frame matrices or not. */
2633 set_frame_matrix_frame (f
)
2636 frame_matrix_frame
= f
;
2640 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2641 DESIRED_MATRIX is the desired matrix corresponding to
2642 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2643 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2644 frame_matrix_frame is non-null, this indicates that the exchange is
2645 done in frame matrices, and that we have to perform analogous
2646 operations in window matrices of frame_matrix_frame. */
2649 make_current (desired_matrix
, current_matrix
, row
)
2650 struct glyph_matrix
*desired_matrix
, *current_matrix
;
2653 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, row
);
2654 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, row
);
2655 int mouse_face_p
= current_row
->mouse_face_p
;
2657 /* Do current_row = desired_row. This exchanges glyph pointers
2658 between both rows, and does a structure assignment otherwise. */
2659 assign_row (current_row
, desired_row
);
2661 /* Enable current_row to mark it as valid. */
2662 current_row
->enabled_p
= 1;
2663 current_row
->mouse_face_p
= mouse_face_p
;
2665 /* If we are called on frame matrices, perform analogous operations
2666 for window matrices. */
2667 if (frame_matrix_frame
)
2668 mirror_make_current (XWINDOW (frame_matrix_frame
->root_window
), row
);
2672 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2673 W's frame which has been made current (by swapping pointers between
2674 current and desired matrix). Perform analogous operations in the
2675 matrices of leaf windows in the window tree rooted at W. */
2678 mirror_make_current (w
, frame_row
)
2684 if (!NILP (w
->hchild
))
2685 mirror_make_current (XWINDOW (w
->hchild
), frame_row
);
2686 else if (!NILP (w
->vchild
))
2687 mirror_make_current (XWINDOW (w
->vchild
), frame_row
);
2690 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2691 here because the checks performed in debug mode there
2692 will not allow the conversion. */
2693 int row
= frame_row
- w
->desired_matrix
->matrix_y
;
2695 /* If FRAME_ROW is within W, assign the desired row to the
2696 current row (exchanging glyph pointers). */
2697 if (row
>= 0 && row
< w
->desired_matrix
->matrix_h
)
2699 struct glyph_row
*current_row
2700 = MATRIX_ROW (w
->current_matrix
, row
);
2701 struct glyph_row
*desired_row
2702 = MATRIX_ROW (w
->desired_matrix
, row
);
2704 if (desired_row
->enabled_p
)
2705 assign_row (current_row
, desired_row
);
2707 swap_glyph_pointers (desired_row
, current_row
);
2708 current_row
->enabled_p
= 1;
2712 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2717 /* Perform row dance after scrolling. We are working on the range of
2718 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2719 including) in MATRIX. COPY_FROM is a vector containing, for each
2720 row I in the range 0 <= I < NLINES, the index of the original line
2721 to move to I. This index is relative to the row range, i.e. 0 <=
2722 index < NLINES. RETAINED_P is a vector containing zero for each
2723 row 0 <= I < NLINES which is empty.
2725 This function is called from do_scrolling and do_direct_scrolling. */
2728 mirrored_line_dance (matrix
, unchanged_at_top
, nlines
, copy_from
,
2730 struct glyph_matrix
*matrix
;
2731 int unchanged_at_top
, nlines
;
2735 /* A copy of original rows. */
2736 struct glyph_row
*old_rows
;
2738 /* Rows to assign to. */
2739 struct glyph_row
*new_rows
= MATRIX_ROW (matrix
, unchanged_at_top
);
2743 /* Make a copy of the original rows. */
2744 old_rows
= (struct glyph_row
*) alloca (nlines
* sizeof *old_rows
);
2745 bcopy (new_rows
, old_rows
, nlines
* sizeof *old_rows
);
2747 /* Assign new rows, maybe clear lines. */
2748 for (i
= 0; i
< nlines
; ++i
)
2750 int enabled_before_p
= new_rows
[i
].enabled_p
;
2752 xassert (i
+ unchanged_at_top
< matrix
->nrows
);
2753 xassert (unchanged_at_top
+ copy_from
[i
] < matrix
->nrows
);
2754 new_rows
[i
] = old_rows
[copy_from
[i
]];
2755 new_rows
[i
].enabled_p
= enabled_before_p
;
2757 /* RETAINED_P is zero for empty lines. */
2758 if (!retained_p
[copy_from
[i
]])
2759 new_rows
[i
].enabled_p
= 0;
2762 /* Do the same for window matrices, if MATRIX Is a frame matrix. */
2763 if (frame_matrix_frame
)
2764 mirror_line_dance (XWINDOW (frame_matrix_frame
->root_window
),
2765 unchanged_at_top
, nlines
, copy_from
, retained_p
);
2769 /* Synchronize glyph pointers in the current matrix of window W with
2770 the current frame matrix. W must be full-width, and be on a tty
2774 sync_window_with_frame_matrix_rows (w
)
2777 struct frame
*f
= XFRAME (w
->frame
);
2778 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
2780 /* Preconditions: W must be a leaf window and full-width. Its frame
2781 must have a frame matrix. */
2782 xassert (NILP (w
->hchild
) && NILP (w
->vchild
));
2783 xassert (WINDOW_FULL_WIDTH_P (w
));
2784 xassert (!FRAME_WINDOW_P (f
));
2786 /* If W is a full-width window, glyph pointers in W's current matrix
2787 have, by definition, to be the same as glyph pointers in the
2788 corresponding frame matrix. */
2789 window_row
= w
->current_matrix
->rows
;
2790 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
2791 frame_row
= f
->current_matrix
->rows
+ XFASTINT (w
->top
);
2792 while (window_row
< window_row_end
)
2796 for (area
= LEFT_MARGIN_AREA
; area
<= LAST_AREA
; ++area
)
2797 window_row
->glyphs
[area
] = frame_row
->glyphs
[area
];
2799 ++window_row
, ++frame_row
;
2804 /* Return the window in the window tree rooted in W containing frame
2805 row ROW. Value is null if none is found. */
2808 frame_row_to_window (w
, row
)
2812 struct window
*found
= NULL
;
2816 if (!NILP (w
->hchild
))
2817 found
= frame_row_to_window (XWINDOW (w
->hchild
), row
);
2818 else if (!NILP (w
->vchild
))
2819 found
= frame_row_to_window (XWINDOW (w
->vchild
), row
);
2820 else if (row
>= XFASTINT (w
->top
)
2821 && row
< XFASTINT (w
->top
) + XFASTINT (w
->height
))
2824 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2831 /* Perform a line dance in the window tree rooted at W, after
2832 scrolling a frame matrix in mirrored_line_dance.
2834 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
2835 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
2836 COPY_FROM is a vector containing, for each row I in the range 0 <=
2837 I < NLINES, the index of the original line to move to I. This
2838 index is relative to the row range, i.e. 0 <= index < NLINES.
2839 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
2843 mirror_line_dance (w
, unchanged_at_top
, nlines
, copy_from
, retained_p
)
2845 int unchanged_at_top
, nlines
;
2851 if (!NILP (w
->hchild
))
2852 mirror_line_dance (XWINDOW (w
->hchild
), unchanged_at_top
,
2853 nlines
, copy_from
, retained_p
);
2854 else if (!NILP (w
->vchild
))
2855 mirror_line_dance (XWINDOW (w
->vchild
), unchanged_at_top
,
2856 nlines
, copy_from
, retained_p
);
2859 /* W is a leaf window, and we are working on its current
2861 struct glyph_matrix
*m
= w
->current_matrix
;
2863 struct glyph_row
*old_rows
;
2865 /* Make a copy of the original rows of matrix m. */
2866 old_rows
= (struct glyph_row
*) alloca (m
->nrows
* sizeof *old_rows
);
2867 bcopy (m
->rows
, old_rows
, m
->nrows
* sizeof *old_rows
);
2869 for (i
= 0; i
< nlines
; ++i
)
2871 /* Frame relative line assigned to. */
2872 int frame_to
= i
+ unchanged_at_top
;
2874 /* Frame relative line assigned. */
2875 int frame_from
= copy_from
[i
] + unchanged_at_top
;
2877 /* Window relative line assigned to. */
2878 int window_to
= frame_to
- m
->matrix_y
;
2880 /* Window relative line assigned. */
2881 int window_from
= frame_from
- m
->matrix_y
;
2883 /* Is assigned line inside window? */
2884 int from_inside_window_p
2885 = window_from
>= 0 && window_from
< m
->matrix_h
;
2887 /* Is assigned to line inside window? */
2888 int to_inside_window_p
2889 = window_to
>= 0 && window_to
< m
->matrix_h
;
2891 if (from_inside_window_p
&& to_inside_window_p
)
2893 /* Enabled setting before assignment. */
2894 int enabled_before_p
;
2896 /* Do the assignment. The enabled_p flag is saved
2897 over the assignment because the old redisplay did
2899 enabled_before_p
= m
->rows
[window_to
].enabled_p
;
2900 m
->rows
[window_to
] = old_rows
[window_from
];
2901 m
->rows
[window_to
].enabled_p
= enabled_before_p
;
2903 /* If frame line is empty, window line is empty, too. */
2904 if (!retained_p
[copy_from
[i
]])
2905 m
->rows
[window_to
].enabled_p
= 0;
2907 else if (to_inside_window_p
)
2909 /* A copy between windows. This is an infrequent
2910 case not worth optimizing. */
2911 struct frame
*f
= XFRAME (w
->frame
);
2912 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
2914 struct glyph_matrix
*m2
;
2917 w2
= frame_row_to_window (root
, frame_to
);
2918 m2
= w2
->current_matrix
;
2919 m2_from
= frame_from
- m2
->matrix_y
;
2920 copy_row_except_pointers (m
->rows
+ window_to
,
2921 m2
->rows
+ m2_from
);
2923 /* If frame line is empty, window line is empty, too. */
2924 if (!retained_p
[copy_from
[i
]])
2925 m
->rows
[window_to
].enabled_p
= 0;
2928 else if (from_inside_window_p
)
2932 /* If there was a copy between windows, make sure glyph
2933 pointers are in sync with the frame matrix. */
2935 sync_window_with_frame_matrix_rows (w
);
2937 /* Check that no pointers are lost. */
2941 /* Next window on same level. */
2942 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2949 /* Check that window and frame matrices agree about their
2950 understanding where glyphs of the rows are to find. For each
2951 window in the window tree rooted at W, check that rows in the
2952 matrices of leaf window agree with their frame matrices about
2956 check_window_matrix_pointers (w
)
2961 if (!NILP (w
->hchild
))
2962 check_window_matrix_pointers (XWINDOW (w
->hchild
));
2963 else if (!NILP (w
->vchild
))
2964 check_window_matrix_pointers (XWINDOW (w
->vchild
));
2967 struct frame
*f
= XFRAME (w
->frame
);
2968 check_matrix_pointers (w
->desired_matrix
, f
->desired_matrix
);
2969 check_matrix_pointers (w
->current_matrix
, f
->current_matrix
);
2972 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2977 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
2978 a window and FRAME_MATRIX is the corresponding frame matrix. For
2979 each row in WINDOW_MATRIX check that it's a slice of the
2980 corresponding frame row. If it isn't, abort. */
2983 check_matrix_pointers (window_matrix
, frame_matrix
)
2984 struct glyph_matrix
*window_matrix
, *frame_matrix
;
2986 /* Row number in WINDOW_MATRIX. */
2989 /* Row number corresponding to I in FRAME_MATRIX. */
2990 int j
= window_matrix
->matrix_y
;
2992 /* For all rows check that the row in the window matrix is a
2993 slice of the row in the frame matrix. If it isn't we didn't
2994 mirror an operation on the frame matrix correctly. */
2995 while (i
< window_matrix
->nrows
)
2997 if (!glyph_row_slice_p (window_matrix
->rows
+ i
,
2998 frame_matrix
->rows
+ j
))
3004 #endif /* GLYPH_DEBUG != 0 */
3008 /**********************************************************************
3009 VPOS and HPOS translations
3010 **********************************************************************/
3014 /* Translate vertical position VPOS which is relative to window W to a
3015 vertical position relative to W's frame. */
3018 window_to_frame_vpos (w
, vpos
)
3022 struct frame
*f
= XFRAME (w
->frame
);
3024 xassert (!FRAME_WINDOW_P (f
));
3025 xassert (vpos
>= 0 && vpos
<= w
->desired_matrix
->nrows
);
3026 vpos
+= XFASTINT (w
->top
);
3027 xassert (vpos
>= 0 && vpos
<= FRAME_HEIGHT (f
));
3032 /* Translate horizontal position HPOS which is relative to window W to
3033 a vertical position relative to W's frame. */
3036 window_to_frame_hpos (w
, hpos
)
3040 struct frame
*f
= XFRAME (w
->frame
);
3042 xassert (!FRAME_WINDOW_P (f
));
3043 hpos
+= XFASTINT (w
->left
);
3047 #endif /* GLYPH_DEBUG */
3051 /**********************************************************************
3053 **********************************************************************/
3055 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
3056 "Clear frame FRAME and output again what is supposed to appear on it.")
3062 CHECK_LIVE_FRAME (frame
, 0);
3065 /* Ignore redraw requests, if frame has no glyphs yet.
3066 (Implementation note: It still has to be checked why we are
3067 called so early here). */
3068 if (!glyphs_initialized_initially_p
)
3072 if (FRAME_MSDOS_P (f
))
3073 set_terminal_modes ();
3075 clear_current_matrices (f
);
3078 windows_or_buffers_changed
++;
3079 /* Mark all windows as inaccurate, so that every window will have
3080 its redisplay done. */
3081 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
3082 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
3088 /* Redraw frame F. This is nothing more than a call to the Lisp
3089 function redraw-frame. */
3096 XSETFRAME (frame
, f
);
3097 Fredraw_frame (frame
);
3101 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
3102 "Clear and redisplay all visible frames.")
3105 Lisp_Object tail
, frame
;
3107 FOR_EACH_FRAME (tail
, frame
)
3108 if (FRAME_VISIBLE_P (XFRAME (frame
)))
3109 Fredraw_frame (frame
);
3115 /* This is used when frame_garbaged is set. Call Fredraw_frame on all
3116 visible frames marked as garbaged. */
3119 redraw_garbaged_frames ()
3121 Lisp_Object tail
, frame
;
3123 FOR_EACH_FRAME (tail
, frame
)
3124 if (FRAME_VISIBLE_P (XFRAME (frame
))
3125 && FRAME_GARBAGED_P (XFRAME (frame
)))
3126 Fredraw_frame (frame
);
3131 /***********************************************************************
3133 ***********************************************************************/
3135 /* Try to update display and current glyph matrix directly.
3137 This function is called after a character G has been inserted into
3138 current_buffer. It tries to update the current glyph matrix and
3139 perform appropriate screen output to reflect the insertion. If it
3140 succeeds, the global flag redisplay_performed_directly_p will be
3141 set to 1, and thereby prevent the more costly general redisplay
3142 from running (see redisplay_internal).
3144 This function is not called for `hairy' character insertions.
3145 In particular, it is not called when after or before change
3146 functions exist, like they are used by font-lock. See keyboard.c
3147 for details where this function is called. */
3150 direct_output_for_insert (g
)
3153 register struct frame
*f
= SELECTED_FRAME ();
3154 struct window
*w
= XWINDOW (selected_window
);
3156 struct glyph_row
*glyph_row
;
3157 struct glyph
*glyphs
, *glyph
, *end
;
3159 /* Non-null means that Redisplay of W is based on window matrices. */
3160 int window_redisplay_p
= FRAME_WINDOW_P (f
);
3161 /* Non-null means we are in overwrite mode. */
3162 int overwrite_p
= !NILP (current_buffer
->overwrite_mode
);
3164 struct text_pos pos
;
3165 int delta
, delta_bytes
;
3167 /* Not done directly. */
3168 redisplay_performed_directly_p
= 0;
3170 /* Quickly give up for some common cases. */
3171 if (cursor_in_echo_area
3172 /* Give up if fonts have changed. */
3174 /* Give up if face attributes have been changed. */
3175 || face_change_count
3176 /* Give up if cursor position not really known. */
3177 || !display_completed
3178 /* Give up if buffer appears in two places. */
3179 || buffer_shared
> 1
3180 /* Give up if w is mini-buffer and a message is being displayed there */
3181 || (MINI_WINDOW_P (w
) && !NILP (echo_area_buffer
[0]))
3182 /* Give up for hscrolled mini-buffer because display of the prompt
3183 is handled specially there (see display_line). */
3184 || (MINI_WINDOW_P (w
) && XFASTINT (w
->hscroll
))
3185 /* Give up if overwriting in the middle of a line. */
3188 && FETCH_BYTE (PT
) != '\n')
3189 /* Give up for tabs and line ends. */
3193 /* Give up if unable to display the cursor in the window. */
3194 || w
->cursor
.vpos
< 0
3195 || (glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
),
3196 /* Can't do it in a continued line because continuation
3197 lines would change. */
3198 (glyph_row
->continued_p
3199 /* Can't use this method if the line overlaps others or is
3200 overlapped by others because these other lines would
3201 have to be redisplayed. */
3202 || glyph_row
->overlapping_p
3203 || glyph_row
->overlapped_p
))
3204 /* Can't do it for partial width windows on terminal frames
3205 because we can't clear to eol in such a window. */
3206 || (!window_redisplay_p
&& !WINDOW_FULL_WIDTH_P (w
)))
3209 /* Set up a display iterator structure for W. Glyphs will be
3210 produced in scratch_glyph_row. Current position is W's cursor
3212 clear_glyph_row (&scratch_glyph_row
);
3213 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
3214 DEC_TEXT_POS (pos
, !NILP (current_buffer
->enable_multibyte_characters
));
3215 init_iterator (&it
, w
, CHARPOS (pos
), BYTEPOS (pos
), &scratch_glyph_row
,
3218 glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3219 if (glyph_row
->mouse_face_p
)
3222 /* Give up if highlighting trailing whitespace and we have trailing
3223 whitespace in glyph_row. We would have to remove the trailing
3224 whitespace face in that case. */
3225 if (!NILP (Vshow_trailing_whitespace
)
3226 && glyph_row
->used
[TEXT_AREA
])
3230 last
= glyph_row
->glyphs
[TEXT_AREA
] + glyph_row
->used
[TEXT_AREA
] - 1;
3231 if (last
->type
== STRETCH_GLYPH
3232 || (last
->type
== CHAR_GLYPH
3233 && last
->u
.ch
== ' '))
3237 /* Give up if there are overlay strings at pos. This would fail
3238 if the overlay string has newlines in it. */
3239 if (STRINGP (it
.string
))
3242 it
.hpos
= w
->cursor
.hpos
;
3243 it
.vpos
= w
->cursor
.vpos
;
3244 it
.current_x
= w
->cursor
.x
+ it
.first_visible_x
;
3245 it
.current_y
= w
->cursor
.y
;
3246 it
.end_charpos
= PT
;
3247 it
.stop_charpos
= min (PT
, it
.stop_charpos
);
3249 /* More than one display element may be returned for PT - 1 if
3250 (i) it's a control character which is translated into `\003' or
3251 `^C', or (ii) it has a display table entry, or (iii) it's a
3252 combination of both. */
3253 delta
= delta_bytes
= 0;
3254 while (get_next_display_element (&it
))
3256 PRODUCE_GLYPHS (&it
);
3258 /* Give up if glyph doesn't fit completely on the line. */
3259 if (it
.current_x
>= it
.last_visible_x
)
3262 /* Give up if new glyph has different ascent or descent than
3263 the original row, or if it is not a character glyph. */
3264 if (glyph_row
->ascent
!= it
.ascent
3265 || glyph_row
->height
!= it
.ascent
+ it
.descent
3266 || glyph_row
->phys_ascent
!= it
.phys_ascent
3267 || glyph_row
->phys_height
!= it
.phys_ascent
+ it
.phys_descent
3268 || it
.what
!= IT_CHARACTER
)
3272 delta_bytes
+= it
.len
;
3273 set_iterator_to_next (&it
, 1);
3276 /* Give up if we hit the right edge of the window. We would have
3277 to insert truncation or continuation glyphs. */
3278 added_width
= it
.current_x
- (w
->cursor
.x
+ it
.first_visible_x
);
3279 if (glyph_row
->pixel_width
+ added_width
>= it
.last_visible_x
)
3282 /* Give up if there is a \t following in the line. */
3284 it2
.end_charpos
= ZV
;
3285 it2
.stop_charpos
= min (it2
.stop_charpos
, ZV
);
3286 while (get_next_display_element (&it2
)
3287 && !ITERATOR_AT_END_OF_LINE_P (&it2
))
3291 set_iterator_to_next (&it2
, 1);
3294 /* Number of new glyphs produced. */
3295 n
= it
.glyph_row
->used
[TEXT_AREA
];
3297 /* Start and end of glyphs in original row. */
3298 glyphs
= glyph_row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
3299 end
= glyph_row
->glyphs
[1 + TEXT_AREA
];
3301 /* Make room for new glyphs, then insert them. */
3302 xassert (end
- glyphs
- n
>= 0);
3303 safe_bcopy ((char *) glyphs
, (char *) (glyphs
+ n
),
3304 (end
- glyphs
- n
) * sizeof (*end
));
3305 bcopy (it
.glyph_row
->glyphs
[TEXT_AREA
], glyphs
, n
* sizeof *glyphs
);
3306 glyph_row
->used
[TEXT_AREA
] = min (glyph_row
->used
[TEXT_AREA
] + n
,
3307 end
- glyph_row
->glyphs
[TEXT_AREA
]);
3309 /* Compute new line width. */
3310 glyph
= glyph_row
->glyphs
[TEXT_AREA
];
3311 end
= glyph
+ glyph_row
->used
[TEXT_AREA
];
3312 glyph_row
->pixel_width
= glyph_row
->x
;
3315 glyph_row
->pixel_width
+= glyph
->pixel_width
;
3319 /* Increment buffer positions for glyphs following the newly
3321 for (glyph
= glyphs
+ n
; glyph
< end
; ++glyph
)
3322 if (glyph
->charpos
> 0 && BUFFERP (glyph
->object
))
3323 glyph
->charpos
+= delta
;
3325 if (MATRIX_ROW_END_CHARPOS (glyph_row
) > 0)
3327 MATRIX_ROW_END_CHARPOS (glyph_row
) += delta
;
3328 MATRIX_ROW_END_BYTEPOS (glyph_row
) += delta_bytes
;
3331 /* Adjust positions in lines following the one we are in. */
3332 increment_matrix_positions (w
->current_matrix
,
3334 w
->current_matrix
->nrows
,
3335 delta
, delta_bytes
);
3337 glyph_row
->contains_overlapping_glyphs_p
3338 |= it
.glyph_row
->contains_overlapping_glyphs_p
;
3340 glyph_row
->displays_text_p
= 1;
3341 w
->window_end_vpos
= make_number (max (w
->cursor
.vpos
,
3342 XFASTINT (w
->window_end_vpos
)));
3344 if (!NILP (Vshow_trailing_whitespace
))
3345 highlight_trailing_whitespace (it
.f
, glyph_row
);
3347 /* Write glyphs. If at end of row, we can simply call write_glyphs.
3348 In the middle, we have to insert glyphs. Note that this is now
3349 implemented for X frames. The implementation uses updated_window
3351 updated_row
= glyph_row
;
3355 rif
->update_window_begin_hook (w
);
3357 if (glyphs
== end
- n
)
3358 rif
->write_glyphs (glyphs
, n
);
3360 rif
->insert_glyphs (glyphs
, n
);
3364 if (glyphs
== end
- n
)
3365 write_glyphs (glyphs
, n
);
3367 insert_glyphs (glyphs
, n
);
3370 w
->cursor
.hpos
+= n
;
3371 w
->cursor
.x
= it
.current_x
- it
.first_visible_x
;
3372 xassert (w
->cursor
.hpos
>= 0
3373 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3375 /* How to set the cursor differs depending on whether we are
3376 using a frame matrix or a window matrix. Note that when
3377 a frame matrix is used, cursor_to expects frame coordinates,
3378 and the X and Y parameters are not used. */
3379 if (window_redisplay_p
)
3380 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3381 w
->cursor
.y
, w
->cursor
.x
);
3385 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3386 + (INTEGERP (w
->left_margin_width
)
3387 ? XFASTINT (w
->left_margin_width
)
3389 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3394 rif
->update_window_end_hook (w
, 1, 0);
3399 TRACE ((stderr
, "direct output for insert\n"));
3401 UNCHANGED_MODIFIED
= MODIFF
;
3402 BEG_UNCHANGED
= GPT
- BEG
;
3403 XSETFASTINT (w
->last_point
, PT
);
3404 w
->last_cursor
= w
->cursor
;
3405 XSETFASTINT (w
->last_modified
, MODIFF
);
3406 XSETFASTINT (w
->last_overlay_modified
, OVERLAY_MODIFF
);
3408 redisplay_performed_directly_p
= 1;
3413 /* Perform a direct display update for moving PT by N positions
3414 left or right. N < 0 means a movement backwards. This function
3415 is currently only called for N == 1 or N == -1. */
3418 direct_output_forward_char (n
)
3421 struct frame
*f
= SELECTED_FRAME ();
3422 struct window
*w
= XWINDOW (selected_window
);
3423 struct glyph_row
*row
;
3425 /* Give up if point moved out of or into a composition. */
3426 if (check_point_in_composition (current_buffer
, XINT (w
->last_point
),
3427 current_buffer
, PT
))
3430 /* Give up if face attributes have been changed. */
3431 if (face_change_count
)
3434 /* Give up if current matrix is not up to date or we are
3435 displaying a message. */
3436 if (!display_completed
|| cursor_in_echo_area
)
3439 /* Give up if the buffer's direction is reversed. */
3440 if (!NILP (XBUFFER (w
->buffer
)->direction_reversed
))
3443 /* Can't use direct output if highlighting a region. */
3444 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
3447 /* Can't use direct output if highlighting trailing whitespace. */
3448 if (!NILP (Vshow_trailing_whitespace
))
3451 /* Give up if we are showing a message or just cleared the message
3452 because we might need to resize the echo area window. */
3453 if (!NILP (echo_area_buffer
[0]) || !NILP (echo_area_buffer
[1]))
3456 /* Give up if currently displaying a message instead of the
3457 minibuffer contents. */
3458 if (XWINDOW (minibuf_window
) == w
3459 && EQ (minibuf_window
, echo_area_window
))
3462 /* Give up if we don't know where the cursor is. */
3463 if (w
->cursor
.vpos
< 0)
3466 row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3468 /* Give up if PT is outside of the last known cursor row. */
3469 if (PT
<= MATRIX_ROW_START_BYTEPOS (row
)
3470 || PT
>= MATRIX_ROW_END_BYTEPOS (row
))
3473 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
3475 w
->last_cursor
= w
->cursor
;
3476 XSETFASTINT (w
->last_point
, PT
);
3478 xassert (w
->cursor
.hpos
>= 0
3479 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3481 if (FRAME_WINDOW_P (f
))
3482 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3483 w
->cursor
.y
, w
->cursor
.x
);
3487 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3488 + (INTEGERP (w
->left_margin_width
)
3489 ? XFASTINT (w
->left_margin_width
)
3491 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3496 redisplay_performed_directly_p
= 1;
3502 /***********************************************************************
3504 ***********************************************************************/
3506 /* Update frame F based on the data in desired matrices.
3508 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3509 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3512 Value is non-zero if redisplay was stopped due to pending input. */
3515 update_frame (f
, force_p
, inhibit_hairy_id_p
)
3518 int inhibit_hairy_id_p
;
3520 /* 1 means display has been paused because of pending input. */
3522 struct window
*root_window
= XWINDOW (f
->root_window
);
3524 if (FRAME_WINDOW_P (f
))
3526 /* We are working on window matrix basis. All windows whose
3527 flag must_be_updated_p is set have to be updated. */
3529 /* Record that we are not working on frame matrices. */
3530 set_frame_matrix_frame (NULL
);
3532 /* Update all windows in the window tree of F, maybe stopping
3533 when pending input is detected. */
3536 /* Update the menu bar on X frames that don't have toolkit
3538 if (WINDOWP (f
->menu_bar_window
))
3539 update_window (XWINDOW (f
->menu_bar_window
), 1);
3541 /* Update the tool-bar window, if present. */
3542 if (WINDOWP (f
->tool_bar_window
))
3545 struct window
*w
= XWINDOW (f
->tool_bar_window
);
3547 /* Update tool-bar window. */
3548 if (w
->must_be_updated_p
)
3550 update_window (w
, 1);
3551 w
->must_be_updated_p
= 0;
3553 /* Swap tool-bar strings. We swap because we want to
3555 tem
= f
->current_tool_bar_string
;
3556 f
->current_tool_bar_string
= f
->desired_tool_bar_string
;
3557 f
->desired_tool_bar_string
= tem
;
3562 /* Update windows. */
3563 paused_p
= update_window_tree (root_window
, force_p
);
3566 #if 0 /* This flush is a performance bottleneck under X,
3567 and it doesn't seem to be necessary anyway. */
3568 rif
->flush_display (f
);
3573 /* We are working on frame matrix basis. Set the frame on whose
3574 frame matrix we operate. */
3575 set_frame_matrix_frame (f
);
3577 /* Build F's desired matrix from window matrices. */
3578 build_frame_matrix (f
);
3580 /* Update the display */
3582 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3586 fflush (termscript
);
3589 /* Check window matrices for lost pointers. */
3590 IF_DEBUG (check_window_matrix_pointers (root_window
));
3593 /* Reset flags indicating that a window should be updated. */
3594 set_window_update_flags (root_window
, 0);
3596 display_completed
= !paused_p
;
3602 /************************************************************************
3603 Window-based updates
3604 ************************************************************************/
3606 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3607 don't stop updating when input is pending. */
3610 update_window_tree (w
, force_p
)
3616 while (w
&& !paused_p
)
3618 if (!NILP (w
->hchild
))
3619 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
3620 else if (!NILP (w
->vchild
))
3621 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
3622 else if (w
->must_be_updated_p
)
3623 paused_p
|= update_window (w
, force_p
);
3625 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3632 /* Update window W if its flag must_be_updated_p is non-zero. If
3633 FORCE_P is non-zero, don't stop updating if input is pending. */
3636 update_single_window (w
, force_p
)
3640 if (w
->must_be_updated_p
)
3642 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3644 /* Record that this is not a frame-based redisplay. */
3645 set_frame_matrix_frame (NULL
);
3649 update_window (w
, force_p
);
3652 /* Reset flag in W. */
3653 w
->must_be_updated_p
= 0;
3658 /* Redraw lines from the current matrix of window W that are
3659 overlapped by other rows. YB is bottom-most y-position in W. */
3662 redraw_overlapped_rows (w
, yb
)
3668 /* If rows overlapping others have been changed, the rows being
3669 overlapped have to be redrawn. This won't draw lines that have
3670 already been drawn in update_window_line because overlapped_p in
3671 desired rows is 0, so after row assignment overlapped_p in
3672 current rows is 0. */
3673 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3675 struct glyph_row
*row
= w
->current_matrix
->rows
+ i
;
3677 if (!row
->enabled_p
)
3679 else if (row
->mode_line_p
)
3682 if (row
->overlapped_p
)
3684 enum glyph_row_area area
;
3686 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3689 updated_area
= area
;
3690 rif
->cursor_to (i
, 0, row
->y
, area
== TEXT_AREA
? row
->x
: 0);
3691 if (row
->used
[area
])
3692 rif
->write_glyphs (row
->glyphs
[area
], row
->used
[area
]);
3693 rif
->clear_end_of_line (-1);
3696 row
->overlapped_p
= 0;
3699 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3705 /* Redraw lines from the current matrix of window W that overlap
3706 others. YB is bottom-most y-position in W. */
3709 redraw_overlapping_rows (w
, yb
)
3714 struct glyph_row
*row
;
3716 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3718 row
= w
->current_matrix
->rows
+ i
;
3720 if (!row
->enabled_p
)
3722 else if (row
->mode_line_p
)
3725 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3727 if (row
->overlapping_p
&& i
> 0 && bottom_y
< yb
)
3729 if (row
->used
[LEFT_MARGIN_AREA
])
3730 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
);
3732 if (row
->used
[TEXT_AREA
])
3733 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
);
3735 if (row
->used
[RIGHT_MARGIN_AREA
])
3736 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
);
3738 /* Record in neighbor rows that ROW overwrites part of their
3740 if (row
->phys_ascent
> row
->ascent
&& i
> 0)
3741 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3742 if ((row
->phys_height
- row
->phys_ascent
3743 > row
->height
- row
->ascent
)
3745 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
3754 /* Update display of window W. FORCE_P non-zero means that we should
3755 not stop when detecting pending input. */
3758 update_window (w
, force_p
)
3762 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
3764 int preempt_count
= baud_rate
/ 2400 + 1;
3765 extern int input_pending
;
3767 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3768 extern struct frame
*updating_frame
;
3771 /* Check that W's frame doesn't have glyph matrices. */
3772 xassert (FRAME_WINDOW_P (f
));
3773 xassert (updating_frame
!= NULL
);
3775 /* Check pending input the first time so that we can quickly return. */
3776 if (redisplay_dont_pause
)
3779 detect_input_pending ();
3781 /* If forced to complete the update, or if no input is pending, do
3783 if (force_p
|| !input_pending
)
3785 struct glyph_row
*row
, *end
;
3786 struct glyph_row
*mode_line_row
;
3787 struct glyph_row
*header_line_row
= NULL
;
3788 int yb
, changed_p
= 0, mouse_face_overwritten_p
= 0;
3790 rif
->update_window_begin_hook (w
);
3791 yb
= window_text_bottom_y (w
);
3793 /* If window has a top line, update it before everything else.
3794 Adjust y-positions of other rows by the top line height. */
3795 row
= desired_matrix
->rows
;
3796 end
= row
+ desired_matrix
->nrows
- 1;
3797 if (row
->mode_line_p
)
3798 header_line_row
= row
++;
3800 /* Update the mode line, if necessary. */
3801 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3802 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
3804 mode_line_row
->y
= yb
;
3805 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
3807 &mouse_face_overwritten_p
);
3811 /* Find first enabled row. Optimizations in redisplay_internal
3812 may lead to an update with only one row enabled. There may
3813 be also completely empty matrices. */
3814 while (row
< end
&& !row
->enabled_p
)
3817 /* Try reusing part of the display by copying. */
3818 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
3820 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
3823 /* All rows were found to be equal. */
3832 /* Update the top mode line after scrolling because a new top
3833 line would otherwise overwrite lines at the top of the window
3834 that can be scrolled. */
3835 if (header_line_row
&& header_line_row
->enabled_p
)
3837 header_line_row
->y
= 0;
3838 update_window_line (w
, 0, &mouse_face_overwritten_p
);
3842 /* Update the rest of the lines. */
3843 for (; row
< end
&& (force_p
|| !input_pending
); ++row
)
3846 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
3849 /* We'll Have to play a little bit with when to
3850 detect_input_pending. If it's done too often,
3851 scrolling large windows with repeated scroll-up
3852 commands will too quickly pause redisplay. */
3853 if (!force_p
&& vpos
% preempt_count
== 0)
3854 detect_input_pending ();
3856 changed_p
|= update_window_line (w
, vpos
,
3857 &mouse_face_overwritten_p
);
3859 /* Mark all rows below the last visible one in the current
3860 matrix as invalid. This is necessary because of
3861 variable line heights. Consider the case of three
3862 successive redisplays, where the first displays 5
3863 lines, the second 3 lines, and the third 5 lines again.
3864 If the second redisplay wouldn't mark rows in the
3865 current matrix invalid, the third redisplay might be
3866 tempted to optimize redisplay based on lines displayed
3867 in the first redisplay. */
3868 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3869 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
3870 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
3873 /* Was display preempted? */
3874 paused_p
= row
< end
;
3878 /* Fix the appearance of overlapping(overlapped rows. */
3879 if (!paused_p
&& !w
->pseudo_window_p
)
3881 if (changed_p
&& rif
->fix_overlapping_area
)
3883 redraw_overlapped_rows (w
, yb
);
3884 redraw_overlapping_rows (w
, yb
);
3887 /* Make cursor visible at cursor position of W. */
3888 set_window_cursor_after_update (w
);
3890 #if 0 /* Check that current matrix invariants are satisfied. This is
3891 for debugging only. See the comment of check_matrix_invariants. */
3892 IF_DEBUG (check_matrix_invariants (w
));
3897 /* Remember the redisplay method used to display the matrix. */
3898 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
3901 /* End of update of window W. */
3902 rif
->update_window_end_hook (w
, 1, mouse_face_overwritten_p
);
3907 clear_glyph_matrix (desired_matrix
);
3913 /* Update the display of area AREA in window W, row number VPOS.
3914 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3917 update_marginal_area (w
, area
, vpos
)
3921 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3923 /* Let functions in xterm.c know what area subsequent X positions
3924 will be relative to. */
3925 updated_area
= area
;
3927 /* Set cursor to start of glyphs, write them, and clear to the end
3928 of the area. I don't think that something more sophisticated is
3929 necessary here, since marginal areas will not be the default. */
3930 rif
->cursor_to (vpos
, 0, desired_row
->y
, 0);
3931 if (desired_row
->used
[area
])
3932 rif
->write_glyphs (desired_row
->glyphs
[area
], desired_row
->used
[area
]);
3933 rif
->clear_end_of_line (-1);
3937 /* Update the display of the text area of row VPOS in window W.
3938 Value is non-zero if display has changed. */
3941 update_text_area (w
, vpos
)
3945 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3946 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3949 /* Let functions in xterm.c know what area subsequent X positions
3950 will be relative to. */
3951 updated_area
= TEXT_AREA
;
3953 /* If rows are at different X or Y, or rows have different height,
3954 or the current row is marked invalid, write the entire line. */
3955 if (!current_row
->enabled_p
3956 || desired_row
->y
!= current_row
->y
3957 || desired_row
->ascent
!= current_row
->ascent
3958 || desired_row
->phys_ascent
!= current_row
->phys_ascent
3959 || desired_row
->phys_height
!= current_row
->phys_height
3960 || desired_row
->visible_height
!= current_row
->visible_height
3961 || current_row
->overlapped_p
3962 || current_row
->mouse_face_p
3963 || current_row
->x
!= desired_row
->x
)
3965 rif
->cursor_to (vpos
, 0, desired_row
->y
, desired_row
->x
);
3967 if (desired_row
->used
[TEXT_AREA
])
3968 rif
->write_glyphs (desired_row
->glyphs
[TEXT_AREA
],
3969 desired_row
->used
[TEXT_AREA
]);
3971 /* Clear to end of window. */
3972 rif
->clear_end_of_line (-1);
3978 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
3979 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
3980 int overlapping_glyphs_p
= current_row
->contains_overlapping_glyphs_p
;
3982 /* If the desired row extends its face to the text area end,
3983 make sure we write at least one glyph, so that the face
3984 extension actually takes place. */
3985 int desired_stop_pos
= (desired_row
->used
[TEXT_AREA
]
3986 - (MATRIX_ROW_EXTENDS_FACE_P (desired_row
)
3989 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
3997 /* Skip over glyphs that both rows have in common. These
3998 don't have to be written. We can't skip if the last
3999 current glyph overlaps the glyph to its right. For
4000 example, consider a current row of `if ' with the `f' in
4001 Courier bold so that it overlaps the ` ' to its right.
4002 If the desired row is ` ', we would skip over the space
4003 after the `if' and there would remain a pixel from the
4004 `f' on the screen. */
4005 if (overlapping_glyphs_p
&& i
> 0)
4007 struct glyph
*glyph
= ¤t_row
->glyphs
[TEXT_AREA
][i
- 1];
4010 rif
->get_glyph_overhangs (glyph
, XFRAME (w
->frame
),
4012 can_skip_p
= right
== 0;
4018 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
4020 x
+= desired_glyph
->pixel_width
;
4021 ++desired_glyph
, ++current_glyph
, ++i
;
4024 /* Consider the case that the current row contains "xxx
4025 ppp ggg" in italic Courier font, and the desired row
4026 is "xxx ggg". The character `p' has lbearing, `g'
4027 has not. The loop above will stop in front of the
4028 first `p' in the current row. If we would start
4029 writing glyphs there, we wouldn't erase the lbearing
4030 of the `p'. The rest of the lbearing problem is then
4031 taken care of by x_draw_glyphs. */
4032 if (overlapping_glyphs_p
4034 && i
< current_row
->used
[TEXT_AREA
]
4035 && (current_row
->used
[TEXT_AREA
]
4036 != desired_row
->used
[TEXT_AREA
]))
4040 rif
->get_glyph_overhangs (current_glyph
, XFRAME (w
->frame
),
4042 while (left
> 0 && i
> 0)
4044 --i
, --desired_glyph
, --current_glyph
;
4045 x
-= desired_glyph
->pixel_width
;
4046 left
-= desired_glyph
->pixel_width
;
4051 /* Try to avoid writing the entire rest of the desired row
4052 by looking for a resync point. This mainly prevents
4053 mode line flickering in the case the mode line is in
4054 fixed-pitch font, which it usually will be. */
4055 if (i
< desired_row
->used
[TEXT_AREA
])
4057 int start_x
= x
, start_hpos
= i
;
4058 struct glyph
*start
= desired_glyph
;
4060 int skip_first_p
= !can_skip_p
;
4062 /* Find the next glyph that's equal again. */
4065 || !GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
4068 x
+= desired_glyph
->pixel_width
;
4069 current_x
+= current_glyph
->pixel_width
;
4070 ++desired_glyph
, ++current_glyph
, ++i
;
4074 if (i
== start_hpos
|| x
!= current_x
)
4078 desired_glyph
= start
;
4082 rif
->cursor_to (vpos
, start_hpos
, desired_row
->y
, start_x
);
4083 rif
->write_glyphs (start
, i
- start_hpos
);
4088 /* Write the rest. */
4089 if (i
< desired_row
->used
[TEXT_AREA
])
4091 rif
->cursor_to (vpos
, i
, desired_row
->y
, x
);
4092 rif
->write_glyphs (desired_glyph
, desired_row
->used
[TEXT_AREA
] - i
);
4096 /* Maybe clear to end of line. */
4097 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
4099 /* If new row extends to the end of the text area, nothing
4100 has to be cleared, if and only if we did a write_glyphs
4101 above. This is made sure by setting desired_stop_pos
4102 appropriately above. */
4103 xassert (i
< desired_row
->used
[TEXT_AREA
]);
4105 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
4107 /* If old row extends to the end of the text area, clear. */
4108 if (i
>= desired_row
->used
[TEXT_AREA
])
4109 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4110 desired_row
->x
+ desired_row
->pixel_width
);
4111 rif
->clear_end_of_line (-1);
4114 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
4116 /* Otherwise clear to the end of the old row. Everything
4117 after that position should be clear already. */
4120 if (i
>= desired_row
->used
[TEXT_AREA
])
4121 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4122 desired_row
->x
+ desired_row
->pixel_width
);
4124 /* If cursor is displayed at the end of the line, make sure
4125 it's cleared. Nowadays we don't have a phys_cursor_glyph
4126 with which to erase the cursor (because this method
4127 doesn't work with lbearing/rbearing), so we must do it
4129 if (vpos
== w
->phys_cursor
.vpos
4130 && w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])
4132 w
->phys_cursor_on_p
= 0;
4136 x
= current_row
->x
+ current_row
->pixel_width
;
4137 rif
->clear_end_of_line (x
);
4146 /* Update row VPOS in window W. Value is non-zero if display has been
4150 update_window_line (w
, vpos
, mouse_face_overwritten_p
)
4152 int vpos
, *mouse_face_overwritten_p
;
4154 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
4155 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
4158 /* Set the row being updated. This is important to let xterm.c
4159 know what line height values are in effect. */
4160 updated_row
= desired_row
;
4162 /* A row can be completely invisible in case a desired matrix was
4163 built with a vscroll and then make_cursor_line_fully_visible shifts
4164 the matrix. Make sure to make such rows current anyway, since
4165 we need the correct y-position, for example, in the current matrix. */
4166 if (desired_row
->mode_line_p
4167 || desired_row
->visible_height
> 0)
4169 xassert (desired_row
->enabled_p
);
4171 /* Update display of the left margin area, if there is one. */
4172 if (!desired_row
->full_width_p
4173 && !NILP (w
->left_margin_width
))
4176 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
4179 /* Update the display of the text area. */
4180 if (update_text_area (w
, vpos
))
4183 if (current_row
->mouse_face_p
)
4184 *mouse_face_overwritten_p
= 1;
4187 /* Update display of the right margin area, if there is one. */
4188 if (!desired_row
->full_width_p
4189 && !NILP (w
->right_margin_width
))
4192 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
4195 /* Draw truncation marks etc. */
4196 if (!current_row
->enabled_p
4197 || desired_row
->y
!= current_row
->y
4198 || desired_row
->visible_height
!= current_row
->visible_height
4199 || desired_row
->overlay_arrow_p
!= current_row
->overlay_arrow_p
4200 || desired_row
->truncated_on_left_p
!= current_row
->truncated_on_left_p
4201 || desired_row
->truncated_on_right_p
!= current_row
->truncated_on_right_p
4202 || desired_row
->continued_p
!= current_row
->continued_p
4203 || desired_row
->mode_line_p
!= current_row
->mode_line_p
4204 || (desired_row
->indicate_empty_line_p
4205 != current_row
->indicate_empty_line_p
)
4206 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
4207 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
4208 rif
->after_update_window_line_hook (desired_row
);
4211 /* Update current_row from desired_row. */
4212 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4218 /* Set the cursor after an update of window W. This function may only
4219 be called from update_window. */
4222 set_window_cursor_after_update (w
)
4225 struct frame
*f
= XFRAME (w
->frame
);
4226 int cx
, cy
, vpos
, hpos
;
4228 /* Not intended for frame matrix updates. */
4229 xassert (FRAME_WINDOW_P (f
));
4231 if (cursor_in_echo_area
4232 && !NILP (echo_area_buffer
[0])
4233 /* If we are showing a message instead of the mini-buffer,
4234 show the cursor for the message instead. */
4235 && XWINDOW (minibuf_window
) == w
4236 && EQ (minibuf_window
, echo_area_window
)
4237 /* These cases apply only to the frame that contains
4238 the active mini-buffer window. */
4239 && FRAME_HAS_MINIBUF_P (f
)
4240 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4242 cx
= cy
= vpos
= hpos
= 0;
4244 if (cursor_in_echo_area
>= 0)
4246 /* If the mini-buffer is several lines high, find the last
4247 line that has any text on it. Note: either all lines
4248 are enabled or none. Otherwise we wouldn't be able to
4250 struct glyph_row
*row
, *last_row
;
4251 struct glyph
*glyph
;
4252 int yb
= window_text_bottom_y (w
);
4255 for (row
= MATRIX_ROW (w
->current_matrix
, 0);
4259 if (row
->used
[TEXT_AREA
]
4260 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4263 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4269 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
4270 struct glyph
*last
= start
+ row
->used
[TEXT_AREA
] - 1;
4272 while (last
> start
&& last
->charpos
< 0)
4275 for (glyph
= start
; glyph
< last
; ++glyph
)
4277 cx
+= glyph
->pixel_width
;
4282 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4290 hpos
= w
->cursor
.hpos
;
4291 vpos
= w
->cursor
.vpos
;
4294 /* Window cursor can be out of sync for horizontally split windows. */
4295 hpos
= max (0, hpos
);
4296 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4297 vpos
= max (0, vpos
);
4298 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4299 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4303 /* Set WINDOW->must_be_updated_p to ON_P for all windows in the window
4304 tree rooted at W. */
4307 set_window_update_flags (w
, on_p
)
4313 if (!NILP (w
->hchild
))
4314 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4315 else if (!NILP (w
->vchild
))
4316 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4318 w
->must_be_updated_p
= on_p
;
4320 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4326 /***********************************************************************
4327 Window-Based Scrolling
4328 ***********************************************************************/
4330 /* Structure describing rows in scrolling_window. */
4334 /* Number of occurrences of this row in desired and current matrix. */
4335 int old_uses
, new_uses
;
4337 /* Vpos of row in new matrix. */
4338 int new_line_number
;
4340 /* Bucket index of this row_entry in the hash table row_table. */
4343 /* The row described by this entry. */
4344 struct glyph_row
*row
;
4346 /* Hash collision chain. */
4347 struct row_entry
*next
;
4350 /* A pool to allocate row_entry structures from, and the size of the
4351 pool. The pool is reallocated in scrolling_window when we find
4352 that we need a larger one. */
4354 static struct row_entry
*row_entry_pool
;
4355 static int row_entry_pool_size
;
4357 /* Index of next free entry in row_entry_pool. */
4359 static int row_entry_idx
;
4361 /* The hash table used during scrolling, and the table's size. This
4362 table is used to quickly identify equal rows in the desired and
4365 static struct row_entry
**row_table
;
4366 static int row_table_size
;
4368 /* Vectors of pointers to row_entry structures belonging to the
4369 current and desired matrix, and the size of the vectors. */
4371 static struct row_entry
**old_lines
, **new_lines
;
4372 static int old_lines_size
, new_lines_size
;
4374 /* A pool to allocate run structures from, and its size. */
4376 static struct run
*run_pool
;
4377 static int runs_size
;
4379 /* A vector of runs of lines found during scrolling. */
4381 static struct run
**runs
;
4383 static struct row_entry
*add_row_entry
P_ ((struct window
*,
4384 struct glyph_row
*));
4387 /* Add glyph row ROW to the scrolling hash table during the scrolling
4390 static INLINE
struct row_entry
*
4391 add_row_entry (w
, row
)
4393 struct glyph_row
*row
;
4395 struct row_entry
*entry
;
4396 int i
= row
->hash
% row_table_size
;
4398 entry
= row_table
[i
];
4399 while (entry
&& !row_equal_p (w
, entry
->row
, row
, 1))
4400 entry
= entry
->next
;
4404 entry
= row_entry_pool
+ row_entry_idx
++;
4406 entry
->old_uses
= entry
->new_uses
= 0;
4407 entry
->new_line_number
= 0;
4409 entry
->next
= row_table
[i
];
4410 row_table
[i
] = entry
;
4417 /* Try to reuse part of the current display of W by scrolling lines.
4418 HEADER_LINE_P non-zero means W has a top mode line.
4420 The algorithm is taken from Communications of the ACM, Apr78 "A
4421 Technique for Isolating Differences Between Files." It should take
4424 A short outline of the steps of the algorithm
4426 1. Skip lines equal at the start and end of both matrices.
4428 2. Enter rows in the current and desired matrix into a symbol
4429 table, counting how often they appear in both matrices.
4431 3. Rows that appear exactly once in both matrices serve as anchors,
4432 i.e. we assume that such lines are likely to have been moved.
4434 4. Starting from anchor lines, extend regions to be scrolled both
4435 forward and backward.
4439 -1 if all rows were found to be equal.
4440 0 to indicate that we did not scroll the display, or
4441 1 if we did scroll. */
4444 scrolling_window (w
, header_line_p
)
4448 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4449 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4450 int yb
= window_text_bottom_y (w
);
4451 int i
, j
, first_old
, first_new
, last_old
, last_new
;
4452 int nruns
, nbytes
, n
, run_idx
;
4453 struct row_entry
*entry
;
4455 /* Skip over rows equal at the start. */
4456 for (i
= header_line_p
? 1 : 0; i
< current_matrix
->nrows
- 1; ++i
)
4458 struct glyph_row
*d
= MATRIX_ROW (desired_matrix
, i
);
4459 struct glyph_row
*c
= MATRIX_ROW (current_matrix
, i
);
4464 && MATRIX_ROW_BOTTOM_Y (c
) <= yb
4465 && MATRIX_ROW_BOTTOM_Y (d
) <= yb
4466 && row_equal_p (w
, c
, d
, 1))
4475 /* Give up if some rows in the desired matrix are not enabled. */
4476 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4479 first_old
= first_new
= i
;
4481 /* Set last_new to the index + 1 of the last enabled row in the
4484 while (i
< desired_matrix
->nrows
- 1
4485 && MATRIX_ROW (desired_matrix
, i
)->enabled_p
4486 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) <= yb
)
4489 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4494 /* Set last_old to the index + 1 of the last enabled row in the
4495 current matrix. We don't look at the enabled flag here because
4496 we plan to reuse part of the display even if other parts are
4499 while (i
< current_matrix
->nrows
- 1
4500 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) <= yb
)
4504 /* Skip over rows equal at the bottom. */
4507 while (i
- 1 > first_new
4508 && j
- 1 > first_old
4509 && MATRIX_ROW (current_matrix
, i
- 1)->enabled_p
4510 && (MATRIX_ROW (current_matrix
, i
- 1)->y
4511 == MATRIX_ROW (desired_matrix
, j
- 1)->y
)
4513 MATRIX_ROW (desired_matrix
, i
- 1),
4514 MATRIX_ROW (current_matrix
, j
- 1), 1))
4519 /* Nothing to do if all rows are equal. */
4520 if (last_new
== first_new
)
4523 /* Reallocate vectors, tables etc. if necessary. */
4525 if (current_matrix
->nrows
> old_lines_size
)
4527 old_lines_size
= current_matrix
->nrows
;
4528 nbytes
= old_lines_size
* sizeof *old_lines
;
4529 old_lines
= (struct row_entry
**) xrealloc (old_lines
, nbytes
);
4532 if (desired_matrix
->nrows
> new_lines_size
)
4534 new_lines_size
= desired_matrix
->nrows
;
4535 nbytes
= new_lines_size
* sizeof *new_lines
;
4536 new_lines
= (struct row_entry
**) xrealloc (new_lines
, nbytes
);
4539 n
= desired_matrix
->nrows
+ current_matrix
->nrows
;
4540 if (3 * n
> row_table_size
)
4542 row_table_size
= next_almost_prime (3 * n
);
4543 nbytes
= row_table_size
* sizeof *row_table
;
4544 row_table
= (struct row_entry
**) xrealloc (row_table
, nbytes
);
4545 bzero (row_table
, nbytes
);
4548 if (n
> row_entry_pool_size
)
4550 row_entry_pool_size
= n
;
4551 nbytes
= row_entry_pool_size
* sizeof *row_entry_pool
;
4552 row_entry_pool
= (struct row_entry
*) xrealloc (row_entry_pool
, nbytes
);
4555 if (desired_matrix
->nrows
> runs_size
)
4557 runs_size
= desired_matrix
->nrows
;
4558 nbytes
= runs_size
* sizeof *runs
;
4559 runs
= (struct run
**) xrealloc (runs
, nbytes
);
4560 nbytes
= runs_size
* sizeof *run_pool
;
4561 run_pool
= (struct run
*) xrealloc (run_pool
, nbytes
);
4564 nruns
= run_idx
= 0;
4567 /* Add rows from the current and desired matrix to the hash table
4568 row_hash_table to be able to find equal ones quickly. */
4570 for (i
= first_old
; i
< last_old
; ++i
)
4572 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4574 entry
= add_row_entry (w
, MATRIX_ROW (current_matrix
, i
));
4575 old_lines
[i
] = entry
;
4579 old_lines
[i
] = NULL
;
4582 for (i
= first_new
; i
< last_new
; ++i
)
4584 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4585 entry
= add_row_entry (w
, MATRIX_ROW (desired_matrix
, i
));
4587 entry
->new_line_number
= i
;
4588 new_lines
[i
] = entry
;
4591 /* Identify moves based on lines that are unique and equal
4592 in both matrices. */
4593 for (i
= first_old
; i
< last_old
;)
4595 && old_lines
[i
]->old_uses
== 1
4596 && old_lines
[i
]->new_uses
== 1)
4599 int new_line
= old_lines
[i
]->new_line_number
;
4600 struct run
*run
= run_pool
+ run_idx
++;
4603 run
->current_vpos
= i
;
4604 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4605 run
->desired_vpos
= new_line
;
4606 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4608 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4610 /* Extend backward. */
4613 while (j
> first_old
4615 && old_lines
[j
] == new_lines
[k
])
4617 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4618 --run
->current_vpos
;
4619 --run
->desired_vpos
;
4622 run
->desired_y
-= h
;
4623 run
->current_y
-= h
;
4627 /* Extend forward. */
4632 && old_lines
[j
] == new_lines
[k
])
4634 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4640 /* Insert run into list of all runs. Order runs by copied
4641 pixel lines. Note that we record runs that don't have to
4642 be copied because they are already in place. This is done
4643 because we can avoid calling update_window_line in this
4645 for (j
= 0; j
< nruns
&& runs
[j
]->height
> run
->height
; ++j
)
4647 for (k
= nruns
; k
> j
; --k
)
4648 runs
[k
] = runs
[k
- 1];
4657 /* Do the moves. Do it in a way that we don't overwrite something
4658 we want to copy later on. This is not solvable in general
4659 because there is only one display and we don't have a way to
4660 exchange areas on this display. Example:
4662 +-----------+ +-----------+
4664 +-----------+ --> +-----------+
4666 +-----------+ +-----------+
4668 Instead, prefer bigger moves, and invalidate moves that would
4669 copy from where we copied to. */
4671 for (i
= 0; i
< nruns
; ++i
)
4672 if (runs
[i
]->nrows
> 0)
4674 struct run
*r
= runs
[i
];
4676 /* Copy on the display. */
4677 if (r
->current_y
!= r
->desired_y
)
4679 rif
->scroll_run_hook (w
, r
);
4681 /* Invalidate runs that copy from where we copied to. */
4682 for (j
= i
+ 1; j
< nruns
; ++j
)
4684 struct run
*p
= runs
[j
];
4686 if ((p
->current_y
>= r
->desired_y
4687 && p
->current_y
< r
->desired_y
+ r
->height
)
4688 || (p
->current_y
+ p
->height
>= r
->desired_y
4689 && (p
->current_y
+ p
->height
4690 < r
->desired_y
+ r
->height
)))
4695 /* Assign matrix rows. */
4696 for (j
= 0; j
< r
->nrows
; ++j
)
4698 struct glyph_row
*from
, *to
;
4699 int to_overlapped_p
;
4701 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
4702 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
4703 to_overlapped_p
= to
->overlapped_p
;
4704 assign_row (to
, from
);
4705 to
->enabled_p
= 1, from
->enabled_p
= 0;
4706 to
->overlapped_p
= to_overlapped_p
;
4710 /* Clear the hash table, for the next time. */
4711 for (i
= 0; i
< row_entry_idx
; ++i
)
4712 row_table
[row_entry_pool
[i
].bucket
] = NULL
;
4714 /* Value is non-zero to indicate that we scrolled the display. */
4720 /************************************************************************
4722 ************************************************************************/
4724 /* Update the desired frame matrix of frame F.
4726 FORCE_P non-zero means that the update should not be stopped by
4727 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
4728 should not be tried.
4730 Value is non-zero if update was stopped due to pending input. */
4733 update_frame_1 (f
, force_p
, inhibit_id_p
)
4738 /* Frame matrices to work on. */
4739 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4740 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4743 int preempt_count
= baud_rate
/ 2400 + 1;
4744 extern int input_pending
;
4746 xassert (current_matrix
&& desired_matrix
);
4748 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
4749 calculate_costs (f
);
4751 if (preempt_count
<= 0)
4754 if (redisplay_dont_pause
)
4756 else if (!force_p
&& detect_input_pending ())
4762 /* If we cannot insert/delete lines, it's no use trying it. */
4763 if (!line_ins_del_ok
)
4766 /* See if any of the desired lines are enabled; don't compute for
4767 i/d line if just want cursor motion. */
4768 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
4769 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4772 /* Try doing i/d line, if not yet inhibited. */
4773 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
4774 force_p
|= scrolling (f
);
4776 /* Update the individual lines as needed. Do bottom line first. */
4777 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
4778 update_frame_line (f
, desired_matrix
->nrows
- 1);
4780 /* Now update the rest of the lines. */
4781 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
4783 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4785 if (FRAME_TERMCAP_P (f
))
4787 /* Flush out every so many lines.
4788 Also flush out if likely to have more than 1k buffered
4789 otherwise. I'm told that some telnet connections get
4790 really screwed by more than 1k output at once. */
4791 int outq
= PENDING_OUTPUT_COUNT (stdout
);
4793 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
4796 if (preempt_count
== 1)
4798 #ifdef EMACS_OUTQSIZE
4799 if (EMACS_OUTQSIZE (0, &outq
) < 0)
4800 /* Probably not a tty. Ignore the error and reset
4801 * the outq count. */
4802 outq
= PENDING_OUTPUT_COUNT (stdout
);
4805 if (baud_rate
<= outq
&& baud_rate
> 0)
4806 sleep (outq
/ baud_rate
);
4811 if ((i
- 1) % preempt_count
== 0)
4812 detect_input_pending ();
4814 update_frame_line (f
, i
);
4818 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
4820 /* Now just clean up termcap drivers and set cursor, etc. */
4823 if ((cursor_in_echo_area
4824 /* If we are showing a message instead of the mini-buffer,
4825 show the cursor for the message instead of for the
4826 (now hidden) mini-buffer contents. */
4827 || (EQ (minibuf_window
, selected_window
)
4828 && EQ (minibuf_window
, echo_area_window
)
4829 && !NILP (echo_area_buffer
[0])))
4830 /* These cases apply only to the frame that contains
4831 the active mini-buffer window. */
4832 && FRAME_HAS_MINIBUF_P (f
)
4833 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4835 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
4838 if (cursor_in_echo_area
< 0)
4840 /* Negative value of cursor_in_echo_area means put
4841 cursor at beginning of line. */
4847 /* Positive value of cursor_in_echo_area means put
4848 cursor at the end of the prompt. If the mini-buffer
4849 is several lines high, find the last line that has
4851 row
= FRAME_HEIGHT (f
);
4857 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
4859 /* Frame rows are filled up with spaces that
4860 must be ignored here. */
4861 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
4863 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
4864 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
4867 && (last
- 1)->charpos
< 0)
4873 while (row
> top
&& col
== 0);
4875 /* Make sure COL is not out of range. */
4876 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
4878 /* If we have another row, advance cursor into it. */
4879 if (row
< FRAME_HEIGHT (f
) - 1)
4881 col
= FRAME_LEFT_SCROLL_BAR_WIDTH (f
);
4884 /* Otherwise move it back in range. */
4886 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
4890 cursor_to (row
, col
);
4894 /* We have only one cursor on terminal frames. Use it to
4895 display the cursor of the selected window. */
4896 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
4897 if (w
->cursor
.vpos
>= 0
4898 /* The cursor vpos may be temporarily out of bounds
4899 in the following situation: There is one window,
4900 with the cursor in the lower half of it. The window
4901 is split, and a message causes a redisplay before
4902 a new cursor position has been computed. */
4903 && w
->cursor
.vpos
< XFASTINT (w
->height
))
4905 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
4906 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
4908 if (INTEGERP (w
->left_margin_width
))
4909 x
+= XFASTINT (w
->left_margin_width
);
4911 /* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
4919 clear_desired_matrices (f
);
4924 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4928 struct frame
*frame
;
4930 int unchanged_at_top
, unchanged_at_bottom
;
4933 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4934 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4935 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4936 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4938 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
4939 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4940 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4942 if (!current_matrix
)
4945 /* Compute hash codes of all the lines. Also calculate number of
4946 changed lines, number of unchanged lines at the beginning, and
4947 number of unchanged lines at the end. */
4949 unchanged_at_top
= 0;
4950 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
4951 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
4953 /* Give up on this scrolling if some old lines are not enabled. */
4954 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
4956 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
4957 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4959 /* This line cannot be redrawn, so don't let scrolling mess it. */
4960 new_hash
[i
] = old_hash
[i
];
4961 #define INFINITY 1000000 /* Taken from scroll.c */
4962 draw_cost
[i
] = INFINITY
;
4966 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
4967 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
4970 if (old_hash
[i
] != new_hash
[i
])
4973 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
4975 else if (i
== unchanged_at_top
)
4977 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
4980 /* If changed lines are few, don't allow preemption, don't scroll. */
4981 if ((!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400)
4982 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
4985 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
4986 - unchanged_at_bottom
);
4988 if (scroll_region_ok
)
4989 free_at_end_vpos
-= unchanged_at_bottom
;
4990 else if (memory_below_frame
)
4991 free_at_end_vpos
= -1;
4993 /* If large window, fast terminal and few lines in common between
4994 current frame and desired frame, don't bother with i/d calc. */
4995 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
4997 10 * scrolling_max_lines_saved (unchanged_at_top
,
4998 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
4999 old_hash
, new_hash
, draw_cost
)))
5002 if (window_size
< 2)
5005 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
5006 draw_cost
+ unchanged_at_top
- 1,
5007 old_draw_cost
+ unchanged_at_top
- 1,
5008 old_hash
+ unchanged_at_top
- 1,
5009 new_hash
+ unchanged_at_top
- 1,
5010 free_at_end_vpos
- unchanged_at_top
);
5016 /* Count the number of blanks at the start of the vector of glyphs R
5017 which is LEN glyphs long. */
5020 count_blanks (r
, len
)
5026 for (i
= 0; i
< len
; ++i
)
5027 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
5034 /* Count the number of glyphs in common at the start of the glyph
5035 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
5036 of STR2. Value is the number of equal glyphs equal at the start. */
5039 count_match (str1
, end1
, str2
, end2
)
5040 struct glyph
*str1
, *end1
, *str2
, *end2
;
5042 struct glyph
*p1
= str1
;
5043 struct glyph
*p2
= str2
;
5047 && GLYPH_CHAR_AND_FACE_EQUAL_P (p1
, p2
))
5054 /* Char insertion/deletion cost vector, from term.c */
5056 extern int *char_ins_del_vector
;
5057 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
5060 /* Perform a frame-based update on line VPOS in frame FRAME. */
5063 update_frame_line (frame
, vpos
)
5064 register struct frame
*frame
;
5067 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
5069 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
5070 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
5071 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
5072 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
5073 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
5074 int must_write_whole_line_p
;
5075 int write_spaces_p
= must_write_spaces
;
5076 int colored_spaces_p
= (FACE_FROM_ID (frame
, DEFAULT_FACE_ID
)->background
5077 != FACE_TTY_DEFAULT_BG_COLOR
);
5079 if (colored_spaces_p
)
5082 if (desired_row
->inverse_p
5083 != (current_row
->enabled_p
&& current_row
->inverse_p
))
5085 int n
= current_row
->enabled_p
? current_row
->used
[TEXT_AREA
] : 0;
5086 change_line_highlight (desired_row
->inverse_p
, vpos
, vpos
, n
);
5087 current_row
->enabled_p
= 0;
5090 reassert_line_highlight (desired_row
->inverse_p
, vpos
);
5092 /* Current row not enabled means it has unknown contents. We must
5093 write the whole desired line in that case. */
5094 must_write_whole_line_p
= !current_row
->enabled_p
;
5095 if (must_write_whole_line_p
)
5102 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
5103 olen
= current_row
->used
[TEXT_AREA
];
5105 if (!current_row
->inverse_p
)
5107 /* Ignore trailing spaces, if we can. */
5108 if (!write_spaces_p
)
5109 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
5114 /* For an inverse-video line, make sure it's filled with
5115 spaces all the way to the frame edge so that the reverse
5116 video extends all the way across. */
5117 while (olen
< FRAME_WIDTH (frame
) - 1)
5118 obody
[olen
++] = space_glyph
;
5122 current_row
->enabled_p
= 1;
5123 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
5124 current_row
->inverse_p
= desired_row
->inverse_p
;
5126 /* If desired line is empty, just clear the line. */
5127 if (!desired_row
->enabled_p
)
5133 nbody
= desired_row
->glyphs
[TEXT_AREA
];
5134 nlen
= desired_row
->used
[TEXT_AREA
];
5135 nend
= nbody
+ nlen
;
5137 /* If display line has unknown contents, write the whole line. */
5138 if (must_write_whole_line_p
)
5140 /* Ignore spaces at the end, if we can. */
5141 if (!write_spaces_p
)
5142 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5145 /* Write the contents of the desired line. */
5148 cursor_to (vpos
, 0);
5149 write_glyphs (nbody
, nlen
);
5152 /* Don't call clear_end_of_line if we already wrote the whole
5153 line. The cursor will not be at the right margin in that
5154 case but in the line below. */
5155 if (nlen
< FRAME_WINDOW_WIDTH (frame
))
5157 cursor_to (vpos
, nlen
);
5158 clear_end_of_line (FRAME_WINDOW_WIDTH (frame
));
5161 /* Make sure we are in the right row, otherwise cursor movement
5162 with cmgoto might use `ch' in the wrong row. */
5163 cursor_to (vpos
, 0);
5165 make_current (desired_matrix
, current_matrix
, vpos
);
5169 /* Pretend trailing spaces are not there at all,
5170 unless for one reason or another we must write all spaces. */
5171 if (!desired_row
->inverse_p
)
5173 if (!write_spaces_p
)
5174 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5179 /* For an inverse-video line, give it extra trailing spaces all
5180 the way to the frame edge so that the reverse video extends
5181 all the way across. */
5182 while (nlen
< FRAME_WIDTH (frame
) - 1)
5183 nbody
[nlen
++] = space_glyph
;
5186 /* If there's no i/d char, quickly do the best we can without it. */
5187 if (!char_ins_del_ok
)
5191 /* Find the first glyph in desired row that doesn't agree with
5192 a glyph in the current row, and write the rest from there on. */
5193 for (i
= 0; i
< nlen
; i
++)
5195 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
5197 /* Find the end of the run of different glyphs. */
5201 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
5202 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
5205 /* Output this run of non-matching chars. */
5206 cursor_to (vpos
, i
);
5207 write_glyphs (nbody
+ i
, j
- i
);
5210 /* Now find the next non-match. */
5214 /* Clear the rest of the line, or the non-clear part of it. */
5217 cursor_to (vpos
, nlen
);
5218 clear_end_of_line (olen
);
5221 /* Make current row = desired row. */
5222 make_current (desired_matrix
, current_matrix
, vpos
);
5226 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
5227 characters in a row. */
5231 /* If current line is blank, skip over initial spaces, if
5232 possible, and write the rest. */
5233 if (write_spaces_p
|| desired_row
->inverse_p
)
5236 nsp
= count_blanks (nbody
, nlen
);
5240 cursor_to (vpos
, nsp
);
5241 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
5244 /* Exchange contents between current_frame and new_frame. */
5245 make_current (desired_matrix
, current_matrix
, vpos
);
5249 /* Compute number of leading blanks in old and new contents. */
5250 osp
= count_blanks (obody
, olen
);
5251 nsp
= (desired_row
->inverse_p
|| colored_spaces_p
5253 : count_blanks (nbody
, nlen
));
5255 /* Compute number of matching chars starting with first non-blank. */
5256 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
5257 nbody
+ nsp
, nbody
+ nlen
);
5259 /* Spaces in new match implicit space past the end of old. */
5260 /* A bug causing this to be a no-op was fixed in 18.29. */
5261 if (!write_spaces_p
&& osp
+ begmatch
== olen
)
5264 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
5268 /* Avoid doing insert/delete char
5269 just cause number of leading spaces differs
5270 when the following text does not match. */
5271 if (begmatch
== 0 && osp
!= nsp
)
5272 osp
= nsp
= min (osp
, nsp
);
5274 /* Find matching characters at end of line */
5277 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
5279 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
5284 endmatch
= obody
+ olen
- op1
;
5286 /* tem gets the distance to insert or delete.
5287 endmatch is how many characters we save by doing so.
5290 tem
= (nlen
- nsp
) - (olen
- osp
);
5292 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
5295 /* nsp - osp is the distance to insert or delete.
5296 If that is nonzero, begmatch is known to be nonzero also.
5297 begmatch + endmatch is how much we save by doing the ins/del.
5301 && (!char_ins_del_ok
5302 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
5306 osp
= nsp
= min (osp
, nsp
);
5309 /* Now go through the line, inserting, writing and
5310 deleting as appropriate. */
5314 cursor_to (vpos
, nsp
);
5315 delete_glyphs (osp
- nsp
);
5319 /* If going to delete chars later in line
5320 and insert earlier in the line,
5321 must delete first to avoid losing data in the insert */
5322 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
5324 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
5325 delete_glyphs (olen
+ nsp
- osp
- nlen
);
5326 olen
= nlen
- (nsp
- osp
);
5328 cursor_to (vpos
, osp
);
5329 insert_glyphs (0, nsp
- osp
);
5333 tem
= nsp
+ begmatch
+ endmatch
;
5334 if (nlen
!= tem
|| olen
!= tem
)
5336 cursor_to (vpos
, nsp
+ begmatch
);
5337 if (!endmatch
|| nlen
== olen
)
5339 /* If new text being written reaches right margin,
5340 there is no need to do clear-to-eol at the end.
5341 (and it would not be safe, since cursor is not
5342 going to be "at the margin" after the text is done) */
5343 if (nlen
== FRAME_WINDOW_WIDTH (frame
))
5345 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5347 else if (nlen
> olen
)
5349 /* Here, we used to have the following simple code:
5350 ----------------------------------------
5351 write_glyphs (nbody + nsp + begmatch, olen - tem);
5352 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5353 ----------------------------------------
5354 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5355 is a padding glyph. */
5356 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5359 /* Calculate columns we can actually overwrite. */
5360 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
])) out
--;
5361 write_glyphs (nbody
+ nsp
+ begmatch
, out
);
5362 /* If we left columns to be overwritten, we must delete them. */
5363 del
= olen
- tem
- out
;
5364 if (del
> 0) delete_glyphs (del
);
5365 /* At last, we insert columns not yet written out. */
5366 insert_glyphs (nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5369 else if (olen
> nlen
)
5371 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5372 delete_glyphs (olen
- nlen
);
5378 /* If any unerased characters remain after the new line, erase them. */
5381 cursor_to (vpos
, nlen
);
5382 clear_end_of_line (olen
);
5385 /* Exchange contents between current_frame and new_frame. */
5386 make_current (desired_matrix
, current_matrix
, vpos
);
5391 /***********************************************************************
5392 X/Y Position -> Buffer Position
5393 ***********************************************************************/
5395 /* Return the character position of the character at window relative
5396 pixel position (*X, *Y). *X and *Y are adjusted to character
5400 buffer_posn_from_coords (w
, x
, y
)
5405 struct buffer
*old_current_buffer
= current_buffer
;
5406 struct text_pos startp
;
5407 int left_area_width
;
5409 current_buffer
= XBUFFER (w
->buffer
);
5410 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5411 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5412 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5413 start_display (&it
, w
, startp
);
5415 left_area_width
= WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH (w
);
5416 move_it_to (&it
, -1, *x
+ it
.first_visible_x
- left_area_width
, *y
, -1,
5417 MOVE_TO_X
| MOVE_TO_Y
);
5419 *x
= it
.current_x
- it
.first_visible_x
+ left_area_width
;
5421 current_buffer
= old_current_buffer
;
5422 return IT_CHARPOS (it
);
5426 /* Value is the string under window-relative coordinates X/Y in the
5427 mode or top line of window W, or nil if none. MODE_LINE_P non-zero
5428 means look at the mode line. *CHARPOS is set to the position in
5429 the string returned. */
5432 mode_line_string (w
, x
, y
, mode_line_p
, charpos
)
5434 int x
, y
, mode_line_p
;
5437 struct glyph_row
*row
;
5438 struct glyph
*glyph
, *end
;
5439 struct frame
*f
= XFRAME (w
->frame
);
5441 Lisp_Object string
= Qnil
;
5444 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5446 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
5448 if (row
->mode_line_p
&& row
->enabled_p
)
5450 /* The mode lines are displayed over scroll bars and bitmap
5451 areas, and X is window-relative. Correct X by the scroll bar
5452 and bitmap area width. */
5453 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
5454 x
+= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
5455 x
+= FRAME_LEFT_FLAGS_AREA_WIDTH (f
);
5457 /* Find the glyph under X. If we find one with a string object,
5458 it's the one we were looking for. */
5459 glyph
= row
->glyphs
[TEXT_AREA
];
5460 end
= glyph
+ row
->used
[TEXT_AREA
];
5461 for (x0
= 0; glyph
< end
; x0
+= glyph
->pixel_width
, ++glyph
)
5462 if (x
>= x0
&& x
< x0
+ glyph
->pixel_width
)
5464 string
= glyph
->object
;
5465 *charpos
= glyph
->charpos
;
5474 /***********************************************************************
5475 Changing Frame Sizes
5476 ***********************************************************************/
5481 window_change_signal (signalnum
) /* If we don't have an argument, */
5482 int signalnum
; /* some compilers complain in signal calls. */
5488 int old_errno
= errno
;
5490 get_frame_size (&width
, &height
);
5492 /* The frame size change obviously applies to a termcap-controlled
5493 frame. Find such a frame in the list, and assume it's the only
5494 one (since the redisplay code always writes to stdout, not a
5495 FILE * specified in the frame structure). Record the new size,
5496 but don't reallocate the data structures now. Let that be done
5497 later outside of the signal handler. */
5500 Lisp_Object tail
, frame
;
5502 FOR_EACH_FRAME (tail
, frame
)
5504 if (FRAME_TERMCAP_P (XFRAME (frame
)))
5506 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5512 signal (SIGWINCH
, window_change_signal
);
5515 #endif /* SIGWINCH */
5518 /* Do any change in frame size that was requested by a signal. SAFE
5519 non-zero means this function is called from a place where it is
5520 safe to change frame sizes while a redisplay is in progress. */
5523 do_pending_window_change (safe
)
5526 /* If window_change_signal should have run before, run it now. */
5527 if (redisplaying_p
&& !safe
)
5530 while (delayed_size_change
)
5532 Lisp_Object tail
, frame
;
5534 delayed_size_change
= 0;
5536 FOR_EACH_FRAME (tail
, frame
)
5538 struct frame
*f
= XFRAME (frame
);
5540 int height
= FRAME_NEW_HEIGHT (f
);
5541 int width
= FRAME_NEW_WIDTH (f
);
5543 if (height
!= 0 || width
!= 0)
5544 change_frame_size (f
, height
, width
, 0, 0, safe
);
5550 /* Change the frame height and/or width. Values may be given as zero to
5551 indicate no change is to take place.
5553 If DELAY is non-zero, then assume we're being called from a signal
5554 handler, and queue the change for later - perhaps the next
5555 redisplay. Since this tries to resize windows, we can't call it
5556 from a signal handler.
5558 SAFE non-zero means this function is called from a place where it's
5559 safe to change frame sizes while a redisplay is in progress. */
5562 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5563 register struct frame
*f
;
5564 int newheight
, newwidth
, pretend
, delay
, safe
;
5566 Lisp_Object tail
, frame
;
5568 if (! FRAME_WINDOW_P (f
))
5570 /* When using termcap, or on MS-DOS, all frames use
5571 the same screen, so a change in size affects all frames. */
5572 FOR_EACH_FRAME (tail
, frame
)
5573 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5574 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5575 pretend
, delay
, safe
);
5578 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
5582 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5583 register struct frame
*f
;
5584 int newheight
, newwidth
, pretend
, delay
, safe
;
5586 int new_frame_window_width
;
5587 int count
= specpdl_ptr
- specpdl
;
5589 /* If we can't deal with the change now, queue it for later. */
5590 if (delay
|| (redisplaying_p
&& !safe
))
5592 FRAME_NEW_HEIGHT (f
) = newheight
;
5593 FRAME_NEW_WIDTH (f
) = newwidth
;
5594 delayed_size_change
= 1;
5598 /* This size-change overrides any pending one for this frame. */
5599 FRAME_NEW_HEIGHT (f
) = 0;
5600 FRAME_NEW_WIDTH (f
) = 0;
5602 /* If an argument is zero, set it to the current value. */
5604 newheight
= FRAME_HEIGHT (f
);
5606 newwidth
= FRAME_WIDTH (f
);
5608 /* Compute width of windows in F.
5609 This is the width of the frame without vertical scroll bars. */
5610 new_frame_window_width
= FRAME_WINDOW_WIDTH_ARG (f
, newwidth
);
5612 /* Round up to the smallest acceptable size. */
5613 check_frame_size (f
, &newheight
, &newwidth
);
5615 /* If we're not changing the frame size, quit now. */
5616 if (newheight
== FRAME_HEIGHT (f
)
5617 && new_frame_window_width
== FRAME_WINDOW_WIDTH (f
))
5623 /* We only can set screen dimensions to certain values supported
5624 by our video hardware. Try to find the smallest size greater
5625 or equal to the requested dimensions. */
5626 dos_set_window_size (&newheight
, &newwidth
);
5629 if (newheight
!= FRAME_HEIGHT (f
))
5631 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
5633 /* Frame has both root and mini-buffer. */
5634 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f
))->top
,
5635 FRAME_TOP_MARGIN (f
));
5636 set_window_height (FRAME_ROOT_WINDOW (f
),
5639 - FRAME_TOP_MARGIN (f
)),
5641 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
,
5643 set_window_height (FRAME_MINIBUF_WINDOW (f
), 1, 0);
5646 /* Frame has just one top-level window. */
5647 set_window_height (FRAME_ROOT_WINDOW (f
),
5648 newheight
- FRAME_TOP_MARGIN (f
), 0);
5650 if (FRAME_TERMCAP_P (f
) && !pretend
)
5651 FrameRows
= newheight
;
5654 if (new_frame_window_width
!= FRAME_WINDOW_WIDTH (f
))
5656 set_window_width (FRAME_ROOT_WINDOW (f
), new_frame_window_width
, 0);
5657 if (FRAME_HAS_MINIBUF_P (f
))
5658 set_window_width (FRAME_MINIBUF_WINDOW (f
), new_frame_window_width
, 0);
5660 if (FRAME_TERMCAP_P (f
) && !pretend
)
5661 FrameCols
= newwidth
;
5663 if (WINDOWP (f
->tool_bar_window
))
5664 XSETFASTINT (XWINDOW (f
->tool_bar_window
)->width
, newwidth
);
5667 FRAME_HEIGHT (f
) = newheight
;
5668 SET_FRAME_WIDTH (f
, newwidth
);
5671 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5672 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
5674 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
5676 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
5677 w
->cursor
.hpos
= w
->cursor
.x
= 0;
5678 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
5679 w
->cursor
.vpos
= w
->cursor
.y
= 0;
5683 SET_FRAME_GARBAGED (f
);
5684 calculate_costs (f
);
5688 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
5690 /* This isn't quite a no-op: it runs window-configuration-change-hook. */
5691 Fset_window_buffer (FRAME_SELECTED_WINDOW (f
),
5692 XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
);
5694 unbind_to (count
, Qnil
);
5699 /***********************************************************************
5700 Terminal Related Lisp Functions
5701 ***********************************************************************/
5703 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
5704 1, 1, "FOpen termscript file: ",
5705 "Start writing all terminal output to FILE as well as the terminal.\n\
5706 FILE = nil means just close any termscript file currently open.")
5710 if (termscript
!= 0) fclose (termscript
);
5715 file
= Fexpand_file_name (file
, Qnil
);
5716 termscript
= fopen (XSTRING (file
)->data
, "w");
5717 if (termscript
== 0)
5718 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
5724 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
5725 Ssend_string_to_terminal
, 1, 1, 0,
5726 "Send STRING to the terminal without alteration.\n\
5727 Control characters in STRING will have terminal-dependent effects.")
5731 /* ??? Perhaps we should do something special for multibyte strings here. */
5732 CHECK_STRING (string
, 0);
5733 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)), stdout
);
5737 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)),
5739 fflush (termscript
);
5745 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
5746 "Beep, or flash the screen.\n\
5747 Also, unless an argument is given,\n\
5748 terminate any keyboard macro currently executing.")
5771 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
5772 error ("Keyboard macro terminated by a command ringing the bell");
5780 /***********************************************************************
5782 ***********************************************************************/
5784 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
5785 "Pause, without updating display, for SECONDS seconds.\n\
5786 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5787 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5788 additional wait period, in milliseconds; this may be useful if your\n\
5789 Emacs was built without floating point support.\n\
5790 \(Not all operating systems support waiting for a fraction of a second.)")
5791 (seconds
, milliseconds
)
5792 Lisp_Object seconds
, milliseconds
;
5796 if (NILP (milliseconds
))
5797 XSETINT (milliseconds
, 0);
5799 CHECK_NUMBER (milliseconds
, 1);
5800 usec
= XINT (milliseconds
) * 1000;
5803 double duration
= extract_float (seconds
);
5804 sec
= (int) duration
;
5805 usec
+= (duration
- sec
) * 1000000;
5808 #ifndef EMACS_HAS_USECS
5809 if (sec
== 0 && usec
!= 0)
5810 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
5813 /* Assure that 0 <= usec < 1000000. */
5816 /* We can't rely on the rounding being correct if user is negative. */
5817 if (-1000000 < usec
)
5818 sec
--, usec
+= 1000000;
5820 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
5823 sec
+= usec
/ 1000000, usec
%= 1000000;
5825 if (sec
< 0 || (sec
== 0 && usec
== 0))
5831 XSETFASTINT (zero
, 0);
5832 wait_reading_process_input (sec
, usec
, zero
, 0);
5835 /* We should always have wait_reading_process_input; we have a dummy
5836 implementation for systems which don't support subprocesses. */
5838 /* No wait_reading_process_input */
5845 /* The reason this is done this way
5846 (rather than defined (H_S) && defined (H_T))
5847 is because the VMS preprocessor doesn't grok `defined' */
5849 EMACS_GET_TIME (end_time
);
5850 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
5851 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
5855 EMACS_GET_TIME (timeout
);
5856 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
5857 if (EMACS_TIME_NEG_P (timeout
)
5858 || !select (1, 0, 0, 0, &timeout
))
5861 #else /* not HAVE_SELECT */
5863 #endif /* HAVE_SELECT */
5864 #endif /* not VMS */
5867 #endif /* no subprocesses */
5873 /* This is just like wait_reading_process_input, except that
5874 it does the redisplay.
5876 It's also much like Fsit_for, except that it can be used for
5877 waiting for input as well. */
5880 sit_for (sec
, usec
, reading
, display
, initial_display
)
5881 int sec
, usec
, reading
, display
, initial_display
;
5883 Lisp_Object read_kbd
;
5885 swallow_events (display
);
5887 if (detect_input_pending_run_timers (display
))
5890 if (initial_display
)
5891 redisplay_preserve_echo_area ();
5893 if (sec
== 0 && usec
== 0)
5900 XSETINT (read_kbd
, reading
? -1 : 1);
5901 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
5903 return detect_input_pending () ? Qnil
: Qt
;
5907 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
5908 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
5909 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5910 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5911 additional wait period, in milliseconds; this may be useful if your\n\
5912 Emacs was built without floating point support.\n\
5913 \(Not all operating systems support waiting for a fraction of a second.)\n\
5914 Optional third arg NODISP non-nil means don't redisplay, just wait for input.\n\
5915 Redisplay is preempted as always if input arrives, and does not happen\n\
5916 if input is available before it starts.\n\
5917 Value is t if waited the full time with no input arriving.")
5918 (seconds
, milliseconds
, nodisp
)
5919 Lisp_Object seconds
, milliseconds
, nodisp
;
5923 if (NILP (milliseconds
))
5924 XSETINT (milliseconds
, 0);
5926 CHECK_NUMBER (milliseconds
, 1);
5927 usec
= XINT (milliseconds
) * 1000;
5930 double duration
= extract_float (seconds
);
5931 sec
= (int) duration
;
5932 usec
+= (duration
- sec
) * 1000000;
5935 #ifndef EMACS_HAS_USECS
5936 if (usec
!= 0 && sec
== 0)
5937 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
5940 return sit_for (sec
, usec
, 0, NILP (nodisp
), NILP (nodisp
));
5945 /***********************************************************************
5946 Other Lisp Functions
5947 ***********************************************************************/
5949 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
5950 session's frames, frame names, buffers, buffer-read-only flags, and
5951 buffer-modified-flags, and a trailing sentinel (so we don't need to
5952 add length checks). */
5954 static Lisp_Object frame_and_buffer_state
;
5957 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
5958 Sframe_or_buffer_changed_p
, 0, 0, 0,
5959 "Return non-nil if the frame and buffer state appears to have changed.\n\
5960 The state variable is an internal vector containing all frames and buffers,\n\
5961 aside from buffers whose names start with space,\n\
5962 along with the buffers' read-only and modified flags, which allows a fast\n\
5963 check to see whether the menu bars might need to be recomputed.\n\
5964 If this function returns non-nil, it updates the internal vector to reflect\n\
5965 the current state.\n")
5968 Lisp_Object tail
, frame
, buf
;
5972 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5973 FOR_EACH_FRAME (tail
, frame
)
5975 if (!EQ (*vecp
++, frame
))
5977 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
5980 /* Check that the buffer info matches.
5981 No need to test for the end of the vector
5982 because the last element of the vector is lambda
5983 and that will always cause a mismatch. */
5984 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5986 buf
= XCDR (XCAR (tail
));
5987 /* Ignore buffers that aren't included in buffer lists. */
5988 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5990 if (!EQ (*vecp
++, buf
))
5992 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
5994 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
5997 /* Detect deletion of a buffer at the end of the list. */
5998 if (EQ (*vecp
, Qlambda
))
6001 /* Start with 1 so there is room for at least one lambda at the end. */
6003 FOR_EACH_FRAME (tail
, frame
)
6005 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
6007 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
6008 if (n
> XVECTOR (frame_and_buffer_state
)->size
6009 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
6010 /* Add 20 extra so we grow it less often. */
6011 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
6012 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
6013 FOR_EACH_FRAME (tail
, frame
)
6016 *vecp
++ = XFRAME (frame
)->name
;
6018 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
6020 buf
= XCDR (XCAR (tail
));
6021 /* Ignore buffers that aren't included in buffer lists. */
6022 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
6025 *vecp
++ = XBUFFER (buf
)->read_only
;
6026 *vecp
++ = Fbuffer_modified_p (buf
);
6028 /* Fill up the vector with lambdas (always at least one). */
6030 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
6031 < XVECTOR (frame_and_buffer_state
)->size
)
6033 /* Make sure we didn't overflow the vector. */
6034 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
6035 > XVECTOR (frame_and_buffer_state
)->size
)
6042 /***********************************************************************
6044 ***********************************************************************/
6046 char *terminal_type
;
6048 /* Initialization done when Emacs fork is started, before doing stty.
6049 Determine terminal type and set terminal_driver. Then invoke its
6050 decoding routine to set up variables in the terminal package. */
6055 #ifdef HAVE_X_WINDOWS
6056 extern int display_arg
;
6059 /* Construct the space glyph. */
6060 space_glyph
.type
= CHAR_GLYPH
;
6061 SET_CHAR_GLYPH_FROM_GLYPH (space_glyph
, ' ');
6062 space_glyph
.charpos
= -1;
6066 cursor_in_echo_area
= 0;
6067 terminal_type
= (char *) 0;
6069 /* Now is the time to initialize this; it's used by init_sys_modes
6071 Vwindow_system
= Qnil
;
6073 /* If the user wants to use a window system, we shouldn't bother
6074 initializing the terminal. This is especially important when the
6075 terminal is so dumb that emacs gives up before and doesn't bother
6076 using the window system.
6078 If the DISPLAY environment variable is set and nonempty,
6079 try to use X, and die with an error message if that doesn't work. */
6081 #ifdef HAVE_X_WINDOWS
6086 display
= getenv ("DECW$DISPLAY");
6088 display
= getenv ("DISPLAY");
6091 display_arg
= (display
!= 0 && *display
!= 0);
6094 if (!inhibit_window_system
&& display_arg
6100 Vwindow_system
= intern ("x");
6102 Vwindow_system_version
= make_number (11);
6104 Vwindow_system_version
= make_number (10);
6106 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
6107 /* In some versions of ncurses,
6108 tputs crashes if we have not called tgetent.
6110 { char b
[2044]; tgetent (b
, "xterm");}
6112 adjust_frame_glyphs_initially ();
6115 #endif /* HAVE_X_WINDOWS */
6118 if (!inhibit_window_system
)
6120 Vwindow_system
= intern ("w32");
6121 Vwindow_system_version
= make_number (1);
6122 adjust_frame_glyphs_initially ();
6125 #endif /* HAVE_NTGUI */
6128 if (!inhibit_window_system
)
6130 Vwindow_system
= intern ("mac");
6131 Vwindow_system_version
= make_number (1);
6132 adjust_frame_glyphs_initially ();
6135 #endif /* macintosh */
6137 /* If no window system has been specified, try to use the terminal. */
6140 fatal ("standard input is not a tty");
6144 /* Look at the TERM variable */
6145 terminal_type
= (char *) getenv ("TERM");
6149 fprintf (stderr
, "Please specify your terminal type.\n\
6150 For types defined in VMS, use set term /device=TYPE.\n\
6151 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
6152 \(The quotation marks are necessary since terminal types are lower case.)\n");
6154 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
6160 /* VMS DCL tends to up-case things, so down-case term type.
6161 Hardly any uppercase letters in terminal types; should be none. */
6163 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
6166 strcpy (new, terminal_type
);
6168 for (p
= new; *p
; p
++)
6172 terminal_type
= new;
6176 term_init (terminal_type
);
6179 struct frame
*sf
= SELECTED_FRAME ();
6180 int width
= FRAME_WINDOW_WIDTH (sf
);
6181 int height
= FRAME_HEIGHT (sf
);
6183 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (struct glyph
);
6185 /* If these sizes are so big they cause overflow, just ignore the
6186 change. It's not clear what better we could do. */
6187 if (total_glyphs
/ sizeof (struct glyph
) / height
!= width
+ 2)
6188 fatal ("screen size %dx%d too big", width
, height
);
6191 adjust_frame_glyphs_initially ();
6192 calculate_costs (XFRAME (selected_frame
));
6197 #endif /* CANNOT_DUMP */
6198 signal (SIGWINCH
, window_change_signal
);
6199 #endif /* SIGWINCH */
6201 /* Set up faces of the initial terminal frame of a dumped Emacs. */
6205 /* The MSDOS terminal turns on its ``window system'' relatively
6206 late into the startup, so we cannot do the frame faces'
6207 initialization just yet. It will be done later by pc-win.el
6208 and internal_terminal_init. */
6209 && (strcmp (terminal_type
, "internal") != 0 || inhibit_window_system
)
6211 && NILP (Vwindow_system
))
6213 /* For the initial frame, we don't have any way of knowing what
6214 are the foreground and background colors of the terminal. */
6215 struct frame
*sf
= SELECTED_FRAME();
6217 FRAME_FOREGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_FG_COLOR
;
6218 FRAME_BACKGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_BG_COLOR
;
6219 call0 (intern ("tty-set-up-initial-frame-faces"));
6225 /***********************************************************************
6227 ***********************************************************************/
6229 DEFUN ("internal-show-cursor", Finternal_show_cursor
,
6230 Sinternal_show_cursor
, 2, 2, 0,
6231 "Set the cursor-visibility flag of WINDOW to SHOW.\n\
6232 WINDOW nil means use the selected window. SHOW non-nil means\n\
6233 show a cursor in WINDOW in the next redisplay. SHOW nil means\n\
6234 don't show a cursor.")
6236 Lisp_Object window
, show
;
6238 /* Don't change cursor state while redisplaying. This could confuse
6240 if (!redisplaying_p
)
6243 window
= selected_window
;
6245 CHECK_WINDOW (window
, 2);
6247 XWINDOW (window
)->cursor_off_p
= NILP (show
);
6254 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p
,
6255 Sinternal_show_cursor_p
, 0, 1, 0,
6256 "Value is non-nil if next redisplay will display a cursor in WINDOW.\n\
6257 WINDOW nil or omitted means report on the selected window.")
6264 window
= selected_window
;
6266 CHECK_WINDOW (window
, 2);
6268 w
= XWINDOW (window
);
6269 return w
->cursor_off_p
? Qnil
: Qt
;
6273 /***********************************************************************
6275 ***********************************************************************/
6280 defsubr (&Sredraw_frame
);
6281 defsubr (&Sredraw_display
);
6282 defsubr (&Sframe_or_buffer_changed_p
);
6283 defsubr (&Sopen_termscript
);
6285 defsubr (&Ssit_for
);
6286 defsubr (&Ssleep_for
);
6287 defsubr (&Ssend_string_to_terminal
);
6288 defsubr (&Sinternal_show_cursor
);
6289 defsubr (&Sinternal_show_cursor_p
);
6291 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
6292 staticpro (&frame_and_buffer_state
);
6294 Qdisplay_table
= intern ("display-table");
6295 staticpro (&Qdisplay_table
);
6296 Qredisplay_dont_pause
= intern ("redisplay-dont-pause");
6297 staticpro (&Qredisplay_dont_pause
);
6299 DEFVAR_INT ("baud-rate", &baud_rate
,
6300 "*The output baud rate of the terminal.\n\
6301 On most systems, changing this value will affect the amount of padding\n\
6302 and the other strategic decisions made during redisplay.");
6304 DEFVAR_BOOL ("inverse-video", &inverse_video
,
6305 "*Non-nil means invert the entire frame display.\n\
6306 This means everything is in inverse video which otherwise would not be.");
6308 DEFVAR_BOOL ("visible-bell", &visible_bell
,
6309 "*Non-nil means try to flash the frame to represent a bell.");
6311 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
6312 "*Non-nil means no need to redraw entire frame after suspending.\n\
6313 A non-nil value is useful if the terminal can automatically preserve\n\
6314 Emacs's frame display when you reenter Emacs.\n\
6315 It is up to you to set this variable if your terminal can do that.");
6317 DEFVAR_LISP ("window-system", &Vwindow_system
,
6318 "A symbol naming the window-system under which Emacs is running\n\
6319 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
6321 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
6322 "The version number of the window system in use.\n\
6323 For X windows, this is 10 or 11.");
6325 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
6326 "Non-nil means put cursor in minibuffer, at end of any message there.");
6328 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
6329 "Table defining how to output a glyph code to the frame.\n\
6330 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
6331 Each element can be:\n\
6332 integer: a glyph code which this glyph is an alias for.\n\
6333 string: output this glyph using that string (not impl. in X windows).\n\
6334 nil: this glyph mod 256 is char code to output,\n\
6335 and this glyph / 256 is face code for X windows (see `face-id').");
6336 Vglyph_table
= Qnil
;
6338 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
6339 "Display table to use for buffers that specify none.\n\
6340 See `buffer-display-table' for more information.");
6341 Vstandard_display_table
= Qnil
;
6343 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause
,
6344 "*Non-nil means update isn't paused when input is detected.");
6345 redisplay_dont_pause
= 0;
6347 /* Initialize `window-system', unless init_display already decided it. */
6352 Vwindow_system
= Qnil
;
6353 Vwindow_system_version
= Qnil
;