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 equals the_only_frame. */
240 Lisp_Object 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 header_line_changed_p
= 0;
512 int header_line_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 header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
520 header_line_changed_p
= header_line_p
!= matrix
->header_line_p
;
522 matrix
->header_line_p
= header_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 && !header_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
->header_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 || header_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
->header_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_HEADER_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 tool-bar window, if any. */
889 if (WINDOWP (f
->tool_bar_window
))
890 clear_glyph_matrix (XWINDOW (f
->tool_bar_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
->tool_bar_window
))
911 clear_glyph_matrix (XWINDOW (f
->tool_bar_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_HEADER_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 frame
*sf
= SELECTED_FRAME ();
1906 struct window
*root
= XWINDOW (sf
->root_window
);
1907 struct window
*mini
= XWINDOW (root
->next
);
1908 int frame_height
= FRAME_HEIGHT (sf
);
1909 int frame_width
= FRAME_WIDTH (sf
);
1910 int top_margin
= FRAME_TOP_MARGIN (sf
);
1912 /* Do it for the root window. */
1913 XSETFASTINT (root
->top
, top_margin
);
1914 XSETFASTINT (root
->width
, frame_width
);
1915 set_window_height (sf
->root_window
, 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 (sf
);
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 tool bar window. If we
2080 don't have a tool bar window yet, make one. */
2081 if (NILP (f
->tool_bar_window
))
2083 f
->tool_bar_window
= make_window ();
2084 w
= XWINDOW (f
->tool_bar_window
);
2085 XSETFRAME (w
->frame
, f
);
2086 w
->pseudo_window_p
= 1;
2089 w
= XWINDOW (f
->tool_bar_window
);
2091 XSETFASTINT (w
->top
, FRAME_MENU_BAR_LINES (f
));
2092 XSETFASTINT (w
->left
, 0);
2093 XSETFASTINT (w
->height
, FRAME_TOOL_BAR_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 tool bar window and its glyph matrices. */
2171 if (!NILP (f
->tool_bar_window
))
2173 struct window
*w
= XWINDOW (f
->tool_bar_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
->tool_bar_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 ((char *) glyphs
, (char *) (glyphs
+ n
),
3144 (end
- glyphs
- n
) * sizeof (*end
));
3145 bcopy (it
.glyph_row
->glyphs
[TEXT_AREA
], glyphs
, n
* sizeof *glyphs
);
3146 glyph_row
->used
[TEXT_AREA
] = min (glyph_row
->used
[TEXT_AREA
] + n
,
3147 end
- glyph_row
->glyphs
[TEXT_AREA
]);
3149 /* Compute new line width. */
3150 glyph
= glyph_row
->glyphs
[TEXT_AREA
];
3151 end
= glyph
+ glyph_row
->used
[TEXT_AREA
];
3152 glyph_row
->pixel_width
= glyph_row
->x
;
3155 glyph_row
->pixel_width
+= glyph
->pixel_width
;
3159 /* Increment buffer positions for glyphs following the newly
3161 for (glyph
= glyphs
+ n
; glyph
< end
; ++glyph
)
3162 if (glyph
->charpos
> 0)
3163 glyph
->charpos
+= delta
;
3165 if (MATRIX_ROW_END_CHARPOS (glyph_row
) > 0)
3167 MATRIX_ROW_END_CHARPOS (glyph_row
) += delta
;
3168 MATRIX_ROW_END_BYTEPOS (glyph_row
) += delta_bytes
;
3171 /* Adjust positions in lines following the one we are in. */
3172 increment_glyph_matrix_buffer_positions (w
->current_matrix
,
3174 w
->current_matrix
->nrows
,
3175 delta
, delta_bytes
);
3177 glyph_row
->contains_overlapping_glyphs_p
3178 |= it
.glyph_row
->contains_overlapping_glyphs_p
;
3180 if (!NILP (Vshow_trailing_whitespace
))
3181 highlight_trailing_whitespace (it
.f
, glyph_row
);
3183 /* Write glyphs. If at end of row, we can simply call write_glyphs.
3184 In the middle, we have to insert glyphs. Note that this is now
3185 implemented for X frames. The implementation uses updated_window
3187 updated_row
= glyph_row
;
3191 rif
->update_window_begin_hook (w
);
3193 if (glyphs
== end
- n
)
3194 rif
->write_glyphs (glyphs
, n
);
3196 rif
->insert_glyphs (glyphs
, n
);
3200 if (glyphs
== end
- n
)
3201 write_glyphs (glyphs
, n
);
3203 insert_glyphs (glyphs
, n
);
3206 w
->cursor
.hpos
+= n
;
3207 w
->cursor
.x
= it
.current_x
- it
.first_visible_x
;
3208 xassert (w
->cursor
.hpos
>= 0
3209 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3211 /* How to set the cursor differs depending on whether we are
3212 using a frame matrix or a window matrix. Note that when
3213 a frame matrix is used, cursor_to expects frame coordinates,
3214 and the X and Y parameters are not used. */
3215 if (window_redisplay_p
)
3216 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3217 w
->cursor
.y
, w
->cursor
.x
);
3221 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3222 + (INTEGERP (w
->left_margin_width
)
3223 ? XFASTINT (w
->left_margin_width
)
3225 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3230 rif
->update_window_end_hook (w
, 1);
3235 TRACE ((stderr
, "direct output for insert\n"));
3237 UNCHANGED_MODIFIED
= MODIFF
;
3238 BEG_UNCHANGED
= GPT
- BEG
;
3239 XSETFASTINT (w
->last_point
, PT
);
3240 w
->last_cursor
= w
->cursor
;
3241 XSETFASTINT (w
->last_modified
, MODIFF
);
3242 XSETFASTINT (w
->last_overlay_modified
, OVERLAY_MODIFF
);
3244 redisplay_performed_directly_p
= 1;
3249 /* Perform a direct display update for moving PT by N positions
3250 left or right. N < 0 means a movement backwards. This function
3251 is currently only called for N == 1 or N == -1. */
3254 direct_output_forward_char (n
)
3257 struct frame
*f
= SELECTED_FRAME ();
3258 struct window
*w
= XWINDOW (selected_window
);
3259 struct glyph_row
*row
;
3261 /* Give up if face attributes have been changed. */
3262 if (face_change_count
)
3265 /* Give up if current matrix is not up to date or we are
3266 displaying a message. */
3267 if (!display_completed
|| cursor_in_echo_area
)
3270 /* Give up if the buffer's direction is reversed. */
3271 if (!NILP (XBUFFER (w
->buffer
)->direction_reversed
))
3274 /* Can't use direct output if highlighting a region. */
3275 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
3278 /* Can't use direct output if highlighting trailing whitespace. */
3279 if (!NILP (Vshow_trailing_whitespace
))
3282 /* Give up if we are showing a message or just cleared the message
3283 because we might need to resize the echo area window. */
3284 if (!NILP (echo_area_buffer
[0]) || !NILP (echo_area_buffer
[1]))
3287 /* Give up if we don't know where the cursor is. */
3288 if (w
->cursor
.vpos
< 0)
3291 row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3293 if (PT
<= MATRIX_ROW_START_BYTEPOS (row
)
3294 || PT
>= MATRIX_ROW_END_BYTEPOS (row
))
3297 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
3298 w
->last_cursor
= w
->cursor
;
3299 XSETFASTINT (w
->last_point
, PT
);
3301 xassert (w
->cursor
.hpos
>= 0
3302 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3304 if (FRAME_WINDOW_P (f
))
3305 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3306 w
->cursor
.y
, w
->cursor
.x
);
3310 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3311 + (INTEGERP (w
->left_margin_width
)
3312 ? XFASTINT (w
->left_margin_width
)
3314 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3319 redisplay_performed_directly_p
= 1;
3325 /***********************************************************************
3327 ***********************************************************************/
3329 /* Update frame F based on the data in desired matrices.
3331 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3332 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3335 Value is non-zero if redisplay was stopped due to pending input. */
3338 update_frame (f
, force_p
, inhibit_hairy_id_p
)
3341 int inhibit_hairy_id_p
;
3343 /* 1 means display has been paused because of pending input. */
3345 struct window
*root_window
= XWINDOW (f
->root_window
);
3347 if (FRAME_WINDOW_P (f
))
3349 /* We are working on window matrix basis. All windows whose
3350 flag must_be_updated_p is set have to be updated. */
3352 /* Record that we are not working on frame matrices. */
3353 set_frame_matrix_frame (NULL
);
3355 /* Update all windows in the window tree of F, maybe stopping
3356 when pending input is detected. */
3359 /* Update the menu bar on X frames that don't have toolkit
3361 if (WINDOWP (f
->menu_bar_window
))
3362 update_window (XWINDOW (f
->menu_bar_window
), 1);
3364 /* Update the tool-bar window, if present. */
3365 if (WINDOWP (f
->tool_bar_window
))
3368 struct window
*w
= XWINDOW (f
->tool_bar_window
);
3370 /* Update tool-bar window. */
3371 if (w
->must_be_updated_p
)
3373 update_window (w
, 1);
3374 w
->must_be_updated_p
= 0;
3376 /* Swap tool-bar strings. We swap because we want to
3378 tem
= f
->current_tool_bar_string
;
3379 f
->current_tool_bar_string
= f
->desired_tool_bar_string
;
3380 f
->desired_tool_bar_string
= tem
;
3381 f
->n_current_tool_bar_items
= f
->n_desired_tool_bar_items
;
3383 /* Swap tool-bar items. We swap because we want to
3385 tem
= f
->current_tool_bar_items
;
3386 f
->current_tool_bar_items
= f
->desired_tool_bar_items
;
3387 f
->desired_tool_bar_items
= tem
;
3392 /* Update windows. */
3393 paused_p
= update_window_tree (root_window
, force_p
);
3395 display_completed
= !paused_p
;
3397 /* The flush is a performance bottleneck under X. */
3399 rif
->flush_display (f
);
3404 /* We are working on frame matrix basis. Set the frame on whose
3405 frame matrix we operate. */
3406 set_frame_matrix_frame (f
);
3408 /* Build F's desired matrix from window matrices. For windows
3409 whose must_be_updated_p flag is set, desired matrices are
3410 made part of the desired frame matrix. For other windows,
3411 the current matrix is copied. */
3412 build_frame_matrix (f
);
3414 /* Do the update on the frame desired matrix. */
3415 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3417 /* Check window matrices for lost pointers. */
3418 IF_DEBUG (check_window_matrix_pointers (root_window
));
3421 /* Reset flags indicating that a window should be updated. */
3422 set_window_update_flags (root_window
, 0);
3428 /************************************************************************
3429 Window-based updates
3430 ************************************************************************/
3432 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3433 don't stop updating when input is pending. */
3436 update_window_tree (w
, force_p
)
3442 while (w
&& !paused_p
)
3444 if (!NILP (w
->hchild
))
3445 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
3446 else if (!NILP (w
->vchild
))
3447 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
3448 else if (w
->must_be_updated_p
)
3449 paused_p
|= update_window (w
, force_p
);
3451 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3458 /* Update window W if its flag must_be_updated_p is non-zero. If
3459 FORCE_P is non-zero, don't stop updating if input is pending. */
3462 update_single_window (w
, force_p
)
3466 if (w
->must_be_updated_p
)
3468 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3470 /* Record that this is not a frame-based redisplay. */
3471 set_frame_matrix_frame (NULL
);
3475 update_window (w
, force_p
);
3478 /* Reset flag in W. */
3479 w
->must_be_updated_p
= 0;
3484 /* Redraw lines from the current matrix of window W that are
3485 overlapped by other rows. YB is bottom-most y-position in W. */
3488 redraw_overlapped_rows (w
, yb
)
3493 struct glyph_row
*row
;
3495 /* If rows overlapping others have been changed, the rows being
3496 overlapped have to be redrawn. This won't draw lines that have
3497 already been drawn in update_window_line because overlapped_p in
3498 desired rows is 0, so after row assignment overlapped_p in
3499 current rows is 0. */
3500 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3502 row
= w
->current_matrix
->rows
+ i
;
3504 if (!row
->enabled_p
)
3506 else if (row
->mode_line_p
)
3509 if (row
->overlapped_p
)
3511 enum glyph_row_area area
;
3513 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3516 updated_area
= area
;
3517 rif
->cursor_to (i
, 0, row
->y
, area
== TEXT_AREA
? row
->x
: 0);
3518 if (row
->used
[area
])
3519 rif
->write_glyphs (row
->glyphs
[area
], row
->used
[area
]);
3520 rif
->clear_end_of_line (-1);
3523 row
->overlapped_p
= 0;
3526 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3533 /* Redraw lines from the current matrix of window W that overlap
3534 others. YB is bottom-most y-position in W. */
3537 redraw_overlapping_rows (w
, yb
)
3542 struct glyph_row
*row
;
3544 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3546 row
= w
->current_matrix
->rows
+ i
;
3548 if (!row
->enabled_p
)
3550 else if (row
->mode_line_p
)
3553 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3555 if (row
->overlapping_p
&& i
> 0 && bottom_y
< yb
)
3557 if (row
->used
[LEFT_MARGIN_AREA
])
3558 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
);
3560 if (row
->used
[TEXT_AREA
])
3561 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
);
3563 if (row
->used
[RIGHT_MARGIN_AREA
])
3564 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
);
3566 /* Record in neighbor rows that ROW overwrites part of their
3568 if (row
->phys_ascent
> row
->ascent
&& i
> 0)
3569 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3570 if ((row
->phys_height
- row
->phys_ascent
3571 > row
->height
- row
->ascent
)
3573 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
3582 /* Update display of window W. FORCE_P non-zero means that we should
3583 not stop when detecting pending input. */
3586 update_window (w
, force_p
)
3590 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
3592 int preempt_count
= baud_rate
/ 2400 + 1;
3593 extern int input_pending
;
3595 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3596 extern struct frame
*updating_frame
;
3599 /* Check that W's frame doesn't have glyph matrices. */
3600 xassert (FRAME_WINDOW_P (f
));
3601 xassert (updating_frame
!= NULL
);
3603 /* Check pending input the first time so that we can quickly return. */
3604 if (redisplay_dont_pause
)
3607 detect_input_pending ();
3609 /* If forced to complete the update, or if no input is pending, do
3611 if (force_p
|| !input_pending
)
3613 struct glyph_row
*row
, *end
;
3614 struct glyph_row
*mode_line_row
;
3615 struct glyph_row
*header_line_row
= NULL
;
3616 int yb
, changed_p
= 0;
3618 rif
->update_window_begin_hook (w
);
3619 yb
= window_text_bottom_y (w
);
3621 /* If window has a top line, update it before everything else.
3622 Adjust y-positions of other rows by the top line height. */
3623 row
= desired_matrix
->rows
;
3624 end
= row
+ desired_matrix
->nrows
- 1;
3625 if (row
->mode_line_p
)
3626 header_line_row
= row
++;
3628 /* Update the mode line, if necessary. */
3629 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3630 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
3632 mode_line_row
->y
= yb
;
3633 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
3638 /* Find first enabled row. Optimizations in redisplay_internal
3639 may lead to an update with only one row enabled. There may
3640 be also completely empty matrices. */
3641 while (row
< end
&& !row
->enabled_p
)
3644 /* Try reusing part of the display by inserting/deleting lines. */
3645 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
3647 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
3650 /* All rows were found to be equal. */
3659 /* Update the top mode line after scrolling because a new top
3660 line would otherwise overwrite lines at the top of the window
3661 that can be scrolled. */
3662 if (header_line_row
&& header_line_row
->enabled_p
)
3664 header_line_row
->y
= 0;
3665 update_window_line (w
, 0);
3669 /* Update the rest of the lines. */
3670 for (; row
< end
&& (force_p
|| !input_pending
); ++row
)
3672 /* A row can be completely invisible in case a desired
3673 matrix was built with a vscroll and then
3674 make_cursor_line_fully_visible shifts the matrix. */
3675 && row
->visible_height
> 0)
3677 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
3680 /* We'll Have to play a little bit with when to
3681 detect_input_pending. If it's done too often,
3682 scrolling large windows with repeated scroll-up
3683 commands will too quickly pause redisplay. */
3684 if (!force_p
&& vpos
% preempt_count
== 0)
3685 detect_input_pending ();
3687 changed_p
|= update_window_line (w
, vpos
);
3689 /* Mark all rows below the last visible one in the current
3690 matrix as invalid. This is necessary because of
3691 variable line heights. Consider the case of three
3692 successive redisplays, where the first displays 5
3693 lines, the second 3 lines, and the third 5 lines again.
3694 If the second redisplay wouldn't mark rows in the
3695 current matrix invalid, the third redisplay might be
3696 tempted to optimize redisplay based on lines displayed
3697 in the first redisplay. */
3698 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3699 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
3700 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
3703 /* Was display preempted? */
3704 paused_p
= row
< end
;
3708 /* Fix the appearance of overlapping(overlapped rows. */
3709 if (rif
->fix_overlapping_area
3710 && !w
->pseudo_window_p
3714 redraw_overlapped_rows (w
, yb
);
3715 redraw_overlapping_rows (w
, yb
);
3718 if (!paused_p
&& !w
->pseudo_window_p
)
3720 /* Make cursor visible at cursor position of W. */
3721 set_window_cursor_after_update (w
);
3724 /* Check that current matrix invariants are satisfied. This
3725 is for debugging only. See the comment around
3726 check_matrix_invariants. */
3727 IF_DEBUG (check_matrix_invariants (w
));
3732 /* Remember the redisplay method used to display the matrix. */
3733 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
3736 /* End of update of window W. */
3737 rif
->update_window_end_hook (w
, 1);
3743 clear_glyph_matrix (desired_matrix
);
3749 /* Update the display of area AREA in window W, row number VPOS.
3750 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3753 update_marginal_area (w
, area
, vpos
)
3757 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3759 /* Let functions in xterm.c know what area subsequent X positions
3760 will be relative to. */
3761 updated_area
= area
;
3763 /* Set cursor to start of glyphs, write them, and clear to the end
3764 of the area. I don't think that something more sophisticated is
3765 necessary here, since marginal areas will not be the default. */
3766 rif
->cursor_to (vpos
, 0, desired_row
->y
, 0);
3767 if (desired_row
->used
[area
])
3768 rif
->write_glyphs (desired_row
->glyphs
[area
], desired_row
->used
[area
]);
3769 rif
->clear_end_of_line (-1);
3773 /* Update the display of the text area of row VPOS in window W.
3774 Value is non-zero if display has changed. */
3777 update_text_area (w
, vpos
)
3781 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3782 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3785 /* Let functions in xterm.c know what area subsequent X positions
3786 will be relative to. */
3787 updated_area
= TEXT_AREA
;
3789 /* If rows are at different X or Y, or rows have different height,
3790 or the current row is marked invalid, write the entire line. */
3791 if (!current_row
->enabled_p
3792 || desired_row
->y
!= current_row
->y
3793 || desired_row
->ascent
!= current_row
->ascent
3794 || desired_row
->phys_ascent
!= current_row
->phys_ascent
3795 || desired_row
->phys_height
!= current_row
->phys_height
3796 || desired_row
->visible_height
!= current_row
->visible_height
3797 || current_row
->overlapped_p
3798 || current_row
->x
!= desired_row
->x
)
3800 rif
->cursor_to (vpos
, 0, desired_row
->y
, desired_row
->x
);
3802 if (desired_row
->used
[TEXT_AREA
])
3803 rif
->write_glyphs (desired_row
->glyphs
[TEXT_AREA
],
3804 desired_row
->used
[TEXT_AREA
]);
3806 /* Clear to end of window. */
3807 rif
->clear_end_of_line (-1);
3813 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
3814 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
3816 /* If the desired row extends its face to the text area end,
3817 make sure we write at least one glyph, so that the face
3818 extension actually takes place. */
3819 int desired_stop_pos
= (desired_row
->used
[TEXT_AREA
]
3820 - (MATRIX_ROW_EXTENDS_FACE_P (desired_row
)
3823 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
3829 /* Skip over glyphs that both rows have in common. These
3830 don't have to be written. */
3832 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3834 x
+= desired_glyph
->pixel_width
;
3835 ++desired_glyph
, ++current_glyph
, ++i
;
3838 /* Consider the case that the current row contains "xxx ppp
3839 ggg" in italic Courier font, and the desired row is "xxx
3840 ggg". The character `p' has lbearing, `g' has not. The
3841 loop above will stop in front of the first `p' in the
3842 current row. If we would start writing glyphs there, we
3843 wouldn't erase the lbearing of the `p'. The rest of the
3844 lbearing problem is then taken care of by x_draw_glyphs. */
3845 if (current_row
->contains_overlapping_glyphs_p
3847 && i
< current_row
->used
[TEXT_AREA
]
3848 && current_row
->used
[TEXT_AREA
] != desired_row
->used
[TEXT_AREA
])
3851 rif
->get_glyph_overhangs (current_glyph
, XFRAME (w
->frame
),
3853 while (left
> 0 && i
> 0)
3855 --i
, --desired_glyph
, --current_glyph
;
3856 x
-= desired_glyph
->pixel_width
;
3857 left
-= desired_glyph
->pixel_width
;
3861 /* Try to avoid writing the entire rest of the desired row
3862 by looking for a resync point. This mainly prevents
3863 mode line flickering in the case the mode line is in
3864 fixed-pitch font, which it usually will be. */
3865 if (i
< desired_row
->used
[TEXT_AREA
])
3867 int start_x
= x
, start_hpos
= i
;
3868 struct glyph
*start
= desired_glyph
;
3871 /* Find the next glyph that's equal again. */
3873 && !GLYPH_EQUAL_P (desired_glyph
, current_glyph
)
3876 x
+= desired_glyph
->pixel_width
;
3877 current_x
+= current_glyph
->pixel_width
;
3878 ++desired_glyph
, ++current_glyph
, ++i
;
3881 if (i
== start_hpos
|| x
!= current_x
)
3885 desired_glyph
= start
;
3889 rif
->cursor_to (vpos
, start_hpos
, desired_row
->y
, start_x
);
3890 rif
->write_glyphs (start
, i
- start_hpos
);
3895 /* Write the rest. */
3896 if (i
< desired_row
->used
[TEXT_AREA
])
3898 rif
->cursor_to (vpos
, i
, desired_row
->y
, x
);
3899 rif
->write_glyphs (desired_glyph
, desired_row
->used
[TEXT_AREA
] - i
);
3903 /* Maybe clear to end of line. */
3904 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
3906 /* If new row extends to the end of the text area, nothing
3907 has to be cleared, if and only if we did a write_glyphs
3908 above. This is made sure by setting desired_stop_pos
3909 appropriately above. */
3910 xassert (i
< desired_row
->used
[TEXT_AREA
]);
3912 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
3914 /* If old row extends to the end of the text area, clear. */
3915 if (i
>= desired_row
->used
[TEXT_AREA
])
3916 rif
->cursor_to (vpos
, i
, desired_row
->y
,
3917 desired_row
->x
+ desired_row
->pixel_width
);
3918 rif
->clear_end_of_line (-1);
3921 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
3923 /* Otherwise clear to the end of the old row. Everything
3924 after that position should be clear already. */
3927 if (i
>= desired_row
->used
[TEXT_AREA
])
3928 rif
->cursor_to (vpos
, i
, desired_row
->y
,
3929 desired_row
->x
+ desired_row
->pixel_width
);
3931 /* If cursor is displayed at the end of the line, make sure
3932 it's cleared. Nowadays we don't have a phys_cursor_glyph
3933 with which to erase the cursor (because this method
3934 doesn't work with lbearing/rbearing), so we must do it
3936 if (vpos
== w
->phys_cursor
.vpos
3937 && w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])
3939 w
->phys_cursor_on_p
= 0;
3943 x
= current_row
->x
+ current_row
->pixel_width
;
3944 rif
->clear_end_of_line (x
);
3953 /* Update row VPOS in window W. Value is non-zero if display has been
3957 update_window_line (w
, vpos
)
3961 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3962 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3965 xassert (desired_row
->enabled_p
);
3967 /* Set the row being updated. This is important to let xterm.c
3968 know what line height values are in effect. */
3969 updated_row
= desired_row
;
3971 /* Update display of the left margin area, if there is one. */
3972 if (!desired_row
->full_width_p
3973 && !NILP (w
->left_margin_width
))
3975 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
3979 /* Update the display of the text area. */
3980 changed_p
|= update_text_area (w
, vpos
);
3982 /* Update display of the right margin area, if there is one. */
3983 if (!desired_row
->full_width_p
3984 && !NILP (w
->right_margin_width
))
3987 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
3990 /* Draw truncation marks etc. */
3991 if (!current_row
->enabled_p
3992 || desired_row
->y
!= current_row
->y
3993 || desired_row
->visible_height
!= current_row
->visible_height
3994 || desired_row
->overlay_arrow_p
!= current_row
->overlay_arrow_p
3995 || desired_row
->truncated_on_left_p
!= current_row
->truncated_on_left_p
3996 || desired_row
->truncated_on_right_p
!= current_row
->truncated_on_right_p
3997 || desired_row
->continued_p
!= current_row
->continued_p
3998 || desired_row
->mode_line_p
!= current_row
->mode_line_p
3999 || (desired_row
->indicate_empty_line_p
4000 != current_row
->indicate_empty_line_p
)
4001 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
4002 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
4003 rif
->after_update_window_line_hook (desired_row
);
4005 /* Update current_row from desired_row. */
4006 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4012 /* Set the cursor after an update of window W. This function may only
4013 be called from update_window. */
4016 set_window_cursor_after_update (w
)
4019 struct frame
*f
= XFRAME (w
->frame
);
4020 int cx
, cy
, vpos
, hpos
;
4022 /* Not intended for frame matrix updates. */
4023 xassert (FRAME_WINDOW_P (f
));
4025 if (cursor_in_echo_area
4026 && !NILP (echo_area_buffer
[0])
4027 /* If we are showing a message instead of the mini-buffer,
4028 show the cursor for the message instead. */
4029 && XWINDOW (minibuf_window
) == w
4030 && EQ (minibuf_window
, echo_area_window
)
4031 /* These cases apply only to the frame that contains
4032 the active mini-buffer window. */
4033 && FRAME_HAS_MINIBUF_P (f
)
4034 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4036 cx
= cy
= vpos
= hpos
= 0;
4038 if (cursor_in_echo_area
>= 0)
4040 /* If the mini-buffer is several lines high, find the last
4041 line that has any text on it. Note: either all lines
4042 are enabled or none. Otherwise we wouldn't be able to
4044 struct glyph_row
*row
, *last_row
;
4045 struct glyph
*glyph
;
4046 int yb
= window_text_bottom_y (w
);
4049 for (row
= MATRIX_ROW (w
->current_matrix
, 0);
4053 if (row
->used
[TEXT_AREA
]
4054 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4057 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4063 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
4064 struct glyph
*last
= start
+ row
->used
[TEXT_AREA
] - 1;
4066 while (last
> start
&& last
->charpos
< 0)
4069 for (glyph
= start
; glyph
< last
; ++glyph
)
4071 cx
+= glyph
->pixel_width
;
4076 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4084 hpos
= w
->cursor
.hpos
;
4085 vpos
= w
->cursor
.vpos
;
4088 /* Window cursor can be out of sync for horizontally split windows. */
4089 hpos
= max (0, hpos
);
4090 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4091 vpos
= max (0, vpos
);
4092 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4093 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4097 /* Try to reuse part of the current display of W by scrolling lines.
4098 HEADER_LINE_P non-zero means W has a top mode line.
4100 The algorithm is taken from Communications of the ACM, Apr78 "A
4101 Technique for Isolating Differences Between Files." It should take
4104 A short outline of the steps of the algorithm
4106 1. Skip lines equal at the start and end of both matrices.
4108 2. Enter rows in the current and desired matrix into a symbol
4109 table, counting how often they appear in both matrices.
4111 3. Rows that appear exactly once in both matrices serve as anchors,
4112 i.e. we assume that such lines are likely to have been moved.
4114 4. Starting from anchor lines, extend regions to be scrolled both
4115 forward and backward.
4119 -1 if all rows were found to be equal.
4120 0 to indicate that we did not scroll the display, or
4121 1 if we did scroll. */
4124 scrolling_window (w
, header_line_p
)
4130 /* Number of occurrences of this line in old and new matrix. */
4131 short old_uses
, new_uses
;
4133 /* Vpos of line in new matrix. */
4134 short new_line_number
;
4136 /* The line itself. */
4137 struct glyph_row
*row
;
4139 /* Hash collision chain. */
4140 struct symbol
*next
;
4143 int SYMBOL_TABLE_SIZE
= 101;
4144 struct symbol
**table
;
4145 struct symbol
**old_line_syms
, **new_line_syms
;
4146 int i
, j
, first_old
, first_new
, last_old
, last_new
;
4150 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4151 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4152 int yb
= window_text_bottom_y (w
);
4154 /* Skip over rows equal at the start. */
4155 i
= header_line_p
? 1 : 0;
4156 while (i
< current_matrix
->nrows
- 1
4157 && MATRIX_ROW_ENABLED_P (current_matrix
, i
)
4158 && MATRIX_ROW_ENABLED_P (desired_matrix
, i
)
4159 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) < yb
4160 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) < yb
4162 MATRIX_ROW (desired_matrix
, i
),
4163 MATRIX_ROW (current_matrix
, i
)))
4165 assign_row (MATRIX_ROW (current_matrix
, i
),
4166 MATRIX_ROW (desired_matrix
, i
));
4167 MATRIX_ROW (desired_matrix
, i
)->enabled_p
= 0;
4171 /* Give up if some rows in the desired matrix are not enabled. */
4172 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4175 first_old
= first_new
= i
;
4177 /* Set last_new to the index + 1 of the last enabled row in the
4180 while (i
< desired_matrix
->nrows
- 1
4181 && MATRIX_ROW (desired_matrix
, i
)->enabled_p
4182 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) < yb
)
4185 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4190 /* Set last_old to the index + 1 of the last enabled row in the
4191 current matrix. We don't look at the enabled flag here because
4192 we plan to reuse part of the display even if other parts are
4195 while (i
< current_matrix
->nrows
- 1
4196 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) < yb
)
4200 /* Skip over rows equal at the bottom. */
4203 while (i
- 1 > first_new
4204 && j
- 1 > first_old
4205 && MATRIX_ROW (current_matrix
, i
- 1)->enabled_p
4206 && (MATRIX_ROW (current_matrix
, i
- 1)->y
4207 == MATRIX_ROW (desired_matrix
, j
- 1)->y
)
4209 MATRIX_ROW (desired_matrix
, i
- 1),
4210 MATRIX_ROW (current_matrix
, j
- 1)))
4215 /* Nothing to do if all rows are equal. */
4216 if (last_new
== first_new
)
4219 /* Allocate a hash table in which all rows will be inserted. */
4220 table
= (struct symbol
**) alloca (SYMBOL_TABLE_SIZE
* sizeof *table
);
4221 bzero (table
, SYMBOL_TABLE_SIZE
* sizeof *table
);
4223 /* For each row in the current matrix, record the symbol belonging
4224 to the row in OLD_LINE_SYMS. */
4225 old_line_syms
= (struct symbol
**) alloca (current_matrix
->nrows
4226 * sizeof *old_line_syms
);
4227 new_line_syms
= (struct symbol
**) alloca (desired_matrix
->nrows
4228 * sizeof *new_line_syms
);
4230 #define ADDSYM(ROW) \
4233 struct glyph_row *row_ = (ROW); \
4234 int i_ = row_->hash % SYMBOL_TABLE_SIZE; \
4236 while (sym && !row_equal_p (w, sym->row, row_)) \
4240 sym = (struct symbol *) alloca (sizeof *sym); \
4242 sym->old_uses = sym->new_uses = 0; \
4243 sym->next = table[i_]; \
4249 /* Add current rows to the symbol table. */
4250 for (i
= first_old
; i
< last_old
; ++i
)
4252 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4254 ADDSYM (MATRIX_ROW (current_matrix
, i
));
4255 old_line_syms
[i
] = sym
;
4259 old_line_syms
[i
] = NULL
;
4262 /* Add desired rows to the symbol table. */
4263 for (i
= first_new
; i
< last_new
; ++i
)
4265 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4266 ADDSYM (MATRIX_ROW (desired_matrix
, i
));
4268 new_line_syms
[i
] = sym
;
4269 sym
->new_line_number
= i
;
4274 /* Record in runs which moves were found, ordered by pixel
4275 height of copied areas. */
4277 runs
= (struct run
**) alloca (desired_matrix
->nrows
* sizeof *runs
);
4279 /* Identify moves based on lines that are unique and equal
4280 in both matrices. */
4281 for (i
= first_old
; i
< last_old
;)
4282 if (old_line_syms
[i
]
4283 && old_line_syms
[i
]->old_uses
== 1
4284 && old_line_syms
[i
]->new_uses
== 1)
4287 int new_line
= old_line_syms
[i
]->new_line_number
;
4288 struct run
*run
= (struct run
*) alloca (sizeof *run
);
4291 run
->current_vpos
= i
;
4292 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4293 run
->desired_vpos
= new_line
;
4294 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4296 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4298 /* Extend backward. */
4301 while (j
> first_old
4303 && old_line_syms
[j
] == new_line_syms
[k
])
4305 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4306 --run
->current_vpos
;
4307 --run
->desired_vpos
;
4310 run
->desired_y
-= h
;
4311 run
->current_y
-= h
;
4315 /* Extend forward. */
4320 && old_line_syms
[j
] == new_line_syms
[k
])
4322 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4328 /* Insert run into list of all runs. Order runs by copied
4329 pixel lines. Note that we record runs that don't have to
4330 be copied because they are already in place. This is done
4331 because we can avoid calling update_window_line in this
4333 for (j
= 0; j
< nruns
&& runs
[j
]->height
> run
->height
; ++j
)
4335 for (k
= nruns
; k
>= j
; --k
)
4336 runs
[k
] = runs
[k
- 1];
4345 /* Do the moves. Do it in a way that we don't overwrite something
4346 we want to copy later on. This is not solvable in general
4347 because there is only one display and we don't have a way to
4348 exchange areas on this display. Example:
4350 +-----------+ +-----------+
4352 +-----------+ --> +-----------+
4354 +-----------+ +-----------+
4356 Instead, prefer bigger moves, and invalidate moves that would
4357 copy from where we copied to. */
4359 for (i
= 0; i
< nruns
; ++i
)
4360 if (runs
[i
]->nrows
> 0)
4362 struct run
*r
= runs
[i
];
4364 /* Copy on the display. */
4365 if (r
->current_y
!= r
->desired_y
)
4367 rif
->scroll_run_hook (w
, r
);
4369 /* Invalidate runs that copy from where we copied to. */
4370 for (j
= i
+ 1; j
< nruns
; ++j
)
4372 struct run
*p
= runs
[j
];
4374 if ((p
->current_y
>= r
->desired_y
4375 && p
->current_y
< r
->desired_y
+ r
->height
)
4376 || (p
->current_y
+ p
->height
>= r
->desired_y
4377 && (p
->current_y
+ p
->height
4378 < r
->desired_y
+ r
->height
)))
4383 /* Assign matrix rows. */
4384 for (j
= 0; j
< r
->nrows
; ++j
)
4386 struct glyph_row
*from
, *to
;
4387 int to_overlapped_p
;
4389 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
4390 to_overlapped_p
= to
->overlapped_p
;
4391 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
4392 assign_row (to
, from
);
4393 to
->enabled_p
= 1, from
->enabled_p
= 0;
4394 to
->overlapped_p
= to_overlapped_p
;
4398 /* Value is non-zero to indicate that we scrolled the display. */
4403 /* Set WINDOW->must_be_updated_p TO ON_P for all windows WINDOW in the
4404 window tree rooted at W. */
4407 set_window_update_flags (w
, on_p
)
4413 if (!NILP (w
->hchild
))
4414 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4415 else if (!NILP (w
->vchild
))
4416 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4418 w
->must_be_updated_p
= on_p
;
4420 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4426 /************************************************************************
4428 ************************************************************************/
4430 /* Update the desired frame matrix of frame F.
4432 FORCE_P non-zero means that the update should not be stopped by
4433 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
4434 should not be tried.
4436 Value is non-zero if update was stopped due to pending input. */
4439 update_frame_1 (f
, force_p
, inhibit_id_p
)
4444 /* Frame matrices to work on. */
4445 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4446 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4449 int preempt_count
= baud_rate
/ 2400 + 1;
4450 extern int input_pending
;
4452 xassert (current_matrix
&& desired_matrix
);
4454 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
4455 calculate_costs (f
);
4457 if (preempt_count
<= 0)
4460 detect_input_pending ();
4461 if (input_pending
&& !force_p
)
4469 /* If we cannot insert/delete lines, it's no use trying it. */
4470 if (!line_ins_del_ok
)
4473 /* See if any of the desired lines are enabled; don't compute for
4474 i/d line if just want cursor motion. */
4475 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
4476 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4479 /* Try doing i/d line, if not yet inhibited. */
4480 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
4481 force_p
|= scrolling (f
);
4483 /* Update the individual lines as needed. Do bottom line first. */
4484 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
4485 update_frame_line (f
, desired_matrix
->nrows
- 1);
4487 /* Now update the rest of the lines. */
4488 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
4490 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4492 if (FRAME_TERMCAP_P (f
))
4494 /* Flush out every so many lines.
4495 Also flush out if likely to have more than 1k buffered
4496 otherwise. I'm told that some telnet connections get
4497 really screwed by more than 1k output at once. */
4498 int outq
= PENDING_OUTPUT_COUNT (stdout
);
4500 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
4503 if (preempt_count
== 1)
4505 #ifdef EMACS_OUTQSIZE
4506 if (EMACS_OUTQSIZE (0, &outq
) < 0)
4507 /* Probably not a tty. Ignore the error and reset
4508 * the outq count. */
4509 outq
= PENDING_OUTPUT_COUNT (stdout
);
4512 if (baud_rate
<= outq
&& baud_rate
> 0)
4513 sleep (outq
/ baud_rate
);
4518 if ((i
- 1) % preempt_count
== 0)
4519 detect_input_pending ();
4521 update_frame_line (f
, i
);
4525 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
4527 /* Now just clean up termcap drivers and set cursor, etc. */
4530 if ((cursor_in_echo_area
4531 /* If we are showing a message instead of the mini-buffer,
4532 show the cursor for the message instead of for the
4533 (now hidden) mini-buffer contents. */
4534 || (EQ (minibuf_window
, selected_window
)
4535 && EQ (minibuf_window
, echo_area_window
)
4536 && !NILP (echo_area_buffer
[0])))
4537 /* These cases apply only to the frame that contains
4538 the active mini-buffer window. */
4539 && FRAME_HAS_MINIBUF_P (f
)
4540 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4542 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
4545 if (cursor_in_echo_area
< 0)
4547 /* Negative value of cursor_in_echo_area means put
4548 cursor at beginning of line. */
4554 /* Positive value of cursor_in_echo_area means put
4555 cursor at the end of the prompt. If the mini-buffer
4556 is several lines high, find the last line that has
4558 row
= FRAME_HEIGHT (f
);
4564 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
4566 /* Frame rows are filled up with spaces that
4567 must be ignored here. */
4568 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
4570 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
4571 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
4574 && (last
- 1)->charpos
< 0)
4580 while (row
> top
&& col
== 0);
4582 /* Make sure COL is not out of range. */
4583 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
4585 /* If we have another row, advance cursor into it. */
4586 if (row
< FRAME_HEIGHT (f
) - 1)
4588 col
= FRAME_LEFT_SCROLL_BAR_WIDTH (f
);
4591 /* Otherwise move it back in range. */
4593 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
4597 cursor_to (row
, col
);
4601 /* We have only one cursor on terminal frames. Use it to
4602 display the cursor of the selected window. */
4603 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
4604 if (w
->cursor
.vpos
>= 0)
4606 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
4607 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
4609 if (INTEGERP (w
->left_margin_width
))
4610 x
+= XFASTINT (w
->left_margin_width
);
4612 /* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
4621 fflush (termscript
);
4626 display_completed
= !pause
;
4627 clear_desired_matrices (f
);
4632 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4636 struct frame
*frame
;
4638 int unchanged_at_top
, unchanged_at_bottom
;
4641 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4642 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4643 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4644 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4646 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
4647 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4648 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4650 if (!current_matrix
)
4653 /* Compute hash codes of all the lines. Also calculate number of
4654 changed lines, number of unchanged lines at the beginning, and
4655 number of unchanged lines at the end. */
4657 unchanged_at_top
= 0;
4658 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
4659 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
4661 /* Give up on this scrolling if some old lines are not enabled. */
4662 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
4664 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
4665 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4667 /* This line cannot be redrawn, so don't let scrolling mess it. */
4668 new_hash
[i
] = old_hash
[i
];
4669 #define INFINITY 1000000 /* Taken from scroll.c */
4670 draw_cost
[i
] = INFINITY
;
4674 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
4675 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
4678 if (old_hash
[i
] != new_hash
[i
])
4681 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
4683 else if (i
== unchanged_at_top
)
4685 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
4688 /* If changed lines are few, don't allow preemption, don't scroll. */
4689 if ((!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400)
4690 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
4693 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
4694 - unchanged_at_bottom
);
4696 if (scroll_region_ok
)
4697 free_at_end_vpos
-= unchanged_at_bottom
;
4698 else if (memory_below_frame
)
4699 free_at_end_vpos
= -1;
4701 /* If large window, fast terminal and few lines in common between
4702 current frame and desired frame, don't bother with i/d calc. */
4703 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
4705 10 * scrolling_max_lines_saved (unchanged_at_top
,
4706 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
4707 old_hash
, new_hash
, draw_cost
)))
4710 if (window_size
< 2)
4713 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
4714 draw_cost
+ unchanged_at_top
- 1,
4715 old_draw_cost
+ unchanged_at_top
- 1,
4716 old_hash
+ unchanged_at_top
- 1,
4717 new_hash
+ unchanged_at_top
- 1,
4718 free_at_end_vpos
- unchanged_at_top
);
4724 /* Count the number of blanks at the start of the vector of glyphs R
4725 which is LEN glyphs long. */
4728 count_blanks (r
, len
)
4734 for (i
= 0; i
< len
; ++i
)
4735 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
4742 /* Count the number of glyphs in common at the start of the glyph
4743 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
4744 of STR2. Value is the number of equal glyphs equal at the start. */
4747 count_match (str1
, end1
, str2
, end2
)
4748 struct glyph
*str1
, *end1
, *str2
, *end2
;
4750 struct glyph
*p1
= str1
;
4751 struct glyph
*p2
= str2
;
4755 && GLYPH_FROM_CHAR_GLYPH (*p1
) == GLYPH_FROM_CHAR_GLYPH (*p2
))
4762 /* Char insertion/deletion cost vector, from term.c */
4764 extern int *char_ins_del_vector
;
4765 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
4768 /* Perform a frame-based update on line VPOS in frame FRAME. */
4771 update_frame_line (frame
, vpos
)
4772 register struct frame
*frame
;
4775 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
4777 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
4778 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4779 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4780 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
4781 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
4782 int must_write_whole_line_p
;
4784 if (desired_row
->inverse_p
4785 != (current_row
->enabled_p
&& current_row
->inverse_p
))
4787 int n
= current_row
->enabled_p
? current_row
->used
[TEXT_AREA
] : 0;
4788 change_line_highlight (desired_row
->inverse_p
, vpos
, vpos
, n
);
4789 current_row
->enabled_p
= 0;
4792 reassert_line_highlight (desired_row
->inverse_p
, vpos
);
4794 /* Current row not enabled means it has unknown contents. We must
4795 write the whole desired line in that case. */
4796 must_write_whole_line_p
= !current_row
->enabled_p
;
4797 if (must_write_whole_line_p
)
4804 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
4805 olen
= current_row
->used
[TEXT_AREA
];
4807 if (! current_row
->inverse_p
)
4809 /* Ignore trailing spaces, if we can. */
4810 if (!must_write_spaces
)
4811 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
4816 /* For an inverse-video line, make sure it's filled with
4817 spaces all the way to the frame edge so that the reverse
4818 video extends all the way across. */
4819 while (olen
< FRAME_WIDTH (frame
) - 1)
4820 obody
[olen
++] = space_glyph
;
4824 current_row
->enabled_p
= 1;
4825 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
4826 current_row
->inverse_p
= desired_row
->inverse_p
;
4828 /* If desired line is empty, just clear the line. */
4829 if (!desired_row
->enabled_p
)
4835 nbody
= desired_row
->glyphs
[TEXT_AREA
];
4836 nlen
= desired_row
->used
[TEXT_AREA
];
4837 nend
= nbody
+ nlen
;
4839 /* If display line has unknown contents, write the whole line. */
4840 if (must_write_whole_line_p
)
4842 /* Ignore spaces at the end, if we can. */
4843 if (!must_write_spaces
)
4844 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4847 /* Write the contents of the desired line. */
4850 cursor_to (vpos
, 0);
4851 write_glyphs (nbody
, nlen
);
4854 /* Don't call clear_end_of_line if we already wrote the whole
4855 line. The cursor will not be at the right margin in that
4856 case but in the line below. */
4857 if (nlen
< FRAME_WINDOW_WIDTH (frame
))
4859 cursor_to (vpos
, nlen
);
4860 clear_end_of_line (FRAME_WINDOW_WIDTH (frame
));
4863 make_current (desired_matrix
, current_matrix
, vpos
);
4867 /* Pretend trailing spaces are not there at all,
4868 unless for one reason or another we must write all spaces. */
4869 if (!desired_row
->inverse_p
)
4871 if (!must_write_spaces
)
4872 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4877 /* For an inverse-video line, give it extra trailing spaces all
4878 the way to the frame edge so that the reverse video extends
4879 all the way across. */
4880 while (nlen
< FRAME_WIDTH (frame
) - 1)
4881 nbody
[nlen
++] = space_glyph
;
4884 /* If there's no i/d char, quickly do the best we can without it. */
4885 if (!char_ins_del_ok
)
4889 /* Find the first glyph in desired row that doesn't agree with
4890 a glyph in the current row, and write the rest from there on. */
4891 for (i
= 0; i
< nlen
; i
++)
4893 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
4895 /* Find the end of the run of different glyphs. */
4899 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
4900 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
4903 /* Output this run of non-matching chars. */
4904 cursor_to (vpos
, i
);
4905 write_glyphs (nbody
+ i
, j
- i
);
4908 /* Now find the next non-match. */
4912 /* Clear the rest of the line, or the non-clear part of it. */
4915 cursor_to (vpos
, nlen
);
4916 clear_end_of_line (olen
);
4919 /* Make current row = desired row. */
4920 make_current (desired_matrix
, current_matrix
, vpos
);
4924 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
4925 characters in a row. */
4929 /* If current line is blank, skip over initial spaces, if
4930 possible, and write the rest. */
4931 if (must_write_spaces
|| desired_row
->inverse_p
)
4934 nsp
= count_blanks (nbody
, nlen
);
4938 cursor_to (vpos
, nsp
);
4939 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
4942 /* Exchange contents between current_frame and new_frame. */
4943 make_current (desired_matrix
, current_matrix
, vpos
);
4947 /* Compute number of leading blanks in old and new contents. */
4948 osp
= count_blanks (obody
, olen
);
4949 nsp
= desired_row
->inverse_p
? 0 : count_blanks (nbody
, nlen
);
4951 /* Compute number of matching chars starting with first non-blank. */
4952 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
4953 nbody
+ nsp
, nbody
+ nlen
);
4955 /* Spaces in new match implicit space past the end of old. */
4956 /* A bug causing this to be a no-op was fixed in 18.29. */
4957 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
4960 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
4964 /* Avoid doing insert/delete char
4965 just cause number of leading spaces differs
4966 when the following text does not match. */
4967 if (begmatch
== 0 && osp
!= nsp
)
4968 osp
= nsp
= min (osp
, nsp
);
4970 /* Find matching characters at end of line */
4973 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
4975 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
4980 endmatch
= obody
+ olen
- op1
;
4982 /* tem gets the distance to insert or delete.
4983 endmatch is how many characters we save by doing so.
4986 tem
= (nlen
- nsp
) - (olen
- osp
);
4988 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
4991 /* nsp - osp is the distance to insert or delete.
4992 If that is nonzero, begmatch is known to be nonzero also.
4993 begmatch + endmatch is how much we save by doing the ins/del.
4997 && (!char_ins_del_ok
4998 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
5002 osp
= nsp
= min (osp
, nsp
);
5005 /* Now go through the line, inserting, writing and
5006 deleting as appropriate. */
5010 cursor_to (vpos
, nsp
);
5011 delete_glyphs (osp
- nsp
);
5015 /* If going to delete chars later in line
5016 and insert earlier in the line,
5017 must delete first to avoid losing data in the insert */
5018 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
5020 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
5021 delete_glyphs (olen
+ nsp
- osp
- nlen
);
5022 olen
= nlen
- (nsp
- osp
);
5024 cursor_to (vpos
, osp
);
5025 insert_glyphs (0, nsp
- osp
);
5029 tem
= nsp
+ begmatch
+ endmatch
;
5030 if (nlen
!= tem
|| olen
!= tem
)
5032 cursor_to (vpos
, nsp
+ begmatch
);
5033 if (!endmatch
|| nlen
== olen
)
5035 /* If new text being written reaches right margin,
5036 there is no need to do clear-to-eol at the end.
5037 (and it would not be safe, since cursor is not
5038 going to be "at the margin" after the text is done) */
5039 if (nlen
== FRAME_WINDOW_WIDTH (frame
))
5041 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5043 else if (nlen
> olen
)
5045 /* Here, we used to have the following simple code:
5046 ----------------------------------------
5047 write_glyphs (nbody + nsp + begmatch, olen - tem);
5048 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5049 ----------------------------------------
5050 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5051 is a padding glyph. */
5052 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5055 /* Calculate columns we can actually overwrite. */
5056 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
])) out
--;
5057 write_glyphs (nbody
+ nsp
+ begmatch
, out
);
5058 /* If we left columns to be overwritten, we must delete them. */
5059 del
= olen
- tem
- out
;
5060 if (del
> 0) delete_glyphs (del
);
5061 /* At last, we insert columns not yet written out. */
5062 insert_glyphs (nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5065 else if (olen
> nlen
)
5067 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5068 delete_glyphs (olen
- nlen
);
5074 /* If any unerased characters remain after the new line, erase them. */
5077 cursor_to (vpos
, nlen
);
5078 clear_end_of_line (olen
);
5081 /* Exchange contents between current_frame and new_frame. */
5082 make_current (desired_matrix
, current_matrix
, vpos
);
5087 /***********************************************************************
5088 X/Y Position -> Buffer Position
5089 ***********************************************************************/
5091 /* Return the character position of the character at window relative
5092 pixel position (*X, *Y). *X and *Y are adjusted to character
5096 buffer_posn_from_coords (w
, x
, y
)
5101 struct buffer
*old_current_buffer
= current_buffer
;
5102 struct text_pos startp
;
5103 int left_area_width
;
5105 current_buffer
= XBUFFER (w
->buffer
);
5106 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5107 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5108 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5109 start_display (&it
, w
, startp
);
5111 left_area_width
= WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH (w
);
5112 move_it_to (&it
, -1, *x
+ it
.first_visible_x
- left_area_width
, *y
, -1,
5113 MOVE_TO_X
| MOVE_TO_Y
);
5115 *x
= it
.current_x
- it
.first_visible_x
+ left_area_width
;
5117 current_buffer
= old_current_buffer
;
5118 return IT_CHARPOS (it
);
5122 /* Value is the string under window-relative coordinates X/Y in the
5123 mode or top line of window W, or nil if none. MODE_LINE_P non-zero
5124 means look at the mode line. *CHARPOS is set to the position in
5125 the string returned. */
5128 mode_line_string (w
, x
, y
, mode_line_p
, charpos
)
5133 struct glyph_row
*row
;
5134 struct glyph
*glyph
, *end
;
5135 struct frame
*f
= XFRAME (w
->frame
);
5137 Lisp_Object string
= Qnil
;
5139 /* Only do this for frames under a window system. */
5140 if (!FRAME_WINDOW_P (f
))
5144 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5146 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
5148 if (row
->mode_line_p
&& row
->enabled_p
)
5150 /* The mode lines are displayed over scroll bars and bitmap
5151 areas, and X is window-relative. Correct X by the scroll bar
5152 and bitmap area width. */
5153 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
5154 x
+= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
5155 x
+= FRAME_LEFT_FLAGS_AREA_WIDTH (f
);
5157 /* Find the glyph under X. If we find one with a string object,
5158 it's the one we were looking for. */
5159 glyph
= row
->glyphs
[TEXT_AREA
];
5160 end
= glyph
+ row
->used
[TEXT_AREA
];
5161 for (x0
= 0; glyph
< end
; x0
+= glyph
->pixel_width
, ++glyph
)
5162 if (x
>= x0
&& x
< x0
+ glyph
->pixel_width
)
5164 string
= glyph
->object
;
5165 *charpos
= glyph
->charpos
;
5174 /***********************************************************************
5175 Changing Frame Sizes
5176 ***********************************************************************/
5181 window_change_signal (signalnum
) /* If we don't have an argument, */
5182 int signalnum
; /* some compilers complain in signal calls. */
5186 int old_errno
= errno
;
5188 get_frame_size (&width
, &height
);
5190 /* The frame size change obviously applies to a termcap-controlled
5191 frame. Find such a frame in the list, and assume it's the only
5192 one (since the redisplay code always writes to stdout, not a
5193 FILE * specified in the frame structure). Record the new size,
5194 but don't reallocate the data structures now. Let that be done
5195 later outside of the signal handler. */
5198 Lisp_Object tail
, frame
;
5200 FOR_EACH_FRAME (tail
, frame
)
5202 if (FRAME_TERMCAP_P (XFRAME (frame
)))
5204 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5210 signal (SIGWINCH
, window_change_signal
);
5213 #endif /* SIGWINCH */
5216 /* Do any change in frame size that was requested by a signal. SAFE
5217 non-zero means this function is called from a place where it is
5218 safe to change frame sizes while a redisplay is in progress. */
5221 do_pending_window_change (safe
)
5224 /* If window_change_signal should have run before, run it now. */
5225 if (redisplaying_p
&& !safe
)
5228 while (delayed_size_change
)
5230 Lisp_Object tail
, frame
;
5232 delayed_size_change
= 0;
5234 FOR_EACH_FRAME (tail
, frame
)
5236 struct frame
*f
= XFRAME (frame
);
5238 int height
= FRAME_NEW_HEIGHT (f
);
5239 int width
= FRAME_NEW_WIDTH (f
);
5241 if (height
!= 0 || width
!= 0)
5242 change_frame_size (f
, height
, width
, 0, 0, safe
);
5248 /* Change the frame height and/or width. Values may be given as zero to
5249 indicate no change is to take place.
5251 If DELAY is non-zero, then assume we're being called from a signal
5252 handler, and queue the change for later - perhaps the next
5253 redisplay. Since this tries to resize windows, we can't call it
5254 from a signal handler.
5256 SAFE non-zero means this function is called from a place where it's
5257 safe to change frame sizes while a redisplay is in progress. */
5260 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5261 register struct frame
*f
;
5262 int newheight
, newwidth
, pretend
, delay
, safe
;
5264 Lisp_Object tail
, frame
;
5266 if (! FRAME_WINDOW_P (f
))
5268 /* When using termcap, or on MS-DOS, all frames use
5269 the same screen, so a change in size affects all frames. */
5270 FOR_EACH_FRAME (tail
, frame
)
5271 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5272 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5273 pretend
, delay
, safe
);
5276 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
5280 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5281 register struct frame
*f
;
5282 int newheight
, newwidth
, pretend
, delay
, safe
;
5284 int new_frame_window_width
;
5285 int count
= specpdl_ptr
- specpdl
;
5287 /* If we can't deal with the change now, queue it for later. */
5288 if (delay
|| (redisplaying_p
&& !safe
))
5290 FRAME_NEW_HEIGHT (f
) = newheight
;
5291 FRAME_NEW_WIDTH (f
) = newwidth
;
5292 delayed_size_change
= 1;
5296 /* This size-change overrides any pending one for this frame. */
5297 FRAME_NEW_HEIGHT (f
) = 0;
5298 FRAME_NEW_WIDTH (f
) = 0;
5300 /* If an argument is zero, set it to the current value. */
5302 newheight
= FRAME_HEIGHT (f
);
5304 newwidth
= FRAME_WIDTH (f
);
5306 /* Compute width of windows in F.
5307 This is the width of the frame without vertical scroll bars. */
5308 new_frame_window_width
= FRAME_WINDOW_WIDTH_ARG (f
, newwidth
);
5310 /* Round up to the smallest acceptable size. */
5311 check_frame_size (f
, &newheight
, &newwidth
);
5313 /* If we're not changing the frame size, quit now. */
5314 if (newheight
== FRAME_HEIGHT (f
)
5315 && new_frame_window_width
== FRAME_WINDOW_WIDTH (f
))
5321 /* We only can set screen dimensions to certain values supported
5322 by our video hardware. Try to find the smallest size greater
5323 or equal to the requested dimensions. */
5324 dos_set_window_size (&newheight
, &newwidth
);
5327 if (newheight
!= FRAME_HEIGHT (f
))
5329 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
5331 /* Frame has both root and mini-buffer. */
5332 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f
))->top
,
5333 FRAME_TOP_MARGIN (f
));
5334 set_window_height (FRAME_ROOT_WINDOW (f
),
5337 - FRAME_TOP_MARGIN (f
)),
5339 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
,
5341 set_window_height (FRAME_MINIBUF_WINDOW (f
), 1, 0);
5344 /* Frame has just one top-level window. */
5345 set_window_height (FRAME_ROOT_WINDOW (f
),
5346 newheight
- FRAME_TOP_MARGIN (f
), 0);
5348 if (FRAME_TERMCAP_P (f
) && !pretend
)
5349 FrameRows
= newheight
;
5352 if (new_frame_window_width
!= FRAME_WINDOW_WIDTH (f
))
5354 set_window_width (FRAME_ROOT_WINDOW (f
), new_frame_window_width
, 0);
5355 if (FRAME_HAS_MINIBUF_P (f
))
5356 set_window_width (FRAME_MINIBUF_WINDOW (f
), new_frame_window_width
, 0);
5358 if (FRAME_TERMCAP_P (f
) && !pretend
)
5359 FrameCols
= newwidth
;
5361 if (WINDOWP (f
->tool_bar_window
))
5362 XSETFASTINT (XWINDOW (f
->tool_bar_window
)->width
, newwidth
);
5365 FRAME_HEIGHT (f
) = newheight
;
5366 SET_FRAME_WIDTH (f
, newwidth
);
5369 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5370 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
5372 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
5374 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
5375 w
->cursor
.hpos
= w
->cursor
.x
= 0;
5376 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
5377 w
->cursor
.vpos
= w
->cursor
.y
= 0;
5381 SET_FRAME_GARBAGED (f
);
5382 calculate_costs (f
);
5386 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
5388 /* This isn't quite a no-op: it runs window-configuration-change-hook. */
5389 Fset_window_buffer (FRAME_SELECTED_WINDOW (f
),
5390 XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
);
5392 unbind_to (count
, Qnil
);
5397 /***********************************************************************
5398 Terminal Related Lisp Functions
5399 ***********************************************************************/
5401 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
5402 1, 1, "FOpen termscript file: ",
5403 "Start writing all terminal output to FILE as well as the terminal.\n\
5404 FILE = nil means just close any termscript file currently open.")
5408 if (termscript
!= 0) fclose (termscript
);
5413 file
= Fexpand_file_name (file
, Qnil
);
5414 termscript
= fopen (XSTRING (file
)->data
, "w");
5415 if (termscript
== 0)
5416 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
5422 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
5423 Ssend_string_to_terminal
, 1, 1, 0,
5424 "Send STRING to the terminal without alteration.\n\
5425 Control characters in STRING will have terminal-dependent effects.")
5429 /* ??? Perhaps we should do something special for multibyte strings here. */
5430 CHECK_STRING (string
, 0);
5431 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)), stdout
);
5435 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)),
5437 fflush (termscript
);
5443 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
5444 "Beep, or flash the screen.\n\
5445 Also, unless an argument is given,\n\
5446 terminate any keyboard macro currently executing.")
5469 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
5470 error ("Keyboard macro terminated by a command ringing the bell");
5478 /***********************************************************************
5480 ***********************************************************************/
5482 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
5483 "Pause, without updating display, for SECONDS seconds.\n\
5484 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5485 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5486 additional wait period, in milliseconds; this may be useful if your\n\
5487 Emacs was built without floating point support.\n\
5488 \(Not all operating systems support waiting for a fraction of a second.)")
5489 (seconds
, milliseconds
)
5490 Lisp_Object seconds
, milliseconds
;
5494 if (NILP (milliseconds
))
5495 XSETINT (milliseconds
, 0);
5497 CHECK_NUMBER (milliseconds
, 1);
5498 usec
= XINT (milliseconds
) * 1000;
5500 #ifdef LISP_FLOAT_TYPE
5502 double duration
= extract_float (seconds
);
5503 sec
= (int) duration
;
5504 usec
+= (duration
- sec
) * 1000000;
5507 CHECK_NUMBER (seconds
, 0);
5508 sec
= XINT (seconds
);
5511 #ifndef EMACS_HAS_USECS
5512 if (sec
== 0 && usec
!= 0)
5513 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
5516 /* Assure that 0 <= usec < 1000000. */
5519 /* We can't rely on the rounding being correct if user is negative. */
5520 if (-1000000 < usec
)
5521 sec
--, usec
+= 1000000;
5523 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
5526 sec
+= usec
/ 1000000, usec
%= 1000000;
5528 if (sec
< 0 || (sec
== 0 && usec
== 0))
5534 XSETFASTINT (zero
, 0);
5535 wait_reading_process_input (sec
, usec
, zero
, 0);
5538 /* We should always have wait_reading_process_input; we have a dummy
5539 implementation for systems which don't support subprocesses. */
5541 /* No wait_reading_process_input */
5548 /* The reason this is done this way
5549 (rather than defined (H_S) && defined (H_T))
5550 is because the VMS preprocessor doesn't grok `defined' */
5552 EMACS_GET_TIME (end_time
);
5553 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
5554 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
5558 EMACS_GET_TIME (timeout
);
5559 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
5560 if (EMACS_TIME_NEG_P (timeout
)
5561 || !select (1, 0, 0, 0, &timeout
))
5564 #else /* not HAVE_SELECT */
5566 #endif /* HAVE_SELECT */
5567 #endif /* not VMS */
5570 #endif /* no subprocesses */
5576 /* This is just like wait_reading_process_input, except that
5577 it does the redisplay.
5579 It's also much like Fsit_for, except that it can be used for
5580 waiting for input as well. */
5583 sit_for (sec
, usec
, reading
, display
, initial_display
)
5584 int sec
, usec
, reading
, display
, initial_display
;
5586 Lisp_Object read_kbd
;
5588 swallow_events (display
);
5590 if (detect_input_pending_run_timers (display
))
5593 if (initial_display
)
5594 redisplay_preserve_echo_area ();
5596 if (sec
== 0 && usec
== 0)
5603 XSETINT (read_kbd
, reading
? -1 : 1);
5604 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
5606 return detect_input_pending () ? Qnil
: Qt
;
5610 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
5611 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
5612 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5613 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5614 additional wait period, in milliseconds; this may be useful if your\n\
5615 Emacs was built without floating point support.\n\
5616 \(Not all operating systems support waiting for a fraction of a second.)\n\
5617 Optional third arg NODISP non-nil means don't redisplay, just wait for input.\n\
5618 Redisplay is preempted as always if input arrives, and does not happen\n\
5619 if input is available before it starts.\n\
5620 Value is t if waited the full time with no input arriving.")
5621 (seconds
, milliseconds
, nodisp
)
5622 Lisp_Object seconds
, milliseconds
, nodisp
;
5626 if (NILP (milliseconds
))
5627 XSETINT (milliseconds
, 0);
5629 CHECK_NUMBER (milliseconds
, 1);
5630 usec
= XINT (milliseconds
) * 1000;
5632 #ifdef LISP_FLOAT_TYPE
5634 double duration
= extract_float (seconds
);
5635 sec
= (int) duration
;
5636 usec
+= (duration
- sec
) * 1000000;
5639 CHECK_NUMBER (seconds
, 0);
5640 sec
= XINT (seconds
);
5643 #ifndef EMACS_HAS_USECS
5644 if (usec
!= 0 && sec
== 0)
5645 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
5648 return sit_for (sec
, usec
, 0, NILP (nodisp
), NILP (nodisp
));
5653 /***********************************************************************
5654 Other Lisp Functions
5655 ***********************************************************************/
5657 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
5658 session's frames, frame names, buffers, buffer-read-only flags, and
5659 buffer-modified-flags, and a trailing sentinel (so we don't need to
5660 add length checks). */
5662 static Lisp_Object frame_and_buffer_state
;
5665 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
5666 Sframe_or_buffer_changed_p
, 0, 0, 0,
5667 "Return non-nil if the frame and buffer state appears to have changed.\n\
5668 The state variable is an internal vector containing all frames and buffers,\n\
5669 aside from buffers whose names start with space,\n\
5670 along with the buffers' read-only and modified flags, which allows a fast\n\
5671 check to see whether the menu bars might need to be recomputed.\n\
5672 If this function returns non-nil, it updates the internal vector to reflect\n\
5673 the current state.\n")
5676 Lisp_Object tail
, frame
, buf
;
5680 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5681 FOR_EACH_FRAME (tail
, frame
)
5683 if (!EQ (*vecp
++, frame
))
5685 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
5688 /* Check that the buffer info matches.
5689 No need to test for the end of the vector
5690 because the last element of the vector is lambda
5691 and that will always cause a mismatch. */
5692 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5694 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
5695 /* Ignore buffers that aren't included in buffer lists. */
5696 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5698 if (!EQ (*vecp
++, buf
))
5700 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
5702 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
5705 /* Detect deletion of a buffer at the end of the list. */
5706 if (EQ (*vecp
, Qlambda
))
5709 /* Start with 1 so there is room for at least one lambda at the end. */
5711 FOR_EACH_FRAME (tail
, frame
)
5713 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5715 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
5716 if (n
> XVECTOR (frame_and_buffer_state
)->size
5717 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
5718 /* Add 20 extra so we grow it less often. */
5719 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
5720 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5721 FOR_EACH_FRAME (tail
, frame
)
5724 *vecp
++ = XFRAME (frame
)->name
;
5726 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5728 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
5729 /* Ignore buffers that aren't included in buffer lists. */
5730 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5733 *vecp
++ = XBUFFER (buf
)->read_only
;
5734 *vecp
++ = Fbuffer_modified_p (buf
);
5736 /* Fill up the vector with lambdas (always at least one). */
5738 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5739 < XVECTOR (frame_and_buffer_state
)->size
)
5741 /* Make sure we didn't overflow the vector. */
5742 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5743 > XVECTOR (frame_and_buffer_state
)->size
)
5750 /***********************************************************************
5752 ***********************************************************************/
5754 char *terminal_type
;
5756 /* Initialization done when Emacs fork is started, before doing stty.
5757 Determine terminal type and set terminal_driver. Then invoke its
5758 decoding routine to set up variables in the terminal package. */
5763 #ifdef HAVE_X_WINDOWS
5764 extern int display_arg
;
5767 /* Construct the space glyph. */
5768 space_glyph
.type
= CHAR_GLYPH
;
5769 SET_CHAR_GLYPH_FROM_GLYPH (space_glyph
, ' ');
5770 space_glyph
.charpos
= -1;
5774 cursor_in_echo_area
= 0;
5775 terminal_type
= (char *) 0;
5777 /* Now is the time to initialize this; it's used by init_sys_modes
5779 Vwindow_system
= Qnil
;
5781 /* If the user wants to use a window system, we shouldn't bother
5782 initializing the terminal. This is especially important when the
5783 terminal is so dumb that emacs gives up before and doesn't bother
5784 using the window system.
5786 If the DISPLAY environment variable is set and nonempty,
5787 try to use X, and die with an error message if that doesn't work. */
5789 #ifdef HAVE_X_WINDOWS
5794 display
= getenv ("DECW$DISPLAY");
5796 display
= getenv ("DISPLAY");
5799 display_arg
= (display
!= 0 && *display
!= 0);
5802 if (!inhibit_window_system
&& display_arg
5808 Vwindow_system
= intern ("x");
5810 Vwindow_system_version
= make_number (11);
5812 Vwindow_system_version
= make_number (10);
5814 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
5815 /* In some versions of ncurses,
5816 tputs crashes if we have not called tgetent.
5818 { char b
[2044]; tgetent (b
, "xterm");}
5820 adjust_frame_glyphs_initially ();
5823 #endif /* HAVE_X_WINDOWS */
5826 if (!inhibit_window_system
)
5828 Vwindow_system
= intern ("w32");
5829 Vwindow_system_version
= make_number (1);
5830 adjust_frame_glyphs_initially ();
5833 #endif /* HAVE_NTGUI */
5835 /* If no window system has been specified, try to use the terminal. */
5838 fatal ("standard input is not a tty");
5842 /* Look at the TERM variable */
5843 terminal_type
= (char *) getenv ("TERM");
5847 fprintf (stderr
, "Please specify your terminal type.\n\
5848 For types defined in VMS, use set term /device=TYPE.\n\
5849 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
5850 \(The quotation marks are necessary since terminal types are lower case.)\n");
5852 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
5858 /* VMS DCL tends to up-case things, so down-case term type.
5859 Hardly any uppercase letters in terminal types; should be none. */
5861 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
5864 strcpy (new, terminal_type
);
5866 for (p
= new; *p
; p
++)
5870 terminal_type
= new;
5874 term_init (terminal_type
);
5877 struct frame
*sf
= SELECTED_FRAME ();
5878 int width
= FRAME_WINDOW_WIDTH (sf
);
5879 int height
= FRAME_HEIGHT (sf
);
5881 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (struct glyph
);
5883 /* If these sizes are so big they cause overflow, just ignore the
5884 change. It's not clear what better we could do. */
5885 if (total_glyphs
/ sizeof (struct glyph
) / height
!= width
+ 2)
5886 fatal ("screen size %dx%d too big", width
, height
);
5889 adjust_frame_glyphs_initially ();
5890 calculate_costs (XFRAME (selected_frame
));
5895 #endif /* CANNOT_DUMP */
5896 signal (SIGWINCH
, window_change_signal
);
5897 #endif /* SIGWINCH */
5899 /* Set up faces of the initial terminal frame of a dumped Emacs. */
5903 /* The MSDOS terminal turns on its ``window system'' relatively
5904 late into the startup, so we cannot do the frame faces'
5905 initialization just yet. It will be done later by pc-win.el
5906 and internal_terminal_init. */
5907 && (strcmp (terminal_type
, "internal") != 0 || inhibit_window_system
)
5909 && NILP (Vwindow_system
))
5910 call0 (intern ("tty-set-up-initial-frame-faces"));
5915 /***********************************************************************
5917 ***********************************************************************/
5919 DEFUN ("show-cursor", Fshow_cursor
, Sshow_cursor
, 0, 2, 0,
5920 "Change visibility flag of the text cursor of WINDOW.\n\
5921 ON_P nil means toggle the flag. Otherwise, ON_P must be an integer,\n\
5922 and the flag is set according to the value of ON_P. WINDOW nil or\n\
5923 omitted means use the selected window. The new cursor state takes effect\n\
5924 with the next redisplay.")
5926 Lisp_Object on_p
, window
;
5930 /* Don't change cursor state while redisplaying. This could confuse
5932 if (!redisplaying_p
)
5935 window
= selected_window
;
5937 CHECK_WINDOW (window
, 2);
5938 w
= XWINDOW (window
);
5941 w
->cursor_off_p
= !w
->cursor_off_p
;
5944 CHECK_NUMBER (on_p
, 1);
5945 w
->cursor_off_p
= XINT (on_p
) != 0;
5954 /***********************************************************************
5956 ***********************************************************************/
5961 defsubr (&Sredraw_frame
);
5962 defsubr (&Sredraw_display
);
5963 defsubr (&Sframe_or_buffer_changed_p
);
5964 defsubr (&Sopen_termscript
);
5966 defsubr (&Ssit_for
);
5967 defsubr (&Ssleep_for
);
5968 defsubr (&Ssend_string_to_terminal
);
5969 defsubr (&Sshow_cursor
);
5971 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
5972 staticpro (&frame_and_buffer_state
);
5974 Qdisplay_table
= intern ("display-table");
5975 staticpro (&Qdisplay_table
);
5977 DEFVAR_INT ("baud-rate", &baud_rate
,
5978 "*The output baud rate of the terminal.\n\
5979 On most systems, changing this value will affect the amount of padding\n\
5980 and the other strategic decisions made during redisplay.");
5982 DEFVAR_BOOL ("inverse-video", &inverse_video
,
5983 "*Non-nil means invert the entire frame display.\n\
5984 This means everything is in inverse video which otherwise would not be.");
5986 DEFVAR_BOOL ("visible-bell", &visible_bell
,
5987 "*Non-nil means try to flash the frame to represent a bell.");
5989 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
5990 "*Non-nil means no need to redraw entire frame after suspending.\n\
5991 A non-nil value is useful if the terminal can automatically preserve\n\
5992 Emacs's frame display when you reenter Emacs.\n\
5993 It is up to you to set this variable if your terminal can do that.");
5995 DEFVAR_LISP ("window-system", &Vwindow_system
,
5996 "A symbol naming the window-system under which Emacs is running\n\
5997 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
5999 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
6000 "The version number of the window system in use.\n\
6001 For X windows, this is 10 or 11.");
6003 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
6004 "Non-nil means put cursor in minibuffer, at end of any message there.");
6006 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
6007 "Table defining how to output a glyph code to the frame.\n\
6008 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
6009 Each element can be:\n\
6010 integer: a glyph code which this glyph is an alias for.\n\
6011 string: output this glyph using that string (not impl. in X windows).\n\
6012 nil: this glyph mod 256 is char code to output,\n\
6013 and this glyph / 256 is face code for X windows (see `face-id').");
6014 Vglyph_table
= Qnil
;
6016 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
6017 "Display table to use for buffers that specify none.\n\
6018 See `buffer-display-table' for more information.");
6019 Vstandard_display_table
= Qnil
;
6021 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause
,
6022 "*Non-nil means update isn't paused when input is detected.");
6023 redisplay_dont_pause
= 0;
6025 /* Initialize `window-system', unless init_display already decided it. */
6030 Vwindow_system
= Qnil
;
6031 Vwindow_system_version
= Qnil
;