1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 97, 98, 1999
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
34 #include "termhooks.h"
35 /* cm.h must come after dispextern.h on Windows. */
36 #include "dispextern.h"
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 */
63 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
68 /* To get the prototype for `sleep'. */
74 #define max(a, b) ((a) > (b) ? (a) : (b))
75 #define min(a, b) ((a) < (b) ? (a) : (b))
77 /* Get number of chars of output now in the buffer of a stdio stream.
78 This ought to be built in in stdio, but it isn't. Some s- files
79 override this because their stdio internals differ. */
81 #ifdef __GNU_LIBRARY__
83 /* The s- file might have overridden the definition with one that
84 works for the system's C library. But we are using the GNU C
85 library, so this is the right definition for every system. */
87 #ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT
88 #define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT
90 #undef PENDING_OUTPUT_COUNT
91 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
93 #else /* not __GNU_LIBRARY__ */
94 #if !defined (PENDING_OUTPUT_COUNT) && HAVE_STDIO_EXT_H && HAVE___FPENDING
95 #include <stdio_ext.h>
96 #define PENDING_OUTPUT_COUNT(FILE) __fpending (FILE)
98 #ifndef PENDING_OUTPUT_COUNT
99 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
101 #endif /* not __GNU_LIBRARY__ */
103 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
104 #include <term.h> /* for tgetent */
107 /* Structure to pass dimensions around. Used for character bounding
108 boxes, glyph matrix dimensions and alike. */
117 /* Function prototypes. */
119 static void redraw_overlapping_rows
P_ ((struct window
*, int));
120 static void redraw_overlapped_rows
P_ ((struct window
*, int));
121 static int count_blanks
P_ ((struct glyph
*, int));
122 static int count_match
P_ ((struct glyph
*, struct glyph
*,
123 struct glyph
*, struct glyph
*));
124 static unsigned line_draw_cost
P_ ((struct glyph_matrix
*, int));
125 static void update_frame_line
P_ ((struct frame
*, int));
126 static struct dim allocate_matrices_for_frame_redisplay
127 P_ ((Lisp_Object
, int, int, struct dim
, int, int *));
128 static void allocate_matrices_for_window_redisplay
P_ ((struct window
*,
130 static int realloc_glyph_pool
P_ ((struct glyph_pool
*, struct dim
));
131 static void adjust_frame_glyphs
P_ ((struct frame
*));
132 struct glyph_matrix
*new_glyph_matrix
P_ ((struct glyph_pool
*));
133 static void free_glyph_matrix
P_ ((struct glyph_matrix
*));
134 static void adjust_glyph_matrix
P_ ((struct window
*, struct glyph_matrix
*,
135 int, int, struct dim
));
136 static void change_frame_size_1
P_ ((struct frame
*, int, int, int, int, int));
137 static void swap_glyph_pointers
P_ ((struct glyph_row
*, struct glyph_row
*));
139 static int glyph_row_slice_p
P_ ((struct glyph_row
*, struct glyph_row
*));
141 static void fill_up_frame_row_with_spaces
P_ ((struct glyph_row
*, int));
142 static void build_frame_matrix_from_window_tree
P_ ((struct glyph_matrix
*,
144 static void build_frame_matrix_from_leaf_window
P_ ((struct glyph_matrix
*,
146 static struct glyph_pool
*new_glyph_pool
P_ ((void));
147 static void free_glyph_pool
P_ ((struct glyph_pool
*));
148 static void adjust_frame_glyphs_initially
P_ ((void));
149 static void adjust_frame_message_buffer
P_ ((struct frame
*));
150 static void adjust_decode_mode_spec_buffer
P_ ((struct frame
*));
151 static void fill_up_glyph_row_with_spaces
P_ ((struct glyph_row
*));
152 static void build_frame_matrix
P_ ((struct frame
*));
153 void clear_current_matrices
P_ ((struct frame
*));
154 void scroll_glyph_matrix_range
P_ ((struct glyph_matrix
*, int, int,
156 static void clear_window_matrices
P_ ((struct window
*, int));
157 static void fill_up_glyph_row_area_with_spaces
P_ ((struct glyph_row
*, int));
158 static int scrolling_window
P_ ((struct window
*, int));
159 static int update_window_line
P_ ((struct window
*, int, int *));
160 static void update_marginal_area
P_ ((struct window
*, int, int));
161 static int update_text_area
P_ ((struct window
*, int));
162 static void make_current
P_ ((struct glyph_matrix
*, struct glyph_matrix
*,
164 static void mirror_make_current
P_ ((struct window
*, int));
165 void check_window_matrix_pointers
P_ ((struct window
*));
167 static void check_matrix_pointers
P_ ((struct glyph_matrix
*,
168 struct glyph_matrix
*));
170 static void mirror_line_dance
P_ ((struct window
*, int, int, int *, char *));
171 static int update_window_tree
P_ ((struct window
*, int));
172 static int update_window
P_ ((struct window
*, int));
173 static int update_frame_1
P_ ((struct frame
*, int, int));
174 static void set_window_cursor_after_update
P_ ((struct window
*));
175 static int row_equal_p
P_ ((struct window
*, struct glyph_row
*,
176 struct glyph_row
*, int));
177 static void adjust_frame_glyphs_for_window_redisplay
P_ ((struct frame
*));
178 static void adjust_frame_glyphs_for_frame_redisplay
P_ ((struct frame
*));
179 static void reverse_rows
P_ ((struct glyph_matrix
*, int, int));
180 static int margin_glyphs_to_reserve
P_ ((struct window
*, int, Lisp_Object
));
181 static void sync_window_with_frame_matrix_rows
P_ ((struct window
*));
182 struct window
*frame_row_to_window
P_ ((struct window
*, int));
186 /* Non-zero means don't pause redisplay for pending input. (This is
187 for debugging and for a future implementation of EDT-like
190 int redisplay_dont_pause
;
192 /* Nonzero upon entry to redisplay means do not assume anything about
193 current contents of actual terminal frame; clear and redraw it. */
197 /* Nonzero means last display completed. Zero means it was preempted. */
199 int display_completed
;
201 /* Lisp variable visible-bell; enables use of screen-flash instead of
206 /* Invert the color of the whole frame, at a low level. */
210 /* Line speed of the terminal. */
214 /* Either nil or a symbol naming the window system under which Emacs
217 Lisp_Object Vwindow_system
;
219 /* Version number of X windows: 10, 11 or nil. */
221 Lisp_Object Vwindow_system_version
;
223 /* Vector of glyph definitions. Indexed by glyph number, the contents
224 are a string which is how to output the glyph.
226 If Vglyph_table is nil, a glyph is output by using its low 8 bits
229 This is an obsolete feature that is no longer used. The variable
230 is retained for compatibility. */
232 Lisp_Object Vglyph_table
;
234 /* Display table to use for vectors that don't specify their own. */
236 Lisp_Object Vstandard_display_table
;
238 /* Nonzero means reading single-character input with prompt so put
239 cursor on mini-buffer after the prompt. positive means at end of
240 text in echo area; negative means at beginning of line. */
242 int cursor_in_echo_area
;
244 Lisp_Object Qdisplay_table
, Qredisplay_dont_pause
;
247 /* The currently selected frame. In a single-frame version, this
248 variable always equals the_only_frame. */
250 Lisp_Object selected_frame
;
252 /* A frame which is not just a mini-buffer, or 0 if there are no such
253 frames. This is usually the most recent such frame that was
254 selected. In a single-frame version, this variable always holds
255 the address of the_only_frame. */
257 struct frame
*last_nonminibuf_frame
;
259 /* Stdio stream being used for copy of all output. */
263 /* Structure for info on cursor positioning. */
267 /* 1 means SIGWINCH happened when not safe. */
269 int delayed_size_change
;
271 /* 1 means glyph initialization has been completed at startup. */
273 static int glyphs_initialized_initially_p
;
275 /* Updated window if != 0. Set by update_window. */
277 struct window
*updated_window
;
279 /* Glyph row updated in update_window_line, and area that is updated. */
281 struct glyph_row
*updated_row
;
284 /* A glyph for a space. */
286 struct glyph space_glyph
;
288 /* Non-zero means update has been performed directly, so that there's
289 no need for redisplay_internal to do much work. Set by
290 direct_output_for_insert. */
292 int redisplay_performed_directly_p
;
294 /* Counts of allocated structures. These counts serve to diagnose
295 memory leaks and double frees. */
297 int glyph_matrix_count
;
298 int glyph_pool_count
;
300 /* If non-null, the frame whose frame matrices are manipulated. If
301 null, window matrices are worked on. */
303 static struct frame
*frame_matrix_frame
;
305 /* Current interface for window-based redisplay. Set from init_xterm.
306 A null value means we are not using window-based redisplay. */
308 struct redisplay_interface
*rif
;
310 /* Non-zero means that fonts have been loaded since the last glyph
311 matrix adjustments. Redisplay must stop, and glyph matrices must
312 be adjusted when this flag becomes non-zero during display. The
313 reason fonts can be loaded so late is that fonts of fontsets are
318 /* Convert vpos and hpos from frame to window and vice versa.
319 This may only be used for terminal frames. */
323 static int window_to_frame_vpos
P_ ((struct window
*, int));
324 static int window_to_frame_hpos
P_ ((struct window
*, int));
325 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
326 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
328 #else /* GLYPH_DEBUG == 0 */
330 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + XFASTINT ((W)->top))
331 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + XFASTINT ((W)->left))
333 #endif /* GLYPH_DEBUG == 0 */
336 /* Like bcopy except never gets confused by overlap. Let this be the
337 first function defined in this file, or change emacs.c where the
338 address of this function is used. */
341 safe_bcopy (from
, to
, size
)
345 if (size
<= 0 || from
== to
)
348 /* If the source and destination don't overlap, then bcopy can
349 handle it. If they do overlap, but the destination is lower in
350 memory than the source, we'll assume bcopy can handle that. */
351 if (to
< from
|| from
+ size
<= to
)
352 bcopy (from
, to
, size
);
354 /* Otherwise, we'll copy from the end. */
357 register char *endf
= from
+ size
;
358 register char *endt
= to
+ size
;
360 /* If TO - FROM is large, then we should break the copy into
361 nonoverlapping chunks of TO - FROM bytes each. However, if
362 TO - FROM is small, then the bcopy function call overhead
363 makes this not worth it. The crossover point could be about
364 anywhere. Since I don't think the obvious copy loop is too
365 bad, I'm trying to err in its favor. */
370 while (endf
!= from
);
382 bcopy (endf
, endt
, to
- from
);
385 /* If SIZE wasn't a multiple of TO - FROM, there will be a
386 little left over. The amount left over is (endt + (to -
387 from)) - to, which is endt - from. */
388 bcopy (from
, to
, endt
- from
);
395 /***********************************************************************
397 ***********************************************************************/
399 /* Allocate and return a glyph_matrix structure. POOL is the glyph
400 pool from which memory for the matrix should be allocated, or null
401 for window-based redisplay where no glyph pools are used. The
402 member `pool' of the glyph matrix structure returned is set to
403 POOL, the structure is otherwise zeroed. */
405 struct glyph_matrix
*
406 new_glyph_matrix (pool
)
407 struct glyph_pool
*pool
;
409 struct glyph_matrix
*result
;
411 /* Allocate and clear. */
412 result
= (struct glyph_matrix
*) xmalloc (sizeof *result
);
413 bzero (result
, sizeof *result
);
415 /* Increment number of allocated matrices. This count is used
416 to detect memory leaks. */
417 ++glyph_matrix_count
;
419 /* Set pool and return. */
425 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
427 The global counter glyph_matrix_count is decremented when a matrix
428 is freed. If the count gets negative, more structures were freed
429 than allocated, i.e. one matrix was freed more than once or a bogus
430 pointer was passed to this function.
432 If MATRIX->pool is null, this means that the matrix manages its own
433 glyph memory---this is done for matrices on X frames. Freeing the
434 matrix also frees the glyph memory in this case. */
437 free_glyph_matrix (matrix
)
438 struct glyph_matrix
*matrix
;
444 /* Detect the case that more matrices are freed than were
446 if (--glyph_matrix_count
< 0)
449 /* Free glyph memory if MATRIX owns it. */
450 if (matrix
->pool
== NULL
)
451 for (i
= 0; i
< matrix
->rows_allocated
; ++i
)
452 xfree (matrix
->rows
[i
].glyphs
[LEFT_MARGIN_AREA
]);
454 /* Free row structures and the matrix itself. */
455 xfree (matrix
->rows
);
461 /* Return the number of glyphs to reserve for a marginal area of
462 window W. TOTAL_GLYPHS is the number of glyphs in a complete
463 display line of window W. MARGIN gives the width of the marginal
464 area in canonical character units. MARGIN should be an integer
468 margin_glyphs_to_reserve (w
, total_glyphs
, margin
)
475 if (NUMBERP (margin
))
477 int width
= XFASTINT (w
->width
);
478 double d
= max (0, XFLOATINT (margin
));
479 d
= min (width
/ 2 - 1, d
);
480 n
= (int) ((double) total_glyphs
/ width
* d
);
489 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
492 W is null if the function is called for a frame glyph matrix.
493 Otherwise it is the window MATRIX is a member of. X and Y are the
494 indices of the first column and row of MATRIX within the frame
495 matrix, if such a matrix exists. They are zero for purely
496 window-based redisplay. DIM is the needed size of the matrix.
498 In window-based redisplay, where no frame matrices exist, glyph
499 matrices manage their own glyph storage. Otherwise, they allocate
500 storage from a common frame glyph pool which can be found in
503 The reason for this memory management strategy is to avoid complete
504 frame redraws if possible. When we allocate from a common pool, a
505 change of the location or size of a sub-matrix within the pool
506 requires a complete redisplay of the frame because we cannot easily
507 make sure that the current matrices of all windows still agree with
508 what is displayed on the screen. While this is usually fast, it
509 leads to screen flickering. */
512 adjust_glyph_matrix (w
, matrix
, x
, y
, dim
)
514 struct glyph_matrix
*matrix
;
520 int marginal_areas_changed_p
= 0;
521 int header_line_changed_p
= 0;
522 int header_line_p
= 0;
523 int left
= -1, right
= -1;
524 int window_x
, window_y
, window_width
, window_height
;
526 /* See if W had a top line that has disappeared now, or vice versa. */
529 header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
530 header_line_changed_p
= header_line_p
!= matrix
->header_line_p
;
532 matrix
->header_line_p
= header_line_p
;
534 /* Do nothing if MATRIX' size, position, vscroll, and marginal areas
535 haven't changed. This optimization is important because preserving
536 the matrix means preventing redisplay. */
537 if (matrix
->pool
== NULL
)
539 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
540 left
= margin_glyphs_to_reserve (w
, dim
.width
, w
->left_margin_width
);
541 right
= margin_glyphs_to_reserve (w
, dim
.width
, w
->right_margin_width
);
542 xassert (left
>= 0 && right
>= 0);
543 marginal_areas_changed_p
= (left
!= matrix
->left_margin_glyphs
544 || right
!= matrix
->right_margin_glyphs
);
546 if (!marginal_areas_changed_p
548 && !header_line_changed_p
549 && matrix
->window_top_y
== XFASTINT (w
->top
)
550 && matrix
->window_height
== window_height
551 && matrix
->window_vscroll
== w
->vscroll
552 && matrix
->window_width
== window_width
)
556 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
557 if (matrix
->rows_allocated
< dim
.height
)
559 int size
= dim
.height
* sizeof (struct glyph_row
);
560 new_rows
= dim
.height
- matrix
->rows_allocated
;
561 matrix
->rows
= (struct glyph_row
*) xrealloc (matrix
->rows
, size
);
562 bzero (matrix
->rows
+ matrix
->rows_allocated
,
563 new_rows
* sizeof *matrix
->rows
);
564 matrix
->rows_allocated
= dim
.height
;
569 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
570 on a frame not using window-based redisplay. Set up pointers for
571 each row into the glyph pool. */
574 xassert (matrix
->pool
->glyphs
);
578 left
= margin_glyphs_to_reserve (w
, dim
.width
,
579 w
->left_margin_width
);
580 right
= margin_glyphs_to_reserve (w
, dim
.width
,
581 w
->right_margin_width
);
586 for (i
= 0; i
< dim
.height
; ++i
)
588 struct glyph_row
*row
= &matrix
->rows
[i
];
590 row
->glyphs
[LEFT_MARGIN_AREA
]
591 = (matrix
->pool
->glyphs
592 + (y
+ i
) * matrix
->pool
->ncolumns
596 || row
== matrix
->rows
+ dim
.height
- 1
597 || (row
== matrix
->rows
&& matrix
->header_line_p
))
599 row
->glyphs
[TEXT_AREA
]
600 = row
->glyphs
[LEFT_MARGIN_AREA
];
601 row
->glyphs
[RIGHT_MARGIN_AREA
]
602 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
603 row
->glyphs
[LAST_AREA
]
604 = row
->glyphs
[RIGHT_MARGIN_AREA
];
608 row
->glyphs
[TEXT_AREA
]
609 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
610 row
->glyphs
[RIGHT_MARGIN_AREA
]
611 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
612 row
->glyphs
[LAST_AREA
]
613 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
617 matrix
->left_margin_glyphs
= left
;
618 matrix
->right_margin_glyphs
= right
;
622 /* If MATRIX->pool is null, MATRIX is responsible for managing
623 its own memory. Allocate glyph memory from the heap. */
624 if (dim
.width
> matrix
->matrix_w
626 || header_line_changed_p
627 || marginal_areas_changed_p
)
629 struct glyph_row
*row
= matrix
->rows
;
630 struct glyph_row
*end
= row
+ matrix
->rows_allocated
;
634 row
->glyphs
[LEFT_MARGIN_AREA
]
635 = (struct glyph
*) xrealloc (row
->glyphs
[LEFT_MARGIN_AREA
],
637 * sizeof (struct glyph
)));
639 /* The mode line never has marginal areas. */
640 if (row
== matrix
->rows
+ dim
.height
- 1
641 || (row
== matrix
->rows
&& matrix
->header_line_p
))
643 row
->glyphs
[TEXT_AREA
]
644 = row
->glyphs
[LEFT_MARGIN_AREA
];
645 row
->glyphs
[RIGHT_MARGIN_AREA
]
646 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
647 row
->glyphs
[LAST_AREA
]
648 = row
->glyphs
[RIGHT_MARGIN_AREA
];
652 row
->glyphs
[TEXT_AREA
]
653 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
654 row
->glyphs
[RIGHT_MARGIN_AREA
]
655 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
656 row
->glyphs
[LAST_AREA
]
657 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
663 xassert (left
>= 0 && right
>= 0);
664 matrix
->left_margin_glyphs
= left
;
665 matrix
->right_margin_glyphs
= right
;
668 /* Number of rows to be used by MATRIX. */
669 matrix
->nrows
= dim
.height
;
671 /* Mark rows in a current matrix of a window as not having valid
672 contents. It's important to not do this for desired matrices.
673 When Emacs starts, it may already be building desired matrices
674 when this function runs. */
675 if (w
&& matrix
== w
->current_matrix
)
677 /* Optimize the case that only the height has changed (C-x 2,
678 upper window). Invalidate all rows that are no longer part
680 if (!marginal_areas_changed_p
681 && matrix
->window_top_y
== XFASTINT (w
->top
)
682 && matrix
->window_width
== window_width
)
685 while (matrix
->rows
[i
].enabled_p
686 && (MATRIX_ROW_BOTTOM_Y (matrix
->rows
+ i
)
687 < matrix
->window_height
))
690 /* Window end is invalid, if inside of the rows that
692 if (INTEGERP (w
->window_end_vpos
)
693 && XFASTINT (w
->window_end_vpos
) >= i
)
694 w
->window_end_valid
= Qnil
;
696 while (i
< matrix
->nrows
)
697 matrix
->rows
[i
++].enabled_p
= 0;
701 for (i
= 0; i
< matrix
->nrows
; ++i
)
702 matrix
->rows
[i
].enabled_p
= 0;
706 /* Remember last values to be able to optimize frame redraws. */
707 matrix
->matrix_x
= x
;
708 matrix
->matrix_y
= y
;
709 matrix
->matrix_w
= dim
.width
;
710 matrix
->matrix_h
= dim
.height
;
712 /* Record the top y location and height of W at the time the matrix
713 was last adjusted. This is used to optimize redisplay above. */
716 matrix
->window_top_y
= XFASTINT (w
->top
);
717 matrix
->window_height
= window_height
;
718 matrix
->window_width
= window_width
;
719 matrix
->window_vscroll
= w
->vscroll
;
724 /* Reverse the contents of rows in MATRIX between START and END. The
725 contents of the row at END - 1 end up at START, END - 2 at START +
726 1 etc. This is part of the implementation of rotate_matrix (see
730 reverse_rows (matrix
, start
, end
)
731 struct glyph_matrix
*matrix
;
736 for (i
= start
, j
= end
- 1; i
< j
; ++i
, --j
)
738 /* Non-ISO HP/UX compiler doesn't like auto struct
740 struct glyph_row temp
;
741 temp
= matrix
->rows
[i
];
742 matrix
->rows
[i
] = matrix
->rows
[j
];
743 matrix
->rows
[j
] = temp
;
748 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
749 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
750 indices. (Note: this does not copy glyphs, only glyph pointers in
751 row structures are moved around).
753 The algorithm used for rotating the vector was, I believe, first
754 described by Kernighan. See the vector R as consisting of two
755 sub-vectors AB, where A has length BY for BY >= 0. The result
756 after rotating is then BA. Reverse both sub-vectors to get ArBr
757 and reverse the result to get (ArBr)r which is BA. Similar for
761 rotate_matrix (matrix
, first
, last
, by
)
762 struct glyph_matrix
*matrix
;
767 /* Up (rotate left, i.e. towards lower indices). */
769 reverse_rows (matrix
, first
, first
+ by
);
770 reverse_rows (matrix
, first
+ by
, last
);
771 reverse_rows (matrix
, first
, last
);
775 /* Down (rotate right, i.e. towards higher indices). */
776 reverse_rows (matrix
, last
- by
, last
);
777 reverse_rows (matrix
, first
, last
- by
);
778 reverse_rows (matrix
, first
, last
);
783 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
784 with indices START <= index < END. Increment positions by DELTA/
788 increment_matrix_positions (matrix
, start
, end
, delta
, delta_bytes
)
789 struct glyph_matrix
*matrix
;
790 int start
, end
, delta
, delta_bytes
;
792 /* Check that START and END are reasonable values. */
793 xassert (start
>= 0 && start
<= matrix
->nrows
);
794 xassert (end
>= 0 && end
<= matrix
->nrows
);
795 xassert (start
<= end
);
797 for (; start
< end
; ++start
)
798 increment_row_positions (matrix
->rows
+ start
, delta
, delta_bytes
);
802 /* Enable a range of rows in glyph matrix MATRIX. START and END are
803 the row indices of the first and last + 1 row to enable. If
804 ENABLED_P is non-zero, enabled_p flags in rows will be set to 1. */
807 enable_glyph_matrix_rows (matrix
, start
, end
, enabled_p
)
808 struct glyph_matrix
*matrix
;
812 xassert (start
<= end
);
813 xassert (start
>= 0 && start
< matrix
->nrows
);
814 xassert (end
>= 0 && end
<= matrix
->nrows
);
816 for (; start
< end
; ++start
)
817 matrix
->rows
[start
].enabled_p
= enabled_p
!= 0;
823 This empties all rows in MATRIX by setting the enabled_p flag for
824 all rows of the matrix to zero. The function prepare_desired_row
825 will eventually really clear a row when it sees one with a zero
828 Resets update hints to defaults value. The only update hint
829 currently present is the flag MATRIX->no_scrolling_p. */
832 clear_glyph_matrix (matrix
)
833 struct glyph_matrix
*matrix
;
837 enable_glyph_matrix_rows (matrix
, 0, matrix
->nrows
, 0);
838 matrix
->no_scrolling_p
= 0;
843 /* Shift part of the glyph matrix MATRIX of window W up or down.
844 Increment y-positions in glyph rows between START and END by DY,
845 and recompute their visible height. */
848 shift_glyph_matrix (w
, matrix
, start
, end
, dy
)
850 struct glyph_matrix
*matrix
;
855 xassert (start
<= end
);
856 xassert (start
>= 0 && start
< matrix
->nrows
);
857 xassert (end
>= 0 && end
<= matrix
->nrows
);
859 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
860 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
862 for (; start
< end
; ++start
)
864 struct glyph_row
*row
= &matrix
->rows
[start
];
869 row
->visible_height
= row
->height
- (min_y
- row
->y
);
870 else if (row
->y
+ row
->height
> max_y
)
871 row
->visible_height
= row
->height
- (row
->y
+ row
->height
- max_y
);
873 row
->visible_height
= row
->height
;
878 /* Mark all rows in current matrices of frame F as invalid. Marking
879 invalid is done by setting enabled_p to zero for all rows in a
883 clear_current_matrices (f
)
884 register struct frame
*f
;
886 /* Clear frame current matrix, if we have one. */
887 if (f
->current_matrix
)
888 clear_glyph_matrix (f
->current_matrix
);
890 /* Clear the matrix of the menu bar window, if such a window exists.
891 The menu bar window is currently used to display menus on X when
892 no toolkit support is compiled in. */
893 if (WINDOWP (f
->menu_bar_window
))
894 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->current_matrix
);
896 /* Clear the matrix of the tool-bar window, if any. */
897 if (WINDOWP (f
->tool_bar_window
))
898 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
900 /* Clear current window matrices. */
901 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
902 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 0);
906 /* Clear out all display lines of F for a coming redisplay. */
909 clear_desired_matrices (f
)
910 register struct frame
*f
;
912 if (f
->desired_matrix
)
913 clear_glyph_matrix (f
->desired_matrix
);
915 if (WINDOWP (f
->menu_bar_window
))
916 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->desired_matrix
);
918 if (WINDOWP (f
->tool_bar_window
))
919 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->desired_matrix
);
921 /* Do it for window matrices. */
922 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
923 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
927 /* Clear matrices in window tree rooted in W. If DESIRED_P is
928 non-zero clear desired matrices, otherwise clear current matrices. */
931 clear_window_matrices (w
, desired_p
)
937 if (!NILP (w
->hchild
))
939 xassert (WINDOWP (w
->hchild
));
940 clear_window_matrices (XWINDOW (w
->hchild
), desired_p
);
942 else if (!NILP (w
->vchild
))
944 xassert (WINDOWP (w
->vchild
));
945 clear_window_matrices (XWINDOW (w
->vchild
), desired_p
);
950 clear_glyph_matrix (w
->desired_matrix
);
953 clear_glyph_matrix (w
->current_matrix
);
954 w
->window_end_valid
= Qnil
;
958 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
964 /***********************************************************************
967 See dispextern.h for an overall explanation of glyph rows.
968 ***********************************************************************/
970 /* Clear glyph row ROW. Do it in a way that makes it robust against
971 changes in the glyph_row structure, i.e. addition or removal of
972 structure members. */
975 clear_glyph_row (row
)
976 struct glyph_row
*row
;
978 struct glyph
*p
[1 + LAST_AREA
];
979 static struct glyph_row null_row
;
982 p
[LEFT_MARGIN_AREA
] = row
->glyphs
[LEFT_MARGIN_AREA
];
983 p
[TEXT_AREA
] = row
->glyphs
[TEXT_AREA
];
984 p
[RIGHT_MARGIN_AREA
] = row
->glyphs
[RIGHT_MARGIN_AREA
];
985 p
[LAST_AREA
] = row
->glyphs
[LAST_AREA
];
990 /* Restore pointers. */
991 row
->glyphs
[LEFT_MARGIN_AREA
] = p
[LEFT_MARGIN_AREA
];
992 row
->glyphs
[TEXT_AREA
] = p
[TEXT_AREA
];
993 row
->glyphs
[RIGHT_MARGIN_AREA
] = p
[RIGHT_MARGIN_AREA
];
994 row
->glyphs
[LAST_AREA
] = p
[LAST_AREA
];
996 #if 0 /* At some point, some bit-fields of struct glyph were not set,
997 which made glyphs unequal when compared with GLYPH_EQUAL_P.
998 Redisplay outputs such glyphs, and flickering effects were
999 the result. This also depended on the contents of memory
1000 returned by xmalloc. If flickering happens again, activate
1001 the code below If the flickering is gone with that, chances
1002 are that the flickering has the same reason as here. */
1003 bzero (p
[0], (char *) p
[LAST_AREA
] - (char *) p
[0]);
1008 /* Make ROW an empty, enabled row of canonical character height,
1009 in window W starting at y-position Y. */
1012 blank_row (w
, row
, y
)
1014 struct glyph_row
*row
;
1019 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
1020 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
1022 clear_glyph_row (row
);
1024 row
->ascent
= row
->phys_ascent
= 0;
1025 row
->height
= row
->phys_height
= CANON_Y_UNIT (XFRAME (w
->frame
));
1028 row
->visible_height
= row
->height
- (min_y
- row
->y
);
1029 else if (row
->y
+ row
->height
> max_y
)
1030 row
->visible_height
= row
->height
- (row
->y
+ row
->height
- max_y
);
1032 row
->visible_height
= row
->height
;
1038 /* Increment buffer positions in glyph row ROW. DELTA and DELTA_BYTES
1039 are the amounts by which to change positions. Note that the first
1040 glyph of the text area of a row can have a buffer position even if
1041 the used count of the text area is zero. Such rows display line
1045 increment_row_positions (row
, delta
, delta_bytes
)
1046 struct glyph_row
*row
;
1047 int delta
, delta_bytes
;
1051 /* Increment start and end positions. */
1052 MATRIX_ROW_START_CHARPOS (row
) += delta
;
1053 MATRIX_ROW_START_BYTEPOS (row
) += delta_bytes
;
1054 MATRIX_ROW_END_CHARPOS (row
) += delta
;
1055 MATRIX_ROW_END_BYTEPOS (row
) += delta_bytes
;
1057 /* Increment positions in glyphs. */
1058 for (area
= 0; area
< LAST_AREA
; ++area
)
1059 for (i
= 0; i
< row
->used
[area
]; ++i
)
1060 if (BUFFERP (row
->glyphs
[area
][i
].object
)
1061 && row
->glyphs
[area
][i
].charpos
> 0)
1062 row
->glyphs
[area
][i
].charpos
+= delta
;
1064 /* Capture the case of rows displaying a line end. */
1065 if (row
->used
[TEXT_AREA
] == 0
1066 && MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1067 row
->glyphs
[TEXT_AREA
]->charpos
+= delta
;
1072 /* Swap glyphs between two glyph rows A and B. This exchanges glyph
1073 contents, i.e. glyph structure contents are exchanged between A and
1074 B without changing glyph pointers in A and B. */
1077 swap_glyphs_in_rows (a
, b
)
1078 struct glyph_row
*a
, *b
;
1082 for (area
= 0; area
< LAST_AREA
; ++area
)
1084 /* Number of glyphs to swap. */
1085 int max_used
= max (a
->used
[area
], b
->used
[area
]);
1087 /* Start of glyphs in area of row A. */
1088 struct glyph
*glyph_a
= a
->glyphs
[area
];
1090 /* End + 1 of glyphs in area of row A. */
1091 struct glyph
*glyph_a_end
= a
->glyphs
[max_used
];
1093 /* Start of glyphs in area of row B. */
1094 struct glyph
*glyph_b
= b
->glyphs
[area
];
1096 while (glyph_a
< glyph_a_end
)
1098 /* Non-ISO HP/UX compiler doesn't like auto struct
1102 *glyph_a
= *glyph_b
;
1112 /* Exchange pointers to glyph memory between glyph rows A and B. */
1115 swap_glyph_pointers (a
, b
)
1116 struct glyph_row
*a
, *b
;
1119 for (i
= 0; i
< LAST_AREA
+ 1; ++i
)
1121 struct glyph
*temp
= a
->glyphs
[i
];
1122 a
->glyphs
[i
] = b
->glyphs
[i
];
1123 b
->glyphs
[i
] = temp
;
1128 /* Copy glyph row structure FROM to glyph row structure TO, except
1129 that glyph pointers in the structures are left unchanged. */
1132 copy_row_except_pointers (to
, from
)
1133 struct glyph_row
*to
, *from
;
1135 struct glyph
*pointers
[1 + LAST_AREA
];
1137 /* Save glyph pointers of TO. */
1138 bcopy (to
->glyphs
, pointers
, sizeof to
->glyphs
);
1140 /* Do a structure assignment. */
1143 /* Restore original pointers of TO. */
1144 bcopy (pointers
, to
->glyphs
, sizeof to
->glyphs
);
1148 /* Copy contents of glyph row FROM to glyph row TO. Glyph pointers in
1149 TO and FROM are left unchanged. Glyph contents are copied from the
1150 glyph memory of FROM to the glyph memory of TO. Increment buffer
1151 positions in row TO by DELTA/ DELTA_BYTES. */
1154 copy_glyph_row_contents (to
, from
, delta
, delta_bytes
)
1155 struct glyph_row
*to
, *from
;
1156 int delta
, delta_bytes
;
1160 /* This is like a structure assignment TO = FROM, except that
1161 glyph pointers in the rows are left unchanged. */
1162 copy_row_except_pointers (to
, from
);
1164 /* Copy glyphs from FROM to TO. */
1165 for (area
= 0; area
< LAST_AREA
; ++area
)
1166 if (from
->used
[area
])
1167 bcopy (from
->glyphs
[area
], to
->glyphs
[area
],
1168 from
->used
[area
] * sizeof (struct glyph
));
1170 /* Increment buffer positions in TO by DELTA. */
1171 increment_row_positions (to
, delta
, delta_bytes
);
1175 /* Assign glyph row FROM to glyph row TO. This works like a structure
1176 assignment TO = FROM, except that glyph pointers are not copied but
1177 exchanged between TO and FROM. Pointers must be exchanged to avoid
1181 assign_row (to
, from
)
1182 struct glyph_row
*to
, *from
;
1184 swap_glyph_pointers (to
, from
);
1185 copy_row_except_pointers (to
, from
);
1189 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1190 a row in a window matrix, is a slice of the glyph memory of the
1191 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1192 is non-zero if the glyph memory of WINDOW_ROW is part of the glyph
1193 memory of FRAME_ROW. */
1198 glyph_row_slice_p (window_row
, frame_row
)
1199 struct glyph_row
*window_row
, *frame_row
;
1201 struct glyph
*window_glyph_start
= window_row
->glyphs
[0];
1202 struct glyph
*frame_glyph_start
= frame_row
->glyphs
[0];
1203 struct glyph
*frame_glyph_end
= frame_row
->glyphs
[LAST_AREA
];
1205 return (frame_glyph_start
<= window_glyph_start
1206 && window_glyph_start
< frame_glyph_end
);
1209 #endif /* GLYPH_DEBUG */
1213 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1214 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1215 in WINDOW_MATRIX is found satisfying the condition. */
1217 static struct glyph_row
*
1218 find_glyph_row_slice (window_matrix
, frame_matrix
, row
)
1219 struct glyph_matrix
*window_matrix
, *frame_matrix
;
1224 xassert (row
>= 0 && row
< frame_matrix
->nrows
);
1226 for (i
= 0; i
< window_matrix
->nrows
; ++i
)
1227 if (glyph_row_slice_p (window_matrix
->rows
+ i
,
1228 frame_matrix
->rows
+ row
))
1231 return i
< window_matrix
->nrows
? window_matrix
->rows
+ i
: 0;
1236 /* Prepare ROW for display. Desired rows are cleared lazily,
1237 i.e. they are only marked as to be cleared by setting their
1238 enabled_p flag to zero. When a row is to be displayed, a prior
1239 call to this function really clears it. */
1242 prepare_desired_row (row
)
1243 struct glyph_row
*row
;
1245 if (!row
->enabled_p
)
1247 clear_glyph_row (row
);
1253 /* Return a hash code for glyph row ROW. */
1256 line_hash_code (row
)
1257 struct glyph_row
*row
;
1265 /* Give all highlighted lines the same hash code
1266 so as to encourage scrolling to leave them in place. */
1271 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
1272 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
1276 int c
= glyph
->u
.ch
;
1277 int face_id
= glyph
->face_id
;
1278 if (must_write_spaces
)
1280 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + c
;
1281 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + face_id
;
1294 /* Return the cost of drawing line VPOS In MATRIX. The cost equals
1295 the number of characters in the line. If must_write_spaces is
1296 zero, leading and trailing spaces are ignored. */
1299 line_draw_cost (matrix
, vpos
)
1300 struct glyph_matrix
*matrix
;
1303 struct glyph_row
*row
= matrix
->rows
+ vpos
;
1304 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
1305 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
];
1307 Lisp_Object
*glyph_table_base
= GLYPH_TABLE_BASE
;
1308 int glyph_table_len
= GLYPH_TABLE_LENGTH
;
1310 /* Ignore trailing and leading spaces if we can. */
1311 if (!must_write_spaces
)
1313 /* Skip from the end over trailing spaces. */
1314 while (end
!= beg
&& CHAR_GLYPH_SPACE_P (*end
))
1317 /* All blank line. */
1321 /* Skip over leading spaces. */
1322 while (CHAR_GLYPH_SPACE_P (*beg
))
1326 /* If we don't have a glyph-table, each glyph is one character,
1327 so return the number of glyphs. */
1328 if (glyph_table_base
== 0)
1332 /* Otherwise, scan the glyphs and accumulate their total length
1337 GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*beg
);
1340 || GLYPH_SIMPLE_P (glyph_table_base
, glyph_table_len
, g
))
1343 len
+= GLYPH_LENGTH (glyph_table_base
, g
);
1353 /* Test two glyph rows A and B for equality. Value is non-zero if A
1354 and B have equal contents. W is the window to which the glyphs
1355 rows A and B belong. It is needed here to test for partial row
1356 visibility. MOUSE_FACE_P non-zero means compare the mouse_face_p
1357 flags of A and B, too. */
1360 row_equal_p (w
, a
, b
, mouse_face_p
)
1362 struct glyph_row
*a
, *b
;
1367 else if (a
->hash
!= b
->hash
)
1371 struct glyph
*a_glyph
, *b_glyph
, *a_end
;
1374 if (mouse_face_p
&& a
->mouse_face_p
!= b
->mouse_face_p
)
1377 /* Compare glyphs. */
1378 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
1380 if (a
->used
[area
] != b
->used
[area
])
1383 a_glyph
= a
->glyphs
[area
];
1384 a_end
= a_glyph
+ a
->used
[area
];
1385 b_glyph
= b
->glyphs
[area
];
1387 while (a_glyph
< a_end
1388 && GLYPH_EQUAL_P (a_glyph
, b_glyph
))
1389 ++a_glyph
, ++b_glyph
;
1391 if (a_glyph
!= a_end
)
1395 if (a
->truncated_on_left_p
!= b
->truncated_on_left_p
1396 || a
->inverse_p
!= b
->inverse_p
1397 || a
->fill_line_p
!= b
->fill_line_p
1398 || a
->truncated_on_right_p
!= b
->truncated_on_right_p
1399 || a
->overlay_arrow_p
!= b
->overlay_arrow_p
1400 || a
->continued_p
!= b
->continued_p
1401 || a
->indicate_empty_line_p
!= b
->indicate_empty_line_p
1402 || a
->overlapped_p
!= b
->overlapped_p
1403 || (MATRIX_ROW_CONTINUATION_LINE_P (a
)
1404 != MATRIX_ROW_CONTINUATION_LINE_P (b
))
1405 /* Different partially visible characters on left margin. */
1407 /* Different height. */
1408 || a
->ascent
!= b
->ascent
1409 || a
->phys_ascent
!= b
->phys_ascent
1410 || a
->phys_height
!= b
->phys_height
1411 || a
->visible_height
!= b
->visible_height
)
1420 /***********************************************************************
1423 See dispextern.h for an overall explanation of glyph pools.
1424 ***********************************************************************/
1426 /* Allocate a glyph_pool structure. The structure returned is
1427 initialized with zeros. The global variable glyph_pool_count is
1428 incremented for each pool allocated. */
1430 static struct glyph_pool
*
1433 struct glyph_pool
*result
;
1435 /* Allocate a new glyph_pool and clear it. */
1436 result
= (struct glyph_pool
*) xmalloc (sizeof *result
);
1437 bzero (result
, sizeof *result
);
1439 /* For memory leak and double deletion checking. */
1446 /* Free a glyph_pool structure POOL. The function may be called with
1447 a null POOL pointer. The global variable glyph_pool_count is
1448 decremented with every pool structure freed. If this count gets
1449 negative, more structures were freed than allocated, i.e. one
1450 structure must have been freed more than once or a bogus pointer
1451 was passed to free_glyph_pool. */
1454 free_glyph_pool (pool
)
1455 struct glyph_pool
*pool
;
1459 /* More freed than allocated? */
1461 xassert (glyph_pool_count
>= 0);
1463 xfree (pool
->glyphs
);
1469 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1470 columns we need. This function never shrinks a pool. The only
1471 case in which this would make sense, would be when a frame's size
1472 is changed from a large value to a smaller one. But, if someone
1473 does it once, we can expect that he will do it again.
1475 Value is non-zero if the pool changed in a way which makes
1476 re-adjusting window glyph matrices necessary. */
1479 realloc_glyph_pool (pool
, matrix_dim
)
1480 struct glyph_pool
*pool
;
1481 struct dim matrix_dim
;
1486 changed_p
= (pool
->glyphs
== 0
1487 || matrix_dim
.height
!= pool
->nrows
1488 || matrix_dim
.width
!= pool
->ncolumns
);
1490 /* Enlarge the glyph pool. */
1491 needed
= matrix_dim
.width
* matrix_dim
.height
;
1492 if (needed
> pool
->nglyphs
)
1494 int size
= needed
* sizeof (struct glyph
);
1497 pool
->glyphs
= (struct glyph
*) xrealloc (pool
->glyphs
, size
);
1500 pool
->glyphs
= (struct glyph
*) xmalloc (size
);
1501 bzero (pool
->glyphs
, size
);
1504 pool
->nglyphs
= needed
;
1507 /* Remember the number of rows and columns because (a) we use then
1508 to do sanity checks, and (b) the number of columns determines
1509 where rows in the frame matrix start---this must be available to
1510 determine pointers to rows of window sub-matrices. */
1511 pool
->nrows
= matrix_dim
.height
;
1512 pool
->ncolumns
= matrix_dim
.width
;
1519 /***********************************************************************
1521 ***********************************************************************/
1526 /* Flush standard output. This is sometimes useful to call from
1536 /* Check that no glyph pointers have been lost in MATRIX. If a
1537 pointer has been lost, e.g. by using a structure assignment between
1538 rows, at least one pointer must occur more than once in the rows of
1542 check_matrix_pointer_lossage (matrix
)
1543 struct glyph_matrix
*matrix
;
1547 for (i
= 0; i
< matrix
->nrows
; ++i
)
1548 for (j
= 0; j
< matrix
->nrows
; ++j
)
1550 || (matrix
->rows
[i
].glyphs
[TEXT_AREA
]
1551 != matrix
->rows
[j
].glyphs
[TEXT_AREA
]));
1555 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1558 matrix_row (matrix
, row
)
1559 struct glyph_matrix
*matrix
;
1562 xassert (matrix
&& matrix
->rows
);
1563 xassert (row
>= 0 && row
< matrix
->nrows
);
1565 /* That's really too slow for normal testing because this function
1566 is called almost everywhere. Although---it's still astonishingly
1567 fast, so it is valuable to have for debugging purposes. */
1569 check_matrix_pointer_lossage (matrix
);
1572 return matrix
->rows
+ row
;
1576 #if 0 /* This function makes invalid assumptions when text is
1577 partially invisible. But it might come handy for debugging
1580 /* Check invariants that must hold for an up to date current matrix of
1584 check_matrix_invariants (w
)
1587 struct glyph_matrix
*matrix
= w
->current_matrix
;
1588 int yb
= window_text_bottom_y (w
);
1589 struct glyph_row
*row
= matrix
->rows
;
1590 struct glyph_row
*last_text_row
= NULL
;
1591 struct buffer
*saved
= current_buffer
;
1592 struct buffer
*buffer
= XBUFFER (w
->buffer
);
1595 /* This can sometimes happen for a fresh window. */
1596 if (matrix
->nrows
< 2)
1599 set_buffer_temp (buffer
);
1601 /* Note: last row is always reserved for the mode line. */
1602 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1603 && MATRIX_ROW_BOTTOM_Y (row
) < yb
)
1605 struct glyph_row
*next
= row
+ 1;
1607 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1608 last_text_row
= row
;
1610 /* Check that character and byte positions are in sync. */
1611 xassert (MATRIX_ROW_START_BYTEPOS (row
)
1612 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row
)));
1614 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1615 have such a position temporarily in case of a minibuffer
1616 displaying something like `[Sole completion]' at its end. */
1617 if (MATRIX_ROW_END_CHARPOS (row
) < BUF_ZV (current_buffer
))
1618 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1619 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row
)));
1621 /* Check that end position of `row' is equal to start position
1623 if (next
->enabled_p
&& MATRIX_ROW_DISPLAYS_TEXT_P (next
))
1625 xassert (MATRIX_ROW_END_CHARPOS (row
)
1626 == MATRIX_ROW_START_CHARPOS (next
));
1627 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1628 == MATRIX_ROW_START_BYTEPOS (next
));
1633 xassert (w
->current_matrix
->nrows
== w
->desired_matrix
->nrows
);
1634 xassert (w
->desired_matrix
->rows
!= NULL
);
1635 set_buffer_temp (saved
);
1640 #endif /* GLYPH_DEBUG != 0 */
1644 /**********************************************************************
1645 Allocating/ Adjusting Glyph Matrices
1646 **********************************************************************/
1648 /* Allocate glyph matrices over a window tree for a frame-based
1651 X and Y are column/row within the frame glyph matrix where
1652 sub-matrices for the window tree rooted at WINDOW must be
1653 allocated. CH_DIM contains the dimensions of the smallest
1654 character that could be used during display. DIM_ONLY_P non-zero
1655 means that the caller of this function is only interested in the
1656 result matrix dimension, and matrix adjustments should not be
1659 The function returns the total width/height of the sub-matrices of
1660 the window tree. If called on a frame root window, the computation
1661 will take the mini-buffer window into account.
1663 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1665 NEW_LEAF_MATRIX set if any window in the tree did not have a
1666 glyph matrices yet, and
1668 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1669 any window in the tree will be changed or have been changed (see
1672 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1675 Windows are arranged into chains of windows on the same level
1676 through the next fields of window structures. Such a level can be
1677 either a sequence of horizontally adjacent windows from left to
1678 right, or a sequence of vertically adjacent windows from top to
1679 bottom. Each window in a horizontal sequence can be either a leaf
1680 window or a vertical sequence; a window in a vertical sequence can
1681 be either a leaf or a horizontal sequence. All windows in a
1682 horizontal sequence have the same height, and all windows in a
1683 vertical sequence have the same width.
1685 This function uses, for historical reasons, a more general
1686 algorithm to determine glyph matrix dimensions that would be
1689 The matrix height of a horizontal sequence is determined by the
1690 maximum height of any matrix in the sequence. The matrix width of
1691 a horizontal sequence is computed by adding up matrix widths of
1692 windows in the sequence.
1694 |<------- result width ------->|
1695 +---------+----------+---------+ ---
1698 +---------+ | | result height
1703 The matrix width of a vertical sequence is the maximum matrix width
1704 of any window in the sequence. Its height is computed by adding up
1705 matrix heights of windows in the sequence.
1707 |<---- result width -->|
1715 +------------+---------+ |
1718 +------------+---------+ --- */
1720 /* Bit indicating that a new matrix will be allocated or has been
1723 #define NEW_LEAF_MATRIX (1 << 0)
1725 /* Bit indicating that a matrix will or has changed its location or
1728 #define CHANGED_LEAF_MATRIX (1 << 1)
1731 allocate_matrices_for_frame_redisplay (window
, x
, y
, ch_dim
,
1732 dim_only_p
, window_change_flags
)
1737 int *window_change_flags
;
1739 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1741 int wmax
= 0, hmax
= 0;
1745 int in_horz_combination_p
;
1747 /* What combination is WINDOW part of? Compute this once since the
1748 result is the same for all windows in the `next' chain. The
1749 special case of a root window (parent equal to nil) is treated
1750 like a vertical combination because a root window's `next'
1751 points to the mini-buffer window, if any, which is arranged
1752 vertically below other windows. */
1753 in_horz_combination_p
1754 = (!NILP (XWINDOW (window
)->parent
)
1755 && !NILP (XWINDOW (XWINDOW (window
)->parent
)->hchild
));
1757 /* For WINDOW and all windows on the same level. */
1760 w
= XWINDOW (window
);
1762 /* Get the dimension of the window sub-matrix for W, depending
1763 on whether this a combination or a leaf window. */
1764 if (!NILP (w
->hchild
))
1765 dim
= allocate_matrices_for_frame_redisplay (w
->hchild
, x
, y
, ch_dim
,
1767 window_change_flags
);
1768 else if (!NILP (w
->vchild
))
1769 dim
= allocate_matrices_for_frame_redisplay (w
->vchild
, x
, y
, ch_dim
,
1771 window_change_flags
);
1774 /* If not already done, allocate sub-matrix structures. */
1775 if (w
->desired_matrix
== NULL
)
1777 w
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1778 w
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1779 *window_change_flags
|= NEW_LEAF_MATRIX
;
1782 /* Width and height MUST be chosen so that there are no
1783 holes in the frame matrix. */
1784 dim
.width
= XINT (w
->width
);
1785 dim
.height
= XINT (w
->height
);
1787 /* Will matrix be re-allocated? */
1788 if (x
!= w
->desired_matrix
->matrix_x
1789 || y
!= w
->desired_matrix
->matrix_y
1790 || dim
.width
!= w
->desired_matrix
->matrix_w
1791 || dim
.height
!= w
->desired_matrix
->matrix_h
1792 || (margin_glyphs_to_reserve (w
, dim
.width
,
1793 w
->right_margin_width
)
1794 != w
->desired_matrix
->left_margin_glyphs
)
1795 || (margin_glyphs_to_reserve (w
, dim
.width
,
1796 w
->left_margin_width
)
1797 != w
->desired_matrix
->right_margin_glyphs
))
1798 *window_change_flags
|= CHANGED_LEAF_MATRIX
;
1800 /* Actually change matrices, if allowed. Do not consider
1801 CHANGED_LEAF_MATRIX computed above here because the pool
1802 may have been changed which we don't now here. We trust
1803 that we only will be called with DIM_ONLY_P != 0 when
1807 adjust_glyph_matrix (w
, w
->desired_matrix
, x
, y
, dim
);
1808 adjust_glyph_matrix (w
, w
->current_matrix
, x
, y
, dim
);
1812 /* If we are part of a horizontal combination, advance x for
1813 windows to the right of W; otherwise advance y for windows
1815 if (in_horz_combination_p
)
1820 /* Remember maximum glyph matrix dimensions. */
1821 wmax
= max (wmax
, dim
.width
);
1822 hmax
= max (hmax
, dim
.height
);
1824 /* Next window on same level. */
1827 while (!NILP (window
));
1829 /* Set `total' to the total glyph matrix dimension of this window
1830 level. In a vertical combination, the width is the width of the
1831 widest window; the height is the y we finally reached, corrected
1832 by the y we started with. In a horizontal combination, the total
1833 height is the height of the tallest window, and the width is the
1834 x we finally reached, corrected by the x we started with. */
1835 if (in_horz_combination_p
)
1837 total
.width
= x
- x0
;
1838 total
.height
= hmax
;
1843 total
.height
= y
- y0
;
1850 /* Allocate window matrices for window-based redisplay. W is the
1851 window whose matrices must be allocated/reallocated. CH_DIM is the
1852 size of the smallest character that could potentially be used on W. */
1855 allocate_matrices_for_window_redisplay (w
, ch_dim
)
1859 struct frame
*f
= XFRAME (w
->frame
);
1863 if (!NILP (w
->vchild
))
1864 allocate_matrices_for_window_redisplay (XWINDOW (w
->vchild
), ch_dim
);
1865 else if (!NILP (w
->hchild
))
1866 allocate_matrices_for_window_redisplay (XWINDOW (w
->hchild
), ch_dim
);
1869 /* W is a leaf window. */
1870 int window_pixel_width
= XFLOATINT (w
->width
) * CANON_X_UNIT (f
);
1871 int window_pixel_height
= window_box_height (w
) + abs (w
->vscroll
);
1874 /* If matrices are not yet allocated, allocate them now. */
1875 if (w
->desired_matrix
== NULL
)
1877 w
->desired_matrix
= new_glyph_matrix (NULL
);
1878 w
->current_matrix
= new_glyph_matrix (NULL
);
1881 /* Compute number of glyphs needed in a glyph row. */
1882 dim
.width
= (((window_pixel_width
+ ch_dim
.width
- 1)
1884 /* 2 partially visible columns in the text area. */
1886 /* One partially visible column at the right
1887 edge of each marginal area. */
1890 /* Compute number of glyph rows needed. */
1891 dim
.height
= (((window_pixel_height
+ ch_dim
.height
- 1)
1893 /* One partially visible line at the top and
1894 bottom of the window. */
1896 /* 2 for top and mode line. */
1899 /* Change matrices. */
1900 adjust_glyph_matrix (w
, w
->desired_matrix
, 0, 0, dim
);
1901 adjust_glyph_matrix (w
, w
->current_matrix
, 0, 0, dim
);
1904 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
1909 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
1910 do it for all frames; otherwise do it just for the given frame.
1911 This function must be called when a new frame is created, its size
1912 changes, or its window configuration changes. */
1918 /* Block input so that expose events and other events that access
1919 glyph matrices are not processed while we are changing them. */
1923 adjust_frame_glyphs (f
);
1926 Lisp_Object tail
, lisp_frame
;
1928 FOR_EACH_FRAME (tail
, lisp_frame
)
1929 adjust_frame_glyphs (XFRAME (lisp_frame
));
1936 /* Adjust frame glyphs when Emacs is initialized.
1938 To be called from init_display.
1940 We need a glyph matrix because redraw will happen soon.
1941 Unfortunately, window sizes on selected_frame are not yet set to
1942 meaningful values. I believe we can assume that there are only two
1943 windows on the frame---the mini-buffer and the root window. Frame
1944 height and width seem to be correct so far. So, set the sizes of
1945 windows to estimated values. */
1948 adjust_frame_glyphs_initially ()
1950 struct frame
*sf
= SELECTED_FRAME ();
1951 struct window
*root
= XWINDOW (sf
->root_window
);
1952 struct window
*mini
= XWINDOW (root
->next
);
1953 int frame_height
= FRAME_HEIGHT (sf
);
1954 int frame_width
= FRAME_WIDTH (sf
);
1955 int top_margin
= FRAME_TOP_MARGIN (sf
);
1957 /* Do it for the root window. */
1958 XSETFASTINT (root
->top
, top_margin
);
1959 XSETFASTINT (root
->width
, frame_width
);
1960 set_window_height (sf
->root_window
, frame_height
- 1 - top_margin
, 0);
1962 /* Do it for the mini-buffer window. */
1963 XSETFASTINT (mini
->top
, frame_height
- 1);
1964 XSETFASTINT (mini
->width
, frame_width
);
1965 set_window_height (root
->next
, 1, 0);
1967 adjust_frame_glyphs (sf
);
1968 glyphs_initialized_initially_p
= 1;
1972 /* Allocate/reallocate glyph matrices of a single frame F. */
1975 adjust_frame_glyphs (f
)
1978 if (FRAME_WINDOW_P (f
))
1979 adjust_frame_glyphs_for_window_redisplay (f
);
1981 adjust_frame_glyphs_for_frame_redisplay (f
);
1983 /* Don't forget the message buffer and the buffer for
1984 decode_mode_spec. */
1985 adjust_frame_message_buffer (f
);
1986 adjust_decode_mode_spec_buffer (f
);
1988 f
->glyphs_initialized_p
= 1;
1992 /* Allocate/reallocate glyph matrices of a single frame F for
1993 frame-based redisplay. */
1996 adjust_frame_glyphs_for_frame_redisplay (f
)
2000 struct dim matrix_dim
;
2002 int window_change_flags
;
2005 if (!FRAME_LIVE_P (f
))
2008 /* Determine the smallest character in any font for F. On
2009 console windows, all characters have dimension (1, 1). */
2010 ch_dim
.width
= ch_dim
.height
= 1;
2012 top_window_y
= FRAME_TOP_MARGIN (f
);
2014 /* Allocate glyph pool structures if not already done. */
2015 if (f
->desired_pool
== NULL
)
2017 f
->desired_pool
= new_glyph_pool ();
2018 f
->current_pool
= new_glyph_pool ();
2021 /* Allocate frames matrix structures if needed. */
2022 if (f
->desired_matrix
== NULL
)
2024 f
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
2025 f
->current_matrix
= new_glyph_matrix (f
->current_pool
);
2028 /* Compute window glyph matrices. (This takes the mini-buffer
2029 window into account). The result is the size of the frame glyph
2030 matrix needed. The variable window_change_flags is set to a bit
2031 mask indicating whether new matrices will be allocated or
2032 existing matrices change their size or location within the frame
2034 window_change_flags
= 0;
2036 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2039 &window_change_flags
);
2041 /* Add in menu bar lines, if any. */
2042 matrix_dim
.height
+= top_window_y
;
2044 /* Enlarge pools as necessary. */
2045 pool_changed_p
= realloc_glyph_pool (f
->desired_pool
, matrix_dim
);
2046 realloc_glyph_pool (f
->current_pool
, matrix_dim
);
2048 /* Set up glyph pointers within window matrices. Do this only if
2049 absolutely necessary since it requires a frame redraw. */
2050 if (pool_changed_p
|| window_change_flags
)
2052 /* Do it for window matrices. */
2053 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2054 0, top_window_y
, ch_dim
, 0,
2055 &window_change_flags
);
2057 /* Size of frame matrices must equal size of frame. Note
2058 that we are called for X frames with window widths NOT equal
2059 to the frame width (from CHANGE_FRAME_SIZE_1). */
2060 xassert (matrix_dim
.width
== FRAME_WIDTH (f
)
2061 && matrix_dim
.height
== FRAME_HEIGHT (f
));
2063 /* Resize frame matrices. */
2064 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2065 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2067 /* Since location and size of sub-matrices within the pool may
2068 have changed, and current matrices don't have meaningful
2069 contents anymore, mark the frame garbaged. */
2070 SET_FRAME_GARBAGED (f
);
2075 /* Allocate/reallocate glyph matrices of a single frame F for
2076 window-based redisplay. */
2079 adjust_frame_glyphs_for_window_redisplay (f
)
2085 xassert (FRAME_WINDOW_P (f
) && FRAME_LIVE_P (f
));
2087 /* Get minimum sizes. */
2088 #ifdef HAVE_WINDOW_SYSTEM
2089 ch_dim
.width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2090 ch_dim
.height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
2092 ch_dim
.width
= ch_dim
.height
= 1;
2095 /* Allocate/reallocate window matrices. */
2096 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f
)),
2099 /* Allocate/ reallocate matrices of the dummy window used to display
2100 the menu bar under X when no X toolkit support is available. */
2101 #ifndef USE_X_TOOLKIT
2103 /* Allocate a dummy window if not already done. */
2104 if (NILP (f
->menu_bar_window
))
2106 f
->menu_bar_window
= make_window ();
2107 w
= XWINDOW (f
->menu_bar_window
);
2108 XSETFRAME (w
->frame
, f
);
2109 w
->pseudo_window_p
= 1;
2112 w
= XWINDOW (f
->menu_bar_window
);
2114 /* Set window dimensions to frame dimensions and allocate or
2115 adjust glyph matrices of W. */
2116 XSETFASTINT (w
->top
, 0);
2117 XSETFASTINT (w
->left
, 0);
2118 XSETFASTINT (w
->height
, FRAME_MENU_BAR_LINES (f
));
2119 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2120 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2122 #endif /* not USE_X_TOOLKIT */
2124 /* Allocate/ reallocate matrices of the tool bar window. If we
2125 don't have a tool bar window yet, make one. */
2126 if (NILP (f
->tool_bar_window
))
2128 f
->tool_bar_window
= make_window ();
2129 w
= XWINDOW (f
->tool_bar_window
);
2130 XSETFRAME (w
->frame
, f
);
2131 w
->pseudo_window_p
= 1;
2134 w
= XWINDOW (f
->tool_bar_window
);
2136 XSETFASTINT (w
->top
, FRAME_MENU_BAR_LINES (f
));
2137 XSETFASTINT (w
->left
, 0);
2138 XSETFASTINT (w
->height
, FRAME_TOOL_BAR_LINES (f
));
2139 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2140 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2144 /* Adjust/ allocate message buffer of frame F.
2146 Note that the message buffer is never freed. Since I could not
2147 find a free in 19.34, I assume that freeing it would be
2148 problematic in some way and don't do it either.
2150 (Implementation note: It should be checked if we can free it
2151 eventually without causing trouble). */
2154 adjust_frame_message_buffer (f
)
2157 int size
= FRAME_MESSAGE_BUF_SIZE (f
) + 1;
2159 if (FRAME_MESSAGE_BUF (f
))
2161 char *buffer
= FRAME_MESSAGE_BUF (f
);
2162 char *new_buffer
= (char *) xrealloc (buffer
, size
);
2163 FRAME_MESSAGE_BUF (f
) = new_buffer
;
2166 FRAME_MESSAGE_BUF (f
) = (char *) xmalloc (size
);
2170 /* Re-allocate buffer for decode_mode_spec on frame F. */
2173 adjust_decode_mode_spec_buffer (f
)
2176 f
->decode_mode_spec_buffer
2177 = (char *) xrealloc (f
->decode_mode_spec_buffer
,
2178 FRAME_MESSAGE_BUF_SIZE (f
) + 1);
2183 /**********************************************************************
2184 Freeing Glyph Matrices
2185 **********************************************************************/
2187 /* Free glyph memory for a frame F. F may be null. This function can
2188 be called for the same frame more than once. The root window of
2189 F may be nil when this function is called. This is the case when
2190 the function is called when F is destroyed. */
2196 if (f
&& f
->glyphs_initialized_p
)
2198 /* Block interrupt input so that we don't get surprised by an X
2199 event while we're in an inconsistent state. */
2201 f
->glyphs_initialized_p
= 0;
2203 /* Release window sub-matrices. */
2204 if (!NILP (f
->root_window
))
2205 free_window_matrices (XWINDOW (f
->root_window
));
2207 /* Free the dummy window for menu bars without X toolkit and its
2209 if (!NILP (f
->menu_bar_window
))
2211 struct window
*w
= XWINDOW (f
->menu_bar_window
);
2212 free_glyph_matrix (w
->desired_matrix
);
2213 free_glyph_matrix (w
->current_matrix
);
2214 w
->desired_matrix
= w
->current_matrix
= NULL
;
2215 f
->menu_bar_window
= Qnil
;
2218 /* Free the tool bar window and its glyph matrices. */
2219 if (!NILP (f
->tool_bar_window
))
2221 struct window
*w
= XWINDOW (f
->tool_bar_window
);
2222 free_glyph_matrix (w
->desired_matrix
);
2223 free_glyph_matrix (w
->current_matrix
);
2224 w
->desired_matrix
= w
->current_matrix
= NULL
;
2225 f
->tool_bar_window
= Qnil
;
2228 /* Release frame glyph matrices. Reset fields to zero in
2229 case we are called a second time. */
2230 if (f
->desired_matrix
)
2232 free_glyph_matrix (f
->desired_matrix
);
2233 free_glyph_matrix (f
->current_matrix
);
2234 f
->desired_matrix
= f
->current_matrix
= NULL
;
2237 /* Release glyph pools. */
2238 if (f
->desired_pool
)
2240 free_glyph_pool (f
->desired_pool
);
2241 free_glyph_pool (f
->current_pool
);
2242 f
->desired_pool
= f
->current_pool
= NULL
;
2250 /* Free glyph sub-matrices in the window tree rooted at W. This
2251 function may be called with a null pointer, and it may be called on
2252 the same tree more than once. */
2255 free_window_matrices (w
)
2260 if (!NILP (w
->hchild
))
2261 free_window_matrices (XWINDOW (w
->hchild
));
2262 else if (!NILP (w
->vchild
))
2263 free_window_matrices (XWINDOW (w
->vchild
));
2266 /* This is a leaf window. Free its memory and reset fields
2267 to zero in case this function is called a second time for
2269 free_glyph_matrix (w
->current_matrix
);
2270 free_glyph_matrix (w
->desired_matrix
);
2271 w
->current_matrix
= w
->desired_matrix
= NULL
;
2274 /* Next window on same level. */
2275 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2280 /* Check glyph memory leaks. This function is called from
2281 shut_down_emacs. Note that frames are not destroyed when Emacs
2282 exits. We therefore free all glyph memory for all active frames
2283 explicitly and check that nothing is left allocated. */
2286 check_glyph_memory ()
2288 Lisp_Object tail
, frame
;
2290 /* Free glyph memory for all frames. */
2291 FOR_EACH_FRAME (tail
, frame
)
2292 free_glyphs (XFRAME (frame
));
2294 /* Check that nothing is left allocated. */
2295 if (glyph_matrix_count
)
2297 if (glyph_pool_count
)
2303 /**********************************************************************
2304 Building a Frame Matrix
2305 **********************************************************************/
2307 /* Most of the redisplay code works on glyph matrices attached to
2308 windows. This is a good solution most of the time, but it is not
2309 suitable for terminal code. Terminal output functions cannot rely
2310 on being able to set an arbitrary terminal window. Instead they
2311 must be provided with a view of the whole frame, i.e. the whole
2312 screen. We build such a view by constructing a frame matrix from
2313 window matrices in this section.
2315 Windows that must be updated have their must_be_update_p flag set.
2316 For all such windows, their desired matrix is made part of the
2317 desired frame matrix. For other windows, their current matrix is
2318 made part of the desired frame matrix.
2320 +-----------------+----------------+
2321 | desired | desired |
2323 +-----------------+----------------+
2326 +----------------------------------+
2328 Desired window matrices can be made part of the frame matrix in a
2329 cheap way: We exploit the fact that the desired frame matrix and
2330 desired window matrices share their glyph memory. This is not
2331 possible for current window matrices. Their glyphs are copied to
2332 the desired frame matrix. The latter is equivalent to
2333 preserve_other_columns in the old redisplay.
2335 Used glyphs counters for frame matrix rows are the result of adding
2336 up glyph lengths of the window matrices. A line in the frame
2337 matrix is enabled, if a corresponding line in a window matrix is
2340 After building the desired frame matrix, it will be passed to
2341 terminal code, which will manipulate both the desired and current
2342 frame matrix. Changes applied to the frame's current matrix have
2343 to be visible in current window matrices afterwards, of course.
2345 This problem is solved like this:
2347 1. Window and frame matrices share glyphs. Window matrices are
2348 constructed in a way that their glyph contents ARE the glyph
2349 contents needed in a frame matrix. Thus, any modification of
2350 glyphs done in terminal code will be reflected in window matrices
2353 2. Exchanges of rows in a frame matrix done by terminal code are
2354 intercepted by hook functions so that corresponding row operations
2355 on window matrices can be performed. This is necessary because we
2356 use pointers to glyphs in glyph row structures. To satisfy the
2357 assumption of point 1 above that glyphs are updated implicitly in
2358 window matrices when they are manipulated via the frame matrix,
2359 window and frame matrix must of course agree where to find the
2360 glyphs for their rows. Possible manipulations that must be
2361 mirrored are assignments of rows of the desired frame matrix to the
2362 current frame matrix and scrolling the current frame matrix. */
2364 /* Build frame F's desired matrix from window matrices. Only windows
2365 which have the flag must_be_updated_p set have to be updated. Menu
2366 bar lines of a frame are not covered by window matrices, so make
2367 sure not to touch them in this function. */
2370 build_frame_matrix (f
)
2375 /* F must have a frame matrix when this function is called. */
2376 xassert (!FRAME_WINDOW_P (f
));
2378 /* Clear all rows in the frame matrix covered by window matrices.
2379 Menu bar lines are not covered by windows. */
2380 for (i
= FRAME_TOP_MARGIN (f
); i
< f
->desired_matrix
->nrows
; ++i
)
2381 clear_glyph_row (MATRIX_ROW (f
->desired_matrix
, i
));
2383 /* Build the matrix by walking the window tree. */
2384 build_frame_matrix_from_window_tree (f
->desired_matrix
,
2385 XWINDOW (FRAME_ROOT_WINDOW (f
)));
2389 /* Walk a window tree, building a frame matrix MATRIX from window
2390 matrices. W is the root of a window tree. */
2393 build_frame_matrix_from_window_tree (matrix
, w
)
2394 struct glyph_matrix
*matrix
;
2399 if (!NILP (w
->hchild
))
2400 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->hchild
));
2401 else if (!NILP (w
->vchild
))
2402 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->vchild
));
2404 build_frame_matrix_from_leaf_window (matrix
, w
);
2406 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2411 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2412 desired frame matrix built. W is a leaf window whose desired or
2413 current matrix is to be added to FRAME_MATRIX. W's flag
2414 must_be_updated_p determines which matrix it contributes to
2415 FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix
2416 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2417 Adding a desired matrix means setting up used counters and such in
2418 frame rows, while adding a current window matrix to FRAME_MATRIX
2419 means copying glyphs. The latter case corresponds to
2420 preserve_other_columns in the old redisplay. */
2423 build_frame_matrix_from_leaf_window (frame_matrix
, w
)
2424 struct glyph_matrix
*frame_matrix
;
2427 struct glyph_matrix
*window_matrix
;
2428 int window_y
, frame_y
;
2429 /* If non-zero, a glyph to insert at the right border of W. */
2430 GLYPH right_border_glyph
= 0;
2432 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2433 if (w
->must_be_updated_p
)
2435 window_matrix
= w
->desired_matrix
;
2437 /* Decide whether we want to add a vertical border glyph. */
2438 if (!WINDOW_RIGHTMOST_P (w
))
2440 struct Lisp_Char_Table
*dp
= window_display_table (w
);
2441 right_border_glyph
= (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
2442 ? XINT (DISP_BORDER_GLYPH (dp
))
2447 window_matrix
= w
->current_matrix
;
2449 /* For all rows in the window matrix and corresponding rows in the
2452 frame_y
= window_matrix
->matrix_y
;
2453 while (window_y
< window_matrix
->nrows
)
2455 struct glyph_row
*frame_row
= frame_matrix
->rows
+ frame_y
;
2456 struct glyph_row
*window_row
= window_matrix
->rows
+ window_y
;
2457 int current_row_p
= window_matrix
== w
->current_matrix
;
2459 /* Fill up the frame row with spaces up to the left margin of the
2461 fill_up_frame_row_with_spaces (frame_row
, window_matrix
->matrix_x
);
2463 /* Fill up areas in the window matrix row with spaces. */
2464 fill_up_glyph_row_with_spaces (window_row
);
2466 /* If only part of W's desired matrix has been built, and
2467 window_row wasn't displayed, use the corresponding current
2469 if (window_matrix
== w
->desired_matrix
2470 && !window_row
->enabled_p
)
2472 window_row
= w
->current_matrix
->rows
+ window_y
;
2478 /* Copy window row to frame row. */
2479 bcopy (window_row
->glyphs
[0],
2480 frame_row
->glyphs
[TEXT_AREA
] + window_matrix
->matrix_x
,
2481 window_matrix
->matrix_w
* sizeof (struct glyph
));
2485 xassert (window_row
->enabled_p
);
2487 /* Only when a desired row has been displayed, we want
2488 the corresponding frame row to be updated. */
2489 frame_row
->enabled_p
= 1;
2491 /* Maybe insert a vertical border between horizontally adjacent
2493 if (right_border_glyph
)
2495 struct glyph
*border
= window_row
->glyphs
[LAST_AREA
] - 1;
2496 SET_CHAR_GLYPH_FROM_GLYPH (*border
, right_border_glyph
);
2499 #if 0 /* This shouldn't be necessary. Let's check it. */
2500 /* Due to hooks installed, it normally doesn't happen that
2501 window rows and frame rows of the same matrix are out of
2502 sync, i.e. have a different understanding of where to
2503 find glyphs for the row. The following is a safety-belt
2504 that doesn't cost much and makes absolutely sure that
2505 window and frame matrices are in sync. */
2506 if (!glyph_row_slice_p (window_row
, frame_row
))
2508 /* Find the row in the window being a slice. There
2509 should exist one from program logic. */
2510 struct glyph_row
*slice_row
2511 = find_glyph_row_slice (window_matrix
, frame_matrix
, frame_y
);
2512 xassert (slice_row
!= 0);
2514 /* Exchange glyphs between both window rows. */
2515 swap_glyphs_in_rows (window_row
, slice_row
);
2517 /* Exchange pointers between both rows. */
2518 swap_glyph_pointers (window_row
, slice_row
);
2522 /* Window row window_y must be a slice of frame row
2524 xassert (glyph_row_slice_p (window_row
, frame_row
));
2526 /* If rows are in sync, we don't have to copy glyphs because
2527 frame and window share glyphs. */
2530 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
2534 /* Set number of used glyphs in the frame matrix. Since we fill
2535 up with spaces, and visit leaf windows from left to right it
2536 can be done simply. */
2537 frame_row
->used
[TEXT_AREA
]
2538 = window_matrix
->matrix_x
+ window_matrix
->matrix_w
;
2540 /* Or in other flags. */
2541 frame_row
->inverse_p
|= window_row
->inverse_p
;
2550 /* Add spaces to a glyph row ROW in a window matrix.
2552 Each row has the form:
2554 +---------+-----------------------------+------------+
2555 | left | text | right |
2556 +---------+-----------------------------+------------+
2558 Left and right marginal areas are optional. This function adds
2559 spaces to areas so that there are no empty holes between areas.
2560 In other words: If the right area is not empty, the text area
2561 is filled up with spaces up to the right area. If the text area
2562 is not empty, the left area is filled up.
2564 To be called for frame-based redisplay, only. */
2567 fill_up_glyph_row_with_spaces (row
)
2568 struct glyph_row
*row
;
2570 fill_up_glyph_row_area_with_spaces (row
, LEFT_MARGIN_AREA
);
2571 fill_up_glyph_row_area_with_spaces (row
, TEXT_AREA
);
2572 fill_up_glyph_row_area_with_spaces (row
, RIGHT_MARGIN_AREA
);
2576 /* Fill area AREA of glyph row ROW with spaces. To be called for
2577 frame-based redisplay only. */
2580 fill_up_glyph_row_area_with_spaces (row
, area
)
2581 struct glyph_row
*row
;
2584 if (row
->glyphs
[area
] < row
->glyphs
[area
+ 1])
2586 struct glyph
*end
= row
->glyphs
[area
+ 1];
2587 struct glyph
*text
= row
->glyphs
[area
] + row
->used
[area
];
2590 *text
++ = space_glyph
;
2591 row
->used
[area
] = text
- row
->glyphs
[area
];
2596 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2597 reached. In frame matrices only one area, TEXT_AREA, is used. */
2600 fill_up_frame_row_with_spaces (row
, upto
)
2601 struct glyph_row
*row
;
2604 int i
= row
->used
[TEXT_AREA
];
2605 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
2608 glyph
[i
++] = space_glyph
;
2610 row
->used
[TEXT_AREA
] = i
;
2615 /**********************************************************************
2616 Mirroring operations on frame matrices in window matrices
2617 **********************************************************************/
2619 /* Set frame being updated via frame-based redisplay to F. This
2620 function must be called before updates to make explicit that we are
2621 working on frame matrices or not. */
2624 set_frame_matrix_frame (f
)
2627 frame_matrix_frame
= f
;
2631 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2632 DESIRED_MATRIX is the desired matrix corresponding to
2633 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2634 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2635 frame_matrix_frame is non-null, this indicates that the exchange is
2636 done in frame matrices, and that we have to perform analogous
2637 operations in window matrices of frame_matrix_frame. */
2640 make_current (desired_matrix
, current_matrix
, row
)
2641 struct glyph_matrix
*desired_matrix
, *current_matrix
;
2644 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, row
);
2645 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, row
);
2646 int mouse_face_p
= current_row
->mouse_face_p
;
2648 /* Do current_row = desired_row. This exchanges glyph pointers
2649 between both rows, and does a structure assignment otherwise. */
2650 assign_row (current_row
, desired_row
);
2652 /* Enable current_row to mark it as valid. */
2653 current_row
->enabled_p
= 1;
2654 current_row
->mouse_face_p
= mouse_face_p
;
2656 /* If we are called on frame matrices, perform analogous operations
2657 for window matrices. */
2658 if (frame_matrix_frame
)
2659 mirror_make_current (XWINDOW (frame_matrix_frame
->root_window
), row
);
2663 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2664 W's frame which has been made current (by swapping pointers between
2665 current and desired matrix). Perform analogous operations in the
2666 matrices of leaf windows in the window tree rooted at W. */
2669 mirror_make_current (w
, frame_row
)
2675 if (!NILP (w
->hchild
))
2676 mirror_make_current (XWINDOW (w
->hchild
), frame_row
);
2677 else if (!NILP (w
->vchild
))
2678 mirror_make_current (XWINDOW (w
->vchild
), frame_row
);
2681 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2682 here because the checks performed in debug mode there
2683 will not allow the conversion. */
2684 int row
= frame_row
- w
->desired_matrix
->matrix_y
;
2686 /* If FRAME_ROW is within W, assign the desired row to the
2687 current row (exchanging glyph pointers). */
2688 if (row
>= 0 && row
< w
->desired_matrix
->matrix_h
)
2690 struct glyph_row
*current_row
2691 = MATRIX_ROW (w
->current_matrix
, row
);
2692 struct glyph_row
*desired_row
2693 = MATRIX_ROW (w
->desired_matrix
, row
);
2695 if (desired_row
->enabled_p
)
2696 assign_row (current_row
, desired_row
);
2698 swap_glyph_pointers (desired_row
, current_row
);
2699 current_row
->enabled_p
= 1;
2703 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2708 /* Perform row dance after scrolling. We are working on the range of
2709 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2710 including) in MATRIX. COPY_FROM is a vector containing, for each
2711 row I in the range 0 <= I < NLINES, the index of the original line
2712 to move to I. This index is relative to the row range, i.e. 0 <=
2713 index < NLINES. RETAINED_P is a vector containing zero for each
2714 row 0 <= I < NLINES which is empty.
2716 This function is called from do_scrolling and do_direct_scrolling. */
2719 mirrored_line_dance (matrix
, unchanged_at_top
, nlines
, copy_from
,
2721 struct glyph_matrix
*matrix
;
2722 int unchanged_at_top
, nlines
;
2726 /* A copy of original rows. */
2727 struct glyph_row
*old_rows
;
2729 /* Rows to assign to. */
2730 struct glyph_row
*new_rows
= MATRIX_ROW (matrix
, unchanged_at_top
);
2734 /* Make a copy of the original rows. */
2735 old_rows
= (struct glyph_row
*) alloca (nlines
* sizeof *old_rows
);
2736 bcopy (new_rows
, old_rows
, nlines
* sizeof *old_rows
);
2738 /* Assign new rows, maybe clear lines. */
2739 for (i
= 0; i
< nlines
; ++i
)
2741 int enabled_before_p
= new_rows
[i
].enabled_p
;
2743 xassert (i
+ unchanged_at_top
< matrix
->nrows
);
2744 xassert (unchanged_at_top
+ copy_from
[i
] < matrix
->nrows
);
2745 new_rows
[i
] = old_rows
[copy_from
[i
]];
2746 new_rows
[i
].enabled_p
= enabled_before_p
;
2748 /* RETAINED_P is zero for empty lines. */
2749 if (!retained_p
[copy_from
[i
]])
2750 new_rows
[i
].enabled_p
= 0;
2753 /* Do the same for window matrices, if MATRIX Is a frame matrix. */
2754 if (frame_matrix_frame
)
2755 mirror_line_dance (XWINDOW (frame_matrix_frame
->root_window
),
2756 unchanged_at_top
, nlines
, copy_from
, retained_p
);
2760 /* Synchronize glyph pointers in the current matrix of window W with
2761 the current frame matrix. W must be full-width, and be on a tty
2765 sync_window_with_frame_matrix_rows (w
)
2768 struct frame
*f
= XFRAME (w
->frame
);
2769 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
2771 /* Preconditions: W must be a leaf window and full-width. Its frame
2772 must have a frame matrix. */
2773 xassert (NILP (w
->hchild
) && NILP (w
->vchild
));
2774 xassert (WINDOW_FULL_WIDTH_P (w
));
2775 xassert (!FRAME_WINDOW_P (f
));
2777 /* If W is a full-width window, glyph pointers in W's current matrix
2778 have, by definition, to be the same as glyph pointers in the
2779 corresponding frame matrix. */
2780 window_row
= w
->current_matrix
->rows
;
2781 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
2782 frame_row
= f
->current_matrix
->rows
+ XFASTINT (w
->top
);
2783 while (window_row
< window_row_end
)
2787 for (area
= LEFT_MARGIN_AREA
; area
<= LAST_AREA
; ++area
)
2788 window_row
->glyphs
[area
] = frame_row
->glyphs
[area
];
2790 ++window_row
, ++frame_row
;
2795 /* Return the window in the window tree rooted in W containing frame
2796 row ROW. Value is null if none is found. */
2799 frame_row_to_window (w
, row
)
2803 struct window
*found
= NULL
;
2807 if (!NILP (w
->hchild
))
2808 found
= frame_row_to_window (XWINDOW (w
->hchild
), row
);
2809 else if (!NILP (w
->vchild
))
2810 found
= frame_row_to_window (XWINDOW (w
->vchild
), row
);
2811 else if (row
>= XFASTINT (w
->top
)
2812 && row
< XFASTINT (w
->top
) + XFASTINT (w
->height
))
2815 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2822 /* Perform a line dance in the window tree rooted at W, after
2823 scrolling a frame matrix in mirrored_line_dance.
2825 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
2826 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
2827 COPY_FROM is a vector containing, for each row I in the range 0 <=
2828 I < NLINES, the index of the original line to move to I. This
2829 index is relative to the row range, i.e. 0 <= index < NLINES.
2830 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
2834 mirror_line_dance (w
, unchanged_at_top
, nlines
, copy_from
, retained_p
)
2836 int unchanged_at_top
, nlines
;
2842 if (!NILP (w
->hchild
))
2843 mirror_line_dance (XWINDOW (w
->hchild
), unchanged_at_top
,
2844 nlines
, copy_from
, retained_p
);
2845 else if (!NILP (w
->vchild
))
2846 mirror_line_dance (XWINDOW (w
->vchild
), unchanged_at_top
,
2847 nlines
, copy_from
, retained_p
);
2850 /* W is a leaf window, and we are working on its current
2852 struct glyph_matrix
*m
= w
->current_matrix
;
2854 struct glyph_row
*old_rows
;
2856 /* Make a copy of the original rows of matrix m. */
2857 old_rows
= (struct glyph_row
*) alloca (m
->nrows
* sizeof *old_rows
);
2858 bcopy (m
->rows
, old_rows
, m
->nrows
* sizeof *old_rows
);
2860 for (i
= 0; i
< nlines
; ++i
)
2862 /* Frame relative line assigned to. */
2863 int frame_to
= i
+ unchanged_at_top
;
2865 /* Frame relative line assigned. */
2866 int frame_from
= copy_from
[i
] + unchanged_at_top
;
2868 /* Window relative line assigned to. */
2869 int window_to
= frame_to
- m
->matrix_y
;
2871 /* Window relative line assigned. */
2872 int window_from
= frame_from
- m
->matrix_y
;
2874 /* Is assigned line inside window? */
2875 int from_inside_window_p
2876 = window_from
>= 0 && window_from
< m
->matrix_h
;
2878 /* Is assigned to line inside window? */
2879 int to_inside_window_p
2880 = window_to
>= 0 && window_to
< m
->matrix_h
;
2882 if (from_inside_window_p
&& to_inside_window_p
)
2884 /* Enabled setting before assignment. */
2885 int enabled_before_p
;
2887 /* Do the assignment. The enabled_p flag is saved
2888 over the assignment because the old redisplay did
2890 enabled_before_p
= m
->rows
[window_to
].enabled_p
;
2891 m
->rows
[window_to
] = old_rows
[window_from
];
2892 m
->rows
[window_to
].enabled_p
= enabled_before_p
;
2894 /* If frame line is empty, window line is empty, too. */
2895 if (!retained_p
[copy_from
[i
]])
2896 m
->rows
[window_to
].enabled_p
= 0;
2898 else if (to_inside_window_p
)
2900 /* A copy between windows. This is an infrequent
2901 case not worth optimizing. */
2902 struct frame
*f
= XFRAME (w
->frame
);
2903 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
2905 struct glyph_matrix
*m2
;
2908 w2
= frame_row_to_window (root
, frame_to
);
2909 m2
= w2
->current_matrix
;
2910 m2_from
= frame_from
- m2
->matrix_y
;
2911 copy_row_except_pointers (m
->rows
+ window_to
,
2912 m2
->rows
+ m2_from
);
2914 /* If frame line is empty, window line is empty, too. */
2915 if (!retained_p
[copy_from
[i
]])
2916 m
->rows
[window_to
].enabled_p
= 0;
2919 else if (from_inside_window_p
)
2923 /* If there was a copy between windows, make sure glyph
2924 pointers are in sync with the frame matrix. */
2926 sync_window_with_frame_matrix_rows (w
);
2928 /* Check that no pointers are lost. */
2932 /* Next window on same level. */
2933 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2940 /* Check that window and frame matrices agree about their
2941 understanding where glyphs of the rows are to find. For each
2942 window in the window tree rooted at W, check that rows in the
2943 matrices of leaf window agree with their frame matrices about
2947 check_window_matrix_pointers (w
)
2952 if (!NILP (w
->hchild
))
2953 check_window_matrix_pointers (XWINDOW (w
->hchild
));
2954 else if (!NILP (w
->vchild
))
2955 check_window_matrix_pointers (XWINDOW (w
->vchild
));
2958 struct frame
*f
= XFRAME (w
->frame
);
2959 check_matrix_pointers (w
->desired_matrix
, f
->desired_matrix
);
2960 check_matrix_pointers (w
->current_matrix
, f
->current_matrix
);
2963 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2968 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
2969 a window and FRAME_MATRIX is the corresponding frame matrix. For
2970 each row in WINDOW_MATRIX check that it's a slice of the
2971 corresponding frame row. If it isn't, abort. */
2974 check_matrix_pointers (window_matrix
, frame_matrix
)
2975 struct glyph_matrix
*window_matrix
, *frame_matrix
;
2977 /* Row number in WINDOW_MATRIX. */
2980 /* Row number corresponding to I in FRAME_MATRIX. */
2981 int j
= window_matrix
->matrix_y
;
2983 /* For all rows check that the row in the window matrix is a
2984 slice of the row in the frame matrix. If it isn't we didn't
2985 mirror an operation on the frame matrix correctly. */
2986 while (i
< window_matrix
->nrows
)
2988 if (!glyph_row_slice_p (window_matrix
->rows
+ i
,
2989 frame_matrix
->rows
+ j
))
2995 #endif /* GLYPH_DEBUG != 0 */
2999 /**********************************************************************
3000 VPOS and HPOS translations
3001 **********************************************************************/
3005 /* Translate vertical position VPOS which is relative to window W to a
3006 vertical position relative to W's frame. */
3009 window_to_frame_vpos (w
, vpos
)
3013 struct frame
*f
= XFRAME (w
->frame
);
3015 xassert (!FRAME_WINDOW_P (f
));
3016 xassert (vpos
>= 0 && vpos
<= w
->desired_matrix
->nrows
);
3017 vpos
+= XFASTINT (w
->top
);
3018 xassert (vpos
>= 0 && vpos
<= FRAME_HEIGHT (f
));
3023 /* Translate horizontal position HPOS which is relative to window W to
3024 a vertical position relative to W's frame. */
3027 window_to_frame_hpos (w
, hpos
)
3031 struct frame
*f
= XFRAME (w
->frame
);
3033 xassert (!FRAME_WINDOW_P (f
));
3034 hpos
+= XFASTINT (w
->left
);
3038 #endif /* GLYPH_DEBUG */
3042 /**********************************************************************
3044 **********************************************************************/
3046 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
3047 "Clear frame FRAME and output again what is supposed to appear on it.")
3053 CHECK_LIVE_FRAME (frame
, 0);
3056 /* Ignore redraw requests, if frame has no glyphs yet.
3057 (Implementation note: It still has to be checked why we are
3058 called so early here). */
3059 if (!glyphs_initialized_initially_p
)
3063 if (FRAME_MSDOS_P (f
))
3064 set_terminal_modes ();
3066 clear_current_matrices (f
);
3069 windows_or_buffers_changed
++;
3070 /* Mark all windows as inaccurate, so that every window will have
3071 its redisplay done. */
3072 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
3073 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
3079 /* Redraw frame F. This is nothing more than a call to the Lisp
3080 function redraw-frame. */
3087 XSETFRAME (frame
, f
);
3088 Fredraw_frame (frame
);
3092 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
3093 "Clear and redisplay all visible frames.")
3096 Lisp_Object tail
, frame
;
3098 FOR_EACH_FRAME (tail
, frame
)
3099 if (FRAME_VISIBLE_P (XFRAME (frame
)))
3100 Fredraw_frame (frame
);
3106 /* This is used when frame_garbaged is set. Call Fredraw_frame on all
3107 visible frames marked as garbaged. */
3110 redraw_garbaged_frames ()
3112 Lisp_Object tail
, frame
;
3114 FOR_EACH_FRAME (tail
, frame
)
3115 if (FRAME_VISIBLE_P (XFRAME (frame
))
3116 && FRAME_GARBAGED_P (XFRAME (frame
)))
3117 Fredraw_frame (frame
);
3122 /***********************************************************************
3124 ***********************************************************************/
3126 /* Try to update display and current glyph matrix directly.
3128 This function is called after a character G has been inserted into
3129 current_buffer. It tries to update the current glyph matrix and
3130 perform appropriate screen output to reflect the insertion. If it
3131 succeeds, the global flag redisplay_performed_directly_p will be
3132 set to 1, and thereby prevent the more costly general redisplay
3133 from running (see redisplay_internal).
3135 This function is not called for `hairy' character insertions.
3136 In particular, it is not called when after or before change
3137 functions exist, like they are used by font-lock. See keyboard.c
3138 for details where this function is called. */
3141 direct_output_for_insert (g
)
3144 register struct frame
*f
= SELECTED_FRAME ();
3145 struct window
*w
= XWINDOW (selected_window
);
3147 struct glyph_row
*glyph_row
;
3148 struct glyph
*glyphs
, *glyph
, *end
;
3150 /* Non-null means that Redisplay of W is based on window matrices. */
3151 int window_redisplay_p
= FRAME_WINDOW_P (f
);
3152 /* Non-null means we are in overwrite mode. */
3153 int overwrite_p
= !NILP (current_buffer
->overwrite_mode
);
3155 struct text_pos pos
;
3156 int delta
, delta_bytes
;
3158 /* Not done directly. */
3159 redisplay_performed_directly_p
= 0;
3161 /* Quickly give up for some common cases. */
3162 if (cursor_in_echo_area
3163 /* Give up if fonts have changed. */
3165 /* Give up if face attributes have been changed. */
3166 || face_change_count
3167 /* Give up if cursor position not really known. */
3168 || !display_completed
3169 /* Give up if buffer appears in two places. */
3170 || buffer_shared
> 1
3171 /* Give up if w is mini-buffer and a message is being displayed there */
3172 || (MINI_WINDOW_P (w
) && !NILP (echo_area_buffer
[0]))
3173 /* Give up for hscrolled mini-buffer because display of the prompt
3174 is handled specially there (see display_line). */
3175 || (MINI_WINDOW_P (w
) && XFASTINT (w
->hscroll
))
3176 /* Give up if overwriting in the middle of a line. */
3179 && FETCH_BYTE (PT
) != '\n')
3180 /* Give up for tabs and line ends. */
3184 /* Give up if unable to display the cursor in the window. */
3185 || w
->cursor
.vpos
< 0
3186 || (glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
),
3187 /* Can't do it in a continued line because continuation
3188 lines would change. */
3189 (glyph_row
->continued_p
3190 /* Can't use this method if the line overlaps others or is
3191 overlapped by others because these other lines would
3192 have to be redisplayed. */
3193 || glyph_row
->overlapping_p
3194 || glyph_row
->overlapped_p
))
3195 /* Can't do it for partial width windows on terminal frames
3196 because we can't clear to eol in such a window. */
3197 || (!window_redisplay_p
&& !WINDOW_FULL_WIDTH_P (w
)))
3200 /* Set up a display iterator structure for W. Glyphs will be
3201 produced in scratch_glyph_row. Current position is W's cursor
3203 clear_glyph_row (&scratch_glyph_row
);
3204 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
3205 DEC_TEXT_POS (pos
, !NILP (current_buffer
->enable_multibyte_characters
));
3206 init_iterator (&it
, w
, CHARPOS (pos
), BYTEPOS (pos
), &scratch_glyph_row
,
3209 glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3210 if (glyph_row
->mouse_face_p
)
3213 /* Give up if highlighting trailing whitespace and we have trailing
3214 whitespace in glyph_row. We would have to remove the trailing
3215 whitespace face in that case. */
3216 if (!NILP (Vshow_trailing_whitespace
)
3217 && glyph_row
->used
[TEXT_AREA
])
3221 last
= glyph_row
->glyphs
[TEXT_AREA
] + glyph_row
->used
[TEXT_AREA
] - 1;
3222 if (last
->type
== STRETCH_GLYPH
3223 || (last
->type
== CHAR_GLYPH
3224 && last
->u
.ch
== ' '))
3228 /* Give up if there are overlay strings at pos. This would fail
3229 if the overlay string has newlines in it. */
3230 if (STRINGP (it
.string
))
3233 it
.hpos
= w
->cursor
.hpos
;
3234 it
.vpos
= w
->cursor
.vpos
;
3235 it
.current_x
= w
->cursor
.x
+ it
.first_visible_x
;
3236 it
.current_y
= w
->cursor
.y
;
3237 it
.end_charpos
= PT
;
3238 it
.stop_charpos
= min (PT
, it
.stop_charpos
);
3240 /* More than one display element may be returned for PT - 1 if
3241 (i) it's a control character which is translated into `\003' or
3242 `^C', or (ii) it has a display table entry, or (iii) it's a
3243 combination of both. */
3244 delta
= delta_bytes
= 0;
3245 while (get_next_display_element (&it
))
3247 PRODUCE_GLYPHS (&it
);
3249 /* Give up if glyph doesn't fit completely on the line. */
3250 if (it
.current_x
>= it
.last_visible_x
)
3253 /* Give up if new glyph has different ascent or descent than
3254 the original row, or if it is not a character glyph. */
3255 if (glyph_row
->ascent
!= it
.ascent
3256 || glyph_row
->height
!= it
.ascent
+ it
.descent
3257 || glyph_row
->phys_ascent
!= it
.phys_ascent
3258 || glyph_row
->phys_height
!= it
.phys_ascent
+ it
.phys_descent
3259 || it
.what
!= IT_CHARACTER
)
3263 delta_bytes
+= it
.len
;
3264 set_iterator_to_next (&it
);
3267 /* Give up if we hit the right edge of the window. We would have
3268 to insert truncation or continuation glyphs. */
3269 added_width
= it
.current_x
- (w
->cursor
.x
+ it
.first_visible_x
);
3270 if (glyph_row
->pixel_width
+ added_width
>= it
.last_visible_x
)
3273 /* Give up if there is a \t following in the line. */
3275 it2
.end_charpos
= ZV
;
3276 it2
.stop_charpos
= min (it2
.stop_charpos
, ZV
);
3277 while (get_next_display_element (&it2
)
3278 && !ITERATOR_AT_END_OF_LINE_P (&it2
))
3282 set_iterator_to_next (&it2
);
3285 /* Number of new glyphs produced. */
3286 n
= it
.glyph_row
->used
[TEXT_AREA
];
3288 /* Start and end of glyphs in original row. */
3289 glyphs
= glyph_row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
3290 end
= glyph_row
->glyphs
[1 + TEXT_AREA
];
3292 /* Make room for new glyphs, then insert them. */
3293 xassert (end
- glyphs
- n
>= 0);
3294 safe_bcopy ((char *) glyphs
, (char *) (glyphs
+ n
),
3295 (end
- glyphs
- n
) * sizeof (*end
));
3296 bcopy (it
.glyph_row
->glyphs
[TEXT_AREA
], glyphs
, n
* sizeof *glyphs
);
3297 glyph_row
->used
[TEXT_AREA
] = min (glyph_row
->used
[TEXT_AREA
] + n
,
3298 end
- glyph_row
->glyphs
[TEXT_AREA
]);
3300 /* Compute new line width. */
3301 glyph
= glyph_row
->glyphs
[TEXT_AREA
];
3302 end
= glyph
+ glyph_row
->used
[TEXT_AREA
];
3303 glyph_row
->pixel_width
= glyph_row
->x
;
3306 glyph_row
->pixel_width
+= glyph
->pixel_width
;
3310 /* Increment buffer positions for glyphs following the newly
3312 for (glyph
= glyphs
+ n
; glyph
< end
; ++glyph
)
3313 if (glyph
->charpos
> 0 && BUFFERP (glyph
->object
))
3314 glyph
->charpos
+= delta
;
3316 if (MATRIX_ROW_END_CHARPOS (glyph_row
) > 0)
3318 MATRIX_ROW_END_CHARPOS (glyph_row
) += delta
;
3319 MATRIX_ROW_END_BYTEPOS (glyph_row
) += delta_bytes
;
3322 /* Adjust positions in lines following the one we are in. */
3323 increment_matrix_positions (w
->current_matrix
,
3325 w
->current_matrix
->nrows
,
3326 delta
, delta_bytes
);
3328 glyph_row
->contains_overlapping_glyphs_p
3329 |= it
.glyph_row
->contains_overlapping_glyphs_p
;
3331 glyph_row
->displays_text_p
= 1;
3332 w
->window_end_vpos
= make_number (max (w
->cursor
.vpos
,
3333 XFASTINT (w
->window_end_vpos
)));
3335 if (!NILP (Vshow_trailing_whitespace
))
3336 highlight_trailing_whitespace (it
.f
, glyph_row
);
3338 /* Write glyphs. If at end of row, we can simply call write_glyphs.
3339 In the middle, we have to insert glyphs. Note that this is now
3340 implemented for X frames. The implementation uses updated_window
3342 updated_row
= glyph_row
;
3346 rif
->update_window_begin_hook (w
);
3348 if (glyphs
== end
- n
)
3349 rif
->write_glyphs (glyphs
, n
);
3351 rif
->insert_glyphs (glyphs
, n
);
3355 if (glyphs
== end
- n
)
3356 write_glyphs (glyphs
, n
);
3358 insert_glyphs (glyphs
, n
);
3361 w
->cursor
.hpos
+= n
;
3362 w
->cursor
.x
= it
.current_x
- it
.first_visible_x
;
3363 xassert (w
->cursor
.hpos
>= 0
3364 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3366 /* How to set the cursor differs depending on whether we are
3367 using a frame matrix or a window matrix. Note that when
3368 a frame matrix is used, cursor_to expects frame coordinates,
3369 and the X and Y parameters are not used. */
3370 if (window_redisplay_p
)
3371 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3372 w
->cursor
.y
, w
->cursor
.x
);
3376 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3377 + (INTEGERP (w
->left_margin_width
)
3378 ? XFASTINT (w
->left_margin_width
)
3380 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3385 rif
->update_window_end_hook (w
, 1, 0);
3390 TRACE ((stderr
, "direct output for insert\n"));
3392 UNCHANGED_MODIFIED
= MODIFF
;
3393 BEG_UNCHANGED
= GPT
- BEG
;
3394 XSETFASTINT (w
->last_point
, PT
);
3395 w
->last_cursor
= w
->cursor
;
3396 XSETFASTINT (w
->last_modified
, MODIFF
);
3397 XSETFASTINT (w
->last_overlay_modified
, OVERLAY_MODIFF
);
3399 redisplay_performed_directly_p
= 1;
3404 /* Perform a direct display update for moving PT by N positions
3405 left or right. N < 0 means a movement backwards. This function
3406 is currently only called for N == 1 or N == -1. */
3409 direct_output_forward_char (n
)
3412 struct frame
*f
= SELECTED_FRAME ();
3413 struct window
*w
= XWINDOW (selected_window
);
3414 struct glyph_row
*row
;
3416 /* Give up if point moved out of or into a composition. */
3417 if (check_point_in_composition (current_buffer
, XINT (w
->last_point
),
3418 current_buffer
, PT
))
3421 /* Give up if face attributes have been changed. */
3422 if (face_change_count
)
3425 /* Give up if current matrix is not up to date or we are
3426 displaying a message. */
3427 if (!display_completed
|| cursor_in_echo_area
)
3430 /* Give up if the buffer's direction is reversed. */
3431 if (!NILP (XBUFFER (w
->buffer
)->direction_reversed
))
3434 /* Can't use direct output if highlighting a region. */
3435 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
3438 /* Can't use direct output if highlighting trailing whitespace. */
3439 if (!NILP (Vshow_trailing_whitespace
))
3442 /* Give up if we are showing a message or just cleared the message
3443 because we might need to resize the echo area window. */
3444 if (!NILP (echo_area_buffer
[0]) || !NILP (echo_area_buffer
[1]))
3447 /* Give up if currently displaying a message instead of the
3448 minibuffer contents. */
3449 if (XWINDOW (minibuf_window
) == w
3450 && EQ (minibuf_window
, echo_area_window
))
3453 /* Give up if we don't know where the cursor is. */
3454 if (w
->cursor
.vpos
< 0)
3457 row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3459 /* Give up if PT is outside of the last known cursor row. */
3460 if (PT
<= MATRIX_ROW_START_BYTEPOS (row
)
3461 || PT
>= MATRIX_ROW_END_BYTEPOS (row
))
3464 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
3466 w
->last_cursor
= w
->cursor
;
3467 XSETFASTINT (w
->last_point
, PT
);
3469 xassert (w
->cursor
.hpos
>= 0
3470 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3472 if (FRAME_WINDOW_P (f
))
3473 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3474 w
->cursor
.y
, w
->cursor
.x
);
3478 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3479 + (INTEGERP (w
->left_margin_width
)
3480 ? XFASTINT (w
->left_margin_width
)
3482 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3487 redisplay_performed_directly_p
= 1;
3493 /***********************************************************************
3495 ***********************************************************************/
3497 /* Update frame F based on the data in desired matrices.
3499 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3500 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3503 Value is non-zero if redisplay was stopped due to pending input. */
3506 update_frame (f
, force_p
, inhibit_hairy_id_p
)
3509 int inhibit_hairy_id_p
;
3511 /* 1 means display has been paused because of pending input. */
3513 struct window
*root_window
= XWINDOW (f
->root_window
);
3515 if (FRAME_WINDOW_P (f
))
3517 /* We are working on window matrix basis. All windows whose
3518 flag must_be_updated_p is set have to be updated. */
3520 /* Record that we are not working on frame matrices. */
3521 set_frame_matrix_frame (NULL
);
3523 /* Update all windows in the window tree of F, maybe stopping
3524 when pending input is detected. */
3527 /* Update the menu bar on X frames that don't have toolkit
3529 if (WINDOWP (f
->menu_bar_window
))
3530 update_window (XWINDOW (f
->menu_bar_window
), 1);
3532 /* Update the tool-bar window, if present. */
3533 if (WINDOWP (f
->tool_bar_window
))
3536 struct window
*w
= XWINDOW (f
->tool_bar_window
);
3538 /* Update tool-bar window. */
3539 if (w
->must_be_updated_p
)
3541 update_window (w
, 1);
3542 w
->must_be_updated_p
= 0;
3544 /* Swap tool-bar strings. We swap because we want to
3546 tem
= f
->current_tool_bar_string
;
3547 f
->current_tool_bar_string
= f
->desired_tool_bar_string
;
3548 f
->desired_tool_bar_string
= tem
;
3549 f
->n_current_tool_bar_items
= f
->n_desired_tool_bar_items
;
3551 /* Swap tool-bar items. We swap because we want to
3553 tem
= f
->current_tool_bar_items
;
3554 f
->current_tool_bar_items
= f
->desired_tool_bar_items
;
3555 f
->desired_tool_bar_items
= tem
;
3560 /* Update windows. */
3561 paused_p
= update_window_tree (root_window
, force_p
);
3563 display_completed
= !paused_p
;
3565 /* The flush is a performance bottleneck under X. */
3567 rif
->flush_display (f
);
3572 /* We are working on frame matrix basis. Set the frame on whose
3573 frame matrix we operate. */
3574 set_frame_matrix_frame (f
);
3576 /* Build F's desired matrix from window matrices. For windows
3577 whose must_be_updated_p flag is set, desired matrices are
3578 made part of the desired frame matrix. For other windows,
3579 the current matrix is copied. */
3580 build_frame_matrix (f
);
3582 /* Do the update on the frame desired matrix. */
3583 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3585 /* Check window matrices for lost pointers. */
3586 IF_DEBUG (check_window_matrix_pointers (root_window
));
3589 /* Reset flags indicating that a window should be updated. */
3590 set_window_update_flags (root_window
, 0);
3596 /************************************************************************
3597 Window-based updates
3598 ************************************************************************/
3600 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3601 don't stop updating when input is pending. */
3604 update_window_tree (w
, force_p
)
3610 while (w
&& !paused_p
)
3612 if (!NILP (w
->hchild
))
3613 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
3614 else if (!NILP (w
->vchild
))
3615 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
3616 else if (w
->must_be_updated_p
)
3617 paused_p
|= update_window (w
, force_p
);
3619 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3626 /* Update window W if its flag must_be_updated_p is non-zero. If
3627 FORCE_P is non-zero, don't stop updating if input is pending. */
3630 update_single_window (w
, force_p
)
3634 if (w
->must_be_updated_p
)
3636 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3638 /* Record that this is not a frame-based redisplay. */
3639 set_frame_matrix_frame (NULL
);
3643 update_window (w
, force_p
);
3646 /* Reset flag in W. */
3647 w
->must_be_updated_p
= 0;
3652 /* Redraw lines from the current matrix of window W that are
3653 overlapped by other rows. YB is bottom-most y-position in W. */
3656 redraw_overlapped_rows (w
, yb
)
3662 /* If rows overlapping others have been changed, the rows being
3663 overlapped have to be redrawn. This won't draw lines that have
3664 already been drawn in update_window_line because overlapped_p in
3665 desired rows is 0, so after row assignment overlapped_p in
3666 current rows is 0. */
3667 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3669 struct glyph_row
*row
= w
->current_matrix
->rows
+ i
;
3671 if (!row
->enabled_p
)
3673 else if (row
->mode_line_p
)
3676 if (row
->overlapped_p
)
3678 enum glyph_row_area area
;
3680 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3683 updated_area
= area
;
3684 rif
->cursor_to (i
, 0, row
->y
, area
== TEXT_AREA
? row
->x
: 0);
3685 if (row
->used
[area
])
3686 rif
->write_glyphs (row
->glyphs
[area
], row
->used
[area
]);
3687 rif
->clear_end_of_line (-1);
3690 row
->overlapped_p
= 0;
3693 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3699 /* Redraw lines from the current matrix of window W that overlap
3700 others. YB is bottom-most y-position in W. */
3703 redraw_overlapping_rows (w
, yb
)
3708 struct glyph_row
*row
;
3710 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3712 row
= w
->current_matrix
->rows
+ i
;
3714 if (!row
->enabled_p
)
3716 else if (row
->mode_line_p
)
3719 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3721 if (row
->overlapping_p
&& i
> 0 && bottom_y
< yb
)
3723 if (row
->used
[LEFT_MARGIN_AREA
])
3724 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
);
3726 if (row
->used
[TEXT_AREA
])
3727 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
);
3729 if (row
->used
[RIGHT_MARGIN_AREA
])
3730 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
);
3732 /* Record in neighbor rows that ROW overwrites part of their
3734 if (row
->phys_ascent
> row
->ascent
&& i
> 0)
3735 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3736 if ((row
->phys_height
- row
->phys_ascent
3737 > row
->height
- row
->ascent
)
3739 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
3748 /* Update display of window W. FORCE_P non-zero means that we should
3749 not stop when detecting pending input. */
3752 update_window (w
, force_p
)
3756 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
3758 int preempt_count
= baud_rate
/ 2400 + 1;
3759 extern int input_pending
;
3761 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3762 extern struct frame
*updating_frame
;
3765 /* Check that W's frame doesn't have glyph matrices. */
3766 xassert (FRAME_WINDOW_P (f
));
3767 xassert (updating_frame
!= NULL
);
3769 /* Check pending input the first time so that we can quickly return. */
3770 if (redisplay_dont_pause
)
3773 detect_input_pending ();
3775 /* If forced to complete the update, or if no input is pending, do
3777 if (force_p
|| !input_pending
)
3779 struct glyph_row
*row
, *end
;
3780 struct glyph_row
*mode_line_row
;
3781 struct glyph_row
*header_line_row
= NULL
;
3782 int yb
, changed_p
= 0, mouse_face_overwritten_p
= 0;
3784 rif
->update_window_begin_hook (w
);
3785 yb
= window_text_bottom_y (w
);
3787 /* If window has a top line, update it before everything else.
3788 Adjust y-positions of other rows by the top line height. */
3789 row
= desired_matrix
->rows
;
3790 end
= row
+ desired_matrix
->nrows
- 1;
3791 if (row
->mode_line_p
)
3792 header_line_row
= row
++;
3794 /* Update the mode line, if necessary. */
3795 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3796 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
3798 mode_line_row
->y
= yb
;
3799 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
3801 &mouse_face_overwritten_p
);
3805 /* Find first enabled row. Optimizations in redisplay_internal
3806 may lead to an update with only one row enabled. There may
3807 be also completely empty matrices. */
3808 while (row
< end
&& !row
->enabled_p
)
3811 /* Try reusing part of the display by inserting/deleting lines. */
3812 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
3814 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
3817 /* All rows were found to be equal. */
3826 /* Update the top mode line after scrolling because a new top
3827 line would otherwise overwrite lines at the top of the window
3828 that can be scrolled. */
3829 if (header_line_row
&& header_line_row
->enabled_p
)
3831 header_line_row
->y
= 0;
3832 update_window_line (w
, 0, &mouse_face_overwritten_p
);
3836 /* Update the rest of the lines. */
3837 for (; row
< end
&& (force_p
|| !input_pending
); ++row
)
3839 /* A row can be completely invisible in case a desired
3840 matrix was built with a vscroll and then
3841 make_cursor_line_fully_visible shifts the matrix. */
3842 && row
->visible_height
> 0)
3844 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
3847 /* We'll Have to play a little bit with when to
3848 detect_input_pending. If it's done too often,
3849 scrolling large windows with repeated scroll-up
3850 commands will too quickly pause redisplay. */
3851 if (!force_p
&& vpos
% preempt_count
== 0)
3852 detect_input_pending ();
3854 changed_p
|= update_window_line (w
, vpos
,
3855 &mouse_face_overwritten_p
);
3857 /* Mark all rows below the last visible one in the current
3858 matrix as invalid. This is necessary because of
3859 variable line heights. Consider the case of three
3860 successive redisplays, where the first displays 5
3861 lines, the second 3 lines, and the third 5 lines again.
3862 If the second redisplay wouldn't mark rows in the
3863 current matrix invalid, the third redisplay might be
3864 tempted to optimize redisplay based on lines displayed
3865 in the first redisplay. */
3866 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3867 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
3868 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
3871 /* Was display preempted? */
3872 paused_p
= row
< end
;
3876 /* Fix the appearance of overlapping(overlapped rows. */
3877 if (!paused_p
&& !w
->pseudo_window_p
)
3879 if (changed_p
&& rif
->fix_overlapping_area
)
3881 redraw_overlapped_rows (w
, yb
);
3882 redraw_overlapping_rows (w
, yb
);
3885 /* Make cursor visible at cursor position of W. */
3886 set_window_cursor_after_update (w
);
3888 #if 0 /* Check that current matrix invariants are satisfied. This is
3889 for debugging only. See the comment of check_matrix_invariants. */
3890 IF_DEBUG (check_matrix_invariants (w
));
3895 /* Remember the redisplay method used to display the matrix. */
3896 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
3899 /* End of update of window W. */
3900 rif
->update_window_end_hook (w
, 1, mouse_face_overwritten_p
);
3905 clear_glyph_matrix (desired_matrix
);
3911 /* Update the display of area AREA in window W, row number VPOS.
3912 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3915 update_marginal_area (w
, area
, vpos
)
3919 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3921 /* Let functions in xterm.c know what area subsequent X positions
3922 will be relative to. */
3923 updated_area
= area
;
3925 /* Set cursor to start of glyphs, write them, and clear to the end
3926 of the area. I don't think that something more sophisticated is
3927 necessary here, since marginal areas will not be the default. */
3928 rif
->cursor_to (vpos
, 0, desired_row
->y
, 0);
3929 if (desired_row
->used
[area
])
3930 rif
->write_glyphs (desired_row
->glyphs
[area
], desired_row
->used
[area
]);
3931 rif
->clear_end_of_line (-1);
3935 /* Update the display of the text area of row VPOS in window W.
3936 Value is non-zero if display has changed. */
3939 update_text_area (w
, vpos
)
3943 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3944 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3947 /* Let functions in xterm.c know what area subsequent X positions
3948 will be relative to. */
3949 updated_area
= TEXT_AREA
;
3951 /* If rows are at different X or Y, or rows have different height,
3952 or the current row is marked invalid, write the entire line. */
3953 if (!current_row
->enabled_p
3954 || desired_row
->y
!= current_row
->y
3955 || desired_row
->ascent
!= current_row
->ascent
3956 || desired_row
->phys_ascent
!= current_row
->phys_ascent
3957 || desired_row
->phys_height
!= current_row
->phys_height
3958 || desired_row
->visible_height
!= current_row
->visible_height
3959 || current_row
->overlapped_p
3960 || current_row
->mouse_face_p
3961 || current_row
->x
!= desired_row
->x
)
3963 rif
->cursor_to (vpos
, 0, desired_row
->y
, desired_row
->x
);
3965 if (desired_row
->used
[TEXT_AREA
])
3966 rif
->write_glyphs (desired_row
->glyphs
[TEXT_AREA
],
3967 desired_row
->used
[TEXT_AREA
]);
3969 /* Clear to end of window. */
3970 rif
->clear_end_of_line (-1);
3976 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
3977 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
3979 /* If the desired row extends its face to the text area end,
3980 make sure we write at least one glyph, so that the face
3981 extension actually takes place. */
3982 int desired_stop_pos
= (desired_row
->used
[TEXT_AREA
]
3983 - (MATRIX_ROW_EXTENDS_FACE_P (desired_row
)
3986 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
3992 /* Skip over glyphs that both rows have in common. These
3993 don't have to be written. */
3995 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3997 x
+= desired_glyph
->pixel_width
;
3998 ++desired_glyph
, ++current_glyph
, ++i
;
4001 /* Consider the case that the current row contains "xxx ppp
4002 ggg" in italic Courier font, and the desired row is "xxx
4003 ggg". The character `p' has lbearing, `g' has not. The
4004 loop above will stop in front of the first `p' in the
4005 current row. If we would start writing glyphs there, we
4006 wouldn't erase the lbearing of the `p'. The rest of the
4007 lbearing problem is then taken care of by x_draw_glyphs. */
4008 if (current_row
->contains_overlapping_glyphs_p
4010 && i
< current_row
->used
[TEXT_AREA
]
4011 && current_row
->used
[TEXT_AREA
] != desired_row
->used
[TEXT_AREA
])
4014 rif
->get_glyph_overhangs (current_glyph
, XFRAME (w
->frame
),
4016 while (left
> 0 && i
> 0)
4018 --i
, --desired_glyph
, --current_glyph
;
4019 x
-= desired_glyph
->pixel_width
;
4020 left
-= desired_glyph
->pixel_width
;
4024 /* Try to avoid writing the entire rest of the desired row
4025 by looking for a resync point. This mainly prevents
4026 mode line flickering in the case the mode line is in
4027 fixed-pitch font, which it usually will be. */
4028 if (i
< desired_row
->used
[TEXT_AREA
])
4030 int start_x
= x
, start_hpos
= i
;
4031 struct glyph
*start
= desired_glyph
;
4034 /* Find the next glyph that's equal again. */
4036 && !GLYPH_EQUAL_P (desired_glyph
, current_glyph
)
4039 x
+= desired_glyph
->pixel_width
;
4040 current_x
+= current_glyph
->pixel_width
;
4041 ++desired_glyph
, ++current_glyph
, ++i
;
4044 if (i
== start_hpos
|| x
!= current_x
)
4048 desired_glyph
= start
;
4052 rif
->cursor_to (vpos
, start_hpos
, desired_row
->y
, start_x
);
4053 rif
->write_glyphs (start
, i
- start_hpos
);
4058 /* Write the rest. */
4059 if (i
< desired_row
->used
[TEXT_AREA
])
4061 rif
->cursor_to (vpos
, i
, desired_row
->y
, x
);
4062 rif
->write_glyphs (desired_glyph
, desired_row
->used
[TEXT_AREA
] - i
);
4066 /* Maybe clear to end of line. */
4067 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
4069 /* If new row extends to the end of the text area, nothing
4070 has to be cleared, if and only if we did a write_glyphs
4071 above. This is made sure by setting desired_stop_pos
4072 appropriately above. */
4073 xassert (i
< desired_row
->used
[TEXT_AREA
]);
4075 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
4077 /* If old row extends to the end of the text area, clear. */
4078 if (i
>= desired_row
->used
[TEXT_AREA
])
4079 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4080 desired_row
->x
+ desired_row
->pixel_width
);
4081 rif
->clear_end_of_line (-1);
4084 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
4086 /* Otherwise clear to the end of the old row. Everything
4087 after that position should be clear already. */
4090 if (i
>= desired_row
->used
[TEXT_AREA
])
4091 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4092 desired_row
->x
+ desired_row
->pixel_width
);
4094 /* If cursor is displayed at the end of the line, make sure
4095 it's cleared. Nowadays we don't have a phys_cursor_glyph
4096 with which to erase the cursor (because this method
4097 doesn't work with lbearing/rbearing), so we must do it
4099 if (vpos
== w
->phys_cursor
.vpos
4100 && w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])
4102 w
->phys_cursor_on_p
= 0;
4106 x
= current_row
->x
+ current_row
->pixel_width
;
4107 rif
->clear_end_of_line (x
);
4116 /* Update row VPOS in window W. Value is non-zero if display has been
4120 update_window_line (w
, vpos
, mouse_face_overwritten_p
)
4122 int vpos
, *mouse_face_overwritten_p
;
4124 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
4125 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
4128 xassert (desired_row
->enabled_p
);
4130 /* Set the row being updated. This is important to let xterm.c
4131 know what line height values are in effect. */
4132 updated_row
= desired_row
;
4134 /* Update display of the left margin area, if there is one. */
4135 if (!desired_row
->full_width_p
4136 && !NILP (w
->left_margin_width
))
4139 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
4142 /* Update the display of the text area. */
4143 if (update_text_area (w
, vpos
))
4146 if (current_row
->mouse_face_p
)
4147 *mouse_face_overwritten_p
= 1;
4150 /* Update display of the right margin area, if there is one. */
4151 if (!desired_row
->full_width_p
4152 && !NILP (w
->right_margin_width
))
4155 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
4158 /* Draw truncation marks etc. */
4159 if (!current_row
->enabled_p
4160 || desired_row
->y
!= current_row
->y
4161 || desired_row
->visible_height
!= current_row
->visible_height
4162 || desired_row
->overlay_arrow_p
!= current_row
->overlay_arrow_p
4163 || desired_row
->truncated_on_left_p
!= current_row
->truncated_on_left_p
4164 || desired_row
->truncated_on_right_p
!= current_row
->truncated_on_right_p
4165 || desired_row
->continued_p
!= current_row
->continued_p
4166 || desired_row
->mode_line_p
!= current_row
->mode_line_p
4167 || (desired_row
->indicate_empty_line_p
4168 != current_row
->indicate_empty_line_p
)
4169 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
4170 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
4171 rif
->after_update_window_line_hook (desired_row
);
4173 /* Update current_row from desired_row. */
4174 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4180 /* Set the cursor after an update of window W. This function may only
4181 be called from update_window. */
4184 set_window_cursor_after_update (w
)
4187 struct frame
*f
= XFRAME (w
->frame
);
4188 int cx
, cy
, vpos
, hpos
;
4190 /* Not intended for frame matrix updates. */
4191 xassert (FRAME_WINDOW_P (f
));
4193 if (cursor_in_echo_area
4194 && !NILP (echo_area_buffer
[0])
4195 /* If we are showing a message instead of the mini-buffer,
4196 show the cursor for the message instead. */
4197 && XWINDOW (minibuf_window
) == w
4198 && EQ (minibuf_window
, echo_area_window
)
4199 /* These cases apply only to the frame that contains
4200 the active mini-buffer window. */
4201 && FRAME_HAS_MINIBUF_P (f
)
4202 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4204 cx
= cy
= vpos
= hpos
= 0;
4206 if (cursor_in_echo_area
>= 0)
4208 /* If the mini-buffer is several lines high, find the last
4209 line that has any text on it. Note: either all lines
4210 are enabled or none. Otherwise we wouldn't be able to
4212 struct glyph_row
*row
, *last_row
;
4213 struct glyph
*glyph
;
4214 int yb
= window_text_bottom_y (w
);
4217 for (row
= MATRIX_ROW (w
->current_matrix
, 0);
4221 if (row
->used
[TEXT_AREA
]
4222 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4225 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4231 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
4232 struct glyph
*last
= start
+ row
->used
[TEXT_AREA
] - 1;
4234 while (last
> start
&& last
->charpos
< 0)
4237 for (glyph
= start
; glyph
< last
; ++glyph
)
4239 cx
+= glyph
->pixel_width
;
4244 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4252 hpos
= w
->cursor
.hpos
;
4253 vpos
= w
->cursor
.vpos
;
4256 /* Window cursor can be out of sync for horizontally split windows. */
4257 hpos
= max (0, hpos
);
4258 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4259 vpos
= max (0, vpos
);
4260 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4261 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4265 /* Set WINDOW->must_be_updated_p to ON_P for all windows in the window
4266 tree rooted at W. */
4269 set_window_update_flags (w
, on_p
)
4275 if (!NILP (w
->hchild
))
4276 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4277 else if (!NILP (w
->vchild
))
4278 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4280 w
->must_be_updated_p
= on_p
;
4282 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4288 /***********************************************************************
4289 Window-Based Scrolling
4290 ***********************************************************************/
4292 /* Structure describing rows in scrolling_window. */
4296 /* Number of occurrences of this row in desired and current matrix. */
4297 int old_uses
, new_uses
;
4299 /* Vpos of row in new matrix. */
4300 int new_line_number
;
4302 /* Bucket index of this row_entry in the hash table row_table. */
4305 /* The row described by this entry. */
4306 struct glyph_row
*row
;
4308 /* Hash collision chain. */
4309 struct row_entry
*next
;
4312 /* A pool to allocate row_entry structures from, and the size of the
4313 pool. The pool is reallocated in scrolling_window when we find
4314 that we need a larger one. */
4316 static struct row_entry
*row_entry_pool
;
4317 static int row_entry_pool_size
;
4319 /* Index of next free entry in row_entry_pool. */
4321 static int row_entry_idx
;
4323 /* The hash table used during scrolling, and the table's size. This
4324 table is used to quickly identify equal rows in the desired and
4327 static struct row_entry
**row_table
;
4328 static int row_table_size
;
4330 /* Vectors of pointers to row_entry structures belonging to the
4331 current and desired matrix, and the size of the vectors. */
4333 static struct row_entry
**old_lines
, **new_lines
;
4334 static int old_lines_size
, new_lines_size
;
4336 /* A pool to allocate run structures from, and its size. */
4338 static struct run
*run_pool
;
4339 static int runs_size
;
4341 /* A vector of runs of lines found during scrolling. */
4343 static struct run
**runs
;
4345 static struct row_entry
*add_row_entry
P_ ((struct window
*,
4346 struct glyph_row
*));
4349 /* Add glyph row ROW to the scrolling hash table during the scrolling
4352 static INLINE
struct row_entry
*
4353 add_row_entry (w
, row
)
4355 struct glyph_row
*row
;
4357 struct row_entry
*entry
;
4358 int i
= row
->hash
% row_table_size
;
4360 entry
= row_table
[i
];
4361 while (entry
&& !row_equal_p (w
, entry
->row
, row
, 1))
4362 entry
= entry
->next
;
4366 entry
= row_entry_pool
+ row_entry_idx
++;
4368 entry
->old_uses
= entry
->new_uses
= 0;
4369 entry
->new_line_number
= 0;
4371 entry
->next
= row_table
[i
];
4372 row_table
[i
] = entry
;
4379 /* Try to reuse part of the current display of W by scrolling lines.
4380 HEADER_LINE_P non-zero means W has a top mode line.
4382 The algorithm is taken from Communications of the ACM, Apr78 "A
4383 Technique for Isolating Differences Between Files." It should take
4386 A short outline of the steps of the algorithm
4388 1. Skip lines equal at the start and end of both matrices.
4390 2. Enter rows in the current and desired matrix into a symbol
4391 table, counting how often they appear in both matrices.
4393 3. Rows that appear exactly once in both matrices serve as anchors,
4394 i.e. we assume that such lines are likely to have been moved.
4396 4. Starting from anchor lines, extend regions to be scrolled both
4397 forward and backward.
4401 -1 if all rows were found to be equal.
4402 0 to indicate that we did not scroll the display, or
4403 1 if we did scroll. */
4406 scrolling_window (w
, header_line_p
)
4410 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4411 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4412 int yb
= window_text_bottom_y (w
);
4413 int i
, j
, first_old
, first_new
, last_old
, last_new
;
4414 int nruns
, nbytes
, n
, run_idx
;
4415 struct row_entry
*entry
;
4417 /* Skip over rows equal at the start. */
4418 i
= header_line_p
? 1 : 0;
4419 while (i
< current_matrix
->nrows
- 1
4420 && MATRIX_ROW_ENABLED_P (current_matrix
, i
)
4421 && MATRIX_ROW_ENABLED_P (desired_matrix
, i
)
4422 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) <= yb
4423 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) <= yb
4425 MATRIX_ROW (desired_matrix
, i
),
4426 MATRIX_ROW (current_matrix
, i
), 1))
4428 assign_row (MATRIX_ROW (current_matrix
, i
),
4429 MATRIX_ROW (desired_matrix
, i
));
4430 MATRIX_ROW (desired_matrix
, i
)->enabled_p
= 0;
4434 /* Give up if some rows in the desired matrix are not enabled. */
4435 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4438 first_old
= first_new
= i
;
4440 /* Set last_new to the index + 1 of the last enabled row in the
4443 while (i
< desired_matrix
->nrows
- 1
4444 && MATRIX_ROW (desired_matrix
, i
)->enabled_p
4445 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) <= yb
)
4448 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4453 /* Set last_old to the index + 1 of the last enabled row in the
4454 current matrix. We don't look at the enabled flag here because
4455 we plan to reuse part of the display even if other parts are
4458 while (i
< current_matrix
->nrows
- 1
4459 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) <= yb
)
4463 /* Skip over rows equal at the bottom. */
4466 while (i
- 1 > first_new
4467 && j
- 1 > first_old
4468 && MATRIX_ROW (current_matrix
, i
- 1)->enabled_p
4469 && (MATRIX_ROW (current_matrix
, i
- 1)->y
4470 == MATRIX_ROW (desired_matrix
, j
- 1)->y
)
4472 MATRIX_ROW (desired_matrix
, i
- 1),
4473 MATRIX_ROW (current_matrix
, j
- 1), 1))
4478 /* Nothing to do if all rows are equal. */
4479 if (last_new
== first_new
)
4482 /* Reallocate vectors, tables etc. if necessary. */
4484 if (current_matrix
->nrows
> old_lines_size
)
4486 old_lines_size
= current_matrix
->nrows
;
4487 nbytes
= old_lines_size
* sizeof *old_lines
;
4488 old_lines
= (struct row_entry
**) xrealloc (old_lines
, nbytes
);
4491 if (desired_matrix
->nrows
> new_lines_size
)
4493 new_lines_size
= desired_matrix
->nrows
;
4494 nbytes
= new_lines_size
* sizeof *new_lines
;
4495 new_lines
= (struct row_entry
**) xrealloc (new_lines
, nbytes
);
4498 n
= desired_matrix
->nrows
+ current_matrix
->nrows
;
4499 if (3 * n
> row_table_size
)
4501 row_table_size
= next_almost_prime (3 * n
);
4502 nbytes
= row_table_size
* sizeof *row_table
;
4503 row_table
= (struct row_entry
**) xrealloc (row_table
, nbytes
);
4504 bzero (row_table
, nbytes
);
4507 if (n
> row_entry_pool_size
)
4509 row_entry_pool_size
= n
;
4510 nbytes
= row_entry_pool_size
* sizeof *row_entry_pool
;
4511 row_entry_pool
= (struct row_entry
*) xrealloc (row_entry_pool
, nbytes
);
4514 if (desired_matrix
->nrows
> runs_size
)
4516 runs_size
= desired_matrix
->nrows
;
4517 nbytes
= runs_size
* sizeof *runs
;
4518 runs
= (struct run
**) xrealloc (runs
, nbytes
);
4519 nbytes
= runs_size
* sizeof *run_pool
;
4520 run_pool
= (struct run
*) xrealloc (run_pool
, nbytes
);
4523 nruns
= run_idx
= 0;
4526 /* Add rows from the current and desired matrix to the hash table
4527 row_hash_table to be able to find equal ones quickly. */
4529 for (i
= first_old
; i
< last_old
; ++i
)
4531 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4533 entry
= add_row_entry (w
, MATRIX_ROW (current_matrix
, i
));
4534 old_lines
[i
] = entry
;
4538 old_lines
[i
] = NULL
;
4541 for (i
= first_new
; i
< last_new
; ++i
)
4543 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4544 entry
= add_row_entry (w
, MATRIX_ROW (desired_matrix
, i
));
4546 entry
->new_line_number
= i
;
4547 new_lines
[i
] = entry
;
4550 /* Identify moves based on lines that are unique and equal
4551 in both matrices. */
4552 for (i
= first_old
; i
< last_old
;)
4554 && old_lines
[i
]->old_uses
== 1
4555 && old_lines
[i
]->new_uses
== 1)
4558 int new_line
= old_lines
[i
]->new_line_number
;
4559 struct run
*run
= run_pool
+ run_idx
++;
4562 run
->current_vpos
= i
;
4563 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4564 run
->desired_vpos
= new_line
;
4565 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4567 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4569 /* Extend backward. */
4572 while (j
> first_old
4574 && old_lines
[j
] == new_lines
[k
])
4576 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4577 --run
->current_vpos
;
4578 --run
->desired_vpos
;
4581 run
->desired_y
-= h
;
4582 run
->current_y
-= h
;
4586 /* Extend forward. */
4591 && old_lines
[j
] == new_lines
[k
])
4593 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4599 /* Insert run into list of all runs. Order runs by copied
4600 pixel lines. Note that we record runs that don't have to
4601 be copied because they are already in place. This is done
4602 because we can avoid calling update_window_line in this
4604 for (j
= 0; j
< nruns
&& runs
[j
]->height
> run
->height
; ++j
)
4606 for (k
= nruns
; k
>= j
; --k
)
4607 runs
[k
] = runs
[k
- 1];
4616 /* Do the moves. Do it in a way that we don't overwrite something
4617 we want to copy later on. This is not solvable in general
4618 because there is only one display and we don't have a way to
4619 exchange areas on this display. Example:
4621 +-----------+ +-----------+
4623 +-----------+ --> +-----------+
4625 +-----------+ +-----------+
4627 Instead, prefer bigger moves, and invalidate moves that would
4628 copy from where we copied to. */
4630 for (i
= 0; i
< nruns
; ++i
)
4631 if (runs
[i
]->nrows
> 0)
4633 struct run
*r
= runs
[i
];
4635 /* Copy on the display. */
4636 if (r
->current_y
!= r
->desired_y
)
4638 rif
->scroll_run_hook (w
, r
);
4640 /* Invalidate runs that copy from where we copied to. */
4641 for (j
= i
+ 1; j
< nruns
; ++j
)
4643 struct run
*p
= runs
[j
];
4645 if ((p
->current_y
>= r
->desired_y
4646 && p
->current_y
< r
->desired_y
+ r
->height
)
4647 || (p
->current_y
+ p
->height
>= r
->desired_y
4648 && (p
->current_y
+ p
->height
4649 < r
->desired_y
+ r
->height
)))
4654 /* Assign matrix rows. */
4655 for (j
= 0; j
< r
->nrows
; ++j
)
4657 struct glyph_row
*from
, *to
;
4658 int to_overlapped_p
;
4660 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
4661 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
4662 to_overlapped_p
= to
->overlapped_p
;
4663 assign_row (to
, from
);
4664 to
->enabled_p
= 1, from
->enabled_p
= 0;
4665 to
->overlapped_p
= to_overlapped_p
;
4669 /* Clear the hash table, for the next time. */
4670 for (i
= 0; i
< row_entry_idx
; ++i
)
4671 row_table
[row_entry_pool
[i
].bucket
] = NULL
;
4673 /* Value is non-zero to indicate that we scrolled the display. */
4679 /************************************************************************
4681 ************************************************************************/
4683 /* Update the desired frame matrix of frame F.
4685 FORCE_P non-zero means that the update should not be stopped by
4686 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
4687 should not be tried.
4689 Value is non-zero if update was stopped due to pending input. */
4692 update_frame_1 (f
, force_p
, inhibit_id_p
)
4697 /* Frame matrices to work on. */
4698 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4699 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4702 int preempt_count
= baud_rate
/ 2400 + 1;
4703 extern int input_pending
;
4705 xassert (current_matrix
&& desired_matrix
);
4707 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
4708 calculate_costs (f
);
4710 if (preempt_count
<= 0)
4713 if (redisplay_dont_pause
)
4715 else if (!force_p
&& detect_input_pending ())
4723 /* If we cannot insert/delete lines, it's no use trying it. */
4724 if (!line_ins_del_ok
)
4727 /* See if any of the desired lines are enabled; don't compute for
4728 i/d line if just want cursor motion. */
4729 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
4730 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4733 /* Try doing i/d line, if not yet inhibited. */
4734 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
4735 force_p
|= scrolling (f
);
4737 /* Update the individual lines as needed. Do bottom line first. */
4738 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
4739 update_frame_line (f
, desired_matrix
->nrows
- 1);
4741 /* Now update the rest of the lines. */
4742 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
4744 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4746 if (FRAME_TERMCAP_P (f
))
4748 /* Flush out every so many lines.
4749 Also flush out if likely to have more than 1k buffered
4750 otherwise. I'm told that some telnet connections get
4751 really screwed by more than 1k output at once. */
4752 int outq
= PENDING_OUTPUT_COUNT (stdout
);
4754 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
4757 if (preempt_count
== 1)
4759 #ifdef EMACS_OUTQSIZE
4760 if (EMACS_OUTQSIZE (0, &outq
) < 0)
4761 /* Probably not a tty. Ignore the error and reset
4762 * the outq count. */
4763 outq
= PENDING_OUTPUT_COUNT (stdout
);
4766 if (baud_rate
<= outq
&& baud_rate
> 0)
4767 sleep (outq
/ baud_rate
);
4772 if ((i
- 1) % preempt_count
== 0)
4773 detect_input_pending ();
4775 update_frame_line (f
, i
);
4779 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
4781 /* Now just clean up termcap drivers and set cursor, etc. */
4784 if ((cursor_in_echo_area
4785 /* If we are showing a message instead of the mini-buffer,
4786 show the cursor for the message instead of for the
4787 (now hidden) mini-buffer contents. */
4788 || (EQ (minibuf_window
, selected_window
)
4789 && EQ (minibuf_window
, echo_area_window
)
4790 && !NILP (echo_area_buffer
[0])))
4791 /* These cases apply only to the frame that contains
4792 the active mini-buffer window. */
4793 && FRAME_HAS_MINIBUF_P (f
)
4794 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4796 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
4799 if (cursor_in_echo_area
< 0)
4801 /* Negative value of cursor_in_echo_area means put
4802 cursor at beginning of line. */
4808 /* Positive value of cursor_in_echo_area means put
4809 cursor at the end of the prompt. If the mini-buffer
4810 is several lines high, find the last line that has
4812 row
= FRAME_HEIGHT (f
);
4818 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
4820 /* Frame rows are filled up with spaces that
4821 must be ignored here. */
4822 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
4824 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
4825 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
4828 && (last
- 1)->charpos
< 0)
4834 while (row
> top
&& col
== 0);
4836 /* Make sure COL is not out of range. */
4837 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
4839 /* If we have another row, advance cursor into it. */
4840 if (row
< FRAME_HEIGHT (f
) - 1)
4842 col
= FRAME_LEFT_SCROLL_BAR_WIDTH (f
);
4845 /* Otherwise move it back in range. */
4847 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
4851 cursor_to (row
, col
);
4855 /* We have only one cursor on terminal frames. Use it to
4856 display the cursor of the selected window. */
4857 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
4858 if (w
->cursor
.vpos
>= 0
4859 /* The cursor vpos may be temporarily out of bounds
4860 in the following situation: There is one window,
4861 with the cursor in the lower half of it. The window
4862 is split, and a message causes a redisplay before
4863 a new cursor position has been computed. */
4864 && w
->cursor
.vpos
< XFASTINT (w
->height
))
4866 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
4867 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
4869 if (INTEGERP (w
->left_margin_width
))
4870 x
+= XFASTINT (w
->left_margin_width
);
4872 /* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
4881 fflush (termscript
);
4886 display_completed
= !pause
;
4887 clear_desired_matrices (f
);
4892 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4896 struct frame
*frame
;
4898 int unchanged_at_top
, unchanged_at_bottom
;
4901 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4902 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4903 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4904 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4906 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
4907 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4908 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4910 if (!current_matrix
)
4913 /* Compute hash codes of all the lines. Also calculate number of
4914 changed lines, number of unchanged lines at the beginning, and
4915 number of unchanged lines at the end. */
4917 unchanged_at_top
= 0;
4918 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
4919 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
4921 /* Give up on this scrolling if some old lines are not enabled. */
4922 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
4924 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
4925 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4927 /* This line cannot be redrawn, so don't let scrolling mess it. */
4928 new_hash
[i
] = old_hash
[i
];
4929 #define INFINITY 1000000 /* Taken from scroll.c */
4930 draw_cost
[i
] = INFINITY
;
4934 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
4935 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
4938 if (old_hash
[i
] != new_hash
[i
])
4941 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
4943 else if (i
== unchanged_at_top
)
4945 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
4948 /* If changed lines are few, don't allow preemption, don't scroll. */
4949 if ((!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400)
4950 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
4953 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
4954 - unchanged_at_bottom
);
4956 if (scroll_region_ok
)
4957 free_at_end_vpos
-= unchanged_at_bottom
;
4958 else if (memory_below_frame
)
4959 free_at_end_vpos
= -1;
4961 /* If large window, fast terminal and few lines in common between
4962 current frame and desired frame, don't bother with i/d calc. */
4963 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
4965 10 * scrolling_max_lines_saved (unchanged_at_top
,
4966 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
4967 old_hash
, new_hash
, draw_cost
)))
4970 if (window_size
< 2)
4973 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
4974 draw_cost
+ unchanged_at_top
- 1,
4975 old_draw_cost
+ unchanged_at_top
- 1,
4976 old_hash
+ unchanged_at_top
- 1,
4977 new_hash
+ unchanged_at_top
- 1,
4978 free_at_end_vpos
- unchanged_at_top
);
4984 /* Count the number of blanks at the start of the vector of glyphs R
4985 which is LEN glyphs long. */
4988 count_blanks (r
, len
)
4994 for (i
= 0; i
< len
; ++i
)
4995 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
5002 /* Count the number of glyphs in common at the start of the glyph
5003 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
5004 of STR2. Value is the number of equal glyphs equal at the start. */
5007 count_match (str1
, end1
, str2
, end2
)
5008 struct glyph
*str1
, *end1
, *str2
, *end2
;
5010 struct glyph
*p1
= str1
;
5011 struct glyph
*p2
= str2
;
5015 && GLYPH_CHAR_AND_FACE_EQUAL_P (p1
, p2
))
5022 /* Char insertion/deletion cost vector, from term.c */
5024 extern int *char_ins_del_vector
;
5025 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
5028 /* Perform a frame-based update on line VPOS in frame FRAME. */
5031 update_frame_line (frame
, vpos
)
5032 register struct frame
*frame
;
5035 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
5037 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
5038 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
5039 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
5040 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
5041 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
5042 int must_write_whole_line_p
;
5044 if (desired_row
->inverse_p
5045 != (current_row
->enabled_p
&& current_row
->inverse_p
))
5047 int n
= current_row
->enabled_p
? current_row
->used
[TEXT_AREA
] : 0;
5048 change_line_highlight (desired_row
->inverse_p
, vpos
, vpos
, n
);
5049 current_row
->enabled_p
= 0;
5052 reassert_line_highlight (desired_row
->inverse_p
, vpos
);
5054 /* Current row not enabled means it has unknown contents. We must
5055 write the whole desired line in that case. */
5056 must_write_whole_line_p
= !current_row
->enabled_p
;
5057 if (must_write_whole_line_p
)
5064 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
5065 olen
= current_row
->used
[TEXT_AREA
];
5067 if (! current_row
->inverse_p
)
5069 /* Ignore trailing spaces, if we can. */
5070 if (!must_write_spaces
)
5071 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
5076 /* For an inverse-video line, make sure it's filled with
5077 spaces all the way to the frame edge so that the reverse
5078 video extends all the way across. */
5079 while (olen
< FRAME_WIDTH (frame
) - 1)
5080 obody
[olen
++] = space_glyph
;
5084 current_row
->enabled_p
= 1;
5085 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
5086 current_row
->inverse_p
= desired_row
->inverse_p
;
5088 /* If desired line is empty, just clear the line. */
5089 if (!desired_row
->enabled_p
)
5095 nbody
= desired_row
->glyphs
[TEXT_AREA
];
5096 nlen
= desired_row
->used
[TEXT_AREA
];
5097 nend
= nbody
+ nlen
;
5099 /* If display line has unknown contents, write the whole line. */
5100 if (must_write_whole_line_p
)
5102 /* Ignore spaces at the end, if we can. */
5103 if (!must_write_spaces
)
5104 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5107 /* Write the contents of the desired line. */
5110 cursor_to (vpos
, 0);
5111 write_glyphs (nbody
, nlen
);
5114 /* Don't call clear_end_of_line if we already wrote the whole
5115 line. The cursor will not be at the right margin in that
5116 case but in the line below. */
5117 if (nlen
< FRAME_WINDOW_WIDTH (frame
))
5119 cursor_to (vpos
, nlen
);
5120 clear_end_of_line (FRAME_WINDOW_WIDTH (frame
));
5123 /* Make sure we are in the right row, otherwise cursor movement
5124 with cmgoto might use `ch' in the wrong row. */
5125 cursor_to (vpos
, 0);
5127 make_current (desired_matrix
, current_matrix
, vpos
);
5131 /* Pretend trailing spaces are not there at all,
5132 unless for one reason or another we must write all spaces. */
5133 if (!desired_row
->inverse_p
)
5135 if (!must_write_spaces
)
5136 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5141 /* For an inverse-video line, give it extra trailing spaces all
5142 the way to the frame edge so that the reverse video extends
5143 all the way across. */
5144 while (nlen
< FRAME_WIDTH (frame
) - 1)
5145 nbody
[nlen
++] = space_glyph
;
5148 /* If there's no i/d char, quickly do the best we can without it. */
5149 if (!char_ins_del_ok
)
5153 /* Find the first glyph in desired row that doesn't agree with
5154 a glyph in the current row, and write the rest from there on. */
5155 for (i
= 0; i
< nlen
; i
++)
5157 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
5159 /* Find the end of the run of different glyphs. */
5163 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
5164 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
5167 /* Output this run of non-matching chars. */
5168 cursor_to (vpos
, i
);
5169 write_glyphs (nbody
+ i
, j
- i
);
5172 /* Now find the next non-match. */
5176 /* Clear the rest of the line, or the non-clear part of it. */
5179 cursor_to (vpos
, nlen
);
5180 clear_end_of_line (olen
);
5183 /* Make current row = desired row. */
5184 make_current (desired_matrix
, current_matrix
, vpos
);
5188 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
5189 characters in a row. */
5193 /* If current line is blank, skip over initial spaces, if
5194 possible, and write the rest. */
5195 if (must_write_spaces
|| desired_row
->inverse_p
)
5198 nsp
= count_blanks (nbody
, nlen
);
5202 cursor_to (vpos
, nsp
);
5203 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
5206 /* Exchange contents between current_frame and new_frame. */
5207 make_current (desired_matrix
, current_matrix
, vpos
);
5211 /* Compute number of leading blanks in old and new contents. */
5212 osp
= count_blanks (obody
, olen
);
5213 nsp
= desired_row
->inverse_p
? 0 : count_blanks (nbody
, nlen
);
5215 /* Compute number of matching chars starting with first non-blank. */
5216 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
5217 nbody
+ nsp
, nbody
+ nlen
);
5219 /* Spaces in new match implicit space past the end of old. */
5220 /* A bug causing this to be a no-op was fixed in 18.29. */
5221 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
5224 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
5228 /* Avoid doing insert/delete char
5229 just cause number of leading spaces differs
5230 when the following text does not match. */
5231 if (begmatch
== 0 && osp
!= nsp
)
5232 osp
= nsp
= min (osp
, nsp
);
5234 /* Find matching characters at end of line */
5237 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
5239 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
5244 endmatch
= obody
+ olen
- op1
;
5246 /* tem gets the distance to insert or delete.
5247 endmatch is how many characters we save by doing so.
5250 tem
= (nlen
- nsp
) - (olen
- osp
);
5252 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
5255 /* nsp - osp is the distance to insert or delete.
5256 If that is nonzero, begmatch is known to be nonzero also.
5257 begmatch + endmatch is how much we save by doing the ins/del.
5261 && (!char_ins_del_ok
5262 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
5266 osp
= nsp
= min (osp
, nsp
);
5269 /* Now go through the line, inserting, writing and
5270 deleting as appropriate. */
5274 cursor_to (vpos
, nsp
);
5275 delete_glyphs (osp
- nsp
);
5279 /* If going to delete chars later in line
5280 and insert earlier in the line,
5281 must delete first to avoid losing data in the insert */
5282 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
5284 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
5285 delete_glyphs (olen
+ nsp
- osp
- nlen
);
5286 olen
= nlen
- (nsp
- osp
);
5288 cursor_to (vpos
, osp
);
5289 insert_glyphs (0, nsp
- osp
);
5293 tem
= nsp
+ begmatch
+ endmatch
;
5294 if (nlen
!= tem
|| olen
!= tem
)
5296 cursor_to (vpos
, nsp
+ begmatch
);
5297 if (!endmatch
|| nlen
== olen
)
5299 /* If new text being written reaches right margin,
5300 there is no need to do clear-to-eol at the end.
5301 (and it would not be safe, since cursor is not
5302 going to be "at the margin" after the text is done) */
5303 if (nlen
== FRAME_WINDOW_WIDTH (frame
))
5305 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5307 else if (nlen
> olen
)
5309 /* Here, we used to have the following simple code:
5310 ----------------------------------------
5311 write_glyphs (nbody + nsp + begmatch, olen - tem);
5312 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5313 ----------------------------------------
5314 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5315 is a padding glyph. */
5316 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5319 /* Calculate columns we can actually overwrite. */
5320 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
])) out
--;
5321 write_glyphs (nbody
+ nsp
+ begmatch
, out
);
5322 /* If we left columns to be overwritten, we must delete them. */
5323 del
= olen
- tem
- out
;
5324 if (del
> 0) delete_glyphs (del
);
5325 /* At last, we insert columns not yet written out. */
5326 insert_glyphs (nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5329 else if (olen
> nlen
)
5331 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5332 delete_glyphs (olen
- nlen
);
5338 /* If any unerased characters remain after the new line, erase them. */
5341 cursor_to (vpos
, nlen
);
5342 clear_end_of_line (olen
);
5345 /* Exchange contents between current_frame and new_frame. */
5346 make_current (desired_matrix
, current_matrix
, vpos
);
5351 /***********************************************************************
5352 X/Y Position -> Buffer Position
5353 ***********************************************************************/
5355 /* Return the character position of the character at window relative
5356 pixel position (*X, *Y). *X and *Y are adjusted to character
5360 buffer_posn_from_coords (w
, x
, y
)
5365 struct buffer
*old_current_buffer
= current_buffer
;
5366 struct text_pos startp
;
5367 int left_area_width
;
5369 current_buffer
= XBUFFER (w
->buffer
);
5370 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5371 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5372 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5373 start_display (&it
, w
, startp
);
5375 left_area_width
= WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH (w
);
5376 move_it_to (&it
, -1, *x
+ it
.first_visible_x
- left_area_width
, *y
, -1,
5377 MOVE_TO_X
| MOVE_TO_Y
);
5379 *x
= it
.current_x
- it
.first_visible_x
+ left_area_width
;
5381 current_buffer
= old_current_buffer
;
5382 return IT_CHARPOS (it
);
5386 /* Value is the string under window-relative coordinates X/Y in the
5387 mode or top line of window W, or nil if none. MODE_LINE_P non-zero
5388 means look at the mode line. *CHARPOS is set to the position in
5389 the string returned. */
5392 mode_line_string (w
, x
, y
, mode_line_p
, charpos
)
5394 int x
, y
, mode_line_p
;
5397 struct glyph_row
*row
;
5398 struct glyph
*glyph
, *end
;
5399 struct frame
*f
= XFRAME (w
->frame
);
5401 Lisp_Object string
= Qnil
;
5404 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5406 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
5408 if (row
->mode_line_p
&& row
->enabled_p
)
5410 /* The mode lines are displayed over scroll bars and bitmap
5411 areas, and X is window-relative. Correct X by the scroll bar
5412 and bitmap area width. */
5413 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
5414 x
+= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
5415 x
+= FRAME_LEFT_FLAGS_AREA_WIDTH (f
);
5417 /* Find the glyph under X. If we find one with a string object,
5418 it's the one we were looking for. */
5419 glyph
= row
->glyphs
[TEXT_AREA
];
5420 end
= glyph
+ row
->used
[TEXT_AREA
];
5421 for (x0
= 0; glyph
< end
; x0
+= glyph
->pixel_width
, ++glyph
)
5422 if (x
>= x0
&& x
< x0
+ glyph
->pixel_width
)
5424 string
= glyph
->object
;
5425 *charpos
= glyph
->charpos
;
5434 /***********************************************************************
5435 Changing Frame Sizes
5436 ***********************************************************************/
5441 window_change_signal (signalnum
) /* If we don't have an argument, */
5442 int signalnum
; /* some compilers complain in signal calls. */
5448 int old_errno
= errno
;
5450 get_frame_size (&width
, &height
);
5452 /* The frame size change obviously applies to a termcap-controlled
5453 frame. Find such a frame in the list, and assume it's the only
5454 one (since the redisplay code always writes to stdout, not a
5455 FILE * specified in the frame structure). Record the new size,
5456 but don't reallocate the data structures now. Let that be done
5457 later outside of the signal handler. */
5460 Lisp_Object tail
, frame
;
5462 FOR_EACH_FRAME (tail
, frame
)
5464 if (FRAME_TERMCAP_P (XFRAME (frame
)))
5466 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5472 signal (SIGWINCH
, window_change_signal
);
5475 #endif /* SIGWINCH */
5478 /* Do any change in frame size that was requested by a signal. SAFE
5479 non-zero means this function is called from a place where it is
5480 safe to change frame sizes while a redisplay is in progress. */
5483 do_pending_window_change (safe
)
5486 /* If window_change_signal should have run before, run it now. */
5487 if (redisplaying_p
&& !safe
)
5490 while (delayed_size_change
)
5492 Lisp_Object tail
, frame
;
5494 delayed_size_change
= 0;
5496 FOR_EACH_FRAME (tail
, frame
)
5498 struct frame
*f
= XFRAME (frame
);
5500 int height
= FRAME_NEW_HEIGHT (f
);
5501 int width
= FRAME_NEW_WIDTH (f
);
5503 if (height
!= 0 || width
!= 0)
5504 change_frame_size (f
, height
, width
, 0, 0, safe
);
5510 /* Change the frame height and/or width. Values may be given as zero to
5511 indicate no change is to take place.
5513 If DELAY is non-zero, then assume we're being called from a signal
5514 handler, and queue the change for later - perhaps the next
5515 redisplay. Since this tries to resize windows, we can't call it
5516 from a signal handler.
5518 SAFE non-zero means this function is called from a place where it's
5519 safe to change frame sizes while a redisplay is in progress. */
5522 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5523 register struct frame
*f
;
5524 int newheight
, newwidth
, pretend
, delay
, safe
;
5526 Lisp_Object tail
, frame
;
5528 if (! FRAME_WINDOW_P (f
))
5530 /* When using termcap, or on MS-DOS, all frames use
5531 the same screen, so a change in size affects all frames. */
5532 FOR_EACH_FRAME (tail
, frame
)
5533 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5534 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5535 pretend
, delay
, safe
);
5538 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
5542 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5543 register struct frame
*f
;
5544 int newheight
, newwidth
, pretend
, delay
, safe
;
5546 int new_frame_window_width
;
5547 int count
= specpdl_ptr
- specpdl
;
5549 /* If we can't deal with the change now, queue it for later. */
5550 if (delay
|| (redisplaying_p
&& !safe
))
5552 FRAME_NEW_HEIGHT (f
) = newheight
;
5553 FRAME_NEW_WIDTH (f
) = newwidth
;
5554 delayed_size_change
= 1;
5558 /* This size-change overrides any pending one for this frame. */
5559 FRAME_NEW_HEIGHT (f
) = 0;
5560 FRAME_NEW_WIDTH (f
) = 0;
5562 /* If an argument is zero, set it to the current value. */
5564 newheight
= FRAME_HEIGHT (f
);
5566 newwidth
= FRAME_WIDTH (f
);
5568 /* Compute width of windows in F.
5569 This is the width of the frame without vertical scroll bars. */
5570 new_frame_window_width
= FRAME_WINDOW_WIDTH_ARG (f
, newwidth
);
5572 /* Round up to the smallest acceptable size. */
5573 check_frame_size (f
, &newheight
, &newwidth
);
5575 /* If we're not changing the frame size, quit now. */
5576 if (newheight
== FRAME_HEIGHT (f
)
5577 && new_frame_window_width
== FRAME_WINDOW_WIDTH (f
))
5583 /* We only can set screen dimensions to certain values supported
5584 by our video hardware. Try to find the smallest size greater
5585 or equal to the requested dimensions. */
5586 dos_set_window_size (&newheight
, &newwidth
);
5589 if (newheight
!= FRAME_HEIGHT (f
))
5591 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
5593 /* Frame has both root and mini-buffer. */
5594 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f
))->top
,
5595 FRAME_TOP_MARGIN (f
));
5596 set_window_height (FRAME_ROOT_WINDOW (f
),
5599 - FRAME_TOP_MARGIN (f
)),
5601 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
,
5603 set_window_height (FRAME_MINIBUF_WINDOW (f
), 1, 0);
5606 /* Frame has just one top-level window. */
5607 set_window_height (FRAME_ROOT_WINDOW (f
),
5608 newheight
- FRAME_TOP_MARGIN (f
), 0);
5610 if (FRAME_TERMCAP_P (f
) && !pretend
)
5611 FrameRows
= newheight
;
5614 if (new_frame_window_width
!= FRAME_WINDOW_WIDTH (f
))
5616 set_window_width (FRAME_ROOT_WINDOW (f
), new_frame_window_width
, 0);
5617 if (FRAME_HAS_MINIBUF_P (f
))
5618 set_window_width (FRAME_MINIBUF_WINDOW (f
), new_frame_window_width
, 0);
5620 if (FRAME_TERMCAP_P (f
) && !pretend
)
5621 FrameCols
= newwidth
;
5623 if (WINDOWP (f
->tool_bar_window
))
5624 XSETFASTINT (XWINDOW (f
->tool_bar_window
)->width
, newwidth
);
5627 FRAME_HEIGHT (f
) = newheight
;
5628 SET_FRAME_WIDTH (f
, newwidth
);
5631 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5632 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
5634 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
5636 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
5637 w
->cursor
.hpos
= w
->cursor
.x
= 0;
5638 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
5639 w
->cursor
.vpos
= w
->cursor
.y
= 0;
5643 SET_FRAME_GARBAGED (f
);
5644 calculate_costs (f
);
5648 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
5650 /* This isn't quite a no-op: it runs window-configuration-change-hook. */
5651 Fset_window_buffer (FRAME_SELECTED_WINDOW (f
),
5652 XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
);
5654 unbind_to (count
, Qnil
);
5659 /***********************************************************************
5660 Terminal Related Lisp Functions
5661 ***********************************************************************/
5663 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
5664 1, 1, "FOpen termscript file: ",
5665 "Start writing all terminal output to FILE as well as the terminal.\n\
5666 FILE = nil means just close any termscript file currently open.")
5670 if (termscript
!= 0) fclose (termscript
);
5675 file
= Fexpand_file_name (file
, Qnil
);
5676 termscript
= fopen (XSTRING (file
)->data
, "w");
5677 if (termscript
== 0)
5678 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
5684 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
5685 Ssend_string_to_terminal
, 1, 1, 0,
5686 "Send STRING to the terminal without alteration.\n\
5687 Control characters in STRING will have terminal-dependent effects.")
5691 /* ??? Perhaps we should do something special for multibyte strings here. */
5692 CHECK_STRING (string
, 0);
5693 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)), stdout
);
5697 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)),
5699 fflush (termscript
);
5705 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
5706 "Beep, or flash the screen.\n\
5707 Also, unless an argument is given,\n\
5708 terminate any keyboard macro currently executing.")
5731 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
5732 error ("Keyboard macro terminated by a command ringing the bell");
5740 /***********************************************************************
5742 ***********************************************************************/
5744 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
5745 "Pause, without updating display, for SECONDS seconds.\n\
5746 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5747 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5748 additional wait period, in milliseconds; this may be useful if your\n\
5749 Emacs was built without floating point support.\n\
5750 \(Not all operating systems support waiting for a fraction of a second.)")
5751 (seconds
, milliseconds
)
5752 Lisp_Object seconds
, milliseconds
;
5756 if (NILP (milliseconds
))
5757 XSETINT (milliseconds
, 0);
5759 CHECK_NUMBER (milliseconds
, 1);
5760 usec
= XINT (milliseconds
) * 1000;
5763 double duration
= extract_float (seconds
);
5764 sec
= (int) duration
;
5765 usec
+= (duration
- sec
) * 1000000;
5768 #ifndef EMACS_HAS_USECS
5769 if (sec
== 0 && usec
!= 0)
5770 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
5773 /* Assure that 0 <= usec < 1000000. */
5776 /* We can't rely on the rounding being correct if user is negative. */
5777 if (-1000000 < usec
)
5778 sec
--, usec
+= 1000000;
5780 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
5783 sec
+= usec
/ 1000000, usec
%= 1000000;
5785 if (sec
< 0 || (sec
== 0 && usec
== 0))
5791 XSETFASTINT (zero
, 0);
5792 wait_reading_process_input (sec
, usec
, zero
, 0);
5795 /* We should always have wait_reading_process_input; we have a dummy
5796 implementation for systems which don't support subprocesses. */
5798 /* No wait_reading_process_input */
5805 /* The reason this is done this way
5806 (rather than defined (H_S) && defined (H_T))
5807 is because the VMS preprocessor doesn't grok `defined' */
5809 EMACS_GET_TIME (end_time
);
5810 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
5811 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
5815 EMACS_GET_TIME (timeout
);
5816 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
5817 if (EMACS_TIME_NEG_P (timeout
)
5818 || !select (1, 0, 0, 0, &timeout
))
5821 #else /* not HAVE_SELECT */
5823 #endif /* HAVE_SELECT */
5824 #endif /* not VMS */
5827 #endif /* no subprocesses */
5833 /* This is just like wait_reading_process_input, except that
5834 it does the redisplay.
5836 It's also much like Fsit_for, except that it can be used for
5837 waiting for input as well. */
5840 sit_for (sec
, usec
, reading
, display
, initial_display
)
5841 int sec
, usec
, reading
, display
, initial_display
;
5843 Lisp_Object read_kbd
;
5845 swallow_events (display
);
5847 if (detect_input_pending_run_timers (display
))
5850 if (initial_display
)
5851 redisplay_preserve_echo_area ();
5853 if (sec
== 0 && usec
== 0)
5860 XSETINT (read_kbd
, reading
? -1 : 1);
5861 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
5863 return detect_input_pending () ? Qnil
: Qt
;
5867 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
5868 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
5869 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5870 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5871 additional wait period, in milliseconds; this may be useful if your\n\
5872 Emacs was built without floating point support.\n\
5873 \(Not all operating systems support waiting for a fraction of a second.)\n\
5874 Optional third arg NODISP non-nil means don't redisplay, just wait for input.\n\
5875 Redisplay is preempted as always if input arrives, and does not happen\n\
5876 if input is available before it starts.\n\
5877 Value is t if waited the full time with no input arriving.")
5878 (seconds
, milliseconds
, nodisp
)
5879 Lisp_Object seconds
, milliseconds
, nodisp
;
5883 if (NILP (milliseconds
))
5884 XSETINT (milliseconds
, 0);
5886 CHECK_NUMBER (milliseconds
, 1);
5887 usec
= XINT (milliseconds
) * 1000;
5890 double duration
= extract_float (seconds
);
5891 sec
= (int) duration
;
5892 usec
+= (duration
- sec
) * 1000000;
5895 #ifndef EMACS_HAS_USECS
5896 if (usec
!= 0 && sec
== 0)
5897 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
5900 return sit_for (sec
, usec
, 0, NILP (nodisp
), NILP (nodisp
));
5905 /***********************************************************************
5906 Other Lisp Functions
5907 ***********************************************************************/
5909 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
5910 session's frames, frame names, buffers, buffer-read-only flags, and
5911 buffer-modified-flags, and a trailing sentinel (so we don't need to
5912 add length checks). */
5914 static Lisp_Object frame_and_buffer_state
;
5917 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
5918 Sframe_or_buffer_changed_p
, 0, 0, 0,
5919 "Return non-nil if the frame and buffer state appears to have changed.\n\
5920 The state variable is an internal vector containing all frames and buffers,\n\
5921 aside from buffers whose names start with space,\n\
5922 along with the buffers' read-only and modified flags, which allows a fast\n\
5923 check to see whether the menu bars might need to be recomputed.\n\
5924 If this function returns non-nil, it updates the internal vector to reflect\n\
5925 the current state.\n")
5928 Lisp_Object tail
, frame
, buf
;
5932 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5933 FOR_EACH_FRAME (tail
, frame
)
5935 if (!EQ (*vecp
++, frame
))
5937 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
5940 /* Check that the buffer info matches.
5941 No need to test for the end of the vector
5942 because the last element of the vector is lambda
5943 and that will always cause a mismatch. */
5944 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5946 buf
= XCDR (XCAR (tail
));
5947 /* Ignore buffers that aren't included in buffer lists. */
5948 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5950 if (!EQ (*vecp
++, buf
))
5952 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
5954 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
5957 /* Detect deletion of a buffer at the end of the list. */
5958 if (EQ (*vecp
, Qlambda
))
5961 /* Start with 1 so there is room for at least one lambda at the end. */
5963 FOR_EACH_FRAME (tail
, frame
)
5965 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5967 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
5968 if (n
> XVECTOR (frame_and_buffer_state
)->size
5969 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
5970 /* Add 20 extra so we grow it less often. */
5971 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
5972 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5973 FOR_EACH_FRAME (tail
, frame
)
5976 *vecp
++ = XFRAME (frame
)->name
;
5978 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5980 buf
= XCDR (XCAR (tail
));
5981 /* Ignore buffers that aren't included in buffer lists. */
5982 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5985 *vecp
++ = XBUFFER (buf
)->read_only
;
5986 *vecp
++ = Fbuffer_modified_p (buf
);
5988 /* Fill up the vector with lambdas (always at least one). */
5990 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5991 < XVECTOR (frame_and_buffer_state
)->size
)
5993 /* Make sure we didn't overflow the vector. */
5994 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5995 > XVECTOR (frame_and_buffer_state
)->size
)
6002 /***********************************************************************
6004 ***********************************************************************/
6006 char *terminal_type
;
6008 /* Initialization done when Emacs fork is started, before doing stty.
6009 Determine terminal type and set terminal_driver. Then invoke its
6010 decoding routine to set up variables in the terminal package. */
6015 #ifdef HAVE_X_WINDOWS
6016 extern int display_arg
;
6019 /* Construct the space glyph. */
6020 space_glyph
.type
= CHAR_GLYPH
;
6021 SET_CHAR_GLYPH_FROM_GLYPH (space_glyph
, ' ');
6022 space_glyph
.charpos
= -1;
6026 cursor_in_echo_area
= 0;
6027 terminal_type
= (char *) 0;
6029 /* Now is the time to initialize this; it's used by init_sys_modes
6031 Vwindow_system
= Qnil
;
6033 /* If the user wants to use a window system, we shouldn't bother
6034 initializing the terminal. This is especially important when the
6035 terminal is so dumb that emacs gives up before and doesn't bother
6036 using the window system.
6038 If the DISPLAY environment variable is set and nonempty,
6039 try to use X, and die with an error message if that doesn't work. */
6041 #ifdef HAVE_X_WINDOWS
6046 display
= getenv ("DECW$DISPLAY");
6048 display
= getenv ("DISPLAY");
6051 display_arg
= (display
!= 0 && *display
!= 0);
6054 if (!inhibit_window_system
&& display_arg
6060 Vwindow_system
= intern ("x");
6062 Vwindow_system_version
= make_number (11);
6064 Vwindow_system_version
= make_number (10);
6066 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
6067 /* In some versions of ncurses,
6068 tputs crashes if we have not called tgetent.
6070 { char b
[2044]; tgetent (b
, "xterm");}
6072 adjust_frame_glyphs_initially ();
6075 #endif /* HAVE_X_WINDOWS */
6078 if (!inhibit_window_system
)
6080 Vwindow_system
= intern ("w32");
6081 Vwindow_system_version
= make_number (1);
6082 adjust_frame_glyphs_initially ();
6085 #endif /* HAVE_NTGUI */
6087 /* If no window system has been specified, try to use the terminal. */
6090 fatal ("standard input is not a tty");
6094 /* Look at the TERM variable */
6095 terminal_type
= (char *) getenv ("TERM");
6099 fprintf (stderr
, "Please specify your terminal type.\n\
6100 For types defined in VMS, use set term /device=TYPE.\n\
6101 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
6102 \(The quotation marks are necessary since terminal types are lower case.)\n");
6104 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
6110 /* VMS DCL tends to up-case things, so down-case term type.
6111 Hardly any uppercase letters in terminal types; should be none. */
6113 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
6116 strcpy (new, terminal_type
);
6118 for (p
= new; *p
; p
++)
6122 terminal_type
= new;
6126 term_init (terminal_type
);
6129 struct frame
*sf
= SELECTED_FRAME ();
6130 int width
= FRAME_WINDOW_WIDTH (sf
);
6131 int height
= FRAME_HEIGHT (sf
);
6133 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (struct glyph
);
6135 /* If these sizes are so big they cause overflow, just ignore the
6136 change. It's not clear what better we could do. */
6137 if (total_glyphs
/ sizeof (struct glyph
) / height
!= width
+ 2)
6138 fatal ("screen size %dx%d too big", width
, height
);
6141 adjust_frame_glyphs_initially ();
6142 calculate_costs (XFRAME (selected_frame
));
6147 #endif /* CANNOT_DUMP */
6148 signal (SIGWINCH
, window_change_signal
);
6149 #endif /* SIGWINCH */
6151 /* Set up faces of the initial terminal frame of a dumped Emacs. */
6155 /* The MSDOS terminal turns on its ``window system'' relatively
6156 late into the startup, so we cannot do the frame faces'
6157 initialization just yet. It will be done later by pc-win.el
6158 and internal_terminal_init. */
6159 && (strcmp (terminal_type
, "internal") != 0 || inhibit_window_system
)
6161 && NILP (Vwindow_system
))
6163 /* For the initial frame, we don't have any way of knowing what
6164 are the foreground and background colors of the terminal. */
6165 struct frame
*sf
= SELECTED_FRAME();
6167 FRAME_FOREGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_FG_COLOR
;
6168 FRAME_BACKGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_BG_COLOR
;
6169 call0 (intern ("tty-set-up-initial-frame-faces"));
6175 /***********************************************************************
6177 ***********************************************************************/
6179 DEFUN ("internal-show-cursor", Finternal_show_cursor
,
6180 Sinternal_show_cursor
, 2, 2, 0,
6181 "Set the cursor-visibility flag of WINDOW to SHOW.\n\
6182 WINDOW nil means use the selected window. SHOW non-nil means\n\
6183 show a cursor in WINDOW in the next redisplay. SHOW nil means\n\
6184 don't show a cursor.")
6186 Lisp_Object window
, show
;
6188 /* Don't change cursor state while redisplaying. This could confuse
6190 if (!redisplaying_p
)
6193 window
= selected_window
;
6195 CHECK_WINDOW (window
, 2);
6197 XWINDOW (window
)->cursor_off_p
= NILP (show
);
6204 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p
,
6205 Sinternal_show_cursor_p
, 0, 1, 0,
6206 "Value is non-nil if next redisplay will display a cursor in WINDOW.\n\
6207 WINDOW nil or omitted means report on the selected window.")
6214 window
= selected_window
;
6216 CHECK_WINDOW (window
, 2);
6218 w
= XWINDOW (window
);
6219 return w
->cursor_off_p
? Qnil
: Qt
;
6223 /***********************************************************************
6225 ***********************************************************************/
6230 defsubr (&Sredraw_frame
);
6231 defsubr (&Sredraw_display
);
6232 defsubr (&Sframe_or_buffer_changed_p
);
6233 defsubr (&Sopen_termscript
);
6235 defsubr (&Ssit_for
);
6236 defsubr (&Ssleep_for
);
6237 defsubr (&Ssend_string_to_terminal
);
6238 defsubr (&Sinternal_show_cursor
);
6239 defsubr (&Sinternal_show_cursor_p
);
6241 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
6242 staticpro (&frame_and_buffer_state
);
6244 Qdisplay_table
= intern ("display-table");
6245 staticpro (&Qdisplay_table
);
6246 Qredisplay_dont_pause
= intern ("redisplay-dont-pause");
6247 staticpro (&Qredisplay_dont_pause
);
6249 DEFVAR_INT ("baud-rate", &baud_rate
,
6250 "*The output baud rate of the terminal.\n\
6251 On most systems, changing this value will affect the amount of padding\n\
6252 and the other strategic decisions made during redisplay.");
6254 DEFVAR_BOOL ("inverse-video", &inverse_video
,
6255 "*Non-nil means invert the entire frame display.\n\
6256 This means everything is in inverse video which otherwise would not be.");
6258 DEFVAR_BOOL ("visible-bell", &visible_bell
,
6259 "*Non-nil means try to flash the frame to represent a bell.");
6261 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
6262 "*Non-nil means no need to redraw entire frame after suspending.\n\
6263 A non-nil value is useful if the terminal can automatically preserve\n\
6264 Emacs's frame display when you reenter Emacs.\n\
6265 It is up to you to set this variable if your terminal can do that.");
6267 DEFVAR_LISP ("window-system", &Vwindow_system
,
6268 "A symbol naming the window-system under which Emacs is running\n\
6269 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
6271 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
6272 "The version number of the window system in use.\n\
6273 For X windows, this is 10 or 11.");
6275 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
6276 "Non-nil means put cursor in minibuffer, at end of any message there.");
6278 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
6279 "Table defining how to output a glyph code to the frame.\n\
6280 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
6281 Each element can be:\n\
6282 integer: a glyph code which this glyph is an alias for.\n\
6283 string: output this glyph using that string (not impl. in X windows).\n\
6284 nil: this glyph mod 256 is char code to output,\n\
6285 and this glyph / 256 is face code for X windows (see `face-id').");
6286 Vglyph_table
= Qnil
;
6288 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
6289 "Display table to use for buffers that specify none.\n\
6290 See `buffer-display-table' for more information.");
6291 Vstandard_display_table
= Qnil
;
6293 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause
,
6294 "*Non-nil means update isn't paused when input is detected.");
6295 redisplay_dont_pause
= 0;
6297 /* Initialize `window-system', unless init_display already decided it. */
6302 Vwindow_system
= Qnil
;
6303 Vwindow_system_version
= Qnil
;