1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 97, 98, 1999
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
34 #include "termhooks.h"
35 /* cm.h must come after dispextern.h on Windows. */
36 #include "dispextern.h"
45 #include "intervals.h"
46 #include "blockinput.h"
50 /* I don't know why DEC Alpha OSF1 fail to compile this file if we
51 include the following file. */
52 /* #include "systty.h" */
53 #include "syssignal.h"
57 #endif /* HAVE_X_WINDOWS */
61 #endif /* HAVE_NTGUI */
63 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
68 /* To get the prototype for `sleep'. */
74 #define max(a, b) ((a) > (b) ? (a) : (b))
75 #define min(a, b) ((a) < (b) ? (a) : (b))
77 /* Get number of chars of output now in the buffer of a stdio stream.
78 This ought to be built in in stdio, but it isn't. Some s- files
79 override this because their stdio internals differ. */
81 #ifdef __GNU_LIBRARY__
83 /* The s- file might have overridden the definition with one that
84 works for the system's C library. But we are using the GNU C
85 library, so this is the right definition for every system. */
87 #ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT
88 #define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT
90 #undef PENDING_OUTPUT_COUNT
91 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
93 #else /* not __GNU_LIBRARY__ */
94 #if !defined (PENDING_OUTPUT_COUNT) && HAVE_STDIO_EXT_H && HAVE___FPENDING
95 #include <stdio_ext.h>
96 #define PENDING_OUTPUT_COUNT(FILE) __fpending (FILE)
98 #ifndef PENDING_OUTPUT_COUNT
99 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
101 #endif /* not __GNU_LIBRARY__ */
103 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
104 #include <term.h> /* for tgetent */
107 /* Structure to pass dimensions around. Used for character bounding
108 boxes, glyph matrix dimensions and alike. */
117 /* Function prototypes. */
119 static void redraw_overlapping_rows
P_ ((struct window
*, int));
120 static void redraw_overlapped_rows
P_ ((struct window
*, int));
121 static int count_blanks
P_ ((struct glyph
*, int));
122 static int count_match
P_ ((struct glyph
*, struct glyph
*,
123 struct glyph
*, struct glyph
*));
124 static unsigned line_draw_cost
P_ ((struct glyph_matrix
*, int));
125 static void update_frame_line
P_ ((struct frame
*, int));
126 static struct dim allocate_matrices_for_frame_redisplay
127 P_ ((Lisp_Object
, int, int, struct dim
, int, int *));
128 static void allocate_matrices_for_window_redisplay
P_ ((struct window
*,
130 static int realloc_glyph_pool
P_ ((struct glyph_pool
*, struct dim
));
131 static void adjust_frame_glyphs
P_ ((struct frame
*));
132 struct glyph_matrix
*new_glyph_matrix
P_ ((struct glyph_pool
*));
133 static void free_glyph_matrix
P_ ((struct glyph_matrix
*));
134 static void adjust_glyph_matrix
P_ ((struct window
*, struct glyph_matrix
*,
135 int, int, struct dim
));
136 static void change_frame_size_1
P_ ((struct frame
*, int, int, int, int, int));
137 static void swap_glyph_pointers
P_ ((struct glyph_row
*, struct glyph_row
*));
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
;
2458 /* Fill up the frame row with spaces up to the left margin of the
2460 fill_up_frame_row_with_spaces (frame_row
, window_matrix
->matrix_x
);
2462 /* Fill up areas in the window matrix row with spaces. */
2463 fill_up_glyph_row_with_spaces (window_row
);
2465 if (window_matrix
== w
->current_matrix
)
2467 /* We have to copy W's current matrix. Copy window
2468 row to frame row. */
2469 bcopy (window_row
->glyphs
[0],
2470 frame_row
->glyphs
[TEXT_AREA
] + window_matrix
->matrix_x
,
2471 window_matrix
->matrix_w
* sizeof (struct glyph
));
2475 /* Copy W's desired matrix. */
2477 /* Maybe insert a vertical border between horizontally adjacent
2479 if (right_border_glyph
)
2481 struct glyph
*border
= window_row
->glyphs
[LAST_AREA
] - 1;
2482 SET_CHAR_GLYPH_FROM_GLYPH (*border
, right_border_glyph
);
2485 #if 0 /* This shouldn't be necessary. Let's check it. */
2486 /* Due to hooks installed, it normally doesn't happen that
2487 window rows and frame rows of the same matrix are out of
2488 sync, i.e. have a different understanding of where to
2489 find glyphs for the row. The following is a safety-belt
2490 that doesn't cost much and makes absolutely sure that
2491 window and frame matrices are in sync. */
2492 if (!glyph_row_slice_p (window_row
, frame_row
))
2494 /* Find the row in the window being a slice. There
2495 should exist one from program logic. */
2496 struct glyph_row
*slice_row
2497 = find_glyph_row_slice (window_matrix
, frame_matrix
, frame_y
);
2498 xassert (slice_row
!= 0);
2500 /* Exchange glyphs between both window rows. */
2501 swap_glyphs_in_rows (window_row
, slice_row
);
2503 /* Exchange pointers between both rows. */
2504 swap_glyph_pointers (window_row
, slice_row
);
2508 /* Window row window_y must be a slice of frame row
2510 xassert (glyph_row_slice_p (window_row
, frame_row
));
2512 /* If rows are in sync, we don't have to copy glyphs because
2513 frame and window share glyphs. */
2516 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
2520 /* Set number of used glyphs in the frame matrix. Since we fill
2521 up with spaces, and visit leaf windows from left to right it
2522 can be done simply. */
2523 frame_row
->used
[TEXT_AREA
]
2524 = window_matrix
->matrix_x
+ window_matrix
->matrix_w
;
2527 frame_row
->enabled_p
|= window_row
->enabled_p
;
2528 frame_row
->inverse_p
|= window_row
->inverse_p
;
2537 /* Add spaces to a glyph row ROW in a window matrix.
2539 Each row has the form:
2541 +---------+-----------------------------+------------+
2542 | left | text | right |
2543 +---------+-----------------------------+------------+
2545 Left and right marginal areas are optional. This function adds
2546 spaces to areas so that there are no empty holes between areas.
2547 In other words: If the right area is not empty, the text area
2548 is filled up with spaces up to the right area. If the text area
2549 is not empty, the left area is filled up.
2551 To be called for frame-based redisplay, only. */
2554 fill_up_glyph_row_with_spaces (row
)
2555 struct glyph_row
*row
;
2557 fill_up_glyph_row_area_with_spaces (row
, LEFT_MARGIN_AREA
);
2558 fill_up_glyph_row_area_with_spaces (row
, TEXT_AREA
);
2559 fill_up_glyph_row_area_with_spaces (row
, RIGHT_MARGIN_AREA
);
2563 /* Fill area AREA of glyph row ROW with spaces. To be called for
2564 frame-based redisplay only. */
2567 fill_up_glyph_row_area_with_spaces (row
, area
)
2568 struct glyph_row
*row
;
2571 if (row
->glyphs
[area
] < row
->glyphs
[area
+ 1])
2573 struct glyph
*end
= row
->glyphs
[area
+ 1];
2574 struct glyph
*text
= row
->glyphs
[area
] + row
->used
[area
];
2577 *text
++ = space_glyph
;
2578 row
->used
[area
] = text
- row
->glyphs
[area
];
2583 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2584 reached. In frame matrices only one area, TEXT_AREA, is used. */
2587 fill_up_frame_row_with_spaces (row
, upto
)
2588 struct glyph_row
*row
;
2591 int i
= row
->used
[TEXT_AREA
];
2592 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
2595 glyph
[i
++] = space_glyph
;
2597 row
->used
[TEXT_AREA
] = i
;
2602 /**********************************************************************
2603 Mirroring operations on frame matrices in window matrices
2604 **********************************************************************/
2606 /* Set frame being updated via frame-based redisplay to F. This
2607 function must be called before updates to make explicit that we are
2608 working on frame matrices or not. */
2611 set_frame_matrix_frame (f
)
2614 frame_matrix_frame
= f
;
2618 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2619 DESIRED_MATRIX is the desired matrix corresponding to
2620 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2621 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2622 frame_matrix_frame is non-null, this indicates that the exchange is
2623 done in frame matrices, and that we have to perform analogous
2624 operations in window matrices of frame_matrix_frame. */
2627 make_current (desired_matrix
, current_matrix
, row
)
2628 struct glyph_matrix
*desired_matrix
, *current_matrix
;
2631 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, row
);
2632 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, row
);
2633 int mouse_face_p
= current_row
->mouse_face_p
;
2635 /* Do current_row = desired_row. This exchanges glyph pointers
2636 between both rows, and does a structure assignment otherwise. */
2637 assign_row (current_row
, desired_row
);
2639 /* Enable current_row to mark it as valid. */
2640 current_row
->enabled_p
= 1;
2641 current_row
->mouse_face_p
= mouse_face_p
;
2643 /* If we are called on frame matrices, perform analogous operations
2644 for window matrices. */
2645 if (frame_matrix_frame
)
2646 mirror_make_current (XWINDOW (frame_matrix_frame
->root_window
), row
);
2650 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2651 W's frame which has been made current (by swapping pointers between
2652 current and desired matrix). Perform analogous operations in the
2653 matrices of leaf windows in the window tree rooted at W. */
2656 mirror_make_current (w
, frame_row
)
2662 if (!NILP (w
->hchild
))
2663 mirror_make_current (XWINDOW (w
->hchild
), frame_row
);
2664 else if (!NILP (w
->vchild
))
2665 mirror_make_current (XWINDOW (w
->vchild
), frame_row
);
2668 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2669 here because the checks performed in debug mode there
2670 will not allow the conversion. */
2671 int row
= frame_row
- w
->desired_matrix
->matrix_y
;
2673 /* If FRAME_ROW is within W, assign the desired row to the
2674 current row (exchanging glyph pointers). */
2675 if (row
>= 0 && row
< w
->desired_matrix
->matrix_h
)
2677 struct glyph_row
*current_row
2678 = MATRIX_ROW (w
->current_matrix
, row
);
2679 struct glyph_row
*desired_row
2680 = MATRIX_ROW (w
->desired_matrix
, row
);
2682 if (desired_row
->enabled_p
)
2683 assign_row (current_row
, desired_row
);
2685 swap_glyph_pointers (desired_row
, current_row
);
2686 current_row
->enabled_p
= 1;
2690 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2695 /* Perform row dance after scrolling. We are working on the range of
2696 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2697 including) in MATRIX. COPY_FROM is a vector containing, for each
2698 row I in the range 0 <= I < NLINES, the index of the original line
2699 to move to I. This index is relative to the row range, i.e. 0 <=
2700 index < NLINES. RETAINED_P is a vector containing zero for each
2701 row 0 <= I < NLINES which is empty.
2703 This function is called from do_scrolling and do_direct_scrolling. */
2706 mirrored_line_dance (matrix
, unchanged_at_top
, nlines
, copy_from
,
2708 struct glyph_matrix
*matrix
;
2709 int unchanged_at_top
, nlines
;
2713 /* A copy of original rows. */
2714 struct glyph_row
*old_rows
;
2716 /* Rows to assign to. */
2717 struct glyph_row
*new_rows
= MATRIX_ROW (matrix
, unchanged_at_top
);
2721 /* Make a copy of the original rows. */
2722 old_rows
= (struct glyph_row
*) alloca (nlines
* sizeof *old_rows
);
2723 bcopy (new_rows
, old_rows
, nlines
* sizeof *old_rows
);
2725 /* Assign new rows, maybe clear lines. */
2726 for (i
= 0; i
< nlines
; ++i
)
2728 int enabled_before_p
= new_rows
[i
].enabled_p
;
2730 xassert (i
+ unchanged_at_top
< matrix
->nrows
);
2731 xassert (unchanged_at_top
+ copy_from
[i
] < matrix
->nrows
);
2732 new_rows
[i
] = old_rows
[copy_from
[i
]];
2733 new_rows
[i
].enabled_p
= enabled_before_p
;
2735 /* RETAINED_P is zero for empty lines. */
2736 if (!retained_p
[copy_from
[i
]])
2737 new_rows
[i
].enabled_p
= 0;
2740 /* Do the same for window matrices, if MATRIX Is a frame matrix. */
2741 if (frame_matrix_frame
)
2742 mirror_line_dance (XWINDOW (frame_matrix_frame
->root_window
),
2743 unchanged_at_top
, nlines
, copy_from
, retained_p
);
2747 /* Synchronize glyph pointers in the current matrix of window W with
2748 the current frame matrix. W must be full-width, and be on a tty
2752 sync_window_with_frame_matrix_rows (w
)
2755 struct frame
*f
= XFRAME (w
->frame
);
2756 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
2758 /* Preconditions: W must be a leaf window and full-width. Its frame
2759 must have a frame matrix. */
2760 xassert (NILP (w
->hchild
) && NILP (w
->vchild
));
2761 xassert (WINDOW_FULL_WIDTH_P (w
));
2762 xassert (!FRAME_WINDOW_P (f
));
2764 /* If W is a full-width window, glyph pointers in W's current matrix
2765 have, by definition, to be the same as glyph pointers in the
2766 corresponding frame matrix. */
2767 window_row
= w
->current_matrix
->rows
;
2768 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
2769 frame_row
= f
->current_matrix
->rows
+ XFASTINT (w
->top
);
2770 while (window_row
< window_row_end
)
2774 for (area
= LEFT_MARGIN_AREA
; area
<= LAST_AREA
; ++area
)
2775 window_row
->glyphs
[area
] = frame_row
->glyphs
[area
];
2777 ++window_row
, ++frame_row
;
2782 /* Return the window in the window tree rooted in W containing frame
2783 row ROW. Value is null if none is found. */
2786 frame_row_to_window (w
, row
)
2790 struct window
*found
= NULL
;
2794 if (!NILP (w
->hchild
))
2795 found
= frame_row_to_window (XWINDOW (w
->hchild
), row
);
2796 else if (!NILP (w
->vchild
))
2797 found
= frame_row_to_window (XWINDOW (w
->vchild
), row
);
2798 else if (row
>= XFASTINT (w
->top
)
2799 && row
< XFASTINT (w
->top
) + XFASTINT (w
->height
))
2802 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2809 /* Perform a line dance in the window tree rooted at W, after
2810 scrolling a frame matrix in mirrored_line_dance.
2812 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
2813 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
2814 COPY_FROM is a vector containing, for each row I in the range 0 <=
2815 I < NLINES, the index of the original line to move to I. This
2816 index is relative to the row range, i.e. 0 <= index < NLINES.
2817 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
2821 mirror_line_dance (w
, unchanged_at_top
, nlines
, copy_from
, retained_p
)
2823 int unchanged_at_top
, nlines
;
2829 if (!NILP (w
->hchild
))
2830 mirror_line_dance (XWINDOW (w
->hchild
), unchanged_at_top
,
2831 nlines
, copy_from
, retained_p
);
2832 else if (!NILP (w
->vchild
))
2833 mirror_line_dance (XWINDOW (w
->vchild
), unchanged_at_top
,
2834 nlines
, copy_from
, retained_p
);
2837 /* W is a leaf window, and we are working on its current
2839 struct glyph_matrix
*m
= w
->current_matrix
;
2841 struct glyph_row
*old_rows
;
2843 /* Make a copy of the original rows of matrix m. */
2844 old_rows
= (struct glyph_row
*) alloca (m
->nrows
* sizeof *old_rows
);
2845 bcopy (m
->rows
, old_rows
, m
->nrows
* sizeof *old_rows
);
2847 for (i
= 0; i
< nlines
; ++i
)
2849 /* Frame relative line assigned to. */
2850 int frame_to
= i
+ unchanged_at_top
;
2852 /* Frame relative line assigned. */
2853 int frame_from
= copy_from
[i
] + unchanged_at_top
;
2855 /* Window relative line assigned to. */
2856 int window_to
= frame_to
- m
->matrix_y
;
2858 /* Window relative line assigned. */
2859 int window_from
= frame_from
- m
->matrix_y
;
2861 /* Is assigned line inside window? */
2862 int from_inside_window_p
2863 = window_from
>= 0 && window_from
< m
->matrix_h
;
2865 /* Is assigned to line inside window? */
2866 int to_inside_window_p
2867 = window_to
>= 0 && window_to
< m
->matrix_h
;
2869 if (from_inside_window_p
&& to_inside_window_p
)
2871 /* Enabled setting before assignment. */
2872 int enabled_before_p
;
2874 /* Do the assignment. The enabled_p flag is saved
2875 over the assignment because the old redisplay did
2877 enabled_before_p
= m
->rows
[window_to
].enabled_p
;
2878 m
->rows
[window_to
] = old_rows
[window_from
];
2879 m
->rows
[window_to
].enabled_p
= enabled_before_p
;
2881 /* If frame line is empty, window line is empty, too. */
2882 if (!retained_p
[copy_from
[i
]])
2883 m
->rows
[window_to
].enabled_p
= 0;
2885 else if (to_inside_window_p
)
2887 /* A copy between windows. This is an infrequent
2888 case not worth optimizing. */
2889 struct frame
*f
= XFRAME (w
->frame
);
2890 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
2892 struct glyph_matrix
*m2
;
2895 w2
= frame_row_to_window (root
, frame_to
);
2896 m2
= w2
->current_matrix
;
2897 m2_from
= frame_from
- m2
->matrix_y
;
2898 copy_row_except_pointers (m
->rows
+ window_to
,
2899 m2
->rows
+ m2_from
);
2901 /* If frame line is empty, window line is empty, too. */
2902 if (!retained_p
[copy_from
[i
]])
2903 m
->rows
[window_to
].enabled_p
= 0;
2906 else if (from_inside_window_p
)
2910 /* If there was a copy between windows, make sure glyph
2911 pointers are in sync with the frame matrix. */
2913 sync_window_with_frame_matrix_rows (w
);
2915 /* Check that no pointers are lost. */
2919 /* Next window on same level. */
2920 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2927 /* Check that window and frame matrices agree about their
2928 understanding where glyphs of the rows are to find. For each
2929 window in the window tree rooted at W, check that rows in the
2930 matrices of leaf window agree with their frame matrices about
2934 check_window_matrix_pointers (w
)
2939 if (!NILP (w
->hchild
))
2940 check_window_matrix_pointers (XWINDOW (w
->hchild
));
2941 else if (!NILP (w
->vchild
))
2942 check_window_matrix_pointers (XWINDOW (w
->vchild
));
2945 struct frame
*f
= XFRAME (w
->frame
);
2946 check_matrix_pointers (w
->desired_matrix
, f
->desired_matrix
);
2947 check_matrix_pointers (w
->current_matrix
, f
->current_matrix
);
2950 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2955 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
2956 a window and FRAME_MATRIX is the corresponding frame matrix. For
2957 each row in WINDOW_MATRIX check that it's a slice of the
2958 corresponding frame row. If it isn't, abort. */
2961 check_matrix_pointers (window_matrix
, frame_matrix
)
2962 struct glyph_matrix
*window_matrix
, *frame_matrix
;
2964 /* Row number in WINDOW_MATRIX. */
2967 /* Row number corresponding to I in FRAME_MATRIX. */
2968 int j
= window_matrix
->matrix_y
;
2970 /* For all rows check that the row in the window matrix is a
2971 slice of the row in the frame matrix. If it isn't we didn't
2972 mirror an operation on the frame matrix correctly. */
2973 while (i
< window_matrix
->nrows
)
2975 if (!glyph_row_slice_p (window_matrix
->rows
+ i
,
2976 frame_matrix
->rows
+ j
))
2982 #endif /* GLYPH_DEBUG != 0 */
2986 /**********************************************************************
2987 VPOS and HPOS translations
2988 **********************************************************************/
2992 /* Translate vertical position VPOS which is relative to window W to a
2993 vertical position relative to W's frame. */
2996 window_to_frame_vpos (w
, vpos
)
3000 struct frame
*f
= XFRAME (w
->frame
);
3002 xassert (!FRAME_WINDOW_P (f
));
3003 xassert (vpos
>= 0 && vpos
<= w
->desired_matrix
->nrows
);
3004 vpos
+= XFASTINT (w
->top
);
3005 xassert (vpos
>= 0 && vpos
<= FRAME_HEIGHT (f
));
3010 /* Translate horizontal position HPOS which is relative to window W to
3011 a vertical position relative to W's frame. */
3014 window_to_frame_hpos (w
, hpos
)
3018 struct frame
*f
= XFRAME (w
->frame
);
3020 xassert (!FRAME_WINDOW_P (f
));
3021 hpos
+= XFASTINT (w
->left
);
3025 #endif /* GLYPH_DEBUG */
3029 /**********************************************************************
3031 **********************************************************************/
3033 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
3034 "Clear frame FRAME and output again what is supposed to appear on it.")
3040 CHECK_LIVE_FRAME (frame
, 0);
3043 /* Ignore redraw requests, if frame has no glyphs yet.
3044 (Implementation note: It still has to be checked why we are
3045 called so early here). */
3046 if (!glyphs_initialized_initially_p
)
3050 if (FRAME_MSDOS_P (f
))
3051 set_terminal_modes ();
3053 clear_current_matrices (f
);
3056 windows_or_buffers_changed
++;
3057 /* Mark all windows as inaccurate, so that every window will have
3058 its redisplay done. */
3059 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
3060 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
3066 /* Redraw frame F. This is nothing more than a call to the Lisp
3067 function redraw-frame. */
3074 XSETFRAME (frame
, f
);
3075 Fredraw_frame (frame
);
3079 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
3080 "Clear and redisplay all visible frames.")
3083 Lisp_Object tail
, frame
;
3085 FOR_EACH_FRAME (tail
, frame
)
3086 if (FRAME_VISIBLE_P (XFRAME (frame
)))
3087 Fredraw_frame (frame
);
3093 /* This is used when frame_garbaged is set. Call Fredraw_frame on all
3094 visible frames marked as garbaged. */
3097 redraw_garbaged_frames ()
3099 Lisp_Object tail
, frame
;
3101 FOR_EACH_FRAME (tail
, frame
)
3102 if (FRAME_VISIBLE_P (XFRAME (frame
))
3103 && FRAME_GARBAGED_P (XFRAME (frame
)))
3104 Fredraw_frame (frame
);
3109 /***********************************************************************
3111 ***********************************************************************/
3113 /* Try to update display and current glyph matrix directly.
3115 This function is called after a character G has been inserted into
3116 current_buffer. It tries to update the current glyph matrix and
3117 perform appropriate screen output to reflect the insertion. If it
3118 succeeds, the global flag redisplay_performed_directly_p will be
3119 set to 1, and thereby prevent the more costly general redisplay
3120 from running (see redisplay_internal).
3122 This function is not called for `hairy' character insertions.
3123 In particular, it is not called when after or before change
3124 functions exist, like they are used by font-lock. See keyboard.c
3125 for details where this function is called. */
3128 direct_output_for_insert (g
)
3131 register struct frame
*f
= SELECTED_FRAME ();
3132 struct window
*w
= XWINDOW (selected_window
);
3134 struct glyph_row
*glyph_row
;
3135 struct glyph
*glyphs
, *glyph
, *end
;
3137 /* Non-null means that Redisplay of W is based on window matrices. */
3138 int window_redisplay_p
= FRAME_WINDOW_P (f
);
3139 /* Non-null means we are in overwrite mode. */
3140 int overwrite_p
= !NILP (current_buffer
->overwrite_mode
);
3142 struct text_pos pos
;
3143 int delta
, delta_bytes
;
3145 /* Not done directly. */
3146 redisplay_performed_directly_p
= 0;
3148 /* Quickly give up for some common cases. */
3149 if (cursor_in_echo_area
3150 /* Give up if fonts have changed. */
3152 /* Give up if face attributes have been changed. */
3153 || face_change_count
3154 /* Give up if cursor position not really known. */
3155 || !display_completed
3156 /* Give up if buffer appears in two places. */
3157 || buffer_shared
> 1
3158 /* Give up if w is mini-buffer and a message is being displayed there */
3159 || (MINI_WINDOW_P (w
) && !NILP (echo_area_buffer
[0]))
3160 /* Give up for hscrolled mini-buffer because display of the prompt
3161 is handled specially there (see display_line). */
3162 || (MINI_WINDOW_P (w
) && XFASTINT (w
->hscroll
))
3163 /* Give up if overwriting in the middle of a line. */
3166 && FETCH_BYTE (PT
) != '\n')
3167 /* Give up for tabs and line ends. */
3171 /* Give up if unable to display the cursor in the window. */
3172 || w
->cursor
.vpos
< 0
3173 || (glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
),
3174 /* Can't do it in a continued line because continuation
3175 lines would change. */
3176 (glyph_row
->continued_p
3177 /* Can't use this method if the line overlaps others or is
3178 overlapped by others because these other lines would
3179 have to be redisplayed. */
3180 || glyph_row
->overlapping_p
3181 || glyph_row
->overlapped_p
))
3182 /* Can't do it for partial width windows on terminal frames
3183 because we can't clear to eol in such a window. */
3184 || (!window_redisplay_p
&& !WINDOW_FULL_WIDTH_P (w
)))
3187 /* Set up a display iterator structure for W. Glyphs will be
3188 produced in scratch_glyph_row. Current position is W's cursor
3190 clear_glyph_row (&scratch_glyph_row
);
3191 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
3192 DEC_TEXT_POS (pos
, !NILP (current_buffer
->enable_multibyte_characters
));
3193 init_iterator (&it
, w
, CHARPOS (pos
), BYTEPOS (pos
), &scratch_glyph_row
,
3196 glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3197 if (glyph_row
->mouse_face_p
)
3200 /* Give up if highlighting trailing whitespace and we have trailing
3201 whitespace in glyph_row. We would have to remove the trailing
3202 whitespace face in that case. */
3203 if (!NILP (Vshow_trailing_whitespace
)
3204 && glyph_row
->used
[TEXT_AREA
])
3208 last
= glyph_row
->glyphs
[TEXT_AREA
] + glyph_row
->used
[TEXT_AREA
] - 1;
3209 if (last
->type
== STRETCH_GLYPH
3210 || (last
->type
== CHAR_GLYPH
3211 && last
->u
.ch
== ' '))
3215 /* Give up if there are overlay strings at pos. This would fail
3216 if the overlay string has newlines in it. */
3217 if (STRINGP (it
.string
))
3220 it
.hpos
= w
->cursor
.hpos
;
3221 it
.vpos
= w
->cursor
.vpos
;
3222 it
.current_x
= w
->cursor
.x
+ it
.first_visible_x
;
3223 it
.current_y
= w
->cursor
.y
;
3224 it
.end_charpos
= PT
;
3225 it
.stop_charpos
= min (PT
, it
.stop_charpos
);
3227 /* More than one display element may be returned for PT - 1 if
3228 (i) it's a control character which is translated into `\003' or
3229 `^C', or (ii) it has a display table entry, or (iii) it's a
3230 combination of both. */
3231 delta
= delta_bytes
= 0;
3232 while (get_next_display_element (&it
))
3234 PRODUCE_GLYPHS (&it
);
3236 /* Give up if glyph doesn't fit completely on the line. */
3237 if (it
.current_x
>= it
.last_visible_x
)
3240 /* Give up if new glyph has different ascent or descent than
3241 the original row, or if it is not a character glyph. */
3242 if (glyph_row
->ascent
!= it
.ascent
3243 || glyph_row
->height
!= it
.ascent
+ it
.descent
3244 || glyph_row
->phys_ascent
!= it
.phys_ascent
3245 || glyph_row
->phys_height
!= it
.phys_ascent
+ it
.phys_descent
3246 || it
.what
!= IT_CHARACTER
)
3250 delta_bytes
+= it
.len
;
3251 set_iterator_to_next (&it
);
3254 /* Give up if we hit the right edge of the window. We would have
3255 to insert truncation or continuation glyphs. */
3256 added_width
= it
.current_x
- (w
->cursor
.x
+ it
.first_visible_x
);
3257 if (glyph_row
->pixel_width
+ added_width
>= it
.last_visible_x
)
3260 /* Give up if there is a \t following in the line. */
3262 it2
.end_charpos
= ZV
;
3263 it2
.stop_charpos
= min (it2
.stop_charpos
, ZV
);
3264 while (get_next_display_element (&it2
)
3265 && !ITERATOR_AT_END_OF_LINE_P (&it2
))
3269 set_iterator_to_next (&it2
);
3272 /* Number of new glyphs produced. */
3273 n
= it
.glyph_row
->used
[TEXT_AREA
];
3275 /* Start and end of glyphs in original row. */
3276 glyphs
= glyph_row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
3277 end
= glyph_row
->glyphs
[1 + TEXT_AREA
];
3279 /* Make room for new glyphs, then insert them. */
3280 xassert (end
- glyphs
- n
>= 0);
3281 safe_bcopy ((char *) glyphs
, (char *) (glyphs
+ n
),
3282 (end
- glyphs
- n
) * sizeof (*end
));
3283 bcopy (it
.glyph_row
->glyphs
[TEXT_AREA
], glyphs
, n
* sizeof *glyphs
);
3284 glyph_row
->used
[TEXT_AREA
] = min (glyph_row
->used
[TEXT_AREA
] + n
,
3285 end
- glyph_row
->glyphs
[TEXT_AREA
]);
3287 /* Compute new line width. */
3288 glyph
= glyph_row
->glyphs
[TEXT_AREA
];
3289 end
= glyph
+ glyph_row
->used
[TEXT_AREA
];
3290 glyph_row
->pixel_width
= glyph_row
->x
;
3293 glyph_row
->pixel_width
+= glyph
->pixel_width
;
3297 /* Increment buffer positions for glyphs following the newly
3299 for (glyph
= glyphs
+ n
; glyph
< end
; ++glyph
)
3300 if (glyph
->charpos
> 0 && BUFFERP (glyph
->object
))
3301 glyph
->charpos
+= delta
;
3303 if (MATRIX_ROW_END_CHARPOS (glyph_row
) > 0)
3305 MATRIX_ROW_END_CHARPOS (glyph_row
) += delta
;
3306 MATRIX_ROW_END_BYTEPOS (glyph_row
) += delta_bytes
;
3309 /* Adjust positions in lines following the one we are in. */
3310 increment_matrix_positions (w
->current_matrix
,
3312 w
->current_matrix
->nrows
,
3313 delta
, delta_bytes
);
3315 glyph_row
->contains_overlapping_glyphs_p
3316 |= it
.glyph_row
->contains_overlapping_glyphs_p
;
3318 glyph_row
->displays_text_p
= 1;
3319 w
->window_end_vpos
= make_number (max (w
->cursor
.vpos
,
3320 XFASTINT (w
->window_end_vpos
)));
3322 if (!NILP (Vshow_trailing_whitespace
))
3323 highlight_trailing_whitespace (it
.f
, glyph_row
);
3325 /* Write glyphs. If at end of row, we can simply call write_glyphs.
3326 In the middle, we have to insert glyphs. Note that this is now
3327 implemented for X frames. The implementation uses updated_window
3329 updated_row
= glyph_row
;
3333 rif
->update_window_begin_hook (w
);
3335 if (glyphs
== end
- n
)
3336 rif
->write_glyphs (glyphs
, n
);
3338 rif
->insert_glyphs (glyphs
, n
);
3342 if (glyphs
== end
- n
)
3343 write_glyphs (glyphs
, n
);
3345 insert_glyphs (glyphs
, n
);
3348 w
->cursor
.hpos
+= n
;
3349 w
->cursor
.x
= it
.current_x
- it
.first_visible_x
;
3350 xassert (w
->cursor
.hpos
>= 0
3351 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3353 /* How to set the cursor differs depending on whether we are
3354 using a frame matrix or a window matrix. Note that when
3355 a frame matrix is used, cursor_to expects frame coordinates,
3356 and the X and Y parameters are not used. */
3357 if (window_redisplay_p
)
3358 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3359 w
->cursor
.y
, w
->cursor
.x
);
3363 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3364 + (INTEGERP (w
->left_margin_width
)
3365 ? XFASTINT (w
->left_margin_width
)
3367 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3372 rif
->update_window_end_hook (w
, 1, 0);
3377 TRACE ((stderr
, "direct output for insert\n"));
3379 UNCHANGED_MODIFIED
= MODIFF
;
3380 BEG_UNCHANGED
= GPT
- BEG
;
3381 XSETFASTINT (w
->last_point
, PT
);
3382 w
->last_cursor
= w
->cursor
;
3383 XSETFASTINT (w
->last_modified
, MODIFF
);
3384 XSETFASTINT (w
->last_overlay_modified
, OVERLAY_MODIFF
);
3386 redisplay_performed_directly_p
= 1;
3391 /* Perform a direct display update for moving PT by N positions
3392 left or right. N < 0 means a movement backwards. This function
3393 is currently only called for N == 1 or N == -1. */
3396 direct_output_forward_char (n
)
3399 struct frame
*f
= SELECTED_FRAME ();
3400 struct window
*w
= XWINDOW (selected_window
);
3401 struct glyph_row
*row
;
3403 /* Give up if point moved out of or into a composition. */
3404 if (check_point_in_composition (current_buffer
, XINT (w
->last_point
),
3405 current_buffer
, PT
))
3408 /* Give up if face attributes have been changed. */
3409 if (face_change_count
)
3412 /* Give up if current matrix is not up to date or we are
3413 displaying a message. */
3414 if (!display_completed
|| cursor_in_echo_area
)
3417 /* Give up if the buffer's direction is reversed. */
3418 if (!NILP (XBUFFER (w
->buffer
)->direction_reversed
))
3421 /* Can't use direct output if highlighting a region. */
3422 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
3425 /* Can't use direct output if highlighting trailing whitespace. */
3426 if (!NILP (Vshow_trailing_whitespace
))
3429 /* Give up if we are showing a message or just cleared the message
3430 because we might need to resize the echo area window. */
3431 if (!NILP (echo_area_buffer
[0]) || !NILP (echo_area_buffer
[1]))
3434 /* Give up if currently displaying a message instead of the
3435 minibuffer contents. */
3436 if (XWINDOW (minibuf_window
) == w
3437 && EQ (minibuf_window
, echo_area_window
))
3440 /* Give up if we don't know where the cursor is. */
3441 if (w
->cursor
.vpos
< 0)
3444 row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3446 if (PT
<= MATRIX_ROW_START_BYTEPOS (row
)
3447 || PT
>= MATRIX_ROW_END_BYTEPOS (row
))
3450 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
3451 w
->last_cursor
= w
->cursor
;
3452 XSETFASTINT (w
->last_point
, PT
);
3454 xassert (w
->cursor
.hpos
>= 0
3455 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3457 if (FRAME_WINDOW_P (f
))
3458 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3459 w
->cursor
.y
, w
->cursor
.x
);
3463 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3464 + (INTEGERP (w
->left_margin_width
)
3465 ? XFASTINT (w
->left_margin_width
)
3467 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3472 redisplay_performed_directly_p
= 1;
3478 /***********************************************************************
3480 ***********************************************************************/
3482 /* Update frame F based on the data in desired matrices.
3484 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3485 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3488 Value is non-zero if redisplay was stopped due to pending input. */
3491 update_frame (f
, force_p
, inhibit_hairy_id_p
)
3494 int inhibit_hairy_id_p
;
3496 /* 1 means display has been paused because of pending input. */
3498 struct window
*root_window
= XWINDOW (f
->root_window
);
3500 if (FRAME_WINDOW_P (f
))
3502 /* We are working on window matrix basis. All windows whose
3503 flag must_be_updated_p is set have to be updated. */
3505 /* Record that we are not working on frame matrices. */
3506 set_frame_matrix_frame (NULL
);
3508 /* Update all windows in the window tree of F, maybe stopping
3509 when pending input is detected. */
3512 /* Update the menu bar on X frames that don't have toolkit
3514 if (WINDOWP (f
->menu_bar_window
))
3515 update_window (XWINDOW (f
->menu_bar_window
), 1);
3517 /* Update the tool-bar window, if present. */
3518 if (WINDOWP (f
->tool_bar_window
))
3521 struct window
*w
= XWINDOW (f
->tool_bar_window
);
3523 /* Update tool-bar window. */
3524 if (w
->must_be_updated_p
)
3526 update_window (w
, 1);
3527 w
->must_be_updated_p
= 0;
3529 /* Swap tool-bar strings. We swap because we want to
3531 tem
= f
->current_tool_bar_string
;
3532 f
->current_tool_bar_string
= f
->desired_tool_bar_string
;
3533 f
->desired_tool_bar_string
= tem
;
3534 f
->n_current_tool_bar_items
= f
->n_desired_tool_bar_items
;
3536 /* Swap tool-bar items. We swap because we want to
3538 tem
= f
->current_tool_bar_items
;
3539 f
->current_tool_bar_items
= f
->desired_tool_bar_items
;
3540 f
->desired_tool_bar_items
= tem
;
3545 /* Update windows. */
3546 paused_p
= update_window_tree (root_window
, force_p
);
3548 display_completed
= !paused_p
;
3550 /* The flush is a performance bottleneck under X. */
3552 rif
->flush_display (f
);
3557 /* We are working on frame matrix basis. Set the frame on whose
3558 frame matrix we operate. */
3559 set_frame_matrix_frame (f
);
3561 /* Build F's desired matrix from window matrices. For windows
3562 whose must_be_updated_p flag is set, desired matrices are
3563 made part of the desired frame matrix. For other windows,
3564 the current matrix is copied. */
3565 build_frame_matrix (f
);
3567 /* Do the update on the frame desired matrix. */
3568 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3570 /* Check window matrices for lost pointers. */
3571 IF_DEBUG (check_window_matrix_pointers (root_window
));
3574 /* Reset flags indicating that a window should be updated. */
3575 set_window_update_flags (root_window
, 0);
3581 /************************************************************************
3582 Window-based updates
3583 ************************************************************************/
3585 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3586 don't stop updating when input is pending. */
3589 update_window_tree (w
, force_p
)
3595 while (w
&& !paused_p
)
3597 if (!NILP (w
->hchild
))
3598 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
3599 else if (!NILP (w
->vchild
))
3600 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
3601 else if (w
->must_be_updated_p
)
3602 paused_p
|= update_window (w
, force_p
);
3604 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3611 /* Update window W if its flag must_be_updated_p is non-zero. If
3612 FORCE_P is non-zero, don't stop updating if input is pending. */
3615 update_single_window (w
, force_p
)
3619 if (w
->must_be_updated_p
)
3621 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3623 /* Record that this is not a frame-based redisplay. */
3624 set_frame_matrix_frame (NULL
);
3628 update_window (w
, force_p
);
3631 /* Reset flag in W. */
3632 w
->must_be_updated_p
= 0;
3637 /* Redraw lines from the current matrix of window W that are
3638 overlapped by other rows. YB is bottom-most y-position in W. */
3641 redraw_overlapped_rows (w
, yb
)
3647 /* If rows overlapping others have been changed, the rows being
3648 overlapped have to be redrawn. This won't draw lines that have
3649 already been drawn in update_window_line because overlapped_p in
3650 desired rows is 0, so after row assignment overlapped_p in
3651 current rows is 0. */
3652 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3654 struct glyph_row
*row
= w
->current_matrix
->rows
+ i
;
3656 if (!row
->enabled_p
)
3658 else if (row
->mode_line_p
)
3661 if (row
->overlapped_p
)
3663 enum glyph_row_area area
;
3665 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3668 updated_area
= area
;
3669 rif
->cursor_to (i
, 0, row
->y
, area
== TEXT_AREA
? row
->x
: 0);
3670 if (row
->used
[area
])
3671 rif
->write_glyphs (row
->glyphs
[area
], row
->used
[area
]);
3672 rif
->clear_end_of_line (-1);
3675 row
->overlapped_p
= 0;
3678 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3684 /* Redraw lines from the current matrix of window W that overlap
3685 others. YB is bottom-most y-position in W. */
3688 redraw_overlapping_rows (w
, yb
)
3693 struct glyph_row
*row
;
3695 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3697 row
= w
->current_matrix
->rows
+ i
;
3699 if (!row
->enabled_p
)
3701 else if (row
->mode_line_p
)
3704 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3706 if (row
->overlapping_p
&& i
> 0 && bottom_y
< yb
)
3708 if (row
->used
[LEFT_MARGIN_AREA
])
3709 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
);
3711 if (row
->used
[TEXT_AREA
])
3712 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
);
3714 if (row
->used
[RIGHT_MARGIN_AREA
])
3715 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
);
3717 /* Record in neighbor rows that ROW overwrites part of their
3719 if (row
->phys_ascent
> row
->ascent
&& i
> 0)
3720 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3721 if ((row
->phys_height
- row
->phys_ascent
3722 > row
->height
- row
->ascent
)
3724 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
3733 /* Update display of window W. FORCE_P non-zero means that we should
3734 not stop when detecting pending input. */
3737 update_window (w
, force_p
)
3741 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
3743 int preempt_count
= baud_rate
/ 2400 + 1;
3744 extern int input_pending
;
3746 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3747 extern struct frame
*updating_frame
;
3750 /* Check that W's frame doesn't have glyph matrices. */
3751 xassert (FRAME_WINDOW_P (f
));
3752 xassert (updating_frame
!= NULL
);
3754 /* Check pending input the first time so that we can quickly return. */
3755 if (redisplay_dont_pause
)
3758 detect_input_pending ();
3760 /* If forced to complete the update, or if no input is pending, do
3762 if (force_p
|| !input_pending
)
3764 struct glyph_row
*row
, *end
;
3765 struct glyph_row
*mode_line_row
;
3766 struct glyph_row
*header_line_row
= NULL
;
3767 int yb
, changed_p
= 0, mouse_face_overwritten_p
= 0;
3769 rif
->update_window_begin_hook (w
);
3770 yb
= window_text_bottom_y (w
);
3772 /* If window has a top line, update it before everything else.
3773 Adjust y-positions of other rows by the top line height. */
3774 row
= desired_matrix
->rows
;
3775 end
= row
+ desired_matrix
->nrows
- 1;
3776 if (row
->mode_line_p
)
3777 header_line_row
= row
++;
3779 /* Update the mode line, if necessary. */
3780 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3781 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
3783 mode_line_row
->y
= yb
;
3784 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
3786 &mouse_face_overwritten_p
);
3790 /* Find first enabled row. Optimizations in redisplay_internal
3791 may lead to an update with only one row enabled. There may
3792 be also completely empty matrices. */
3793 while (row
< end
&& !row
->enabled_p
)
3796 /* Try reusing part of the display by inserting/deleting lines. */
3797 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
3799 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
3802 /* All rows were found to be equal. */
3811 /* Update the top mode line after scrolling because a new top
3812 line would otherwise overwrite lines at the top of the window
3813 that can be scrolled. */
3814 if (header_line_row
&& header_line_row
->enabled_p
)
3816 header_line_row
->y
= 0;
3817 update_window_line (w
, 0, &mouse_face_overwritten_p
);
3821 /* Update the rest of the lines. */
3822 for (; row
< end
&& (force_p
|| !input_pending
); ++row
)
3824 /* A row can be completely invisible in case a desired
3825 matrix was built with a vscroll and then
3826 make_cursor_line_fully_visible shifts the matrix. */
3827 && row
->visible_height
> 0)
3829 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
3832 /* We'll Have to play a little bit with when to
3833 detect_input_pending. If it's done too often,
3834 scrolling large windows with repeated scroll-up
3835 commands will too quickly pause redisplay. */
3836 if (!force_p
&& vpos
% preempt_count
== 0)
3837 detect_input_pending ();
3839 changed_p
|= update_window_line (w
, vpos
,
3840 &mouse_face_overwritten_p
);
3842 /* Mark all rows below the last visible one in the current
3843 matrix as invalid. This is necessary because of
3844 variable line heights. Consider the case of three
3845 successive redisplays, where the first displays 5
3846 lines, the second 3 lines, and the third 5 lines again.
3847 If the second redisplay wouldn't mark rows in the
3848 current matrix invalid, the third redisplay might be
3849 tempted to optimize redisplay based on lines displayed
3850 in the first redisplay. */
3851 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3852 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
3853 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
3856 /* Was display preempted? */
3857 paused_p
= row
< end
;
3861 /* Fix the appearance of overlapping(overlapped rows. */
3862 if (!paused_p
&& !w
->pseudo_window_p
)
3864 if (changed_p
&& rif
->fix_overlapping_area
)
3866 redraw_overlapped_rows (w
, yb
);
3867 redraw_overlapping_rows (w
, yb
);
3870 /* Make cursor visible at cursor position of W. */
3871 set_window_cursor_after_update (w
);
3873 #if 0 /* Check that current matrix invariants are satisfied. This is
3874 for debugging only. See the comment of check_matrix_invariants. */
3875 IF_DEBUG (check_matrix_invariants (w
));
3880 /* Remember the redisplay method used to display the matrix. */
3881 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
3884 /* End of update of window W. */
3885 rif
->update_window_end_hook (w
, 1, mouse_face_overwritten_p
);
3890 clear_glyph_matrix (desired_matrix
);
3896 /* Update the display of area AREA in window W, row number VPOS.
3897 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3900 update_marginal_area (w
, area
, vpos
)
3904 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3906 /* Let functions in xterm.c know what area subsequent X positions
3907 will be relative to. */
3908 updated_area
= area
;
3910 /* Set cursor to start of glyphs, write them, and clear to the end
3911 of the area. I don't think that something more sophisticated is
3912 necessary here, since marginal areas will not be the default. */
3913 rif
->cursor_to (vpos
, 0, desired_row
->y
, 0);
3914 if (desired_row
->used
[area
])
3915 rif
->write_glyphs (desired_row
->glyphs
[area
], desired_row
->used
[area
]);
3916 rif
->clear_end_of_line (-1);
3920 /* Update the display of the text area of row VPOS in window W.
3921 Value is non-zero if display has changed. */
3924 update_text_area (w
, vpos
)
3928 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3929 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3932 /* Let functions in xterm.c know what area subsequent X positions
3933 will be relative to. */
3934 updated_area
= TEXT_AREA
;
3936 /* If rows are at different X or Y, or rows have different height,
3937 or the current row is marked invalid, write the entire line. */
3938 if (!current_row
->enabled_p
3939 || desired_row
->y
!= current_row
->y
3940 || desired_row
->ascent
!= current_row
->ascent
3941 || desired_row
->phys_ascent
!= current_row
->phys_ascent
3942 || desired_row
->phys_height
!= current_row
->phys_height
3943 || desired_row
->visible_height
!= current_row
->visible_height
3944 || current_row
->overlapped_p
3945 || current_row
->mouse_face_p
3946 || current_row
->x
!= desired_row
->x
)
3948 rif
->cursor_to (vpos
, 0, desired_row
->y
, desired_row
->x
);
3950 if (desired_row
->used
[TEXT_AREA
])
3951 rif
->write_glyphs (desired_row
->glyphs
[TEXT_AREA
],
3952 desired_row
->used
[TEXT_AREA
]);
3954 /* Clear to end of window. */
3955 rif
->clear_end_of_line (-1);
3961 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
3962 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
3964 /* If the desired row extends its face to the text area end,
3965 make sure we write at least one glyph, so that the face
3966 extension actually takes place. */
3967 int desired_stop_pos
= (desired_row
->used
[TEXT_AREA
]
3968 - (MATRIX_ROW_EXTENDS_FACE_P (desired_row
)
3971 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
3977 /* Skip over glyphs that both rows have in common. These
3978 don't have to be written. */
3980 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3982 x
+= desired_glyph
->pixel_width
;
3983 ++desired_glyph
, ++current_glyph
, ++i
;
3986 /* Consider the case that the current row contains "xxx ppp
3987 ggg" in italic Courier font, and the desired row is "xxx
3988 ggg". The character `p' has lbearing, `g' has not. The
3989 loop above will stop in front of the first `p' in the
3990 current row. If we would start writing glyphs there, we
3991 wouldn't erase the lbearing of the `p'. The rest of the
3992 lbearing problem is then taken care of by x_draw_glyphs. */
3993 if (current_row
->contains_overlapping_glyphs_p
3995 && i
< current_row
->used
[TEXT_AREA
]
3996 && current_row
->used
[TEXT_AREA
] != desired_row
->used
[TEXT_AREA
])
3999 rif
->get_glyph_overhangs (current_glyph
, XFRAME (w
->frame
),
4001 while (left
> 0 && i
> 0)
4003 --i
, --desired_glyph
, --current_glyph
;
4004 x
-= desired_glyph
->pixel_width
;
4005 left
-= desired_glyph
->pixel_width
;
4009 /* Try to avoid writing the entire rest of the desired row
4010 by looking for a resync point. This mainly prevents
4011 mode line flickering in the case the mode line is in
4012 fixed-pitch font, which it usually will be. */
4013 if (i
< desired_row
->used
[TEXT_AREA
])
4015 int start_x
= x
, start_hpos
= i
;
4016 struct glyph
*start
= desired_glyph
;
4019 /* Find the next glyph that's equal again. */
4021 && !GLYPH_EQUAL_P (desired_glyph
, current_glyph
)
4024 x
+= desired_glyph
->pixel_width
;
4025 current_x
+= current_glyph
->pixel_width
;
4026 ++desired_glyph
, ++current_glyph
, ++i
;
4029 if (i
== start_hpos
|| x
!= current_x
)
4033 desired_glyph
= start
;
4037 rif
->cursor_to (vpos
, start_hpos
, desired_row
->y
, start_x
);
4038 rif
->write_glyphs (start
, i
- start_hpos
);
4043 /* Write the rest. */
4044 if (i
< desired_row
->used
[TEXT_AREA
])
4046 rif
->cursor_to (vpos
, i
, desired_row
->y
, x
);
4047 rif
->write_glyphs (desired_glyph
, desired_row
->used
[TEXT_AREA
] - i
);
4051 /* Maybe clear to end of line. */
4052 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
4054 /* If new row extends to the end of the text area, nothing
4055 has to be cleared, if and only if we did a write_glyphs
4056 above. This is made sure by setting desired_stop_pos
4057 appropriately above. */
4058 xassert (i
< desired_row
->used
[TEXT_AREA
]);
4060 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
4062 /* If old row extends to the end of the text area, clear. */
4063 if (i
>= desired_row
->used
[TEXT_AREA
])
4064 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4065 desired_row
->x
+ desired_row
->pixel_width
);
4066 rif
->clear_end_of_line (-1);
4069 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
4071 /* Otherwise clear to the end of the old row. Everything
4072 after that position should be clear already. */
4075 if (i
>= desired_row
->used
[TEXT_AREA
])
4076 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4077 desired_row
->x
+ desired_row
->pixel_width
);
4079 /* If cursor is displayed at the end of the line, make sure
4080 it's cleared. Nowadays we don't have a phys_cursor_glyph
4081 with which to erase the cursor (because this method
4082 doesn't work with lbearing/rbearing), so we must do it
4084 if (vpos
== w
->phys_cursor
.vpos
4085 && w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])
4087 w
->phys_cursor_on_p
= 0;
4091 x
= current_row
->x
+ current_row
->pixel_width
;
4092 rif
->clear_end_of_line (x
);
4101 /* Update row VPOS in window W. Value is non-zero if display has been
4105 update_window_line (w
, vpos
, mouse_face_overwritten_p
)
4107 int vpos
, *mouse_face_overwritten_p
;
4109 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
4110 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
4113 xassert (desired_row
->enabled_p
);
4115 /* Set the row being updated. This is important to let xterm.c
4116 know what line height values are in effect. */
4117 updated_row
= desired_row
;
4119 /* Update display of the left margin area, if there is one. */
4120 if (!desired_row
->full_width_p
4121 && !NILP (w
->left_margin_width
))
4124 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
4127 /* Update the display of the text area. */
4128 if (update_text_area (w
, vpos
))
4131 if (current_row
->mouse_face_p
)
4132 *mouse_face_overwritten_p
= 1;
4135 /* Update display of the right margin area, if there is one. */
4136 if (!desired_row
->full_width_p
4137 && !NILP (w
->right_margin_width
))
4140 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
4143 /* Draw truncation marks etc. */
4144 if (!current_row
->enabled_p
4145 || desired_row
->y
!= current_row
->y
4146 || desired_row
->visible_height
!= current_row
->visible_height
4147 || desired_row
->overlay_arrow_p
!= current_row
->overlay_arrow_p
4148 || desired_row
->truncated_on_left_p
!= current_row
->truncated_on_left_p
4149 || desired_row
->truncated_on_right_p
!= current_row
->truncated_on_right_p
4150 || desired_row
->continued_p
!= current_row
->continued_p
4151 || desired_row
->mode_line_p
!= current_row
->mode_line_p
4152 || (desired_row
->indicate_empty_line_p
4153 != current_row
->indicate_empty_line_p
)
4154 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
4155 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
4156 rif
->after_update_window_line_hook (desired_row
);
4158 /* Update current_row from desired_row. */
4159 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4165 /* Set the cursor after an update of window W. This function may only
4166 be called from update_window. */
4169 set_window_cursor_after_update (w
)
4172 struct frame
*f
= XFRAME (w
->frame
);
4173 int cx
, cy
, vpos
, hpos
;
4175 /* Not intended for frame matrix updates. */
4176 xassert (FRAME_WINDOW_P (f
));
4178 if (cursor_in_echo_area
4179 && !NILP (echo_area_buffer
[0])
4180 /* If we are showing a message instead of the mini-buffer,
4181 show the cursor for the message instead. */
4182 && XWINDOW (minibuf_window
) == w
4183 && EQ (minibuf_window
, echo_area_window
)
4184 /* These cases apply only to the frame that contains
4185 the active mini-buffer window. */
4186 && FRAME_HAS_MINIBUF_P (f
)
4187 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4189 cx
= cy
= vpos
= hpos
= 0;
4191 if (cursor_in_echo_area
>= 0)
4193 /* If the mini-buffer is several lines high, find the last
4194 line that has any text on it. Note: either all lines
4195 are enabled or none. Otherwise we wouldn't be able to
4197 struct glyph_row
*row
, *last_row
;
4198 struct glyph
*glyph
;
4199 int yb
= window_text_bottom_y (w
);
4202 for (row
= MATRIX_ROW (w
->current_matrix
, 0);
4206 if (row
->used
[TEXT_AREA
]
4207 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4210 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4216 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
4217 struct glyph
*last
= start
+ row
->used
[TEXT_AREA
] - 1;
4219 while (last
> start
&& last
->charpos
< 0)
4222 for (glyph
= start
; glyph
< last
; ++glyph
)
4224 cx
+= glyph
->pixel_width
;
4229 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4237 hpos
= w
->cursor
.hpos
;
4238 vpos
= w
->cursor
.vpos
;
4241 /* Window cursor can be out of sync for horizontally split windows. */
4242 hpos
= max (0, hpos
);
4243 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4244 vpos
= max (0, vpos
);
4245 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4246 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4250 /* Set WINDOW->must_be_updated_p to ON_P for all windows in the window
4251 tree rooted at W. */
4254 set_window_update_flags (w
, on_p
)
4260 if (!NILP (w
->hchild
))
4261 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4262 else if (!NILP (w
->vchild
))
4263 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4265 w
->must_be_updated_p
= on_p
;
4267 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4273 /***********************************************************************
4274 Window-Based Scrolling
4275 ***********************************************************************/
4277 /* Structure describing rows in scrolling_window. */
4281 /* Number of occurrences of this row in desired and current matrix. */
4282 int old_uses
, new_uses
;
4284 /* Vpos of row in new matrix. */
4285 int new_line_number
;
4287 /* Bucket index of this row_entry in the hash table row_table. */
4290 /* The row described by this entry. */
4291 struct glyph_row
*row
;
4293 /* Hash collision chain. */
4294 struct row_entry
*next
;
4297 /* A pool to allocate row_entry structures from, and the size of the
4298 pool. The pool is reallocated in scrolling_window when we find
4299 that we need a larger one. */
4301 static struct row_entry
*row_entry_pool
;
4302 static int row_entry_pool_size
;
4304 /* Index of next free entry in row_entry_pool. */
4306 static int row_entry_idx
;
4308 /* The hash table used during scrolling, and the table's size. This
4309 table is used to quickly identify equal rows in the desired and
4312 static struct row_entry
**row_table
;
4313 static int row_table_size
;
4315 /* Vectors of pointers to row_entry structures belonging to the
4316 current and desired matrix, and the size of the vectors. */
4318 static struct row_entry
**old_lines
, **new_lines
;
4319 static int old_lines_size
, new_lines_size
;
4321 /* A pool to allocate run structures from, and its size. */
4323 static struct run
*run_pool
;
4324 static int runs_size
;
4326 /* A vector of runs of lines found during scrolling. */
4328 static struct run
**runs
;
4330 static struct row_entry
*add_row_entry
P_ ((struct window
*,
4331 struct glyph_row
*));
4334 /* Add glyph row ROW to the scrolling hash table during the scrolling
4337 static INLINE
struct row_entry
*
4338 add_row_entry (w
, row
)
4340 struct glyph_row
*row
;
4342 struct row_entry
*entry
;
4343 int i
= row
->hash
% row_table_size
;
4345 entry
= row_table
[i
];
4346 while (entry
&& !row_equal_p (w
, entry
->row
, row
, 1))
4347 entry
= entry
->next
;
4351 entry
= row_entry_pool
+ row_entry_idx
++;
4353 entry
->old_uses
= entry
->new_uses
= 0;
4354 entry
->new_line_number
= 0;
4356 entry
->next
= row_table
[i
];
4357 row_table
[i
] = entry
;
4364 /* Try to reuse part of the current display of W by scrolling lines.
4365 HEADER_LINE_P non-zero means W has a top mode line.
4367 The algorithm is taken from Communications of the ACM, Apr78 "A
4368 Technique for Isolating Differences Between Files." It should take
4371 A short outline of the steps of the algorithm
4373 1. Skip lines equal at the start and end of both matrices.
4375 2. Enter rows in the current and desired matrix into a symbol
4376 table, counting how often they appear in both matrices.
4378 3. Rows that appear exactly once in both matrices serve as anchors,
4379 i.e. we assume that such lines are likely to have been moved.
4381 4. Starting from anchor lines, extend regions to be scrolled both
4382 forward and backward.
4386 -1 if all rows were found to be equal.
4387 0 to indicate that we did not scroll the display, or
4388 1 if we did scroll. */
4391 scrolling_window (w
, header_line_p
)
4395 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4396 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4397 int yb
= window_text_bottom_y (w
);
4398 int i
, j
, first_old
, first_new
, last_old
, last_new
;
4399 int nruns
, nbytes
, n
, run_idx
;
4400 struct row_entry
*entry
;
4402 /* Skip over rows equal at the start. */
4403 i
= header_line_p
? 1 : 0;
4404 while (i
< current_matrix
->nrows
- 1
4405 && MATRIX_ROW_ENABLED_P (current_matrix
, i
)
4406 && MATRIX_ROW_ENABLED_P (desired_matrix
, i
)
4407 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) <= yb
4408 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) <= yb
4410 MATRIX_ROW (desired_matrix
, i
),
4411 MATRIX_ROW (current_matrix
, i
), 1))
4413 assign_row (MATRIX_ROW (current_matrix
, i
),
4414 MATRIX_ROW (desired_matrix
, i
));
4415 MATRIX_ROW (desired_matrix
, i
)->enabled_p
= 0;
4419 /* Give up if some rows in the desired matrix are not enabled. */
4420 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4423 first_old
= first_new
= i
;
4425 /* Set last_new to the index + 1 of the last enabled row in the
4428 while (i
< desired_matrix
->nrows
- 1
4429 && MATRIX_ROW (desired_matrix
, i
)->enabled_p
4430 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) <= yb
)
4433 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4438 /* Set last_old to the index + 1 of the last enabled row in the
4439 current matrix. We don't look at the enabled flag here because
4440 we plan to reuse part of the display even if other parts are
4443 while (i
< current_matrix
->nrows
- 1
4444 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) <= yb
)
4448 /* Skip over rows equal at the bottom. */
4451 while (i
- 1 > first_new
4452 && j
- 1 > first_old
4453 && MATRIX_ROW (current_matrix
, i
- 1)->enabled_p
4454 && (MATRIX_ROW (current_matrix
, i
- 1)->y
4455 == MATRIX_ROW (desired_matrix
, j
- 1)->y
)
4457 MATRIX_ROW (desired_matrix
, i
- 1),
4458 MATRIX_ROW (current_matrix
, j
- 1), 1))
4463 /* Nothing to do if all rows are equal. */
4464 if (last_new
== first_new
)
4467 /* Reallocate vectors, tables etc. if necessary. */
4469 if (current_matrix
->nrows
> old_lines_size
)
4471 old_lines_size
= current_matrix
->nrows
;
4472 nbytes
= old_lines_size
* sizeof *old_lines
;
4473 old_lines
= (struct row_entry
**) xrealloc (old_lines
, nbytes
);
4476 if (desired_matrix
->nrows
> new_lines_size
)
4478 new_lines_size
= desired_matrix
->nrows
;
4479 nbytes
= new_lines_size
* sizeof *new_lines
;
4480 new_lines
= (struct row_entry
**) xrealloc (new_lines
, nbytes
);
4483 n
= desired_matrix
->nrows
+ current_matrix
->nrows
;
4484 if (3 * n
> row_table_size
)
4486 row_table_size
= next_almost_prime (3 * n
);
4487 nbytes
= row_table_size
* sizeof *row_table
;
4488 row_table
= (struct row_entry
**) xrealloc (row_table
, nbytes
);
4489 bzero (row_table
, nbytes
);
4492 if (n
> row_entry_pool_size
)
4494 row_entry_pool_size
= n
;
4495 nbytes
= row_entry_pool_size
* sizeof *row_entry_pool
;
4496 row_entry_pool
= (struct row_entry
*) xrealloc (row_entry_pool
, nbytes
);
4499 if (desired_matrix
->nrows
> runs_size
)
4501 runs_size
= desired_matrix
->nrows
;
4502 nbytes
= runs_size
* sizeof *runs
;
4503 runs
= (struct run
**) xrealloc (runs
, nbytes
);
4504 nbytes
= runs_size
* sizeof *run_pool
;
4505 run_pool
= (struct run
*) xrealloc (run_pool
, nbytes
);
4508 nruns
= run_idx
= 0;
4511 /* Add rows from the current and desired matrix to the hash table
4512 row_hash_table to be able to find equal ones quickly. */
4514 for (i
= first_old
; i
< last_old
; ++i
)
4516 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4518 entry
= add_row_entry (w
, MATRIX_ROW (current_matrix
, i
));
4519 old_lines
[i
] = entry
;
4523 old_lines
[i
] = NULL
;
4526 for (i
= first_new
; i
< last_new
; ++i
)
4528 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4529 entry
= add_row_entry (w
, MATRIX_ROW (desired_matrix
, i
));
4531 entry
->new_line_number
= i
;
4532 new_lines
[i
] = entry
;
4535 /* Identify moves based on lines that are unique and equal
4536 in both matrices. */
4537 for (i
= first_old
; i
< last_old
;)
4539 && old_lines
[i
]->old_uses
== 1
4540 && old_lines
[i
]->new_uses
== 1)
4543 int new_line
= old_lines
[i
]->new_line_number
;
4544 struct run
*run
= run_pool
+ run_idx
++;
4547 run
->current_vpos
= i
;
4548 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4549 run
->desired_vpos
= new_line
;
4550 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4552 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4554 /* Extend backward. */
4557 while (j
> first_old
4559 && old_lines
[j
] == new_lines
[k
])
4561 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4562 --run
->current_vpos
;
4563 --run
->desired_vpos
;
4566 run
->desired_y
-= h
;
4567 run
->current_y
-= h
;
4571 /* Extend forward. */
4576 && old_lines
[j
] == new_lines
[k
])
4578 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4584 /* Insert run into list of all runs. Order runs by copied
4585 pixel lines. Note that we record runs that don't have to
4586 be copied because they are already in place. This is done
4587 because we can avoid calling update_window_line in this
4589 for (j
= 0; j
< nruns
&& runs
[j
]->height
> run
->height
; ++j
)
4591 for (k
= nruns
; k
>= j
; --k
)
4592 runs
[k
] = runs
[k
- 1];
4601 /* Do the moves. Do it in a way that we don't overwrite something
4602 we want to copy later on. This is not solvable in general
4603 because there is only one display and we don't have a way to
4604 exchange areas on this display. Example:
4606 +-----------+ +-----------+
4608 +-----------+ --> +-----------+
4610 +-----------+ +-----------+
4612 Instead, prefer bigger moves, and invalidate moves that would
4613 copy from where we copied to. */
4615 for (i
= 0; i
< nruns
; ++i
)
4616 if (runs
[i
]->nrows
> 0)
4618 struct run
*r
= runs
[i
];
4620 /* Copy on the display. */
4621 if (r
->current_y
!= r
->desired_y
)
4623 rif
->scroll_run_hook (w
, r
);
4625 /* Invalidate runs that copy from where we copied to. */
4626 for (j
= i
+ 1; j
< nruns
; ++j
)
4628 struct run
*p
= runs
[j
];
4630 if ((p
->current_y
>= r
->desired_y
4631 && p
->current_y
< r
->desired_y
+ r
->height
)
4632 || (p
->current_y
+ p
->height
>= r
->desired_y
4633 && (p
->current_y
+ p
->height
4634 < r
->desired_y
+ r
->height
)))
4639 /* Assign matrix rows. */
4640 for (j
= 0; j
< r
->nrows
; ++j
)
4642 struct glyph_row
*from
, *to
;
4643 int to_overlapped_p
;
4645 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
4646 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
4647 to_overlapped_p
= to
->overlapped_p
;
4648 assign_row (to
, from
);
4649 to
->enabled_p
= 1, from
->enabled_p
= 0;
4650 to
->overlapped_p
= to_overlapped_p
;
4654 /* Clear the hash table, for the next time. */
4655 for (i
= 0; i
< row_entry_idx
; ++i
)
4656 row_table
[row_entry_pool
[i
].bucket
] = NULL
;
4658 /* Value is non-zero to indicate that we scrolled the display. */
4664 /************************************************************************
4666 ************************************************************************/
4668 /* Update the desired frame matrix of frame F.
4670 FORCE_P non-zero means that the update should not be stopped by
4671 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
4672 should not be tried.
4674 Value is non-zero if update was stopped due to pending input. */
4677 update_frame_1 (f
, force_p
, inhibit_id_p
)
4682 /* Frame matrices to work on. */
4683 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4684 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4687 int preempt_count
= baud_rate
/ 2400 + 1;
4688 extern int input_pending
;
4690 xassert (current_matrix
&& desired_matrix
);
4692 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
4693 calculate_costs (f
);
4695 if (preempt_count
<= 0)
4698 if (redisplay_dont_pause
)
4700 else if (!force_p
&& detect_input_pending ())
4708 /* If we cannot insert/delete lines, it's no use trying it. */
4709 if (!line_ins_del_ok
)
4712 /* See if any of the desired lines are enabled; don't compute for
4713 i/d line if just want cursor motion. */
4714 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
4715 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4718 /* Try doing i/d line, if not yet inhibited. */
4719 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
4720 force_p
|= scrolling (f
);
4722 /* Update the individual lines as needed. Do bottom line first. */
4723 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
4724 update_frame_line (f
, desired_matrix
->nrows
- 1);
4726 /* Now update the rest of the lines. */
4727 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
4729 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4731 if (FRAME_TERMCAP_P (f
))
4733 /* Flush out every so many lines.
4734 Also flush out if likely to have more than 1k buffered
4735 otherwise. I'm told that some telnet connections get
4736 really screwed by more than 1k output at once. */
4737 int outq
= PENDING_OUTPUT_COUNT (stdout
);
4739 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
4742 if (preempt_count
== 1)
4744 #ifdef EMACS_OUTQSIZE
4745 if (EMACS_OUTQSIZE (0, &outq
) < 0)
4746 /* Probably not a tty. Ignore the error and reset
4747 * the outq count. */
4748 outq
= PENDING_OUTPUT_COUNT (stdout
);
4751 if (baud_rate
<= outq
&& baud_rate
> 0)
4752 sleep (outq
/ baud_rate
);
4757 if ((i
- 1) % preempt_count
== 0)
4758 detect_input_pending ();
4760 update_frame_line (f
, i
);
4764 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
4766 /* Now just clean up termcap drivers and set cursor, etc. */
4769 if ((cursor_in_echo_area
4770 /* If we are showing a message instead of the mini-buffer,
4771 show the cursor for the message instead of for the
4772 (now hidden) mini-buffer contents. */
4773 || (EQ (minibuf_window
, selected_window
)
4774 && EQ (minibuf_window
, echo_area_window
)
4775 && !NILP (echo_area_buffer
[0])))
4776 /* These cases apply only to the frame that contains
4777 the active mini-buffer window. */
4778 && FRAME_HAS_MINIBUF_P (f
)
4779 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4781 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
4784 if (cursor_in_echo_area
< 0)
4786 /* Negative value of cursor_in_echo_area means put
4787 cursor at beginning of line. */
4793 /* Positive value of cursor_in_echo_area means put
4794 cursor at the end of the prompt. If the mini-buffer
4795 is several lines high, find the last line that has
4797 row
= FRAME_HEIGHT (f
);
4803 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
4805 /* Frame rows are filled up with spaces that
4806 must be ignored here. */
4807 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
4809 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
4810 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
4813 && (last
- 1)->charpos
< 0)
4819 while (row
> top
&& col
== 0);
4821 /* Make sure COL is not out of range. */
4822 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
4824 /* If we have another row, advance cursor into it. */
4825 if (row
< FRAME_HEIGHT (f
) - 1)
4827 col
= FRAME_LEFT_SCROLL_BAR_WIDTH (f
);
4830 /* Otherwise move it back in range. */
4832 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
4836 cursor_to (row
, col
);
4840 /* We have only one cursor on terminal frames. Use it to
4841 display the cursor of the selected window. */
4842 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
4843 if (w
->cursor
.vpos
>= 0
4844 /* The cursor vpos may be temporarily out of bounds
4845 in the following situation: There is one window,
4846 with the cursor in the lower half of it. The window
4847 is split, and a message causes a redisplay before
4848 a new cursor position has been computed. */
4849 && w
->cursor
.vpos
< XFASTINT (w
->height
))
4851 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
4852 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
4854 if (INTEGERP (w
->left_margin_width
))
4855 x
+= XFASTINT (w
->left_margin_width
);
4857 /* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
4866 fflush (termscript
);
4871 display_completed
= !pause
;
4872 clear_desired_matrices (f
);
4877 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4881 struct frame
*frame
;
4883 int unchanged_at_top
, unchanged_at_bottom
;
4886 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4887 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4888 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4889 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4891 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
4892 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4893 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4895 if (!current_matrix
)
4898 /* Compute hash codes of all the lines. Also calculate number of
4899 changed lines, number of unchanged lines at the beginning, and
4900 number of unchanged lines at the end. */
4902 unchanged_at_top
= 0;
4903 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
4904 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
4906 /* Give up on this scrolling if some old lines are not enabled. */
4907 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
4909 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
4910 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4912 /* This line cannot be redrawn, so don't let scrolling mess it. */
4913 new_hash
[i
] = old_hash
[i
];
4914 #define INFINITY 1000000 /* Taken from scroll.c */
4915 draw_cost
[i
] = INFINITY
;
4919 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
4920 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
4923 if (old_hash
[i
] != new_hash
[i
])
4926 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
4928 else if (i
== unchanged_at_top
)
4930 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
4933 /* If changed lines are few, don't allow preemption, don't scroll. */
4934 if ((!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400)
4935 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
4938 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
4939 - unchanged_at_bottom
);
4941 if (scroll_region_ok
)
4942 free_at_end_vpos
-= unchanged_at_bottom
;
4943 else if (memory_below_frame
)
4944 free_at_end_vpos
= -1;
4946 /* If large window, fast terminal and few lines in common between
4947 current frame and desired frame, don't bother with i/d calc. */
4948 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
4950 10 * scrolling_max_lines_saved (unchanged_at_top
,
4951 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
4952 old_hash
, new_hash
, draw_cost
)))
4955 if (window_size
< 2)
4958 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
4959 draw_cost
+ unchanged_at_top
- 1,
4960 old_draw_cost
+ unchanged_at_top
- 1,
4961 old_hash
+ unchanged_at_top
- 1,
4962 new_hash
+ unchanged_at_top
- 1,
4963 free_at_end_vpos
- unchanged_at_top
);
4969 /* Count the number of blanks at the start of the vector of glyphs R
4970 which is LEN glyphs long. */
4973 count_blanks (r
, len
)
4979 for (i
= 0; i
< len
; ++i
)
4980 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
4987 /* Count the number of glyphs in common at the start of the glyph
4988 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
4989 of STR2. Value is the number of equal glyphs equal at the start. */
4992 count_match (str1
, end1
, str2
, end2
)
4993 struct glyph
*str1
, *end1
, *str2
, *end2
;
4995 struct glyph
*p1
= str1
;
4996 struct glyph
*p2
= str2
;
5000 && GLYPH_CHAR_AND_FACE_EQUAL_P (p1
, p2
))
5007 /* Char insertion/deletion cost vector, from term.c */
5009 extern int *char_ins_del_vector
;
5010 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
5013 /* Perform a frame-based update on line VPOS in frame FRAME. */
5016 update_frame_line (frame
, vpos
)
5017 register struct frame
*frame
;
5020 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
5022 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
5023 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
5024 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
5025 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
5026 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
5027 int must_write_whole_line_p
;
5029 if (desired_row
->inverse_p
5030 != (current_row
->enabled_p
&& current_row
->inverse_p
))
5032 int n
= current_row
->enabled_p
? current_row
->used
[TEXT_AREA
] : 0;
5033 change_line_highlight (desired_row
->inverse_p
, vpos
, vpos
, n
);
5034 current_row
->enabled_p
= 0;
5037 reassert_line_highlight (desired_row
->inverse_p
, vpos
);
5039 /* Current row not enabled means it has unknown contents. We must
5040 write the whole desired line in that case. */
5041 must_write_whole_line_p
= !current_row
->enabled_p
;
5042 if (must_write_whole_line_p
)
5049 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
5050 olen
= current_row
->used
[TEXT_AREA
];
5052 if (! current_row
->inverse_p
)
5054 /* Ignore trailing spaces, if we can. */
5055 if (!must_write_spaces
)
5056 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
5061 /* For an inverse-video line, make sure it's filled with
5062 spaces all the way to the frame edge so that the reverse
5063 video extends all the way across. */
5064 while (olen
< FRAME_WIDTH (frame
) - 1)
5065 obody
[olen
++] = space_glyph
;
5069 current_row
->enabled_p
= 1;
5070 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
5071 current_row
->inverse_p
= desired_row
->inverse_p
;
5073 /* If desired line is empty, just clear the line. */
5074 if (!desired_row
->enabled_p
)
5080 nbody
= desired_row
->glyphs
[TEXT_AREA
];
5081 nlen
= desired_row
->used
[TEXT_AREA
];
5082 nend
= nbody
+ nlen
;
5084 /* If display line has unknown contents, write the whole line. */
5085 if (must_write_whole_line_p
)
5087 /* Ignore spaces at the end, if we can. */
5088 if (!must_write_spaces
)
5089 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5092 /* Write the contents of the desired line. */
5095 cursor_to (vpos
, 0);
5096 write_glyphs (nbody
, nlen
);
5099 /* Don't call clear_end_of_line if we already wrote the whole
5100 line. The cursor will not be at the right margin in that
5101 case but in the line below. */
5102 if (nlen
< FRAME_WINDOW_WIDTH (frame
))
5104 cursor_to (vpos
, nlen
);
5105 clear_end_of_line (FRAME_WINDOW_WIDTH (frame
));
5108 /* Make sure we are in the right row, otherwise cursor movement
5109 with cmgoto might use `ch' in the wrong row. */
5110 cursor_to (vpos
, 0);
5112 make_current (desired_matrix
, current_matrix
, vpos
);
5116 /* Pretend trailing spaces are not there at all,
5117 unless for one reason or another we must write all spaces. */
5118 if (!desired_row
->inverse_p
)
5120 if (!must_write_spaces
)
5121 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5126 /* For an inverse-video line, give it extra trailing spaces all
5127 the way to the frame edge so that the reverse video extends
5128 all the way across. */
5129 while (nlen
< FRAME_WIDTH (frame
) - 1)
5130 nbody
[nlen
++] = space_glyph
;
5133 /* If there's no i/d char, quickly do the best we can without it. */
5134 if (!char_ins_del_ok
)
5138 /* Find the first glyph in desired row that doesn't agree with
5139 a glyph in the current row, and write the rest from there on. */
5140 for (i
= 0; i
< nlen
; i
++)
5142 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
5144 /* Find the end of the run of different glyphs. */
5148 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
5149 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
5152 /* Output this run of non-matching chars. */
5153 cursor_to (vpos
, i
);
5154 write_glyphs (nbody
+ i
, j
- i
);
5157 /* Now find the next non-match. */
5161 /* Clear the rest of the line, or the non-clear part of it. */
5164 cursor_to (vpos
, nlen
);
5165 clear_end_of_line (olen
);
5168 /* Make current row = desired row. */
5169 make_current (desired_matrix
, current_matrix
, vpos
);
5173 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
5174 characters in a row. */
5178 /* If current line is blank, skip over initial spaces, if
5179 possible, and write the rest. */
5180 if (must_write_spaces
|| desired_row
->inverse_p
)
5183 nsp
= count_blanks (nbody
, nlen
);
5187 cursor_to (vpos
, nsp
);
5188 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
5191 /* Exchange contents between current_frame and new_frame. */
5192 make_current (desired_matrix
, current_matrix
, vpos
);
5196 /* Compute number of leading blanks in old and new contents. */
5197 osp
= count_blanks (obody
, olen
);
5198 nsp
= desired_row
->inverse_p
? 0 : count_blanks (nbody
, nlen
);
5200 /* Compute number of matching chars starting with first non-blank. */
5201 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
5202 nbody
+ nsp
, nbody
+ nlen
);
5204 /* Spaces in new match implicit space past the end of old. */
5205 /* A bug causing this to be a no-op was fixed in 18.29. */
5206 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
5209 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
5213 /* Avoid doing insert/delete char
5214 just cause number of leading spaces differs
5215 when the following text does not match. */
5216 if (begmatch
== 0 && osp
!= nsp
)
5217 osp
= nsp
= min (osp
, nsp
);
5219 /* Find matching characters at end of line */
5222 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
5224 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
5229 endmatch
= obody
+ olen
- op1
;
5231 /* tem gets the distance to insert or delete.
5232 endmatch is how many characters we save by doing so.
5235 tem
= (nlen
- nsp
) - (olen
- osp
);
5237 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
5240 /* nsp - osp is the distance to insert or delete.
5241 If that is nonzero, begmatch is known to be nonzero also.
5242 begmatch + endmatch is how much we save by doing the ins/del.
5246 && (!char_ins_del_ok
5247 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
5251 osp
= nsp
= min (osp
, nsp
);
5254 /* Now go through the line, inserting, writing and
5255 deleting as appropriate. */
5259 cursor_to (vpos
, nsp
);
5260 delete_glyphs (osp
- nsp
);
5264 /* If going to delete chars later in line
5265 and insert earlier in the line,
5266 must delete first to avoid losing data in the insert */
5267 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
5269 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
5270 delete_glyphs (olen
+ nsp
- osp
- nlen
);
5271 olen
= nlen
- (nsp
- osp
);
5273 cursor_to (vpos
, osp
);
5274 insert_glyphs (0, nsp
- osp
);
5278 tem
= nsp
+ begmatch
+ endmatch
;
5279 if (nlen
!= tem
|| olen
!= tem
)
5281 cursor_to (vpos
, nsp
+ begmatch
);
5282 if (!endmatch
|| nlen
== olen
)
5284 /* If new text being written reaches right margin,
5285 there is no need to do clear-to-eol at the end.
5286 (and it would not be safe, since cursor is not
5287 going to be "at the margin" after the text is done) */
5288 if (nlen
== FRAME_WINDOW_WIDTH (frame
))
5290 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5292 else if (nlen
> olen
)
5294 /* Here, we used to have the following simple code:
5295 ----------------------------------------
5296 write_glyphs (nbody + nsp + begmatch, olen - tem);
5297 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5298 ----------------------------------------
5299 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5300 is a padding glyph. */
5301 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5304 /* Calculate columns we can actually overwrite. */
5305 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
])) out
--;
5306 write_glyphs (nbody
+ nsp
+ begmatch
, out
);
5307 /* If we left columns to be overwritten, we must delete them. */
5308 del
= olen
- tem
- out
;
5309 if (del
> 0) delete_glyphs (del
);
5310 /* At last, we insert columns not yet written out. */
5311 insert_glyphs (nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5314 else if (olen
> nlen
)
5316 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5317 delete_glyphs (olen
- nlen
);
5323 /* If any unerased characters remain after the new line, erase them. */
5326 cursor_to (vpos
, nlen
);
5327 clear_end_of_line (olen
);
5330 /* Exchange contents between current_frame and new_frame. */
5331 make_current (desired_matrix
, current_matrix
, vpos
);
5336 /***********************************************************************
5337 X/Y Position -> Buffer Position
5338 ***********************************************************************/
5340 /* Return the character position of the character at window relative
5341 pixel position (*X, *Y). *X and *Y are adjusted to character
5345 buffer_posn_from_coords (w
, x
, y
)
5350 struct buffer
*old_current_buffer
= current_buffer
;
5351 struct text_pos startp
;
5352 int left_area_width
;
5354 current_buffer
= XBUFFER (w
->buffer
);
5355 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5356 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5357 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5358 start_display (&it
, w
, startp
);
5360 left_area_width
= WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH (w
);
5361 move_it_to (&it
, -1, *x
+ it
.first_visible_x
- left_area_width
, *y
, -1,
5362 MOVE_TO_X
| MOVE_TO_Y
);
5364 *x
= it
.current_x
- it
.first_visible_x
+ left_area_width
;
5366 current_buffer
= old_current_buffer
;
5367 return IT_CHARPOS (it
);
5371 /* Value is the string under window-relative coordinates X/Y in the
5372 mode or top line of window W, or nil if none. MODE_LINE_P non-zero
5373 means look at the mode line. *CHARPOS is set to the position in
5374 the string returned. */
5377 mode_line_string (w
, x
, y
, mode_line_p
, charpos
)
5379 int x
, y
, mode_line_p
;
5382 struct glyph_row
*row
;
5383 struct glyph
*glyph
, *end
;
5384 struct frame
*f
= XFRAME (w
->frame
);
5386 Lisp_Object string
= Qnil
;
5389 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5391 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
5393 if (row
->mode_line_p
&& row
->enabled_p
)
5395 /* The mode lines are displayed over scroll bars and bitmap
5396 areas, and X is window-relative. Correct X by the scroll bar
5397 and bitmap area width. */
5398 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
5399 x
+= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
5400 x
+= FRAME_LEFT_FLAGS_AREA_WIDTH (f
);
5402 /* Find the glyph under X. If we find one with a string object,
5403 it's the one we were looking for. */
5404 glyph
= row
->glyphs
[TEXT_AREA
];
5405 end
= glyph
+ row
->used
[TEXT_AREA
];
5406 for (x0
= 0; glyph
< end
; x0
+= glyph
->pixel_width
, ++glyph
)
5407 if (x
>= x0
&& x
< x0
+ glyph
->pixel_width
)
5409 string
= glyph
->object
;
5410 *charpos
= glyph
->charpos
;
5419 /***********************************************************************
5420 Changing Frame Sizes
5421 ***********************************************************************/
5426 window_change_signal (signalnum
) /* If we don't have an argument, */
5427 int signalnum
; /* some compilers complain in signal calls. */
5431 int old_errno
= errno
;
5433 get_frame_size (&width
, &height
);
5435 /* The frame size change obviously applies to a termcap-controlled
5436 frame. Find such a frame in the list, and assume it's the only
5437 one (since the redisplay code always writes to stdout, not a
5438 FILE * specified in the frame structure). Record the new size,
5439 but don't reallocate the data structures now. Let that be done
5440 later outside of the signal handler. */
5443 Lisp_Object tail
, frame
;
5445 FOR_EACH_FRAME (tail
, frame
)
5447 if (FRAME_TERMCAP_P (XFRAME (frame
)))
5449 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5455 signal (SIGWINCH
, window_change_signal
);
5458 #endif /* SIGWINCH */
5461 /* Do any change in frame size that was requested by a signal. SAFE
5462 non-zero means this function is called from a place where it is
5463 safe to change frame sizes while a redisplay is in progress. */
5466 do_pending_window_change (safe
)
5469 /* If window_change_signal should have run before, run it now. */
5470 if (redisplaying_p
&& !safe
)
5473 while (delayed_size_change
)
5475 Lisp_Object tail
, frame
;
5477 delayed_size_change
= 0;
5479 FOR_EACH_FRAME (tail
, frame
)
5481 struct frame
*f
= XFRAME (frame
);
5483 int height
= FRAME_NEW_HEIGHT (f
);
5484 int width
= FRAME_NEW_WIDTH (f
);
5486 if (height
!= 0 || width
!= 0)
5487 change_frame_size (f
, height
, width
, 0, 0, safe
);
5493 /* Change the frame height and/or width. Values may be given as zero to
5494 indicate no change is to take place.
5496 If DELAY is non-zero, then assume we're being called from a signal
5497 handler, and queue the change for later - perhaps the next
5498 redisplay. Since this tries to resize windows, we can't call it
5499 from a signal handler.
5501 SAFE non-zero means this function is called from a place where it's
5502 safe to change frame sizes while a redisplay is in progress. */
5505 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5506 register struct frame
*f
;
5507 int newheight
, newwidth
, pretend
, delay
, safe
;
5509 Lisp_Object tail
, frame
;
5511 if (! FRAME_WINDOW_P (f
))
5513 /* When using termcap, or on MS-DOS, all frames use
5514 the same screen, so a change in size affects all frames. */
5515 FOR_EACH_FRAME (tail
, frame
)
5516 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5517 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5518 pretend
, delay
, safe
);
5521 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
5525 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5526 register struct frame
*f
;
5527 int newheight
, newwidth
, pretend
, delay
, safe
;
5529 int new_frame_window_width
;
5530 int count
= specpdl_ptr
- specpdl
;
5532 /* If we can't deal with the change now, queue it for later. */
5533 if (delay
|| (redisplaying_p
&& !safe
))
5535 FRAME_NEW_HEIGHT (f
) = newheight
;
5536 FRAME_NEW_WIDTH (f
) = newwidth
;
5537 delayed_size_change
= 1;
5541 /* This size-change overrides any pending one for this frame. */
5542 FRAME_NEW_HEIGHT (f
) = 0;
5543 FRAME_NEW_WIDTH (f
) = 0;
5545 /* If an argument is zero, set it to the current value. */
5547 newheight
= FRAME_HEIGHT (f
);
5549 newwidth
= FRAME_WIDTH (f
);
5551 /* Compute width of windows in F.
5552 This is the width of the frame without vertical scroll bars. */
5553 new_frame_window_width
= FRAME_WINDOW_WIDTH_ARG (f
, newwidth
);
5555 /* Round up to the smallest acceptable size. */
5556 check_frame_size (f
, &newheight
, &newwidth
);
5558 /* If we're not changing the frame size, quit now. */
5559 if (newheight
== FRAME_HEIGHT (f
)
5560 && new_frame_window_width
== FRAME_WINDOW_WIDTH (f
))
5566 /* We only can set screen dimensions to certain values supported
5567 by our video hardware. Try to find the smallest size greater
5568 or equal to the requested dimensions. */
5569 dos_set_window_size (&newheight
, &newwidth
);
5572 if (newheight
!= FRAME_HEIGHT (f
))
5574 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
5576 /* Frame has both root and mini-buffer. */
5577 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f
))->top
,
5578 FRAME_TOP_MARGIN (f
));
5579 set_window_height (FRAME_ROOT_WINDOW (f
),
5582 - FRAME_TOP_MARGIN (f
)),
5584 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
,
5586 set_window_height (FRAME_MINIBUF_WINDOW (f
), 1, 0);
5589 /* Frame has just one top-level window. */
5590 set_window_height (FRAME_ROOT_WINDOW (f
),
5591 newheight
- FRAME_TOP_MARGIN (f
), 0);
5593 if (FRAME_TERMCAP_P (f
) && !pretend
)
5594 FrameRows
= newheight
;
5597 if (new_frame_window_width
!= FRAME_WINDOW_WIDTH (f
))
5599 set_window_width (FRAME_ROOT_WINDOW (f
), new_frame_window_width
, 0);
5600 if (FRAME_HAS_MINIBUF_P (f
))
5601 set_window_width (FRAME_MINIBUF_WINDOW (f
), new_frame_window_width
, 0);
5603 if (FRAME_TERMCAP_P (f
) && !pretend
)
5604 FrameCols
= newwidth
;
5606 if (WINDOWP (f
->tool_bar_window
))
5607 XSETFASTINT (XWINDOW (f
->tool_bar_window
)->width
, newwidth
);
5610 FRAME_HEIGHT (f
) = newheight
;
5611 SET_FRAME_WIDTH (f
, newwidth
);
5614 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5615 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
5617 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
5619 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
5620 w
->cursor
.hpos
= w
->cursor
.x
= 0;
5621 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
5622 w
->cursor
.vpos
= w
->cursor
.y
= 0;
5626 SET_FRAME_GARBAGED (f
);
5627 calculate_costs (f
);
5631 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
5633 /* This isn't quite a no-op: it runs window-configuration-change-hook. */
5634 Fset_window_buffer (FRAME_SELECTED_WINDOW (f
),
5635 XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
);
5637 unbind_to (count
, Qnil
);
5642 /***********************************************************************
5643 Terminal Related Lisp Functions
5644 ***********************************************************************/
5646 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
5647 1, 1, "FOpen termscript file: ",
5648 "Start writing all terminal output to FILE as well as the terminal.\n\
5649 FILE = nil means just close any termscript file currently open.")
5653 if (termscript
!= 0) fclose (termscript
);
5658 file
= Fexpand_file_name (file
, Qnil
);
5659 termscript
= fopen (XSTRING (file
)->data
, "w");
5660 if (termscript
== 0)
5661 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
5667 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
5668 Ssend_string_to_terminal
, 1, 1, 0,
5669 "Send STRING to the terminal without alteration.\n\
5670 Control characters in STRING will have terminal-dependent effects.")
5674 /* ??? Perhaps we should do something special for multibyte strings here. */
5675 CHECK_STRING (string
, 0);
5676 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)), stdout
);
5680 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)),
5682 fflush (termscript
);
5688 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
5689 "Beep, or flash the screen.\n\
5690 Also, unless an argument is given,\n\
5691 terminate any keyboard macro currently executing.")
5714 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
5715 error ("Keyboard macro terminated by a command ringing the bell");
5723 /***********************************************************************
5725 ***********************************************************************/
5727 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
5728 "Pause, without updating display, for SECONDS seconds.\n\
5729 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5730 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5731 additional wait period, in milliseconds; this may be useful if your\n\
5732 Emacs was built without floating point support.\n\
5733 \(Not all operating systems support waiting for a fraction of a second.)")
5734 (seconds
, milliseconds
)
5735 Lisp_Object seconds
, milliseconds
;
5739 if (NILP (milliseconds
))
5740 XSETINT (milliseconds
, 0);
5742 CHECK_NUMBER (milliseconds
, 1);
5743 usec
= XINT (milliseconds
) * 1000;
5746 double duration
= extract_float (seconds
);
5747 sec
= (int) duration
;
5748 usec
+= (duration
- sec
) * 1000000;
5751 #ifndef EMACS_HAS_USECS
5752 if (sec
== 0 && usec
!= 0)
5753 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
5756 /* Assure that 0 <= usec < 1000000. */
5759 /* We can't rely on the rounding being correct if user is negative. */
5760 if (-1000000 < usec
)
5761 sec
--, usec
+= 1000000;
5763 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
5766 sec
+= usec
/ 1000000, usec
%= 1000000;
5768 if (sec
< 0 || (sec
== 0 && usec
== 0))
5774 XSETFASTINT (zero
, 0);
5775 wait_reading_process_input (sec
, usec
, zero
, 0);
5778 /* We should always have wait_reading_process_input; we have a dummy
5779 implementation for systems which don't support subprocesses. */
5781 /* No wait_reading_process_input */
5788 /* The reason this is done this way
5789 (rather than defined (H_S) && defined (H_T))
5790 is because the VMS preprocessor doesn't grok `defined' */
5792 EMACS_GET_TIME (end_time
);
5793 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
5794 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
5798 EMACS_GET_TIME (timeout
);
5799 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
5800 if (EMACS_TIME_NEG_P (timeout
)
5801 || !select (1, 0, 0, 0, &timeout
))
5804 #else /* not HAVE_SELECT */
5806 #endif /* HAVE_SELECT */
5807 #endif /* not VMS */
5810 #endif /* no subprocesses */
5816 /* This is just like wait_reading_process_input, except that
5817 it does the redisplay.
5819 It's also much like Fsit_for, except that it can be used for
5820 waiting for input as well. */
5823 sit_for (sec
, usec
, reading
, display
, initial_display
)
5824 int sec
, usec
, reading
, display
, initial_display
;
5826 Lisp_Object read_kbd
;
5828 swallow_events (display
);
5830 if (detect_input_pending_run_timers (display
))
5833 if (initial_display
)
5834 redisplay_preserve_echo_area ();
5836 if (sec
== 0 && usec
== 0)
5843 XSETINT (read_kbd
, reading
? -1 : 1);
5844 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
5846 return detect_input_pending () ? Qnil
: Qt
;
5850 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
5851 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
5852 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5853 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5854 additional wait period, in milliseconds; this may be useful if your\n\
5855 Emacs was built without floating point support.\n\
5856 \(Not all operating systems support waiting for a fraction of a second.)\n\
5857 Optional third arg NODISP non-nil means don't redisplay, just wait for input.\n\
5858 Redisplay is preempted as always if input arrives, and does not happen\n\
5859 if input is available before it starts.\n\
5860 Value is t if waited the full time with no input arriving.")
5861 (seconds
, milliseconds
, nodisp
)
5862 Lisp_Object seconds
, milliseconds
, nodisp
;
5866 if (NILP (milliseconds
))
5867 XSETINT (milliseconds
, 0);
5869 CHECK_NUMBER (milliseconds
, 1);
5870 usec
= XINT (milliseconds
) * 1000;
5873 double duration
= extract_float (seconds
);
5874 sec
= (int) duration
;
5875 usec
+= (duration
- sec
) * 1000000;
5878 #ifndef EMACS_HAS_USECS
5879 if (usec
!= 0 && sec
== 0)
5880 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
5883 return sit_for (sec
, usec
, 0, NILP (nodisp
), NILP (nodisp
));
5888 /***********************************************************************
5889 Other Lisp Functions
5890 ***********************************************************************/
5892 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
5893 session's frames, frame names, buffers, buffer-read-only flags, and
5894 buffer-modified-flags, and a trailing sentinel (so we don't need to
5895 add length checks). */
5897 static Lisp_Object frame_and_buffer_state
;
5900 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
5901 Sframe_or_buffer_changed_p
, 0, 0, 0,
5902 "Return non-nil if the frame and buffer state appears to have changed.\n\
5903 The state variable is an internal vector containing all frames and buffers,\n\
5904 aside from buffers whose names start with space,\n\
5905 along with the buffers' read-only and modified flags, which allows a fast\n\
5906 check to see whether the menu bars might need to be recomputed.\n\
5907 If this function returns non-nil, it updates the internal vector to reflect\n\
5908 the current state.\n")
5911 Lisp_Object tail
, frame
, buf
;
5915 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5916 FOR_EACH_FRAME (tail
, frame
)
5918 if (!EQ (*vecp
++, frame
))
5920 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
5923 /* Check that the buffer info matches.
5924 No need to test for the end of the vector
5925 because the last element of the vector is lambda
5926 and that will always cause a mismatch. */
5927 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5929 buf
= XCDR (XCAR (tail
));
5930 /* Ignore buffers that aren't included in buffer lists. */
5931 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5933 if (!EQ (*vecp
++, buf
))
5935 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
5937 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
5940 /* Detect deletion of a buffer at the end of the list. */
5941 if (EQ (*vecp
, Qlambda
))
5944 /* Start with 1 so there is room for at least one lambda at the end. */
5946 FOR_EACH_FRAME (tail
, frame
)
5948 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5950 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
5951 if (n
> XVECTOR (frame_and_buffer_state
)->size
5952 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
5953 /* Add 20 extra so we grow it less often. */
5954 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
5955 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5956 FOR_EACH_FRAME (tail
, frame
)
5959 *vecp
++ = XFRAME (frame
)->name
;
5961 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5963 buf
= XCDR (XCAR (tail
));
5964 /* Ignore buffers that aren't included in buffer lists. */
5965 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5968 *vecp
++ = XBUFFER (buf
)->read_only
;
5969 *vecp
++ = Fbuffer_modified_p (buf
);
5971 /* Fill up the vector with lambdas (always at least one). */
5973 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5974 < XVECTOR (frame_and_buffer_state
)->size
)
5976 /* Make sure we didn't overflow the vector. */
5977 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5978 > XVECTOR (frame_and_buffer_state
)->size
)
5985 /***********************************************************************
5987 ***********************************************************************/
5989 char *terminal_type
;
5991 /* Initialization done when Emacs fork is started, before doing stty.
5992 Determine terminal type and set terminal_driver. Then invoke its
5993 decoding routine to set up variables in the terminal package. */
5998 #ifdef HAVE_X_WINDOWS
5999 extern int display_arg
;
6002 /* Construct the space glyph. */
6003 space_glyph
.type
= CHAR_GLYPH
;
6004 SET_CHAR_GLYPH_FROM_GLYPH (space_glyph
, ' ');
6005 space_glyph
.charpos
= -1;
6009 cursor_in_echo_area
= 0;
6010 terminal_type
= (char *) 0;
6012 /* Now is the time to initialize this; it's used by init_sys_modes
6014 Vwindow_system
= Qnil
;
6016 /* If the user wants to use a window system, we shouldn't bother
6017 initializing the terminal. This is especially important when the
6018 terminal is so dumb that emacs gives up before and doesn't bother
6019 using the window system.
6021 If the DISPLAY environment variable is set and nonempty,
6022 try to use X, and die with an error message if that doesn't work. */
6024 #ifdef HAVE_X_WINDOWS
6029 display
= getenv ("DECW$DISPLAY");
6031 display
= getenv ("DISPLAY");
6034 display_arg
= (display
!= 0 && *display
!= 0);
6037 if (!inhibit_window_system
&& display_arg
6043 Vwindow_system
= intern ("x");
6045 Vwindow_system_version
= make_number (11);
6047 Vwindow_system_version
= make_number (10);
6049 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
6050 /* In some versions of ncurses,
6051 tputs crashes if we have not called tgetent.
6053 { char b
[2044]; tgetent (b
, "xterm");}
6055 adjust_frame_glyphs_initially ();
6058 #endif /* HAVE_X_WINDOWS */
6061 if (!inhibit_window_system
)
6063 Vwindow_system
= intern ("w32");
6064 Vwindow_system_version
= make_number (1);
6065 adjust_frame_glyphs_initially ();
6068 #endif /* HAVE_NTGUI */
6070 /* If no window system has been specified, try to use the terminal. */
6073 fatal ("standard input is not a tty");
6077 /* Look at the TERM variable */
6078 terminal_type
= (char *) getenv ("TERM");
6082 fprintf (stderr
, "Please specify your terminal type.\n\
6083 For types defined in VMS, use set term /device=TYPE.\n\
6084 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
6085 \(The quotation marks are necessary since terminal types are lower case.)\n");
6087 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
6093 /* VMS DCL tends to up-case things, so down-case term type.
6094 Hardly any uppercase letters in terminal types; should be none. */
6096 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
6099 strcpy (new, terminal_type
);
6101 for (p
= new; *p
; p
++)
6105 terminal_type
= new;
6109 term_init (terminal_type
);
6112 struct frame
*sf
= SELECTED_FRAME ();
6113 int width
= FRAME_WINDOW_WIDTH (sf
);
6114 int height
= FRAME_HEIGHT (sf
);
6116 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (struct glyph
);
6118 /* If these sizes are so big they cause overflow, just ignore the
6119 change. It's not clear what better we could do. */
6120 if (total_glyphs
/ sizeof (struct glyph
) / height
!= width
+ 2)
6121 fatal ("screen size %dx%d too big", width
, height
);
6124 adjust_frame_glyphs_initially ();
6125 calculate_costs (XFRAME (selected_frame
));
6130 #endif /* CANNOT_DUMP */
6131 signal (SIGWINCH
, window_change_signal
);
6132 #endif /* SIGWINCH */
6134 /* Set up faces of the initial terminal frame of a dumped Emacs. */
6138 /* The MSDOS terminal turns on its ``window system'' relatively
6139 late into the startup, so we cannot do the frame faces'
6140 initialization just yet. It will be done later by pc-win.el
6141 and internal_terminal_init. */
6142 && (strcmp (terminal_type
, "internal") != 0 || inhibit_window_system
)
6144 && NILP (Vwindow_system
))
6146 /* For the initial frame, we don't have any way of knowing what
6147 are the foreground and background colors of the terminal. */
6148 struct frame
*sf
= SELECTED_FRAME();
6150 FRAME_FOREGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_FG_COLOR
;
6151 FRAME_BACKGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_BG_COLOR
;
6152 call0 (intern ("tty-set-up-initial-frame-faces"));
6158 /***********************************************************************
6160 ***********************************************************************/
6162 DEFUN ("internal-show-cursor", Finternal_show_cursor
,
6163 Sinternal_show_cursor
, 2, 2, 0,
6164 "Set the cursor-visibility flag of WINDOW to SHOW.\n\
6165 WINDOW nil means use the selected window. SHOW non-nil means\n\
6166 show a cursor in WINDOW in the next redisplay. SHOW nil means\n\
6167 don't show a cursor.")
6169 Lisp_Object window
, show
;
6171 /* Don't change cursor state while redisplaying. This could confuse
6173 if (!redisplaying_p
)
6176 window
= selected_window
;
6178 CHECK_WINDOW (window
, 2);
6180 XWINDOW (window
)->cursor_off_p
= NILP (show
);
6187 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p
,
6188 Sinternal_show_cursor_p
, 0, 1, 0,
6189 "Value is non-nil if next redisplay will display a cursor in WINDOW.\n\
6190 WINDOW nil or omitted means report on the selected window.")
6197 window
= selected_window
;
6199 CHECK_WINDOW (window
, 2);
6201 w
= XWINDOW (window
);
6202 return w
->cursor_off_p
? Qnil
: Qt
;
6206 /***********************************************************************
6208 ***********************************************************************/
6213 defsubr (&Sredraw_frame
);
6214 defsubr (&Sredraw_display
);
6215 defsubr (&Sframe_or_buffer_changed_p
);
6216 defsubr (&Sopen_termscript
);
6218 defsubr (&Ssit_for
);
6219 defsubr (&Ssleep_for
);
6220 defsubr (&Ssend_string_to_terminal
);
6221 defsubr (&Sinternal_show_cursor
);
6222 defsubr (&Sinternal_show_cursor_p
);
6224 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
6225 staticpro (&frame_and_buffer_state
);
6227 Qdisplay_table
= intern ("display-table");
6228 staticpro (&Qdisplay_table
);
6229 Qredisplay_dont_pause
= intern ("redisplay-dont-pause");
6230 staticpro (&Qredisplay_dont_pause
);
6232 DEFVAR_INT ("baud-rate", &baud_rate
,
6233 "*The output baud rate of the terminal.\n\
6234 On most systems, changing this value will affect the amount of padding\n\
6235 and the other strategic decisions made during redisplay.");
6237 DEFVAR_BOOL ("inverse-video", &inverse_video
,
6238 "*Non-nil means invert the entire frame display.\n\
6239 This means everything is in inverse video which otherwise would not be.");
6241 DEFVAR_BOOL ("visible-bell", &visible_bell
,
6242 "*Non-nil means try to flash the frame to represent a bell.");
6244 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
6245 "*Non-nil means no need to redraw entire frame after suspending.\n\
6246 A non-nil value is useful if the terminal can automatically preserve\n\
6247 Emacs's frame display when you reenter Emacs.\n\
6248 It is up to you to set this variable if your terminal can do that.");
6250 DEFVAR_LISP ("window-system", &Vwindow_system
,
6251 "A symbol naming the window-system under which Emacs is running\n\
6252 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
6254 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
6255 "The version number of the window system in use.\n\
6256 For X windows, this is 10 or 11.");
6258 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
6259 "Non-nil means put cursor in minibuffer, at end of any message there.");
6261 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
6262 "Table defining how to output a glyph code to the frame.\n\
6263 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
6264 Each element can be:\n\
6265 integer: a glyph code which this glyph is an alias for.\n\
6266 string: output this glyph using that string (not impl. in X windows).\n\
6267 nil: this glyph mod 256 is char code to output,\n\
6268 and this glyph / 256 is face code for X windows (see `face-id').");
6269 Vglyph_table
= Qnil
;
6271 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
6272 "Display table to use for buffers that specify none.\n\
6273 See `buffer-display-table' for more information.");
6274 Vstandard_display_table
= Qnil
;
6276 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause
,
6277 "*Non-nil means update isn't paused when input is detected.");
6278 redisplay_dont_pause
= 0;
6280 /* Initialize `window-system', unless init_display already decided it. */
6285 Vwindow_system
= Qnil
;
6286 Vwindow_system_version
= Qnil
;