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__ */
104 /* Structure to pass dimensions around. Used for character bounding
105 boxes, glyph matrix dimensions and alike. */
114 /* Function prototypes. */
116 static void redraw_overlapping_rows
P_ ((struct window
*, int));
117 static void redraw_overlapped_rows
P_ ((struct window
*, int));
118 static int count_blanks
P_ ((struct glyph
*, int));
119 static int count_match
P_ ((struct glyph
*, struct glyph
*,
120 struct glyph
*, struct glyph
*));
121 static unsigned line_draw_cost
P_ ((struct glyph_matrix
*, int));
122 static void update_frame_line
P_ ((struct frame
*, int));
123 static struct dim allocate_matrices_for_frame_redisplay
124 P_ ((Lisp_Object
, int, int, struct dim
, int, int *));
125 static void allocate_matrices_for_window_redisplay
P_ ((struct window
*,
127 static int realloc_glyph_pool
P_ ((struct glyph_pool
*, struct dim
));
128 static void adjust_frame_glyphs
P_ ((struct frame
*));
129 struct glyph_matrix
*new_glyph_matrix
P_ ((struct glyph_pool
*));
130 static void free_glyph_matrix
P_ ((struct glyph_matrix
*));
131 static void adjust_glyph_matrix
P_ ((struct window
*, struct glyph_matrix
*,
132 int, int, struct dim
));
133 static void change_frame_size_1
P_ ((struct frame
*, int, int, int, int, int));
134 static void swap_glyphs_in_rows
P_ ((struct glyph_row
*, struct glyph_row
*));
135 static void swap_glyph_pointers
P_ ((struct glyph_row
*, struct glyph_row
*));
136 static int glyph_row_slice_p
P_ ((struct glyph_row
*, struct glyph_row
*));
137 static void fill_up_frame_row_with_spaces
P_ ((struct glyph_row
*, int));
138 static void build_frame_matrix_from_window_tree
P_ ((struct glyph_matrix
*,
140 static void build_frame_matrix_from_leaf_window
P_ ((struct glyph_matrix
*,
142 static struct glyph_pool
*new_glyph_pool
P_ ((void));
143 static void free_glyph_pool
P_ ((struct glyph_pool
*));
144 static void adjust_frame_glyphs_initially
P_ ((void));
145 static void adjust_frame_message_buffer
P_ ((struct frame
*));
146 static void adjust_decode_mode_spec_buffer
P_ ((struct frame
*));
147 static void fill_up_glyph_row_with_spaces
P_ ((struct glyph_row
*));
148 static void build_frame_matrix
P_ ((struct frame
*));
149 void clear_current_matrices
P_ ((struct frame
*));
150 void scroll_glyph_matrix_range
P_ ((struct glyph_matrix
*, int, int,
152 static void clear_window_matrices
P_ ((struct window
*, int));
153 static void fill_up_glyph_row_area_with_spaces
P_ ((struct glyph_row
*, int));
154 static int scrolling_window
P_ ((struct window
*, int));
155 static int update_window_line
P_ ((struct window
*, int));
156 static void update_marginal_area
P_ ((struct window
*, int, int));
157 static int update_text_area
P_ ((struct window
*, int));
158 static void make_current
P_ ((struct glyph_matrix
*, struct glyph_matrix
*,
160 static void mirror_make_current
P_ ((struct window
*, int));
161 void check_window_matrix_pointers
P_ ((struct window
*));
163 static void check_matrix_pointers
P_ ((struct glyph_matrix
*,
164 struct glyph_matrix
*));
166 static void mirror_line_dance
P_ ((struct window
*, int, int, int *, char *));
167 static int update_window_tree
P_ ((struct window
*, int));
168 static int update_window
P_ ((struct window
*, int));
169 static int update_frame_1
P_ ((struct frame
*, int, int));
170 static void set_window_cursor_after_update
P_ ((struct window
*));
171 static int row_equal_p
P_ ((struct window
*, struct glyph_row
*,
172 struct glyph_row
*));
173 static void adjust_frame_glyphs_for_window_redisplay
P_ ((struct frame
*));
174 static void adjust_frame_glyphs_for_frame_redisplay
P_ ((struct frame
*));
175 static void reverse_rows
P_ ((struct glyph_matrix
*, int, int));
176 static int margin_glyphs_to_reserve
P_ ((struct window
*, int, Lisp_Object
));
180 /* Non-zero means don't pause redisplay for pending input. (This is
181 for debugging and for a future implementation of EDT-like
184 int redisplay_dont_pause
;
186 /* Nonzero upon entry to redisplay means do not assume anything about
187 current contents of actual terminal frame; clear and redraw it. */
191 /* Nonzero means last display completed. Zero means it was preempted. */
193 int display_completed
;
195 /* Lisp variable visible-bell; enables use of screen-flash instead of
200 /* Invert the color of the whole frame, at a low level. */
204 /* Line speed of the terminal. */
208 /* Either nil or a symbol naming the window system under which Emacs
211 Lisp_Object Vwindow_system
;
213 /* Version number of X windows: 10, 11 or nil. */
215 Lisp_Object Vwindow_system_version
;
217 /* Vector of glyph definitions. Indexed by glyph number, the contents
218 are a string which is how to output the glyph.
220 If Vglyph_table is nil, a glyph is output by using its low 8 bits
223 This is an obsolete feature that is no longer used. The variable
224 is retained for compatibility. */
226 Lisp_Object Vglyph_table
;
228 /* Display table to use for vectors that don't specify their own. */
230 Lisp_Object Vstandard_display_table
;
232 /* Nonzero means reading single-character input with prompt so put
233 cursor on mini-buffer after the prompt. positive means at end of
234 text in echo area; negative means at beginning of line. */
236 int cursor_in_echo_area
;
238 Lisp_Object Qdisplay_table
;
241 /* The currently selected frame. In a single-frame version, this
242 variable always equals the_only_frame. */
244 Lisp_Object selected_frame
;
246 /* A frame which is not just a mini-buffer, or 0 if there are no such
247 frames. This is usually the most recent such frame that was
248 selected. In a single-frame version, this variable always holds
249 the address of the_only_frame. */
251 struct frame
*last_nonminibuf_frame
;
253 /* Stdio stream being used for copy of all output. */
257 /* Structure for info on cursor positioning. */
261 /* 1 means SIGWINCH happened when not safe. */
263 int delayed_size_change
;
265 /* 1 means glyph initialization has been completed at startup. */
267 static int glyphs_initialized_initially_p
;
269 /* Updated window if != 0. Set by update_window. */
271 struct window
*updated_window
;
273 /* Glyph row updated in update_window_line, and area that is updated. */
275 struct glyph_row
*updated_row
;
278 /* A glyph for a space. */
280 struct glyph space_glyph
;
282 /* Non-zero means update has been performed directly, so that there's
283 no need for redisplay_internal to do much work. Set by
284 direct_output_for_insert. */
286 int redisplay_performed_directly_p
;
288 /* Counts of allocated structures. These counts serve to diagnose
289 memory leaks and double frees. */
291 int glyph_matrix_count
;
292 int glyph_pool_count
;
294 /* If non-null, the frame whose frame matrices are manipulated. If
295 null, window matrices are worked on. */
297 static struct frame
*frame_matrix_frame
;
299 /* Current interface for window-based redisplay. Set from init_xterm.
300 A null value means we are not using window-based redisplay. */
302 struct redisplay_interface
*rif
;
304 /* Non-zero means that fonts have been loaded since the last glyph
305 matrix adjustments. Redisplay must stop, and glyph matrices must
306 be adjusted when this flag becomes non-zero during display. The
307 reason fonts can be loaded so late is that fonts of fontsets are
312 /* Convert vpos and hpos from frame to window and vice versa.
313 This may only be used for terminal frames. */
317 static int window_to_frame_vpos
P_ ((struct window
*, int));
318 static int window_to_frame_hpos
P_ ((struct window
*, int));
319 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
320 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
322 #else /* GLYPH_DEBUG == 0 */
324 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + XFASTINT ((W)->top))
325 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + XFASTINT ((W)->left))
327 #endif /* GLYPH_DEBUG == 0 */
330 /* Like bcopy except never gets confused by overlap. Let this be the
331 first function defined in this file, or change emacs.c where the
332 address of this function is used. */
335 safe_bcopy (from
, to
, size
)
339 if (size
<= 0 || from
== to
)
342 /* If the source and destination don't overlap, then bcopy can
343 handle it. If they do overlap, but the destination is lower in
344 memory than the source, we'll assume bcopy can handle that. */
345 if (to
< from
|| from
+ size
<= to
)
346 bcopy (from
, to
, size
);
348 /* Otherwise, we'll copy from the end. */
351 register char *endf
= from
+ size
;
352 register char *endt
= to
+ size
;
354 /* If TO - FROM is large, then we should break the copy into
355 nonoverlapping chunks of TO - FROM bytes each. However, if
356 TO - FROM is small, then the bcopy function call overhead
357 makes this not worth it. The crossover point could be about
358 anywhere. Since I don't think the obvious copy loop is too
359 bad, I'm trying to err in its favor. */
364 while (endf
!= from
);
376 bcopy (endf
, endt
, to
- from
);
379 /* If SIZE wasn't a multiple of TO - FROM, there will be a
380 little left over. The amount left over is (endt + (to -
381 from)) - to, which is endt - from. */
382 bcopy (from
, to
, endt
- from
);
389 /***********************************************************************
391 ***********************************************************************/
393 /* Allocate and return a glyph_matrix structure. POOL is the glyph
394 pool from which memory for the matrix should be allocated, or null
395 for window-based redisplay where no glyph pools are used. The
396 member `pool' of the glyph matrix structure returned is set to
397 POOL, the structure is otherwise zeroed. */
399 struct glyph_matrix
*
400 new_glyph_matrix (pool
)
401 struct glyph_pool
*pool
;
403 struct glyph_matrix
*result
;
405 /* Allocate and clear. */
406 result
= (struct glyph_matrix
*) xmalloc (sizeof *result
);
407 bzero (result
, sizeof *result
);
409 /* Increment number of allocated matrices. This count is used
410 to detect memory leaks. */
411 ++glyph_matrix_count
;
413 /* Set pool and return. */
419 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
421 The global counter glyph_matrix_count is decremented when a matrix
422 is freed. If the count gets negative, more structures were freed
423 than allocated, i.e. one matrix was freed more than once or a bogus
424 pointer was passed to this function.
426 If MATRIX->pool is null, this means that the matrix manages its own
427 glyph memory---this is done for matrices on X frames. Freeing the
428 matrix also frees the glyph memory in this case. */
431 free_glyph_matrix (matrix
)
432 struct glyph_matrix
*matrix
;
438 /* Detect the case that more matrices are freed than were
440 if (--glyph_matrix_count
< 0)
443 /* Free glyph memory if MATRIX owns it. */
444 if (matrix
->pool
== NULL
)
445 for (i
= 0; i
< matrix
->rows_allocated
; ++i
)
446 xfree (matrix
->rows
[i
].glyphs
[LEFT_MARGIN_AREA
]);
448 /* Free row structures and the matrix itself. */
449 xfree (matrix
->rows
);
455 /* Return the number of glyphs to reserve for a marginal area of
456 window W. TOTAL_GLYPHS is the number of glyphs in a complete
457 display line of window W. MARGIN gives the width of the marginal
458 area in canonical character units. MARGIN should be an integer
462 margin_glyphs_to_reserve (w
, total_glyphs
, margin
)
469 if (NUMBERP (margin
))
471 int width
= XFASTINT (w
->width
);
472 double d
= max (0, XFLOATINT (margin
));
473 d
= min (width
/ 2 - 1, d
);
474 n
= (int) ((double) total_glyphs
/ width
* d
);
483 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
486 W is null if the function is called for a frame glyph matrix.
487 Otherwise it is the window MATRIX is a member of. X and Y are the
488 indices of the first column and row of MATRIX within the frame
489 matrix, if such a matrix exists. They are zero for purely
490 window-based redisplay. DIM is the needed size of the matrix.
492 In window-based redisplay, where no frame matrices exist, glyph
493 matrices manage their own glyph storage. Otherwise, they allocate
494 storage from a common frame glyph pool which can be found in
497 The reason for this memory management strategy is to avoid complete
498 frame redraws if possible. When we allocate from a common pool, a
499 change of the location or size of a sub-matrix within the pool
500 requires a complete redisplay of the frame because we cannot easily
501 make sure that the current matrices of all windows still agree with
502 what is displayed on the screen. While this is usually fast, it
503 leads to screen flickering. */
506 adjust_glyph_matrix (w
, matrix
, x
, y
, dim
)
508 struct glyph_matrix
*matrix
;
514 int marginal_areas_changed_p
= 0;
515 int header_line_changed_p
= 0;
516 int header_line_p
= 0;
517 int left
= -1, right
= -1;
518 int window_x
, window_y
, window_width
, window_height
;
520 /* See if W had a top line that has disappeared now, or vice versa. */
523 header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
524 header_line_changed_p
= header_line_p
!= matrix
->header_line_p
;
526 matrix
->header_line_p
= header_line_p
;
528 /* Do nothing if MATRIX' size, position, vscroll, and marginal areas
529 haven't changed. This optimization is important because preserving
530 the matrix means preventing redisplay. */
531 if (matrix
->pool
== NULL
)
533 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
534 left
= margin_glyphs_to_reserve (w
, dim
.width
, w
->left_margin_width
);
535 right
= margin_glyphs_to_reserve (w
, dim
.width
, w
->right_margin_width
);
536 xassert (left
>= 0 && right
>= 0);
537 marginal_areas_changed_p
= (left
!= matrix
->left_margin_glyphs
538 || right
!= matrix
->right_margin_glyphs
);
540 if (!marginal_areas_changed_p
542 && !header_line_changed_p
543 && matrix
->window_top_y
== XFASTINT (w
->top
)
544 && matrix
->window_height
== window_height
545 && matrix
->window_vscroll
== w
->vscroll
546 && matrix
->window_width
== window_width
)
550 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
551 if (matrix
->rows_allocated
< dim
.height
)
553 int size
= dim
.height
* sizeof (struct glyph_row
);
554 new_rows
= dim
.height
- matrix
->rows_allocated
;
555 matrix
->rows
= (struct glyph_row
*) xrealloc (matrix
->rows
, size
);
556 bzero (matrix
->rows
+ matrix
->rows_allocated
,
557 new_rows
* sizeof *matrix
->rows
);
558 matrix
->rows_allocated
= dim
.height
;
563 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
564 on a frame not using window-based redisplay. Set up pointers for
565 each row into the glyph pool. */
568 xassert (matrix
->pool
->glyphs
);
572 left
= margin_glyphs_to_reserve (w
, dim
.width
,
573 w
->left_margin_width
);
574 right
= margin_glyphs_to_reserve (w
, dim
.width
,
575 w
->right_margin_width
);
580 for (i
= 0; i
< dim
.height
; ++i
)
582 struct glyph_row
*row
= &matrix
->rows
[i
];
584 row
->glyphs
[LEFT_MARGIN_AREA
]
585 = (matrix
->pool
->glyphs
586 + (y
+ i
) * matrix
->pool
->ncolumns
590 || row
== matrix
->rows
+ dim
.height
- 1
591 || (row
== matrix
->rows
&& matrix
->header_line_p
))
593 row
->glyphs
[TEXT_AREA
]
594 = row
->glyphs
[LEFT_MARGIN_AREA
];
595 row
->glyphs
[RIGHT_MARGIN_AREA
]
596 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
597 row
->glyphs
[LAST_AREA
]
598 = row
->glyphs
[RIGHT_MARGIN_AREA
];
602 row
->glyphs
[TEXT_AREA
]
603 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
604 row
->glyphs
[RIGHT_MARGIN_AREA
]
605 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
606 row
->glyphs
[LAST_AREA
]
607 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
611 matrix
->left_margin_glyphs
= left
;
612 matrix
->right_margin_glyphs
= right
;
616 /* If MATRIX->pool is null, MATRIX is responsible for managing
617 its own memory. Allocate glyph memory from the heap. */
618 if (dim
.width
> matrix
->matrix_w
620 || header_line_changed_p
621 || marginal_areas_changed_p
)
623 struct glyph_row
*row
= matrix
->rows
;
624 struct glyph_row
*end
= row
+ matrix
->rows_allocated
;
628 row
->glyphs
[LEFT_MARGIN_AREA
]
629 = (struct glyph
*) xrealloc (row
->glyphs
[LEFT_MARGIN_AREA
],
631 * sizeof (struct glyph
)));
633 /* The mode line never has marginal areas. */
634 if (row
== matrix
->rows
+ dim
.height
- 1
635 || (row
== matrix
->rows
&& matrix
->header_line_p
))
637 row
->glyphs
[TEXT_AREA
]
638 = row
->glyphs
[LEFT_MARGIN_AREA
];
639 row
->glyphs
[RIGHT_MARGIN_AREA
]
640 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
641 row
->glyphs
[LAST_AREA
]
642 = row
->glyphs
[RIGHT_MARGIN_AREA
];
646 row
->glyphs
[TEXT_AREA
]
647 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
648 row
->glyphs
[RIGHT_MARGIN_AREA
]
649 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
650 row
->glyphs
[LAST_AREA
]
651 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
657 xassert (left
>= 0 && right
>= 0);
658 matrix
->left_margin_glyphs
= left
;
659 matrix
->right_margin_glyphs
= right
;
662 /* Number of rows to be used by MATRIX. */
663 matrix
->nrows
= dim
.height
;
665 /* Mark rows in a current matrix of a window as not having valid
666 contents. It's important to not do this for desired matrices.
667 When Emacs starts, it may already be building desired matrices
668 when this function runs. */
669 if (w
&& matrix
== w
->current_matrix
)
671 /* Optimize the case that only the height has changed (C-x 2,
672 upper window). Invalidate all rows that are no longer part
674 if (!marginal_areas_changed_p
675 && matrix
->window_top_y
== XFASTINT (w
->top
)
676 && matrix
->window_width
== window_width
)
679 while (matrix
->rows
[i
].enabled_p
680 && (MATRIX_ROW_BOTTOM_Y (matrix
->rows
+ i
)
681 < matrix
->window_height
))
684 /* Window end is invalid, if inside of the rows that
686 if (INTEGERP (w
->window_end_vpos
)
687 && XFASTINT (w
->window_end_vpos
) >= i
)
688 w
->window_end_valid
= Qnil
;
690 while (i
< matrix
->nrows
)
691 matrix
->rows
[i
++].enabled_p
= 0;
695 for (i
= 0; i
< matrix
->nrows
; ++i
)
696 matrix
->rows
[i
].enabled_p
= 0;
700 /* Remember last values to be able to optimize frame redraws. */
701 matrix
->matrix_x
= x
;
702 matrix
->matrix_y
= y
;
703 matrix
->matrix_w
= dim
.width
;
704 matrix
->matrix_h
= dim
.height
;
706 /* Record the top y location and height of W at the time the matrix
707 was last adjusted. This is used to optimize redisplay above. */
710 matrix
->window_top_y
= XFASTINT (w
->top
);
711 matrix
->window_height
= window_height
;
712 matrix
->window_width
= window_width
;
713 matrix
->window_vscroll
= w
->vscroll
;
718 /* Reverse the contents of rows in MATRIX between START and END. The
719 contents of the row at END - 1 end up at START, END - 2 at START +
720 1 etc. This is part of the implementation of rotate_matrix (see
724 reverse_rows (matrix
, start
, end
)
725 struct glyph_matrix
*matrix
;
730 for (i
= start
, j
= end
- 1; i
< j
; ++i
, --j
)
732 /* Non-ISO HP/UX compiler doesn't like auto struct
734 struct glyph_row temp
;
735 temp
= matrix
->rows
[i
];
736 matrix
->rows
[i
] = matrix
->rows
[j
];
737 matrix
->rows
[j
] = temp
;
742 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
743 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
744 indices. (Note: this does not copy glyphs, only glyph pointers in
745 row structures are moved around).
747 The algorithm used for rotating the vector was, I believe, first
748 described by Kernighan. See the vector R as consisting of two
749 sub-vectors AB, where A has length BY for BY >= 0. The result
750 after rotating is then BA. Reverse both sub-vectors to get ArBr
751 and reverse the result to get (ArBr)r which is BA. Similar for
755 rotate_matrix (matrix
, first
, last
, by
)
756 struct glyph_matrix
*matrix
;
761 /* Up (rotate left, i.e. towards lower indices). */
763 reverse_rows (matrix
, first
, first
+ by
);
764 reverse_rows (matrix
, first
+ by
, last
);
765 reverse_rows (matrix
, first
, last
);
769 /* Down (rotate right, i.e. towards higher indices). */
770 reverse_rows (matrix
, last
- by
, last
);
771 reverse_rows (matrix
, first
, last
- by
);
772 reverse_rows (matrix
, first
, last
);
777 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
778 with indices START <= index < END. Increment positions by DELTA/
782 increment_glyph_matrix_buffer_positions (matrix
, start
, end
, delta
,
784 struct glyph_matrix
*matrix
;
785 int start
, end
, delta
, delta_bytes
;
787 /* Check that START and END are reasonable values. */
788 xassert (start
>= 0 && start
<= matrix
->nrows
);
789 xassert (end
>= 0 && end
<= matrix
->nrows
);
790 xassert (start
<= end
);
792 for (; start
< end
; ++start
)
793 increment_glyph_row_buffer_positions (matrix
->rows
+ start
,
798 /* Enable a range of rows in glyph matrix MATRIX. START and END are
799 the row indices of the first and last + 1 row to enable. If
800 ENABLED_P is non-zero, enabled_p flags in rows will be set to 1. */
803 enable_glyph_matrix_rows (matrix
, start
, end
, enabled_p
)
804 struct glyph_matrix
*matrix
;
808 xassert (start
<= end
);
809 xassert (start
>= 0 && start
< matrix
->nrows
);
810 xassert (end
>= 0 && end
<= matrix
->nrows
);
812 for (; start
< end
; ++start
)
813 matrix
->rows
[start
].enabled_p
= enabled_p
!= 0;
819 This empties all rows in MATRIX by setting the enabled_p flag for
820 all rows of the matrix to zero. The function prepare_desired_row
821 will eventually really clear a row when it sees one with a zero
824 Resets update hints to defaults value. The only update hint
825 currently present is the flag MATRIX->no_scrolling_p. */
828 clear_glyph_matrix (matrix
)
829 struct glyph_matrix
*matrix
;
833 enable_glyph_matrix_rows (matrix
, 0, matrix
->nrows
, 0);
834 matrix
->no_scrolling_p
= 0;
839 /* Shift part of the glyph matrix MATRIX of window W up or down.
840 Increment y-positions in glyph rows between START and END by DY,
841 and recompute their visible height. */
844 shift_glyph_matrix (w
, matrix
, start
, end
, dy
)
846 struct glyph_matrix
*matrix
;
851 xassert (start
<= end
);
852 xassert (start
>= 0 && start
< matrix
->nrows
);
853 xassert (end
>= 0 && end
<= matrix
->nrows
);
855 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
856 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
858 for (; start
< end
; ++start
)
860 struct glyph_row
*row
= &matrix
->rows
[start
];
865 row
->visible_height
= row
->height
- (min_y
- row
->y
);
866 else if (row
->y
+ row
->height
> max_y
)
867 row
->visible_height
= row
->height
- (row
->y
+ row
->height
- max_y
);
869 row
->visible_height
= row
->height
;
874 /* Mark all rows in current matrices of frame F as invalid. Marking
875 invalid is done by setting enabled_p to zero for all rows in a
879 clear_current_matrices (f
)
880 register struct frame
*f
;
882 /* Clear frame current matrix, if we have one. */
883 if (f
->current_matrix
)
884 clear_glyph_matrix (f
->current_matrix
);
886 /* Clear the matrix of the menu bar window, if such a window exists.
887 The menu bar window is currently used to display menus on X when
888 no toolkit support is compiled in. */
889 if (WINDOWP (f
->menu_bar_window
))
890 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->current_matrix
);
892 /* Clear the matrix of the tool-bar window, if any. */
893 if (WINDOWP (f
->tool_bar_window
))
894 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
896 /* Clear current window matrices. */
897 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
898 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 0);
902 /* Clear out all display lines of F for a coming redisplay. */
905 clear_desired_matrices (f
)
906 register struct frame
*f
;
908 if (f
->desired_matrix
)
909 clear_glyph_matrix (f
->desired_matrix
);
911 if (WINDOWP (f
->menu_bar_window
))
912 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->desired_matrix
);
914 if (WINDOWP (f
->tool_bar_window
))
915 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->desired_matrix
);
917 /* Do it for window matrices. */
918 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
919 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
923 /* Clear matrices in window tree rooted in W. If DESIRED_P is
924 non-zero clear desired matrices, otherwise clear current matrices. */
927 clear_window_matrices (w
, desired_p
)
933 if (!NILP (w
->hchild
))
935 xassert (WINDOWP (w
->hchild
));
936 clear_window_matrices (XWINDOW (w
->hchild
), desired_p
);
938 else if (!NILP (w
->vchild
))
940 xassert (WINDOWP (w
->vchild
));
941 clear_window_matrices (XWINDOW (w
->vchild
), desired_p
);
946 clear_glyph_matrix (w
->desired_matrix
);
949 clear_glyph_matrix (w
->current_matrix
);
950 w
->window_end_valid
= Qnil
;
954 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
960 /***********************************************************************
963 See dispextern.h for an overall explanation of glyph rows.
964 ***********************************************************************/
966 /* Clear glyph row ROW. Do it in a way that makes it robust against
967 changes in the glyph_row structure, i.e. addition or removal of
968 structure members. */
971 clear_glyph_row (row
)
972 struct glyph_row
*row
;
974 struct glyph
*p
[1 + LAST_AREA
];
975 static struct glyph_row null_row
;
978 p
[LEFT_MARGIN_AREA
] = row
->glyphs
[LEFT_MARGIN_AREA
];
979 p
[TEXT_AREA
] = row
->glyphs
[TEXT_AREA
];
980 p
[RIGHT_MARGIN_AREA
] = row
->glyphs
[RIGHT_MARGIN_AREA
];
981 p
[LAST_AREA
] = row
->glyphs
[LAST_AREA
];
986 /* Restore pointers. */
987 row
->glyphs
[LEFT_MARGIN_AREA
] = p
[LEFT_MARGIN_AREA
];
988 row
->glyphs
[TEXT_AREA
] = p
[TEXT_AREA
];
989 row
->glyphs
[RIGHT_MARGIN_AREA
] = p
[RIGHT_MARGIN_AREA
];
990 row
->glyphs
[LAST_AREA
] = p
[LAST_AREA
];
994 /* Make ROW an empty, enabled row of canonical character height,
995 in window W starting at y-position Y. */
998 blank_row (w
, row
, y
)
1000 struct glyph_row
*row
;
1005 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
1006 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
1008 clear_glyph_row (row
);
1010 row
->ascent
= row
->phys_ascent
= 0;
1011 row
->height
= row
->phys_height
= CANON_Y_UNIT (XFRAME (w
->frame
));
1014 row
->visible_height
= row
->height
- (min_y
- row
->y
);
1015 else if (row
->y
+ row
->height
> max_y
)
1016 row
->visible_height
= row
->height
- (row
->y
+ row
->height
- max_y
);
1018 row
->visible_height
= row
->height
;
1024 /* Increment buffer positions in glyph row ROW. DELTA and DELTA_BYTES
1025 are the amounts by which to change positions. Note that the first
1026 glyph of the text area of a row can have a buffer position even if
1027 the used count of the text area is zero. Such rows display line
1031 increment_glyph_row_buffer_positions (row
, delta
, delta_bytes
)
1032 struct glyph_row
*row
;
1033 int delta
, delta_bytes
;
1037 /* Increment start and end positions. */
1038 MATRIX_ROW_START_CHARPOS (row
) += delta
;
1039 MATRIX_ROW_START_BYTEPOS (row
) += delta_bytes
;
1040 MATRIX_ROW_END_CHARPOS (row
) += delta
;
1041 MATRIX_ROW_END_BYTEPOS (row
) += delta_bytes
;
1043 /* Increment positions in glyphs. */
1044 for (area
= 0; area
< LAST_AREA
; ++area
)
1045 for (i
= 0; i
< row
->used
[area
]; ++i
)
1046 if (BUFFERP (row
->glyphs
[area
][i
].object
)
1047 && row
->glyphs
[area
][i
].charpos
> 0)
1048 row
->glyphs
[area
][i
].charpos
+= delta
;
1050 /* Capture the case of rows displaying a line end. */
1051 if (row
->used
[TEXT_AREA
] == 0
1052 && MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1053 row
->glyphs
[TEXT_AREA
]->charpos
+= delta
;
1057 /* Swap glyphs between two glyph rows A and B. This exchanges glyph
1058 contents, i.e. glyph structure contents are exchanged between A and
1059 B without changing glyph pointers in A and B. */
1062 swap_glyphs_in_rows (a
, b
)
1063 struct glyph_row
*a
, *b
;
1067 for (area
= 0; area
< LAST_AREA
; ++area
)
1069 /* Number of glyphs to swap. */
1070 int max_used
= max (a
->used
[area
], b
->used
[area
]);
1072 /* Start of glyphs in area of row A. */
1073 struct glyph
*glyph_a
= a
->glyphs
[area
];
1075 /* End + 1 of glyphs in area of row A. */
1076 struct glyph
*glyph_a_end
= a
->glyphs
[max_used
];
1078 /* Start of glyphs in area of row B. */
1079 struct glyph
*glyph_b
= b
->glyphs
[area
];
1081 while (glyph_a
< glyph_a_end
)
1083 /* Non-ISO HP/UX compiler doesn't like auto struct
1087 *glyph_a
= *glyph_b
;
1096 /* Exchange pointers to glyph memory between glyph rows A and B. */
1099 swap_glyph_pointers (a
, b
)
1100 struct glyph_row
*a
, *b
;
1103 for (i
= 0; i
< LAST_AREA
+ 1; ++i
)
1105 struct glyph
*temp
= a
->glyphs
[i
];
1106 a
->glyphs
[i
] = b
->glyphs
[i
];
1107 b
->glyphs
[i
] = temp
;
1112 /* Copy glyph row structure FROM to glyph row structure TO, except
1113 that glyph pointers in the structures are left unchanged. */
1116 copy_row_except_pointers (to
, from
)
1117 struct glyph_row
*to
, *from
;
1119 struct glyph
*pointers
[1 + LAST_AREA
];
1121 /* Save glyph pointers of TO. */
1122 bcopy (to
->glyphs
, pointers
, sizeof to
->glyphs
);
1124 /* Do a structure assignment. */
1127 /* Restore original pointers of TO. */
1128 bcopy (pointers
, to
->glyphs
, sizeof to
->glyphs
);
1132 /* Copy contents of glyph row FROM to glyph row TO. Glyph pointers in
1133 TO and FROM are left unchanged. Glyph contents are copied from the
1134 glyph memory of FROM to the glyph memory of TO. Increment buffer
1135 positions in row TO by DELTA/ DELTA_BYTES. */
1138 copy_glyph_row_contents (to
, from
, delta
, delta_bytes
)
1139 struct glyph_row
*to
, *from
;
1140 int delta
, delta_bytes
;
1144 /* This is like a structure assignment TO = FROM, except that
1145 glyph pointers in the rows are left unchanged. */
1146 copy_row_except_pointers (to
, from
);
1148 /* Copy glyphs from FROM to TO. */
1149 for (area
= 0; area
< LAST_AREA
; ++area
)
1150 if (from
->used
[area
])
1151 bcopy (from
->glyphs
[area
], to
->glyphs
[area
],
1152 from
->used
[area
] * sizeof (struct glyph
));
1154 /* Increment buffer positions in TO by DELTA. */
1155 increment_glyph_row_buffer_positions (to
, delta
, delta_bytes
);
1159 /* Assign glyph row FROM to glyph row TO. This works like a structure
1160 assignment TO = FROM, except that glyph pointers are not copied but
1161 exchanged between TO and FROM. Pointers must be exchanged to avoid
1165 assign_row (to
, from
)
1166 struct glyph_row
*to
, *from
;
1168 swap_glyph_pointers (to
, from
);
1169 copy_row_except_pointers (to
, from
);
1173 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1174 a row in a window matrix, is a slice of the glyph memory of the
1175 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1176 is non-zero if the glyph memory of WINDOW_ROW is part of the glyph
1177 memory of FRAME_ROW. */
1180 glyph_row_slice_p (window_row
, frame_row
)
1181 struct glyph_row
*window_row
, *frame_row
;
1183 struct glyph
*window_glyph_start
= window_row
->glyphs
[0];
1184 struct glyph
*frame_glyph_start
= frame_row
->glyphs
[0];
1185 struct glyph
*frame_glyph_end
= frame_row
->glyphs
[LAST_AREA
];
1187 return (frame_glyph_start
<= window_glyph_start
1188 && window_glyph_start
< frame_glyph_end
);
1192 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1193 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1194 in WINDOW_MATRIX is found satisfying the condition. */
1196 static struct glyph_row
*
1197 find_glyph_row_slice (window_matrix
, frame_matrix
, row
)
1198 struct glyph_matrix
*window_matrix
, *frame_matrix
;
1203 xassert (row
>= 0 && row
< frame_matrix
->nrows
);
1205 for (i
= 0; i
< window_matrix
->nrows
; ++i
)
1206 if (glyph_row_slice_p (window_matrix
->rows
+ i
,
1207 frame_matrix
->rows
+ row
))
1210 return i
< window_matrix
->nrows
? window_matrix
->rows
+ i
: 0;
1214 /* Prepare ROW for display. Desired rows are cleared lazily,
1215 i.e. they are only marked as to be cleared by setting their
1216 enabled_p flag to zero. When a row is to be displayed, a prior
1217 call to this function really clears it. */
1220 prepare_desired_row (row
)
1221 struct glyph_row
*row
;
1223 if (!row
->enabled_p
)
1225 clear_glyph_row (row
);
1231 /* Return a hash code for glyph row ROW. */
1234 line_hash_code (row
)
1235 struct glyph_row
*row
;
1243 /* Give all highlighted lines the same hash code
1244 so as to encourage scrolling to leave them in place. */
1249 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
1250 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
1254 GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*glyph
);
1255 if (must_write_spaces
)
1257 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + g
;
1270 /* Return the cost of drawing line VPOS In MATRIX. The cost equals
1271 the number of characters in the line. If must_write_spaces is
1272 zero, leading and trailing spaces are ignored. */
1275 line_draw_cost (matrix
, vpos
)
1276 struct glyph_matrix
*matrix
;
1279 struct glyph_row
*row
= matrix
->rows
+ vpos
;
1280 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
1281 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
];
1283 Lisp_Object
*glyph_table_base
= GLYPH_TABLE_BASE
;
1284 int glyph_table_len
= GLYPH_TABLE_LENGTH
;
1286 /* Ignore trailing and leading spaces if we can. */
1287 if (!must_write_spaces
)
1289 /* Skip from the end over trailing spaces. */
1290 while (end
!= beg
&& CHAR_GLYPH_SPACE_P (*end
))
1293 /* All blank line. */
1297 /* Skip over leading spaces. */
1298 while (CHAR_GLYPH_SPACE_P (*beg
))
1302 /* If we don't have a glyph-table, each glyph is one character,
1303 so return the number of glyphs. */
1304 if (glyph_table_base
== 0)
1308 /* Otherwise, scan the glyphs and accumulate their total length
1313 GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*beg
);
1315 if (GLYPH_SIMPLE_P (glyph_table_base
, glyph_table_len
, g
))
1318 len
+= GLYPH_LENGTH (glyph_table_base
, g
);
1328 /* Test two glyph rows A and B for equality. Value is non-zero if A
1329 and B have equal contents. W is the window to which the glyphs
1330 rows A and B belong. It is needed here to test for partial row
1334 row_equal_p (w
, a
, b
)
1336 struct glyph_row
*a
, *b
;
1340 else if (a
->hash
!= b
->hash
)
1344 struct glyph
*a_glyph
, *b_glyph
, *a_end
;
1347 /* Compare glyphs. */
1348 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
1350 if (a
->used
[area
] != b
->used
[area
])
1353 a_glyph
= a
->glyphs
[area
];
1354 a_end
= a_glyph
+ a
->used
[area
];
1355 b_glyph
= b
->glyphs
[area
];
1357 while (a_glyph
< a_end
1358 && GLYPH_EQUAL_P (a_glyph
, b_glyph
))
1359 ++a_glyph
, ++b_glyph
;
1361 if (a_glyph
!= a_end
)
1365 if (a
->truncated_on_left_p
!= b
->truncated_on_left_p
1366 || a
->inverse_p
!= b
->inverse_p
1367 || a
->fill_line_p
!= b
->fill_line_p
1368 || a
->truncated_on_right_p
!= b
->truncated_on_right_p
1369 || a
->overlay_arrow_p
!= b
->overlay_arrow_p
1370 || a
->continued_p
!= b
->continued_p
1371 || a
->indicate_empty_line_p
!= b
->indicate_empty_line_p
1372 || a
->overlapped_p
!= b
->overlapped_p
1373 || (MATRIX_ROW_CONTINUATION_LINE_P (a
)
1374 != MATRIX_ROW_CONTINUATION_LINE_P (b
))
1375 /* Different partially visible characters on left margin. */
1377 /* Different height. */
1378 || a
->ascent
!= b
->ascent
1379 || a
->phys_ascent
!= b
->phys_ascent
1380 || a
->phys_height
!= b
->phys_height
1381 || a
->visible_height
!= b
->visible_height
)
1390 /***********************************************************************
1393 See dispextern.h for an overall explanation of glyph pools.
1394 ***********************************************************************/
1396 /* Allocate a glyph_pool structure. The structure returned is
1397 initialized with zeros. The global variable glyph_pool_count is
1398 incremented for each pool allocated. */
1400 static struct glyph_pool
*
1403 struct glyph_pool
*result
;
1405 /* Allocate a new glyph_pool and clear it. */
1406 result
= (struct glyph_pool
*) xmalloc (sizeof *result
);
1407 bzero (result
, sizeof *result
);
1409 /* For memory leak and double deletion checking. */
1416 /* Free a glyph_pool structure POOL. The function may be called with
1417 a null POOL pointer. The global variable glyph_pool_count is
1418 decremented with every pool structure freed. If this count gets
1419 negative, more structures were freed than allocated, i.e. one
1420 structure must have been freed more than once or a bogus pointer
1421 was passed to free_glyph_pool. */
1424 free_glyph_pool (pool
)
1425 struct glyph_pool
*pool
;
1429 /* More freed than allocated? */
1431 xassert (glyph_pool_count
>= 0);
1433 xfree (pool
->glyphs
);
1439 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1440 columns we need. This function never shrinks a pool. The only
1441 case in which this would make sense, would be when a frame's size
1442 is changed from a large value to a smaller one. But, if someone
1443 does it once, we can expect that he will do it again.
1445 Value is non-zero if the pool changed in a way which makes
1446 re-adjusting window glyph matrices necessary. */
1449 realloc_glyph_pool (pool
, matrix_dim
)
1450 struct glyph_pool
*pool
;
1451 struct dim matrix_dim
;
1456 changed_p
= (pool
->glyphs
== 0
1457 || matrix_dim
.height
!= pool
->nrows
1458 || matrix_dim
.width
!= pool
->ncolumns
);
1460 /* Enlarge the glyph pool. */
1461 needed
= matrix_dim
.width
* matrix_dim
.height
;
1462 if (needed
> pool
->nglyphs
)
1464 int size
= needed
* sizeof (struct glyph
);
1467 pool
->glyphs
= (struct glyph
*) xrealloc (pool
->glyphs
, size
);
1470 pool
->glyphs
= (struct glyph
*) xmalloc (size
);
1471 bzero (pool
->glyphs
, size
);
1474 pool
->nglyphs
= needed
;
1477 /* Remember the number of rows and columns because (a) we use then
1478 to do sanity checks, and (b) the number of columns determines
1479 where rows in the frame matrix start---this must be available to
1480 determine pointers to rows of window sub-matrices. */
1481 pool
->nrows
= matrix_dim
.height
;
1482 pool
->ncolumns
= matrix_dim
.width
;
1489 /***********************************************************************
1491 ***********************************************************************/
1495 /* Check that no glyph pointers have been lost in MATRIX. If a
1496 pointer has been lost, e.g. by using a structure assignment between
1497 rows, at least one pointer must occur more than once in the rows of
1501 check_matrix_pointer_lossage (matrix
)
1502 struct glyph_matrix
*matrix
;
1506 for (i
= 0; i
< matrix
->nrows
; ++i
)
1507 for (j
= 0; j
< matrix
->nrows
; ++j
)
1509 || (matrix
->rows
[i
].glyphs
[TEXT_AREA
]
1510 != matrix
->rows
[j
].glyphs
[TEXT_AREA
]));
1514 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1517 matrix_row (matrix
, row
)
1518 struct glyph_matrix
*matrix
;
1521 xassert (matrix
&& matrix
->rows
);
1522 xassert (row
>= 0 && row
< matrix
->nrows
);
1524 /* That's really too slow for normal testing because this function
1525 is called almost everywhere. Although---it's still astonishingly
1526 fast, so it is valuable to have for debugging purposes. */
1528 check_matrix_pointer_lossage (matrix
);
1531 return matrix
->rows
+ row
;
1535 #if 0 /* This function makes invalid assumptions when text is
1536 partially invisible. But it might come handy for debugging
1539 /* Check invariants that must hold for an up to date current matrix of
1543 check_matrix_invariants (w
)
1546 struct glyph_matrix
*matrix
= w
->current_matrix
;
1547 int yb
= window_text_bottom_y (w
);
1548 struct glyph_row
*row
= matrix
->rows
;
1549 struct glyph_row
*last_text_row
= NULL
;
1550 struct buffer
*saved
= current_buffer
;
1551 struct buffer
*buffer
= XBUFFER (w
->buffer
);
1554 /* This can sometimes happen for a fresh window. */
1555 if (matrix
->nrows
< 2)
1558 set_buffer_temp (buffer
);
1560 /* Note: last row is always reserved for the mode line. */
1561 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1562 && MATRIX_ROW_BOTTOM_Y (row
) < yb
)
1564 struct glyph_row
*next
= row
+ 1;
1566 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1567 last_text_row
= row
;
1569 /* Check that character and byte positions are in sync. */
1570 xassert (MATRIX_ROW_START_BYTEPOS (row
)
1571 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row
)));
1573 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1574 have such a position temporarily in case of a minibuffer
1575 displaying something like `[Sole completion]' at its end. */
1576 if (MATRIX_ROW_END_CHARPOS (row
) < BUF_ZV (current_buffer
))
1577 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1578 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row
)));
1580 /* Check that end position of `row' is equal to start position
1582 if (next
->enabled_p
&& MATRIX_ROW_DISPLAYS_TEXT_P (next
))
1584 xassert (MATRIX_ROW_END_CHARPOS (row
)
1585 == MATRIX_ROW_START_CHARPOS (next
));
1586 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1587 == MATRIX_ROW_START_BYTEPOS (next
));
1592 xassert (w
->current_matrix
->nrows
== w
->desired_matrix
->nrows
);
1593 xassert (w
->desired_matrix
->rows
!= NULL
);
1594 set_buffer_temp (saved
);
1599 #endif /* GLYPH_DEBUG != 0 */
1603 /**********************************************************************
1604 Allocating/ Adjusting Glyph Matrices
1605 **********************************************************************/
1607 /* Allocate glyph matrices over a window tree for a frame-based
1610 X and Y are column/row within the frame glyph matrix where
1611 sub-matrices for the window tree rooted at WINDOW must be
1612 allocated. CH_DIM contains the dimensions of the smallest
1613 character that could be used during display. DIM_ONLY_P non-zero
1614 means that the caller of this function is only interested in the
1615 result matrix dimension, and matrix adjustments should not be
1618 The function returns the total width/height of the sub-matrices of
1619 the window tree. If called on a frame root window, the computation
1620 will take the mini-buffer window into account.
1622 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1624 NEW_LEAF_MATRIX set if any window in the tree did not have a
1625 glyph matrices yet, and
1627 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1628 any window in the tree will be changed or have been changed (see
1631 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1634 Windows are arranged into chains of windows on the same level
1635 through the next fields of window structures. Such a level can be
1636 either a sequence of horizontally adjacent windows from left to
1637 right, or a sequence of vertically adjacent windows from top to
1638 bottom. Each window in a horizontal sequence can be either a leaf
1639 window or a vertical sequence; a window in a vertical sequence can
1640 be either a leaf or a horizontal sequence. All windows in a
1641 horizontal sequence have the same height, and all windows in a
1642 vertical sequence have the same width.
1644 This function uses, for historical reasons, a more general
1645 algorithm to determine glyph matrix dimensions that would be
1648 The matrix height of a horizontal sequence is determined by the
1649 maximum height of any matrix in the sequence. The matrix width of
1650 a horizontal sequence is computed by adding up matrix widths of
1651 windows in the sequence.
1653 |<------- result width ------->|
1654 +---------+----------+---------+ ---
1657 +---------+ | | result height
1662 The matrix width of a vertical sequence is the maximum matrix width
1663 of any window in the sequence. Its height is computed by adding up
1664 matrix heights of windows in the sequence.
1666 |<---- result width -->|
1674 +------------+---------+ |
1677 +------------+---------+ --- */
1679 /* Bit indicating that a new matrix will be allocated or has been
1682 #define NEW_LEAF_MATRIX (1 << 0)
1684 /* Bit indicating that a matrix will or has changed its location or
1687 #define CHANGED_LEAF_MATRIX (1 << 1)
1690 allocate_matrices_for_frame_redisplay (window
, x
, y
, ch_dim
,
1691 dim_only_p
, window_change_flags
)
1696 int *window_change_flags
;
1698 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1700 int wmax
= 0, hmax
= 0;
1704 int in_horz_combination_p
;
1706 /* What combination is WINDOW part of? Compute this once since the
1707 result is the same for all windows in the `next' chain. The
1708 special case of a root window (parent equal to nil) is treated
1709 like a vertical combination because a root window's `next'
1710 points to the mini-buffer window, if any, which is arranged
1711 vertically below other windows. */
1712 in_horz_combination_p
1713 = (!NILP (XWINDOW (window
)->parent
)
1714 && !NILP (XWINDOW (XWINDOW (window
)->parent
)->hchild
));
1716 /* For WINDOW and all windows on the same level. */
1719 w
= XWINDOW (window
);
1721 /* Get the dimension of the window sub-matrix for W, depending
1722 on whether this a combination or a leaf window. */
1723 if (!NILP (w
->hchild
))
1724 dim
= allocate_matrices_for_frame_redisplay (w
->hchild
, x
, y
, ch_dim
,
1726 window_change_flags
);
1727 else if (!NILP (w
->vchild
))
1728 dim
= allocate_matrices_for_frame_redisplay (w
->vchild
, x
, y
, ch_dim
,
1730 window_change_flags
);
1733 /* If not already done, allocate sub-matrix structures. */
1734 if (w
->desired_matrix
== NULL
)
1736 w
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1737 w
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1738 *window_change_flags
|= NEW_LEAF_MATRIX
;
1741 /* Width and height MUST be chosen so that there are no
1742 holes in the frame matrix. */
1743 dim
.width
= w
->width
;
1744 dim
.height
= w
->height
;
1746 /* Will matrix be re-allocated? */
1747 if (x
!= w
->desired_matrix
->matrix_x
1748 || y
!= w
->desired_matrix
->matrix_y
1749 || dim
.width
!= w
->desired_matrix
->matrix_w
1750 || dim
.height
!= w
->desired_matrix
->matrix_h
1751 || (margin_glyphs_to_reserve (w
, dim
.width
,
1752 w
->right_margin_width
)
1753 != w
->desired_matrix
->left_margin_glyphs
)
1754 || (margin_glyphs_to_reserve (w
, dim
.width
,
1755 w
->left_margin_width
)
1756 != w
->desired_matrix
->right_margin_glyphs
))
1757 *window_change_flags
|= CHANGED_LEAF_MATRIX
;
1759 /* Actually change matrices, if allowed. Do not consider
1760 CHANGED_LEAF_MATRIX computed above here because the pool
1761 may have been changed which we don't now here. We trust
1762 that we only will be called with DIM_ONLY_P != 0 when
1766 adjust_glyph_matrix (w
, w
->desired_matrix
, x
, y
, dim
);
1767 adjust_glyph_matrix (w
, w
->current_matrix
, x
, y
, dim
);
1771 /* If we are part of a horizontal combination, advance x for
1772 windows to the right of W; otherwise advance y for windows
1774 if (in_horz_combination_p
)
1779 /* Remember maximum glyph matrix dimensions. */
1780 wmax
= max (wmax
, dim
.width
);
1781 hmax
= max (hmax
, dim
.height
);
1783 /* Next window on same level. */
1786 while (!NILP (window
));
1788 /* Set `total' to the total glyph matrix dimension of this window
1789 level. In a vertical combination, the width is the width of the
1790 widest window; the height is the y we finally reached, corrected
1791 by the y we started with. In a horizontal combination, the total
1792 height is the height of the tallest window, and the width is the
1793 x we finally reached, corrected by the x we started with. */
1794 if (in_horz_combination_p
)
1796 total
.width
= x
- x0
;
1797 total
.height
= hmax
;
1802 total
.height
= y
- y0
;
1809 /* Allocate window matrices for window-based redisplay. W is the
1810 window whose matrices must be allocated/reallocated. CH_DIM is the
1811 size of the smallest character that could potentially be used on W. */
1814 allocate_matrices_for_window_redisplay (w
, ch_dim
)
1818 struct frame
*f
= XFRAME (w
->frame
);
1822 if (!NILP (w
->vchild
))
1823 allocate_matrices_for_window_redisplay (XWINDOW (w
->vchild
), ch_dim
);
1824 else if (!NILP (w
->hchild
))
1825 allocate_matrices_for_window_redisplay (XWINDOW (w
->hchild
), ch_dim
);
1828 /* W is a leaf window. */
1829 int window_pixel_width
= XFLOATINT (w
->width
) * CANON_X_UNIT (f
);
1830 int window_pixel_height
= window_box_height (w
) + abs (w
->vscroll
);
1833 /* If matrices are not yet allocated, allocate them now. */
1834 if (w
->desired_matrix
== NULL
)
1836 w
->desired_matrix
= new_glyph_matrix (NULL
);
1837 w
->current_matrix
= new_glyph_matrix (NULL
);
1840 /* Compute number of glyphs needed in a glyph row. */
1841 dim
.width
= (((window_pixel_width
+ ch_dim
.width
- 1)
1843 /* 2 partially visible columns in the text area. */
1845 /* One partially visible column at the right
1846 edge of each marginal area. */
1849 /* Compute number of glyph rows needed. */
1850 dim
.height
= (((window_pixel_height
+ ch_dim
.height
- 1)
1852 /* One partially visible line at the top and
1853 bottom of the window. */
1855 /* 2 for top and mode line. */
1858 /* Change matrices. */
1859 adjust_glyph_matrix (w
, w
->desired_matrix
, 0, 0, dim
);
1860 adjust_glyph_matrix (w
, w
->current_matrix
, 0, 0, dim
);
1863 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
1868 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
1869 do it for all frames; otherwise do it just for the given frame.
1870 This function must be called when a new frame is created, its size
1871 changes, or its window configuration changes. */
1877 /* Block input so that expose events and other events that access
1878 glyph matrices are not processed while we are changing them. */
1882 adjust_frame_glyphs (f
);
1885 Lisp_Object tail
, lisp_frame
;
1887 FOR_EACH_FRAME (tail
, lisp_frame
)
1888 adjust_frame_glyphs (XFRAME (lisp_frame
));
1895 /* Adjust frame glyphs when Emacs is initialized.
1897 To be called from init_display.
1899 We need a glyph matrix because redraw will happen soon.
1900 Unfortunately, window sizes on selected_frame are not yet set to
1901 meaningful values. I believe we can assume that there are only two
1902 windows on the frame---the mini-buffer and the root window. Frame
1903 height and width seem to be correct so far. So, set the sizes of
1904 windows to estimated values. */
1907 adjust_frame_glyphs_initially ()
1909 struct frame
*sf
= SELECTED_FRAME ();
1910 struct window
*root
= XWINDOW (sf
->root_window
);
1911 struct window
*mini
= XWINDOW (root
->next
);
1912 int frame_height
= FRAME_HEIGHT (sf
);
1913 int frame_width
= FRAME_WIDTH (sf
);
1914 int top_margin
= FRAME_TOP_MARGIN (sf
);
1916 /* Do it for the root window. */
1917 XSETFASTINT (root
->top
, top_margin
);
1918 XSETFASTINT (root
->width
, frame_width
);
1919 set_window_height (sf
->root_window
, frame_height
- 1 - top_margin
, 0);
1921 /* Do it for the mini-buffer window. */
1922 XSETFASTINT (mini
->top
, frame_height
- 1);
1923 XSETFASTINT (mini
->width
, frame_width
);
1924 set_window_height (root
->next
, 1, 0);
1926 adjust_frame_glyphs (sf
);
1927 glyphs_initialized_initially_p
= 1;
1931 /* Allocate/reallocate glyph matrices of a single frame F. */
1934 adjust_frame_glyphs (f
)
1937 if (FRAME_WINDOW_P (f
))
1938 adjust_frame_glyphs_for_window_redisplay (f
);
1940 adjust_frame_glyphs_for_frame_redisplay (f
);
1942 /* Don't forget the message buffer and the buffer for
1943 decode_mode_spec. */
1944 adjust_frame_message_buffer (f
);
1945 adjust_decode_mode_spec_buffer (f
);
1947 f
->glyphs_initialized_p
= 1;
1951 /* Allocate/reallocate glyph matrices of a single frame F for
1952 frame-based redisplay. */
1955 adjust_frame_glyphs_for_frame_redisplay (f
)
1959 struct dim matrix_dim
;
1961 int window_change_flags
;
1964 if (!FRAME_LIVE_P (f
))
1967 /* Determine the smallest character in any font for F. On
1968 console windows, all characters have dimension (1, 1). */
1969 ch_dim
.width
= ch_dim
.height
= 1;
1971 top_window_y
= FRAME_TOP_MARGIN (f
);
1973 /* Allocate glyph pool structures if not already done. */
1974 if (f
->desired_pool
== NULL
)
1976 f
->desired_pool
= new_glyph_pool ();
1977 f
->current_pool
= new_glyph_pool ();
1980 /* Allocate frames matrix structures if needed. */
1981 if (f
->desired_matrix
== NULL
)
1983 f
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1984 f
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1987 /* Compute window glyph matrices. (This takes the mini-buffer
1988 window into account). The result is the size of the frame glyph
1989 matrix needed. The variable window_change_flags is set to a bit
1990 mask indicating whether new matrices will be allocated or
1991 existing matrices change their size or location within the frame
1993 window_change_flags
= 0;
1995 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
1998 &window_change_flags
);
2000 /* Add in menu bar lines, if any. */
2001 matrix_dim
.height
+= top_window_y
;
2003 /* Enlarge pools as necessary. */
2004 pool_changed_p
= realloc_glyph_pool (f
->desired_pool
, matrix_dim
);
2005 realloc_glyph_pool (f
->current_pool
, matrix_dim
);
2007 /* Set up glyph pointers within window matrices. Do this only if
2008 absolutely necessary since it requires a frame redraw. */
2009 if (pool_changed_p
|| window_change_flags
)
2011 /* Do it for window matrices. */
2012 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2013 0, top_window_y
, ch_dim
, 0,
2014 &window_change_flags
);
2016 /* Size of frame matrices must equal size of frame. Note
2017 that we are called for X frames with window widths NOT equal
2018 to the frame width (from CHANGE_FRAME_SIZE_1). */
2019 xassert (matrix_dim
.width
== FRAME_WIDTH (f
)
2020 && matrix_dim
.height
== FRAME_HEIGHT (f
));
2022 /* Resize frame matrices. */
2023 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2024 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2026 /* Since location and size of sub-matrices within the pool may
2027 have changed, and current matrices don't have meaningful
2028 contents anymore, mark the frame garbaged. */
2029 SET_FRAME_GARBAGED (f
);
2034 /* Allocate/reallocate glyph matrices of a single frame F for
2035 window-based redisplay. */
2038 adjust_frame_glyphs_for_window_redisplay (f
)
2044 xassert (FRAME_WINDOW_P (f
) && FRAME_LIVE_P (f
));
2046 /* Get minimum sizes. */
2047 #ifdef HAVE_WINDOW_SYSTEM
2048 ch_dim
.width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2049 ch_dim
.height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
2051 ch_dim
.width
= ch_dim
.height
= 1;
2054 /* Allocate/reallocate window matrices. */
2055 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f
)),
2058 /* Allocate/ reallocate matrices of the dummy window used to display
2059 the menu bar under X when no X toolkit support is available. */
2060 #ifndef USE_X_TOOLKIT
2062 /* Allocate a dummy window if not already done. */
2063 if (NILP (f
->menu_bar_window
))
2065 f
->menu_bar_window
= make_window ();
2066 w
= XWINDOW (f
->menu_bar_window
);
2067 XSETFRAME (w
->frame
, f
);
2068 w
->pseudo_window_p
= 1;
2071 w
= XWINDOW (f
->menu_bar_window
);
2073 /* Set window dimensions to frame dimensions and allocate or
2074 adjust glyph matrices of W. */
2075 XSETFASTINT (w
->top
, 0);
2076 XSETFASTINT (w
->left
, 0);
2077 XSETFASTINT (w
->height
, FRAME_MENU_BAR_LINES (f
));
2078 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2079 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2081 #endif /* not USE_X_TOOLKIT */
2083 /* Allocate/ reallocate matrices of the tool bar window. If we
2084 don't have a tool bar window yet, make one. */
2085 if (NILP (f
->tool_bar_window
))
2087 f
->tool_bar_window
= make_window ();
2088 w
= XWINDOW (f
->tool_bar_window
);
2089 XSETFRAME (w
->frame
, f
);
2090 w
->pseudo_window_p
= 1;
2093 w
= XWINDOW (f
->tool_bar_window
);
2095 XSETFASTINT (w
->top
, FRAME_MENU_BAR_LINES (f
));
2096 XSETFASTINT (w
->left
, 0);
2097 XSETFASTINT (w
->height
, FRAME_TOOL_BAR_LINES (f
));
2098 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2099 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2103 /* Adjust/ allocate message buffer of frame F.
2105 Note that the message buffer is never freed. Since I could not
2106 find a free in 19.34, I assume that freeing it would be
2107 problematic in some way and don't do it either.
2109 (Implementation note: It should be checked if we can free it
2110 eventually without causing trouble). */
2113 adjust_frame_message_buffer (f
)
2116 int size
= FRAME_MESSAGE_BUF_SIZE (f
) + 1;
2118 if (FRAME_MESSAGE_BUF (f
))
2120 char *buffer
= FRAME_MESSAGE_BUF (f
);
2121 char *new_buffer
= (char *) xrealloc (buffer
, size
);
2122 FRAME_MESSAGE_BUF (f
) = new_buffer
;
2125 FRAME_MESSAGE_BUF (f
) = (char *) xmalloc (size
);
2129 /* Re-allocate buffer for decode_mode_spec on frame F. */
2132 adjust_decode_mode_spec_buffer (f
)
2135 f
->decode_mode_spec_buffer
2136 = (char *) xrealloc (f
->decode_mode_spec_buffer
,
2137 FRAME_MESSAGE_BUF_SIZE (f
) + 1);
2142 /**********************************************************************
2143 Freeing Glyph Matrices
2144 **********************************************************************/
2146 /* Free glyph memory for a frame F. F may be null. This function can
2147 be called for the same frame more than once. The root window of
2148 F may be nil when this function is called. This is the case when
2149 the function is called when F is destroyed. */
2155 if (f
&& f
->glyphs_initialized_p
)
2157 f
->glyphs_initialized_p
= 0;
2159 /* Release window sub-matrices. */
2160 if (!NILP (f
->root_window
))
2161 free_window_matrices (XWINDOW (f
->root_window
));
2163 /* Free the dummy window for menu bars without X toolkit and its
2165 if (!NILP (f
->menu_bar_window
))
2167 struct window
*w
= XWINDOW (f
->menu_bar_window
);
2168 free_glyph_matrix (w
->desired_matrix
);
2169 free_glyph_matrix (w
->current_matrix
);
2170 w
->desired_matrix
= w
->current_matrix
= NULL
;
2171 f
->menu_bar_window
= Qnil
;
2174 /* Free the tool bar window and its glyph matrices. */
2175 if (!NILP (f
->tool_bar_window
))
2177 struct window
*w
= XWINDOW (f
->tool_bar_window
);
2178 free_glyph_matrix (w
->desired_matrix
);
2179 free_glyph_matrix (w
->current_matrix
);
2180 w
->desired_matrix
= w
->current_matrix
= NULL
;
2181 f
->tool_bar_window
= Qnil
;
2184 /* Release frame glyph matrices. Reset fields to zero in
2185 case we are called a second time. */
2186 if (f
->desired_matrix
)
2188 free_glyph_matrix (f
->desired_matrix
);
2189 free_glyph_matrix (f
->current_matrix
);
2190 f
->desired_matrix
= f
->current_matrix
= NULL
;
2193 /* Release glyph pools. */
2194 if (f
->desired_pool
)
2196 free_glyph_pool (f
->desired_pool
);
2197 free_glyph_pool (f
->current_pool
);
2198 f
->desired_pool
= f
->current_pool
= NULL
;
2204 /* Free glyph sub-matrices in the window tree rooted at W. This
2205 function may be called with a null pointer, and it may be called on
2206 the same tree more than once. */
2209 free_window_matrices (w
)
2214 if (!NILP (w
->hchild
))
2215 free_window_matrices (XWINDOW (w
->hchild
));
2216 else if (!NILP (w
->vchild
))
2217 free_window_matrices (XWINDOW (w
->vchild
));
2220 /* This is a leaf window. Free its memory and reset fields
2221 to zero in case this function is called a second time for
2223 free_glyph_matrix (w
->current_matrix
);
2224 free_glyph_matrix (w
->desired_matrix
);
2225 w
->current_matrix
= w
->desired_matrix
= NULL
;
2228 /* Next window on same level. */
2229 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2234 /* Check glyph memory leaks. This function is called from
2235 shut_down_emacs. Note that frames are not destroyed when Emacs
2236 exits. We therefore free all glyph memory for all active frames
2237 explicitly and check that nothing is left allocated. */
2240 check_glyph_memory ()
2242 Lisp_Object tail
, frame
;
2244 /* Free glyph memory for all frames. */
2245 FOR_EACH_FRAME (tail
, frame
)
2246 free_glyphs (XFRAME (frame
));
2248 /* Check that nothing is left allocated. */
2249 if (glyph_matrix_count
)
2251 if (glyph_pool_count
)
2257 /**********************************************************************
2258 Building a Frame Matrix
2259 **********************************************************************/
2261 /* Most of the redisplay code works on glyph matrices attached to
2262 windows. This is a good solution most of the time, but it is not
2263 suitable for terminal code. Terminal output functions cannot rely
2264 on being able to set an arbitrary terminal window. Instead they
2265 must be provided with a view of the whole frame, i.e. the whole
2266 screen. We build such a view by constructing a frame matrix from
2267 window matrices in this section.
2269 Windows that must be updated have their must_be_update_p flag set.
2270 For all such windows, their desired matrix is made part of the
2271 desired frame matrix. For other windows, their current matrix is
2272 made part of the desired frame matrix.
2274 +-----------------+----------------+
2275 | desired | desired |
2277 +-----------------+----------------+
2280 +----------------------------------+
2282 Desired window matrices can be made part of the frame matrix in a
2283 cheap way: We exploit the fact that the desired frame matrix and
2284 desired window matrices share their glyph memory. This is not
2285 possible for current window matrices. Their glyphs are copied to
2286 the desired frame matrix. The latter is equivalent to
2287 preserve_other_columns in the old redisplay.
2289 Used glyphs counters for frame matrix rows are the result of adding
2290 up glyph lengths of the window matrices. A line in the frame
2291 matrix is enabled, if a corresponding line in a window matrix is
2294 After building the desired frame matrix, it will be passed to
2295 terminal code, which will manipulate both the desired and current
2296 frame matrix. Changes applied to the frame's current matrix have
2297 to be visible in current window matrices afterwards, of course.
2299 This problem is solved like this:
2301 1. Window and frame matrices share glyphs. Window matrices are
2302 constructed in a way that their glyph contents ARE the glyph
2303 contents needed in a frame matrix. Thus, any modification of
2304 glyphs done in terminal code will be reflected in window matrices
2307 2. Exchanges of rows in a frame matrix done by terminal code are
2308 intercepted by hook functions so that corresponding row operations
2309 on window matrices can be performed. This is necessary because we
2310 use pointers to glyphs in glyph row structures. To satisfy the
2311 assumption of point 1 above that glyphs are updated implicitly in
2312 window matrices when they are manipulated via the frame matrix,
2313 window and frame matrix must of course agree where to find the
2314 glyphs for their rows. Possible manipulations that must be
2315 mirrored are assignments of rows of the desired frame matrix to the
2316 current frame matrix and scrolling the current frame matrix. */
2318 /* Build frame F's desired matrix from window matrices. Only windows
2319 which have the flag must_be_updated_p set have to be updated. Menu
2320 bar lines of a frame are not covered by window matrices, so make
2321 sure not to touch them in this function. */
2324 build_frame_matrix (f
)
2329 /* F must have a frame matrix when this function is called. */
2330 xassert (!FRAME_WINDOW_P (f
));
2332 /* Clear all rows in the frame matrix covered by window matrices.
2333 Menu bar lines are not covered by windows. */
2334 for (i
= FRAME_TOP_MARGIN (f
); i
< f
->desired_matrix
->nrows
; ++i
)
2335 clear_glyph_row (MATRIX_ROW (f
->desired_matrix
, i
));
2337 /* Build the matrix by walking the window tree. */
2338 build_frame_matrix_from_window_tree (f
->desired_matrix
,
2339 XWINDOW (FRAME_ROOT_WINDOW (f
)));
2343 /* Walk a window tree, building a frame matrix MATRIX from window
2344 matrices. W is the root of a window tree. */
2347 build_frame_matrix_from_window_tree (matrix
, w
)
2348 struct glyph_matrix
*matrix
;
2353 if (!NILP (w
->hchild
))
2354 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->hchild
));
2355 else if (!NILP (w
->vchild
))
2356 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->vchild
));
2358 build_frame_matrix_from_leaf_window (matrix
, w
);
2360 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2365 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2366 desired frame matrix built. W is a leaf window whose desired or
2367 current matrix is to be added to FRAME_MATRIX. W's flag
2368 must_be_updated_p determines which matrix it contributes to
2369 FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix
2370 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2371 Adding a desired matrix means setting up used counters and such in
2372 frame rows, while adding a current window matrix to FRAME_MATRIX
2373 means copying glyphs. The latter case corresponds to
2374 preserve_other_columns in the old redisplay. */
2377 build_frame_matrix_from_leaf_window (frame_matrix
, w
)
2378 struct glyph_matrix
*frame_matrix
;
2381 struct glyph_matrix
*window_matrix
;
2382 int window_y
, frame_y
;
2383 /* If non-zero, a glyph to insert at the right border of W. */
2384 GLYPH right_border_glyph
= 0;
2386 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2387 if (w
->must_be_updated_p
)
2389 window_matrix
= w
->desired_matrix
;
2391 /* Decide whether we want to add a vertical border glyph. */
2392 if (!WINDOW_RIGHTMOST_P (w
))
2394 struct Lisp_Char_Table
*dp
= window_display_table (w
);
2395 right_border_glyph
= (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
2396 ? XINT (DISP_BORDER_GLYPH (dp
))
2401 window_matrix
= w
->current_matrix
;
2403 /* For all rows in the window matrix and corresponding rows in the
2406 frame_y
= window_matrix
->matrix_y
;
2407 while (window_y
< window_matrix
->nrows
)
2409 struct glyph_row
*frame_row
= frame_matrix
->rows
+ frame_y
;
2410 struct glyph_row
*window_row
= window_matrix
->rows
+ window_y
;
2412 /* Fill up the frame row with spaces up to the left margin of the
2414 fill_up_frame_row_with_spaces (frame_row
, window_matrix
->matrix_x
);
2416 /* Fill up areas in the window matrix row with spaces. */
2417 fill_up_glyph_row_with_spaces (window_row
);
2419 if (window_matrix
== w
->current_matrix
)
2421 /* We have to copy W's current matrix. Copy window
2422 row to frame row. */
2423 bcopy (window_row
->glyphs
[0],
2424 frame_row
->glyphs
[TEXT_AREA
] + window_matrix
->matrix_x
,
2425 window_matrix
->matrix_w
* sizeof (struct glyph
));
2429 /* Copy W's desired matrix. */
2431 /* Maybe insert a vertical border between horizontally adjacent
2433 if (right_border_glyph
)
2435 struct glyph
*border
= window_row
->glyphs
[LAST_AREA
] - 1;
2436 SET_CHAR_GLYPH_FROM_GLYPH (*border
, right_border_glyph
);
2439 /* Due to hooks installed, it normally doesn't happen that
2440 window rows and frame rows of the same matrix are out of
2441 sync, i.e. have a different understanding of where to
2442 find glyphs for the row. The following is a safety-belt
2443 that doesn't cost much and makes absolutely sure that
2444 window and frame matrices are in sync. */
2445 if (!glyph_row_slice_p (window_row
, frame_row
))
2447 /* Find the row in the window being a slice. There
2448 should exist one from program logic. */
2449 struct glyph_row
*slice_row
2450 = find_glyph_row_slice (window_matrix
, frame_matrix
, frame_y
);
2451 xassert (slice_row
!= 0);
2453 /* Exchange glyphs between both window rows. */
2454 swap_glyphs_in_rows (window_row
, slice_row
);
2456 /* Exchange pointers between both rows. */
2457 swap_glyph_pointers (window_row
, slice_row
);
2460 /* Now, we are sure that window row window_y is a slice of
2461 the frame row frame_y. But, lets check that assumption. */
2462 xassert (glyph_row_slice_p (window_row
, frame_row
));
2464 /* If rows are in sync, we don't have to copy glyphs because
2465 frame and window share glyphs. */
2468 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
2472 /* Set number of used glyphs in the frame matrix. Since we fill
2473 up with spaces, and visit leaf windows from left to right it
2474 can be done simply. */
2475 frame_row
->used
[TEXT_AREA
]
2476 = window_matrix
->matrix_x
+ window_matrix
->matrix_w
;
2479 frame_row
->enabled_p
|= window_row
->enabled_p
;
2480 frame_row
->inverse_p
|= window_row
->inverse_p
;
2489 /* Add spaces to a glyph row ROW in a window matrix.
2491 Each row has the form:
2493 +---------+-----------------------------+------------+
2494 | left | text | right |
2495 +---------+-----------------------------+------------+
2497 Left and right marginal areas are optional. This function adds
2498 spaces to areas so that there are no empty holes between areas.
2499 In other words: If the right area is not empty, the text area
2500 is filled up with spaces up to the right area. If the text area
2501 is not empty, the left area is filled up.
2503 To be called for frame-based redisplay, only. */
2506 fill_up_glyph_row_with_spaces (row
)
2507 struct glyph_row
*row
;
2509 fill_up_glyph_row_area_with_spaces (row
, LEFT_MARGIN_AREA
);
2510 fill_up_glyph_row_area_with_spaces (row
, TEXT_AREA
);
2511 fill_up_glyph_row_area_with_spaces (row
, RIGHT_MARGIN_AREA
);
2515 /* Fill area AREA of glyph row ROW with spaces. To be called for
2516 frame-based redisplay only. */
2519 fill_up_glyph_row_area_with_spaces (row
, area
)
2520 struct glyph_row
*row
;
2523 if (row
->glyphs
[area
] < row
->glyphs
[area
+ 1])
2525 struct glyph
*end
= row
->glyphs
[area
+ 1];
2526 struct glyph
*text
= row
->glyphs
[area
] + row
->used
[area
];
2529 *text
++ = space_glyph
;
2530 row
->used
[area
] = text
- row
->glyphs
[area
];
2535 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2536 reached. In frame matrices only one area, TEXT_AREA, is used. */
2539 fill_up_frame_row_with_spaces (row
, upto
)
2540 struct glyph_row
*row
;
2543 int i
= row
->used
[TEXT_AREA
];
2544 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
2547 glyph
[i
++] = space_glyph
;
2549 row
->used
[TEXT_AREA
] = i
;
2554 /**********************************************************************
2555 Mirroring operations on frame matrices in window matrices
2556 **********************************************************************/
2558 /* Set frame being updated via frame-based redisplay to F. This
2559 function must be called before updates to make explicit that we are
2560 working on frame matrices or not. */
2563 set_frame_matrix_frame (f
)
2566 frame_matrix_frame
= f
;
2570 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2571 DESIRED_MATRIX is the desired matrix corresponding to
2572 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2573 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2574 frame_matrix_frame is non-null, this indicates that the exchange is
2575 done in frame matrices, and that we have to perform analogous
2576 operations in window matrices of frame_matrix_frame. */
2579 make_current (desired_matrix
, current_matrix
, row
)
2580 struct glyph_matrix
*desired_matrix
, *current_matrix
;
2583 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, row
);
2584 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, row
);
2586 /* Do current_row = desired_row. This exchanges glyph pointers
2587 between both rows, and does a structure assignment otherwise. */
2588 assign_row (current_row
, desired_row
);
2590 /* Enable current_row to mark it as valid. */
2591 current_row
->enabled_p
= 1;
2593 /* If we are called on frame matrices, perform analogous operations
2594 for window matrices. */
2595 if (frame_matrix_frame
)
2596 mirror_make_current (XWINDOW (frame_matrix_frame
->root_window
), row
);
2600 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2601 W's frame which has been made current (by swapping pointers between
2602 current and desired matrix). Perform analogous operations in the
2603 matrices of leaf windows in the window tree rooted at W. */
2606 mirror_make_current (w
, frame_row
)
2612 if (!NILP (w
->hchild
))
2613 mirror_make_current (XWINDOW (w
->hchild
), frame_row
);
2614 else if (!NILP (w
->vchild
))
2615 mirror_make_current (XWINDOW (w
->vchild
), frame_row
);
2618 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2619 here because the checks performed in debug mode there
2620 will not allow the conversion. */
2621 int row
= frame_row
- w
->desired_matrix
->matrix_y
;
2623 /* If FRAME_ROW is within W, assign the desired row to the
2624 current row (exchanging glyph pointers). */
2625 if (row
>= 0 && row
< w
->desired_matrix
->matrix_h
)
2627 struct glyph_row
*current_row
2628 = MATRIX_ROW (w
->current_matrix
, row
);
2629 struct glyph_row
*desired_row
2630 = MATRIX_ROW (w
->desired_matrix
, row
);
2632 if (desired_row
->enabled_p
)
2633 assign_row (current_row
, desired_row
);
2635 swap_glyph_pointers (desired_row
, current_row
);
2636 current_row
->enabled_p
= 1;
2640 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2645 /* Perform row dance after scrolling. We are working on the range of
2646 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2647 including) in MATRIX. COPY_FROM is a vector containing, for each
2648 row I in the range 0 <= I < NLINES, the index of the original line
2649 to move to I. This index is relative to the row range, i.e. 0 <=
2650 index < NLINES. RETAINED_P is a vector containing zero for each
2651 row 0 <= I < NLINES which is empty.
2653 This function is called from do_scrolling and do_direct_scrolling. */
2656 mirrored_line_dance (matrix
, unchanged_at_top
, nlines
, copy_from
,
2658 struct glyph_matrix
*matrix
;
2659 int unchanged_at_top
, nlines
;
2663 /* A copy of original rows. */
2664 struct glyph_row
*old_rows
;
2666 /* Rows to assign to. */
2667 struct glyph_row
*new_rows
= MATRIX_ROW (matrix
, unchanged_at_top
);
2671 /* Make a copy of the original rows. */
2672 old_rows
= (struct glyph_row
*) alloca (nlines
* sizeof *old_rows
);
2673 bcopy (new_rows
, old_rows
, nlines
* sizeof *old_rows
);
2675 /* Assign new rows, maybe clear lines. */
2676 for (i
= 0; i
< nlines
; ++i
)
2678 int enabled_before_p
= new_rows
[i
].enabled_p
;
2680 xassert (i
+ unchanged_at_top
< matrix
->nrows
);
2681 xassert (unchanged_at_top
+ copy_from
[i
] < matrix
->nrows
);
2682 new_rows
[i
] = old_rows
[copy_from
[i
]];
2683 new_rows
[i
].enabled_p
= enabled_before_p
;
2685 /* RETAINED_P is zero for empty lines. */
2686 if (!retained_p
[copy_from
[i
]])
2687 new_rows
[i
].enabled_p
= 0;
2690 /* Do the same for window matrices, if MATRIX Is a frame matrix. */
2691 if (frame_matrix_frame
)
2692 mirror_line_dance (XWINDOW (frame_matrix_frame
->root_window
),
2693 unchanged_at_top
, nlines
, copy_from
, retained_p
);
2697 /* Perform a line dance in the window tree rooted at W, after
2698 scrolling a frame matrix in mirrored_line_dance.
2700 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
2701 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
2702 COPY_FROM is a vector containing, for each row I in the range 0 <=
2703 I < NLINES, the index of the original line to move to I. This
2704 index is relative to the row range, i.e. 0 <= index < NLINES.
2705 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
2709 mirror_line_dance (w
, unchanged_at_top
, nlines
, copy_from
, retained_p
)
2711 int unchanged_at_top
, nlines
;
2717 if (!NILP (w
->hchild
))
2718 mirror_line_dance (XWINDOW (w
->hchild
), unchanged_at_top
,
2719 nlines
, copy_from
, retained_p
);
2720 else if (!NILP (w
->vchild
))
2721 mirror_line_dance (XWINDOW (w
->vchild
), unchanged_at_top
,
2722 nlines
, copy_from
, retained_p
);
2725 /* W is a leaf window, and we are working on its current
2727 struct glyph_matrix
*m
= w
->current_matrix
;
2731 struct glyph_row
*old_rows
;
2733 /* Make a copy of the original rows of matrix m. */
2734 old_rows
= (struct glyph_row
*) alloca (m
->nrows
* sizeof *old_rows
);
2735 bcopy (m
->rows
, old_rows
, m
->nrows
* sizeof *old_rows
);
2737 for (i
= 0; i
< nlines
; ++i
)
2739 /* Frame relative line assigned to. */
2740 int frame_to
= i
+ unchanged_at_top
;
2742 /* Frame relative line assigned. */
2743 int frame_from
= copy_from
[i
] + unchanged_at_top
;
2745 /* Window relative line assigned to. */
2746 int window_to
= frame_to
- m
->matrix_y
;
2748 /* Window relative line assigned. */
2749 int window_from
= frame_from
- m
->matrix_y
;
2751 /* Is assigned line inside window? */
2752 int from_inside_window_p
2753 = window_from
>= 0 && window_from
< m
->matrix_h
;
2755 if (from_inside_window_p
)
2758 /* Is assigned to line inside window? */
2759 int to_inside_window_p
2760 = window_to
>= 0 && window_to
< m
->matrix_h
;
2763 /* Enabled setting before assignment. */
2764 int enabled_before_p
;
2766 /* If not both lines inside the window, we have a
2768 xassert (to_inside_window_p
);
2770 /* Do the assignment. The enabled_p flag is saved
2771 over the assignment because the old redisplay did
2773 enabled_before_p
= m
->rows
[window_to
].enabled_p
;
2774 m
->rows
[window_to
] = old_rows
[window_from
];
2775 m
->rows
[window_to
].enabled_p
= enabled_before_p
;
2777 /* If frame line is empty, window line is empty, too. */
2778 if (!retained_p
[copy_from
[i
]])
2779 m
->rows
[window_to
].enabled_p
= 0;
2783 /* Check that no pointers are lost. */
2787 /* Next window on same level. */
2788 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2795 /* Check that window and frame matrices agree about their
2796 understanding where glyphs of the rows are to find. For each
2797 window in the window tree rooted at W, check that rows in the
2798 matrices of leaf window agree with their frame matrices about
2802 check_window_matrix_pointers (w
)
2807 if (!NILP (w
->hchild
))
2808 check_window_matrix_pointers (XWINDOW (w
->hchild
));
2809 else if (!NILP (w
->vchild
))
2810 check_window_matrix_pointers (XWINDOW (w
->vchild
));
2813 struct frame
*f
= XFRAME (w
->frame
);
2814 check_matrix_pointers (w
->desired_matrix
, f
->desired_matrix
);
2815 check_matrix_pointers (w
->current_matrix
, f
->current_matrix
);
2818 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2823 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
2824 a window and FRAME_MATRIX is the corresponding frame matrix. For
2825 each row in WINDOW_MATRIX check that it's a slice of the
2826 corresponding frame row. If it isn't, abort. */
2829 check_matrix_pointers (window_matrix
, frame_matrix
)
2830 struct glyph_matrix
*window_matrix
, *frame_matrix
;
2832 /* Row number in WINDOW_MATRIX. */
2835 /* Row number corresponding to I in FRAME_MATRIX. */
2836 int j
= window_matrix
->matrix_y
;
2838 /* For all rows check that the row in the window matrix is a
2839 slice of the row in the frame matrix. If it isn't we didn't
2840 mirror an operation on the frame matrix correctly. */
2841 while (i
< window_matrix
->nrows
)
2843 if (!glyph_row_slice_p (window_matrix
->rows
+ i
,
2844 frame_matrix
->rows
+ j
))
2850 #endif /* GLYPH_DEBUG != 0 */
2854 /**********************************************************************
2855 VPOS and HPOS translations
2856 **********************************************************************/
2860 /* Translate vertical position VPOS which is relative to window W to a
2861 vertical position relative to W's frame. */
2864 window_to_frame_vpos (w
, vpos
)
2868 struct frame
*f
= XFRAME (w
->frame
);
2870 xassert (!FRAME_WINDOW_P (f
));
2871 xassert (vpos
>= 0 && vpos
<= w
->desired_matrix
->nrows
);
2872 vpos
+= XFASTINT (w
->top
);
2873 xassert (vpos
>= 0 && vpos
<= FRAME_HEIGHT (f
));
2878 /* Translate horizontal position HPOS which is relative to window W to
2879 a vertical position relative to W's frame. */
2882 window_to_frame_hpos (w
, hpos
)
2886 struct frame
*f
= XFRAME (w
->frame
);
2888 xassert (!FRAME_WINDOW_P (f
));
2889 hpos
+= XFASTINT (w
->left
);
2893 #endif /* GLYPH_DEBUG */
2897 /**********************************************************************
2899 **********************************************************************/
2901 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
2902 "Clear frame FRAME and output again what is supposed to appear on it.")
2908 CHECK_LIVE_FRAME (frame
, 0);
2911 /* Ignore redraw requests, if frame has no glyphs yet.
2912 (Implementation note: It still has to be checked why we are
2913 called so early here). */
2914 if (!glyphs_initialized_initially_p
)
2918 if (FRAME_MSDOS_P (f
))
2919 set_terminal_modes ();
2921 clear_current_matrices (f
);
2924 windows_or_buffers_changed
++;
2925 /* Mark all windows as inaccurate, so that every window will have
2926 its redisplay done. */
2927 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
2928 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
2934 /* Redraw frame F. This is nothing more than a call to the Lisp
2935 function redraw-frame. */
2942 XSETFRAME (frame
, f
);
2943 Fredraw_frame (frame
);
2947 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
2948 "Clear and redisplay all visible frames.")
2951 Lisp_Object tail
, frame
;
2953 FOR_EACH_FRAME (tail
, frame
)
2954 if (FRAME_VISIBLE_P (XFRAME (frame
)))
2955 Fredraw_frame (frame
);
2961 /* This is used when frame_garbaged is set. Call Fredraw_frame on all
2962 visible frames marked as garbaged. */
2965 redraw_garbaged_frames ()
2967 Lisp_Object tail
, frame
;
2969 FOR_EACH_FRAME (tail
, frame
)
2970 if (FRAME_VISIBLE_P (XFRAME (frame
))
2971 && FRAME_GARBAGED_P (XFRAME (frame
)))
2972 Fredraw_frame (frame
);
2977 /***********************************************************************
2979 ***********************************************************************/
2981 /* Try to update display and current glyph matrix directly.
2983 This function is called after a character G has been inserted into
2984 current_buffer. It tries to update the current glyph matrix and
2985 perform appropriate screen output to reflect the insertion. If it
2986 succeeds, the global flag redisplay_performed_directly_p will be
2987 set to 1, and thereby prevent the more costly general redisplay
2988 from running (see redisplay_internal).
2990 This function is not called for `hairy' character insertions.
2991 In particular, it is not called when after or before change
2992 functions exist, like they are used by font-lock. See keyboard.c
2993 for details where this function is called. */
2996 direct_output_for_insert (g
)
2999 register struct frame
*f
= SELECTED_FRAME ();
3000 struct window
*w
= XWINDOW (selected_window
);
3002 struct glyph_row
*glyph_row
;
3003 struct glyph
*glyphs
, *glyph
, *end
;
3005 /* Non-null means that Redisplay of W is based on window matrices. */
3006 int window_redisplay_p
= FRAME_WINDOW_P (f
);
3007 /* Non-null means we are in overwrite mode. */
3008 int overwrite_p
= !NILP (current_buffer
->overwrite_mode
);
3010 struct text_pos pos
;
3011 int delta
, delta_bytes
;
3013 /* Not done directly. */
3014 redisplay_performed_directly_p
= 0;
3016 /* Quickly give up for some common cases. */
3017 if (cursor_in_echo_area
3018 /* Give up if fonts have changed. */
3020 /* Give up if face attributes have been changed. */
3021 || face_change_count
3022 /* Give up if cursor position not really known. */
3023 || !display_completed
3024 /* Give up if buffer appears in two places. */
3025 || buffer_shared
> 1
3026 /* Give up if w is mini-buffer and a message is being displayed there */
3027 || (MINI_WINDOW_P (w
) && !NILP (echo_area_buffer
[0]))
3028 /* Give up for hscrolled mini-buffer because display of the prompt
3029 is handled specially there (see display_line). */
3030 || (MINI_WINDOW_P (w
) && XFASTINT (w
->hscroll
))
3031 /* Give up if overwriting in the middle of a line. */
3034 && FETCH_BYTE (PT
) != '\n')
3035 /* Give up for tabs and line ends. */
3039 /* Give up if unable to display the cursor in the window. */
3040 || w
->cursor
.vpos
< 0
3041 || (glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
),
3042 /* Can't do it in a continued line because continuation
3043 lines would change. */
3044 (glyph_row
->continued_p
3045 /* Can't use this method if the line overlaps others or is
3046 overlapped by others because these other lines would
3047 have to be redisplayed. */
3048 || glyph_row
->overlapping_p
3049 || glyph_row
->overlapped_p
))
3050 /* Can't do it for partial width windows on terminal frames
3051 because we can't clear to eol in such a window. */
3052 || (!window_redisplay_p
&& !WINDOW_FULL_WIDTH_P (w
)))
3055 /* Set up a display iterator structure for W. Glyphs will be
3056 produced in scratch_glyph_row. Current position is W's cursor
3058 clear_glyph_row (&scratch_glyph_row
);
3059 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
3061 init_iterator (&it
, w
, CHARPOS (pos
), BYTEPOS (pos
), &scratch_glyph_row
,
3064 glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3066 /* Give up if highlighting trailing whitespace and we have trailing
3067 whitespace in glyph_row. We would have to remove the trailing
3068 whitespace face in that case. */
3069 if (!NILP (Vshow_trailing_whitespace
)
3070 && glyph_row
->used
[TEXT_AREA
])
3074 last
= glyph_row
->glyphs
[TEXT_AREA
] + glyph_row
->used
[TEXT_AREA
] - 1;
3075 if (last
->type
== STRETCH_GLYPH
3076 || (last
->type
== CHAR_GLYPH
3077 && last
->u
.ch
.code
== ' '))
3081 /* Give up if there are overlay strings at pos. This would fail
3082 if the overlay string has newlines in it. */
3083 if (STRINGP (it
.string
))
3086 it
.hpos
= w
->cursor
.hpos
;
3087 it
.vpos
= w
->cursor
.vpos
;
3088 it
.current_x
= w
->cursor
.x
+ it
.first_visible_x
;
3089 it
.current_y
= w
->cursor
.y
;
3090 it
.end_charpos
= PT
;
3091 it
.stop_charpos
= min (PT
, it
.stop_charpos
);
3093 /* More than one display element may be returned for PT - 1 if
3094 (i) it's a control character which is translated into `\003' or
3095 `^C', or (ii) it has a display table entry, or (iii) it's a
3096 combination of both. */
3097 delta
= delta_bytes
= 0;
3098 while (get_next_display_element (&it
))
3100 PRODUCE_GLYPHS (&it
);
3102 /* Give up if glyph doesn't fit completely on the line. */
3103 if (it
.current_x
>= it
.last_visible_x
)
3106 /* Give up if new glyph has different ascent or descent than
3107 the original row, or if it is not a character glyph. */
3108 if (glyph_row
->ascent
!= it
.ascent
3109 || glyph_row
->height
!= it
.ascent
+ it
.descent
3110 || glyph_row
->phys_ascent
!= it
.phys_ascent
3111 || glyph_row
->phys_height
!= it
.phys_ascent
+ it
.phys_descent
3112 || it
.what
!= IT_CHARACTER
)
3116 delta_bytes
+= it
.len
;
3117 set_iterator_to_next (&it
);
3120 /* Give up if we hit the right edge of the window. We would have
3121 to insert truncation or continuation glyphs. */
3122 added_width
= it
.current_x
- (w
->cursor
.x
+ it
.first_visible_x
);
3123 if (glyph_row
->pixel_width
+ added_width
>= it
.last_visible_x
)
3126 /* Give up if there is a \t following in the line. */
3128 it2
.end_charpos
= ZV
;
3129 it2
.stop_charpos
= min (it2
.stop_charpos
, ZV
);
3130 while (get_next_display_element (&it2
)
3131 && !ITERATOR_AT_END_OF_LINE_P (&it2
))
3135 set_iterator_to_next (&it2
);
3138 /* Number of new glyphs produced. */
3139 n
= it
.glyph_row
->used
[TEXT_AREA
];
3141 /* Start and end of glyphs in original row. */
3142 glyphs
= glyph_row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
3143 end
= glyph_row
->glyphs
[1 + TEXT_AREA
];
3145 /* Make room for new glyphs, then insert them. */
3146 xassert (end
- glyphs
- n
>= 0);
3147 safe_bcopy ((char *) glyphs
, (char *) (glyphs
+ n
),
3148 (end
- glyphs
- n
) * sizeof (*end
));
3149 bcopy (it
.glyph_row
->glyphs
[TEXT_AREA
], glyphs
, n
* sizeof *glyphs
);
3150 glyph_row
->used
[TEXT_AREA
] = min (glyph_row
->used
[TEXT_AREA
] + n
,
3151 end
- glyph_row
->glyphs
[TEXT_AREA
]);
3153 /* Compute new line width. */
3154 glyph
= glyph_row
->glyphs
[TEXT_AREA
];
3155 end
= glyph
+ glyph_row
->used
[TEXT_AREA
];
3156 glyph_row
->pixel_width
= glyph_row
->x
;
3159 glyph_row
->pixel_width
+= glyph
->pixel_width
;
3163 /* Increment buffer positions for glyphs following the newly
3165 for (glyph
= glyphs
+ n
; glyph
< end
; ++glyph
)
3166 if (glyph
->charpos
> 0)
3167 glyph
->charpos
+= delta
;
3169 if (MATRIX_ROW_END_CHARPOS (glyph_row
) > 0)
3171 MATRIX_ROW_END_CHARPOS (glyph_row
) += delta
;
3172 MATRIX_ROW_END_BYTEPOS (glyph_row
) += delta_bytes
;
3175 /* Adjust positions in lines following the one we are in. */
3176 increment_glyph_matrix_buffer_positions (w
->current_matrix
,
3178 w
->current_matrix
->nrows
,
3179 delta
, delta_bytes
);
3181 glyph_row
->contains_overlapping_glyphs_p
3182 |= it
.glyph_row
->contains_overlapping_glyphs_p
;
3184 if (!NILP (Vshow_trailing_whitespace
))
3185 highlight_trailing_whitespace (it
.f
, glyph_row
);
3187 /* Write glyphs. If at end of row, we can simply call write_glyphs.
3188 In the middle, we have to insert glyphs. Note that this is now
3189 implemented for X frames. The implementation uses updated_window
3191 updated_row
= glyph_row
;
3195 rif
->update_window_begin_hook (w
);
3197 if (glyphs
== end
- n
)
3198 rif
->write_glyphs (glyphs
, n
);
3200 rif
->insert_glyphs (glyphs
, n
);
3204 if (glyphs
== end
- n
)
3205 write_glyphs (glyphs
, n
);
3207 insert_glyphs (glyphs
, n
);
3210 w
->cursor
.hpos
+= n
;
3211 w
->cursor
.x
= it
.current_x
- it
.first_visible_x
;
3212 xassert (w
->cursor
.hpos
>= 0
3213 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3215 /* How to set the cursor differs depending on whether we are
3216 using a frame matrix or a window matrix. Note that when
3217 a frame matrix is used, cursor_to expects frame coordinates,
3218 and the X and Y parameters are not used. */
3219 if (window_redisplay_p
)
3220 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3221 w
->cursor
.y
, w
->cursor
.x
);
3225 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3226 + (INTEGERP (w
->left_margin_width
)
3227 ? XFASTINT (w
->left_margin_width
)
3229 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3234 rif
->update_window_end_hook (w
, 1);
3239 TRACE ((stderr
, "direct output for insert\n"));
3241 UNCHANGED_MODIFIED
= MODIFF
;
3242 BEG_UNCHANGED
= GPT
- BEG
;
3243 XSETFASTINT (w
->last_point
, PT
);
3244 w
->last_cursor
= w
->cursor
;
3245 XSETFASTINT (w
->last_modified
, MODIFF
);
3246 XSETFASTINT (w
->last_overlay_modified
, OVERLAY_MODIFF
);
3248 redisplay_performed_directly_p
= 1;
3253 /* Perform a direct display update for moving PT by N positions
3254 left or right. N < 0 means a movement backwards. This function
3255 is currently only called for N == 1 or N == -1. */
3258 direct_output_forward_char (n
)
3261 struct frame
*f
= SELECTED_FRAME ();
3262 struct window
*w
= XWINDOW (selected_window
);
3263 struct glyph_row
*row
;
3265 /* Give up if face attributes have been changed. */
3266 if (face_change_count
)
3269 /* Give up if current matrix is not up to date or we are
3270 displaying a message. */
3271 if (!display_completed
|| cursor_in_echo_area
)
3274 /* Give up if the buffer's direction is reversed. */
3275 if (!NILP (XBUFFER (w
->buffer
)->direction_reversed
))
3278 /* Can't use direct output if highlighting a region. */
3279 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
3282 /* Can't use direct output if highlighting trailing whitespace. */
3283 if (!NILP (Vshow_trailing_whitespace
))
3286 /* Give up if we are showing a message or just cleared the message
3287 because we might need to resize the echo area window. */
3288 if (!NILP (echo_area_buffer
[0]) || !NILP (echo_area_buffer
[1]))
3291 /* Give up if we don't know where the cursor is. */
3292 if (w
->cursor
.vpos
< 0)
3295 row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3297 if (PT
<= MATRIX_ROW_START_BYTEPOS (row
)
3298 || PT
>= MATRIX_ROW_END_BYTEPOS (row
))
3301 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
3302 w
->last_cursor
= w
->cursor
;
3303 XSETFASTINT (w
->last_point
, PT
);
3305 xassert (w
->cursor
.hpos
>= 0
3306 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3308 if (FRAME_WINDOW_P (f
))
3309 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3310 w
->cursor
.y
, w
->cursor
.x
);
3314 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3315 + (INTEGERP (w
->left_margin_width
)
3316 ? XFASTINT (w
->left_margin_width
)
3318 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3323 redisplay_performed_directly_p
= 1;
3329 /***********************************************************************
3331 ***********************************************************************/
3333 /* Update frame F based on the data in desired matrices.
3335 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3336 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3339 Value is non-zero if redisplay was stopped due to pending input. */
3342 update_frame (f
, force_p
, inhibit_hairy_id_p
)
3345 int inhibit_hairy_id_p
;
3347 /* 1 means display has been paused because of pending input. */
3349 struct window
*root_window
= XWINDOW (f
->root_window
);
3351 if (FRAME_WINDOW_P (f
))
3353 /* We are working on window matrix basis. All windows whose
3354 flag must_be_updated_p is set have to be updated. */
3356 /* Record that we are not working on frame matrices. */
3357 set_frame_matrix_frame (NULL
);
3359 /* Update all windows in the window tree of F, maybe stopping
3360 when pending input is detected. */
3363 /* Update the menu bar on X frames that don't have toolkit
3365 if (WINDOWP (f
->menu_bar_window
))
3366 update_window (XWINDOW (f
->menu_bar_window
), 1);
3368 /* Update the tool-bar window, if present. */
3369 if (WINDOWP (f
->tool_bar_window
))
3372 struct window
*w
= XWINDOW (f
->tool_bar_window
);
3374 /* Update tool-bar window. */
3375 if (w
->must_be_updated_p
)
3377 update_window (w
, 1);
3378 w
->must_be_updated_p
= 0;
3380 /* Swap tool-bar strings. We swap because we want to
3382 tem
= f
->current_tool_bar_string
;
3383 f
->current_tool_bar_string
= f
->desired_tool_bar_string
;
3384 f
->desired_tool_bar_string
= tem
;
3385 f
->n_current_tool_bar_items
= f
->n_desired_tool_bar_items
;
3387 /* Swap tool-bar items. We swap because we want to
3389 tem
= f
->current_tool_bar_items
;
3390 f
->current_tool_bar_items
= f
->desired_tool_bar_items
;
3391 f
->desired_tool_bar_items
= tem
;
3396 /* Update windows. */
3397 paused_p
= update_window_tree (root_window
, force_p
);
3399 display_completed
= !paused_p
;
3401 /* The flush is a performance bottleneck under X. */
3403 rif
->flush_display (f
);
3408 /* We are working on frame matrix basis. Set the frame on whose
3409 frame matrix we operate. */
3410 set_frame_matrix_frame (f
);
3412 /* Build F's desired matrix from window matrices. For windows
3413 whose must_be_updated_p flag is set, desired matrices are
3414 made part of the desired frame matrix. For other windows,
3415 the current matrix is copied. */
3416 build_frame_matrix (f
);
3418 /* Do the update on the frame desired matrix. */
3419 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3421 /* Check window matrices for lost pointers. */
3422 IF_DEBUG (check_window_matrix_pointers (root_window
));
3425 /* Reset flags indicating that a window should be updated. */
3426 set_window_update_flags (root_window
, 0);
3432 /************************************************************************
3433 Window-based updates
3434 ************************************************************************/
3436 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3437 don't stop updating when input is pending. */
3440 update_window_tree (w
, force_p
)
3446 while (w
&& !paused_p
)
3448 if (!NILP (w
->hchild
))
3449 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
3450 else if (!NILP (w
->vchild
))
3451 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
3452 else if (w
->must_be_updated_p
)
3453 paused_p
|= update_window (w
, force_p
);
3455 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3462 /* Update window W if its flag must_be_updated_p is non-zero. If
3463 FORCE_P is non-zero, don't stop updating if input is pending. */
3466 update_single_window (w
, force_p
)
3470 if (w
->must_be_updated_p
)
3472 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3474 /* Record that this is not a frame-based redisplay. */
3475 set_frame_matrix_frame (NULL
);
3479 update_window (w
, force_p
);
3482 /* Reset flag in W. */
3483 w
->must_be_updated_p
= 0;
3488 /* Redraw lines from the current matrix of window W that are
3489 overlapped by other rows. YB is bottom-most y-position in W. */
3492 redraw_overlapped_rows (w
, yb
)
3497 struct glyph_row
*row
;
3499 /* If rows overlapping others have been changed, the rows being
3500 overlapped have to be redrawn. This won't draw lines that have
3501 already been drawn in update_window_line because overlapped_p in
3502 desired rows is 0, so after row assignment overlapped_p in
3503 current rows is 0. */
3504 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3506 row
= w
->current_matrix
->rows
+ i
;
3508 if (!row
->enabled_p
)
3510 else if (row
->mode_line_p
)
3513 if (row
->overlapped_p
)
3515 enum glyph_row_area area
;
3517 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3520 updated_area
= area
;
3521 rif
->cursor_to (i
, 0, row
->y
, area
== TEXT_AREA
? row
->x
: 0);
3522 if (row
->used
[area
])
3523 rif
->write_glyphs (row
->glyphs
[area
], row
->used
[area
]);
3524 rif
->clear_end_of_line (-1);
3527 row
->overlapped_p
= 0;
3530 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3537 /* Redraw lines from the current matrix of window W that overlap
3538 others. YB is bottom-most y-position in W. */
3541 redraw_overlapping_rows (w
, yb
)
3546 struct glyph_row
*row
;
3548 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3550 row
= w
->current_matrix
->rows
+ i
;
3552 if (!row
->enabled_p
)
3554 else if (row
->mode_line_p
)
3557 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3559 if (row
->overlapping_p
&& i
> 0 && bottom_y
< yb
)
3561 if (row
->used
[LEFT_MARGIN_AREA
])
3562 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
);
3564 if (row
->used
[TEXT_AREA
])
3565 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
);
3567 if (row
->used
[RIGHT_MARGIN_AREA
])
3568 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
);
3570 /* Record in neighbor rows that ROW overwrites part of their
3572 if (row
->phys_ascent
> row
->ascent
&& i
> 0)
3573 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3574 if ((row
->phys_height
- row
->phys_ascent
3575 > row
->height
- row
->ascent
)
3577 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
3586 /* Update display of window W. FORCE_P non-zero means that we should
3587 not stop when detecting pending input. */
3590 update_window (w
, force_p
)
3594 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
3596 int preempt_count
= baud_rate
/ 2400 + 1;
3597 extern int input_pending
;
3599 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3600 extern struct frame
*updating_frame
;
3603 /* Check that W's frame doesn't have glyph matrices. */
3604 xassert (FRAME_WINDOW_P (f
));
3605 xassert (updating_frame
!= NULL
);
3607 /* Check pending input the first time so that we can quickly return. */
3608 if (redisplay_dont_pause
)
3611 detect_input_pending ();
3613 /* If forced to complete the update, or if no input is pending, do
3615 if (force_p
|| !input_pending
)
3617 struct glyph_row
*row
, *end
;
3618 struct glyph_row
*mode_line_row
;
3619 struct glyph_row
*header_line_row
= NULL
;
3620 int yb
, changed_p
= 0;
3622 rif
->update_window_begin_hook (w
);
3623 yb
= window_text_bottom_y (w
);
3625 /* If window has a top line, update it before everything else.
3626 Adjust y-positions of other rows by the top line height. */
3627 row
= desired_matrix
->rows
;
3628 end
= row
+ desired_matrix
->nrows
- 1;
3629 if (row
->mode_line_p
)
3630 header_line_row
= row
++;
3632 /* Update the mode line, if necessary. */
3633 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3634 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
3636 mode_line_row
->y
= yb
;
3637 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
3642 /* Find first enabled row. Optimizations in redisplay_internal
3643 may lead to an update with only one row enabled. There may
3644 be also completely empty matrices. */
3645 while (row
< end
&& !row
->enabled_p
)
3648 /* Try reusing part of the display by inserting/deleting lines. */
3649 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
3651 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
3654 /* All rows were found to be equal. */
3663 /* Update the top mode line after scrolling because a new top
3664 line would otherwise overwrite lines at the top of the window
3665 that can be scrolled. */
3666 if (header_line_row
&& header_line_row
->enabled_p
)
3668 header_line_row
->y
= 0;
3669 update_window_line (w
, 0);
3673 /* Update the rest of the lines. */
3674 for (; row
< end
&& (force_p
|| !input_pending
); ++row
)
3676 /* A row can be completely invisible in case a desired
3677 matrix was built with a vscroll and then
3678 make_cursor_line_fully_visible shifts the matrix. */
3679 && row
->visible_height
> 0)
3681 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
3684 /* We'll Have to play a little bit with when to
3685 detect_input_pending. If it's done too often,
3686 scrolling large windows with repeated scroll-up
3687 commands will too quickly pause redisplay. */
3688 if (!force_p
&& vpos
% preempt_count
== 0)
3689 detect_input_pending ();
3691 changed_p
|= update_window_line (w
, vpos
);
3693 /* Mark all rows below the last visible one in the current
3694 matrix as invalid. This is necessary because of
3695 variable line heights. Consider the case of three
3696 successive redisplays, where the first displays 5
3697 lines, the second 3 lines, and the third 5 lines again.
3698 If the second redisplay wouldn't mark rows in the
3699 current matrix invalid, the third redisplay might be
3700 tempted to optimize redisplay based on lines displayed
3701 in the first redisplay. */
3702 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3703 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
3704 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
3707 /* Was display preempted? */
3708 paused_p
= row
< end
;
3712 /* Fix the appearance of overlapping(overlapped rows. */
3713 if (rif
->fix_overlapping_area
3714 && !w
->pseudo_window_p
3718 redraw_overlapped_rows (w
, yb
);
3719 redraw_overlapping_rows (w
, yb
);
3722 if (!paused_p
&& !w
->pseudo_window_p
)
3724 /* Make cursor visible at cursor position of W. */
3725 set_window_cursor_after_update (w
);
3728 /* Check that current matrix invariants are satisfied. This
3729 is for debugging only. See the comment around
3730 check_matrix_invariants. */
3731 IF_DEBUG (check_matrix_invariants (w
));
3736 /* Remember the redisplay method used to display the matrix. */
3737 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
3740 /* End of update of window W. */
3741 rif
->update_window_end_hook (w
, 1);
3747 clear_glyph_matrix (desired_matrix
);
3753 /* Update the display of area AREA in window W, row number VPOS.
3754 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3757 update_marginal_area (w
, area
, vpos
)
3761 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3763 /* Let functions in xterm.c know what area subsequent X positions
3764 will be relative to. */
3765 updated_area
= area
;
3767 /* Set cursor to start of glyphs, write them, and clear to the end
3768 of the area. I don't think that something more sophisticated is
3769 necessary here, since marginal areas will not be the default. */
3770 rif
->cursor_to (vpos
, 0, desired_row
->y
, 0);
3771 if (desired_row
->used
[area
])
3772 rif
->write_glyphs (desired_row
->glyphs
[area
], desired_row
->used
[area
]);
3773 rif
->clear_end_of_line (-1);
3777 /* Update the display of the text area of row VPOS in window W.
3778 Value is non-zero if display has changed. */
3781 update_text_area (w
, vpos
)
3785 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3786 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3789 /* Let functions in xterm.c know what area subsequent X positions
3790 will be relative to. */
3791 updated_area
= TEXT_AREA
;
3793 /* If rows are at different X or Y, or rows have different height,
3794 or the current row is marked invalid, write the entire line. */
3795 if (!current_row
->enabled_p
3796 || desired_row
->y
!= current_row
->y
3797 || desired_row
->ascent
!= current_row
->ascent
3798 || desired_row
->phys_ascent
!= current_row
->phys_ascent
3799 || desired_row
->phys_height
!= current_row
->phys_height
3800 || desired_row
->visible_height
!= current_row
->visible_height
3801 || current_row
->overlapped_p
3802 || current_row
->x
!= desired_row
->x
)
3804 rif
->cursor_to (vpos
, 0, desired_row
->y
, desired_row
->x
);
3806 if (desired_row
->used
[TEXT_AREA
])
3807 rif
->write_glyphs (desired_row
->glyphs
[TEXT_AREA
],
3808 desired_row
->used
[TEXT_AREA
]);
3810 /* Clear to end of window. */
3811 rif
->clear_end_of_line (-1);
3817 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
3818 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
3820 /* If the desired row extends its face to the text area end,
3821 make sure we write at least one glyph, so that the face
3822 extension actually takes place. */
3823 int desired_stop_pos
= (desired_row
->used
[TEXT_AREA
]
3824 - (MATRIX_ROW_EXTENDS_FACE_P (desired_row
)
3827 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
3833 /* Skip over glyphs that both rows have in common. These
3834 don't have to be written. */
3836 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3838 x
+= desired_glyph
->pixel_width
;
3839 ++desired_glyph
, ++current_glyph
, ++i
;
3842 /* Consider the case that the current row contains "xxx ppp
3843 ggg" in italic Courier font, and the desired row is "xxx
3844 ggg". The character `p' has lbearing, `g' has not. The
3845 loop above will stop in front of the first `p' in the
3846 current row. If we would start writing glyphs there, we
3847 wouldn't erase the lbearing of the `p'. The rest of the
3848 lbearing problem is then taken care of by x_draw_glyphs. */
3849 if (current_row
->contains_overlapping_glyphs_p
3851 && i
< current_row
->used
[TEXT_AREA
]
3852 && current_row
->used
[TEXT_AREA
] != desired_row
->used
[TEXT_AREA
])
3855 rif
->get_glyph_overhangs (current_glyph
, XFRAME (w
->frame
),
3857 while (left
> 0 && i
> 0)
3859 --i
, --desired_glyph
, --current_glyph
;
3860 x
-= desired_glyph
->pixel_width
;
3861 left
-= desired_glyph
->pixel_width
;
3865 /* Try to avoid writing the entire rest of the desired row
3866 by looking for a resync point. This mainly prevents
3867 mode line flickering in the case the mode line is in
3868 fixed-pitch font, which it usually will be. */
3869 if (i
< desired_row
->used
[TEXT_AREA
])
3871 int start_x
= x
, start_hpos
= i
;
3872 struct glyph
*start
= desired_glyph
;
3875 /* Find the next glyph that's equal again. */
3877 && !GLYPH_EQUAL_P (desired_glyph
, current_glyph
)
3880 x
+= desired_glyph
->pixel_width
;
3881 current_x
+= current_glyph
->pixel_width
;
3882 ++desired_glyph
, ++current_glyph
, ++i
;
3885 if (i
== start_hpos
|| x
!= current_x
)
3889 desired_glyph
= start
;
3893 rif
->cursor_to (vpos
, start_hpos
, desired_row
->y
, start_x
);
3894 rif
->write_glyphs (start
, i
- start_hpos
);
3899 /* Write the rest. */
3900 if (i
< desired_row
->used
[TEXT_AREA
])
3902 rif
->cursor_to (vpos
, i
, desired_row
->y
, x
);
3903 rif
->write_glyphs (desired_glyph
, desired_row
->used
[TEXT_AREA
] - i
);
3907 /* Maybe clear to end of line. */
3908 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
3910 /* If new row extends to the end of the text area, nothing
3911 has to be cleared, if and only if we did a write_glyphs
3912 above. This is made sure by setting desired_stop_pos
3913 appropriately above. */
3914 xassert (i
< desired_row
->used
[TEXT_AREA
]);
3916 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
3918 /* If old row extends to the end of the text area, clear. */
3919 if (i
>= desired_row
->used
[TEXT_AREA
])
3920 rif
->cursor_to (vpos
, i
, desired_row
->y
,
3921 desired_row
->x
+ desired_row
->pixel_width
);
3922 rif
->clear_end_of_line (-1);
3925 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
3927 /* Otherwise clear to the end of the old row. Everything
3928 after that position should be clear already. */
3931 if (i
>= desired_row
->used
[TEXT_AREA
])
3932 rif
->cursor_to (vpos
, i
, desired_row
->y
,
3933 desired_row
->x
+ desired_row
->pixel_width
);
3935 /* If cursor is displayed at the end of the line, make sure
3936 it's cleared. Nowadays we don't have a phys_cursor_glyph
3937 with which to erase the cursor (because this method
3938 doesn't work with lbearing/rbearing), so we must do it
3940 if (vpos
== w
->phys_cursor
.vpos
3941 && w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])
3943 w
->phys_cursor_on_p
= 0;
3947 x
= current_row
->x
+ current_row
->pixel_width
;
3948 rif
->clear_end_of_line (x
);
3957 /* Update row VPOS in window W. Value is non-zero if display has been
3961 update_window_line (w
, vpos
)
3965 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3966 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3969 xassert (desired_row
->enabled_p
);
3971 /* Set the row being updated. This is important to let xterm.c
3972 know what line height values are in effect. */
3973 updated_row
= desired_row
;
3975 /* Update display of the left margin area, if there is one. */
3976 if (!desired_row
->full_width_p
3977 && !NILP (w
->left_margin_width
))
3979 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
3983 /* Update the display of the text area. */
3984 changed_p
|= update_text_area (w
, vpos
);
3986 /* Update display of the right margin area, if there is one. */
3987 if (!desired_row
->full_width_p
3988 && !NILP (w
->right_margin_width
))
3991 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
3994 /* Draw truncation marks etc. */
3995 if (!current_row
->enabled_p
3996 || desired_row
->y
!= current_row
->y
3997 || desired_row
->visible_height
!= current_row
->visible_height
3998 || desired_row
->overlay_arrow_p
!= current_row
->overlay_arrow_p
3999 || desired_row
->truncated_on_left_p
!= current_row
->truncated_on_left_p
4000 || desired_row
->truncated_on_right_p
!= current_row
->truncated_on_right_p
4001 || desired_row
->continued_p
!= current_row
->continued_p
4002 || desired_row
->mode_line_p
!= current_row
->mode_line_p
4003 || (desired_row
->indicate_empty_line_p
4004 != current_row
->indicate_empty_line_p
)
4005 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
4006 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
4007 rif
->after_update_window_line_hook (desired_row
);
4009 /* Update current_row from desired_row. */
4010 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4016 /* Set the cursor after an update of window W. This function may only
4017 be called from update_window. */
4020 set_window_cursor_after_update (w
)
4023 struct frame
*f
= XFRAME (w
->frame
);
4024 int cx
, cy
, vpos
, hpos
;
4026 /* Not intended for frame matrix updates. */
4027 xassert (FRAME_WINDOW_P (f
));
4029 if (cursor_in_echo_area
4030 && !NILP (echo_area_buffer
[0])
4031 /* If we are showing a message instead of the mini-buffer,
4032 show the cursor for the message instead. */
4033 && XWINDOW (minibuf_window
) == w
4034 && EQ (minibuf_window
, echo_area_window
)
4035 /* These cases apply only to the frame that contains
4036 the active mini-buffer window. */
4037 && FRAME_HAS_MINIBUF_P (f
)
4038 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4040 cx
= cy
= vpos
= hpos
= 0;
4042 if (cursor_in_echo_area
>= 0)
4044 /* If the mini-buffer is several lines high, find the last
4045 line that has any text on it. Note: either all lines
4046 are enabled or none. Otherwise we wouldn't be able to
4048 struct glyph_row
*row
, *last_row
;
4049 struct glyph
*glyph
;
4050 int yb
= window_text_bottom_y (w
);
4053 for (row
= MATRIX_ROW (w
->current_matrix
, 0);
4057 if (row
->used
[TEXT_AREA
]
4058 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4061 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4067 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
4068 struct glyph
*last
= start
+ row
->used
[TEXT_AREA
] - 1;
4070 while (last
> start
&& last
->charpos
< 0)
4073 for (glyph
= start
; glyph
< last
; ++glyph
)
4075 cx
+= glyph
->pixel_width
;
4080 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4088 hpos
= w
->cursor
.hpos
;
4089 vpos
= w
->cursor
.vpos
;
4092 /* Window cursor can be out of sync for horizontally split windows. */
4093 hpos
= max (0, hpos
);
4094 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4095 vpos
= max (0, vpos
);
4096 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4097 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4101 /* Try to reuse part of the current display of W by scrolling lines.
4102 HEADER_LINE_P non-zero means W has a top mode line.
4104 The algorithm is taken from Communications of the ACM, Apr78 "A
4105 Technique for Isolating Differences Between Files." It should take
4108 A short outline of the steps of the algorithm
4110 1. Skip lines equal at the start and end of both matrices.
4112 2. Enter rows in the current and desired matrix into a symbol
4113 table, counting how often they appear in both matrices.
4115 3. Rows that appear exactly once in both matrices serve as anchors,
4116 i.e. we assume that such lines are likely to have been moved.
4118 4. Starting from anchor lines, extend regions to be scrolled both
4119 forward and backward.
4123 -1 if all rows were found to be equal.
4124 0 to indicate that we did not scroll the display, or
4125 1 if we did scroll. */
4128 scrolling_window (w
, header_line_p
)
4134 /* Number of occurrences of this line in old and new matrix. */
4135 short old_uses
, new_uses
;
4137 /* Vpos of line in new matrix. */
4138 short new_line_number
;
4140 /* The line itself. */
4141 struct glyph_row
*row
;
4143 /* Hash collision chain. */
4144 struct symbol
*next
;
4147 int SYMBOL_TABLE_SIZE
= 101;
4148 struct symbol
**table
;
4149 struct symbol
**old_line_syms
, **new_line_syms
;
4150 int i
, j
, first_old
, first_new
, last_old
, last_new
;
4154 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4155 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4156 int yb
= window_text_bottom_y (w
);
4158 /* Skip over rows equal at the start. */
4159 i
= header_line_p
? 1 : 0;
4160 while (i
< current_matrix
->nrows
- 1
4161 && MATRIX_ROW_ENABLED_P (current_matrix
, i
)
4162 && MATRIX_ROW_ENABLED_P (desired_matrix
, i
)
4163 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) < yb
4164 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) < yb
4166 MATRIX_ROW (desired_matrix
, i
),
4167 MATRIX_ROW (current_matrix
, i
)))
4169 assign_row (MATRIX_ROW (current_matrix
, i
),
4170 MATRIX_ROW (desired_matrix
, i
));
4171 MATRIX_ROW (desired_matrix
, i
)->enabled_p
= 0;
4175 /* Give up if some rows in the desired matrix are not enabled. */
4176 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4179 first_old
= first_new
= i
;
4181 /* Set last_new to the index + 1 of the last enabled row in the
4184 while (i
< desired_matrix
->nrows
- 1
4185 && MATRIX_ROW (desired_matrix
, i
)->enabled_p
4186 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) < yb
)
4189 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4194 /* Set last_old to the index + 1 of the last enabled row in the
4195 current matrix. We don't look at the enabled flag here because
4196 we plan to reuse part of the display even if other parts are
4199 while (i
< current_matrix
->nrows
- 1
4200 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) < yb
)
4204 /* Skip over rows equal at the bottom. */
4207 while (i
- 1 > first_new
4208 && j
- 1 > first_old
4209 && MATRIX_ROW (current_matrix
, i
- 1)->enabled_p
4210 && (MATRIX_ROW (current_matrix
, i
- 1)->y
4211 == MATRIX_ROW (desired_matrix
, j
- 1)->y
)
4213 MATRIX_ROW (desired_matrix
, i
- 1),
4214 MATRIX_ROW (current_matrix
, j
- 1)))
4219 /* Nothing to do if all rows are equal. */
4220 if (last_new
== first_new
)
4223 /* Allocate a hash table in which all rows will be inserted. */
4224 table
= (struct symbol
**) alloca (SYMBOL_TABLE_SIZE
* sizeof *table
);
4225 bzero (table
, SYMBOL_TABLE_SIZE
* sizeof *table
);
4227 /* For each row in the current matrix, record the symbol belonging
4228 to the row in OLD_LINE_SYMS. */
4229 old_line_syms
= (struct symbol
**) alloca (current_matrix
->nrows
4230 * sizeof *old_line_syms
);
4231 new_line_syms
= (struct symbol
**) alloca (desired_matrix
->nrows
4232 * sizeof *new_line_syms
);
4234 #define ADDSYM(ROW) \
4237 struct glyph_row *row_ = (ROW); \
4238 int i_ = row_->hash % SYMBOL_TABLE_SIZE; \
4240 while (sym && !row_equal_p (w, sym->row, row_)) \
4244 sym = (struct symbol *) alloca (sizeof *sym); \
4246 sym->old_uses = sym->new_uses = 0; \
4247 sym->next = table[i_]; \
4253 /* Add current rows to the symbol table. */
4254 for (i
= first_old
; i
< last_old
; ++i
)
4256 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4258 ADDSYM (MATRIX_ROW (current_matrix
, i
));
4259 old_line_syms
[i
] = sym
;
4263 old_line_syms
[i
] = NULL
;
4266 /* Add desired rows to the symbol table. */
4267 for (i
= first_new
; i
< last_new
; ++i
)
4269 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4270 ADDSYM (MATRIX_ROW (desired_matrix
, i
));
4272 new_line_syms
[i
] = sym
;
4273 sym
->new_line_number
= i
;
4278 /* Record in runs which moves were found, ordered by pixel
4279 height of copied areas. */
4281 runs
= (struct run
**) alloca (desired_matrix
->nrows
* sizeof *runs
);
4283 /* Identify moves based on lines that are unique and equal
4284 in both matrices. */
4285 for (i
= first_old
; i
< last_old
;)
4286 if (old_line_syms
[i
]
4287 && old_line_syms
[i
]->old_uses
== 1
4288 && old_line_syms
[i
]->new_uses
== 1)
4291 int new_line
= old_line_syms
[i
]->new_line_number
;
4292 struct run
*run
= (struct run
*) alloca (sizeof *run
);
4295 run
->current_vpos
= i
;
4296 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4297 run
->desired_vpos
= new_line
;
4298 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4300 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4302 /* Extend backward. */
4305 while (j
> first_old
4307 && old_line_syms
[j
] == new_line_syms
[k
])
4309 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4310 --run
->current_vpos
;
4311 --run
->desired_vpos
;
4314 run
->desired_y
-= h
;
4315 run
->current_y
-= h
;
4319 /* Extend forward. */
4324 && old_line_syms
[j
] == new_line_syms
[k
])
4326 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4332 /* Insert run into list of all runs. Order runs by copied
4333 pixel lines. Note that we record runs that don't have to
4334 be copied because they are already in place. This is done
4335 because we can avoid calling update_window_line in this
4337 for (j
= 0; j
< nruns
&& runs
[j
]->height
> run
->height
; ++j
)
4339 for (k
= nruns
; k
>= j
; --k
)
4340 runs
[k
] = runs
[k
- 1];
4349 /* Do the moves. Do it in a way that we don't overwrite something
4350 we want to copy later on. This is not solvable in general
4351 because there is only one display and we don't have a way to
4352 exchange areas on this display. Example:
4354 +-----------+ +-----------+
4356 +-----------+ --> +-----------+
4358 +-----------+ +-----------+
4360 Instead, prefer bigger moves, and invalidate moves that would
4361 copy from where we copied to. */
4363 for (i
= 0; i
< nruns
; ++i
)
4364 if (runs
[i
]->nrows
> 0)
4366 struct run
*r
= runs
[i
];
4368 /* Copy on the display. */
4369 if (r
->current_y
!= r
->desired_y
)
4371 rif
->scroll_run_hook (w
, r
);
4373 /* Invalidate runs that copy from where we copied to. */
4374 for (j
= i
+ 1; j
< nruns
; ++j
)
4376 struct run
*p
= runs
[j
];
4378 if ((p
->current_y
>= r
->desired_y
4379 && p
->current_y
< r
->desired_y
+ r
->height
)
4380 || (p
->current_y
+ p
->height
>= r
->desired_y
4381 && (p
->current_y
+ p
->height
4382 < r
->desired_y
+ r
->height
)))
4387 /* Assign matrix rows. */
4388 for (j
= 0; j
< r
->nrows
; ++j
)
4390 struct glyph_row
*from
, *to
;
4391 int to_overlapped_p
;
4393 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
4394 to_overlapped_p
= to
->overlapped_p
;
4395 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
4396 assign_row (to
, from
);
4397 to
->enabled_p
= 1, from
->enabled_p
= 0;
4398 to
->overlapped_p
= to_overlapped_p
;
4402 /* Value is non-zero to indicate that we scrolled the display. */
4407 /* Set WINDOW->must_be_updated_p TO ON_P for all windows WINDOW in the
4408 window tree rooted at W. */
4411 set_window_update_flags (w
, on_p
)
4417 if (!NILP (w
->hchild
))
4418 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4419 else if (!NILP (w
->vchild
))
4420 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4422 w
->must_be_updated_p
= on_p
;
4424 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4430 /************************************************************************
4432 ************************************************************************/
4434 /* Update the desired frame matrix of frame F.
4436 FORCE_P non-zero means that the update should not be stopped by
4437 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
4438 should not be tried.
4440 Value is non-zero if update was stopped due to pending input. */
4443 update_frame_1 (f
, force_p
, inhibit_id_p
)
4448 /* Frame matrices to work on. */
4449 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4450 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4453 int preempt_count
= baud_rate
/ 2400 + 1;
4454 extern int input_pending
;
4456 xassert (current_matrix
&& desired_matrix
);
4458 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
4459 calculate_costs (f
);
4461 if (preempt_count
<= 0)
4464 detect_input_pending ();
4465 if (input_pending
&& !force_p
)
4473 /* If we cannot insert/delete lines, it's no use trying it. */
4474 if (!line_ins_del_ok
)
4477 /* See if any of the desired lines are enabled; don't compute for
4478 i/d line if just want cursor motion. */
4479 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
4480 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4483 /* Try doing i/d line, if not yet inhibited. */
4484 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
4485 force_p
|= scrolling (f
);
4487 /* Update the individual lines as needed. Do bottom line first. */
4488 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
4489 update_frame_line (f
, desired_matrix
->nrows
- 1);
4491 /* Now update the rest of the lines. */
4492 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
4494 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4496 if (FRAME_TERMCAP_P (f
))
4498 /* Flush out every so many lines.
4499 Also flush out if likely to have more than 1k buffered
4500 otherwise. I'm told that some telnet connections get
4501 really screwed by more than 1k output at once. */
4502 int outq
= PENDING_OUTPUT_COUNT (stdout
);
4504 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
4507 if (preempt_count
== 1)
4509 #ifdef EMACS_OUTQSIZE
4510 if (EMACS_OUTQSIZE (0, &outq
) < 0)
4511 /* Probably not a tty. Ignore the error and reset
4512 * the outq count. */
4513 outq
= PENDING_OUTPUT_COUNT (stdout
);
4516 if (baud_rate
<= outq
&& baud_rate
> 0)
4517 sleep (outq
/ baud_rate
);
4522 if ((i
- 1) % preempt_count
== 0)
4523 detect_input_pending ();
4525 update_frame_line (f
, i
);
4529 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
4531 /* Now just clean up termcap drivers and set cursor, etc. */
4534 if ((cursor_in_echo_area
4535 /* If we are showing a message instead of the mini-buffer,
4536 show the cursor for the message instead of for the
4537 (now hidden) mini-buffer contents. */
4538 || (EQ (minibuf_window
, selected_window
)
4539 && EQ (minibuf_window
, echo_area_window
)
4540 && !NILP (echo_area_buffer
[0])))
4541 /* These cases apply only to the frame that contains
4542 the active mini-buffer window. */
4543 && FRAME_HAS_MINIBUF_P (f
)
4544 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4546 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
4549 if (cursor_in_echo_area
< 0)
4551 /* Negative value of cursor_in_echo_area means put
4552 cursor at beginning of line. */
4558 /* Positive value of cursor_in_echo_area means put
4559 cursor at the end of the prompt. If the mini-buffer
4560 is several lines high, find the last line that has
4562 row
= FRAME_HEIGHT (f
);
4568 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
4570 /* Frame rows are filled up with spaces that
4571 must be ignored here. */
4572 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
4574 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
4575 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
4578 && (last
- 1)->charpos
< 0)
4584 while (row
> top
&& col
== 0);
4586 /* Make sure COL is not out of range. */
4587 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
4589 /* If we have another row, advance cursor into it. */
4590 if (row
< FRAME_HEIGHT (f
) - 1)
4592 col
= FRAME_LEFT_SCROLL_BAR_WIDTH (f
);
4595 /* Otherwise move it back in range. */
4597 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
4601 cursor_to (row
, col
);
4605 /* We have only one cursor on terminal frames. Use it to
4606 display the cursor of the selected window. */
4607 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
4608 if (w
->cursor
.vpos
>= 0)
4610 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
4611 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
4613 if (INTEGERP (w
->left_margin_width
))
4614 x
+= XFASTINT (w
->left_margin_width
);
4616 /* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
4625 fflush (termscript
);
4630 display_completed
= !pause
;
4631 clear_desired_matrices (f
);
4636 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4640 struct frame
*frame
;
4642 int unchanged_at_top
, unchanged_at_bottom
;
4645 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4646 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4647 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4648 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4650 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
4651 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4652 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4654 if (!current_matrix
)
4657 /* Compute hash codes of all the lines. Also calculate number of
4658 changed lines, number of unchanged lines at the beginning, and
4659 number of unchanged lines at the end. */
4661 unchanged_at_top
= 0;
4662 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
4663 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
4665 /* Give up on this scrolling if some old lines are not enabled. */
4666 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
4668 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
4669 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4671 /* This line cannot be redrawn, so don't let scrolling mess it. */
4672 new_hash
[i
] = old_hash
[i
];
4673 #define INFINITY 1000000 /* Taken from scroll.c */
4674 draw_cost
[i
] = INFINITY
;
4678 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
4679 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
4682 if (old_hash
[i
] != new_hash
[i
])
4685 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
4687 else if (i
== unchanged_at_top
)
4689 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
4692 /* If changed lines are few, don't allow preemption, don't scroll. */
4693 if ((!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400)
4694 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
4697 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
4698 - unchanged_at_bottom
);
4700 if (scroll_region_ok
)
4701 free_at_end_vpos
-= unchanged_at_bottom
;
4702 else if (memory_below_frame
)
4703 free_at_end_vpos
= -1;
4705 /* If large window, fast terminal and few lines in common between
4706 current frame and desired frame, don't bother with i/d calc. */
4707 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
4709 10 * scrolling_max_lines_saved (unchanged_at_top
,
4710 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
4711 old_hash
, new_hash
, draw_cost
)))
4714 if (window_size
< 2)
4717 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
4718 draw_cost
+ unchanged_at_top
- 1,
4719 old_draw_cost
+ unchanged_at_top
- 1,
4720 old_hash
+ unchanged_at_top
- 1,
4721 new_hash
+ unchanged_at_top
- 1,
4722 free_at_end_vpos
- unchanged_at_top
);
4728 /* Count the number of blanks at the start of the vector of glyphs R
4729 which is LEN glyphs long. */
4732 count_blanks (r
, len
)
4738 for (i
= 0; i
< len
; ++i
)
4739 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
4746 /* Count the number of glyphs in common at the start of the glyph
4747 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
4748 of STR2. Value is the number of equal glyphs equal at the start. */
4751 count_match (str1
, end1
, str2
, end2
)
4752 struct glyph
*str1
, *end1
, *str2
, *end2
;
4754 struct glyph
*p1
= str1
;
4755 struct glyph
*p2
= str2
;
4759 && GLYPH_FROM_CHAR_GLYPH (*p1
) == GLYPH_FROM_CHAR_GLYPH (*p2
))
4766 /* Char insertion/deletion cost vector, from term.c */
4768 extern int *char_ins_del_vector
;
4769 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
4772 /* Perform a frame-based update on line VPOS in frame FRAME. */
4775 update_frame_line (frame
, vpos
)
4776 register struct frame
*frame
;
4779 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
4781 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
4782 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4783 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4784 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
4785 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
4786 int must_write_whole_line_p
;
4788 if (desired_row
->inverse_p
4789 != (current_row
->enabled_p
&& current_row
->inverse_p
))
4791 int n
= current_row
->enabled_p
? current_row
->used
[TEXT_AREA
] : 0;
4792 change_line_highlight (desired_row
->inverse_p
, vpos
, vpos
, n
);
4793 current_row
->enabled_p
= 0;
4796 reassert_line_highlight (desired_row
->inverse_p
, vpos
);
4798 /* Current row not enabled means it has unknown contents. We must
4799 write the whole desired line in that case. */
4800 must_write_whole_line_p
= !current_row
->enabled_p
;
4801 if (must_write_whole_line_p
)
4808 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
4809 olen
= current_row
->used
[TEXT_AREA
];
4811 if (! current_row
->inverse_p
)
4813 /* Ignore trailing spaces, if we can. */
4814 if (!must_write_spaces
)
4815 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
4820 /* For an inverse-video line, make sure it's filled with
4821 spaces all the way to the frame edge so that the reverse
4822 video extends all the way across. */
4823 while (olen
< FRAME_WIDTH (frame
) - 1)
4824 obody
[olen
++] = space_glyph
;
4828 current_row
->enabled_p
= 1;
4829 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
4830 current_row
->inverse_p
= desired_row
->inverse_p
;
4832 /* If desired line is empty, just clear the line. */
4833 if (!desired_row
->enabled_p
)
4839 nbody
= desired_row
->glyphs
[TEXT_AREA
];
4840 nlen
= desired_row
->used
[TEXT_AREA
];
4841 nend
= nbody
+ nlen
;
4843 /* If display line has unknown contents, write the whole line. */
4844 if (must_write_whole_line_p
)
4846 /* Ignore spaces at the end, if we can. */
4847 if (!must_write_spaces
)
4848 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4851 /* Write the contents of the desired line. */
4854 cursor_to (vpos
, 0);
4855 write_glyphs (nbody
, nlen
);
4858 /* Don't call clear_end_of_line if we already wrote the whole
4859 line. The cursor will not be at the right margin in that
4860 case but in the line below. */
4861 if (nlen
< FRAME_WINDOW_WIDTH (frame
))
4863 cursor_to (vpos
, nlen
);
4864 clear_end_of_line (FRAME_WINDOW_WIDTH (frame
));
4867 make_current (desired_matrix
, current_matrix
, vpos
);
4871 /* Pretend trailing spaces are not there at all,
4872 unless for one reason or another we must write all spaces. */
4873 if (!desired_row
->inverse_p
)
4875 if (!must_write_spaces
)
4876 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4881 /* For an inverse-video line, give it extra trailing spaces all
4882 the way to the frame edge so that the reverse video extends
4883 all the way across. */
4884 while (nlen
< FRAME_WIDTH (frame
) - 1)
4885 nbody
[nlen
++] = space_glyph
;
4888 /* If there's no i/d char, quickly do the best we can without it. */
4889 if (!char_ins_del_ok
)
4893 /* Find the first glyph in desired row that doesn't agree with
4894 a glyph in the current row, and write the rest from there on. */
4895 for (i
= 0; i
< nlen
; i
++)
4897 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
4899 /* Find the end of the run of different glyphs. */
4903 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
4904 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
4907 /* Output this run of non-matching chars. */
4908 cursor_to (vpos
, i
);
4909 write_glyphs (nbody
+ i
, j
- i
);
4912 /* Now find the next non-match. */
4916 /* Clear the rest of the line, or the non-clear part of it. */
4919 cursor_to (vpos
, nlen
);
4920 clear_end_of_line (olen
);
4923 /* Make current row = desired row. */
4924 make_current (desired_matrix
, current_matrix
, vpos
);
4928 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
4929 characters in a row. */
4933 /* If current line is blank, skip over initial spaces, if
4934 possible, and write the rest. */
4935 if (must_write_spaces
|| desired_row
->inverse_p
)
4938 nsp
= count_blanks (nbody
, nlen
);
4942 cursor_to (vpos
, nsp
);
4943 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
4946 /* Exchange contents between current_frame and new_frame. */
4947 make_current (desired_matrix
, current_matrix
, vpos
);
4951 /* Compute number of leading blanks in old and new contents. */
4952 osp
= count_blanks (obody
, olen
);
4953 nsp
= desired_row
->inverse_p
? 0 : count_blanks (nbody
, nlen
);
4955 /* Compute number of matching chars starting with first non-blank. */
4956 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
4957 nbody
+ nsp
, nbody
+ nlen
);
4959 /* Spaces in new match implicit space past the end of old. */
4960 /* A bug causing this to be a no-op was fixed in 18.29. */
4961 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
4964 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
4968 /* Avoid doing insert/delete char
4969 just cause number of leading spaces differs
4970 when the following text does not match. */
4971 if (begmatch
== 0 && osp
!= nsp
)
4972 osp
= nsp
= min (osp
, nsp
);
4974 /* Find matching characters at end of line */
4977 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
4979 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
4984 endmatch
= obody
+ olen
- op1
;
4986 /* tem gets the distance to insert or delete.
4987 endmatch is how many characters we save by doing so.
4990 tem
= (nlen
- nsp
) - (olen
- osp
);
4992 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
4995 /* nsp - osp is the distance to insert or delete.
4996 If that is nonzero, begmatch is known to be nonzero also.
4997 begmatch + endmatch is how much we save by doing the ins/del.
5001 && (!char_ins_del_ok
5002 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
5006 osp
= nsp
= min (osp
, nsp
);
5009 /* Now go through the line, inserting, writing and
5010 deleting as appropriate. */
5014 cursor_to (vpos
, nsp
);
5015 delete_glyphs (osp
- nsp
);
5019 /* If going to delete chars later in line
5020 and insert earlier in the line,
5021 must delete first to avoid losing data in the insert */
5022 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
5024 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
5025 delete_glyphs (olen
+ nsp
- osp
- nlen
);
5026 olen
= nlen
- (nsp
- osp
);
5028 cursor_to (vpos
, osp
);
5029 insert_glyphs (0, nsp
- osp
);
5033 tem
= nsp
+ begmatch
+ endmatch
;
5034 if (nlen
!= tem
|| olen
!= tem
)
5036 cursor_to (vpos
, nsp
+ begmatch
);
5037 if (!endmatch
|| nlen
== olen
)
5039 /* If new text being written reaches right margin,
5040 there is no need to do clear-to-eol at the end.
5041 (and it would not be safe, since cursor is not
5042 going to be "at the margin" after the text is done) */
5043 if (nlen
== FRAME_WINDOW_WIDTH (frame
))
5045 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5047 else if (nlen
> olen
)
5049 /* Here, we used to have the following simple code:
5050 ----------------------------------------
5051 write_glyphs (nbody + nsp + begmatch, olen - tem);
5052 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5053 ----------------------------------------
5054 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5055 is a padding glyph. */
5056 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5059 /* Calculate columns we can actually overwrite. */
5060 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
])) out
--;
5061 write_glyphs (nbody
+ nsp
+ begmatch
, out
);
5062 /* If we left columns to be overwritten, we must delete them. */
5063 del
= olen
- tem
- out
;
5064 if (del
> 0) delete_glyphs (del
);
5065 /* At last, we insert columns not yet written out. */
5066 insert_glyphs (nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5069 else if (olen
> nlen
)
5071 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5072 delete_glyphs (olen
- nlen
);
5078 /* If any unerased characters remain after the new line, erase them. */
5081 cursor_to (vpos
, nlen
);
5082 clear_end_of_line (olen
);
5085 /* Exchange contents between current_frame and new_frame. */
5086 make_current (desired_matrix
, current_matrix
, vpos
);
5091 /***********************************************************************
5092 X/Y Position -> Buffer Position
5093 ***********************************************************************/
5095 /* Return the character position of the character at window relative
5096 pixel position (*X, *Y). *X and *Y are adjusted to character
5100 buffer_posn_from_coords (w
, x
, y
)
5105 struct buffer
*old_current_buffer
= current_buffer
;
5106 struct text_pos startp
;
5107 int left_area_width
;
5109 current_buffer
= XBUFFER (w
->buffer
);
5110 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5111 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5112 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5113 start_display (&it
, w
, startp
);
5115 left_area_width
= WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH (w
);
5116 move_it_to (&it
, -1, *x
+ it
.first_visible_x
- left_area_width
, *y
, -1,
5117 MOVE_TO_X
| MOVE_TO_Y
);
5119 *x
= it
.current_x
- it
.first_visible_x
+ left_area_width
;
5121 current_buffer
= old_current_buffer
;
5122 return IT_CHARPOS (it
);
5126 /* Value is the string under window-relative coordinates X/Y in the
5127 mode or top line of window W, or nil if none. MODE_LINE_P non-zero
5128 means look at the mode line. *CHARPOS is set to the position in
5129 the string returned. */
5132 mode_line_string (w
, x
, y
, mode_line_p
, charpos
)
5137 struct glyph_row
*row
;
5138 struct glyph
*glyph
, *end
;
5139 struct frame
*f
= XFRAME (w
->frame
);
5141 Lisp_Object string
= Qnil
;
5143 /* Only do this for frames under a window system. */
5144 if (!FRAME_WINDOW_P (f
))
5148 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5150 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
5152 if (row
->mode_line_p
&& row
->enabled_p
)
5154 /* The mode lines are displayed over scroll bars and bitmap
5155 areas, and X is window-relative. Correct X by the scroll bar
5156 and bitmap area width. */
5157 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
5158 x
+= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
5159 x
+= FRAME_LEFT_FLAGS_AREA_WIDTH (f
);
5161 /* Find the glyph under X. If we find one with a string object,
5162 it's the one we were looking for. */
5163 glyph
= row
->glyphs
[TEXT_AREA
];
5164 end
= glyph
+ row
->used
[TEXT_AREA
];
5165 for (x0
= 0; glyph
< end
; x0
+= glyph
->pixel_width
, ++glyph
)
5166 if (x
>= x0
&& x
< x0
+ glyph
->pixel_width
)
5168 string
= glyph
->object
;
5169 *charpos
= glyph
->charpos
;
5178 /***********************************************************************
5179 Changing Frame Sizes
5180 ***********************************************************************/
5185 window_change_signal (signalnum
) /* If we don't have an argument, */
5186 int signalnum
; /* some compilers complain in signal calls. */
5190 int old_errno
= errno
;
5192 get_frame_size (&width
, &height
);
5194 /* The frame size change obviously applies to a termcap-controlled
5195 frame. Find such a frame in the list, and assume it's the only
5196 one (since the redisplay code always writes to stdout, not a
5197 FILE * specified in the frame structure). Record the new size,
5198 but don't reallocate the data structures now. Let that be done
5199 later outside of the signal handler. */
5202 Lisp_Object tail
, frame
;
5204 FOR_EACH_FRAME (tail
, frame
)
5206 if (FRAME_TERMCAP_P (XFRAME (frame
)))
5208 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5214 signal (SIGWINCH
, window_change_signal
);
5217 #endif /* SIGWINCH */
5220 /* Do any change in frame size that was requested by a signal. SAFE
5221 non-zero means this function is called from a place where it is
5222 safe to change frame sizes while a redisplay is in progress. */
5225 do_pending_window_change (safe
)
5228 /* If window_change_signal should have run before, run it now. */
5229 if (redisplaying_p
&& !safe
)
5232 while (delayed_size_change
)
5234 Lisp_Object tail
, frame
;
5236 delayed_size_change
= 0;
5238 FOR_EACH_FRAME (tail
, frame
)
5240 struct frame
*f
= XFRAME (frame
);
5242 int height
= FRAME_NEW_HEIGHT (f
);
5243 int width
= FRAME_NEW_WIDTH (f
);
5245 if (height
!= 0 || width
!= 0)
5246 change_frame_size (f
, height
, width
, 0, 0, safe
);
5252 /* Change the frame height and/or width. Values may be given as zero to
5253 indicate no change is to take place.
5255 If DELAY is non-zero, then assume we're being called from a signal
5256 handler, and queue the change for later - perhaps the next
5257 redisplay. Since this tries to resize windows, we can't call it
5258 from a signal handler.
5260 SAFE non-zero means this function is called from a place where it's
5261 safe to change frame sizes while a redisplay is in progress. */
5264 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5265 register struct frame
*f
;
5266 int newheight
, newwidth
, pretend
, delay
, safe
;
5268 Lisp_Object tail
, frame
;
5270 if (! FRAME_WINDOW_P (f
))
5272 /* When using termcap, or on MS-DOS, all frames use
5273 the same screen, so a change in size affects all frames. */
5274 FOR_EACH_FRAME (tail
, frame
)
5275 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5276 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5277 pretend
, delay
, safe
);
5280 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
5284 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5285 register struct frame
*f
;
5286 int newheight
, newwidth
, pretend
, delay
, safe
;
5288 int new_frame_window_width
;
5289 int count
= specpdl_ptr
- specpdl
;
5291 /* If we can't deal with the change now, queue it for later. */
5292 if (delay
|| (redisplaying_p
&& !safe
))
5294 FRAME_NEW_HEIGHT (f
) = newheight
;
5295 FRAME_NEW_WIDTH (f
) = newwidth
;
5296 delayed_size_change
= 1;
5300 /* This size-change overrides any pending one for this frame. */
5301 FRAME_NEW_HEIGHT (f
) = 0;
5302 FRAME_NEW_WIDTH (f
) = 0;
5304 /* If an argument is zero, set it to the current value. */
5306 newheight
= FRAME_HEIGHT (f
);
5308 newwidth
= FRAME_WIDTH (f
);
5310 /* Compute width of windows in F.
5311 This is the width of the frame without vertical scroll bars. */
5312 new_frame_window_width
= FRAME_WINDOW_WIDTH_ARG (f
, newwidth
);
5314 /* Round up to the smallest acceptable size. */
5315 check_frame_size (f
, &newheight
, &newwidth
);
5317 /* If we're not changing the frame size, quit now. */
5318 if (newheight
== FRAME_HEIGHT (f
)
5319 && new_frame_window_width
== FRAME_WINDOW_WIDTH (f
))
5325 /* We only can set screen dimensions to certain values supported
5326 by our video hardware. Try to find the smallest size greater
5327 or equal to the requested dimensions. */
5328 dos_set_window_size (&newheight
, &newwidth
);
5331 if (newheight
!= FRAME_HEIGHT (f
))
5333 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
5335 /* Frame has both root and mini-buffer. */
5336 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f
))->top
,
5337 FRAME_TOP_MARGIN (f
));
5338 set_window_height (FRAME_ROOT_WINDOW (f
),
5341 - FRAME_TOP_MARGIN (f
)),
5343 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
,
5345 set_window_height (FRAME_MINIBUF_WINDOW (f
), 1, 0);
5348 /* Frame has just one top-level window. */
5349 set_window_height (FRAME_ROOT_WINDOW (f
),
5350 newheight
- FRAME_TOP_MARGIN (f
), 0);
5352 if (FRAME_TERMCAP_P (f
) && !pretend
)
5353 FrameRows
= newheight
;
5356 if (new_frame_window_width
!= FRAME_WINDOW_WIDTH (f
))
5358 set_window_width (FRAME_ROOT_WINDOW (f
), new_frame_window_width
, 0);
5359 if (FRAME_HAS_MINIBUF_P (f
))
5360 set_window_width (FRAME_MINIBUF_WINDOW (f
), new_frame_window_width
, 0);
5362 if (FRAME_TERMCAP_P (f
) && !pretend
)
5363 FrameCols
= newwidth
;
5365 if (WINDOWP (f
->tool_bar_window
))
5366 XSETFASTINT (XWINDOW (f
->tool_bar_window
)->width
, newwidth
);
5369 FRAME_HEIGHT (f
) = newheight
;
5370 SET_FRAME_WIDTH (f
, newwidth
);
5373 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5374 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
5376 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
5378 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
5379 w
->cursor
.hpos
= w
->cursor
.x
= 0;
5380 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
5381 w
->cursor
.vpos
= w
->cursor
.y
= 0;
5385 SET_FRAME_GARBAGED (f
);
5386 calculate_costs (f
);
5390 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
5392 /* This isn't quite a no-op: it runs window-configuration-change-hook. */
5393 Fset_window_buffer (FRAME_SELECTED_WINDOW (f
),
5394 XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
);
5396 unbind_to (count
, Qnil
);
5401 /***********************************************************************
5402 Terminal Related Lisp Functions
5403 ***********************************************************************/
5405 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
5406 1, 1, "FOpen termscript file: ",
5407 "Start writing all terminal output to FILE as well as the terminal.\n\
5408 FILE = nil means just close any termscript file currently open.")
5412 if (termscript
!= 0) fclose (termscript
);
5417 file
= Fexpand_file_name (file
, Qnil
);
5418 termscript
= fopen (XSTRING (file
)->data
, "w");
5419 if (termscript
== 0)
5420 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
5426 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
5427 Ssend_string_to_terminal
, 1, 1, 0,
5428 "Send STRING to the terminal without alteration.\n\
5429 Control characters in STRING will have terminal-dependent effects.")
5433 /* ??? Perhaps we should do something special for multibyte strings here. */
5434 CHECK_STRING (string
, 0);
5435 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)), stdout
);
5439 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)),
5441 fflush (termscript
);
5447 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
5448 "Beep, or flash the screen.\n\
5449 Also, unless an argument is given,\n\
5450 terminate any keyboard macro currently executing.")
5473 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
5474 error ("Keyboard macro terminated by a command ringing the bell");
5482 /***********************************************************************
5484 ***********************************************************************/
5486 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
5487 "Pause, without updating display, for SECONDS seconds.\n\
5488 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5489 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5490 additional wait period, in milliseconds; this may be useful if your\n\
5491 Emacs was built without floating point support.\n\
5492 \(Not all operating systems support waiting for a fraction of a second.)")
5493 (seconds
, milliseconds
)
5494 Lisp_Object seconds
, milliseconds
;
5498 if (NILP (milliseconds
))
5499 XSETINT (milliseconds
, 0);
5501 CHECK_NUMBER (milliseconds
, 1);
5502 usec
= XINT (milliseconds
) * 1000;
5504 #ifdef LISP_FLOAT_TYPE
5506 double duration
= extract_float (seconds
);
5507 sec
= (int) duration
;
5508 usec
+= (duration
- sec
) * 1000000;
5511 CHECK_NUMBER (seconds
, 0);
5512 sec
= XINT (seconds
);
5515 #ifndef EMACS_HAS_USECS
5516 if (sec
== 0 && usec
!= 0)
5517 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
5520 /* Assure that 0 <= usec < 1000000. */
5523 /* We can't rely on the rounding being correct if user is negative. */
5524 if (-1000000 < usec
)
5525 sec
--, usec
+= 1000000;
5527 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
5530 sec
+= usec
/ 1000000, usec
%= 1000000;
5532 if (sec
< 0 || (sec
== 0 && usec
== 0))
5538 XSETFASTINT (zero
, 0);
5539 wait_reading_process_input (sec
, usec
, zero
, 0);
5542 /* We should always have wait_reading_process_input; we have a dummy
5543 implementation for systems which don't support subprocesses. */
5545 /* No wait_reading_process_input */
5552 /* The reason this is done this way
5553 (rather than defined (H_S) && defined (H_T))
5554 is because the VMS preprocessor doesn't grok `defined' */
5556 EMACS_GET_TIME (end_time
);
5557 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
5558 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
5562 EMACS_GET_TIME (timeout
);
5563 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
5564 if (EMACS_TIME_NEG_P (timeout
)
5565 || !select (1, 0, 0, 0, &timeout
))
5568 #else /* not HAVE_SELECT */
5570 #endif /* HAVE_SELECT */
5571 #endif /* not VMS */
5574 #endif /* no subprocesses */
5580 /* This is just like wait_reading_process_input, except that
5581 it does the redisplay.
5583 It's also much like Fsit_for, except that it can be used for
5584 waiting for input as well. */
5587 sit_for (sec
, usec
, reading
, display
, initial_display
)
5588 int sec
, usec
, reading
, display
, initial_display
;
5590 Lisp_Object read_kbd
;
5592 swallow_events (display
);
5594 if (detect_input_pending_run_timers (display
))
5597 if (initial_display
)
5598 redisplay_preserve_echo_area ();
5600 if (sec
== 0 && usec
== 0)
5607 XSETINT (read_kbd
, reading
? -1 : 1);
5608 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
5610 return detect_input_pending () ? Qnil
: Qt
;
5614 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
5615 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
5616 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5617 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5618 additional wait period, in milliseconds; this may be useful if your\n\
5619 Emacs was built without floating point support.\n\
5620 \(Not all operating systems support waiting for a fraction of a second.)\n\
5621 Optional third arg NODISP non-nil means don't redisplay, just wait for input.\n\
5622 Redisplay is preempted as always if input arrives, and does not happen\n\
5623 if input is available before it starts.\n\
5624 Value is t if waited the full time with no input arriving.")
5625 (seconds
, milliseconds
, nodisp
)
5626 Lisp_Object seconds
, milliseconds
, nodisp
;
5630 if (NILP (milliseconds
))
5631 XSETINT (milliseconds
, 0);
5633 CHECK_NUMBER (milliseconds
, 1);
5634 usec
= XINT (milliseconds
) * 1000;
5636 #ifdef LISP_FLOAT_TYPE
5638 double duration
= extract_float (seconds
);
5639 sec
= (int) duration
;
5640 usec
+= (duration
- sec
) * 1000000;
5643 CHECK_NUMBER (seconds
, 0);
5644 sec
= XINT (seconds
);
5647 #ifndef EMACS_HAS_USECS
5648 if (usec
!= 0 && sec
== 0)
5649 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
5652 return sit_for (sec
, usec
, 0, NILP (nodisp
), NILP (nodisp
));
5657 /***********************************************************************
5658 Other Lisp Functions
5659 ***********************************************************************/
5661 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
5662 session's frames, frame names, buffers, buffer-read-only flags, and
5663 buffer-modified-flags, and a trailing sentinel (so we don't need to
5664 add length checks). */
5666 static Lisp_Object frame_and_buffer_state
;
5669 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
5670 Sframe_or_buffer_changed_p
, 0, 0, 0,
5671 "Return non-nil if the frame and buffer state appears to have changed.\n\
5672 The state variable is an internal vector containing all frames and buffers,\n\
5673 aside from buffers whose names start with space,\n\
5674 along with the buffers' read-only and modified flags, which allows a fast\n\
5675 check to see whether the menu bars might need to be recomputed.\n\
5676 If this function returns non-nil, it updates the internal vector to reflect\n\
5677 the current state.\n")
5680 Lisp_Object tail
, frame
, buf
;
5684 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5685 FOR_EACH_FRAME (tail
, frame
)
5687 if (!EQ (*vecp
++, frame
))
5689 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
5692 /* Check that the buffer info matches.
5693 No need to test for the end of the vector
5694 because the last element of the vector is lambda
5695 and that will always cause a mismatch. */
5696 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5698 buf
= XCDR (XCAR (tail
));
5699 /* Ignore buffers that aren't included in buffer lists. */
5700 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5702 if (!EQ (*vecp
++, buf
))
5704 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
5706 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
5709 /* Detect deletion of a buffer at the end of the list. */
5710 if (EQ (*vecp
, Qlambda
))
5713 /* Start with 1 so there is room for at least one lambda at the end. */
5715 FOR_EACH_FRAME (tail
, frame
)
5717 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5719 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
5720 if (n
> XVECTOR (frame_and_buffer_state
)->size
5721 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
5722 /* Add 20 extra so we grow it less often. */
5723 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
5724 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5725 FOR_EACH_FRAME (tail
, frame
)
5728 *vecp
++ = XFRAME (frame
)->name
;
5730 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
5732 buf
= XCDR (XCAR (tail
));
5733 /* Ignore buffers that aren't included in buffer lists. */
5734 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5737 *vecp
++ = XBUFFER (buf
)->read_only
;
5738 *vecp
++ = Fbuffer_modified_p (buf
);
5740 /* Fill up the vector with lambdas (always at least one). */
5742 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5743 < XVECTOR (frame_and_buffer_state
)->size
)
5745 /* Make sure we didn't overflow the vector. */
5746 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5747 > XVECTOR (frame_and_buffer_state
)->size
)
5754 /***********************************************************************
5756 ***********************************************************************/
5758 char *terminal_type
;
5760 /* Initialization done when Emacs fork is started, before doing stty.
5761 Determine terminal type and set terminal_driver. Then invoke its
5762 decoding routine to set up variables in the terminal package. */
5767 #ifdef HAVE_X_WINDOWS
5768 extern int display_arg
;
5771 /* Construct the space glyph. */
5772 space_glyph
.type
= CHAR_GLYPH
;
5773 SET_CHAR_GLYPH_FROM_GLYPH (space_glyph
, ' ');
5774 space_glyph
.charpos
= -1;
5778 cursor_in_echo_area
= 0;
5779 terminal_type
= (char *) 0;
5781 /* Now is the time to initialize this; it's used by init_sys_modes
5783 Vwindow_system
= Qnil
;
5785 /* If the user wants to use a window system, we shouldn't bother
5786 initializing the terminal. This is especially important when the
5787 terminal is so dumb that emacs gives up before and doesn't bother
5788 using the window system.
5790 If the DISPLAY environment variable is set and nonempty,
5791 try to use X, and die with an error message if that doesn't work. */
5793 #ifdef HAVE_X_WINDOWS
5798 display
= getenv ("DECW$DISPLAY");
5800 display
= getenv ("DISPLAY");
5803 display_arg
= (display
!= 0 && *display
!= 0);
5806 if (!inhibit_window_system
&& display_arg
5812 Vwindow_system
= intern ("x");
5814 Vwindow_system_version
= make_number (11);
5816 Vwindow_system_version
= make_number (10);
5818 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
5819 /* In some versions of ncurses,
5820 tputs crashes if we have not called tgetent.
5822 { char b
[2044]; tgetent (b
, "xterm");}
5824 adjust_frame_glyphs_initially ();
5827 #endif /* HAVE_X_WINDOWS */
5830 if (!inhibit_window_system
)
5832 Vwindow_system
= intern ("w32");
5833 Vwindow_system_version
= make_number (1);
5834 adjust_frame_glyphs_initially ();
5837 #endif /* HAVE_NTGUI */
5839 /* If no window system has been specified, try to use the terminal. */
5842 fatal ("standard input is not a tty");
5846 /* Look at the TERM variable */
5847 terminal_type
= (char *) getenv ("TERM");
5851 fprintf (stderr
, "Please specify your terminal type.\n\
5852 For types defined in VMS, use set term /device=TYPE.\n\
5853 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
5854 \(The quotation marks are necessary since terminal types are lower case.)\n");
5856 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
5862 /* VMS DCL tends to up-case things, so down-case term type.
5863 Hardly any uppercase letters in terminal types; should be none. */
5865 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
5868 strcpy (new, terminal_type
);
5870 for (p
= new; *p
; p
++)
5874 terminal_type
= new;
5878 term_init (terminal_type
);
5881 struct frame
*sf
= SELECTED_FRAME ();
5882 int width
= FRAME_WINDOW_WIDTH (sf
);
5883 int height
= FRAME_HEIGHT (sf
);
5885 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (struct glyph
);
5887 /* If these sizes are so big they cause overflow, just ignore the
5888 change. It's not clear what better we could do. */
5889 if (total_glyphs
/ sizeof (struct glyph
) / height
!= width
+ 2)
5890 fatal ("screen size %dx%d too big", width
, height
);
5893 adjust_frame_glyphs_initially ();
5894 calculate_costs (XFRAME (selected_frame
));
5899 #endif /* CANNOT_DUMP */
5900 signal (SIGWINCH
, window_change_signal
);
5901 #endif /* SIGWINCH */
5903 /* Set up faces of the initial terminal frame of a dumped Emacs. */
5907 /* The MSDOS terminal turns on its ``window system'' relatively
5908 late into the startup, so we cannot do the frame faces'
5909 initialization just yet. It will be done later by pc-win.el
5910 and internal_terminal_init. */
5911 && (strcmp (terminal_type
, "internal") != 0 || inhibit_window_system
)
5913 && NILP (Vwindow_system
))
5914 call0 (intern ("tty-set-up-initial-frame-faces"));
5919 /***********************************************************************
5921 ***********************************************************************/
5923 DEFUN ("show-cursor", Fshow_cursor
, Sshow_cursor
, 0, 2, 0,
5924 "Change visibility flag of the text cursor of WINDOW.\n\
5925 ON_P nil means toggle the flag. Otherwise, ON_P must be an integer,\n\
5926 and the flag is set according to the value of ON_P. WINDOW nil or\n\
5927 omitted means use the selected window. The new cursor state takes effect\n\
5928 with the next redisplay.")
5930 Lisp_Object on_p
, window
;
5934 /* Don't change cursor state while redisplaying. This could confuse
5936 if (!redisplaying_p
)
5939 window
= selected_window
;
5941 CHECK_WINDOW (window
, 2);
5942 w
= XWINDOW (window
);
5945 w
->cursor_off_p
= !w
->cursor_off_p
;
5948 CHECK_NUMBER (on_p
, 1);
5949 w
->cursor_off_p
= XINT (on_p
) != 0;
5958 /***********************************************************************
5960 ***********************************************************************/
5965 defsubr (&Sredraw_frame
);
5966 defsubr (&Sredraw_display
);
5967 defsubr (&Sframe_or_buffer_changed_p
);
5968 defsubr (&Sopen_termscript
);
5970 defsubr (&Ssit_for
);
5971 defsubr (&Ssleep_for
);
5972 defsubr (&Ssend_string_to_terminal
);
5973 defsubr (&Sshow_cursor
);
5975 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
5976 staticpro (&frame_and_buffer_state
);
5978 Qdisplay_table
= intern ("display-table");
5979 staticpro (&Qdisplay_table
);
5981 DEFVAR_INT ("baud-rate", &baud_rate
,
5982 "*The output baud rate of the terminal.\n\
5983 On most systems, changing this value will affect the amount of padding\n\
5984 and the other strategic decisions made during redisplay.");
5986 DEFVAR_BOOL ("inverse-video", &inverse_video
,
5987 "*Non-nil means invert the entire frame display.\n\
5988 This means everything is in inverse video which otherwise would not be.");
5990 DEFVAR_BOOL ("visible-bell", &visible_bell
,
5991 "*Non-nil means try to flash the frame to represent a bell.");
5993 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
5994 "*Non-nil means no need to redraw entire frame after suspending.\n\
5995 A non-nil value is useful if the terminal can automatically preserve\n\
5996 Emacs's frame display when you reenter Emacs.\n\
5997 It is up to you to set this variable if your terminal can do that.");
5999 DEFVAR_LISP ("window-system", &Vwindow_system
,
6000 "A symbol naming the window-system under which Emacs is running\n\
6001 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
6003 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
6004 "The version number of the window system in use.\n\
6005 For X windows, this is 10 or 11.");
6007 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
6008 "Non-nil means put cursor in minibuffer, at end of any message there.");
6010 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
6011 "Table defining how to output a glyph code to the frame.\n\
6012 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
6013 Each element can be:\n\
6014 integer: a glyph code which this glyph is an alias for.\n\
6015 string: output this glyph using that string (not impl. in X windows).\n\
6016 nil: this glyph mod 256 is char code to output,\n\
6017 and this glyph / 256 is face code for X windows (see `face-id').");
6018 Vglyph_table
= Qnil
;
6020 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
6021 "Display table to use for buffers that specify none.\n\
6022 See `buffer-display-table' for more information.");
6023 Vstandard_display_table
= Qnil
;
6025 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause
,
6026 "*Non-nil means update isn't paused when input is detected.");
6027 redisplay_dont_pause
= 0;
6029 /* Initialize `window-system', unless init_display already decided it. */
6034 Vwindow_system
= Qnil
;
6035 Vwindow_system_version
= Qnil
;