1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 97, 1998
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 #ifndef PENDING_OUTPUT_COUNT
95 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
97 #endif /* not __GNU_LIBRARY__ */
100 /* Structure to pass dimensions around. Used for character bounding
101 boxes, glyph matrix dimensions and alike. */
110 /* Function prototypes. */
112 static void redraw_overlapping_rows
P_ ((struct window
*, int));
113 static void redraw_overlapped_rows
P_ ((struct window
*, int));
114 static int count_blanks
P_ ((struct glyph
*, int));
115 static int count_match
P_ ((struct glyph
*, struct glyph
*,
116 struct glyph
*, struct glyph
*));
117 static unsigned line_draw_cost
P_ ((struct glyph_matrix
*, int));
118 static void update_frame_line
P_ ((struct frame
*, int));
119 static struct dim allocate_matrices_for_frame_redisplay
120 P_ ((Lisp_Object
, int, int, struct dim
, int, int *));
121 static void allocate_matrices_for_window_redisplay
P_ ((struct window
*,
123 static int realloc_glyph_pool
P_ ((struct glyph_pool
*, struct dim
));
124 static void adjust_frame_glyphs
P_ ((struct frame
*));
125 struct glyph_matrix
*new_glyph_matrix
P_ ((struct glyph_pool
*));
126 static void free_glyph_matrix
P_ ((struct glyph_matrix
*));
127 static void adjust_glyph_matrix
P_ ((struct window
*, struct glyph_matrix
*,
128 int, int, struct dim
));
129 static void change_frame_size_1
P_ ((struct frame
*, int, int, int, int, int));
130 static void swap_glyphs_in_rows
P_ ((struct glyph_row
*, struct glyph_row
*));
131 static void swap_glyph_pointers
P_ ((struct glyph_row
*, struct glyph_row
*));
132 static int glyph_row_slice_p
P_ ((struct glyph_row
*, struct glyph_row
*));
133 static void fill_up_frame_row_with_spaces
P_ ((struct glyph_row
*, int));
134 static void build_frame_matrix_from_window_tree
P_ ((struct glyph_matrix
*,
136 static void build_frame_matrix_from_leaf_window
P_ ((struct glyph_matrix
*,
138 static struct glyph_pool
*new_glyph_pool
P_ ((void));
139 static void free_glyph_pool
P_ ((struct glyph_pool
*));
140 static void adjust_frame_glyphs_initially
P_ ((void));
141 static void adjust_frame_message_buffer
P_ ((struct frame
*));
142 static void adjust_decode_mode_spec_buffer
P_ ((struct frame
*));
143 static void fill_up_glyph_row_with_spaces
P_ ((struct glyph_row
*));
144 static void build_frame_matrix
P_ ((struct frame
*));
145 void clear_current_matrices
P_ ((struct frame
*));
146 void scroll_glyph_matrix_range
P_ ((struct glyph_matrix
*, int, int,
148 static void clear_window_matrices
P_ ((struct window
*, int));
149 static void fill_up_glyph_row_area_with_spaces
P_ ((struct glyph_row
*, int));
150 static int scrolling_window
P_ ((struct window
*, int));
151 static int update_window_line
P_ ((struct window
*, int));
152 static void update_marginal_area
P_ ((struct window
*, int, int));
153 static int update_text_area
P_ ((struct window
*, int));
154 static void make_current
P_ ((struct glyph_matrix
*, struct glyph_matrix
*,
156 static void mirror_make_current
P_ ((struct window
*, int));
157 void check_window_matrix_pointers
P_ ((struct window
*));
159 static void check_matrix_pointers
P_ ((struct glyph_matrix
*,
160 struct glyph_matrix
*));
162 static void mirror_line_dance
P_ ((struct window
*, int, int, int *, char *));
163 static int update_window_tree
P_ ((struct window
*, int));
164 static int update_window
P_ ((struct window
*, int));
165 static int update_frame_1
P_ ((struct frame
*, int, int));
166 static void set_window_cursor_after_update
P_ ((struct window
*));
167 static int row_equal_p
P_ ((struct window
*, struct glyph_row
*,
168 struct glyph_row
*));
169 static void adjust_frame_glyphs_for_window_redisplay
P_ ((struct frame
*));
170 static void adjust_frame_glyphs_for_frame_redisplay
P_ ((struct frame
*));
171 static void reverse_rows
P_ ((struct glyph_matrix
*, int, int));
172 static int margin_glyphs_to_reserve
P_ ((struct window
*, int, Lisp_Object
));
176 /* Non-zero means don't pause redisplay for pending input. (This is
177 for debugging and for a future implementation of EDT-like
180 int redisplay_dont_pause
;
182 /* Nonzero upon entry to redisplay means do not assume anything about
183 current contents of actual terminal frame; clear and redraw it. */
187 /* Nonzero means last display completed. Zero means it was preempted. */
189 int display_completed
;
191 /* Lisp variable visible-bell; enables use of screen-flash instead of
196 /* Invert the color of the whole frame, at a low level. */
200 /* Line speed of the terminal. */
204 /* Either nil or a symbol naming the window system under which Emacs
207 Lisp_Object Vwindow_system
;
209 /* Version number of X windows: 10, 11 or nil. */
211 Lisp_Object Vwindow_system_version
;
213 /* Vector of glyph definitions. Indexed by glyph number, the contents
214 are a string which is how to output the glyph.
216 If Vglyph_table is nil, a glyph is output by using its low 8 bits
219 This is an obsolete feature that is no longer used. The variable
220 is retained for compatibility. */
222 Lisp_Object Vglyph_table
;
224 /* Display table to use for vectors that don't specify their own. */
226 Lisp_Object Vstandard_display_table
;
228 /* Nonzero means reading single-character input with prompt so put
229 cursor on mini-buffer after the prompt. positive means at end of
230 text in echo area; negative means at beginning of line. */
232 int cursor_in_echo_area
;
234 Lisp_Object Qdisplay_table
;
237 /* The currently selected frame. In a single-frame version, this
238 variable always holds the address of the_only_frame. */
240 struct frame
*selected_frame
;
242 /* A frame which is not just a mini-buffer, or 0 if there are no such
243 frames. This is usually the most recent such frame that was
244 selected. In a single-frame version, this variable always holds
245 the address of the_only_frame. */
247 struct frame
*last_nonminibuf_frame
;
249 /* Stdio stream being used for copy of all output. */
253 /* Structure for info on cursor positioning. */
257 /* 1 means SIGWINCH happened when not safe. */
259 int delayed_size_change
;
261 /* 1 means glyph initialization has been completed at startup. */
263 static int glyphs_initialized_initially_p
;
265 /* Updated window if != 0. Set by update_window. */
267 struct window
*updated_window
;
269 /* Glyph row updated in update_window_line, and area that is updated. */
271 struct glyph_row
*updated_row
;
274 /* A glyph for a space. */
276 struct glyph space_glyph
;
278 /* Non-zero means update has been performed directly, so that there's
279 no need for redisplay_internal to do much work. Set by
280 direct_output_for_insert. */
282 int redisplay_performed_directly_p
;
284 /* Counts of allocated structures. These counts serve to diagnose
285 memory leaks and double frees. */
287 int glyph_matrix_count
;
288 int glyph_pool_count
;
290 /* If non-null, the frame whose frame matrices are manipulated. If
291 null, window matrices are worked on. */
293 static struct frame
*frame_matrix_frame
;
295 /* Current interface for window-based redisplay. Set from init_xterm.
296 A null value means we are not using window-based redisplay. */
298 struct redisplay_interface
*rif
;
300 /* Non-zero means that fonts have been loaded since the last glyph
301 matrix adjustments. Redisplay must stop, and glyph matrices must
302 be adjusted when this flag becomes non-zero during display. The
303 reason fonts can be loaded so late is that fonts of fontsets are
308 /* Convert vpos and hpos from frame to window and vice versa.
309 This may only be used for terminal frames. */
313 static int window_to_frame_vpos
P_ ((struct window
*, int));
314 static int window_to_frame_hpos
P_ ((struct window
*, int));
315 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
316 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
318 #else /* GLYPH_DEBUG == 0 */
320 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + XFASTINT ((W)->top))
321 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + XFASTINT ((W)->left))
323 #endif /* GLYPH_DEBUG == 0 */
326 /* Like bcopy except never gets confused by overlap. Let this be the
327 first function defined in this file, or change emacs.c where the
328 address of this function is used. */
331 safe_bcopy (from
, to
, size
)
335 if (size
<= 0 || from
== to
)
338 /* If the source and destination don't overlap, then bcopy can
339 handle it. If they do overlap, but the destination is lower in
340 memory than the source, we'll assume bcopy can handle that. */
341 if (to
< from
|| from
+ size
<= to
)
342 bcopy (from
, to
, size
);
344 /* Otherwise, we'll copy from the end. */
347 register char *endf
= from
+ size
;
348 register char *endt
= to
+ size
;
350 /* If TO - FROM is large, then we should break the copy into
351 nonoverlapping chunks of TO - FROM bytes each. However, if
352 TO - FROM is small, then the bcopy function call overhead
353 makes this not worth it. The crossover point could be about
354 anywhere. Since I don't think the obvious copy loop is too
355 bad, I'm trying to err in its favor. */
360 while (endf
!= from
);
372 bcopy (endf
, endt
, to
- from
);
375 /* If SIZE wasn't a multiple of TO - FROM, there will be a
376 little left over. The amount left over is (endt + (to -
377 from)) - to, which is endt - from. */
378 bcopy (from
, to
, endt
- from
);
385 /***********************************************************************
387 ***********************************************************************/
389 /* Allocate and return a glyph_matrix structure. POOL is the glyph
390 pool from which memory for the matrix should be allocated, or null
391 for window-based redisplay where no glyph pools are used. The
392 member `pool' of the glyph matrix structure returned is set to
393 POOL, the structure is otherwise zeroed. */
395 struct glyph_matrix
*
396 new_glyph_matrix (pool
)
397 struct glyph_pool
*pool
;
399 struct glyph_matrix
*result
;
401 /* Allocate and clear. */
402 result
= (struct glyph_matrix
*) xmalloc (sizeof *result
);
403 bzero (result
, sizeof *result
);
405 /* Increment number of allocated matrices. This count is used
406 to detect memory leaks. */
407 ++glyph_matrix_count
;
409 /* Set pool and return. */
415 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
417 The global counter glyph_matrix_count is decremented when a matrix
418 is freed. If the count gets negative, more structures were freed
419 than allocated, i.e. one matrix was freed more than once or a bogus
420 pointer was passed to this function.
422 If MATRIX->pool is null, this means that the matrix manages its own
423 glyph memory---this is done for matrices on X frames. Freeing the
424 matrix also frees the glyph memory in this case. */
427 free_glyph_matrix (matrix
)
428 struct glyph_matrix
*matrix
;
434 /* Detect the case that more matrices are freed than were
436 if (--glyph_matrix_count
< 0)
439 /* Free glyph memory if MATRIX owns it. */
440 if (matrix
->pool
== NULL
)
441 for (i
= 0; i
< matrix
->rows_allocated
; ++i
)
442 xfree (matrix
->rows
[i
].glyphs
[LEFT_MARGIN_AREA
]);
444 /* Free row structures and the matrix itself. */
445 xfree (matrix
->rows
);
451 /* Return the number of glyphs to reserve for a marginal area of
452 window W. TOTAL_GLYPHS is the number of glyphs in a complete
453 display line of window W. MARGIN gives the width of the marginal
454 area in canonical character units. MARGIN should be an integer
458 margin_glyphs_to_reserve (w
, total_glyphs
, margin
)
465 if (NUMBERP (margin
))
467 int width
= XFASTINT (w
->width
);
468 double d
= max (0, XFLOATINT (margin
));
469 d
= min (width
/ 2 - 1, d
);
470 n
= (int) ((double) total_glyphs
/ width
* d
);
479 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
482 W is null if the function is called for a frame glyph matrix.
483 Otherwise it is the window MATRIX is a member of. X and Y are the
484 indices of the first column and row of MATRIX within the frame
485 matrix, if such a matrix exists. They are zero for purely
486 window-based redisplay. DIM is the needed size of the matrix.
488 In window-based redisplay, where no frame matrices exist, glyph
489 matrices manage their own glyph storage. Otherwise, they allocate
490 storage from a common frame glyph pool which can be found in
493 The reason for this memory management strategy is to avoid complete
494 frame redraws if possible. When we allocate from a common pool, a
495 change of the location or size of a sub-matrix within the pool
496 requires a complete redisplay of the frame because we cannot easily
497 make sure that the current matrices of all windows still agree with
498 what is displayed on the screen. While this is usually fast, it
499 leads to screen flickering. */
502 adjust_glyph_matrix (w
, matrix
, x
, y
, dim
)
504 struct glyph_matrix
*matrix
;
510 int marginal_areas_changed_p
= 0;
511 int top_line_changed_p
= 0;
513 int left
= -1, right
= -1;
514 int window_x
, window_y
, window_width
, window_height
;
516 /* See if W had a top line that has disappeared now, or vice versa. */
519 top_line_p
= WINDOW_WANTS_TOP_LINE_P (w
);
520 top_line_changed_p
= top_line_p
!= matrix
->top_line_p
;
522 matrix
->top_line_p
= top_line_p
;
524 /* Do nothing if MATRIX' size, position, vscroll, and marginal areas
525 haven't changed. This optimization is important because preserving
526 the matrix means preventing redisplay. */
527 if (matrix
->pool
== NULL
)
529 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
530 left
= margin_glyphs_to_reserve (w
, dim
.width
, w
->left_margin_width
);
531 right
= margin_glyphs_to_reserve (w
, dim
.width
, w
->right_margin_width
);
532 xassert (left
>= 0 && right
>= 0);
533 marginal_areas_changed_p
= (left
!= matrix
->left_margin_glyphs
534 || right
!= matrix
->right_margin_glyphs
);
536 if (!marginal_areas_changed_p
538 && !top_line_changed_p
539 && matrix
->window_top_y
== XFASTINT (w
->top
)
540 && matrix
->window_height
== window_height
541 && matrix
->window_vscroll
== w
->vscroll
542 && matrix
->window_width
== window_width
)
546 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
547 if (matrix
->rows_allocated
< dim
.height
)
549 int size
= dim
.height
* sizeof (struct glyph_row
);
550 new_rows
= dim
.height
- matrix
->rows_allocated
;
551 matrix
->rows
= (struct glyph_row
*) xrealloc (matrix
->rows
, size
);
552 bzero (matrix
->rows
+ matrix
->rows_allocated
,
553 new_rows
* sizeof *matrix
->rows
);
554 matrix
->rows_allocated
= dim
.height
;
559 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
560 on a frame not using window-based redisplay. Set up pointers for
561 each row into the glyph pool. */
564 xassert (matrix
->pool
->glyphs
);
568 left
= margin_glyphs_to_reserve (w
, dim
.width
,
569 w
->left_margin_width
);
570 right
= margin_glyphs_to_reserve (w
, dim
.width
,
571 w
->right_margin_width
);
576 for (i
= 0; i
< dim
.height
; ++i
)
578 struct glyph_row
*row
= &matrix
->rows
[i
];
580 row
->glyphs
[LEFT_MARGIN_AREA
]
581 = (matrix
->pool
->glyphs
582 + (y
+ i
) * matrix
->pool
->ncolumns
586 || row
== matrix
->rows
+ dim
.height
- 1
587 || (row
== matrix
->rows
&& matrix
->top_line_p
))
589 row
->glyphs
[TEXT_AREA
]
590 = row
->glyphs
[LEFT_MARGIN_AREA
];
591 row
->glyphs
[RIGHT_MARGIN_AREA
]
592 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
593 row
->glyphs
[LAST_AREA
]
594 = row
->glyphs
[RIGHT_MARGIN_AREA
];
598 row
->glyphs
[TEXT_AREA
]
599 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
600 row
->glyphs
[RIGHT_MARGIN_AREA
]
601 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
602 row
->glyphs
[LAST_AREA
]
603 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
607 matrix
->left_margin_glyphs
= left
;
608 matrix
->right_margin_glyphs
= right
;
612 /* If MATRIX->pool is null, MATRIX is responsible for managing
613 its own memory. Allocate glyph memory from the heap. */
614 if (dim
.width
> matrix
->matrix_w
616 || top_line_changed_p
617 || marginal_areas_changed_p
)
619 struct glyph_row
*row
= matrix
->rows
;
620 struct glyph_row
*end
= row
+ matrix
->rows_allocated
;
624 row
->glyphs
[LEFT_MARGIN_AREA
]
625 = (struct glyph
*) xrealloc (row
->glyphs
[LEFT_MARGIN_AREA
],
627 * sizeof (struct glyph
)));
629 /* The mode line never has marginal areas. */
630 if (row
== matrix
->rows
+ dim
.height
- 1
631 || (row
== matrix
->rows
&& matrix
->top_line_p
))
633 row
->glyphs
[TEXT_AREA
]
634 = row
->glyphs
[LEFT_MARGIN_AREA
];
635 row
->glyphs
[RIGHT_MARGIN_AREA
]
636 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
637 row
->glyphs
[LAST_AREA
]
638 = row
->glyphs
[RIGHT_MARGIN_AREA
];
642 row
->glyphs
[TEXT_AREA
]
643 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
644 row
->glyphs
[RIGHT_MARGIN_AREA
]
645 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
646 row
->glyphs
[LAST_AREA
]
647 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
653 xassert (left
>= 0 && right
>= 0);
654 matrix
->left_margin_glyphs
= left
;
655 matrix
->right_margin_glyphs
= right
;
658 /* Number of rows to be used by MATRIX. */
659 matrix
->nrows
= dim
.height
;
661 /* Mark rows in a current matrix of a window as not having valid
662 contents. It's important to not do this for desired matrices.
663 When Emacs starts, it may already be building desired matrices
664 when this function runs. */
665 if (w
&& matrix
== w
->current_matrix
)
667 /* Optimize the case that only the height has changed (C-x 2,
668 upper window). Invalidate all rows that are no longer part
670 if (!marginal_areas_changed_p
671 && matrix
->window_top_y
== XFASTINT (w
->top
)
672 && matrix
->window_width
== window_width
)
675 while (matrix
->rows
[i
].enabled_p
676 && (MATRIX_ROW_BOTTOM_Y (matrix
->rows
+ i
)
677 < matrix
->window_height
))
680 /* Window end is invalid, if inside of the rows that
682 if (INTEGERP (w
->window_end_vpos
)
683 && XFASTINT (w
->window_end_vpos
) >= i
)
684 w
->window_end_valid
= Qnil
;
686 while (i
< matrix
->nrows
)
687 matrix
->rows
[i
++].enabled_p
= 0;
691 for (i
= 0; i
< matrix
->nrows
; ++i
)
692 matrix
->rows
[i
].enabled_p
= 0;
696 /* Remember last values to be able to optimize frame redraws. */
697 matrix
->matrix_x
= x
;
698 matrix
->matrix_y
= y
;
699 matrix
->matrix_w
= dim
.width
;
700 matrix
->matrix_h
= dim
.height
;
702 /* Record the top y location and height of W at the time the matrix
703 was last adjusted. This is used to optimize redisplay above. */
706 matrix
->window_top_y
= XFASTINT (w
->top
);
707 matrix
->window_height
= window_height
;
708 matrix
->window_width
= window_width
;
709 matrix
->window_vscroll
= w
->vscroll
;
714 /* Reverse the contents of rows in MATRIX between START and END. The
715 contents of the row at END - 1 end up at START, END - 2 at START +
716 1 etc. This is part of the implementation of rotate_matrix (see
720 reverse_rows (matrix
, start
, end
)
721 struct glyph_matrix
*matrix
;
726 for (i
= start
, j
= end
- 1; i
< j
; ++i
, --j
)
728 /* Non-ISO HP/UX compiler doesn't like auto struct
730 struct glyph_row temp
;
731 temp
= matrix
->rows
[i
];
732 matrix
->rows
[i
] = matrix
->rows
[j
];
733 matrix
->rows
[j
] = temp
;
738 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
739 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
740 indices. (Note: this does not copy glyphs, only glyph pointers in
741 row structures are moved around).
743 The algorithm used for rotating the vector was, I believe, first
744 described by Kernighan. See the vector R as consisting of two
745 sub-vectors AB, where A has length BY for BY >= 0. The result
746 after rotating is then BA. Reverse both sub-vectors to get ArBr
747 and reverse the result to get (ArBr)r which is BA. Similar for
751 rotate_matrix (matrix
, first
, last
, by
)
752 struct glyph_matrix
*matrix
;
757 /* Up (rotate left, i.e. towards lower indices). */
759 reverse_rows (matrix
, first
, first
+ by
);
760 reverse_rows (matrix
, first
+ by
, last
);
761 reverse_rows (matrix
, first
, last
);
765 /* Down (rotate right, i.e. towards higher indices). */
766 reverse_rows (matrix
, last
- by
, last
);
767 reverse_rows (matrix
, first
, last
- by
);
768 reverse_rows (matrix
, first
, last
);
773 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
774 with indices START <= index < END. Increment positions by DELTA/
778 increment_glyph_matrix_buffer_positions (matrix
, start
, end
, delta
,
780 struct glyph_matrix
*matrix
;
781 int start
, end
, delta
, delta_bytes
;
783 /* Check that START and END are reasonable values. */
784 xassert (start
>= 0 && start
<= matrix
->nrows
);
785 xassert (end
>= 0 && end
<= matrix
->nrows
);
786 xassert (start
<= end
);
788 for (; start
< end
; ++start
)
789 increment_glyph_row_buffer_positions (matrix
->rows
+ start
,
794 /* Enable a range of rows in glyph matrix MATRIX. START and END are
795 the row indices of the first and last + 1 row to enable. If
796 ENABLED_P is non-zero, enabled_p flags in rows will be set to 1. */
799 enable_glyph_matrix_rows (matrix
, start
, end
, enabled_p
)
800 struct glyph_matrix
*matrix
;
804 xassert (start
<= end
);
805 xassert (start
>= 0 && start
< matrix
->nrows
);
806 xassert (end
>= 0 && end
<= matrix
->nrows
);
808 for (; start
< end
; ++start
)
809 matrix
->rows
[start
].enabled_p
= enabled_p
!= 0;
815 This empties all rows in MATRIX by setting the enabled_p flag for
816 all rows of the matrix to zero. The function prepare_desired_row
817 will eventually really clear a row when it sees one with a zero
820 Resets update hints to defaults value. The only update hint
821 currently present is the flag MATRIX->no_scrolling_p. */
824 clear_glyph_matrix (matrix
)
825 struct glyph_matrix
*matrix
;
829 enable_glyph_matrix_rows (matrix
, 0, matrix
->nrows
, 0);
830 matrix
->no_scrolling_p
= 0;
835 /* Shift part of the glyph matrix MATRIX of window W up or down.
836 Increment y-positions in glyph rows between START and END by DY,
837 and recompute their visible height. */
840 shift_glyph_matrix (w
, matrix
, start
, end
, dy
)
842 struct glyph_matrix
*matrix
;
847 xassert (start
<= end
);
848 xassert (start
>= 0 && start
< matrix
->nrows
);
849 xassert (end
>= 0 && end
<= matrix
->nrows
);
851 min_y
= WINDOW_DISPLAY_TOP_LINE_HEIGHT (w
);
852 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
854 for (; start
< end
; ++start
)
856 struct glyph_row
*row
= &matrix
->rows
[start
];
861 row
->visible_height
= row
->height
- (min_y
- row
->y
);
862 else if (row
->y
+ row
->height
> max_y
)
863 row
->visible_height
= row
->height
- (row
->y
+ row
->height
- max_y
);
865 row
->visible_height
= row
->height
;
870 /* Mark all rows in current matrices of frame F as invalid. Marking
871 invalid is done by setting enabled_p to zero for all rows in a
875 clear_current_matrices (f
)
876 register struct frame
*f
;
878 /* Clear frame current matrix, if we have one. */
879 if (f
->current_matrix
)
880 clear_glyph_matrix (f
->current_matrix
);
882 /* Clear the matrix of the menu bar window, if such a window exists.
883 The menu bar window is currently used to display menus on X when
884 no toolkit support is compiled in. */
885 if (WINDOWP (f
->menu_bar_window
))
886 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->current_matrix
);
888 /* Clear the matrix of the toolbar window, if any. */
889 if (WINDOWP (f
->toolbar_window
))
890 clear_glyph_matrix (XWINDOW (f
->toolbar_window
)->current_matrix
);
892 /* Clear current window matrices. */
893 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
894 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 0);
898 /* Clear out all display lines of F for a coming redisplay. */
901 clear_desired_matrices (f
)
902 register struct frame
*f
;
904 if (f
->desired_matrix
)
905 clear_glyph_matrix (f
->desired_matrix
);
907 if (WINDOWP (f
->menu_bar_window
))
908 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->desired_matrix
);
910 if (WINDOWP (f
->toolbar_window
))
911 clear_glyph_matrix (XWINDOW (f
->toolbar_window
)->desired_matrix
);
913 /* Do it for window matrices. */
914 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
915 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
919 /* Clear matrices in window tree rooted in W. If DESIRED_P is
920 non-zero clear desired matrices, otherwise clear current matrices. */
923 clear_window_matrices (w
, desired_p
)
929 if (!NILP (w
->hchild
))
931 xassert (WINDOWP (w
->hchild
));
932 clear_window_matrices (XWINDOW (w
->hchild
), desired_p
);
934 else if (!NILP (w
->vchild
))
936 xassert (WINDOWP (w
->vchild
));
937 clear_window_matrices (XWINDOW (w
->vchild
), desired_p
);
942 clear_glyph_matrix (w
->desired_matrix
);
945 clear_glyph_matrix (w
->current_matrix
);
946 w
->window_end_valid
= Qnil
;
950 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
956 /***********************************************************************
959 See dispextern.h for an overall explanation of glyph rows.
960 ***********************************************************************/
962 /* Clear glyph row ROW. Do it in a way that makes it robust against
963 changes in the glyph_row structure, i.e. addition or removal of
964 structure members. */
967 clear_glyph_row (row
)
968 struct glyph_row
*row
;
970 struct glyph
*p
[1 + LAST_AREA
];
971 static struct glyph_row null_row
;
974 p
[LEFT_MARGIN_AREA
] = row
->glyphs
[LEFT_MARGIN_AREA
];
975 p
[TEXT_AREA
] = row
->glyphs
[TEXT_AREA
];
976 p
[RIGHT_MARGIN_AREA
] = row
->glyphs
[RIGHT_MARGIN_AREA
];
977 p
[LAST_AREA
] = row
->glyphs
[LAST_AREA
];
982 /* Restore pointers. */
983 row
->glyphs
[LEFT_MARGIN_AREA
] = p
[LEFT_MARGIN_AREA
];
984 row
->glyphs
[TEXT_AREA
] = p
[TEXT_AREA
];
985 row
->glyphs
[RIGHT_MARGIN_AREA
] = p
[RIGHT_MARGIN_AREA
];
986 row
->glyphs
[LAST_AREA
] = p
[LAST_AREA
];
990 /* Make ROW an empty, enabled row of canonical character height,
991 in window W starting at y-position Y. */
994 blank_row (w
, row
, y
)
996 struct glyph_row
*row
;
1001 min_y
= WINDOW_DISPLAY_TOP_LINE_HEIGHT (w
);
1002 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
1004 clear_glyph_row (row
);
1006 row
->ascent
= row
->phys_ascent
= 0;
1007 row
->height
= row
->phys_height
= CANON_Y_UNIT (XFRAME (w
->frame
));
1010 row
->visible_height
= row
->height
- (min_y
- row
->y
);
1011 else if (row
->y
+ row
->height
> max_y
)
1012 row
->visible_height
= row
->height
- (row
->y
+ row
->height
- max_y
);
1014 row
->visible_height
= row
->height
;
1020 /* Increment buffer positions in glyph row ROW. DELTA and DELTA_BYTES
1021 are the amounts by which to change positions. Note that the first
1022 glyph of the text area of a row can have a buffer position even if
1023 the used count of the text area is zero. Such rows display line
1027 increment_glyph_row_buffer_positions (row
, delta
, delta_bytes
)
1028 struct glyph_row
*row
;
1029 int delta
, delta_bytes
;
1033 /* Increment start and end positions. */
1034 MATRIX_ROW_START_CHARPOS (row
) += delta
;
1035 MATRIX_ROW_START_BYTEPOS (row
) += delta_bytes
;
1036 MATRIX_ROW_END_CHARPOS (row
) += delta
;
1037 MATRIX_ROW_END_BYTEPOS (row
) += delta_bytes
;
1039 /* Increment positions in glyphs. */
1040 for (area
= 0; area
< LAST_AREA
; ++area
)
1041 for (i
= 0; i
< row
->used
[area
]; ++i
)
1042 if (BUFFERP (row
->glyphs
[area
][i
].object
)
1043 && row
->glyphs
[area
][i
].charpos
> 0)
1044 row
->glyphs
[area
][i
].charpos
+= delta
;
1046 /* Capture the case of rows displaying a line end. */
1047 if (row
->used
[TEXT_AREA
] == 0
1048 && MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1049 row
->glyphs
[TEXT_AREA
]->charpos
+= delta
;
1053 /* Swap glyphs between two glyph rows A and B. This exchanges glyph
1054 contents, i.e. glyph structure contents are exchanged between A and
1055 B without changing glyph pointers in A and B. */
1058 swap_glyphs_in_rows (a
, b
)
1059 struct glyph_row
*a
, *b
;
1063 for (area
= 0; area
< LAST_AREA
; ++area
)
1065 /* Number of glyphs to swap. */
1066 int max_used
= max (a
->used
[area
], b
->used
[area
]);
1068 /* Start of glyphs in area of row A. */
1069 struct glyph
*glyph_a
= a
->glyphs
[area
];
1071 /* End + 1 of glyphs in area of row A. */
1072 struct glyph
*glyph_a_end
= a
->glyphs
[max_used
];
1074 /* Start of glyphs in area of row B. */
1075 struct glyph
*glyph_b
= b
->glyphs
[area
];
1077 while (glyph_a
< glyph_a_end
)
1079 /* Non-ISO HP/UX compiler doesn't like auto struct
1083 *glyph_a
= *glyph_b
;
1092 /* Exchange pointers to glyph memory between glyph rows A and B. */
1095 swap_glyph_pointers (a
, b
)
1096 struct glyph_row
*a
, *b
;
1099 for (i
= 0; i
< LAST_AREA
+ 1; ++i
)
1101 struct glyph
*temp
= a
->glyphs
[i
];
1102 a
->glyphs
[i
] = b
->glyphs
[i
];
1103 b
->glyphs
[i
] = temp
;
1108 /* Copy glyph row structure FROM to glyph row structure TO, except
1109 that glyph pointers in the structures are left unchanged. */
1112 copy_row_except_pointers (to
, from
)
1113 struct glyph_row
*to
, *from
;
1115 struct glyph
*pointers
[1 + LAST_AREA
];
1117 /* Save glyph pointers of TO. */
1118 bcopy (to
->glyphs
, pointers
, sizeof to
->glyphs
);
1120 /* Do a structure assignment. */
1123 /* Restore original pointers of TO. */
1124 bcopy (pointers
, to
->glyphs
, sizeof to
->glyphs
);
1128 /* Copy contents of glyph row FROM to glyph row TO. Glyph pointers in
1129 TO and FROM are left unchanged. Glyph contents are copied from the
1130 glyph memory of FROM to the glyph memory of TO. Increment buffer
1131 positions in row TO by DELTA/ DELTA_BYTES. */
1134 copy_glyph_row_contents (to
, from
, delta
, delta_bytes
)
1135 struct glyph_row
*to
, *from
;
1136 int delta
, delta_bytes
;
1140 /* This is like a structure assignment TO = FROM, except that
1141 glyph pointers in the rows are left unchanged. */
1142 copy_row_except_pointers (to
, from
);
1144 /* Copy glyphs from FROM to TO. */
1145 for (area
= 0; area
< LAST_AREA
; ++area
)
1146 if (from
->used
[area
])
1147 bcopy (from
->glyphs
[area
], to
->glyphs
[area
],
1148 from
->used
[area
] * sizeof (struct glyph
));
1150 /* Increment buffer positions in TO by DELTA. */
1151 increment_glyph_row_buffer_positions (to
, delta
, delta_bytes
);
1155 /* Assign glyph row FROM to glyph row TO. This works like a structure
1156 assignment TO = FROM, except that glyph pointers are not copied but
1157 exchanged between TO and FROM. Pointers must be exchanged to avoid
1161 assign_row (to
, from
)
1162 struct glyph_row
*to
, *from
;
1164 swap_glyph_pointers (to
, from
);
1165 copy_row_except_pointers (to
, from
);
1169 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1170 a row in a window matrix, is a slice of the glyph memory of the
1171 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1172 is non-zero if the glyph memory of WINDOW_ROW is part of the glyph
1173 memory of FRAME_ROW. */
1176 glyph_row_slice_p (window_row
, frame_row
)
1177 struct glyph_row
*window_row
, *frame_row
;
1179 struct glyph
*window_glyph_start
= window_row
->glyphs
[0];
1180 struct glyph
*frame_glyph_start
= frame_row
->glyphs
[0];
1181 struct glyph
*frame_glyph_end
= frame_row
->glyphs
[LAST_AREA
];
1183 return (frame_glyph_start
<= window_glyph_start
1184 && window_glyph_start
< frame_glyph_end
);
1188 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1189 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1190 in WINDOW_MATRIX is found satisfying the condition. */
1192 static struct glyph_row
*
1193 find_glyph_row_slice (window_matrix
, frame_matrix
, row
)
1194 struct glyph_matrix
*window_matrix
, *frame_matrix
;
1199 xassert (row
>= 0 && row
< frame_matrix
->nrows
);
1201 for (i
= 0; i
< window_matrix
->nrows
; ++i
)
1202 if (glyph_row_slice_p (window_matrix
->rows
+ i
,
1203 frame_matrix
->rows
+ row
))
1206 return i
< window_matrix
->nrows
? window_matrix
->rows
+ i
: 0;
1210 /* Prepare ROW for display. Desired rows are cleared lazily,
1211 i.e. they are only marked as to be cleared by setting their
1212 enabled_p flag to zero. When a row is to be displayed, a prior
1213 call to this function really clears it. */
1216 prepare_desired_row (row
)
1217 struct glyph_row
*row
;
1219 if (!row
->enabled_p
)
1221 clear_glyph_row (row
);
1227 /* Return a hash code for glyph row ROW. */
1230 line_hash_code (row
)
1231 struct glyph_row
*row
;
1239 /* Give all highlighted lines the same hash code
1240 so as to encourage scrolling to leave them in place. */
1245 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
1246 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
1250 GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*glyph
);
1251 if (must_write_spaces
)
1253 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + g
;
1266 /* Return the cost of drawing line VPOS In MATRIX. The cost equals
1267 the number of characters in the line. If must_write_spaces is
1268 zero, leading and trailing spaces are ignored. */
1271 line_draw_cost (matrix
, vpos
)
1272 struct glyph_matrix
*matrix
;
1275 struct glyph_row
*row
= matrix
->rows
+ vpos
;
1276 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
1277 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
];
1279 Lisp_Object
*glyph_table_base
= GLYPH_TABLE_BASE
;
1280 int glyph_table_len
= GLYPH_TABLE_LENGTH
;
1282 /* Ignore trailing and leading spaces if we can. */
1283 if (!must_write_spaces
)
1285 /* Skip from the end over trailing spaces. */
1286 while (end
!= beg
&& CHAR_GLYPH_SPACE_P (*end
))
1289 /* All blank line. */
1293 /* Skip over leading spaces. */
1294 while (CHAR_GLYPH_SPACE_P (*beg
))
1298 /* If we don't have a glyph-table, each glyph is one character,
1299 so return the number of glyphs. */
1300 if (glyph_table_base
== 0)
1304 /* Otherwise, scan the glyphs and accumulate their total length
1309 GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*beg
);
1311 if (GLYPH_SIMPLE_P (glyph_table_base
, glyph_table_len
, g
))
1314 len
+= GLYPH_LENGTH (glyph_table_base
, g
);
1324 /* Test two glyph rows A and B for equality. Value is non-zero if A
1325 and B have equal contents. W is the window to which the glyphs
1326 rows A and B belong. It is needed here to test for partial row
1330 row_equal_p (w
, a
, b
)
1332 struct glyph_row
*a
, *b
;
1336 else if (a
->hash
!= b
->hash
)
1340 struct glyph
*a_glyph
, *b_glyph
, *a_end
;
1343 /* Compare glyphs. */
1344 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
1346 if (a
->used
[area
] != b
->used
[area
])
1349 a_glyph
= a
->glyphs
[area
];
1350 a_end
= a_glyph
+ a
->used
[area
];
1351 b_glyph
= b
->glyphs
[area
];
1353 while (a_glyph
< a_end
1354 && GLYPH_EQUAL_P (a_glyph
, b_glyph
))
1355 ++a_glyph
, ++b_glyph
;
1357 if (a_glyph
!= a_end
)
1361 if (a
->truncated_on_left_p
!= b
->truncated_on_left_p
1362 || a
->inverse_p
!= b
->inverse_p
1363 || a
->fill_line_p
!= b
->fill_line_p
1364 || a
->truncated_on_right_p
!= b
->truncated_on_right_p
1365 || a
->overlay_arrow_p
!= b
->overlay_arrow_p
1366 || a
->continued_p
!= b
->continued_p
1367 || a
->indicate_empty_line_p
!= b
->indicate_empty_line_p
1368 || a
->overlapped_p
!= b
->overlapped_p
1369 || (MATRIX_ROW_CONTINUATION_LINE_P (a
)
1370 != MATRIX_ROW_CONTINUATION_LINE_P (b
))
1371 /* Different partially visible characters on left margin. */
1373 /* Different height. */
1374 || a
->ascent
!= b
->ascent
1375 || a
->phys_ascent
!= b
->phys_ascent
1376 || a
->phys_height
!= b
->phys_height
1377 || a
->visible_height
!= b
->visible_height
)
1386 /***********************************************************************
1389 See dispextern.h for an overall explanation of glyph pools.
1390 ***********************************************************************/
1392 /* Allocate a glyph_pool structure. The structure returned is
1393 initialized with zeros. The global variable glyph_pool_count is
1394 incremented for each pool allocated. */
1396 static struct glyph_pool
*
1399 struct glyph_pool
*result
;
1401 /* Allocate a new glyph_pool and clear it. */
1402 result
= (struct glyph_pool
*) xmalloc (sizeof *result
);
1403 bzero (result
, sizeof *result
);
1405 /* For memory leak and double deletion checking. */
1412 /* Free a glyph_pool structure POOL. The function may be called with
1413 a null POOL pointer. The global variable glyph_pool_count is
1414 decremented with every pool structure freed. If this count gets
1415 negative, more structures were freed than allocated, i.e. one
1416 structure must have been freed more than once or a bogus pointer
1417 was passed to free_glyph_pool. */
1420 free_glyph_pool (pool
)
1421 struct glyph_pool
*pool
;
1425 /* More freed than allocated? */
1427 xassert (glyph_pool_count
>= 0);
1429 xfree (pool
->glyphs
);
1435 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1436 columns we need. This function never shrinks a pool. The only
1437 case in which this would make sense, would be when a frame's size
1438 is changed from a large value to a smaller one. But, if someone
1439 does it once, we can expect that he will do it again.
1441 Value is non-zero if the pool changed in a way which makes
1442 re-adjusting window glyph matrices necessary. */
1445 realloc_glyph_pool (pool
, matrix_dim
)
1446 struct glyph_pool
*pool
;
1447 struct dim matrix_dim
;
1452 changed_p
= (pool
->glyphs
== 0
1453 || matrix_dim
.height
!= pool
->nrows
1454 || matrix_dim
.width
!= pool
->ncolumns
);
1456 /* Enlarge the glyph pool. */
1457 needed
= matrix_dim
.width
* matrix_dim
.height
;
1458 if (needed
> pool
->nglyphs
)
1460 int size
= needed
* sizeof (struct glyph
);
1463 pool
->glyphs
= (struct glyph
*) xrealloc (pool
->glyphs
, size
);
1466 pool
->glyphs
= (struct glyph
*) xmalloc (size
);
1467 bzero (pool
->glyphs
, size
);
1470 pool
->nglyphs
= needed
;
1473 /* Remember the number of rows and columns because (a) we use then
1474 to do sanity checks, and (b) the number of columns determines
1475 where rows in the frame matrix start---this must be available to
1476 determine pointers to rows of window sub-matrices. */
1477 pool
->nrows
= matrix_dim
.height
;
1478 pool
->ncolumns
= matrix_dim
.width
;
1485 /***********************************************************************
1487 ***********************************************************************/
1491 /* Check that no glyph pointers have been lost in MATRIX. If a
1492 pointer has been lost, e.g. by using a structure assignment between
1493 rows, at least one pointer must occur more than once in the rows of
1497 check_matrix_pointer_lossage (matrix
)
1498 struct glyph_matrix
*matrix
;
1502 for (i
= 0; i
< matrix
->nrows
; ++i
)
1503 for (j
= 0; j
< matrix
->nrows
; ++j
)
1505 || (matrix
->rows
[i
].glyphs
[TEXT_AREA
]
1506 != matrix
->rows
[j
].glyphs
[TEXT_AREA
]));
1510 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1513 matrix_row (matrix
, row
)
1514 struct glyph_matrix
*matrix
;
1517 xassert (matrix
&& matrix
->rows
);
1518 xassert (row
>= 0 && row
< matrix
->nrows
);
1520 /* That's really too slow for normal testing because this function
1521 is called almost everywhere. Although---it's still astonishingly
1522 fast, so it is valuable to have for debugging purposes. */
1524 check_matrix_pointer_lossage (matrix
);
1527 return matrix
->rows
+ row
;
1531 #if 0 /* This function makes invalid assumptions when text is
1532 partially invisible. But it might come handy for debugging
1535 /* Check invariants that must hold for an up to date current matrix of
1539 check_matrix_invariants (w
)
1542 struct glyph_matrix
*matrix
= w
->current_matrix
;
1543 int yb
= window_text_bottom_y (w
);
1544 struct glyph_row
*row
= matrix
->rows
;
1545 struct glyph_row
*last_text_row
= NULL
;
1546 struct buffer
*saved
= current_buffer
;
1547 struct buffer
*buffer
= XBUFFER (w
->buffer
);
1550 /* This can sometimes happen for a fresh window. */
1551 if (matrix
->nrows
< 2)
1554 set_buffer_temp (buffer
);
1556 /* Note: last row is always reserved for the mode line. */
1557 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1558 && MATRIX_ROW_BOTTOM_Y (row
) < yb
)
1560 struct glyph_row
*next
= row
+ 1;
1562 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1563 last_text_row
= row
;
1565 /* Check that character and byte positions are in sync. */
1566 xassert (MATRIX_ROW_START_BYTEPOS (row
)
1567 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row
)));
1569 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1570 have such a position temporarily in case of a minibuffer
1571 displaying something like `[Sole completion]' at its end. */
1572 if (MATRIX_ROW_END_CHARPOS (row
) < BUF_ZV (current_buffer
))
1573 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1574 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row
)));
1576 /* Check that end position of `row' is equal to start position
1578 if (next
->enabled_p
&& MATRIX_ROW_DISPLAYS_TEXT_P (next
))
1580 xassert (MATRIX_ROW_END_CHARPOS (row
)
1581 == MATRIX_ROW_START_CHARPOS (next
));
1582 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1583 == MATRIX_ROW_START_BYTEPOS (next
));
1588 xassert (w
->current_matrix
->nrows
== w
->desired_matrix
->nrows
);
1589 xassert (w
->desired_matrix
->rows
!= NULL
);
1590 set_buffer_temp (saved
);
1595 #endif /* GLYPH_DEBUG != 0 */
1599 /**********************************************************************
1600 Allocating/ Adjusting Glyph Matrices
1601 **********************************************************************/
1603 /* Allocate glyph matrices over a window tree for a frame-based
1606 X and Y are column/row within the frame glyph matrix where
1607 sub-matrices for the window tree rooted at WINDOW must be
1608 allocated. CH_DIM contains the dimensions of the smallest
1609 character that could be used during display. DIM_ONLY_P non-zero
1610 means that the caller of this function is only interested in the
1611 result matrix dimension, and matrix adjustments should not be
1614 The function returns the total width/height of the sub-matrices of
1615 the window tree. If called on a frame root window, the computation
1616 will take the mini-buffer window into account.
1618 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1620 NEW_LEAF_MATRIX set if any window in the tree did not have a
1621 glyph matrices yet, and
1623 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1624 any window in the tree will be changed or have been changed (see
1627 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1630 Windows are arranged into chains of windows on the same level
1631 through the next fields of window structures. Such a level can be
1632 either a sequence of horizontally adjacent windows from left to
1633 right, or a sequence of vertically adjacent windows from top to
1634 bottom. Each window in a horizontal sequence can be either a leaf
1635 window or a vertical sequence; a window in a vertical sequence can
1636 be either a leaf or a horizontal sequence. All windows in a
1637 horizontal sequence have the same height, and all windows in a
1638 vertical sequence have the same width.
1640 This function uses, for historical reasons, a more general
1641 algorithm to determine glyph matrix dimensions that would be
1644 The matrix height of a horizontal sequence is determined by the
1645 maximum height of any matrix in the sequence. The matrix width of
1646 a horizontal sequence is computed by adding up matrix widths of
1647 windows in the sequence.
1649 |<------- result width ------->|
1650 +---------+----------+---------+ ---
1653 +---------+ | | result height
1658 The matrix width of a vertical sequence is the maximum matrix width
1659 of any window in the sequence. Its height is computed by adding up
1660 matrix heights of windows in the sequence.
1662 |<---- result width -->|
1670 +------------+---------+ |
1673 +------------+---------+ --- */
1675 /* Bit indicating that a new matrix will be allocated or has been
1678 #define NEW_LEAF_MATRIX (1 << 0)
1680 /* Bit indicating that a matrix will or has changed its location or
1683 #define CHANGED_LEAF_MATRIX (1 << 1)
1686 allocate_matrices_for_frame_redisplay (window
, x
, y
, ch_dim
,
1687 dim_only_p
, window_change_flags
)
1692 int *window_change_flags
;
1694 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1696 int wmax
= 0, hmax
= 0;
1700 int in_horz_combination_p
;
1702 /* What combination is WINDOW part of? Compute this once since the
1703 result is the same for all windows in the `next' chain. The
1704 special case of a root window (parent equal to nil) is treated
1705 like a vertical combination because a root window's `next'
1706 points to the mini-buffer window, if any, which is arranged
1707 vertically below other windows. */
1708 in_horz_combination_p
1709 = (!NILP (XWINDOW (window
)->parent
)
1710 && !NILP (XWINDOW (XWINDOW (window
)->parent
)->hchild
));
1712 /* For WINDOW and all windows on the same level. */
1715 w
= XWINDOW (window
);
1717 /* Get the dimension of the window sub-matrix for W, depending
1718 on whether this a combination or a leaf window. */
1719 if (!NILP (w
->hchild
))
1720 dim
= allocate_matrices_for_frame_redisplay (w
->hchild
, x
, y
, ch_dim
,
1722 window_change_flags
);
1723 else if (!NILP (w
->vchild
))
1724 dim
= allocate_matrices_for_frame_redisplay (w
->vchild
, x
, y
, ch_dim
,
1726 window_change_flags
);
1729 /* If not already done, allocate sub-matrix structures. */
1730 if (w
->desired_matrix
== NULL
)
1732 w
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1733 w
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1734 *window_change_flags
|= NEW_LEAF_MATRIX
;
1737 /* Width and height MUST be chosen so that there are no
1738 holes in the frame matrix. */
1739 dim
.width
= w
->width
;
1740 dim
.height
= w
->height
;
1742 /* Will matrix be re-allocated? */
1743 if (x
!= w
->desired_matrix
->matrix_x
1744 || y
!= w
->desired_matrix
->matrix_y
1745 || dim
.width
!= w
->desired_matrix
->matrix_w
1746 || dim
.height
!= w
->desired_matrix
->matrix_h
1747 || (margin_glyphs_to_reserve (w
, dim
.width
,
1748 w
->right_margin_width
)
1749 != w
->desired_matrix
->left_margin_glyphs
)
1750 || (margin_glyphs_to_reserve (w
, dim
.width
,
1751 w
->left_margin_width
)
1752 != w
->desired_matrix
->right_margin_glyphs
))
1753 *window_change_flags
|= CHANGED_LEAF_MATRIX
;
1755 /* Actually change matrices, if allowed. Do not consider
1756 CHANGED_LEAF_MATRIX computed above here because the pool
1757 may have been changed which we don't now here. We trust
1758 that we only will be called with DIM_ONLY_P != 0 when
1762 adjust_glyph_matrix (w
, w
->desired_matrix
, x
, y
, dim
);
1763 adjust_glyph_matrix (w
, w
->current_matrix
, x
, y
, dim
);
1767 /* If we are part of a horizontal combination, advance x for
1768 windows to the right of W; otherwise advance y for windows
1770 if (in_horz_combination_p
)
1775 /* Remember maximum glyph matrix dimensions. */
1776 wmax
= max (wmax
, dim
.width
);
1777 hmax
= max (hmax
, dim
.height
);
1779 /* Next window on same level. */
1782 while (!NILP (window
));
1784 /* Set `total' to the total glyph matrix dimension of this window
1785 level. In a vertical combination, the width is the width of the
1786 widest window; the height is the y we finally reached, corrected
1787 by the y we started with. In a horizontal combination, the total
1788 height is the height of the tallest window, and the width is the
1789 x we finally reached, corrected by the x we started with. */
1790 if (in_horz_combination_p
)
1792 total
.width
= x
- x0
;
1793 total
.height
= hmax
;
1798 total
.height
= y
- y0
;
1805 /* Allocate window matrices for window-based redisplay. W is the
1806 window whose matrices must be allocated/reallocated. CH_DIM is the
1807 size of the smallest character that could potentially be used on W. */
1810 allocate_matrices_for_window_redisplay (w
, ch_dim
)
1814 struct frame
*f
= XFRAME (w
->frame
);
1818 if (!NILP (w
->vchild
))
1819 allocate_matrices_for_window_redisplay (XWINDOW (w
->vchild
), ch_dim
);
1820 else if (!NILP (w
->hchild
))
1821 allocate_matrices_for_window_redisplay (XWINDOW (w
->hchild
), ch_dim
);
1824 /* W is a leaf window. */
1825 int window_pixel_width
= XFLOATINT (w
->width
) * CANON_X_UNIT (f
);
1826 int window_pixel_height
= window_box_height (w
) + abs (w
->vscroll
);
1829 /* If matrices are not yet allocated, allocate them now. */
1830 if (w
->desired_matrix
== NULL
)
1832 w
->desired_matrix
= new_glyph_matrix (NULL
);
1833 w
->current_matrix
= new_glyph_matrix (NULL
);
1836 /* Compute number of glyphs needed in a glyph row. */
1837 dim
.width
= (((window_pixel_width
+ ch_dim
.width
- 1)
1839 /* 2 partially visible columns in the text area. */
1841 /* One partially visible column at the right
1842 edge of each marginal area. */
1845 /* Compute number of glyph rows needed. */
1846 dim
.height
= (((window_pixel_height
+ ch_dim
.height
- 1)
1848 /* One partially visible line at the top and
1849 bottom of the window. */
1851 /* 2 for top and mode line. */
1854 /* Change matrices. */
1855 adjust_glyph_matrix (w
, w
->desired_matrix
, 0, 0, dim
);
1856 adjust_glyph_matrix (w
, w
->current_matrix
, 0, 0, dim
);
1859 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
1864 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
1865 do it for all frames; otherwise do it just for the given frame.
1866 This function must be called when a new frame is created, its size
1867 changes, or its window configuration changes. */
1873 /* Block input so that expose events and other events that access
1874 glyph matrices are not processed while we are changing them. */
1878 adjust_frame_glyphs (f
);
1881 Lisp_Object tail
, lisp_frame
;
1883 FOR_EACH_FRAME (tail
, lisp_frame
)
1884 adjust_frame_glyphs (XFRAME (lisp_frame
));
1891 /* Adjust frame glyphs when Emacs is initialized.
1893 To be called from init_display.
1895 We need a glyph matrix because redraw will happen soon.
1896 Unfortunately, window sizes on selected_frame are not yet set to
1897 meaningful values. I believe we can assume that there are only two
1898 windows on the frame---the mini-buffer and the root window. Frame
1899 height and width seem to be correct so far. So, set the sizes of
1900 windows to estimated values. */
1903 adjust_frame_glyphs_initially ()
1905 struct window
*root
= XWINDOW (selected_frame
->root_window
);
1906 struct window
*mini
= XWINDOW (root
->next
);
1907 int frame_height
= FRAME_HEIGHT (selected_frame
);
1908 int frame_width
= FRAME_WIDTH (selected_frame
);
1909 int top_margin
= FRAME_TOP_MARGIN (selected_frame
);
1911 /* Do it for the root window. */
1912 XSETFASTINT (root
->top
, top_margin
);
1913 XSETFASTINT (root
->width
, frame_width
);
1914 set_window_height (selected_frame
->root_window
,
1915 frame_height
- 1 - top_margin
, 0);
1917 /* Do it for the mini-buffer window. */
1918 XSETFASTINT (mini
->top
, frame_height
- 1);
1919 XSETFASTINT (mini
->width
, frame_width
);
1920 set_window_height (root
->next
, 1, 0);
1922 adjust_frame_glyphs (selected_frame
);
1923 glyphs_initialized_initially_p
= 1;
1927 /* Allocate/reallocate glyph matrices of a single frame F. */
1930 adjust_frame_glyphs (f
)
1933 if (FRAME_WINDOW_P (f
))
1934 adjust_frame_glyphs_for_window_redisplay (f
);
1936 adjust_frame_glyphs_for_frame_redisplay (f
);
1938 /* Don't forget the message buffer and the buffer for
1939 decode_mode_spec. */
1940 adjust_frame_message_buffer (f
);
1941 adjust_decode_mode_spec_buffer (f
);
1943 f
->glyphs_initialized_p
= 1;
1947 /* Allocate/reallocate glyph matrices of a single frame F for
1948 frame-based redisplay. */
1951 adjust_frame_glyphs_for_frame_redisplay (f
)
1955 struct dim matrix_dim
;
1957 int window_change_flags
;
1960 if (!FRAME_LIVE_P (f
))
1963 /* Determine the smallest character in any font for F. On
1964 console windows, all characters have dimension (1, 1). */
1965 ch_dim
.width
= ch_dim
.height
= 1;
1967 top_window_y
= FRAME_TOP_MARGIN (f
);
1969 /* Allocate glyph pool structures if not already done. */
1970 if (f
->desired_pool
== NULL
)
1972 f
->desired_pool
= new_glyph_pool ();
1973 f
->current_pool
= new_glyph_pool ();
1976 /* Allocate frames matrix structures if needed. */
1977 if (f
->desired_matrix
== NULL
)
1979 f
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1980 f
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1983 /* Compute window glyph matrices. (This takes the mini-buffer
1984 window into account). The result is the size of the frame glyph
1985 matrix needed. The variable window_change_flags is set to a bit
1986 mask indicating whether new matrices will be allocated or
1987 existing matrices change their size or location within the frame
1989 window_change_flags
= 0;
1991 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
1994 &window_change_flags
);
1996 /* Add in menu bar lines, if any. */
1997 matrix_dim
.height
+= top_window_y
;
1999 /* Enlarge pools as necessary. */
2000 pool_changed_p
= realloc_glyph_pool (f
->desired_pool
, matrix_dim
);
2001 realloc_glyph_pool (f
->current_pool
, matrix_dim
);
2003 /* Set up glyph pointers within window matrices. Do this only if
2004 absolutely necessary since it requires a frame redraw. */
2005 if (pool_changed_p
|| window_change_flags
)
2007 /* Do it for window matrices. */
2008 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2009 0, top_window_y
, ch_dim
, 0,
2010 &window_change_flags
);
2012 /* Size of frame matrices must equal size of frame. Note
2013 that we are called for X frames with window widths NOT equal
2014 to the frame width (from CHANGE_FRAME_SIZE_1). */
2015 xassert (matrix_dim
.width
== FRAME_WIDTH (f
)
2016 && matrix_dim
.height
== FRAME_HEIGHT (f
));
2018 /* Resize frame matrices. */
2019 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2020 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2022 /* Since location and size of sub-matrices within the pool may
2023 have changed, and current matrices don't have meaningful
2024 contents anymore, mark the frame garbaged. */
2025 SET_FRAME_GARBAGED (f
);
2030 /* Allocate/reallocate glyph matrices of a single frame F for
2031 window-based redisplay. */
2034 adjust_frame_glyphs_for_window_redisplay (f
)
2040 xassert (FRAME_WINDOW_P (f
) && FRAME_LIVE_P (f
));
2042 /* Get minimum sizes. */
2043 #ifdef HAVE_WINDOW_SYSTEM
2044 ch_dim
.width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2045 ch_dim
.height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
2047 ch_dim
.width
= ch_dim
.height
= 1;
2050 /* Allocate/reallocate window matrices. */
2051 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f
)),
2054 /* Allocate/ reallocate matrices of the dummy window used to display
2055 the menu bar under X when no X toolkit support is available. */
2056 #ifndef USE_X_TOOLKIT
2058 /* Allocate a dummy window if not already done. */
2059 if (NILP (f
->menu_bar_window
))
2061 f
->menu_bar_window
= make_window ();
2062 w
= XWINDOW (f
->menu_bar_window
);
2063 XSETFRAME (w
->frame
, f
);
2064 w
->pseudo_window_p
= 1;
2067 w
= XWINDOW (f
->menu_bar_window
);
2069 /* Set window dimensions to frame dimensions and allocate or
2070 adjust glyph matrices of W. */
2071 XSETFASTINT (w
->top
, 0);
2072 XSETFASTINT (w
->left
, 0);
2073 XSETFASTINT (w
->height
, FRAME_MENU_BAR_LINES (f
));
2074 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2075 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2077 #endif /* not USE_X_TOOLKIT */
2079 /* Allocate/ reallocate matrices of the toolbar window. If we don't
2080 have a toolbar window yet, make one. */
2081 if (NILP (f
->toolbar_window
))
2083 f
->toolbar_window
= make_window ();
2084 w
= XWINDOW (f
->toolbar_window
);
2085 XSETFRAME (w
->frame
, f
);
2086 w
->pseudo_window_p
= 1;
2089 w
= XWINDOW (f
->toolbar_window
);
2091 XSETFASTINT (w
->top
, FRAME_MENU_BAR_LINES (f
));
2092 XSETFASTINT (w
->left
, 0);
2093 XSETFASTINT (w
->height
, FRAME_TOOLBAR_LINES (f
));
2094 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2095 allocate_matrices_for_window_redisplay (w
, ch_dim
);
2099 /* Adjust/ allocate message buffer of frame F.
2101 Note that the message buffer is never freed. Since I could not
2102 find a free in 19.34, I assume that freeing it would be
2103 problematic in some way and don't do it either.
2105 (Implementation note: It should be checked if we can free it
2106 eventually without causing trouble). */
2109 adjust_frame_message_buffer (f
)
2112 int size
= FRAME_MESSAGE_BUF_SIZE (f
) + 1;
2114 if (FRAME_MESSAGE_BUF (f
))
2116 char *buffer
= FRAME_MESSAGE_BUF (f
);
2117 char *new_buffer
= (char *) xrealloc (buffer
, size
);
2118 FRAME_MESSAGE_BUF (f
) = new_buffer
;
2121 FRAME_MESSAGE_BUF (f
) = (char *) xmalloc (size
);
2125 /* Re-allocate buffer for decode_mode_spec on frame F. */
2128 adjust_decode_mode_spec_buffer (f
)
2131 f
->decode_mode_spec_buffer
2132 = (char *) xrealloc (f
->decode_mode_spec_buffer
,
2133 FRAME_MESSAGE_BUF_SIZE (f
) + 1);
2138 /**********************************************************************
2139 Freeing Glyph Matrices
2140 **********************************************************************/
2142 /* Free glyph memory for a frame F. F may be null. This function can
2143 be called for the same frame more than once. The root window of
2144 F may be nil when this function is called. This is the case when
2145 the function is called when F is destroyed. */
2151 if (f
&& f
->glyphs_initialized_p
)
2153 f
->glyphs_initialized_p
= 0;
2155 /* Release window sub-matrices. */
2156 if (!NILP (f
->root_window
))
2157 free_window_matrices (XWINDOW (f
->root_window
));
2159 /* Free the dummy window for menu bars without X toolkit and its
2161 if (!NILP (f
->menu_bar_window
))
2163 struct window
*w
= XWINDOW (f
->menu_bar_window
);
2164 free_glyph_matrix (w
->desired_matrix
);
2165 free_glyph_matrix (w
->current_matrix
);
2166 w
->desired_matrix
= w
->current_matrix
= NULL
;
2167 f
->menu_bar_window
= Qnil
;
2170 /* Free the toolbar window and its glyph matrices. */
2171 if (!NILP (f
->toolbar_window
))
2173 struct window
*w
= XWINDOW (f
->toolbar_window
);
2174 free_glyph_matrix (w
->desired_matrix
);
2175 free_glyph_matrix (w
->current_matrix
);
2176 w
->desired_matrix
= w
->current_matrix
= NULL
;
2177 f
->toolbar_window
= Qnil
;
2180 /* Release frame glyph matrices. Reset fields to zero in
2181 case we are called a second time. */
2182 if (f
->desired_matrix
)
2184 free_glyph_matrix (f
->desired_matrix
);
2185 free_glyph_matrix (f
->current_matrix
);
2186 f
->desired_matrix
= f
->current_matrix
= NULL
;
2189 /* Release glyph pools. */
2190 if (f
->desired_pool
)
2192 free_glyph_pool (f
->desired_pool
);
2193 free_glyph_pool (f
->current_pool
);
2194 f
->desired_pool
= f
->current_pool
= NULL
;
2200 /* Free glyph sub-matrices in the window tree rooted at W. This
2201 function may be called with a null pointer, and it may be called on
2202 the same tree more than once. */
2205 free_window_matrices (w
)
2210 if (!NILP (w
->hchild
))
2211 free_window_matrices (XWINDOW (w
->hchild
));
2212 else if (!NILP (w
->vchild
))
2213 free_window_matrices (XWINDOW (w
->vchild
));
2216 /* This is a leaf window. Free its memory and reset fields
2217 to zero in case this function is called a second time for
2219 free_glyph_matrix (w
->current_matrix
);
2220 free_glyph_matrix (w
->desired_matrix
);
2221 w
->current_matrix
= w
->desired_matrix
= NULL
;
2224 /* Next window on same level. */
2225 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2230 /* Check glyph memory leaks. This function is called from
2231 shut_down_emacs. Note that frames are not destroyed when Emacs
2232 exits. We therefore free all glyph memory for all active frames
2233 explicitly and check that nothing is left allocated. */
2236 check_glyph_memory ()
2238 Lisp_Object tail
, frame
;
2240 /* Free glyph memory for all frames. */
2241 FOR_EACH_FRAME (tail
, frame
)
2242 free_glyphs (XFRAME (frame
));
2244 /* Check that nothing is left allocated. */
2245 if (glyph_matrix_count
)
2247 if (glyph_pool_count
)
2253 /**********************************************************************
2254 Building a Frame Matrix
2255 **********************************************************************/
2257 /* Most of the redisplay code works on glyph matrices attached to
2258 windows. This is a good solution most of the time, but it is not
2259 suitable for terminal code. Terminal output functions cannot rely
2260 on being able to set an arbitrary terminal window. Instead they
2261 must be provided with a view of the whole frame, i.e. the whole
2262 screen. We build such a view by constructing a frame matrix from
2263 window matrices in this section.
2265 Windows that must be updated have their must_be_update_p flag set.
2266 For all such windows, their desired matrix is made part of the
2267 desired frame matrix. For other windows, their current matrix is
2268 made part of the desired frame matrix.
2270 +-----------------+----------------+
2271 | desired | desired |
2273 +-----------------+----------------+
2276 +----------------------------------+
2278 Desired window matrices can be made part of the frame matrix in a
2279 cheap way: We exploit the fact that the desired frame matrix and
2280 desired window matrices share their glyph memory. This is not
2281 possible for current window matrices. Their glyphs are copied to
2282 the desired frame matrix. The latter is equivalent to
2283 preserve_other_columns in the old redisplay.
2285 Used glyphs counters for frame matrix rows are the result of adding
2286 up glyph lengths of the window matrices. A line in the frame
2287 matrix is enabled, if a corresponding line in a window matrix is
2290 After building the desired frame matrix, it will be passed to
2291 terminal code, which will manipulate both the desired and current
2292 frame matrix. Changes applied to the frame's current matrix have
2293 to be visible in current window matrices afterwards, of course.
2295 This problem is solved like this:
2297 1. Window and frame matrices share glyphs. Window matrices are
2298 constructed in a way that their glyph contents ARE the glyph
2299 contents needed in a frame matrix. Thus, any modification of
2300 glyphs done in terminal code will be reflected in window matrices
2303 2. Exchanges of rows in a frame matrix done by terminal code are
2304 intercepted by hook functions so that corresponding row operations
2305 on window matrices can be performed. This is necessary because we
2306 use pointers to glyphs in glyph row structures. To satisfy the
2307 assumption of point 1 above that glyphs are updated implicitly in
2308 window matrices when they are manipulated via the frame matrix,
2309 window and frame matrix must of course agree where to find the
2310 glyphs for their rows. Possible manipulations that must be
2311 mirrored are assignments of rows of the desired frame matrix to the
2312 current frame matrix and scrolling the current frame matrix. */
2314 /* Build frame F's desired matrix from window matrices. Only windows
2315 which have the flag must_be_updated_p set have to be updated. Menu
2316 bar lines of a frame are not covered by window matrices, so make
2317 sure not to touch them in this function. */
2320 build_frame_matrix (f
)
2325 /* F must have a frame matrix when this function is called. */
2326 xassert (!FRAME_WINDOW_P (f
));
2328 /* Clear all rows in the frame matrix covered by window matrices.
2329 Menu bar lines are not covered by windows. */
2330 for (i
= FRAME_TOP_MARGIN (f
); i
< f
->desired_matrix
->nrows
; ++i
)
2331 clear_glyph_row (MATRIX_ROW (f
->desired_matrix
, i
));
2333 /* Build the matrix by walking the window tree. */
2334 build_frame_matrix_from_window_tree (f
->desired_matrix
,
2335 XWINDOW (FRAME_ROOT_WINDOW (f
)));
2339 /* Walk a window tree, building a frame matrix MATRIX from window
2340 matrices. W is the root of a window tree. */
2343 build_frame_matrix_from_window_tree (matrix
, w
)
2344 struct glyph_matrix
*matrix
;
2349 if (!NILP (w
->hchild
))
2350 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->hchild
));
2351 else if (!NILP (w
->vchild
))
2352 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->vchild
));
2354 build_frame_matrix_from_leaf_window (matrix
, w
);
2356 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2361 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2362 desired frame matrix built. W is a leaf window whose desired or
2363 current matrix is to be added to FRAME_MATRIX. W's flag
2364 must_be_updated_p determines which matrix it contributes to
2365 FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix
2366 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2367 Adding a desired matrix means setting up used counters and such in
2368 frame rows, while adding a current window matrix to FRAME_MATRIX
2369 means copying glyphs. The latter case corresponds to
2370 preserve_other_columns in the old redisplay. */
2373 build_frame_matrix_from_leaf_window (frame_matrix
, w
)
2374 struct glyph_matrix
*frame_matrix
;
2377 struct glyph_matrix
*window_matrix
;
2378 int window_y
, frame_y
;
2379 /* If non-zero, a glyph to insert at the right border of W. */
2380 GLYPH right_border_glyph
= 0;
2382 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2383 if (w
->must_be_updated_p
)
2385 window_matrix
= w
->desired_matrix
;
2387 /* Decide whether we want to add a vertical border glyph. */
2388 if (!WINDOW_RIGHTMOST_P (w
))
2390 struct Lisp_Char_Table
*dp
= window_display_table (w
);
2391 right_border_glyph
= (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
2392 ? XINT (DISP_BORDER_GLYPH (dp
))
2397 window_matrix
= w
->current_matrix
;
2399 /* For all rows in the window matrix and corresponding rows in the
2402 frame_y
= window_matrix
->matrix_y
;
2403 while (window_y
< window_matrix
->nrows
)
2405 struct glyph_row
*frame_row
= frame_matrix
->rows
+ frame_y
;
2406 struct glyph_row
*window_row
= window_matrix
->rows
+ window_y
;
2408 /* Fill up the frame row with spaces up to the left margin of the
2410 fill_up_frame_row_with_spaces (frame_row
, window_matrix
->matrix_x
);
2412 /* Fill up areas in the window matrix row with spaces. */
2413 fill_up_glyph_row_with_spaces (window_row
);
2415 if (window_matrix
== w
->current_matrix
)
2417 /* We have to copy W's current matrix. Copy window
2418 row to frame row. */
2419 bcopy (window_row
->glyphs
[0],
2420 frame_row
->glyphs
[TEXT_AREA
] + window_matrix
->matrix_x
,
2421 window_matrix
->matrix_w
* sizeof (struct glyph
));
2425 /* Copy W's desired matrix. */
2427 /* Maybe insert a vertical border between horizontally adjacent
2429 if (right_border_glyph
)
2431 struct glyph
*border
= window_row
->glyphs
[LAST_AREA
] - 1;
2432 SET_CHAR_GLYPH_FROM_GLYPH (*border
, right_border_glyph
);
2435 /* Due to hooks installed, it normally doesn't happen that
2436 window rows and frame rows of the same matrix are out of
2437 sync, i.e. have a different understanding of where to
2438 find glyphs for the row. The following is a safety-belt
2439 that doesn't cost much and makes absolutely sure that
2440 window and frame matrices are in sync. */
2441 if (!glyph_row_slice_p (window_row
, frame_row
))
2443 /* Find the row in the window being a slice. There
2444 should exist one from program logic. */
2445 struct glyph_row
*slice_row
2446 = find_glyph_row_slice (window_matrix
, frame_matrix
, frame_y
);
2447 xassert (slice_row
!= 0);
2449 /* Exchange glyphs between both window rows. */
2450 swap_glyphs_in_rows (window_row
, slice_row
);
2452 /* Exchange pointers between both rows. */
2453 swap_glyph_pointers (window_row
, slice_row
);
2456 /* Now, we are sure that window row window_y is a slice of
2457 the frame row frame_y. But, lets check that assumption. */
2458 xassert (glyph_row_slice_p (window_row
, frame_row
));
2460 /* If rows are in sync, we don't have to copy glyphs because
2461 frame and window share glyphs. */
2464 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
2468 /* Set number of used glyphs in the frame matrix. Since we fill
2469 up with spaces, and visit leaf windows from left to right it
2470 can be done simply. */
2471 frame_row
->used
[TEXT_AREA
]
2472 = window_matrix
->matrix_x
+ window_matrix
->matrix_w
;
2475 frame_row
->enabled_p
|= window_row
->enabled_p
;
2476 frame_row
->inverse_p
|= window_row
->inverse_p
;
2485 /* Add spaces to a glyph row ROW in a window matrix.
2487 Each row has the form:
2489 +---------+-----------------------------+------------+
2490 | left | text | right |
2491 +---------+-----------------------------+------------+
2493 Left and right marginal areas are optional. This function adds
2494 spaces to areas so that there are no empty holes between areas.
2495 In other words: If the right area is not empty, the text area
2496 is filled up with spaces up to the right area. If the text area
2497 is not empty, the left area is filled up.
2499 To be called for frame-based redisplay, only. */
2502 fill_up_glyph_row_with_spaces (row
)
2503 struct glyph_row
*row
;
2505 fill_up_glyph_row_area_with_spaces (row
, LEFT_MARGIN_AREA
);
2506 fill_up_glyph_row_area_with_spaces (row
, TEXT_AREA
);
2507 fill_up_glyph_row_area_with_spaces (row
, RIGHT_MARGIN_AREA
);
2511 /* Fill area AREA of glyph row ROW with spaces. To be called for
2512 frame-based redisplay only. */
2515 fill_up_glyph_row_area_with_spaces (row
, area
)
2516 struct glyph_row
*row
;
2519 if (row
->glyphs
[area
] < row
->glyphs
[area
+ 1])
2521 struct glyph
*end
= row
->glyphs
[area
+ 1];
2522 struct glyph
*text
= row
->glyphs
[area
] + row
->used
[area
];
2525 *text
++ = space_glyph
;
2526 row
->used
[area
] = text
- row
->glyphs
[area
];
2531 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2532 reached. In frame matrices only one area, TEXT_AREA, is used. */
2535 fill_up_frame_row_with_spaces (row
, upto
)
2536 struct glyph_row
*row
;
2539 int i
= row
->used
[TEXT_AREA
];
2540 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
2543 glyph
[i
++] = space_glyph
;
2545 row
->used
[TEXT_AREA
] = i
;
2550 /**********************************************************************
2551 Mirroring operations on frame matrices in window matrices
2552 **********************************************************************/
2554 /* Set frame being updated via frame-based redisplay to F. This
2555 function must be called before updates to make explicit that we are
2556 working on frame matrices or not. */
2559 set_frame_matrix_frame (f
)
2562 frame_matrix_frame
= f
;
2566 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2567 DESIRED_MATRIX is the desired matrix corresponding to
2568 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2569 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2570 frame_matrix_frame is non-null, this indicates that the exchange is
2571 done in frame matrices, and that we have to perform analogous
2572 operations in window matrices of frame_matrix_frame. */
2575 make_current (desired_matrix
, current_matrix
, row
)
2576 struct glyph_matrix
*desired_matrix
, *current_matrix
;
2579 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, row
);
2580 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, row
);
2582 /* Do current_row = desired_row. This exchanges glyph pointers
2583 between both rows, and does a structure assignment otherwise. */
2584 assign_row (current_row
, desired_row
);
2586 /* Enable current_row to mark it as valid. */
2587 current_row
->enabled_p
= 1;
2589 /* If we are called on frame matrices, perform analogous operations
2590 for window matrices. */
2591 if (frame_matrix_frame
)
2592 mirror_make_current (XWINDOW (frame_matrix_frame
->root_window
), row
);
2596 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2597 W's frame which has been made current (by swapping pointers between
2598 current and desired matrix). Perform analogous operations in the
2599 matrices of leaf windows in the window tree rooted at W. */
2602 mirror_make_current (w
, frame_row
)
2608 if (!NILP (w
->hchild
))
2609 mirror_make_current (XWINDOW (w
->hchild
), frame_row
);
2610 else if (!NILP (w
->vchild
))
2611 mirror_make_current (XWINDOW (w
->vchild
), frame_row
);
2614 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2615 here because the checks performed in debug mode there
2616 will not allow the conversion. */
2617 int row
= frame_row
- w
->desired_matrix
->matrix_y
;
2619 /* If FRAME_ROW is within W, assign the desired row to the
2620 current row (exchanging glyph pointers). */
2621 if (row
>= 0 && row
< w
->desired_matrix
->matrix_h
)
2623 struct glyph_row
*current_row
2624 = MATRIX_ROW (w
->current_matrix
, row
);
2625 struct glyph_row
*desired_row
2626 = MATRIX_ROW (w
->desired_matrix
, row
);
2628 if (desired_row
->enabled_p
)
2629 assign_row (current_row
, desired_row
);
2631 swap_glyph_pointers (desired_row
, current_row
);
2632 current_row
->enabled_p
= 1;
2636 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2641 /* Perform row dance after scrolling. We are working on the range of
2642 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2643 including) in MATRIX. COPY_FROM is a vector containing, for each
2644 row I in the range 0 <= I < NLINES, the index of the original line
2645 to move to I. This index is relative to the row range, i.e. 0 <=
2646 index < NLINES. RETAINED_P is a vector containing zero for each
2647 row 0 <= I < NLINES which is empty.
2649 This function is called from do_scrolling and do_direct_scrolling. */
2652 mirrored_line_dance (matrix
, unchanged_at_top
, nlines
, copy_from
,
2654 struct glyph_matrix
*matrix
;
2655 int unchanged_at_top
, nlines
;
2659 /* A copy of original rows. */
2660 struct glyph_row
*old_rows
;
2662 /* Rows to assign to. */
2663 struct glyph_row
*new_rows
= MATRIX_ROW (matrix
, unchanged_at_top
);
2667 /* Make a copy of the original rows. */
2668 old_rows
= (struct glyph_row
*) alloca (nlines
* sizeof *old_rows
);
2669 bcopy (new_rows
, old_rows
, nlines
* sizeof *old_rows
);
2671 /* Assign new rows, maybe clear lines. */
2672 for (i
= 0; i
< nlines
; ++i
)
2674 int enabled_before_p
= new_rows
[i
].enabled_p
;
2676 xassert (i
+ unchanged_at_top
< matrix
->nrows
);
2677 xassert (unchanged_at_top
+ copy_from
[i
] < matrix
->nrows
);
2678 new_rows
[i
] = old_rows
[copy_from
[i
]];
2679 new_rows
[i
].enabled_p
= enabled_before_p
;
2681 /* RETAINED_P is zero for empty lines. */
2682 if (!retained_p
[copy_from
[i
]])
2683 new_rows
[i
].enabled_p
= 0;
2686 /* Do the same for window matrices, if MATRIX Is a frame matrix. */
2687 if (frame_matrix_frame
)
2688 mirror_line_dance (XWINDOW (frame_matrix_frame
->root_window
),
2689 unchanged_at_top
, nlines
, copy_from
, retained_p
);
2693 /* Perform a line dance in the window tree rooted at W, after
2694 scrolling a frame matrix in mirrored_line_dance.
2696 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
2697 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
2698 COPY_FROM is a vector containing, for each row I in the range 0 <=
2699 I < NLINES, the index of the original line to move to I. This
2700 index is relative to the row range, i.e. 0 <= index < NLINES.
2701 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
2705 mirror_line_dance (w
, unchanged_at_top
, nlines
, copy_from
, retained_p
)
2707 int unchanged_at_top
, nlines
;
2713 if (!NILP (w
->hchild
))
2714 mirror_line_dance (XWINDOW (w
->hchild
), unchanged_at_top
,
2715 nlines
, copy_from
, retained_p
);
2716 else if (!NILP (w
->vchild
))
2717 mirror_line_dance (XWINDOW (w
->vchild
), unchanged_at_top
,
2718 nlines
, copy_from
, retained_p
);
2721 /* W is a leaf window, and we are working on its current
2723 struct glyph_matrix
*m
= w
->current_matrix
;
2727 struct glyph_row
*old_rows
;
2729 /* Make a copy of the original rows of matrix m. */
2730 old_rows
= (struct glyph_row
*) alloca (m
->nrows
* sizeof *old_rows
);
2731 bcopy (m
->rows
, old_rows
, m
->nrows
* sizeof *old_rows
);
2733 for (i
= 0; i
< nlines
; ++i
)
2735 /* Frame relative line assigned to. */
2736 int frame_to
= i
+ unchanged_at_top
;
2738 /* Frame relative line assigned. */
2739 int frame_from
= copy_from
[i
] + unchanged_at_top
;
2741 /* Window relative line assigned to. */
2742 int window_to
= frame_to
- m
->matrix_y
;
2744 /* Window relative line assigned. */
2745 int window_from
= frame_from
- m
->matrix_y
;
2747 /* Is assigned line inside window? */
2748 int from_inside_window_p
2749 = window_from
>= 0 && window_from
< m
->matrix_h
;
2751 if (from_inside_window_p
)
2754 /* Is assigned to line inside window? */
2755 int to_inside_window_p
2756 = window_to
>= 0 && window_to
< m
->matrix_h
;
2759 /* Enabled setting before assignment. */
2760 int enabled_before_p
;
2762 /* If not both lines inside the window, we have a
2764 xassert (to_inside_window_p
);
2766 /* Do the assignment. The enabled_p flag is saved
2767 over the assignment because the old redisplay did
2769 enabled_before_p
= m
->rows
[window_to
].enabled_p
;
2770 m
->rows
[window_to
] = old_rows
[window_from
];
2771 m
->rows
[window_to
].enabled_p
= enabled_before_p
;
2773 /* If frame line is empty, window line is empty, too. */
2774 if (!retained_p
[copy_from
[i
]])
2775 m
->rows
[window_to
].enabled_p
= 0;
2779 /* Check that no pointers are lost. */
2783 /* Next window on same level. */
2784 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2791 /* Check that window and frame matrices agree about their
2792 understanding where glyphs of the rows are to find. For each
2793 window in the window tree rooted at W, check that rows in the
2794 matrices of leaf window agree with their frame matrices about
2798 check_window_matrix_pointers (w
)
2803 if (!NILP (w
->hchild
))
2804 check_window_matrix_pointers (XWINDOW (w
->hchild
));
2805 else if (!NILP (w
->vchild
))
2806 check_window_matrix_pointers (XWINDOW (w
->vchild
));
2809 struct frame
*f
= XFRAME (w
->frame
);
2810 check_matrix_pointers (w
->desired_matrix
, f
->desired_matrix
);
2811 check_matrix_pointers (w
->current_matrix
, f
->current_matrix
);
2814 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2819 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
2820 a window and FRAME_MATRIX is the corresponding frame matrix. For
2821 each row in WINDOW_MATRIX check that it's a slice of the
2822 corresponding frame row. If it isn't, abort. */
2825 check_matrix_pointers (window_matrix
, frame_matrix
)
2826 struct glyph_matrix
*window_matrix
, *frame_matrix
;
2828 /* Row number in WINDOW_MATRIX. */
2831 /* Row number corresponding to I in FRAME_MATRIX. */
2832 int j
= window_matrix
->matrix_y
;
2834 /* For all rows check that the row in the window matrix is a
2835 slice of the row in the frame matrix. If it isn't we didn't
2836 mirror an operation on the frame matrix correctly. */
2837 while (i
< window_matrix
->nrows
)
2839 if (!glyph_row_slice_p (window_matrix
->rows
+ i
,
2840 frame_matrix
->rows
+ j
))
2846 #endif /* GLYPH_DEBUG != 0 */
2850 /**********************************************************************
2851 VPOS and HPOS translations
2852 **********************************************************************/
2856 /* Translate vertical position VPOS which is relative to window W to a
2857 vertical position relative to W's frame. */
2860 window_to_frame_vpos (w
, vpos
)
2864 struct frame
*f
= XFRAME (w
->frame
);
2866 xassert (!FRAME_WINDOW_P (f
));
2867 xassert (vpos
>= 0 && vpos
<= w
->desired_matrix
->nrows
);
2868 vpos
+= XFASTINT (w
->top
);
2869 xassert (vpos
>= 0 && vpos
<= FRAME_HEIGHT (f
));
2874 /* Translate horizontal position HPOS which is relative to window W to
2875 a vertical position relative to W's frame. */
2878 window_to_frame_hpos (w
, hpos
)
2882 struct frame
*f
= XFRAME (w
->frame
);
2884 xassert (!FRAME_WINDOW_P (f
));
2885 hpos
+= XFASTINT (w
->left
);
2889 #endif /* GLYPH_DEBUG */
2893 /**********************************************************************
2895 **********************************************************************/
2897 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
2898 "Clear frame FRAME and output again what is supposed to appear on it.")
2904 CHECK_LIVE_FRAME (frame
, 0);
2907 /* Ignore redraw requests, if frame has no glyphs yet.
2908 (Implementation note: It still has to be checked why we are
2909 called so early here). */
2910 if (!glyphs_initialized_initially_p
)
2914 if (FRAME_MSDOS_P (f
))
2915 set_terminal_modes ();
2917 clear_current_matrices (f
);
2920 windows_or_buffers_changed
++;
2921 /* Mark all windows as inaccurate, so that every window will have
2922 its redisplay done. */
2923 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
2924 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
2930 /* Redraw frame F. This is nothing more than a call to the Lisp
2931 function redraw-frame. */
2938 XSETFRAME (frame
, f
);
2939 Fredraw_frame (frame
);
2943 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
2944 "Clear and redisplay all visible frames.")
2947 Lisp_Object tail
, frame
;
2949 FOR_EACH_FRAME (tail
, frame
)
2950 if (FRAME_VISIBLE_P (XFRAME (frame
)))
2951 Fredraw_frame (frame
);
2957 /* This is used when frame_garbaged is set. Call Fredraw_frame on all
2958 visible frames marked as garbaged. */
2961 redraw_garbaged_frames ()
2963 Lisp_Object tail
, frame
;
2965 FOR_EACH_FRAME (tail
, frame
)
2966 if (FRAME_VISIBLE_P (XFRAME (frame
))
2967 && FRAME_GARBAGED_P (XFRAME (frame
)))
2968 Fredraw_frame (frame
);
2973 /***********************************************************************
2975 ***********************************************************************/
2977 /* Try to update display and current glyph matrix directly.
2979 This function is called after a character G has been inserted into
2980 current_buffer. It tries to update the current glyph matrix and
2981 perform appropriate screen output to reflect the insertion. If it
2982 succeeds, the global flag redisplay_performed_directly_p will be
2983 set to 1, and thereby prevent the more costly general redisplay
2984 from running (see redisplay_internal).
2986 This function is not called for `hairy' character insertions.
2987 In particular, it is not called when after or before change
2988 functions exist, like they are used by font-lock. See keyboard.c
2989 for details where this function is called. */
2992 direct_output_for_insert (g
)
2995 register struct frame
*f
= selected_frame
;
2996 struct window
*w
= XWINDOW (selected_window
);
2998 struct glyph_row
*glyph_row
;
2999 struct glyph
*glyphs
, *glyph
, *end
;
3001 /* Non-null means that Redisplay of W is based on window matrices. */
3002 int window_redisplay_p
= FRAME_WINDOW_P (f
);
3003 /* Non-null means we are in overwrite mode. */
3004 int overwrite_p
= !NILP (current_buffer
->overwrite_mode
);
3006 struct text_pos pos
;
3007 int delta
, delta_bytes
;
3009 /* Not done directly. */
3010 redisplay_performed_directly_p
= 0;
3012 /* Quickly give up for some common cases. */
3013 if (cursor_in_echo_area
3014 /* Give up if fonts have changed. */
3016 /* Give up if face attributes have been changed. */
3017 || face_change_count
3018 /* Give up if cursor position not really known. */
3019 || !display_completed
3020 /* Give up if buffer appears in two places. */
3021 || buffer_shared
> 1
3022 /* Give up if w is mini-buffer and a message is being displayed there */
3023 || (MINI_WINDOW_P (w
) && !NILP (echo_area_buffer
[0]))
3024 /* Give up for hscrolled mini-buffer because display of the prompt
3025 is handled specially there (see display_line). */
3026 || (MINI_WINDOW_P (w
) && XFASTINT (w
->hscroll
))
3027 /* Give up if overwriting in the middle of a line. */
3030 && FETCH_BYTE (PT
) != '\n')
3031 /* Give up for tabs and line ends. */
3035 /* Give up if unable to display the cursor in the window. */
3036 || w
->cursor
.vpos
< 0
3037 || (glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
),
3038 /* Can't do it in a continued line because continuation
3039 lines would change. */
3040 (glyph_row
->continued_p
3041 /* Can't use this method if the line overlaps others or is
3042 overlapped by others because these other lines would
3043 have to be redisplayed. */
3044 || glyph_row
->overlapping_p
3045 || glyph_row
->overlapped_p
))
3046 /* Can't do it for partial width windows on terminal frames
3047 because we can't clear to eol in such a window. */
3048 || (!window_redisplay_p
&& !WINDOW_FULL_WIDTH_P (w
)))
3051 /* Set up a display iterator structure for W. Glyphs will be
3052 produced in scratch_glyph_row. Current position is W's cursor
3054 clear_glyph_row (&scratch_glyph_row
);
3055 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
3057 init_iterator (&it
, w
, CHARPOS (pos
), BYTEPOS (pos
), &scratch_glyph_row
,
3060 glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3062 /* Give up if highlighting trailing whitespace and we have trailing
3063 whitespace in glyph_row. We would have to remove the trailing
3064 whitespace face in that case. */
3065 if (!NILP (Vshow_trailing_whitespace
)
3066 && glyph_row
->used
[TEXT_AREA
])
3070 last
= glyph_row
->glyphs
[TEXT_AREA
] + glyph_row
->used
[TEXT_AREA
] - 1;
3071 if (last
->type
== STRETCH_GLYPH
3072 || (last
->type
== CHAR_GLYPH
3073 && last
->u
.ch
.code
== ' '))
3077 /* Give up if there are overlay strings at pos. This would fail
3078 if the overlay string has newlines in it. */
3079 if (STRINGP (it
.string
))
3082 it
.hpos
= w
->cursor
.hpos
;
3083 it
.vpos
= w
->cursor
.vpos
;
3084 it
.current_x
= w
->cursor
.x
+ it
.first_visible_x
;
3085 it
.current_y
= w
->cursor
.y
;
3086 it
.end_charpos
= PT
;
3087 it
.stop_charpos
= min (PT
, it
.stop_charpos
);
3089 /* More than one display element may be returned for PT - 1 if
3090 (i) it's a control character which is translated into `\003' or
3091 `^C', or (ii) it has a display table entry, or (iii) it's a
3092 combination of both. */
3093 delta
= delta_bytes
= 0;
3094 while (get_next_display_element (&it
))
3096 PRODUCE_GLYPHS (&it
);
3098 /* Give up if glyph doesn't fit completely on the line. */
3099 if (it
.current_x
>= it
.last_visible_x
)
3102 /* Give up if new glyph has different ascent or descent than
3103 the original row, or if it is not a character glyph. */
3104 if (glyph_row
->ascent
!= it
.ascent
3105 || glyph_row
->height
!= it
.ascent
+ it
.descent
3106 || glyph_row
->phys_ascent
!= it
.phys_ascent
3107 || glyph_row
->phys_height
!= it
.phys_ascent
+ it
.phys_descent
3108 || it
.what
!= IT_CHARACTER
)
3112 delta_bytes
+= it
.len
;
3113 set_iterator_to_next (&it
);
3116 /* Give up if we hit the right edge of the window. We would have
3117 to insert truncation or continuation glyphs. */
3118 added_width
= it
.current_x
- (w
->cursor
.x
+ it
.first_visible_x
);
3119 if (glyph_row
->pixel_width
+ added_width
>= it
.last_visible_x
)
3122 /* Give up if there is a \t following in the line. */
3124 it2
.end_charpos
= ZV
;
3125 it2
.stop_charpos
= min (it2
.stop_charpos
, ZV
);
3126 while (get_next_display_element (&it2
)
3127 && !ITERATOR_AT_END_OF_LINE_P (&it2
))
3131 set_iterator_to_next (&it2
);
3134 /* Number of new glyphs produced. */
3135 n
= it
.glyph_row
->used
[TEXT_AREA
];
3137 /* Start and end of glyphs in original row. */
3138 glyphs
= glyph_row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
3139 end
= glyph_row
->glyphs
[1 + TEXT_AREA
];
3141 /* Make room for new glyphs, then insert them. */
3142 xassert (end
- glyphs
- n
>= 0);
3143 safe_bcopy (glyphs
, glyphs
+ n
, (end
- glyphs
- n
) * sizeof (*end
));
3144 bcopy (it
.glyph_row
->glyphs
[TEXT_AREA
], glyphs
, n
* sizeof *glyphs
);
3145 glyph_row
->used
[TEXT_AREA
] = min (glyph_row
->used
[TEXT_AREA
] + n
,
3146 end
- glyph_row
->glyphs
[TEXT_AREA
]);
3148 /* Compute new line width. */
3149 glyph
= glyph_row
->glyphs
[TEXT_AREA
];
3150 end
= glyph
+ glyph_row
->used
[TEXT_AREA
];
3151 glyph_row
->pixel_width
= glyph_row
->x
;
3154 glyph_row
->pixel_width
+= glyph
->pixel_width
;
3158 /* Increment buffer positions for glyphs following the newly
3160 for (glyph
= glyphs
+ n
; glyph
< end
; ++glyph
)
3161 if (glyph
->charpos
> 0)
3162 glyph
->charpos
+= delta
;
3164 if (MATRIX_ROW_END_CHARPOS (glyph_row
) > 0)
3166 MATRIX_ROW_END_CHARPOS (glyph_row
) += delta
;
3167 MATRIX_ROW_END_BYTEPOS (glyph_row
) += delta_bytes
;
3170 /* Adjust positions in lines following the one we are in. */
3171 increment_glyph_matrix_buffer_positions (w
->current_matrix
,
3173 w
->current_matrix
->nrows
,
3174 delta
, delta_bytes
);
3176 glyph_row
->contains_overlapping_glyphs_p
3177 |= it
.glyph_row
->contains_overlapping_glyphs_p
;
3179 if (!NILP (Vshow_trailing_whitespace
))
3180 highlight_trailing_whitespace (it
.f
, glyph_row
);
3182 /* Write glyphs. If at end of row, we can simply call write_glyphs.
3183 In the middle, we have to insert glyphs. Note that this is now
3184 implemented for X frames. The implementation uses updated_window
3186 updated_row
= glyph_row
;
3190 rif
->update_window_begin_hook (w
);
3192 if (glyphs
== end
- n
)
3193 rif
->write_glyphs (glyphs
, n
);
3195 rif
->insert_glyphs (glyphs
, n
);
3199 if (glyphs
== end
- n
)
3200 write_glyphs (glyphs
, n
);
3202 insert_glyphs (glyphs
, n
);
3205 w
->cursor
.hpos
+= n
;
3206 w
->cursor
.x
= it
.current_x
- it
.first_visible_x
;
3207 xassert (w
->cursor
.hpos
>= 0
3208 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3210 /* How to set the cursor differs depending on whether we are
3211 using a frame matrix or a window matrix. Note that when
3212 a frame matrix is used, cursor_to expects frame coordinates,
3213 and the X and Y parameters are not used. */
3214 if (window_redisplay_p
)
3215 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3216 w
->cursor
.y
, w
->cursor
.x
);
3220 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3221 + (INTEGERP (w
->left_margin_width
)
3222 ? XFASTINT (w
->left_margin_width
)
3224 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3229 rif
->update_window_end_hook (w
, 1);
3234 TRACE ((stderr
, "direct output for insert\n"));
3236 unchanged_modified
= MODIFF
;
3237 beg_unchanged
= GPT
- BEG
;
3238 XSETFASTINT (w
->last_point
, PT
);
3239 w
->last_cursor
= w
->cursor
;
3240 XSETFASTINT (w
->last_modified
, MODIFF
);
3241 XSETFASTINT (w
->last_overlay_modified
, OVERLAY_MODIFF
);
3243 redisplay_performed_directly_p
= 1;
3248 /* Perform a direct display update for moving PT by N positions
3249 left or right. N < 0 means a movement backwards. This function
3250 is currently only called for N == 1 or N == -1. */
3253 direct_output_forward_char (n
)
3256 struct frame
*f
= selected_frame
;
3257 struct window
*w
= XWINDOW (selected_window
);
3258 struct glyph_row
*row
;
3260 /* Give up if face attributes have been changed. */
3261 if (face_change_count
)
3264 /* Give up if current matrix is not up to date or we are
3265 displaying a message. */
3266 if (!display_completed
|| cursor_in_echo_area
)
3269 /* Give up if the buffer's direction is reversed. */
3270 if (!NILP (XBUFFER (w
->buffer
)->direction_reversed
))
3273 /* Can't use direct output if highlighting a region. */
3274 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
3277 /* Can't use direct output if highlighting trailing whitespace. */
3278 if (!NILP (Vshow_trailing_whitespace
))
3281 row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3283 if (PT
<= MATRIX_ROW_START_BYTEPOS (row
)
3284 || PT
>= MATRIX_ROW_END_BYTEPOS (row
))
3287 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
3288 w
->last_cursor
= w
->cursor
;
3289 XSETFASTINT (w
->last_point
, PT
);
3291 xassert (w
->cursor
.hpos
>= 0
3292 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3294 if (FRAME_WINDOW_P (f
))
3295 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3296 w
->cursor
.y
, w
->cursor
.x
);
3300 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3301 + (INTEGERP (w
->left_margin_width
)
3302 ? XFASTINT (w
->left_margin_width
)
3304 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3309 redisplay_performed_directly_p
= 1;
3315 /***********************************************************************
3317 ***********************************************************************/
3319 /* Update frame F based on the data in desired matrices.
3321 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3322 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3325 Value is non-zero if redisplay was stopped due to pending input. */
3328 update_frame (f
, force_p
, inhibit_hairy_id_p
)
3331 int inhibit_hairy_id_p
;
3333 /* 1 means display has been paused because of pending input. */
3335 struct window
*root_window
= XWINDOW (f
->root_window
);
3337 if (FRAME_WINDOW_P (f
))
3339 /* We are working on window matrix basis. All windows whose
3340 flag must_be_updated_p is set have to be updated. */
3342 /* Record that we are not working on frame matrices. */
3343 set_frame_matrix_frame (NULL
);
3345 /* Update all windows in the window tree of F, maybe stopping
3346 when pending input is detected. */
3349 /* Update the menu bar on X frames that don't have toolkit
3351 if (WINDOWP (f
->menu_bar_window
))
3352 update_window (XWINDOW (f
->menu_bar_window
), 1);
3354 /* Update the tool-bar window, if present. */
3355 if (WINDOWP (f
->toolbar_window
))
3358 struct window
*w
= XWINDOW (f
->toolbar_window
);
3360 /* Update tool-bar window. */
3361 if (w
->must_be_updated_p
)
3363 update_window (w
, 1);
3364 w
->must_be_updated_p
= 0;
3366 /* Swap tool-bar strings. We swap because we want to
3368 tem
= f
->current_toolbar_string
;
3369 f
->current_toolbar_string
= f
->desired_toolbar_string
;
3370 f
->desired_toolbar_string
= tem
;
3371 f
->n_current_toolbar_items
= f
->n_desired_toolbar_items
;
3373 /* Swap tool-bar items. We swap because we want to
3375 tem
= f
->current_toolbar_items
;
3376 f
->current_toolbar_items
= f
->desired_toolbar_items
;
3377 f
->desired_toolbar_items
= tem
;
3382 /* Update windows. */
3383 paused_p
= update_window_tree (root_window
, force_p
);
3385 display_completed
= !paused_p
;
3387 /* The flush is a performance bottleneck under X. */
3389 rif
->flush_display (f
);
3394 /* We are working on frame matrix basis. Set the frame on whose
3395 frame matrix we operate. */
3396 set_frame_matrix_frame (f
);
3398 /* Build F's desired matrix from window matrices. For windows
3399 whose must_be_updated_p flag is set, desired matrices are
3400 made part of the desired frame matrix. For other windows,
3401 the current matrix is copied. */
3402 build_frame_matrix (f
);
3404 /* Do the update on the frame desired matrix. */
3405 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3407 /* Check window matrices for lost pointers. */
3408 IF_DEBUG (check_window_matrix_pointers (root_window
));
3411 /* Reset flags indicating that a window should be updated. */
3412 set_window_update_flags (root_window
, 0);
3418 /************************************************************************
3419 Window-based updates
3420 ************************************************************************/
3422 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3423 don't stop updating when input is pending. */
3426 update_window_tree (w
, force_p
)
3432 while (w
&& !paused_p
)
3434 if (!NILP (w
->hchild
))
3435 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
3436 else if (!NILP (w
->vchild
))
3437 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
3438 else if (w
->must_be_updated_p
)
3439 paused_p
|= update_window (w
, force_p
);
3441 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3448 /* Update window W if its flag must_be_updated_p is non-zero. If
3449 FORCE_P is non-zero, don't stop updating if input is pending. */
3452 update_single_window (w
, force_p
)
3456 if (w
->must_be_updated_p
)
3458 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3460 /* Record that this is not a frame-based redisplay. */
3461 set_frame_matrix_frame (NULL
);
3465 update_window (w
, force_p
);
3468 /* Reset flag in W. */
3469 w
->must_be_updated_p
= 0;
3474 /* Redraw lines from the current matrix of window W that are
3475 overlapped by other rows. YB is bottom-most y-position in W. */
3478 redraw_overlapped_rows (w
, yb
)
3483 struct glyph_row
*row
;
3485 /* If rows overlapping others have been changed, the rows being
3486 overlapped have to be redrawn. This won't draw lines that have
3487 already been drawn in update_window_line because overlapped_p in
3488 desired rows is 0, so after row assignment overlapped_p in
3489 current rows is 0. */
3490 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3492 row
= w
->current_matrix
->rows
+ i
;
3494 if (!row
->enabled_p
)
3496 else if (row
->mode_line_p
)
3499 if (row
->overlapped_p
)
3501 enum glyph_row_area area
;
3503 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3506 updated_area
= area
;
3507 rif
->cursor_to (i
, 0, row
->y
, area
== TEXT_AREA
? row
->x
: 0);
3508 if (row
->used
[area
])
3509 rif
->write_glyphs (row
->glyphs
[area
], row
->used
[area
]);
3510 rif
->clear_end_of_line (-1);
3513 row
->overlapped_p
= 0;
3516 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3523 /* Redraw lines from the current matrix of window W that overlap
3524 others. YB is bottom-most y-position in W. */
3527 redraw_overlapping_rows (w
, yb
)
3532 struct glyph_row
*row
;
3534 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3536 row
= w
->current_matrix
->rows
+ i
;
3538 if (!row
->enabled_p
)
3540 else if (row
->mode_line_p
)
3543 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3545 if (row
->overlapping_p
&& i
> 0 && bottom_y
< yb
)
3547 if (row
->used
[LEFT_MARGIN_AREA
])
3548 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
);
3550 if (row
->used
[TEXT_AREA
])
3551 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
);
3553 if (row
->used
[RIGHT_MARGIN_AREA
])
3554 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
);
3556 /* Record in neighbor rows that ROW overwrites part of their
3558 if (row
->phys_ascent
> row
->ascent
&& i
> 0)
3559 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3560 if ((row
->phys_height
- row
->phys_ascent
3561 > row
->height
- row
->ascent
)
3563 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
3572 /* Update display of window W. FORCE_P non-zero means that we should
3573 not stop when detecting pending input. */
3576 update_window (w
, force_p
)
3580 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
3582 int preempt_count
= baud_rate
/ 2400 + 1;
3583 extern int input_pending
;
3585 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3586 extern struct frame
*updating_frame
;
3589 /* Check that W's frame doesn't have glyph matrices. */
3590 xassert (FRAME_WINDOW_P (f
));
3591 xassert (updating_frame
!= NULL
);
3593 /* Check pending input the first time so that we can quickly return. */
3594 if (redisplay_dont_pause
)
3597 detect_input_pending ();
3599 /* If forced to complete the update, or if no input is pending, do
3601 if (force_p
|| !input_pending
)
3603 struct glyph_row
*row
, *end
;
3604 struct glyph_row
*mode_line_row
;
3605 struct glyph_row
*top_line_row
= NULL
;
3606 int yb
, changed_p
= 0;
3608 rif
->update_window_begin_hook (w
);
3609 yb
= window_text_bottom_y (w
);
3611 /* If window has a top line, update it before everything else.
3612 Adjust y-positions of other rows by the top line height. */
3613 row
= desired_matrix
->rows
;
3614 end
= row
+ desired_matrix
->nrows
- 1;
3615 if (row
->mode_line_p
)
3616 top_line_row
= row
++;
3618 /* Update the mode line, if necessary. */
3619 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3620 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
3622 mode_line_row
->y
= yb
;
3623 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
3628 /* Find first enabled row. Optimizations in redisplay_internal
3629 may lead to an update with only one row enabled. There may
3630 be also completely empty matrices. */
3631 while (row
< end
&& !row
->enabled_p
)
3634 /* Try reusing part of the display by inserting/deleting lines. */
3635 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
3637 int rc
= scrolling_window (w
, top_line_row
!= NULL
);
3640 /* All rows were found to be equal. */
3649 /* Update the top mode line after scrolling because a new top
3650 line would otherwise overwrite lines at the top of the window
3651 that can be scrolled. */
3652 if (top_line_row
&& top_line_row
->enabled_p
)
3654 top_line_row
->y
= 0;
3655 update_window_line (w
, 0);
3659 /* Update the rest of the lines. */
3660 for (; row
< end
&& (force_p
|| !input_pending
); ++row
)
3662 /* A row can be completely invisible in case a desired
3663 matrix was built with a vscroll and then
3664 make_cursor_line_fully_visible shifts the matrix. */
3665 && row
->visible_height
> 0)
3667 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
3670 /* We'll Have to play a little bit with when to
3671 detect_input_pending. If it's done too often,
3672 scrolling large windows with repeated scroll-up
3673 commands will too quickly pause redisplay. */
3674 if (!force_p
&& vpos
% preempt_count
== 0)
3675 detect_input_pending ();
3677 changed_p
|= update_window_line (w
, vpos
);
3679 /* Mark all rows below the last visible one in the current
3680 matrix as invalid. This is necessary because of
3681 variable line heights. Consider the case of three
3682 successive redisplays, where the first displays 5
3683 lines, the second 3 lines, and the third 5 lines again.
3684 If the second redisplay wouldn't mark rows in the
3685 current matrix invalid, the third redisplay might be
3686 tempted to optimize redisplay based on lines displayed
3687 in the first redisplay. */
3688 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3689 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
3690 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
3693 /* Was display preempted? */
3694 paused_p
= row
< end
;
3698 /* Fix the appearance of overlapping(overlapped rows. */
3699 if (rif
->fix_overlapping_area
3700 && !w
->pseudo_window_p
3704 redraw_overlapped_rows (w
, yb
);
3705 redraw_overlapping_rows (w
, yb
);
3708 if (!paused_p
&& !w
->pseudo_window_p
)
3710 /* Make cursor visible at cursor position of W. */
3711 set_window_cursor_after_update (w
);
3714 /* Check that current matrix invariants are satisfied. This
3715 is for debugging only. See the comment around
3716 check_matrix_invariants. */
3717 IF_DEBUG (check_matrix_invariants (w
));
3722 /* Remember the redisplay method used to display the matrix. */
3723 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
3726 /* End of update of window W. */
3727 rif
->update_window_end_hook (w
, 1);
3733 clear_glyph_matrix (desired_matrix
);
3739 /* Update the display of area AREA in window W, row number VPOS.
3740 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3743 update_marginal_area (w
, area
, vpos
)
3747 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3749 /* Let functions in xterm.c know what area subsequent X positions
3750 will be relative to. */
3751 updated_area
= area
;
3753 /* Set cursor to start of glyphs, write them, and clear to the end
3754 of the area. I don't think that something more sophisticated is
3755 necessary here, since marginal areas will not be the default. */
3756 rif
->cursor_to (vpos
, 0, desired_row
->y
, 0);
3757 if (desired_row
->used
[area
])
3758 rif
->write_glyphs (desired_row
->glyphs
[area
], desired_row
->used
[area
]);
3759 rif
->clear_end_of_line (-1);
3763 /* Update the display of the text area of row VPOS in window W.
3764 Value is non-zero if display has changed. */
3767 update_text_area (w
, vpos
)
3771 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3772 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3775 /* Let functions in xterm.c know what area subsequent X positions
3776 will be relative to. */
3777 updated_area
= TEXT_AREA
;
3779 /* If rows are at different X or Y, or rows have different height,
3780 or the current row is marked invalid, write the entire line. */
3781 if (!current_row
->enabled_p
3782 || desired_row
->y
!= current_row
->y
3783 || desired_row
->ascent
!= current_row
->ascent
3784 || desired_row
->phys_ascent
!= current_row
->phys_ascent
3785 || desired_row
->phys_height
!= current_row
->phys_height
3786 || desired_row
->visible_height
!= current_row
->visible_height
3787 || current_row
->overlapped_p
3788 || current_row
->x
!= desired_row
->x
)
3790 rif
->cursor_to (vpos
, 0, desired_row
->y
, desired_row
->x
);
3792 if (desired_row
->used
[TEXT_AREA
])
3793 rif
->write_glyphs (desired_row
->glyphs
[TEXT_AREA
],
3794 desired_row
->used
[TEXT_AREA
]);
3796 /* Clear to end of window. */
3797 rif
->clear_end_of_line (-1);
3803 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
3804 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
3806 /* If the desired row extends its face to the text area end,
3807 make sure we write at least one glyph, so that the face
3808 extension actually takes place. */
3809 int desired_stop_pos
= (desired_row
->used
[TEXT_AREA
]
3810 - (MATRIX_ROW_EXTENDS_FACE_P (desired_row
)
3813 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
3819 /* Skip over glyphs that both rows have in common. These
3820 don't have to be written. */
3822 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3824 x
+= desired_glyph
->pixel_width
;
3825 ++desired_glyph
, ++current_glyph
, ++i
;
3828 /* Consider the case that the current row contains "xxx ppp
3829 ggg" in italic Courier font, and the desired row is "xxx
3830 ggg". The character `p' has lbearing, `g' has not. The
3831 loop above will stop in front of the first `p' in the
3832 current row. If we would start writing glyphs there, we
3833 wouldn't erase the lbearing of the `p'. The rest of the
3834 lbearing problem is then taken care of by x_draw_glyphs. */
3835 if (current_row
->contains_overlapping_glyphs_p
3837 && i
< current_row
->used
[TEXT_AREA
]
3838 && current_row
->used
[TEXT_AREA
] != desired_row
->used
[TEXT_AREA
])
3841 rif
->get_glyph_overhangs (current_glyph
, XFRAME (w
->frame
),
3843 while (left
> 0 && i
> 0)
3845 --i
, --desired_glyph
, --current_glyph
;
3846 x
-= desired_glyph
->pixel_width
;
3847 left
-= desired_glyph
->pixel_width
;
3851 /* Try to avoid writing the entire rest of the desired row
3852 by looking for a resync point. This mainly prevents
3853 mode line flickering in the case the mode line is in
3854 fixed-pitch font, which it usually will be. */
3855 if (i
< desired_row
->used
[TEXT_AREA
])
3857 int start_x
= x
, start_hpos
= i
;
3858 struct glyph
*start
= desired_glyph
;
3861 /* Find the next glyph that's equal again. */
3863 && !GLYPH_EQUAL_P (desired_glyph
, current_glyph
)
3866 x
+= desired_glyph
->pixel_width
;
3867 current_x
+= current_glyph
->pixel_width
;
3868 ++desired_glyph
, ++current_glyph
, ++i
;
3871 if (i
== start_hpos
|| x
!= current_x
)
3875 desired_glyph
= start
;
3879 rif
->cursor_to (vpos
, start_hpos
, desired_row
->y
, start_x
);
3880 rif
->write_glyphs (start
, i
- start_hpos
);
3885 /* Write the rest. */
3886 if (i
< desired_row
->used
[TEXT_AREA
])
3888 rif
->cursor_to (vpos
, i
, desired_row
->y
, x
);
3889 rif
->write_glyphs (desired_glyph
, desired_row
->used
[TEXT_AREA
] - i
);
3893 /* Maybe clear to end of line. */
3894 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
3896 /* If new row extends to the end of the text area, nothing
3897 has to be cleared, if and only if we did a write_glyphs
3898 above. This is made sure by setting desired_stop_pos
3899 appropriately above. */
3900 xassert (i
< desired_row
->used
[TEXT_AREA
]);
3902 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
3904 /* If old row extends to the end of the text area, clear. */
3905 if (i
>= desired_row
->used
[TEXT_AREA
])
3906 rif
->cursor_to (vpos
, i
, desired_row
->y
,
3907 desired_row
->x
+ desired_row
->pixel_width
);
3908 rif
->clear_end_of_line (-1);
3911 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
3913 /* Otherwise clear to the end of the old row. Everything
3914 after that position should be clear already. */
3917 if (i
>= desired_row
->used
[TEXT_AREA
])
3918 rif
->cursor_to (vpos
, i
, desired_row
->y
,
3919 desired_row
->x
+ desired_row
->pixel_width
);
3921 /* If cursor is displayed at the end of the line, make sure
3922 it's cleared. Nowadays we don't have a phys_cursor_glyph
3923 with which to erase the cursor (because this method
3924 doesn't work with lbearing/rbearing), so we must do it
3926 if (vpos
== w
->phys_cursor
.vpos
3927 && w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])
3929 w
->phys_cursor_on_p
= 0;
3933 x
= current_row
->x
+ current_row
->pixel_width
;
3934 rif
->clear_end_of_line (x
);
3943 /* Update row VPOS in window W. Value is non-zero if display has been
3947 update_window_line (w
, vpos
)
3951 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3952 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3955 xassert (desired_row
->enabled_p
);
3957 /* Set the row being updated. This is important to let xterm.c
3958 know what line height values are in effect. */
3959 updated_row
= desired_row
;
3961 /* Update display of the left margin area, if there is one. */
3962 if (!desired_row
->full_width_p
3963 && !NILP (w
->left_margin_width
))
3965 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
3969 /* Update the display of the text area. */
3970 changed_p
|= update_text_area (w
, vpos
);
3972 /* Update display of the right margin area, if there is one. */
3973 if (!desired_row
->full_width_p
3974 && !NILP (w
->right_margin_width
))
3977 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
3980 /* Draw truncation marks etc. */
3981 if (!current_row
->enabled_p
3982 || desired_row
->y
!= current_row
->y
3983 || desired_row
->visible_height
!= current_row
->visible_height
3984 || desired_row
->overlay_arrow_p
!= current_row
->overlay_arrow_p
3985 || desired_row
->truncated_on_left_p
!= current_row
->truncated_on_left_p
3986 || desired_row
->truncated_on_right_p
!= current_row
->truncated_on_right_p
3987 || desired_row
->continued_p
!= current_row
->continued_p
3988 || desired_row
->mode_line_p
!= current_row
->mode_line_p
3989 || (desired_row
->indicate_empty_line_p
3990 != current_row
->indicate_empty_line_p
)
3991 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
3992 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
3993 rif
->after_update_window_line_hook (desired_row
);
3995 /* Update current_row from desired_row. */
3996 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4002 /* Set the cursor after an update of window W. This function may only
4003 be called from update_window. */
4006 set_window_cursor_after_update (w
)
4009 struct frame
*f
= XFRAME (w
->frame
);
4010 int cx
, cy
, vpos
, hpos
;
4012 /* Not intended for frame matrix updates. */
4013 xassert (FRAME_WINDOW_P (f
));
4015 if (cursor_in_echo_area
4016 && !NILP (echo_area_buffer
[0])
4017 /* If we are showing a message instead of the mini-buffer,
4018 show the cursor for the message instead. */
4019 && XWINDOW (minibuf_window
) == w
4020 && EQ (minibuf_window
, echo_area_window
)
4021 /* These cases apply only to the frame that contains
4022 the active mini-buffer window. */
4023 && FRAME_HAS_MINIBUF_P (f
)
4024 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4026 cx
= cy
= vpos
= hpos
= 0;
4028 if (cursor_in_echo_area
>= 0)
4030 /* If the mini-buffer is several lines high, find the last
4031 line that has any text on it. Note: either all lines
4032 are enabled or none. Otherwise we wouldn't be able to
4034 struct glyph_row
*row
, *last_row
;
4035 struct glyph
*glyph
;
4036 int yb
= window_text_bottom_y (w
);
4039 for (row
= MATRIX_ROW (w
->current_matrix
, 0);
4043 if (row
->used
[TEXT_AREA
]
4044 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4047 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4053 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
4054 struct glyph
*last
= start
+ row
->used
[TEXT_AREA
] - 1;
4056 while (last
> start
&& last
->charpos
< 0)
4059 for (glyph
= start
; glyph
< last
; ++glyph
)
4061 cx
+= glyph
->pixel_width
;
4066 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4074 hpos
= w
->cursor
.hpos
;
4075 vpos
= w
->cursor
.vpos
;
4078 /* Window cursor can be out of sync for horizontally split windows. */
4079 hpos
= max (0, hpos
);
4080 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4081 vpos
= max (0, vpos
);
4082 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4083 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4087 /* Try to reuse part of the current display of W by scrolling lines.
4088 TOP_LINE_P non-zero means W has a top mode line.
4090 The algorithm is taken from Communications of the ACM, Apr78 "A
4091 Technique for Isolating Differences Between Files." It should take
4094 A short outline of the steps of the algorithm
4096 1. Skip lines equal at the start and end of both matrices.
4098 2. Enter rows in the current and desired matrix into a symbol
4099 table, counting how often they appear in both matrices.
4101 3. Rows that appear exactly once in both matrices serve as anchors,
4102 i.e. we assume that such lines are likely to have been moved.
4104 4. Starting from anchor lines, extend regions to be scrolled both
4105 forward and backward.
4109 -1 if all rows were found to be equal.
4110 0 to indicate that we did not scroll the display, or
4111 1 if we did scroll. */
4114 scrolling_window (w
, top_line_p
)
4120 /* Number of occurrences of this line in old and new matrix. */
4121 short old_uses
, new_uses
;
4123 /* Vpos of line in new matrix. */
4124 short new_line_number
;
4126 /* The line itself. */
4127 struct glyph_row
*row
;
4129 /* Hash collision chain. */
4130 struct symbol
*next
;
4133 int SYMBOL_TABLE_SIZE
= 101;
4134 struct symbol
**table
;
4135 struct symbol
**old_line_syms
, **new_line_syms
;
4136 int i
, j
, first_old
, first_new
, last_old
, last_new
;
4140 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4141 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4142 int yb
= window_text_bottom_y (w
);
4144 /* Skip over rows equal at the start. */
4145 i
= top_line_p
? 1 : 0;
4146 while (i
< current_matrix
->nrows
- 1
4147 && MATRIX_ROW_ENABLED_P (current_matrix
, i
)
4148 && MATRIX_ROW_ENABLED_P (desired_matrix
, i
)
4149 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) < yb
4150 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) < yb
4152 MATRIX_ROW (desired_matrix
, i
),
4153 MATRIX_ROW (current_matrix
, i
)))
4155 assign_row (MATRIX_ROW (current_matrix
, i
),
4156 MATRIX_ROW (desired_matrix
, i
));
4157 MATRIX_ROW (desired_matrix
, i
)->enabled_p
= 0;
4161 /* Give up if some rows in the desired matrix are not enabled. */
4162 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4165 first_old
= first_new
= i
;
4167 /* Set last_new to the index + 1 of the last enabled row in the
4170 while (i
< desired_matrix
->nrows
- 1
4171 && MATRIX_ROW (desired_matrix
, i
)->enabled_p
4172 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) < yb
)
4175 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4180 /* Set last_old to the index + 1 of the last enabled row in the
4181 current matrix. We don't look at the enabled flag here because
4182 we plan to reuse part of the display even if other parts are
4185 while (i
< current_matrix
->nrows
- 1
4186 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) < yb
)
4190 /* Skip over rows equal at the bottom. */
4193 while (i
- 1 > first_new
4194 && j
- 1 > first_old
4195 && MATRIX_ROW (current_matrix
, i
- 1)->enabled_p
4196 && (MATRIX_ROW (current_matrix
, i
- 1)->y
4197 == MATRIX_ROW (desired_matrix
, j
- 1)->y
)
4199 MATRIX_ROW (desired_matrix
, i
- 1),
4200 MATRIX_ROW (current_matrix
, j
- 1)))
4205 /* Nothing to do if all rows are equal. */
4206 if (last_new
== first_new
)
4209 /* Allocate a hash table in which all rows will be inserted. */
4210 table
= (struct symbol
**) alloca (SYMBOL_TABLE_SIZE
* sizeof *table
);
4211 bzero (table
, SYMBOL_TABLE_SIZE
* sizeof *table
);
4213 /* For each row in the current matrix, record the symbol belonging
4214 to the row in OLD_LINE_SYMS. */
4215 old_line_syms
= (struct symbol
**) alloca (current_matrix
->nrows
4216 * sizeof *old_line_syms
);
4217 new_line_syms
= (struct symbol
**) alloca (desired_matrix
->nrows
4218 * sizeof *new_line_syms
);
4220 #define ADDSYM(ROW) \
4223 struct glyph_row *row_ = (ROW); \
4224 int i_ = row_->hash % SYMBOL_TABLE_SIZE; \
4226 while (sym && !row_equal_p (w, sym->row, row_)) \
4230 sym = (struct symbol *) alloca (sizeof *sym); \
4232 sym->old_uses = sym->new_uses = 0; \
4233 sym->next = table[i_]; \
4239 /* Add current rows to the symbol table. */
4240 for (i
= first_old
; i
< last_old
; ++i
)
4242 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4244 ADDSYM (MATRIX_ROW (current_matrix
, i
));
4245 old_line_syms
[i
] = sym
;
4249 old_line_syms
[i
] = NULL
;
4252 /* Add desired rows to the symbol table. */
4253 for (i
= first_new
; i
< last_new
; ++i
)
4255 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4256 ADDSYM (MATRIX_ROW (desired_matrix
, i
));
4258 new_line_syms
[i
] = sym
;
4259 sym
->new_line_number
= i
;
4264 /* Record in runs which moves were found, ordered by pixel
4265 height of copied areas. */
4267 runs
= (struct run
**) alloca (desired_matrix
->nrows
* sizeof *runs
);
4269 /* Identify moves based on lines that are unique and equal
4270 in both matrices. */
4271 for (i
= first_old
; i
< last_old
;)
4272 if (old_line_syms
[i
]
4273 && old_line_syms
[i
]->old_uses
== 1
4274 && old_line_syms
[i
]->new_uses
== 1)
4277 int new_line
= old_line_syms
[i
]->new_line_number
;
4278 struct run
*run
= (struct run
*) alloca (sizeof *run
);
4281 run
->current_vpos
= i
;
4282 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4283 run
->desired_vpos
= new_line
;
4284 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4286 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4288 /* Extend backward. */
4291 while (j
> first_old
4293 && old_line_syms
[j
] == new_line_syms
[k
])
4295 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4296 --run
->current_vpos
;
4297 --run
->desired_vpos
;
4300 run
->desired_y
-= h
;
4301 run
->current_y
-= h
;
4305 /* Extend forward. */
4310 && old_line_syms
[j
] == new_line_syms
[k
])
4312 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4318 /* Insert run into list of all runs. Order runs by copied
4319 pixel lines. Note that we record runs that don't have to
4320 be copied because they are already in place. This is done
4321 because we can avoid calling update_window_line in this
4323 for (j
= 0; j
< nruns
&& runs
[j
]->height
> run
->height
; ++j
)
4325 for (k
= nruns
; k
>= j
; --k
)
4326 runs
[k
] = runs
[k
- 1];
4335 /* Do the moves. Do it in a way that we don't overwrite something
4336 we want to copy later on. This is not solvable in general
4337 because there is only one display and we don't have a way to
4338 exchange areas on this display. Example:
4340 +-----------+ +-----------+
4342 +-----------+ --> +-----------+
4344 +-----------+ +-----------+
4346 Instead, prefer bigger moves, and invalidate moves that would
4347 copy from where we copied to. */
4349 for (i
= 0; i
< nruns
; ++i
)
4350 if (runs
[i
]->nrows
> 0)
4352 struct run
*r
= runs
[i
];
4354 /* Copy on the display. */
4355 if (r
->current_y
!= r
->desired_y
)
4357 rif
->scroll_run_hook (w
, r
);
4359 /* Invalidate runs that copy from where we copied to. */
4360 for (j
= i
+ 1; j
< nruns
; ++j
)
4362 struct run
*p
= runs
[j
];
4364 if ((p
->current_y
>= r
->desired_y
4365 && p
->current_y
< r
->desired_y
+ r
->height
)
4366 || (p
->current_y
+ p
->height
>= r
->desired_y
4367 && (p
->current_y
+ p
->height
4368 < r
->desired_y
+ r
->height
)))
4373 /* Assign matrix rows. */
4374 for (j
= 0; j
< r
->nrows
; ++j
)
4376 struct glyph_row
*from
, *to
;
4377 int to_overlapped_p
;
4379 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
4380 to_overlapped_p
= to
->overlapped_p
;
4381 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
4382 assign_row (to
, from
);
4383 to
->enabled_p
= 1, from
->enabled_p
= 0;
4384 to
->overlapped_p
= to_overlapped_p
;
4388 /* Value is non-zero to indicate that we scrolled the display. */
4393 /* Set WINDOW->must_be_updated_p TO ON_P for all windows WINDOW in the
4394 window tree rooted at W. */
4397 set_window_update_flags (w
, on_p
)
4403 if (!NILP (w
->hchild
))
4404 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4405 else if (!NILP (w
->vchild
))
4406 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4408 w
->must_be_updated_p
= on_p
;
4410 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4416 /************************************************************************
4418 ************************************************************************/
4420 /* Update the desired frame matrix of frame F.
4422 FORCE_P non-zero means that the update should not be stopped by
4423 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
4424 should not be tried.
4426 Value is non-zero if update was stopped due to pending input. */
4429 update_frame_1 (f
, force_p
, inhibit_id_p
)
4434 /* Frame matrices to work on. */
4435 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4436 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4439 int preempt_count
= baud_rate
/ 2400 + 1;
4440 extern int input_pending
;
4442 xassert (current_matrix
&& desired_matrix
);
4444 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
4445 calculate_costs (f
);
4447 if (preempt_count
<= 0)
4450 detect_input_pending ();
4451 if (input_pending
&& !force_p
)
4459 /* If we cannot insert/delete lines, it's no use trying it. */
4460 if (!line_ins_del_ok
)
4463 /* See if any of the desired lines are enabled; don't compute for
4464 i/d line if just want cursor motion. */
4465 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
4466 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4469 /* Try doing i/d line, if not yet inhibited. */
4470 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
4471 force_p
|= scrolling (f
);
4473 /* Update the individual lines as needed. Do bottom line first. */
4474 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
4475 update_frame_line (f
, desired_matrix
->nrows
- 1);
4477 /* Now update the rest of the lines. */
4478 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
4480 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4482 if (FRAME_TERMCAP_P (f
))
4484 /* Flush out every so many lines.
4485 Also flush out if likely to have more than 1k buffered
4486 otherwise. I'm told that some telnet connections get
4487 really screwed by more than 1k output at once. */
4488 int outq
= PENDING_OUTPUT_COUNT (stdout
);
4490 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
4493 if (preempt_count
== 1)
4495 #ifdef EMACS_OUTQSIZE
4496 if (EMACS_OUTQSIZE (0, &outq
) < 0)
4497 /* Probably not a tty. Ignore the error and reset
4498 * the outq count. */
4499 outq
= PENDING_OUTPUT_COUNT (stdout
);
4502 if (baud_rate
<= outq
&& baud_rate
> 0)
4503 sleep (outq
/ baud_rate
);
4508 if ((i
- 1) % preempt_count
== 0)
4509 detect_input_pending ();
4511 update_frame_line (f
, i
);
4515 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
4517 /* Now just clean up termcap drivers and set cursor, etc. */
4520 if ((cursor_in_echo_area
4521 /* If we are showing a message instead of the mini-buffer,
4522 show the cursor for the message instead of for the
4523 (now hidden) mini-buffer contents. */
4524 || (EQ (minibuf_window
, selected_window
)
4525 && EQ (minibuf_window
, echo_area_window
)
4526 && !NILP (echo_area_buffer
[0])))
4527 /* These cases apply only to the frame that contains
4528 the active mini-buffer window. */
4529 && FRAME_HAS_MINIBUF_P (f
)
4530 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4532 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
4535 if (cursor_in_echo_area
< 0)
4537 /* Negative value of cursor_in_echo_area means put
4538 cursor at beginning of line. */
4544 /* Positive value of cursor_in_echo_area means put
4545 cursor at the end of the prompt. If the mini-buffer
4546 is several lines high, find the last line that has
4548 row
= FRAME_HEIGHT (f
);
4554 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
4556 /* Frame rows are filled up with spaces that
4557 must be ignored here. */
4558 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
4560 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
4561 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
4564 && (last
- 1)->charpos
< 0)
4570 while (row
> top
&& col
== 0);
4572 /* Make sure COL is not out of range. */
4573 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
4575 /* If we have another row, advance cursor into it. */
4576 if (row
< FRAME_HEIGHT (f
) - 1)
4578 col
= FRAME_LEFT_SCROLL_BAR_WIDTH (f
);
4581 /* Otherwise move it back in range. */
4583 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
4587 cursor_to (row
, col
);
4591 /* We have only one cursor on terminal frames. Use it to
4592 display the cursor of the selected window. */
4593 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
4594 if (w
->cursor
.vpos
>= 0)
4596 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
4597 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
4599 if (INTEGERP (w
->left_margin_width
))
4600 x
+= XFASTINT (w
->left_margin_width
);
4602 /* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
4611 fflush (termscript
);
4616 display_completed
= !pause
;
4617 clear_desired_matrices (f
);
4622 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4626 struct frame
*frame
;
4628 int unchanged_at_top
, unchanged_at_bottom
;
4631 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4632 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4633 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4634 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4636 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
4637 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4638 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4640 if (!current_matrix
)
4643 /* Compute hash codes of all the lines. Also calculate number of
4644 changed lines, number of unchanged lines at the beginning, and
4645 number of unchanged lines at the end. */
4647 unchanged_at_top
= 0;
4648 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
4649 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
4651 /* Give up on this scrolling if some old lines are not enabled. */
4652 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
4654 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
4655 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4657 /* This line cannot be redrawn, so don't let scrolling mess it. */
4658 new_hash
[i
] = old_hash
[i
];
4659 #define INFINITY 1000000 /* Taken from scroll.c */
4660 draw_cost
[i
] = INFINITY
;
4664 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
4665 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
4668 if (old_hash
[i
] != new_hash
[i
])
4671 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
4673 else if (i
== unchanged_at_top
)
4675 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
4678 /* If changed lines are few, don't allow preemption, don't scroll. */
4679 if ((!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400)
4680 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
4683 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
4684 - unchanged_at_bottom
);
4686 if (scroll_region_ok
)
4687 free_at_end_vpos
-= unchanged_at_bottom
;
4688 else if (memory_below_frame
)
4689 free_at_end_vpos
= -1;
4691 /* If large window, fast terminal and few lines in common between
4692 current frame and desired frame, don't bother with i/d calc. */
4693 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
4695 10 * scrolling_max_lines_saved (unchanged_at_top
,
4696 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
4697 old_hash
, new_hash
, draw_cost
)))
4700 if (window_size
< 2)
4703 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
4704 draw_cost
+ unchanged_at_top
- 1,
4705 old_draw_cost
+ unchanged_at_top
- 1,
4706 old_hash
+ unchanged_at_top
- 1,
4707 new_hash
+ unchanged_at_top
- 1,
4708 free_at_end_vpos
- unchanged_at_top
);
4714 /* Count the number of blanks at the start of the vector of glyphs R
4715 which is LEN glyphs long. */
4718 count_blanks (r
, len
)
4724 for (i
= 0; i
< len
; ++i
)
4725 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
4732 /* Count the number of glyphs in common at the start of the glyph
4733 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
4734 of STR2. Value is the number of equal glyphs equal at the start. */
4737 count_match (str1
, end1
, str2
, end2
)
4738 struct glyph
*str1
, *end1
, *str2
, *end2
;
4740 struct glyph
*p1
= str1
;
4741 struct glyph
*p2
= str2
;
4745 && GLYPH_FROM_CHAR_GLYPH (*p1
) == GLYPH_FROM_CHAR_GLYPH (*p2
))
4752 /* Char insertion/deletion cost vector, from term.c */
4754 extern int *char_ins_del_vector
;
4755 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
4758 /* Perform a frame-based update on line VPOS in frame FRAME. */
4761 update_frame_line (frame
, vpos
)
4762 register struct frame
*frame
;
4765 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
4767 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
4768 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4769 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4770 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
4771 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
4772 int must_write_whole_line_p
;
4774 if (desired_row
->inverse_p
4775 != (current_row
->enabled_p
&& current_row
->inverse_p
))
4777 int n
= current_row
->enabled_p
? current_row
->used
[TEXT_AREA
] : 0;
4778 change_line_highlight (desired_row
->inverse_p
, vpos
, vpos
, n
);
4779 current_row
->enabled_p
= 0;
4782 reassert_line_highlight (desired_row
->inverse_p
, vpos
);
4784 must_write_whole_line_p
= !current_row
->enabled_p
;
4785 if (must_write_whole_line_p
)
4787 /* A line that is not enabled is empty. */
4793 /* A line not empty in the current matrix. */
4794 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
4795 olen
= current_row
->used
[TEXT_AREA
];
4797 if (! current_row
->inverse_p
)
4799 /* Ignore trailing spaces. */
4800 if (!must_write_spaces
)
4801 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
4806 /* For an inverse-video line, remember we gave it spaces all
4807 the way to the frame edge so that the reverse video
4808 extends all the way across. */
4809 while (olen
< FRAME_WIDTH (frame
) - 1)
4810 obody
[olen
++] = space_glyph
;
4814 current_row
->enabled_p
= 1;
4815 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
4816 current_row
->inverse_p
= desired_row
->inverse_p
;
4818 /* If desired line is empty, just clear the line. */
4819 if (!desired_row
->enabled_p
)
4825 nbody
= desired_row
->glyphs
[TEXT_AREA
];
4826 nlen
= desired_row
->used
[TEXT_AREA
];
4827 nend
= nbody
+ nlen
;
4829 /* If display line has unknown contents, write the whole line. */
4830 if (must_write_whole_line_p
)
4832 if (!must_write_spaces
)
4833 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4836 cursor_to (vpos
, 0);
4838 write_glyphs (nbody
, nlen
);
4840 clear_end_of_line (FRAME_WINDOW_WIDTH (frame
));
4841 make_current (desired_matrix
, current_matrix
, vpos
);
4845 /* Pretend trailing spaces are not there at all,
4846 unless for one reason or another we must write all spaces. */
4847 if (!desired_row
->inverse_p
)
4849 if (!must_write_spaces
)
4850 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4855 /* For an inverse-video line, give it extra trailing spaces all
4856 the way to the frame edge so that the reverse video extends
4857 all the way across. */
4858 while (nlen
< FRAME_WIDTH (frame
) - 1)
4859 nbody
[nlen
++] = space_glyph
;
4862 /* If there's no i/d char, quickly do the best we can without it. */
4863 if (!char_ins_del_ok
)
4867 /* Find the first glyph in desired row that doesn't agree with
4868 a glyph in the current row, and write the rest from there on. */
4869 for (i
= 0; i
< nlen
; i
++)
4871 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
4873 /* Find the end of the run of different glyphs. */
4877 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
4878 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
4881 /* Output this run of non-matching chars. */
4882 cursor_to (vpos
, i
);
4883 write_glyphs (nbody
+ i
, j
- i
);
4886 /* Now find the next non-match. */
4890 /* Clear the rest of the line, or the non-clear part of it. */
4893 cursor_to (vpos
, nlen
);
4894 clear_end_of_line (olen
);
4897 /* Make current row = desired row. */
4898 make_current (desired_matrix
, current_matrix
, vpos
);
4902 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
4903 characters in a row. */
4907 /* If current line is blank, skip over initial spaces, if
4908 possible, and write the rest. */
4909 if (must_write_spaces
|| desired_row
->inverse_p
)
4912 nsp
= count_blanks (nbody
, nlen
);
4916 cursor_to (vpos
, nsp
);
4917 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
4920 /* Exchange contents between current_frame and new_frame. */
4921 make_current (desired_matrix
, current_matrix
, vpos
);
4925 /* Compute number of leading blanks in old and new contents. */
4926 osp
= count_blanks (obody
, olen
);
4927 nsp
= desired_row
->inverse_p
? 0 : count_blanks (nbody
, nlen
);
4929 /* Compute number of matching chars starting with first non-blank. */
4930 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
4931 nbody
+ nsp
, nbody
+ nlen
);
4933 /* Spaces in new match implicit space past the end of old. */
4934 /* A bug causing this to be a no-op was fixed in 18.29. */
4935 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
4938 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
4942 /* Avoid doing insert/delete char
4943 just cause number of leading spaces differs
4944 when the following text does not match. */
4945 if (begmatch
== 0 && osp
!= nsp
)
4946 osp
= nsp
= min (osp
, nsp
);
4948 /* Find matching characters at end of line */
4951 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
4953 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
4958 endmatch
= obody
+ olen
- op1
;
4960 /* tem gets the distance to insert or delete.
4961 endmatch is how many characters we save by doing so.
4964 tem
= (nlen
- nsp
) - (olen
- osp
);
4966 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
4969 /* nsp - osp is the distance to insert or delete.
4970 If that is nonzero, begmatch is known to be nonzero also.
4971 begmatch + endmatch is how much we save by doing the ins/del.
4975 && (!char_ins_del_ok
4976 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
4980 osp
= nsp
= min (osp
, nsp
);
4983 /* Now go through the line, inserting, writing and
4984 deleting as appropriate. */
4988 cursor_to (vpos
, nsp
);
4989 delete_glyphs (osp
- nsp
);
4993 /* If going to delete chars later in line
4994 and insert earlier in the line,
4995 must delete first to avoid losing data in the insert */
4996 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
4998 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
4999 delete_glyphs (olen
+ nsp
- osp
- nlen
);
5000 olen
= nlen
- (nsp
- osp
);
5002 cursor_to (vpos
, osp
);
5003 insert_glyphs (0, nsp
- osp
);
5007 tem
= nsp
+ begmatch
+ endmatch
;
5008 if (nlen
!= tem
|| olen
!= tem
)
5010 cursor_to (vpos
, nsp
+ begmatch
);
5011 if (!endmatch
|| nlen
== olen
)
5013 /* If new text being written reaches right margin,
5014 there is no need to do clear-to-eol at the end.
5015 (and it would not be safe, since cursor is not
5016 going to be "at the margin" after the text is done) */
5017 if (nlen
== FRAME_WINDOW_WIDTH (frame
))
5019 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5021 else if (nlen
> olen
)
5023 /* Here, we used to have the following simple code:
5024 ----------------------------------------
5025 write_glyphs (nbody + nsp + begmatch, olen - tem);
5026 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5027 ----------------------------------------
5028 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5029 is a padding glyph. */
5030 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5033 /* Calculate columns we can actually overwrite. */
5034 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
])) out
--;
5035 write_glyphs (nbody
+ nsp
+ begmatch
, out
);
5036 /* If we left columns to be overwritten, we must delete them. */
5037 del
= olen
- tem
- out
;
5038 if (del
> 0) delete_glyphs (del
);
5039 /* At last, we insert columns not yet written out. */
5040 insert_glyphs (nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5043 else if (olen
> nlen
)
5045 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5046 delete_glyphs (olen
- nlen
);
5052 /* If any unerased characters remain after the new line, erase them. */
5055 cursor_to (vpos
, nlen
);
5056 clear_end_of_line (olen
);
5059 /* Exchange contents between current_frame and new_frame. */
5060 make_current (desired_matrix
, current_matrix
, vpos
);
5065 /***********************************************************************
5066 X/Y Position -> Buffer Position
5067 ***********************************************************************/
5069 /* Return the character position of the character at window relative
5070 pixel position (*X, *Y). *X and *Y are adjusted to character
5074 buffer_posn_from_coords (w
, x
, y
)
5079 struct buffer
*old_current_buffer
= current_buffer
;
5080 struct text_pos startp
;
5081 int left_area_width
;
5083 current_buffer
= XBUFFER (w
->buffer
);
5084 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5085 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5086 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5087 start_display (&it
, w
, startp
);
5089 left_area_width
= WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH (w
);
5090 move_it_to (&it
, -1, *x
+ it
.first_visible_x
- left_area_width
, *y
, -1,
5091 MOVE_TO_X
| MOVE_TO_Y
);
5093 *x
= it
.current_x
- it
.first_visible_x
+ left_area_width
;
5095 current_buffer
= old_current_buffer
;
5096 return IT_CHARPOS (it
);
5100 /* Value is the string under window-relative coordinates X/Y in the
5101 mode or top line of window W, or nil if none. MODE_LINE_P non-zero
5102 means look at the mode line. *CHARPOS is set to the position in
5103 the string returned. */
5106 mode_line_string (w
, x
, y
, mode_line_p
, charpos
)
5111 struct glyph_row
*row
;
5112 struct glyph
*glyph
, *end
;
5113 struct frame
*f
= XFRAME (w
->frame
);
5115 Lisp_Object string
= Qnil
;
5117 /* Only do this for frames under a window system. */
5118 if (!FRAME_WINDOW_P (f
))
5122 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5124 row
= MATRIX_TOP_LINE_ROW (w
->current_matrix
);
5126 if (row
->mode_line_p
&& row
->enabled_p
)
5128 /* The mode lines are displayed over scroll bars and bitmap
5129 areas, and X is window-relative. Correct X by the scroll bar
5130 and bitmap area width. */
5131 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
5132 x
+= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
5133 x
+= FRAME_FLAGS_AREA_WIDTH (f
);
5135 /* Find the glyph under X. If we find one with a string object,
5136 it's the one we were looking for. */
5137 glyph
= row
->glyphs
[TEXT_AREA
];
5138 end
= glyph
+ row
->used
[TEXT_AREA
];
5139 for (x0
= 0; glyph
< end
; x0
+= glyph
->pixel_width
, ++glyph
)
5140 if (x
>= x0
&& x
< x0
+ glyph
->pixel_width
)
5142 string
= glyph
->object
;
5143 *charpos
= glyph
->charpos
;
5152 /***********************************************************************
5153 Changing Frame Sizes
5154 ***********************************************************************/
5159 window_change_signal (signalnum
) /* If we don't have an argument, */
5160 int signalnum
; /* some compilers complain in signal calls. */
5164 int old_errno
= errno
;
5166 get_frame_size (&width
, &height
);
5168 /* The frame size change obviously applies to a termcap-controlled
5169 frame. Find such a frame in the list, and assume it's the only
5170 one (since the redisplay code always writes to stdout, not a
5171 FILE * specified in the frame structure). Record the new size,
5172 but don't reallocate the data structures now. Let that be done
5173 later outside of the signal handler. */
5176 Lisp_Object tail
, frame
;
5178 FOR_EACH_FRAME (tail
, frame
)
5180 if (FRAME_TERMCAP_P (XFRAME (frame
)))
5182 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5188 signal (SIGWINCH
, window_change_signal
);
5191 #endif /* SIGWINCH */
5194 /* Do any change in frame size that was requested by a signal. SAFE
5195 non-zero means this function is called from a place where it is
5196 safe to change frame sizes while a redisplay is in progress. */
5199 do_pending_window_change (safe
)
5202 /* If window_change_signal should have run before, run it now. */
5203 if (redisplaying_p
&& !safe
)
5206 while (delayed_size_change
)
5208 Lisp_Object tail
, frame
;
5210 delayed_size_change
= 0;
5212 FOR_EACH_FRAME (tail
, frame
)
5214 struct frame
*f
= XFRAME (frame
);
5216 int height
= FRAME_NEW_HEIGHT (f
);
5217 int width
= FRAME_NEW_WIDTH (f
);
5219 if (height
!= 0 || width
!= 0)
5220 change_frame_size (f
, height
, width
, 0, 0, safe
);
5226 /* Change the frame height and/or width. Values may be given as zero to
5227 indicate no change is to take place.
5229 If DELAY is non-zero, then assume we're being called from a signal
5230 handler, and queue the change for later - perhaps the next
5231 redisplay. Since this tries to resize windows, we can't call it
5232 from a signal handler.
5234 SAFE non-zero means this function is called from a place where it's
5235 safe to change frame sizes while a redisplay is in progress. */
5238 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5239 register struct frame
*f
;
5240 int newheight
, newwidth
, pretend
, delay
, safe
;
5242 Lisp_Object tail
, frame
;
5244 if (! FRAME_WINDOW_P (f
))
5246 /* When using termcap, or on MS-DOS, all frames use
5247 the same screen, so a change in size affects all frames. */
5248 FOR_EACH_FRAME (tail
, frame
)
5249 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5250 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5251 pretend
, delay
, safe
);
5254 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
5258 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5259 register struct frame
*f
;
5260 int newheight
, newwidth
, pretend
, delay
, safe
;
5262 int new_frame_window_width
;
5263 int count
= specpdl_ptr
- specpdl
;
5265 /* If we can't deal with the change now, queue it for later. */
5266 if (delay
|| (redisplaying_p
&& !safe
))
5268 FRAME_NEW_HEIGHT (f
) = newheight
;
5269 FRAME_NEW_WIDTH (f
) = newwidth
;
5270 delayed_size_change
= 1;
5274 /* This size-change overrides any pending one for this frame. */
5275 FRAME_NEW_HEIGHT (f
) = 0;
5276 FRAME_NEW_WIDTH (f
) = 0;
5278 /* If an argument is zero, set it to the current value. */
5280 newheight
= FRAME_HEIGHT (f
);
5282 newwidth
= FRAME_WIDTH (f
);
5284 /* Compute width of windows in F.
5285 This is the width of the frame without vertical scroll bars. */
5286 new_frame_window_width
= FRAME_WINDOW_WIDTH_ARG (f
, newwidth
);
5288 /* Round up to the smallest acceptable size. */
5289 check_frame_size (f
, &newheight
, &newwidth
);
5291 /* If we're not changing the frame size, quit now. */
5292 if (newheight
== FRAME_HEIGHT (f
)
5293 && new_frame_window_width
== FRAME_WINDOW_WIDTH (f
))
5299 /* We only can set screen dimensions to certain values supported
5300 by our video hardware. Try to find the smallest size greater
5301 or equal to the requested dimensions. */
5302 dos_set_window_size (&newheight
, &newwidth
);
5305 if (newheight
!= FRAME_HEIGHT (f
))
5307 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
5309 /* Frame has both root and mini-buffer. */
5310 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f
))->top
,
5311 FRAME_TOP_MARGIN (f
));
5312 set_window_height (FRAME_ROOT_WINDOW (f
),
5315 - FRAME_TOP_MARGIN (f
)),
5317 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
,
5319 set_window_height (FRAME_MINIBUF_WINDOW (f
), 1, 0);
5322 /* Frame has just one top-level window. */
5323 set_window_height (FRAME_ROOT_WINDOW (f
),
5324 newheight
- FRAME_TOP_MARGIN (f
), 0);
5326 if (FRAME_TERMCAP_P (f
) && !pretend
)
5327 FrameRows
= newheight
;
5330 if (new_frame_window_width
!= FRAME_WINDOW_WIDTH (f
))
5332 set_window_width (FRAME_ROOT_WINDOW (f
), new_frame_window_width
, 0);
5333 if (FRAME_HAS_MINIBUF_P (f
))
5334 set_window_width (FRAME_MINIBUF_WINDOW (f
), new_frame_window_width
, 0);
5336 if (FRAME_TERMCAP_P (f
) && !pretend
)
5337 FrameCols
= newwidth
;
5339 if (WINDOWP (f
->toolbar_window
))
5340 XSETFASTINT (XWINDOW (f
->toolbar_window
)->width
, newwidth
);
5343 FRAME_HEIGHT (f
) = newheight
;
5344 SET_FRAME_WIDTH (f
, newwidth
);
5347 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5348 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
5350 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
5352 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
5353 w
->cursor
.hpos
= w
->cursor
.x
= 0;
5354 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
5355 w
->cursor
.vpos
= w
->cursor
.y
= 0;
5359 SET_FRAME_GARBAGED (f
);
5360 calculate_costs (f
);
5364 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
5366 /* This isn't quite a no-op: it runs window-configuration-change-hook. */
5367 Fset_window_buffer (FRAME_SELECTED_WINDOW (f
),
5368 XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
);
5370 unbind_to (count
, Qnil
);
5375 /***********************************************************************
5376 Terminal Related Lisp Functions
5377 ***********************************************************************/
5379 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
5380 1, 1, "FOpen termscript file: ",
5381 "Start writing all terminal output to FILE as well as the terminal.\n\
5382 FILE = nil means just close any termscript file currently open.")
5386 if (termscript
!= 0) fclose (termscript
);
5391 file
= Fexpand_file_name (file
, Qnil
);
5392 termscript
= fopen (XSTRING (file
)->data
, "w");
5393 if (termscript
== 0)
5394 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
5400 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
5401 Ssend_string_to_terminal
, 1, 1, 0,
5402 "Send STRING to the terminal without alteration.\n\
5403 Control characters in STRING will have terminal-dependent effects.")
5407 /* ??? Perhaps we should do something special for multibyte strings here. */
5408 CHECK_STRING (string
, 0);
5409 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)), stdout
);
5413 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)),
5415 fflush (termscript
);
5421 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
5422 "Beep, or flash the screen.\n\
5423 Also, unless an argument is given,\n\
5424 terminate any keyboard macro currently executing.")
5447 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
5448 error ("Keyboard macro terminated by a command ringing the bell");
5456 /***********************************************************************
5458 ***********************************************************************/
5460 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
5461 "Pause, without updating display, for SECONDS seconds.\n\
5462 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5463 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5464 additional wait period, in milliseconds; this may be useful if your\n\
5465 Emacs was built without floating point support.\n\
5466 \(Not all operating systems support waiting for a fraction of a second.)")
5467 (seconds
, milliseconds
)
5468 Lisp_Object seconds
, milliseconds
;
5472 if (NILP (milliseconds
))
5473 XSETINT (milliseconds
, 0);
5475 CHECK_NUMBER (milliseconds
, 1);
5476 usec
= XINT (milliseconds
) * 1000;
5478 #ifdef LISP_FLOAT_TYPE
5480 double duration
= extract_float (seconds
);
5481 sec
= (int) duration
;
5482 usec
+= (duration
- sec
) * 1000000;
5485 CHECK_NUMBER (seconds
, 0);
5486 sec
= XINT (seconds
);
5489 #ifndef EMACS_HAS_USECS
5490 if (sec
== 0 && usec
!= 0)
5491 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
5494 /* Assure that 0 <= usec < 1000000. */
5497 /* We can't rely on the rounding being correct if user is negative. */
5498 if (-1000000 < usec
)
5499 sec
--, usec
+= 1000000;
5501 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
5504 sec
+= usec
/ 1000000, usec
%= 1000000;
5506 if (sec
< 0 || (sec
== 0 && usec
== 0))
5512 XSETFASTINT (zero
, 0);
5513 wait_reading_process_input (sec
, usec
, zero
, 0);
5516 /* We should always have wait_reading_process_input; we have a dummy
5517 implementation for systems which don't support subprocesses. */
5519 /* No wait_reading_process_input */
5526 /* The reason this is done this way
5527 (rather than defined (H_S) && defined (H_T))
5528 is because the VMS preprocessor doesn't grok `defined' */
5530 EMACS_GET_TIME (end_time
);
5531 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
5532 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
5536 EMACS_GET_TIME (timeout
);
5537 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
5538 if (EMACS_TIME_NEG_P (timeout
)
5539 || !select (1, 0, 0, 0, &timeout
))
5542 #else /* not HAVE_SELECT */
5544 #endif /* HAVE_SELECT */
5545 #endif /* not VMS */
5548 #endif /* no subprocesses */
5554 /* This is just like wait_reading_process_input, except that
5555 it does the redisplay.
5557 It's also much like Fsit_for, except that it can be used for
5558 waiting for input as well. */
5561 sit_for (sec
, usec
, reading
, display
, initial_display
)
5562 int sec
, usec
, reading
, display
, initial_display
;
5564 Lisp_Object read_kbd
;
5566 swallow_events (display
);
5568 if (detect_input_pending_run_timers (display
))
5571 if (initial_display
)
5572 redisplay_preserve_echo_area ();
5574 if (sec
== 0 && usec
== 0)
5581 XSETINT (read_kbd
, reading
? -1 : 1);
5582 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
5584 return detect_input_pending () ? Qnil
: Qt
;
5588 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
5589 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
5590 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5591 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5592 additional wait period, in milliseconds; this may be useful if your\n\
5593 Emacs was built without floating point support.\n\
5594 \(Not all operating systems support waiting for a fraction of a second.)\n\
5595 Optional third arg NODISP non-nil means don't redisplay, just wait for input.\n\
5596 Redisplay is preempted as always if input arrives, and does not happen\n\
5597 if input is available before it starts.\n\
5598 Value is t if waited the full time with no input arriving.")
5599 (seconds
, milliseconds
, nodisp
)
5600 Lisp_Object seconds
, milliseconds
, nodisp
;
5604 if (NILP (milliseconds
))
5605 XSETINT (milliseconds
, 0);
5607 CHECK_NUMBER (milliseconds
, 1);
5608 usec
= XINT (milliseconds
) * 1000;
5610 #ifdef LISP_FLOAT_TYPE
5612 double duration
= extract_float (seconds
);
5613 sec
= (int) duration
;
5614 usec
+= (duration
- sec
) * 1000000;
5617 CHECK_NUMBER (seconds
, 0);
5618 sec
= XINT (seconds
);
5621 #ifndef EMACS_HAS_USECS
5622 if (usec
!= 0 && sec
== 0)
5623 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
5626 return sit_for (sec
, usec
, 0, NILP (nodisp
), NILP (nodisp
));
5631 /***********************************************************************
5632 Other Lisp Functions
5633 ***********************************************************************/
5635 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
5636 session's frames, frame names, buffers, buffer-read-only flags, and
5637 buffer-modified-flags, and a trailing sentinel (so we don't need to
5638 add length checks). */
5640 static Lisp_Object frame_and_buffer_state
;
5643 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
5644 Sframe_or_buffer_changed_p
, 0, 0, 0,
5645 "Return non-nil if the frame and buffer state appears to have changed.\n\
5646 The state variable is an internal vector containing all frames and buffers,\n\
5647 aside from buffers whose names start with space,\n\
5648 along with the buffers' read-only and modified flags, which allows a fast\n\
5649 check to see whether the menu bars might need to be recomputed.\n\
5650 If this function returns non-nil, it updates the internal vector to reflect\n\
5651 the current state.\n")
5654 Lisp_Object tail
, frame
, buf
;
5658 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5659 FOR_EACH_FRAME (tail
, frame
)
5661 if (!EQ (*vecp
++, frame
))
5663 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
5666 /* Check that the buffer info matches.
5667 No need to test for the end of the vector
5668 because the last element of the vector is lambda
5669 and that will always cause a mismatch. */
5670 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5672 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
5673 /* Ignore buffers that aren't included in buffer lists. */
5674 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5676 if (!EQ (*vecp
++, buf
))
5678 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
5680 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
5683 /* Detect deletion of a buffer at the end of the list. */
5684 if (EQ (*vecp
, Qlambda
))
5687 /* Start with 1 so there is room for at least one lambda at the end. */
5689 FOR_EACH_FRAME (tail
, frame
)
5691 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5693 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
5694 if (n
> XVECTOR (frame_and_buffer_state
)->size
5695 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
5696 /* Add 20 extra so we grow it less often. */
5697 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
5698 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5699 FOR_EACH_FRAME (tail
, frame
)
5702 *vecp
++ = XFRAME (frame
)->name
;
5704 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5706 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
5707 /* Ignore buffers that aren't included in buffer lists. */
5708 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5711 *vecp
++ = XBUFFER (buf
)->read_only
;
5712 *vecp
++ = Fbuffer_modified_p (buf
);
5714 /* Fill up the vector with lambdas (always at least one). */
5716 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5717 < XVECTOR (frame_and_buffer_state
)->size
)
5719 /* Make sure we didn't overflow the vector. */
5720 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5721 > XVECTOR (frame_and_buffer_state
)->size
)
5728 /***********************************************************************
5730 ***********************************************************************/
5732 char *terminal_type
;
5734 /* Initialization done when Emacs fork is started, before doing stty.
5735 Determine terminal type and set terminal_driver. Then invoke its
5736 decoding routine to set up variables in the terminal package. */
5741 #ifdef HAVE_X_WINDOWS
5742 extern int display_arg
;
5745 /* Construct the space glyph. */
5746 space_glyph
.type
= CHAR_GLYPH
;
5747 SET_CHAR_GLYPH_FROM_GLYPH (space_glyph
, ' ');
5748 space_glyph
.charpos
= -1;
5752 cursor_in_echo_area
= 0;
5753 terminal_type
= (char *) 0;
5755 /* Now is the time to initialize this; it's used by init_sys_modes
5757 Vwindow_system
= Qnil
;
5759 /* If the user wants to use a window system, we shouldn't bother
5760 initializing the terminal. This is especially important when the
5761 terminal is so dumb that emacs gives up before and doesn't bother
5762 using the window system.
5764 If the DISPLAY environment variable is set and nonempty,
5765 try to use X, and die with an error message if that doesn't work. */
5767 #ifdef HAVE_X_WINDOWS
5772 display
= getenv ("DECW$DISPLAY");
5774 display
= getenv ("DISPLAY");
5777 display_arg
= (display
!= 0 && *display
!= 0);
5780 if (!inhibit_window_system
&& display_arg
5786 Vwindow_system
= intern ("x");
5788 Vwindow_system_version
= make_number (11);
5790 Vwindow_system_version
= make_number (10);
5792 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
5793 /* In some versions of ncurses,
5794 tputs crashes if we have not called tgetent.
5796 { char b
[2044]; tgetent (b
, "xterm");}
5798 adjust_frame_glyphs_initially ();
5801 #endif /* HAVE_X_WINDOWS */
5804 if (!inhibit_window_system
)
5806 Vwindow_system
= intern ("w32");
5807 Vwindow_system_version
= make_number (1);
5808 adjust_frame_glyphs_initially ();
5811 #endif /* HAVE_NTGUI */
5813 /* If no window system has been specified, try to use the terminal. */
5816 fatal ("standard input is not a tty");
5820 /* Look at the TERM variable */
5821 terminal_type
= (char *) getenv ("TERM");
5825 fprintf (stderr
, "Please specify your terminal type.\n\
5826 For types defined in VMS, use set term /device=TYPE.\n\
5827 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
5828 \(The quotation marks are necessary since terminal types are lower case.)\n");
5830 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
5836 /* VMS DCL tends to up-case things, so down-case term type.
5837 Hardly any uppercase letters in terminal types; should be none. */
5839 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
5842 strcpy (new, terminal_type
);
5844 for (p
= new; *p
; p
++)
5848 terminal_type
= new;
5852 term_init (terminal_type
);
5855 int width
= FRAME_WINDOW_WIDTH (selected_frame
);
5856 int height
= FRAME_HEIGHT (selected_frame
);
5858 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (struct glyph
);
5860 /* If these sizes are so big they cause overflow, just ignore the
5861 change. It's not clear what better we could do. */
5862 if (total_glyphs
/ sizeof (struct glyph
) / height
!= width
+ 2)
5863 fatal ("screen size %dx%d too big", width
, height
);
5866 adjust_frame_glyphs_initially ();
5867 calculate_costs (selected_frame
);
5872 #endif /* CANNOT_DUMP */
5873 signal (SIGWINCH
, window_change_signal
);
5874 #endif /* SIGWINCH */
5876 /* Set up faces of the initial terminal frame of a dumped Emacs. */
5880 /* The MSDOS terminal turns on its ``window system'' relatively
5881 late into the startup, so we cannot do the frame faces'
5882 initialization just yet. It will be done later by pc-win.el
5883 and internal_terminal_init. */
5884 && (strcmp (terminal_type
, "internal") != 0 || inhibit_window_system
)
5886 && NILP (Vwindow_system
))
5887 call0 (intern ("tty-set-up-initial-frame-faces"));
5892 /***********************************************************************
5894 ***********************************************************************/
5896 DEFUN ("show-cursor", Fshow_cursor
, Sshow_cursor
, 0, 2, 0,
5897 "Change visibility flag of the text cursor of WINDOW.\n\
5898 ON_P nil means toggle the flag. Otherwise, ON_P must be an integer,\n\
5899 and the flag is set according to the value of ON_P. WINDOW nil or\n\
5900 omitted means use the selected window. The new cursor state takes effect\n\
5901 with the next redisplay.")
5903 Lisp_Object on_p
, window
;
5907 /* Don't change cursor state while redisplaying. This could confuse
5909 if (!redisplaying_p
)
5912 window
= selected_window
;
5914 CHECK_WINDOW (window
, 2);
5915 w
= XWINDOW (window
);
5918 w
->cursor_off_p
= !w
->cursor_off_p
;
5921 CHECK_NUMBER (on_p
, 1);
5922 w
->cursor_off_p
= XINT (on_p
) != 0;
5931 /***********************************************************************
5933 ***********************************************************************/
5938 defsubr (&Sredraw_frame
);
5939 defsubr (&Sredraw_display
);
5940 defsubr (&Sframe_or_buffer_changed_p
);
5941 defsubr (&Sopen_termscript
);
5943 defsubr (&Ssit_for
);
5944 defsubr (&Ssleep_for
);
5945 defsubr (&Ssend_string_to_terminal
);
5946 defsubr (&Sshow_cursor
);
5948 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
5949 staticpro (&frame_and_buffer_state
);
5951 Qdisplay_table
= intern ("display-table");
5952 staticpro (&Qdisplay_table
);
5954 DEFVAR_INT ("baud-rate", &baud_rate
,
5955 "*The output baud rate of the terminal.\n\
5956 On most systems, changing this value will affect the amount of padding\n\
5957 and the other strategic decisions made during redisplay.");
5959 DEFVAR_BOOL ("inverse-video", &inverse_video
,
5960 "*Non-nil means invert the entire frame display.\n\
5961 This means everything is in inverse video which otherwise would not be.");
5963 DEFVAR_BOOL ("visible-bell", &visible_bell
,
5964 "*Non-nil means try to flash the frame to represent a bell.");
5966 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
5967 "*Non-nil means no need to redraw entire frame after suspending.\n\
5968 A non-nil value is useful if the terminal can automatically preserve\n\
5969 Emacs's frame display when you reenter Emacs.\n\
5970 It is up to you to set this variable if your terminal can do that.");
5972 DEFVAR_LISP ("window-system", &Vwindow_system
,
5973 "A symbol naming the window-system under which Emacs is running\n\
5974 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
5976 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
5977 "The version number of the window system in use.\n\
5978 For X windows, this is 10 or 11.");
5980 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
5981 "Non-nil means put cursor in minibuffer, at end of any message there.");
5983 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
5984 "Table defining how to output a glyph code to the frame.\n\
5985 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
5986 Each element can be:\n\
5987 integer: a glyph code which this glyph is an alias for.\n\
5988 string: output this glyph using that string (not impl. in X windows).\n\
5989 nil: this glyph mod 256 is char code to output,\n\
5990 and this glyph / 256 is face code for X windows (see `face-id').");
5991 Vglyph_table
= Qnil
;
5993 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
5994 "Display table to use for buffers that specify none.\n\
5995 See `buffer-display-table' for more information.");
5996 Vstandard_display_table
= Qnil
;
5998 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause
,
5999 "*Non-nil means update isn't paused when input is detected.");
6000 redisplay_dont_pause
= 0;
6002 /* Initialize `window-system', unless init_display already decided it. */
6007 Vwindow_system
= Qnil
;
6008 Vwindow_system_version
= Qnil
;