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
);
3564 #if 0 /* This flush is a performance bottleneck under X,
3565 and it doesn't seem to be necessary anyway. */
3566 rif
->flush_display (f
);
3571 /* We are working on frame matrix basis. Set the frame on whose
3572 frame matrix we operate. */
3573 set_frame_matrix_frame (f
);
3575 /* Build F's desired matrix from window matrices. */
3576 build_frame_matrix (f
);
3578 /* Update the display */
3580 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3584 fflush (termscript
);
3587 /* Check window matrices for lost pointers. */
3588 IF_DEBUG (check_window_matrix_pointers (root_window
));
3591 /* Reset flags indicating that a window should be updated. */
3592 set_window_update_flags (root_window
, 0);
3594 display_completed
= !paused_p
;
3600 /************************************************************************
3601 Window-based updates
3602 ************************************************************************/
3604 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3605 don't stop updating when input is pending. */
3608 update_window_tree (w
, force_p
)
3614 while (w
&& !paused_p
)
3616 if (!NILP (w
->hchild
))
3617 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
3618 else if (!NILP (w
->vchild
))
3619 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
3620 else if (w
->must_be_updated_p
)
3621 paused_p
|= update_window (w
, force_p
);
3623 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3630 /* Update window W if its flag must_be_updated_p is non-zero. If
3631 FORCE_P is non-zero, don't stop updating if input is pending. */
3634 update_single_window (w
, force_p
)
3638 if (w
->must_be_updated_p
)
3640 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3642 /* Record that this is not a frame-based redisplay. */
3643 set_frame_matrix_frame (NULL
);
3647 update_window (w
, force_p
);
3650 /* Reset flag in W. */
3651 w
->must_be_updated_p
= 0;
3656 /* Redraw lines from the current matrix of window W that are
3657 overlapped by other rows. YB is bottom-most y-position in W. */
3660 redraw_overlapped_rows (w
, yb
)
3666 /* If rows overlapping others have been changed, the rows being
3667 overlapped have to be redrawn. This won't draw lines that have
3668 already been drawn in update_window_line because overlapped_p in
3669 desired rows is 0, so after row assignment overlapped_p in
3670 current rows is 0. */
3671 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3673 struct glyph_row
*row
= w
->current_matrix
->rows
+ i
;
3675 if (!row
->enabled_p
)
3677 else if (row
->mode_line_p
)
3680 if (row
->overlapped_p
)
3682 enum glyph_row_area area
;
3684 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3687 updated_area
= area
;
3688 rif
->cursor_to (i
, 0, row
->y
, area
== TEXT_AREA
? row
->x
: 0);
3689 if (row
->used
[area
])
3690 rif
->write_glyphs (row
->glyphs
[area
], row
->used
[area
]);
3691 rif
->clear_end_of_line (-1);
3694 row
->overlapped_p
= 0;
3697 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3703 /* Redraw lines from the current matrix of window W that overlap
3704 others. YB is bottom-most y-position in W. */
3707 redraw_overlapping_rows (w
, yb
)
3712 struct glyph_row
*row
;
3714 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3716 row
= w
->current_matrix
->rows
+ i
;
3718 if (!row
->enabled_p
)
3720 else if (row
->mode_line_p
)
3723 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3725 if (row
->overlapping_p
&& i
> 0 && bottom_y
< yb
)
3727 if (row
->used
[LEFT_MARGIN_AREA
])
3728 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
);
3730 if (row
->used
[TEXT_AREA
])
3731 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
);
3733 if (row
->used
[RIGHT_MARGIN_AREA
])
3734 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
);
3736 /* Record in neighbor rows that ROW overwrites part of their
3738 if (row
->phys_ascent
> row
->ascent
&& i
> 0)
3739 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3740 if ((row
->phys_height
- row
->phys_ascent
3741 > row
->height
- row
->ascent
)
3743 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
3752 /* Update display of window W. FORCE_P non-zero means that we should
3753 not stop when detecting pending input. */
3756 update_window (w
, force_p
)
3760 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
3762 int preempt_count
= baud_rate
/ 2400 + 1;
3763 extern int input_pending
;
3765 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3766 extern struct frame
*updating_frame
;
3769 /* Check that W's frame doesn't have glyph matrices. */
3770 xassert (FRAME_WINDOW_P (f
));
3771 xassert (updating_frame
!= NULL
);
3773 /* Check pending input the first time so that we can quickly return. */
3774 if (redisplay_dont_pause
)
3777 detect_input_pending ();
3779 /* If forced to complete the update, or if no input is pending, do
3781 if (force_p
|| !input_pending
)
3783 struct glyph_row
*row
, *end
;
3784 struct glyph_row
*mode_line_row
;
3785 struct glyph_row
*header_line_row
= NULL
;
3786 int yb
, changed_p
= 0, mouse_face_overwritten_p
= 0;
3788 rif
->update_window_begin_hook (w
);
3789 yb
= window_text_bottom_y (w
);
3791 /* If window has a top line, update it before everything else.
3792 Adjust y-positions of other rows by the top line height. */
3793 row
= desired_matrix
->rows
;
3794 end
= row
+ desired_matrix
->nrows
- 1;
3795 if (row
->mode_line_p
)
3796 header_line_row
= row
++;
3798 /* Update the mode line, if necessary. */
3799 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3800 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
3802 mode_line_row
->y
= yb
;
3803 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
3805 &mouse_face_overwritten_p
);
3809 /* Find first enabled row. Optimizations in redisplay_internal
3810 may lead to an update with only one row enabled. There may
3811 be also completely empty matrices. */
3812 while (row
< end
&& !row
->enabled_p
)
3815 /* Try reusing part of the display by copying. */
3816 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
3818 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
3821 /* All rows were found to be equal. */
3830 /* Update the top mode line after scrolling because a new top
3831 line would otherwise overwrite lines at the top of the window
3832 that can be scrolled. */
3833 if (header_line_row
&& header_line_row
->enabled_p
)
3835 header_line_row
->y
= 0;
3836 update_window_line (w
, 0, &mouse_face_overwritten_p
);
3840 /* Update the rest of the lines. */
3841 for (; row
< end
&& (force_p
|| !input_pending
); ++row
)
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 /* Set the row being updated. This is important to let xterm.c
4129 know what line height values are in effect. */
4130 updated_row
= desired_row
;
4132 /* A row can be completely invisible in case a desired matrix was
4133 built with a vscroll and then make_cursor_line_fully_visible shifts
4134 the matrix. Make sure to make such rows current anyway, since
4135 we need the correct y-position, for example, in the current matrix. */
4136 if (desired_row
->mode_line_p
4137 || desired_row
->visible_height
> 0)
4139 xassert (desired_row
->enabled_p
);
4141 /* Update display of the left margin area, if there is one. */
4142 if (!desired_row
->full_width_p
4143 && !NILP (w
->left_margin_width
))
4146 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
4149 /* Update the display of the text area. */
4150 if (update_text_area (w
, vpos
))
4153 if (current_row
->mouse_face_p
)
4154 *mouse_face_overwritten_p
= 1;
4157 /* Update display of the right margin area, if there is one. */
4158 if (!desired_row
->full_width_p
4159 && !NILP (w
->right_margin_width
))
4162 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
4165 /* Draw truncation marks etc. */
4166 if (!current_row
->enabled_p
4167 || desired_row
->y
!= current_row
->y
4168 || desired_row
->visible_height
!= current_row
->visible_height
4169 || desired_row
->overlay_arrow_p
!= current_row
->overlay_arrow_p
4170 || desired_row
->truncated_on_left_p
!= current_row
->truncated_on_left_p
4171 || desired_row
->truncated_on_right_p
!= current_row
->truncated_on_right_p
4172 || desired_row
->continued_p
!= current_row
->continued_p
4173 || desired_row
->mode_line_p
!= current_row
->mode_line_p
4174 || (desired_row
->indicate_empty_line_p
4175 != current_row
->indicate_empty_line_p
)
4176 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
4177 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
4178 rif
->after_update_window_line_hook (desired_row
);
4181 /* Update current_row from desired_row. */
4182 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4188 /* Set the cursor after an update of window W. This function may only
4189 be called from update_window. */
4192 set_window_cursor_after_update (w
)
4195 struct frame
*f
= XFRAME (w
->frame
);
4196 int cx
, cy
, vpos
, hpos
;
4198 /* Not intended for frame matrix updates. */
4199 xassert (FRAME_WINDOW_P (f
));
4201 if (cursor_in_echo_area
4202 && !NILP (echo_area_buffer
[0])
4203 /* If we are showing a message instead of the mini-buffer,
4204 show the cursor for the message instead. */
4205 && XWINDOW (minibuf_window
) == w
4206 && EQ (minibuf_window
, echo_area_window
)
4207 /* These cases apply only to the frame that contains
4208 the active mini-buffer window. */
4209 && FRAME_HAS_MINIBUF_P (f
)
4210 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4212 cx
= cy
= vpos
= hpos
= 0;
4214 if (cursor_in_echo_area
>= 0)
4216 /* If the mini-buffer is several lines high, find the last
4217 line that has any text on it. Note: either all lines
4218 are enabled or none. Otherwise we wouldn't be able to
4220 struct glyph_row
*row
, *last_row
;
4221 struct glyph
*glyph
;
4222 int yb
= window_text_bottom_y (w
);
4225 for (row
= MATRIX_ROW (w
->current_matrix
, 0);
4229 if (row
->used
[TEXT_AREA
]
4230 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4233 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4239 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
4240 struct glyph
*last
= start
+ row
->used
[TEXT_AREA
] - 1;
4242 while (last
> start
&& last
->charpos
< 0)
4245 for (glyph
= start
; glyph
< last
; ++glyph
)
4247 cx
+= glyph
->pixel_width
;
4252 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4260 hpos
= w
->cursor
.hpos
;
4261 vpos
= w
->cursor
.vpos
;
4264 /* Window cursor can be out of sync for horizontally split windows. */
4265 hpos
= max (0, hpos
);
4266 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4267 vpos
= max (0, vpos
);
4268 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4269 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4273 /* Set WINDOW->must_be_updated_p to ON_P for all windows in the window
4274 tree rooted at W. */
4277 set_window_update_flags (w
, on_p
)
4283 if (!NILP (w
->hchild
))
4284 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4285 else if (!NILP (w
->vchild
))
4286 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4288 w
->must_be_updated_p
= on_p
;
4290 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4296 /***********************************************************************
4297 Window-Based Scrolling
4298 ***********************************************************************/
4300 /* Structure describing rows in scrolling_window. */
4304 /* Number of occurrences of this row in desired and current matrix. */
4305 int old_uses
, new_uses
;
4307 /* Vpos of row in new matrix. */
4308 int new_line_number
;
4310 /* Bucket index of this row_entry in the hash table row_table. */
4313 /* The row described by this entry. */
4314 struct glyph_row
*row
;
4316 /* Hash collision chain. */
4317 struct row_entry
*next
;
4320 /* A pool to allocate row_entry structures from, and the size of the
4321 pool. The pool is reallocated in scrolling_window when we find
4322 that we need a larger one. */
4324 static struct row_entry
*row_entry_pool
;
4325 static int row_entry_pool_size
;
4327 /* Index of next free entry in row_entry_pool. */
4329 static int row_entry_idx
;
4331 /* The hash table used during scrolling, and the table's size. This
4332 table is used to quickly identify equal rows in the desired and
4335 static struct row_entry
**row_table
;
4336 static int row_table_size
;
4338 /* Vectors of pointers to row_entry structures belonging to the
4339 current and desired matrix, and the size of the vectors. */
4341 static struct row_entry
**old_lines
, **new_lines
;
4342 static int old_lines_size
, new_lines_size
;
4344 /* A pool to allocate run structures from, and its size. */
4346 static struct run
*run_pool
;
4347 static int runs_size
;
4349 /* A vector of runs of lines found during scrolling. */
4351 static struct run
**runs
;
4353 static struct row_entry
*add_row_entry
P_ ((struct window
*,
4354 struct glyph_row
*));
4357 /* Add glyph row ROW to the scrolling hash table during the scrolling
4360 static INLINE
struct row_entry
*
4361 add_row_entry (w
, row
)
4363 struct glyph_row
*row
;
4365 struct row_entry
*entry
;
4366 int i
= row
->hash
% row_table_size
;
4368 entry
= row_table
[i
];
4369 while (entry
&& !row_equal_p (w
, entry
->row
, row
, 1))
4370 entry
= entry
->next
;
4374 entry
= row_entry_pool
+ row_entry_idx
++;
4376 entry
->old_uses
= entry
->new_uses
= 0;
4377 entry
->new_line_number
= 0;
4379 entry
->next
= row_table
[i
];
4380 row_table
[i
] = entry
;
4387 /* Try to reuse part of the current display of W by scrolling lines.
4388 HEADER_LINE_P non-zero means W has a top mode line.
4390 The algorithm is taken from Communications of the ACM, Apr78 "A
4391 Technique for Isolating Differences Between Files." It should take
4394 A short outline of the steps of the algorithm
4396 1. Skip lines equal at the start and end of both matrices.
4398 2. Enter rows in the current and desired matrix into a symbol
4399 table, counting how often they appear in both matrices.
4401 3. Rows that appear exactly once in both matrices serve as anchors,
4402 i.e. we assume that such lines are likely to have been moved.
4404 4. Starting from anchor lines, extend regions to be scrolled both
4405 forward and backward.
4409 -1 if all rows were found to be equal.
4410 0 to indicate that we did not scroll the display, or
4411 1 if we did scroll. */
4414 scrolling_window (w
, header_line_p
)
4418 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4419 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4420 int yb
= window_text_bottom_y (w
);
4421 int i
, j
, first_old
, first_new
, last_old
, last_new
;
4422 int nruns
, nbytes
, n
, run_idx
;
4423 struct row_entry
*entry
;
4425 /* Skip over rows equal at the start. */
4426 for (i
= header_line_p
? 1 : 0; i
< current_matrix
->nrows
- 1; ++i
)
4428 struct glyph_row
*d
= MATRIX_ROW (desired_matrix
, i
);
4429 struct glyph_row
*c
= MATRIX_ROW (current_matrix
, i
);
4434 && MATRIX_ROW_BOTTOM_Y (c
) <= yb
4435 && MATRIX_ROW_BOTTOM_Y (d
) <= yb
4436 && row_equal_p (w
, c
, d
, 1))
4445 /* Give up if some rows in the desired matrix are not enabled. */
4446 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4449 first_old
= first_new
= i
;
4451 /* Set last_new to the index + 1 of the last enabled row in the
4454 while (i
< desired_matrix
->nrows
- 1
4455 && MATRIX_ROW (desired_matrix
, i
)->enabled_p
4456 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) <= yb
)
4459 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4464 /* Set last_old to the index + 1 of the last enabled row in the
4465 current matrix. We don't look at the enabled flag here because
4466 we plan to reuse part of the display even if other parts are
4469 while (i
< current_matrix
->nrows
- 1
4470 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) <= yb
)
4474 /* Skip over rows equal at the bottom. */
4477 while (i
- 1 > first_new
4478 && j
- 1 > first_old
4479 && MATRIX_ROW (current_matrix
, i
- 1)->enabled_p
4480 && (MATRIX_ROW (current_matrix
, i
- 1)->y
4481 == MATRIX_ROW (desired_matrix
, j
- 1)->y
)
4483 MATRIX_ROW (desired_matrix
, i
- 1),
4484 MATRIX_ROW (current_matrix
, j
- 1), 1))
4489 /* Nothing to do if all rows are equal. */
4490 if (last_new
== first_new
)
4493 /* Reallocate vectors, tables etc. if necessary. */
4495 if (current_matrix
->nrows
> old_lines_size
)
4497 old_lines_size
= current_matrix
->nrows
;
4498 nbytes
= old_lines_size
* sizeof *old_lines
;
4499 old_lines
= (struct row_entry
**) xrealloc (old_lines
, nbytes
);
4502 if (desired_matrix
->nrows
> new_lines_size
)
4504 new_lines_size
= desired_matrix
->nrows
;
4505 nbytes
= new_lines_size
* sizeof *new_lines
;
4506 new_lines
= (struct row_entry
**) xrealloc (new_lines
, nbytes
);
4509 n
= desired_matrix
->nrows
+ current_matrix
->nrows
;
4510 if (3 * n
> row_table_size
)
4512 row_table_size
= next_almost_prime (3 * n
);
4513 nbytes
= row_table_size
* sizeof *row_table
;
4514 row_table
= (struct row_entry
**) xrealloc (row_table
, nbytes
);
4515 bzero (row_table
, nbytes
);
4518 if (n
> row_entry_pool_size
)
4520 row_entry_pool_size
= n
;
4521 nbytes
= row_entry_pool_size
* sizeof *row_entry_pool
;
4522 row_entry_pool
= (struct row_entry
*) xrealloc (row_entry_pool
, nbytes
);
4525 if (desired_matrix
->nrows
> runs_size
)
4527 runs_size
= desired_matrix
->nrows
;
4528 nbytes
= runs_size
* sizeof *runs
;
4529 runs
= (struct run
**) xrealloc (runs
, nbytes
);
4530 nbytes
= runs_size
* sizeof *run_pool
;
4531 run_pool
= (struct run
*) xrealloc (run_pool
, nbytes
);
4534 nruns
= run_idx
= 0;
4537 /* Add rows from the current and desired matrix to the hash table
4538 row_hash_table to be able to find equal ones quickly. */
4540 for (i
= first_old
; i
< last_old
; ++i
)
4542 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4544 entry
= add_row_entry (w
, MATRIX_ROW (current_matrix
, i
));
4545 old_lines
[i
] = entry
;
4549 old_lines
[i
] = NULL
;
4552 for (i
= first_new
; i
< last_new
; ++i
)
4554 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4555 entry
= add_row_entry (w
, MATRIX_ROW (desired_matrix
, i
));
4557 entry
->new_line_number
= i
;
4558 new_lines
[i
] = entry
;
4561 /* Identify moves based on lines that are unique and equal
4562 in both matrices. */
4563 for (i
= first_old
; i
< last_old
;)
4565 && old_lines
[i
]->old_uses
== 1
4566 && old_lines
[i
]->new_uses
== 1)
4569 int new_line
= old_lines
[i
]->new_line_number
;
4570 struct run
*run
= run_pool
+ run_idx
++;
4573 run
->current_vpos
= i
;
4574 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4575 run
->desired_vpos
= new_line
;
4576 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4578 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4580 /* Extend backward. */
4583 while (j
> first_old
4585 && old_lines
[j
] == new_lines
[k
])
4587 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4588 --run
->current_vpos
;
4589 --run
->desired_vpos
;
4592 run
->desired_y
-= h
;
4593 run
->current_y
-= h
;
4597 /* Extend forward. */
4602 && old_lines
[j
] == new_lines
[k
])
4604 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4610 /* Insert run into list of all runs. Order runs by copied
4611 pixel lines. Note that we record runs that don't have to
4612 be copied because they are already in place. This is done
4613 because we can avoid calling update_window_line in this
4615 for (j
= 0; j
< nruns
&& runs
[j
]->height
> run
->height
; ++j
)
4617 for (k
= nruns
; k
>= j
; --k
)
4618 runs
[k
] = runs
[k
- 1];
4627 /* Do the moves. Do it in a way that we don't overwrite something
4628 we want to copy later on. This is not solvable in general
4629 because there is only one display and we don't have a way to
4630 exchange areas on this display. Example:
4632 +-----------+ +-----------+
4634 +-----------+ --> +-----------+
4636 +-----------+ +-----------+
4638 Instead, prefer bigger moves, and invalidate moves that would
4639 copy from where we copied to. */
4641 for (i
= 0; i
< nruns
; ++i
)
4642 if (runs
[i
]->nrows
> 0)
4644 struct run
*r
= runs
[i
];
4646 /* Copy on the display. */
4647 if (r
->current_y
!= r
->desired_y
)
4649 rif
->scroll_run_hook (w
, r
);
4651 /* Invalidate runs that copy from where we copied to. */
4652 for (j
= i
+ 1; j
< nruns
; ++j
)
4654 struct run
*p
= runs
[j
];
4656 if ((p
->current_y
>= r
->desired_y
4657 && p
->current_y
< r
->desired_y
+ r
->height
)
4658 || (p
->current_y
+ p
->height
>= r
->desired_y
4659 && (p
->current_y
+ p
->height
4660 < r
->desired_y
+ r
->height
)))
4665 /* Assign matrix rows. */
4666 for (j
= 0; j
< r
->nrows
; ++j
)
4668 struct glyph_row
*from
, *to
;
4669 int to_overlapped_p
;
4671 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
4672 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
4673 to_overlapped_p
= to
->overlapped_p
;
4674 assign_row (to
, from
);
4675 to
->enabled_p
= 1, from
->enabled_p
= 0;
4676 to
->overlapped_p
= to_overlapped_p
;
4680 /* Clear the hash table, for the next time. */
4681 for (i
= 0; i
< row_entry_idx
; ++i
)
4682 row_table
[row_entry_pool
[i
].bucket
] = NULL
;
4684 /* Value is non-zero to indicate that we scrolled the display. */
4690 /************************************************************************
4692 ************************************************************************/
4694 /* Update the desired frame matrix of frame F.
4696 FORCE_P non-zero means that the update should not be stopped by
4697 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
4698 should not be tried.
4700 Value is non-zero if update was stopped due to pending input. */
4703 update_frame_1 (f
, force_p
, inhibit_id_p
)
4708 /* Frame matrices to work on. */
4709 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4710 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4713 int preempt_count
= baud_rate
/ 2400 + 1;
4714 extern int input_pending
;
4716 xassert (current_matrix
&& desired_matrix
);
4718 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
4719 calculate_costs (f
);
4721 if (preempt_count
<= 0)
4724 if (redisplay_dont_pause
)
4726 else if (!force_p
&& detect_input_pending ())
4732 /* If we cannot insert/delete lines, it's no use trying it. */
4733 if (!line_ins_del_ok
)
4736 /* See if any of the desired lines are enabled; don't compute for
4737 i/d line if just want cursor motion. */
4738 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
4739 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4742 /* Try doing i/d line, if not yet inhibited. */
4743 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
4744 force_p
|= scrolling (f
);
4746 /* Update the individual lines as needed. Do bottom line first. */
4747 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
4748 update_frame_line (f
, desired_matrix
->nrows
- 1);
4750 /* Now update the rest of the lines. */
4751 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
4753 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4755 if (FRAME_TERMCAP_P (f
))
4757 /* Flush out every so many lines.
4758 Also flush out if likely to have more than 1k buffered
4759 otherwise. I'm told that some telnet connections get
4760 really screwed by more than 1k output at once. */
4761 int outq
= PENDING_OUTPUT_COUNT (stdout
);
4763 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
4766 if (preempt_count
== 1)
4768 #ifdef EMACS_OUTQSIZE
4769 if (EMACS_OUTQSIZE (0, &outq
) < 0)
4770 /* Probably not a tty. Ignore the error and reset
4771 * the outq count. */
4772 outq
= PENDING_OUTPUT_COUNT (stdout
);
4775 if (baud_rate
<= outq
&& baud_rate
> 0)
4776 sleep (outq
/ baud_rate
);
4781 if ((i
- 1) % preempt_count
== 0)
4782 detect_input_pending ();
4784 update_frame_line (f
, i
);
4788 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
4790 /* Now just clean up termcap drivers and set cursor, etc. */
4793 if ((cursor_in_echo_area
4794 /* If we are showing a message instead of the mini-buffer,
4795 show the cursor for the message instead of for the
4796 (now hidden) mini-buffer contents. */
4797 || (EQ (minibuf_window
, selected_window
)
4798 && EQ (minibuf_window
, echo_area_window
)
4799 && !NILP (echo_area_buffer
[0])))
4800 /* These cases apply only to the frame that contains
4801 the active mini-buffer window. */
4802 && FRAME_HAS_MINIBUF_P (f
)
4803 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4805 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
4808 if (cursor_in_echo_area
< 0)
4810 /* Negative value of cursor_in_echo_area means put
4811 cursor at beginning of line. */
4817 /* Positive value of cursor_in_echo_area means put
4818 cursor at the end of the prompt. If the mini-buffer
4819 is several lines high, find the last line that has
4821 row
= FRAME_HEIGHT (f
);
4827 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
4829 /* Frame rows are filled up with spaces that
4830 must be ignored here. */
4831 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
4833 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
4834 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
4837 && (last
- 1)->charpos
< 0)
4843 while (row
> top
&& col
== 0);
4845 /* Make sure COL is not out of range. */
4846 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
4848 /* If we have another row, advance cursor into it. */
4849 if (row
< FRAME_HEIGHT (f
) - 1)
4851 col
= FRAME_LEFT_SCROLL_BAR_WIDTH (f
);
4854 /* Otherwise move it back in range. */
4856 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
4860 cursor_to (row
, col
);
4864 /* We have only one cursor on terminal frames. Use it to
4865 display the cursor of the selected window. */
4866 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
4867 if (w
->cursor
.vpos
>= 0
4868 /* The cursor vpos may be temporarily out of bounds
4869 in the following situation: There is one window,
4870 with the cursor in the lower half of it. The window
4871 is split, and a message causes a redisplay before
4872 a new cursor position has been computed. */
4873 && w
->cursor
.vpos
< XFASTINT (w
->height
))
4875 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
4876 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
4878 if (INTEGERP (w
->left_margin_width
))
4879 x
+= XFASTINT (w
->left_margin_width
);
4881 /* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
4889 clear_desired_matrices (f
);
4894 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4898 struct frame
*frame
;
4900 int unchanged_at_top
, unchanged_at_bottom
;
4903 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4904 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4905 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4906 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4908 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
4909 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4910 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4912 if (!current_matrix
)
4915 /* Compute hash codes of all the lines. Also calculate number of
4916 changed lines, number of unchanged lines at the beginning, and
4917 number of unchanged lines at the end. */
4919 unchanged_at_top
= 0;
4920 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
4921 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
4923 /* Give up on this scrolling if some old lines are not enabled. */
4924 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
4926 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
4927 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4929 /* This line cannot be redrawn, so don't let scrolling mess it. */
4930 new_hash
[i
] = old_hash
[i
];
4931 #define INFINITY 1000000 /* Taken from scroll.c */
4932 draw_cost
[i
] = INFINITY
;
4936 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
4937 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
4940 if (old_hash
[i
] != new_hash
[i
])
4943 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
4945 else if (i
== unchanged_at_top
)
4947 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
4950 /* If changed lines are few, don't allow preemption, don't scroll. */
4951 if ((!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400)
4952 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
4955 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
4956 - unchanged_at_bottom
);
4958 if (scroll_region_ok
)
4959 free_at_end_vpos
-= unchanged_at_bottom
;
4960 else if (memory_below_frame
)
4961 free_at_end_vpos
= -1;
4963 /* If large window, fast terminal and few lines in common between
4964 current frame and desired frame, don't bother with i/d calc. */
4965 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
4967 10 * scrolling_max_lines_saved (unchanged_at_top
,
4968 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
4969 old_hash
, new_hash
, draw_cost
)))
4972 if (window_size
< 2)
4975 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
4976 draw_cost
+ unchanged_at_top
- 1,
4977 old_draw_cost
+ unchanged_at_top
- 1,
4978 old_hash
+ unchanged_at_top
- 1,
4979 new_hash
+ unchanged_at_top
- 1,
4980 free_at_end_vpos
- unchanged_at_top
);
4986 /* Count the number of blanks at the start of the vector of glyphs R
4987 which is LEN glyphs long. */
4990 count_blanks (r
, len
)
4996 for (i
= 0; i
< len
; ++i
)
4997 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
5004 /* Count the number of glyphs in common at the start of the glyph
5005 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
5006 of STR2. Value is the number of equal glyphs equal at the start. */
5009 count_match (str1
, end1
, str2
, end2
)
5010 struct glyph
*str1
, *end1
, *str2
, *end2
;
5012 struct glyph
*p1
= str1
;
5013 struct glyph
*p2
= str2
;
5017 && GLYPH_CHAR_AND_FACE_EQUAL_P (p1
, p2
))
5024 /* Char insertion/deletion cost vector, from term.c */
5026 extern int *char_ins_del_vector
;
5027 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
5030 /* Perform a frame-based update on line VPOS in frame FRAME. */
5033 update_frame_line (frame
, vpos
)
5034 register struct frame
*frame
;
5037 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
5039 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
5040 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
5041 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
5042 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
5043 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
5044 int must_write_whole_line_p
;
5046 if (desired_row
->inverse_p
5047 != (current_row
->enabled_p
&& current_row
->inverse_p
))
5049 int n
= current_row
->enabled_p
? current_row
->used
[TEXT_AREA
] : 0;
5050 change_line_highlight (desired_row
->inverse_p
, vpos
, vpos
, n
);
5051 current_row
->enabled_p
= 0;
5054 reassert_line_highlight (desired_row
->inverse_p
, vpos
);
5056 /* Current row not enabled means it has unknown contents. We must
5057 write the whole desired line in that case. */
5058 must_write_whole_line_p
= !current_row
->enabled_p
;
5059 if (must_write_whole_line_p
)
5066 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
5067 olen
= current_row
->used
[TEXT_AREA
];
5069 if (! current_row
->inverse_p
)
5071 /* Ignore trailing spaces, if we can. */
5072 if (!must_write_spaces
)
5073 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
5078 /* For an inverse-video line, make sure it's filled with
5079 spaces all the way to the frame edge so that the reverse
5080 video extends all the way across. */
5081 while (olen
< FRAME_WIDTH (frame
) - 1)
5082 obody
[olen
++] = space_glyph
;
5086 current_row
->enabled_p
= 1;
5087 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
5088 current_row
->inverse_p
= desired_row
->inverse_p
;
5090 /* If desired line is empty, just clear the line. */
5091 if (!desired_row
->enabled_p
)
5097 nbody
= desired_row
->glyphs
[TEXT_AREA
];
5098 nlen
= desired_row
->used
[TEXT_AREA
];
5099 nend
= nbody
+ nlen
;
5101 /* If display line has unknown contents, write the whole line. */
5102 if (must_write_whole_line_p
)
5104 /* Ignore spaces at the end, if we can. */
5105 if (!must_write_spaces
)
5106 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5109 /* Write the contents of the desired line. */
5112 cursor_to (vpos
, 0);
5113 write_glyphs (nbody
, nlen
);
5116 /* Don't call clear_end_of_line if we already wrote the whole
5117 line. The cursor will not be at the right margin in that
5118 case but in the line below. */
5119 if (nlen
< FRAME_WINDOW_WIDTH (frame
))
5121 cursor_to (vpos
, nlen
);
5122 clear_end_of_line (FRAME_WINDOW_WIDTH (frame
));
5125 /* Make sure we are in the right row, otherwise cursor movement
5126 with cmgoto might use `ch' in the wrong row. */
5127 cursor_to (vpos
, 0);
5129 make_current (desired_matrix
, current_matrix
, vpos
);
5133 /* Pretend trailing spaces are not there at all,
5134 unless for one reason or another we must write all spaces. */
5135 if (!desired_row
->inverse_p
)
5137 if (!must_write_spaces
)
5138 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5143 /* For an inverse-video line, give it extra trailing spaces all
5144 the way to the frame edge so that the reverse video extends
5145 all the way across. */
5146 while (nlen
< FRAME_WIDTH (frame
) - 1)
5147 nbody
[nlen
++] = space_glyph
;
5150 /* If there's no i/d char, quickly do the best we can without it. */
5151 if (!char_ins_del_ok
)
5155 /* Find the first glyph in desired row that doesn't agree with
5156 a glyph in the current row, and write the rest from there on. */
5157 for (i
= 0; i
< nlen
; i
++)
5159 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
5161 /* Find the end of the run of different glyphs. */
5165 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
5166 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
5169 /* Output this run of non-matching chars. */
5170 cursor_to (vpos
, i
);
5171 write_glyphs (nbody
+ i
, j
- i
);
5174 /* Now find the next non-match. */
5178 /* Clear the rest of the line, or the non-clear part of it. */
5181 cursor_to (vpos
, nlen
);
5182 clear_end_of_line (olen
);
5185 /* Make current row = desired row. */
5186 make_current (desired_matrix
, current_matrix
, vpos
);
5190 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
5191 characters in a row. */
5195 /* If current line is blank, skip over initial spaces, if
5196 possible, and write the rest. */
5197 if (must_write_spaces
|| desired_row
->inverse_p
)
5200 nsp
= count_blanks (nbody
, nlen
);
5204 cursor_to (vpos
, nsp
);
5205 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
5208 /* Exchange contents between current_frame and new_frame. */
5209 make_current (desired_matrix
, current_matrix
, vpos
);
5213 /* Compute number of leading blanks in old and new contents. */
5214 osp
= count_blanks (obody
, olen
);
5215 nsp
= desired_row
->inverse_p
? 0 : count_blanks (nbody
, nlen
);
5217 /* Compute number of matching chars starting with first non-blank. */
5218 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
5219 nbody
+ nsp
, nbody
+ nlen
);
5221 /* Spaces in new match implicit space past the end of old. */
5222 /* A bug causing this to be a no-op was fixed in 18.29. */
5223 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
5226 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
5230 /* Avoid doing insert/delete char
5231 just cause number of leading spaces differs
5232 when the following text does not match. */
5233 if (begmatch
== 0 && osp
!= nsp
)
5234 osp
= nsp
= min (osp
, nsp
);
5236 /* Find matching characters at end of line */
5239 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
5241 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
5246 endmatch
= obody
+ olen
- op1
;
5248 /* tem gets the distance to insert or delete.
5249 endmatch is how many characters we save by doing so.
5252 tem
= (nlen
- nsp
) - (olen
- osp
);
5254 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
5257 /* nsp - osp is the distance to insert or delete.
5258 If that is nonzero, begmatch is known to be nonzero also.
5259 begmatch + endmatch is how much we save by doing the ins/del.
5263 && (!char_ins_del_ok
5264 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
5268 osp
= nsp
= min (osp
, nsp
);
5271 /* Now go through the line, inserting, writing and
5272 deleting as appropriate. */
5276 cursor_to (vpos
, nsp
);
5277 delete_glyphs (osp
- nsp
);
5281 /* If going to delete chars later in line
5282 and insert earlier in the line,
5283 must delete first to avoid losing data in the insert */
5284 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
5286 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
5287 delete_glyphs (olen
+ nsp
- osp
- nlen
);
5288 olen
= nlen
- (nsp
- osp
);
5290 cursor_to (vpos
, osp
);
5291 insert_glyphs (0, nsp
- osp
);
5295 tem
= nsp
+ begmatch
+ endmatch
;
5296 if (nlen
!= tem
|| olen
!= tem
)
5298 cursor_to (vpos
, nsp
+ begmatch
);
5299 if (!endmatch
|| nlen
== olen
)
5301 /* If new text being written reaches right margin,
5302 there is no need to do clear-to-eol at the end.
5303 (and it would not be safe, since cursor is not
5304 going to be "at the margin" after the text is done) */
5305 if (nlen
== FRAME_WINDOW_WIDTH (frame
))
5307 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5309 else if (nlen
> olen
)
5311 /* Here, we used to have the following simple code:
5312 ----------------------------------------
5313 write_glyphs (nbody + nsp + begmatch, olen - tem);
5314 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5315 ----------------------------------------
5316 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5317 is a padding glyph. */
5318 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5321 /* Calculate columns we can actually overwrite. */
5322 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
])) out
--;
5323 write_glyphs (nbody
+ nsp
+ begmatch
, out
);
5324 /* If we left columns to be overwritten, we must delete them. */
5325 del
= olen
- tem
- out
;
5326 if (del
> 0) delete_glyphs (del
);
5327 /* At last, we insert columns not yet written out. */
5328 insert_glyphs (nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5331 else if (olen
> nlen
)
5333 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5334 delete_glyphs (olen
- nlen
);
5340 /* If any unerased characters remain after the new line, erase them. */
5343 cursor_to (vpos
, nlen
);
5344 clear_end_of_line (olen
);
5347 /* Exchange contents between current_frame and new_frame. */
5348 make_current (desired_matrix
, current_matrix
, vpos
);
5353 /***********************************************************************
5354 X/Y Position -> Buffer Position
5355 ***********************************************************************/
5357 /* Return the character position of the character at window relative
5358 pixel position (*X, *Y). *X and *Y are adjusted to character
5362 buffer_posn_from_coords (w
, x
, y
)
5367 struct buffer
*old_current_buffer
= current_buffer
;
5368 struct text_pos startp
;
5369 int left_area_width
;
5371 current_buffer
= XBUFFER (w
->buffer
);
5372 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5373 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5374 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5375 start_display (&it
, w
, startp
);
5377 left_area_width
= WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH (w
);
5378 move_it_to (&it
, -1, *x
+ it
.first_visible_x
- left_area_width
, *y
, -1,
5379 MOVE_TO_X
| MOVE_TO_Y
);
5381 *x
= it
.current_x
- it
.first_visible_x
+ left_area_width
;
5383 current_buffer
= old_current_buffer
;
5384 return IT_CHARPOS (it
);
5388 /* Value is the string under window-relative coordinates X/Y in the
5389 mode or top line of window W, or nil if none. MODE_LINE_P non-zero
5390 means look at the mode line. *CHARPOS is set to the position in
5391 the string returned. */
5394 mode_line_string (w
, x
, y
, mode_line_p
, charpos
)
5396 int x
, y
, mode_line_p
;
5399 struct glyph_row
*row
;
5400 struct glyph
*glyph
, *end
;
5401 struct frame
*f
= XFRAME (w
->frame
);
5403 Lisp_Object string
= Qnil
;
5406 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5408 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
5410 if (row
->mode_line_p
&& row
->enabled_p
)
5412 /* The mode lines are displayed over scroll bars and bitmap
5413 areas, and X is window-relative. Correct X by the scroll bar
5414 and bitmap area width. */
5415 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
5416 x
+= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
5417 x
+= FRAME_LEFT_FLAGS_AREA_WIDTH (f
);
5419 /* Find the glyph under X. If we find one with a string object,
5420 it's the one we were looking for. */
5421 glyph
= row
->glyphs
[TEXT_AREA
];
5422 end
= glyph
+ row
->used
[TEXT_AREA
];
5423 for (x0
= 0; glyph
< end
; x0
+= glyph
->pixel_width
, ++glyph
)
5424 if (x
>= x0
&& x
< x0
+ glyph
->pixel_width
)
5426 string
= glyph
->object
;
5427 *charpos
= glyph
->charpos
;
5436 /***********************************************************************
5437 Changing Frame Sizes
5438 ***********************************************************************/
5443 window_change_signal (signalnum
) /* If we don't have an argument, */
5444 int signalnum
; /* some compilers complain in signal calls. */
5450 int old_errno
= errno
;
5452 get_frame_size (&width
, &height
);
5454 /* The frame size change obviously applies to a termcap-controlled
5455 frame. Find such a frame in the list, and assume it's the only
5456 one (since the redisplay code always writes to stdout, not a
5457 FILE * specified in the frame structure). Record the new size,
5458 but don't reallocate the data structures now. Let that be done
5459 later outside of the signal handler. */
5462 Lisp_Object tail
, frame
;
5464 FOR_EACH_FRAME (tail
, frame
)
5466 if (FRAME_TERMCAP_P (XFRAME (frame
)))
5468 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5474 signal (SIGWINCH
, window_change_signal
);
5477 #endif /* SIGWINCH */
5480 /* Do any change in frame size that was requested by a signal. SAFE
5481 non-zero means this function is called from a place where it is
5482 safe to change frame sizes while a redisplay is in progress. */
5485 do_pending_window_change (safe
)
5488 /* If window_change_signal should have run before, run it now. */
5489 if (redisplaying_p
&& !safe
)
5492 while (delayed_size_change
)
5494 Lisp_Object tail
, frame
;
5496 delayed_size_change
= 0;
5498 FOR_EACH_FRAME (tail
, frame
)
5500 struct frame
*f
= XFRAME (frame
);
5502 int height
= FRAME_NEW_HEIGHT (f
);
5503 int width
= FRAME_NEW_WIDTH (f
);
5505 if (height
!= 0 || width
!= 0)
5506 change_frame_size (f
, height
, width
, 0, 0, safe
);
5512 /* Change the frame height and/or width. Values may be given as zero to
5513 indicate no change is to take place.
5515 If DELAY is non-zero, then assume we're being called from a signal
5516 handler, and queue the change for later - perhaps the next
5517 redisplay. Since this tries to resize windows, we can't call it
5518 from a signal handler.
5520 SAFE non-zero means this function is called from a place where it's
5521 safe to change frame sizes while a redisplay is in progress. */
5524 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5525 register struct frame
*f
;
5526 int newheight
, newwidth
, pretend
, delay
, safe
;
5528 Lisp_Object tail
, frame
;
5530 if (! FRAME_WINDOW_P (f
))
5532 /* When using termcap, or on MS-DOS, all frames use
5533 the same screen, so a change in size affects all frames. */
5534 FOR_EACH_FRAME (tail
, frame
)
5535 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5536 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5537 pretend
, delay
, safe
);
5540 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
5544 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5545 register struct frame
*f
;
5546 int newheight
, newwidth
, pretend
, delay
, safe
;
5548 int new_frame_window_width
;
5549 int count
= specpdl_ptr
- specpdl
;
5551 /* If we can't deal with the change now, queue it for later. */
5552 if (delay
|| (redisplaying_p
&& !safe
))
5554 FRAME_NEW_HEIGHT (f
) = newheight
;
5555 FRAME_NEW_WIDTH (f
) = newwidth
;
5556 delayed_size_change
= 1;
5560 /* This size-change overrides any pending one for this frame. */
5561 FRAME_NEW_HEIGHT (f
) = 0;
5562 FRAME_NEW_WIDTH (f
) = 0;
5564 /* If an argument is zero, set it to the current value. */
5566 newheight
= FRAME_HEIGHT (f
);
5568 newwidth
= FRAME_WIDTH (f
);
5570 /* Compute width of windows in F.
5571 This is the width of the frame without vertical scroll bars. */
5572 new_frame_window_width
= FRAME_WINDOW_WIDTH_ARG (f
, newwidth
);
5574 /* Round up to the smallest acceptable size. */
5575 check_frame_size (f
, &newheight
, &newwidth
);
5577 /* If we're not changing the frame size, quit now. */
5578 if (newheight
== FRAME_HEIGHT (f
)
5579 && new_frame_window_width
== FRAME_WINDOW_WIDTH (f
))
5585 /* We only can set screen dimensions to certain values supported
5586 by our video hardware. Try to find the smallest size greater
5587 or equal to the requested dimensions. */
5588 dos_set_window_size (&newheight
, &newwidth
);
5591 if (newheight
!= FRAME_HEIGHT (f
))
5593 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
5595 /* Frame has both root and mini-buffer. */
5596 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f
))->top
,
5597 FRAME_TOP_MARGIN (f
));
5598 set_window_height (FRAME_ROOT_WINDOW (f
),
5601 - FRAME_TOP_MARGIN (f
)),
5603 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
,
5605 set_window_height (FRAME_MINIBUF_WINDOW (f
), 1, 0);
5608 /* Frame has just one top-level window. */
5609 set_window_height (FRAME_ROOT_WINDOW (f
),
5610 newheight
- FRAME_TOP_MARGIN (f
), 0);
5612 if (FRAME_TERMCAP_P (f
) && !pretend
)
5613 FrameRows
= newheight
;
5616 if (new_frame_window_width
!= FRAME_WINDOW_WIDTH (f
))
5618 set_window_width (FRAME_ROOT_WINDOW (f
), new_frame_window_width
, 0);
5619 if (FRAME_HAS_MINIBUF_P (f
))
5620 set_window_width (FRAME_MINIBUF_WINDOW (f
), new_frame_window_width
, 0);
5622 if (FRAME_TERMCAP_P (f
) && !pretend
)
5623 FrameCols
= newwidth
;
5625 if (WINDOWP (f
->tool_bar_window
))
5626 XSETFASTINT (XWINDOW (f
->tool_bar_window
)->width
, newwidth
);
5629 FRAME_HEIGHT (f
) = newheight
;
5630 SET_FRAME_WIDTH (f
, newwidth
);
5633 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5634 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
5636 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
5638 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
5639 w
->cursor
.hpos
= w
->cursor
.x
= 0;
5640 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
5641 w
->cursor
.vpos
= w
->cursor
.y
= 0;
5645 SET_FRAME_GARBAGED (f
);
5646 calculate_costs (f
);
5650 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
5652 /* This isn't quite a no-op: it runs window-configuration-change-hook. */
5653 Fset_window_buffer (FRAME_SELECTED_WINDOW (f
),
5654 XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
);
5656 unbind_to (count
, Qnil
);
5661 /***********************************************************************
5662 Terminal Related Lisp Functions
5663 ***********************************************************************/
5665 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
5666 1, 1, "FOpen termscript file: ",
5667 "Start writing all terminal output to FILE as well as the terminal.\n\
5668 FILE = nil means just close any termscript file currently open.")
5672 if (termscript
!= 0) fclose (termscript
);
5677 file
= Fexpand_file_name (file
, Qnil
);
5678 termscript
= fopen (XSTRING (file
)->data
, "w");
5679 if (termscript
== 0)
5680 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
5686 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
5687 Ssend_string_to_terminal
, 1, 1, 0,
5688 "Send STRING to the terminal without alteration.\n\
5689 Control characters in STRING will have terminal-dependent effects.")
5693 /* ??? Perhaps we should do something special for multibyte strings here. */
5694 CHECK_STRING (string
, 0);
5695 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)), stdout
);
5699 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)),
5701 fflush (termscript
);
5707 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
5708 "Beep, or flash the screen.\n\
5709 Also, unless an argument is given,\n\
5710 terminate any keyboard macro currently executing.")
5733 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
5734 error ("Keyboard macro terminated by a command ringing the bell");
5742 /***********************************************************************
5744 ***********************************************************************/
5746 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
5747 "Pause, without updating display, for SECONDS seconds.\n\
5748 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5749 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5750 additional wait period, in milliseconds; this may be useful if your\n\
5751 Emacs was built without floating point support.\n\
5752 \(Not all operating systems support waiting for a fraction of a second.)")
5753 (seconds
, milliseconds
)
5754 Lisp_Object seconds
, milliseconds
;
5758 if (NILP (milliseconds
))
5759 XSETINT (milliseconds
, 0);
5761 CHECK_NUMBER (milliseconds
, 1);
5762 usec
= XINT (milliseconds
) * 1000;
5765 double duration
= extract_float (seconds
);
5766 sec
= (int) duration
;
5767 usec
+= (duration
- sec
) * 1000000;
5770 #ifndef EMACS_HAS_USECS
5771 if (sec
== 0 && usec
!= 0)
5772 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
5775 /* Assure that 0 <= usec < 1000000. */
5778 /* We can't rely on the rounding being correct if user is negative. */
5779 if (-1000000 < usec
)
5780 sec
--, usec
+= 1000000;
5782 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
5785 sec
+= usec
/ 1000000, usec
%= 1000000;
5787 if (sec
< 0 || (sec
== 0 && usec
== 0))
5793 XSETFASTINT (zero
, 0);
5794 wait_reading_process_input (sec
, usec
, zero
, 0);
5797 /* We should always have wait_reading_process_input; we have a dummy
5798 implementation for systems which don't support subprocesses. */
5800 /* No wait_reading_process_input */
5807 /* The reason this is done this way
5808 (rather than defined (H_S) && defined (H_T))
5809 is because the VMS preprocessor doesn't grok `defined' */
5811 EMACS_GET_TIME (end_time
);
5812 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
5813 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
5817 EMACS_GET_TIME (timeout
);
5818 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
5819 if (EMACS_TIME_NEG_P (timeout
)
5820 || !select (1, 0, 0, 0, &timeout
))
5823 #else /* not HAVE_SELECT */
5825 #endif /* HAVE_SELECT */
5826 #endif /* not VMS */
5829 #endif /* no subprocesses */
5835 /* This is just like wait_reading_process_input, except that
5836 it does the redisplay.
5838 It's also much like Fsit_for, except that it can be used for
5839 waiting for input as well. */
5842 sit_for (sec
, usec
, reading
, display
, initial_display
)
5843 int sec
, usec
, reading
, display
, initial_display
;
5845 Lisp_Object read_kbd
;
5847 swallow_events (display
);
5849 if (detect_input_pending_run_timers (display
))
5852 if (initial_display
)
5853 redisplay_preserve_echo_area ();
5855 if (sec
== 0 && usec
== 0)
5862 XSETINT (read_kbd
, reading
? -1 : 1);
5863 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
5865 return detect_input_pending () ? Qnil
: Qt
;
5869 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
5870 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
5871 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5872 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5873 additional wait period, in milliseconds; this may be useful if your\n\
5874 Emacs was built without floating point support.\n\
5875 \(Not all operating systems support waiting for a fraction of a second.)\n\
5876 Optional third arg NODISP non-nil means don't redisplay, just wait for input.\n\
5877 Redisplay is preempted as always if input arrives, and does not happen\n\
5878 if input is available before it starts.\n\
5879 Value is t if waited the full time with no input arriving.")
5880 (seconds
, milliseconds
, nodisp
)
5881 Lisp_Object seconds
, milliseconds
, nodisp
;
5885 if (NILP (milliseconds
))
5886 XSETINT (milliseconds
, 0);
5888 CHECK_NUMBER (milliseconds
, 1);
5889 usec
= XINT (milliseconds
) * 1000;
5892 double duration
= extract_float (seconds
);
5893 sec
= (int) duration
;
5894 usec
+= (duration
- sec
) * 1000000;
5897 #ifndef EMACS_HAS_USECS
5898 if (usec
!= 0 && sec
== 0)
5899 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
5902 return sit_for (sec
, usec
, 0, NILP (nodisp
), NILP (nodisp
));
5907 /***********************************************************************
5908 Other Lisp Functions
5909 ***********************************************************************/
5911 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
5912 session's frames, frame names, buffers, buffer-read-only flags, and
5913 buffer-modified-flags, and a trailing sentinel (so we don't need to
5914 add length checks). */
5916 static Lisp_Object frame_and_buffer_state
;
5919 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
5920 Sframe_or_buffer_changed_p
, 0, 0, 0,
5921 "Return non-nil if the frame and buffer state appears to have changed.\n\
5922 The state variable is an internal vector containing all frames and buffers,\n\
5923 aside from buffers whose names start with space,\n\
5924 along with the buffers' read-only and modified flags, which allows a fast\n\
5925 check to see whether the menu bars might need to be recomputed.\n\
5926 If this function returns non-nil, it updates the internal vector to reflect\n\
5927 the current state.\n")
5930 Lisp_Object tail
, frame
, buf
;
5934 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5935 FOR_EACH_FRAME (tail
, frame
)
5937 if (!EQ (*vecp
++, frame
))
5939 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
5942 /* Check that the buffer info matches.
5943 No need to test for the end of the vector
5944 because the last element of the vector is lambda
5945 and that will always cause a mismatch. */
5946 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5948 buf
= XCDR (XCAR (tail
));
5949 /* Ignore buffers that aren't included in buffer lists. */
5950 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5952 if (!EQ (*vecp
++, buf
))
5954 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
5956 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
5959 /* Detect deletion of a buffer at the end of the list. */
5960 if (EQ (*vecp
, Qlambda
))
5963 /* Start with 1 so there is room for at least one lambda at the end. */
5965 FOR_EACH_FRAME (tail
, frame
)
5967 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5969 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
5970 if (n
> XVECTOR (frame_and_buffer_state
)->size
5971 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
5972 /* Add 20 extra so we grow it less often. */
5973 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
5974 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5975 FOR_EACH_FRAME (tail
, frame
)
5978 *vecp
++ = XFRAME (frame
)->name
;
5980 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5982 buf
= XCDR (XCAR (tail
));
5983 /* Ignore buffers that aren't included in buffer lists. */
5984 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5987 *vecp
++ = XBUFFER (buf
)->read_only
;
5988 *vecp
++ = Fbuffer_modified_p (buf
);
5990 /* Fill up the vector with lambdas (always at least one). */
5992 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5993 < XVECTOR (frame_and_buffer_state
)->size
)
5995 /* Make sure we didn't overflow the vector. */
5996 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5997 > XVECTOR (frame_and_buffer_state
)->size
)
6004 /***********************************************************************
6006 ***********************************************************************/
6008 char *terminal_type
;
6010 /* Initialization done when Emacs fork is started, before doing stty.
6011 Determine terminal type and set terminal_driver. Then invoke its
6012 decoding routine to set up variables in the terminal package. */
6017 #ifdef HAVE_X_WINDOWS
6018 extern int display_arg
;
6021 /* Construct the space glyph. */
6022 space_glyph
.type
= CHAR_GLYPH
;
6023 SET_CHAR_GLYPH_FROM_GLYPH (space_glyph
, ' ');
6024 space_glyph
.charpos
= -1;
6028 cursor_in_echo_area
= 0;
6029 terminal_type
= (char *) 0;
6031 /* Now is the time to initialize this; it's used by init_sys_modes
6033 Vwindow_system
= Qnil
;
6035 /* If the user wants to use a window system, we shouldn't bother
6036 initializing the terminal. This is especially important when the
6037 terminal is so dumb that emacs gives up before and doesn't bother
6038 using the window system.
6040 If the DISPLAY environment variable is set and nonempty,
6041 try to use X, and die with an error message if that doesn't work. */
6043 #ifdef HAVE_X_WINDOWS
6048 display
= getenv ("DECW$DISPLAY");
6050 display
= getenv ("DISPLAY");
6053 display_arg
= (display
!= 0 && *display
!= 0);
6056 if (!inhibit_window_system
&& display_arg
6062 Vwindow_system
= intern ("x");
6064 Vwindow_system_version
= make_number (11);
6066 Vwindow_system_version
= make_number (10);
6068 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
6069 /* In some versions of ncurses,
6070 tputs crashes if we have not called tgetent.
6072 { char b
[2044]; tgetent (b
, "xterm");}
6074 adjust_frame_glyphs_initially ();
6077 #endif /* HAVE_X_WINDOWS */
6080 if (!inhibit_window_system
)
6082 Vwindow_system
= intern ("w32");
6083 Vwindow_system_version
= make_number (1);
6084 adjust_frame_glyphs_initially ();
6087 #endif /* HAVE_NTGUI */
6089 /* If no window system has been specified, try to use the terminal. */
6092 fatal ("standard input is not a tty");
6096 /* Look at the TERM variable */
6097 terminal_type
= (char *) getenv ("TERM");
6101 fprintf (stderr
, "Please specify your terminal type.\n\
6102 For types defined in VMS, use set term /device=TYPE.\n\
6103 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
6104 \(The quotation marks are necessary since terminal types are lower case.)\n");
6106 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
6112 /* VMS DCL tends to up-case things, so down-case term type.
6113 Hardly any uppercase letters in terminal types; should be none. */
6115 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
6118 strcpy (new, terminal_type
);
6120 for (p
= new; *p
; p
++)
6124 terminal_type
= new;
6128 term_init (terminal_type
);
6131 struct frame
*sf
= SELECTED_FRAME ();
6132 int width
= FRAME_WINDOW_WIDTH (sf
);
6133 int height
= FRAME_HEIGHT (sf
);
6135 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (struct glyph
);
6137 /* If these sizes are so big they cause overflow, just ignore the
6138 change. It's not clear what better we could do. */
6139 if (total_glyphs
/ sizeof (struct glyph
) / height
!= width
+ 2)
6140 fatal ("screen size %dx%d too big", width
, height
);
6143 adjust_frame_glyphs_initially ();
6144 calculate_costs (XFRAME (selected_frame
));
6149 #endif /* CANNOT_DUMP */
6150 signal (SIGWINCH
, window_change_signal
);
6151 #endif /* SIGWINCH */
6153 /* Set up faces of the initial terminal frame of a dumped Emacs. */
6157 /* The MSDOS terminal turns on its ``window system'' relatively
6158 late into the startup, so we cannot do the frame faces'
6159 initialization just yet. It will be done later by pc-win.el
6160 and internal_terminal_init. */
6161 && (strcmp (terminal_type
, "internal") != 0 || inhibit_window_system
)
6163 && NILP (Vwindow_system
))
6165 /* For the initial frame, we don't have any way of knowing what
6166 are the foreground and background colors of the terminal. */
6167 struct frame
*sf
= SELECTED_FRAME();
6169 FRAME_FOREGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_FG_COLOR
;
6170 FRAME_BACKGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_BG_COLOR
;
6171 call0 (intern ("tty-set-up-initial-frame-faces"));
6177 /***********************************************************************
6179 ***********************************************************************/
6181 DEFUN ("internal-show-cursor", Finternal_show_cursor
,
6182 Sinternal_show_cursor
, 2, 2, 0,
6183 "Set the cursor-visibility flag of WINDOW to SHOW.\n\
6184 WINDOW nil means use the selected window. SHOW non-nil means\n\
6185 show a cursor in WINDOW in the next redisplay. SHOW nil means\n\
6186 don't show a cursor.")
6188 Lisp_Object window
, show
;
6190 /* Don't change cursor state while redisplaying. This could confuse
6192 if (!redisplaying_p
)
6195 window
= selected_window
;
6197 CHECK_WINDOW (window
, 2);
6199 XWINDOW (window
)->cursor_off_p
= NILP (show
);
6206 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p
,
6207 Sinternal_show_cursor_p
, 0, 1, 0,
6208 "Value is non-nil if next redisplay will display a cursor in WINDOW.\n\
6209 WINDOW nil or omitted means report on the selected window.")
6216 window
= selected_window
;
6218 CHECK_WINDOW (window
, 2);
6220 w
= XWINDOW (window
);
6221 return w
->cursor_off_p
? Qnil
: Qt
;
6225 /***********************************************************************
6227 ***********************************************************************/
6232 defsubr (&Sredraw_frame
);
6233 defsubr (&Sredraw_display
);
6234 defsubr (&Sframe_or_buffer_changed_p
);
6235 defsubr (&Sopen_termscript
);
6237 defsubr (&Ssit_for
);
6238 defsubr (&Ssleep_for
);
6239 defsubr (&Ssend_string_to_terminal
);
6240 defsubr (&Sinternal_show_cursor
);
6241 defsubr (&Sinternal_show_cursor_p
);
6243 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
6244 staticpro (&frame_and_buffer_state
);
6246 Qdisplay_table
= intern ("display-table");
6247 staticpro (&Qdisplay_table
);
6248 Qredisplay_dont_pause
= intern ("redisplay-dont-pause");
6249 staticpro (&Qredisplay_dont_pause
);
6251 DEFVAR_INT ("baud-rate", &baud_rate
,
6252 "*The output baud rate of the terminal.\n\
6253 On most systems, changing this value will affect the amount of padding\n\
6254 and the other strategic decisions made during redisplay.");
6256 DEFVAR_BOOL ("inverse-video", &inverse_video
,
6257 "*Non-nil means invert the entire frame display.\n\
6258 This means everything is in inverse video which otherwise would not be.");
6260 DEFVAR_BOOL ("visible-bell", &visible_bell
,
6261 "*Non-nil means try to flash the frame to represent a bell.");
6263 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
6264 "*Non-nil means no need to redraw entire frame after suspending.\n\
6265 A non-nil value is useful if the terminal can automatically preserve\n\
6266 Emacs's frame display when you reenter Emacs.\n\
6267 It is up to you to set this variable if your terminal can do that.");
6269 DEFVAR_LISP ("window-system", &Vwindow_system
,
6270 "A symbol naming the window-system under which Emacs is running\n\
6271 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
6273 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
6274 "The version number of the window system in use.\n\
6275 For X windows, this is 10 or 11.");
6277 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
6278 "Non-nil means put cursor in minibuffer, at end of any message there.");
6280 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
6281 "Table defining how to output a glyph code to the frame.\n\
6282 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
6283 Each element can be:\n\
6284 integer: a glyph code which this glyph is an alias for.\n\
6285 string: output this glyph using that string (not impl. in X windows).\n\
6286 nil: this glyph mod 256 is char code to output,\n\
6287 and this glyph / 256 is face code for X windows (see `face-id').");
6288 Vglyph_table
= Qnil
;
6290 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
6291 "Display table to use for buffers that specify none.\n\
6292 See `buffer-display-table' for more information.");
6293 Vstandard_display_table
= Qnil
;
6295 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause
,
6296 "*Non-nil means update isn't paused when input is detected.");
6297 redisplay_dont_pause
= 0;
6299 /* Initialize `window-system', unless init_display already decided it. */
6304 Vwindow_system
= Qnil
;
6305 Vwindow_system_version
= Qnil
;