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 (glyphs
, glyphs
+ n
, (end
- glyphs
- n
) * sizeof (*end
));
3144 bcopy (it
.glyph_row
->glyphs
[TEXT_AREA
], glyphs
, n
* sizeof *glyphs
);
3145 glyph_row
->used
[TEXT_AREA
] = min (glyph_row
->used
[TEXT_AREA
] + n
,
3146 end
- glyph_row
->glyphs
[TEXT_AREA
]);
3148 /* Compute new line width. */
3149 glyph
= glyph_row
->glyphs
[TEXT_AREA
];
3150 end
= glyph
+ glyph_row
->used
[TEXT_AREA
];
3151 glyph_row
->pixel_width
= glyph_row
->x
;
3154 glyph_row
->pixel_width
+= glyph
->pixel_width
;
3158 /* Increment buffer positions for glyphs following the newly
3160 for (glyph
= glyphs
+ n
; glyph
< end
; ++glyph
)
3161 if (glyph
->charpos
> 0)
3162 glyph
->charpos
+= delta
;
3164 if (MATRIX_ROW_END_CHARPOS (glyph_row
) > 0)
3166 MATRIX_ROW_END_CHARPOS (glyph_row
) += delta
;
3167 MATRIX_ROW_END_BYTEPOS (glyph_row
) += delta_bytes
;
3170 /* Adjust positions in lines following the one we are in. */
3171 increment_glyph_matrix_buffer_positions (w
->current_matrix
,
3173 w
->current_matrix
->nrows
,
3174 delta
, delta_bytes
);
3176 glyph_row
->contains_overlapping_glyphs_p
3177 |= it
.glyph_row
->contains_overlapping_glyphs_p
;
3179 if (!NILP (Vshow_trailing_whitespace
))
3180 highlight_trailing_whitespace (it
.f
, glyph_row
);
3182 /* Write glyphs. If at end of row, we can simply call write_glyphs.
3183 In the middle, we have to insert glyphs. Note that this is now
3184 implemented for X frames. The implementation uses updated_window
3186 updated_row
= glyph_row
;
3190 rif
->update_window_begin_hook (w
);
3192 if (glyphs
== end
- n
)
3193 rif
->write_glyphs (glyphs
, n
);
3195 rif
->insert_glyphs (glyphs
, n
);
3199 if (glyphs
== end
- n
)
3200 write_glyphs (glyphs
, n
);
3202 insert_glyphs (glyphs
, n
);
3205 w
->cursor
.hpos
+= n
;
3206 w
->cursor
.x
= it
.current_x
- it
.first_visible_x
;
3207 xassert (w
->cursor
.hpos
>= 0
3208 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3210 /* How to set the cursor differs depending on whether we are
3211 using a frame matrix or a window matrix. Note that when
3212 a frame matrix is used, cursor_to expects frame coordinates,
3213 and the X and Y parameters are not used. */
3214 if (window_redisplay_p
)
3215 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3216 w
->cursor
.y
, w
->cursor
.x
);
3220 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3221 + (INTEGERP (w
->left_margin_width
)
3222 ? XFASTINT (w
->left_margin_width
)
3224 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3229 rif
->update_window_end_hook (w
, 1);
3234 TRACE ((stderr
, "direct output for insert\n"));
3236 UNCHANGED_MODIFIED
= MODIFF
;
3237 BEG_UNCHANGED
= GPT
- BEG
;
3238 XSETFASTINT (w
->last_point
, PT
);
3239 w
->last_cursor
= w
->cursor
;
3240 XSETFASTINT (w
->last_modified
, MODIFF
);
3241 XSETFASTINT (w
->last_overlay_modified
, OVERLAY_MODIFF
);
3243 redisplay_performed_directly_p
= 1;
3248 /* Perform a direct display update for moving PT by N positions
3249 left or right. N < 0 means a movement backwards. This function
3250 is currently only called for N == 1 or N == -1. */
3253 direct_output_forward_char (n
)
3256 struct frame
*f
= SELECTED_FRAME ();
3257 struct window
*w
= XWINDOW (selected_window
);
3258 struct glyph_row
*row
;
3260 /* Give up if face attributes have been changed. */
3261 if (face_change_count
)
3264 /* Give up if current matrix is not up to date or we are
3265 displaying a message. */
3266 if (!display_completed
|| cursor_in_echo_area
)
3269 /* Give up if the buffer's direction is reversed. */
3270 if (!NILP (XBUFFER (w
->buffer
)->direction_reversed
))
3273 /* Can't use direct output if highlighting a region. */
3274 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
3277 /* Can't use direct output if highlighting trailing whitespace. */
3278 if (!NILP (Vshow_trailing_whitespace
))
3281 /* Give up if we are showing a message or just cleared the message
3282 because we might need to resize the echo area window. */
3283 if (!NILP (echo_area_buffer
[0]) || !NILP (echo_area_buffer
[1]))
3286 /* Give up if we don't know where the cursor is. */
3287 if (w
->cursor
.vpos
< 0)
3290 row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3292 if (PT
<= MATRIX_ROW_START_BYTEPOS (row
)
3293 || PT
>= MATRIX_ROW_END_BYTEPOS (row
))
3296 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
3297 w
->last_cursor
= w
->cursor
;
3298 XSETFASTINT (w
->last_point
, PT
);
3300 xassert (w
->cursor
.hpos
>= 0
3301 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3303 if (FRAME_WINDOW_P (f
))
3304 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3305 w
->cursor
.y
, w
->cursor
.x
);
3309 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3310 + (INTEGERP (w
->left_margin_width
)
3311 ? XFASTINT (w
->left_margin_width
)
3313 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3318 redisplay_performed_directly_p
= 1;
3324 /***********************************************************************
3326 ***********************************************************************/
3328 /* Update frame F based on the data in desired matrices.
3330 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3331 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3334 Value is non-zero if redisplay was stopped due to pending input. */
3337 update_frame (f
, force_p
, inhibit_hairy_id_p
)
3340 int inhibit_hairy_id_p
;
3342 /* 1 means display has been paused because of pending input. */
3344 struct window
*root_window
= XWINDOW (f
->root_window
);
3346 if (FRAME_WINDOW_P (f
))
3348 /* We are working on window matrix basis. All windows whose
3349 flag must_be_updated_p is set have to be updated. */
3351 /* Record that we are not working on frame matrices. */
3352 set_frame_matrix_frame (NULL
);
3354 /* Update all windows in the window tree of F, maybe stopping
3355 when pending input is detected. */
3358 /* Update the menu bar on X frames that don't have toolkit
3360 if (WINDOWP (f
->menu_bar_window
))
3361 update_window (XWINDOW (f
->menu_bar_window
), 1);
3363 /* Update the tool-bar window, if present. */
3364 if (WINDOWP (f
->tool_bar_window
))
3367 struct window
*w
= XWINDOW (f
->tool_bar_window
);
3369 /* Update tool-bar window. */
3370 if (w
->must_be_updated_p
)
3372 update_window (w
, 1);
3373 w
->must_be_updated_p
= 0;
3375 /* Swap tool-bar strings. We swap because we want to
3377 tem
= f
->current_tool_bar_string
;
3378 f
->current_tool_bar_string
= f
->desired_tool_bar_string
;
3379 f
->desired_tool_bar_string
= tem
;
3380 f
->n_current_tool_bar_items
= f
->n_desired_tool_bar_items
;
3382 /* Swap tool-bar items. We swap because we want to
3384 tem
= f
->current_tool_bar_items
;
3385 f
->current_tool_bar_items
= f
->desired_tool_bar_items
;
3386 f
->desired_tool_bar_items
= tem
;
3391 /* Update windows. */
3392 paused_p
= update_window_tree (root_window
, force_p
);
3394 display_completed
= !paused_p
;
3396 /* The flush is a performance bottleneck under X. */
3398 rif
->flush_display (f
);
3403 /* We are working on frame matrix basis. Set the frame on whose
3404 frame matrix we operate. */
3405 set_frame_matrix_frame (f
);
3407 /* Build F's desired matrix from window matrices. For windows
3408 whose must_be_updated_p flag is set, desired matrices are
3409 made part of the desired frame matrix. For other windows,
3410 the current matrix is copied. */
3411 build_frame_matrix (f
);
3413 /* Do the update on the frame desired matrix. */
3414 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3416 /* Check window matrices for lost pointers. */
3417 IF_DEBUG (check_window_matrix_pointers (root_window
));
3420 /* Reset flags indicating that a window should be updated. */
3421 set_window_update_flags (root_window
, 0);
3427 /************************************************************************
3428 Window-based updates
3429 ************************************************************************/
3431 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3432 don't stop updating when input is pending. */
3435 update_window_tree (w
, force_p
)
3441 while (w
&& !paused_p
)
3443 if (!NILP (w
->hchild
))
3444 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
3445 else if (!NILP (w
->vchild
))
3446 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
3447 else if (w
->must_be_updated_p
)
3448 paused_p
|= update_window (w
, force_p
);
3450 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3457 /* Update window W if its flag must_be_updated_p is non-zero. If
3458 FORCE_P is non-zero, don't stop updating if input is pending. */
3461 update_single_window (w
, force_p
)
3465 if (w
->must_be_updated_p
)
3467 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3469 /* Record that this is not a frame-based redisplay. */
3470 set_frame_matrix_frame (NULL
);
3474 update_window (w
, force_p
);
3477 /* Reset flag in W. */
3478 w
->must_be_updated_p
= 0;
3483 /* Redraw lines from the current matrix of window W that are
3484 overlapped by other rows. YB is bottom-most y-position in W. */
3487 redraw_overlapped_rows (w
, yb
)
3492 struct glyph_row
*row
;
3494 /* If rows overlapping others have been changed, the rows being
3495 overlapped have to be redrawn. This won't draw lines that have
3496 already been drawn in update_window_line because overlapped_p in
3497 desired rows is 0, so after row assignment overlapped_p in
3498 current rows is 0. */
3499 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3501 row
= w
->current_matrix
->rows
+ i
;
3503 if (!row
->enabled_p
)
3505 else if (row
->mode_line_p
)
3508 if (row
->overlapped_p
)
3510 enum glyph_row_area area
;
3512 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3515 updated_area
= area
;
3516 rif
->cursor_to (i
, 0, row
->y
, area
== TEXT_AREA
? row
->x
: 0);
3517 if (row
->used
[area
])
3518 rif
->write_glyphs (row
->glyphs
[area
], row
->used
[area
]);
3519 rif
->clear_end_of_line (-1);
3522 row
->overlapped_p
= 0;
3525 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3532 /* Redraw lines from the current matrix of window W that overlap
3533 others. YB is bottom-most y-position in W. */
3536 redraw_overlapping_rows (w
, yb
)
3541 struct glyph_row
*row
;
3543 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3545 row
= w
->current_matrix
->rows
+ i
;
3547 if (!row
->enabled_p
)
3549 else if (row
->mode_line_p
)
3552 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3554 if (row
->overlapping_p
&& i
> 0 && bottom_y
< yb
)
3556 if (row
->used
[LEFT_MARGIN_AREA
])
3557 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
);
3559 if (row
->used
[TEXT_AREA
])
3560 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
);
3562 if (row
->used
[RIGHT_MARGIN_AREA
])
3563 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
);
3565 /* Record in neighbor rows that ROW overwrites part of their
3567 if (row
->phys_ascent
> row
->ascent
&& i
> 0)
3568 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3569 if ((row
->phys_height
- row
->phys_ascent
3570 > row
->height
- row
->ascent
)
3572 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
3581 /* Update display of window W. FORCE_P non-zero means that we should
3582 not stop when detecting pending input. */
3585 update_window (w
, force_p
)
3589 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
3591 int preempt_count
= baud_rate
/ 2400 + 1;
3592 extern int input_pending
;
3594 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3595 extern struct frame
*updating_frame
;
3598 /* Check that W's frame doesn't have glyph matrices. */
3599 xassert (FRAME_WINDOW_P (f
));
3600 xassert (updating_frame
!= NULL
);
3602 /* Check pending input the first time so that we can quickly return. */
3603 if (redisplay_dont_pause
)
3606 detect_input_pending ();
3608 /* If forced to complete the update, or if no input is pending, do
3610 if (force_p
|| !input_pending
)
3612 struct glyph_row
*row
, *end
;
3613 struct glyph_row
*mode_line_row
;
3614 struct glyph_row
*header_line_row
= NULL
;
3615 int yb
, changed_p
= 0;
3617 rif
->update_window_begin_hook (w
);
3618 yb
= window_text_bottom_y (w
);
3620 /* If window has a top line, update it before everything else.
3621 Adjust y-positions of other rows by the top line height. */
3622 row
= desired_matrix
->rows
;
3623 end
= row
+ desired_matrix
->nrows
- 1;
3624 if (row
->mode_line_p
)
3625 header_line_row
= row
++;
3627 /* Update the mode line, if necessary. */
3628 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3629 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
3631 mode_line_row
->y
= yb
;
3632 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
3637 /* Find first enabled row. Optimizations in redisplay_internal
3638 may lead to an update with only one row enabled. There may
3639 be also completely empty matrices. */
3640 while (row
< end
&& !row
->enabled_p
)
3643 /* Try reusing part of the display by inserting/deleting lines. */
3644 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
3646 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
3649 /* All rows were found to be equal. */
3658 /* Update the top mode line after scrolling because a new top
3659 line would otherwise overwrite lines at the top of the window
3660 that can be scrolled. */
3661 if (header_line_row
&& header_line_row
->enabled_p
)
3663 header_line_row
->y
= 0;
3664 update_window_line (w
, 0);
3668 /* Update the rest of the lines. */
3669 for (; row
< end
&& (force_p
|| !input_pending
); ++row
)
3671 /* A row can be completely invisible in case a desired
3672 matrix was built with a vscroll and then
3673 make_cursor_line_fully_visible shifts the matrix. */
3674 && row
->visible_height
> 0)
3676 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
3679 /* We'll Have to play a little bit with when to
3680 detect_input_pending. If it's done too often,
3681 scrolling large windows with repeated scroll-up
3682 commands will too quickly pause redisplay. */
3683 if (!force_p
&& vpos
% preempt_count
== 0)
3684 detect_input_pending ();
3686 changed_p
|= update_window_line (w
, vpos
);
3688 /* Mark all rows below the last visible one in the current
3689 matrix as invalid. This is necessary because of
3690 variable line heights. Consider the case of three
3691 successive redisplays, where the first displays 5
3692 lines, the second 3 lines, and the third 5 lines again.
3693 If the second redisplay wouldn't mark rows in the
3694 current matrix invalid, the third redisplay might be
3695 tempted to optimize redisplay based on lines displayed
3696 in the first redisplay. */
3697 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3698 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
3699 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
3702 /* Was display preempted? */
3703 paused_p
= row
< end
;
3707 /* Fix the appearance of overlapping(overlapped rows. */
3708 if (rif
->fix_overlapping_area
3709 && !w
->pseudo_window_p
3713 redraw_overlapped_rows (w
, yb
);
3714 redraw_overlapping_rows (w
, yb
);
3717 if (!paused_p
&& !w
->pseudo_window_p
)
3719 /* Make cursor visible at cursor position of W. */
3720 set_window_cursor_after_update (w
);
3723 /* Check that current matrix invariants are satisfied. This
3724 is for debugging only. See the comment around
3725 check_matrix_invariants. */
3726 IF_DEBUG (check_matrix_invariants (w
));
3731 /* Remember the redisplay method used to display the matrix. */
3732 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
3735 /* End of update of window W. */
3736 rif
->update_window_end_hook (w
, 1);
3742 clear_glyph_matrix (desired_matrix
);
3748 /* Update the display of area AREA in window W, row number VPOS.
3749 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3752 update_marginal_area (w
, area
, vpos
)
3756 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3758 /* Let functions in xterm.c know what area subsequent X positions
3759 will be relative to. */
3760 updated_area
= area
;
3762 /* Set cursor to start of glyphs, write them, and clear to the end
3763 of the area. I don't think that something more sophisticated is
3764 necessary here, since marginal areas will not be the default. */
3765 rif
->cursor_to (vpos
, 0, desired_row
->y
, 0);
3766 if (desired_row
->used
[area
])
3767 rif
->write_glyphs (desired_row
->glyphs
[area
], desired_row
->used
[area
]);
3768 rif
->clear_end_of_line (-1);
3772 /* Update the display of the text area of row VPOS in window W.
3773 Value is non-zero if display has changed. */
3776 update_text_area (w
, vpos
)
3780 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3781 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3784 /* Let functions in xterm.c know what area subsequent X positions
3785 will be relative to. */
3786 updated_area
= TEXT_AREA
;
3788 /* If rows are at different X or Y, or rows have different height,
3789 or the current row is marked invalid, write the entire line. */
3790 if (!current_row
->enabled_p
3791 || desired_row
->y
!= current_row
->y
3792 || desired_row
->ascent
!= current_row
->ascent
3793 || desired_row
->phys_ascent
!= current_row
->phys_ascent
3794 || desired_row
->phys_height
!= current_row
->phys_height
3795 || desired_row
->visible_height
!= current_row
->visible_height
3796 || current_row
->overlapped_p
3797 || current_row
->x
!= desired_row
->x
)
3799 rif
->cursor_to (vpos
, 0, desired_row
->y
, desired_row
->x
);
3801 if (desired_row
->used
[TEXT_AREA
])
3802 rif
->write_glyphs (desired_row
->glyphs
[TEXT_AREA
],
3803 desired_row
->used
[TEXT_AREA
]);
3805 /* Clear to end of window. */
3806 rif
->clear_end_of_line (-1);
3812 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
3813 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
3815 /* If the desired row extends its face to the text area end,
3816 make sure we write at least one glyph, so that the face
3817 extension actually takes place. */
3818 int desired_stop_pos
= (desired_row
->used
[TEXT_AREA
]
3819 - (MATRIX_ROW_EXTENDS_FACE_P (desired_row
)
3822 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
3828 /* Skip over glyphs that both rows have in common. These
3829 don't have to be written. */
3831 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3833 x
+= desired_glyph
->pixel_width
;
3834 ++desired_glyph
, ++current_glyph
, ++i
;
3837 /* Consider the case that the current row contains "xxx ppp
3838 ggg" in italic Courier font, and the desired row is "xxx
3839 ggg". The character `p' has lbearing, `g' has not. The
3840 loop above will stop in front of the first `p' in the
3841 current row. If we would start writing glyphs there, we
3842 wouldn't erase the lbearing of the `p'. The rest of the
3843 lbearing problem is then taken care of by x_draw_glyphs. */
3844 if (current_row
->contains_overlapping_glyphs_p
3846 && i
< current_row
->used
[TEXT_AREA
]
3847 && current_row
->used
[TEXT_AREA
] != desired_row
->used
[TEXT_AREA
])
3850 rif
->get_glyph_overhangs (current_glyph
, XFRAME (w
->frame
),
3852 while (left
> 0 && i
> 0)
3854 --i
, --desired_glyph
, --current_glyph
;
3855 x
-= desired_glyph
->pixel_width
;
3856 left
-= desired_glyph
->pixel_width
;
3860 /* Try to avoid writing the entire rest of the desired row
3861 by looking for a resync point. This mainly prevents
3862 mode line flickering in the case the mode line is in
3863 fixed-pitch font, which it usually will be. */
3864 if (i
< desired_row
->used
[TEXT_AREA
])
3866 int start_x
= x
, start_hpos
= i
;
3867 struct glyph
*start
= desired_glyph
;
3870 /* Find the next glyph that's equal again. */
3872 && !GLYPH_EQUAL_P (desired_glyph
, current_glyph
)
3875 x
+= desired_glyph
->pixel_width
;
3876 current_x
+= current_glyph
->pixel_width
;
3877 ++desired_glyph
, ++current_glyph
, ++i
;
3880 if (i
== start_hpos
|| x
!= current_x
)
3884 desired_glyph
= start
;
3888 rif
->cursor_to (vpos
, start_hpos
, desired_row
->y
, start_x
);
3889 rif
->write_glyphs (start
, i
- start_hpos
);
3894 /* Write the rest. */
3895 if (i
< desired_row
->used
[TEXT_AREA
])
3897 rif
->cursor_to (vpos
, i
, desired_row
->y
, x
);
3898 rif
->write_glyphs (desired_glyph
, desired_row
->used
[TEXT_AREA
] - i
);
3902 /* Maybe clear to end of line. */
3903 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
3905 /* If new row extends to the end of the text area, nothing
3906 has to be cleared, if and only if we did a write_glyphs
3907 above. This is made sure by setting desired_stop_pos
3908 appropriately above. */
3909 xassert (i
< desired_row
->used
[TEXT_AREA
]);
3911 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
3913 /* If old row extends to the end of the text area, clear. */
3914 if (i
>= desired_row
->used
[TEXT_AREA
])
3915 rif
->cursor_to (vpos
, i
, desired_row
->y
,
3916 desired_row
->x
+ desired_row
->pixel_width
);
3917 rif
->clear_end_of_line (-1);
3920 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
3922 /* Otherwise clear to the end of the old row. Everything
3923 after that position should be clear already. */
3926 if (i
>= desired_row
->used
[TEXT_AREA
])
3927 rif
->cursor_to (vpos
, i
, desired_row
->y
,
3928 desired_row
->x
+ desired_row
->pixel_width
);
3930 /* If cursor is displayed at the end of the line, make sure
3931 it's cleared. Nowadays we don't have a phys_cursor_glyph
3932 with which to erase the cursor (because this method
3933 doesn't work with lbearing/rbearing), so we must do it
3935 if (vpos
== w
->phys_cursor
.vpos
3936 && w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])
3938 w
->phys_cursor_on_p
= 0;
3942 x
= current_row
->x
+ current_row
->pixel_width
;
3943 rif
->clear_end_of_line (x
);
3952 /* Update row VPOS in window W. Value is non-zero if display has been
3956 update_window_line (w
, vpos
)
3960 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3961 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3964 xassert (desired_row
->enabled_p
);
3966 /* Set the row being updated. This is important to let xterm.c
3967 know what line height values are in effect. */
3968 updated_row
= desired_row
;
3970 /* Update display of the left margin area, if there is one. */
3971 if (!desired_row
->full_width_p
3972 && !NILP (w
->left_margin_width
))
3974 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
3978 /* Update the display of the text area. */
3979 changed_p
|= update_text_area (w
, vpos
);
3981 /* Update display of the right margin area, if there is one. */
3982 if (!desired_row
->full_width_p
3983 && !NILP (w
->right_margin_width
))
3986 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
3989 /* Draw truncation marks etc. */
3990 if (!current_row
->enabled_p
3991 || desired_row
->y
!= current_row
->y
3992 || desired_row
->visible_height
!= current_row
->visible_height
3993 || desired_row
->overlay_arrow_p
!= current_row
->overlay_arrow_p
3994 || desired_row
->truncated_on_left_p
!= current_row
->truncated_on_left_p
3995 || desired_row
->truncated_on_right_p
!= current_row
->truncated_on_right_p
3996 || desired_row
->continued_p
!= current_row
->continued_p
3997 || desired_row
->mode_line_p
!= current_row
->mode_line_p
3998 || (desired_row
->indicate_empty_line_p
3999 != current_row
->indicate_empty_line_p
)
4000 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
4001 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
4002 rif
->after_update_window_line_hook (desired_row
);
4004 /* Update current_row from desired_row. */
4005 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4011 /* Set the cursor after an update of window W. This function may only
4012 be called from update_window. */
4015 set_window_cursor_after_update (w
)
4018 struct frame
*f
= XFRAME (w
->frame
);
4019 int cx
, cy
, vpos
, hpos
;
4021 /* Not intended for frame matrix updates. */
4022 xassert (FRAME_WINDOW_P (f
));
4024 if (cursor_in_echo_area
4025 && !NILP (echo_area_buffer
[0])
4026 /* If we are showing a message instead of the mini-buffer,
4027 show the cursor for the message instead. */
4028 && XWINDOW (minibuf_window
) == w
4029 && EQ (minibuf_window
, echo_area_window
)
4030 /* These cases apply only to the frame that contains
4031 the active mini-buffer window. */
4032 && FRAME_HAS_MINIBUF_P (f
)
4033 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4035 cx
= cy
= vpos
= hpos
= 0;
4037 if (cursor_in_echo_area
>= 0)
4039 /* If the mini-buffer is several lines high, find the last
4040 line that has any text on it. Note: either all lines
4041 are enabled or none. Otherwise we wouldn't be able to
4043 struct glyph_row
*row
, *last_row
;
4044 struct glyph
*glyph
;
4045 int yb
= window_text_bottom_y (w
);
4048 for (row
= MATRIX_ROW (w
->current_matrix
, 0);
4052 if (row
->used
[TEXT_AREA
]
4053 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4056 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4062 struct glyph
*start
= row
->glyphs
[TEXT_AREA
];
4063 struct glyph
*last
= start
+ row
->used
[TEXT_AREA
] - 1;
4065 while (last
> start
&& last
->charpos
< 0)
4068 for (glyph
= start
; glyph
< last
; ++glyph
)
4070 cx
+= glyph
->pixel_width
;
4075 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4083 hpos
= w
->cursor
.hpos
;
4084 vpos
= w
->cursor
.vpos
;
4087 /* Window cursor can be out of sync for horizontally split windows. */
4088 hpos
= max (0, hpos
);
4089 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4090 vpos
= max (0, vpos
);
4091 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4092 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4096 /* Try to reuse part of the current display of W by scrolling lines.
4097 HEADER_LINE_P non-zero means W has a top mode line.
4099 The algorithm is taken from Communications of the ACM, Apr78 "A
4100 Technique for Isolating Differences Between Files." It should take
4103 A short outline of the steps of the algorithm
4105 1. Skip lines equal at the start and end of both matrices.
4107 2. Enter rows in the current and desired matrix into a symbol
4108 table, counting how often they appear in both matrices.
4110 3. Rows that appear exactly once in both matrices serve as anchors,
4111 i.e. we assume that such lines are likely to have been moved.
4113 4. Starting from anchor lines, extend regions to be scrolled both
4114 forward and backward.
4118 -1 if all rows were found to be equal.
4119 0 to indicate that we did not scroll the display, or
4120 1 if we did scroll. */
4123 scrolling_window (w
, header_line_p
)
4129 /* Number of occurrences of this line in old and new matrix. */
4130 short old_uses
, new_uses
;
4132 /* Vpos of line in new matrix. */
4133 short new_line_number
;
4135 /* The line itself. */
4136 struct glyph_row
*row
;
4138 /* Hash collision chain. */
4139 struct symbol
*next
;
4142 int SYMBOL_TABLE_SIZE
= 101;
4143 struct symbol
**table
;
4144 struct symbol
**old_line_syms
, **new_line_syms
;
4145 int i
, j
, first_old
, first_new
, last_old
, last_new
;
4149 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4150 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4151 int yb
= window_text_bottom_y (w
);
4153 /* Skip over rows equal at the start. */
4154 i
= header_line_p
? 1 : 0;
4155 while (i
< current_matrix
->nrows
- 1
4156 && MATRIX_ROW_ENABLED_P (current_matrix
, i
)
4157 && MATRIX_ROW_ENABLED_P (desired_matrix
, i
)
4158 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) < yb
4159 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) < yb
4161 MATRIX_ROW (desired_matrix
, i
),
4162 MATRIX_ROW (current_matrix
, i
)))
4164 assign_row (MATRIX_ROW (current_matrix
, i
),
4165 MATRIX_ROW (desired_matrix
, i
));
4166 MATRIX_ROW (desired_matrix
, i
)->enabled_p
= 0;
4170 /* Give up if some rows in the desired matrix are not enabled. */
4171 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4174 first_old
= first_new
= i
;
4176 /* Set last_new to the index + 1 of the last enabled row in the
4179 while (i
< desired_matrix
->nrows
- 1
4180 && MATRIX_ROW (desired_matrix
, i
)->enabled_p
4181 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) < yb
)
4184 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4189 /* Set last_old to the index + 1 of the last enabled row in the
4190 current matrix. We don't look at the enabled flag here because
4191 we plan to reuse part of the display even if other parts are
4194 while (i
< current_matrix
->nrows
- 1
4195 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
)) < yb
)
4199 /* Skip over rows equal at the bottom. */
4202 while (i
- 1 > first_new
4203 && j
- 1 > first_old
4204 && MATRIX_ROW (current_matrix
, i
- 1)->enabled_p
4205 && (MATRIX_ROW (current_matrix
, i
- 1)->y
4206 == MATRIX_ROW (desired_matrix
, j
- 1)->y
)
4208 MATRIX_ROW (desired_matrix
, i
- 1),
4209 MATRIX_ROW (current_matrix
, j
- 1)))
4214 /* Nothing to do if all rows are equal. */
4215 if (last_new
== first_new
)
4218 /* Allocate a hash table in which all rows will be inserted. */
4219 table
= (struct symbol
**) alloca (SYMBOL_TABLE_SIZE
* sizeof *table
);
4220 bzero (table
, SYMBOL_TABLE_SIZE
* sizeof *table
);
4222 /* For each row in the current matrix, record the symbol belonging
4223 to the row in OLD_LINE_SYMS. */
4224 old_line_syms
= (struct symbol
**) alloca (current_matrix
->nrows
4225 * sizeof *old_line_syms
);
4226 new_line_syms
= (struct symbol
**) alloca (desired_matrix
->nrows
4227 * sizeof *new_line_syms
);
4229 #define ADDSYM(ROW) \
4232 struct glyph_row *row_ = (ROW); \
4233 int i_ = row_->hash % SYMBOL_TABLE_SIZE; \
4235 while (sym && !row_equal_p (w, sym->row, row_)) \
4239 sym = (struct symbol *) alloca (sizeof *sym); \
4241 sym->old_uses = sym->new_uses = 0; \
4242 sym->next = table[i_]; \
4248 /* Add current rows to the symbol table. */
4249 for (i
= first_old
; i
< last_old
; ++i
)
4251 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4253 ADDSYM (MATRIX_ROW (current_matrix
, i
));
4254 old_line_syms
[i
] = sym
;
4258 old_line_syms
[i
] = NULL
;
4261 /* Add desired rows to the symbol table. */
4262 for (i
= first_new
; i
< last_new
; ++i
)
4264 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4265 ADDSYM (MATRIX_ROW (desired_matrix
, i
));
4267 new_line_syms
[i
] = sym
;
4268 sym
->new_line_number
= i
;
4273 /* Record in runs which moves were found, ordered by pixel
4274 height of copied areas. */
4276 runs
= (struct run
**) alloca (desired_matrix
->nrows
* sizeof *runs
);
4278 /* Identify moves based on lines that are unique and equal
4279 in both matrices. */
4280 for (i
= first_old
; i
< last_old
;)
4281 if (old_line_syms
[i
]
4282 && old_line_syms
[i
]->old_uses
== 1
4283 && old_line_syms
[i
]->new_uses
== 1)
4286 int new_line
= old_line_syms
[i
]->new_line_number
;
4287 struct run
*run
= (struct run
*) alloca (sizeof *run
);
4290 run
->current_vpos
= i
;
4291 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4292 run
->desired_vpos
= new_line
;
4293 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4295 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4297 /* Extend backward. */
4300 while (j
> first_old
4302 && old_line_syms
[j
] == new_line_syms
[k
])
4304 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4305 --run
->current_vpos
;
4306 --run
->desired_vpos
;
4309 run
->desired_y
-= h
;
4310 run
->current_y
-= h
;
4314 /* Extend forward. */
4319 && old_line_syms
[j
] == new_line_syms
[k
])
4321 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4327 /* Insert run into list of all runs. Order runs by copied
4328 pixel lines. Note that we record runs that don't have to
4329 be copied because they are already in place. This is done
4330 because we can avoid calling update_window_line in this
4332 for (j
= 0; j
< nruns
&& runs
[j
]->height
> run
->height
; ++j
)
4334 for (k
= nruns
; k
>= j
; --k
)
4335 runs
[k
] = runs
[k
- 1];
4344 /* Do the moves. Do it in a way that we don't overwrite something
4345 we want to copy later on. This is not solvable in general
4346 because there is only one display and we don't have a way to
4347 exchange areas on this display. Example:
4349 +-----------+ +-----------+
4351 +-----------+ --> +-----------+
4353 +-----------+ +-----------+
4355 Instead, prefer bigger moves, and invalidate moves that would
4356 copy from where we copied to. */
4358 for (i
= 0; i
< nruns
; ++i
)
4359 if (runs
[i
]->nrows
> 0)
4361 struct run
*r
= runs
[i
];
4363 /* Copy on the display. */
4364 if (r
->current_y
!= r
->desired_y
)
4366 rif
->scroll_run_hook (w
, r
);
4368 /* Invalidate runs that copy from where we copied to. */
4369 for (j
= i
+ 1; j
< nruns
; ++j
)
4371 struct run
*p
= runs
[j
];
4373 if ((p
->current_y
>= r
->desired_y
4374 && p
->current_y
< r
->desired_y
+ r
->height
)
4375 || (p
->current_y
+ p
->height
>= r
->desired_y
4376 && (p
->current_y
+ p
->height
4377 < r
->desired_y
+ r
->height
)))
4382 /* Assign matrix rows. */
4383 for (j
= 0; j
< r
->nrows
; ++j
)
4385 struct glyph_row
*from
, *to
;
4386 int to_overlapped_p
;
4388 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
4389 to_overlapped_p
= to
->overlapped_p
;
4390 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
4391 assign_row (to
, from
);
4392 to
->enabled_p
= 1, from
->enabled_p
= 0;
4393 to
->overlapped_p
= to_overlapped_p
;
4397 /* Value is non-zero to indicate that we scrolled the display. */
4402 /* Set WINDOW->must_be_updated_p TO ON_P for all windows WINDOW in the
4403 window tree rooted at W. */
4406 set_window_update_flags (w
, on_p
)
4412 if (!NILP (w
->hchild
))
4413 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4414 else if (!NILP (w
->vchild
))
4415 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4417 w
->must_be_updated_p
= on_p
;
4419 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4425 /************************************************************************
4427 ************************************************************************/
4429 /* Update the desired frame matrix of frame F.
4431 FORCE_P non-zero means that the update should not be stopped by
4432 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
4433 should not be tried.
4435 Value is non-zero if update was stopped due to pending input. */
4438 update_frame_1 (f
, force_p
, inhibit_id_p
)
4443 /* Frame matrices to work on. */
4444 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4445 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4448 int preempt_count
= baud_rate
/ 2400 + 1;
4449 extern int input_pending
;
4451 xassert (current_matrix
&& desired_matrix
);
4453 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
4454 calculate_costs (f
);
4456 if (preempt_count
<= 0)
4459 detect_input_pending ();
4460 if (input_pending
&& !force_p
)
4468 /* If we cannot insert/delete lines, it's no use trying it. */
4469 if (!line_ins_del_ok
)
4472 /* See if any of the desired lines are enabled; don't compute for
4473 i/d line if just want cursor motion. */
4474 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
4475 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4478 /* Try doing i/d line, if not yet inhibited. */
4479 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
4480 force_p
|= scrolling (f
);
4482 /* Update the individual lines as needed. Do bottom line first. */
4483 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
4484 update_frame_line (f
, desired_matrix
->nrows
- 1);
4486 /* Now update the rest of the lines. */
4487 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
4489 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4491 if (FRAME_TERMCAP_P (f
))
4493 /* Flush out every so many lines.
4494 Also flush out if likely to have more than 1k buffered
4495 otherwise. I'm told that some telnet connections get
4496 really screwed by more than 1k output at once. */
4497 int outq
= PENDING_OUTPUT_COUNT (stdout
);
4499 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
4502 if (preempt_count
== 1)
4504 #ifdef EMACS_OUTQSIZE
4505 if (EMACS_OUTQSIZE (0, &outq
) < 0)
4506 /* Probably not a tty. Ignore the error and reset
4507 * the outq count. */
4508 outq
= PENDING_OUTPUT_COUNT (stdout
);
4511 if (baud_rate
<= outq
&& baud_rate
> 0)
4512 sleep (outq
/ baud_rate
);
4517 if ((i
- 1) % preempt_count
== 0)
4518 detect_input_pending ();
4520 update_frame_line (f
, i
);
4524 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
4526 /* Now just clean up termcap drivers and set cursor, etc. */
4529 if ((cursor_in_echo_area
4530 /* If we are showing a message instead of the mini-buffer,
4531 show the cursor for the message instead of for the
4532 (now hidden) mini-buffer contents. */
4533 || (EQ (minibuf_window
, selected_window
)
4534 && EQ (minibuf_window
, echo_area_window
)
4535 && !NILP (echo_area_buffer
[0])))
4536 /* These cases apply only to the frame that contains
4537 the active mini-buffer window. */
4538 && FRAME_HAS_MINIBUF_P (f
)
4539 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4541 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
4544 if (cursor_in_echo_area
< 0)
4546 /* Negative value of cursor_in_echo_area means put
4547 cursor at beginning of line. */
4553 /* Positive value of cursor_in_echo_area means put
4554 cursor at the end of the prompt. If the mini-buffer
4555 is several lines high, find the last line that has
4557 row
= FRAME_HEIGHT (f
);
4563 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
4565 /* Frame rows are filled up with spaces that
4566 must be ignored here. */
4567 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
4569 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
4570 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
4573 && (last
- 1)->charpos
< 0)
4579 while (row
> top
&& col
== 0);
4581 /* Make sure COL is not out of range. */
4582 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
4584 /* If we have another row, advance cursor into it. */
4585 if (row
< FRAME_HEIGHT (f
) - 1)
4587 col
= FRAME_LEFT_SCROLL_BAR_WIDTH (f
);
4590 /* Otherwise move it back in range. */
4592 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
4596 cursor_to (row
, col
);
4600 /* We have only one cursor on terminal frames. Use it to
4601 display the cursor of the selected window. */
4602 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
4603 if (w
->cursor
.vpos
>= 0)
4605 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
4606 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
4608 if (INTEGERP (w
->left_margin_width
))
4609 x
+= XFASTINT (w
->left_margin_width
);
4611 /* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
4620 fflush (termscript
);
4625 display_completed
= !pause
;
4626 clear_desired_matrices (f
);
4631 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4635 struct frame
*frame
;
4637 int unchanged_at_top
, unchanged_at_bottom
;
4640 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4641 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4642 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4643 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
4645 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
4646 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4647 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4649 if (!current_matrix
)
4652 /* Compute hash codes of all the lines. Also calculate number of
4653 changed lines, number of unchanged lines at the beginning, and
4654 number of unchanged lines at the end. */
4656 unchanged_at_top
= 0;
4657 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
4658 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
4660 /* Give up on this scrolling if some old lines are not enabled. */
4661 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
4663 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
4664 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4666 /* This line cannot be redrawn, so don't let scrolling mess it. */
4667 new_hash
[i
] = old_hash
[i
];
4668 #define INFINITY 1000000 /* Taken from scroll.c */
4669 draw_cost
[i
] = INFINITY
;
4673 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
4674 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
4677 if (old_hash
[i
] != new_hash
[i
])
4680 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
4682 else if (i
== unchanged_at_top
)
4684 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
4687 /* If changed lines are few, don't allow preemption, don't scroll. */
4688 if ((!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400)
4689 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
4692 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
4693 - unchanged_at_bottom
);
4695 if (scroll_region_ok
)
4696 free_at_end_vpos
-= unchanged_at_bottom
;
4697 else if (memory_below_frame
)
4698 free_at_end_vpos
= -1;
4700 /* If large window, fast terminal and few lines in common between
4701 current frame and desired frame, don't bother with i/d calc. */
4702 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
4704 10 * scrolling_max_lines_saved (unchanged_at_top
,
4705 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
4706 old_hash
, new_hash
, draw_cost
)))
4709 if (window_size
< 2)
4712 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
4713 draw_cost
+ unchanged_at_top
- 1,
4714 old_draw_cost
+ unchanged_at_top
- 1,
4715 old_hash
+ unchanged_at_top
- 1,
4716 new_hash
+ unchanged_at_top
- 1,
4717 free_at_end_vpos
- unchanged_at_top
);
4723 /* Count the number of blanks at the start of the vector of glyphs R
4724 which is LEN glyphs long. */
4727 count_blanks (r
, len
)
4733 for (i
= 0; i
< len
; ++i
)
4734 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
4741 /* Count the number of glyphs in common at the start of the glyph
4742 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
4743 of STR2. Value is the number of equal glyphs equal at the start. */
4746 count_match (str1
, end1
, str2
, end2
)
4747 struct glyph
*str1
, *end1
, *str2
, *end2
;
4749 struct glyph
*p1
= str1
;
4750 struct glyph
*p2
= str2
;
4754 && GLYPH_FROM_CHAR_GLYPH (*p1
) == GLYPH_FROM_CHAR_GLYPH (*p2
))
4761 /* Char insertion/deletion cost vector, from term.c */
4763 extern int *char_ins_del_vector
;
4764 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
4767 /* Perform a frame-based update on line VPOS in frame FRAME. */
4770 update_frame_line (frame
, vpos
)
4771 register struct frame
*frame
;
4774 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
4776 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
4777 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4778 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4779 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
4780 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
4781 int must_write_whole_line_p
;
4783 if (desired_row
->inverse_p
4784 != (current_row
->enabled_p
&& current_row
->inverse_p
))
4786 int n
= current_row
->enabled_p
? current_row
->used
[TEXT_AREA
] : 0;
4787 change_line_highlight (desired_row
->inverse_p
, vpos
, vpos
, n
);
4788 current_row
->enabled_p
= 0;
4791 reassert_line_highlight (desired_row
->inverse_p
, vpos
);
4793 /* Current row not enabled means it has unknown contents. We must
4794 write the whole desired line in that case. */
4795 must_write_whole_line_p
= !current_row
->enabled_p
;
4796 if (must_write_whole_line_p
)
4803 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
4804 olen
= current_row
->used
[TEXT_AREA
];
4806 if (! current_row
->inverse_p
)
4808 /* Ignore trailing spaces, if we can. */
4809 if (!must_write_spaces
)
4810 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
4815 /* For an inverse-video line, make sure it's filled with
4816 spaces all the way to the frame edge so that the reverse
4817 video extends all the way across. */
4818 while (olen
< FRAME_WIDTH (frame
) - 1)
4819 obody
[olen
++] = space_glyph
;
4823 current_row
->enabled_p
= 1;
4824 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
4825 current_row
->inverse_p
= desired_row
->inverse_p
;
4827 /* If desired line is empty, just clear the line. */
4828 if (!desired_row
->enabled_p
)
4834 nbody
= desired_row
->glyphs
[TEXT_AREA
];
4835 nlen
= desired_row
->used
[TEXT_AREA
];
4836 nend
= nbody
+ nlen
;
4838 /* If display line has unknown contents, write the whole line. */
4839 if (must_write_whole_line_p
)
4841 /* Ignore spaces at the end, if we can. */
4842 if (!must_write_spaces
)
4843 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4846 /* Write the contents of the desired line. */
4849 cursor_to (vpos
, 0);
4850 write_glyphs (nbody
, nlen
);
4853 /* Don't call clear_end_of_line if we already wrote the whole
4854 line. The cursor will not be at the right margin in that
4855 case but in the line below. */
4856 if (nlen
< FRAME_WINDOW_WIDTH (frame
))
4858 cursor_to (vpos
, nlen
);
4859 clear_end_of_line (FRAME_WINDOW_WIDTH (frame
));
4862 make_current (desired_matrix
, current_matrix
, vpos
);
4866 /* Pretend trailing spaces are not there at all,
4867 unless for one reason or another we must write all spaces. */
4868 if (!desired_row
->inverse_p
)
4870 if (!must_write_spaces
)
4871 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4876 /* For an inverse-video line, give it extra trailing spaces all
4877 the way to the frame edge so that the reverse video extends
4878 all the way across. */
4879 while (nlen
< FRAME_WIDTH (frame
) - 1)
4880 nbody
[nlen
++] = space_glyph
;
4883 /* If there's no i/d char, quickly do the best we can without it. */
4884 if (!char_ins_del_ok
)
4888 /* Find the first glyph in desired row that doesn't agree with
4889 a glyph in the current row, and write the rest from there on. */
4890 for (i
= 0; i
< nlen
; i
++)
4892 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
4894 /* Find the end of the run of different glyphs. */
4898 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
4899 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
4902 /* Output this run of non-matching chars. */
4903 cursor_to (vpos
, i
);
4904 write_glyphs (nbody
+ i
, j
- i
);
4907 /* Now find the next non-match. */
4911 /* Clear the rest of the line, or the non-clear part of it. */
4914 cursor_to (vpos
, nlen
);
4915 clear_end_of_line (olen
);
4918 /* Make current row = desired row. */
4919 make_current (desired_matrix
, current_matrix
, vpos
);
4923 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
4924 characters in a row. */
4928 /* If current line is blank, skip over initial spaces, if
4929 possible, and write the rest. */
4930 if (must_write_spaces
|| desired_row
->inverse_p
)
4933 nsp
= count_blanks (nbody
, nlen
);
4937 cursor_to (vpos
, nsp
);
4938 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
4941 /* Exchange contents between current_frame and new_frame. */
4942 make_current (desired_matrix
, current_matrix
, vpos
);
4946 /* Compute number of leading blanks in old and new contents. */
4947 osp
= count_blanks (obody
, olen
);
4948 nsp
= desired_row
->inverse_p
? 0 : count_blanks (nbody
, nlen
);
4950 /* Compute number of matching chars starting with first non-blank. */
4951 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
4952 nbody
+ nsp
, nbody
+ nlen
);
4954 /* Spaces in new match implicit space past the end of old. */
4955 /* A bug causing this to be a no-op was fixed in 18.29. */
4956 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
4959 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
4963 /* Avoid doing insert/delete char
4964 just cause number of leading spaces differs
4965 when the following text does not match. */
4966 if (begmatch
== 0 && osp
!= nsp
)
4967 osp
= nsp
= min (osp
, nsp
);
4969 /* Find matching characters at end of line */
4972 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
4974 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
4979 endmatch
= obody
+ olen
- op1
;
4981 /* tem gets the distance to insert or delete.
4982 endmatch is how many characters we save by doing so.
4985 tem
= (nlen
- nsp
) - (olen
- osp
);
4987 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
4990 /* nsp - osp is the distance to insert or delete.
4991 If that is nonzero, begmatch is known to be nonzero also.
4992 begmatch + endmatch is how much we save by doing the ins/del.
4996 && (!char_ins_del_ok
4997 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
5001 osp
= nsp
= min (osp
, nsp
);
5004 /* Now go through the line, inserting, writing and
5005 deleting as appropriate. */
5009 cursor_to (vpos
, nsp
);
5010 delete_glyphs (osp
- nsp
);
5014 /* If going to delete chars later in line
5015 and insert earlier in the line,
5016 must delete first to avoid losing data in the insert */
5017 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
5019 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
5020 delete_glyphs (olen
+ nsp
- osp
- nlen
);
5021 olen
= nlen
- (nsp
- osp
);
5023 cursor_to (vpos
, osp
);
5024 insert_glyphs (0, nsp
- osp
);
5028 tem
= nsp
+ begmatch
+ endmatch
;
5029 if (nlen
!= tem
|| olen
!= tem
)
5031 cursor_to (vpos
, nsp
+ begmatch
);
5032 if (!endmatch
|| nlen
== olen
)
5034 /* If new text being written reaches right margin,
5035 there is no need to do clear-to-eol at the end.
5036 (and it would not be safe, since cursor is not
5037 going to be "at the margin" after the text is done) */
5038 if (nlen
== FRAME_WINDOW_WIDTH (frame
))
5040 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5042 else if (nlen
> olen
)
5044 /* Here, we used to have the following simple code:
5045 ----------------------------------------
5046 write_glyphs (nbody + nsp + begmatch, olen - tem);
5047 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5048 ----------------------------------------
5049 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5050 is a padding glyph. */
5051 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5054 /* Calculate columns we can actually overwrite. */
5055 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
])) out
--;
5056 write_glyphs (nbody
+ nsp
+ begmatch
, out
);
5057 /* If we left columns to be overwritten, we must delete them. */
5058 del
= olen
- tem
- out
;
5059 if (del
> 0) delete_glyphs (del
);
5060 /* At last, we insert columns not yet written out. */
5061 insert_glyphs (nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5064 else if (olen
> nlen
)
5066 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5067 delete_glyphs (olen
- nlen
);
5073 /* If any unerased characters remain after the new line, erase them. */
5076 cursor_to (vpos
, nlen
);
5077 clear_end_of_line (olen
);
5080 /* Exchange contents between current_frame and new_frame. */
5081 make_current (desired_matrix
, current_matrix
, vpos
);
5086 /***********************************************************************
5087 X/Y Position -> Buffer Position
5088 ***********************************************************************/
5090 /* Return the character position of the character at window relative
5091 pixel position (*X, *Y). *X and *Y are adjusted to character
5095 buffer_posn_from_coords (w
, x
, y
)
5100 struct buffer
*old_current_buffer
= current_buffer
;
5101 struct text_pos startp
;
5102 int left_area_width
;
5104 current_buffer
= XBUFFER (w
->buffer
);
5105 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5106 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5107 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5108 start_display (&it
, w
, startp
);
5110 left_area_width
= WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH (w
);
5111 move_it_to (&it
, -1, *x
+ it
.first_visible_x
- left_area_width
, *y
, -1,
5112 MOVE_TO_X
| MOVE_TO_Y
);
5114 *x
= it
.current_x
- it
.first_visible_x
+ left_area_width
;
5116 current_buffer
= old_current_buffer
;
5117 return IT_CHARPOS (it
);
5121 /* Value is the string under window-relative coordinates X/Y in the
5122 mode or top line of window W, or nil if none. MODE_LINE_P non-zero
5123 means look at the mode line. *CHARPOS is set to the position in
5124 the string returned. */
5127 mode_line_string (w
, x
, y
, mode_line_p
, charpos
)
5132 struct glyph_row
*row
;
5133 struct glyph
*glyph
, *end
;
5134 struct frame
*f
= XFRAME (w
->frame
);
5136 Lisp_Object string
= Qnil
;
5138 /* Only do this for frames under a window system. */
5139 if (!FRAME_WINDOW_P (f
))
5143 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5145 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
5147 if (row
->mode_line_p
&& row
->enabled_p
)
5149 /* The mode lines are displayed over scroll bars and bitmap
5150 areas, and X is window-relative. Correct X by the scroll bar
5151 and bitmap area width. */
5152 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
5153 x
+= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
5154 x
+= FRAME_LEFT_FLAGS_AREA_WIDTH (f
);
5156 /* Find the glyph under X. If we find one with a string object,
5157 it's the one we were looking for. */
5158 glyph
= row
->glyphs
[TEXT_AREA
];
5159 end
= glyph
+ row
->used
[TEXT_AREA
];
5160 for (x0
= 0; glyph
< end
; x0
+= glyph
->pixel_width
, ++glyph
)
5161 if (x
>= x0
&& x
< x0
+ glyph
->pixel_width
)
5163 string
= glyph
->object
;
5164 *charpos
= glyph
->charpos
;
5173 /***********************************************************************
5174 Changing Frame Sizes
5175 ***********************************************************************/
5180 window_change_signal (signalnum
) /* If we don't have an argument, */
5181 int signalnum
; /* some compilers complain in signal calls. */
5185 int old_errno
= errno
;
5187 get_frame_size (&width
, &height
);
5189 /* The frame size change obviously applies to a termcap-controlled
5190 frame. Find such a frame in the list, and assume it's the only
5191 one (since the redisplay code always writes to stdout, not a
5192 FILE * specified in the frame structure). Record the new size,
5193 but don't reallocate the data structures now. Let that be done
5194 later outside of the signal handler. */
5197 Lisp_Object tail
, frame
;
5199 FOR_EACH_FRAME (tail
, frame
)
5201 if (FRAME_TERMCAP_P (XFRAME (frame
)))
5203 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5209 signal (SIGWINCH
, window_change_signal
);
5212 #endif /* SIGWINCH */
5215 /* Do any change in frame size that was requested by a signal. SAFE
5216 non-zero means this function is called from a place where it is
5217 safe to change frame sizes while a redisplay is in progress. */
5220 do_pending_window_change (safe
)
5223 /* If window_change_signal should have run before, run it now. */
5224 if (redisplaying_p
&& !safe
)
5227 while (delayed_size_change
)
5229 Lisp_Object tail
, frame
;
5231 delayed_size_change
= 0;
5233 FOR_EACH_FRAME (tail
, frame
)
5235 struct frame
*f
= XFRAME (frame
);
5237 int height
= FRAME_NEW_HEIGHT (f
);
5238 int width
= FRAME_NEW_WIDTH (f
);
5240 if (height
!= 0 || width
!= 0)
5241 change_frame_size (f
, height
, width
, 0, 0, safe
);
5247 /* Change the frame height and/or width. Values may be given as zero to
5248 indicate no change is to take place.
5250 If DELAY is non-zero, then assume we're being called from a signal
5251 handler, and queue the change for later - perhaps the next
5252 redisplay. Since this tries to resize windows, we can't call it
5253 from a signal handler.
5255 SAFE non-zero means this function is called from a place where it's
5256 safe to change frame sizes while a redisplay is in progress. */
5259 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5260 register struct frame
*f
;
5261 int newheight
, newwidth
, pretend
, delay
, safe
;
5263 Lisp_Object tail
, frame
;
5265 if (! FRAME_WINDOW_P (f
))
5267 /* When using termcap, or on MS-DOS, all frames use
5268 the same screen, so a change in size affects all frames. */
5269 FOR_EACH_FRAME (tail
, frame
)
5270 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5271 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5272 pretend
, delay
, safe
);
5275 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
5279 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5280 register struct frame
*f
;
5281 int newheight
, newwidth
, pretend
, delay
, safe
;
5283 int new_frame_window_width
;
5284 int count
= specpdl_ptr
- specpdl
;
5286 /* If we can't deal with the change now, queue it for later. */
5287 if (delay
|| (redisplaying_p
&& !safe
))
5289 FRAME_NEW_HEIGHT (f
) = newheight
;
5290 FRAME_NEW_WIDTH (f
) = newwidth
;
5291 delayed_size_change
= 1;
5295 /* This size-change overrides any pending one for this frame. */
5296 FRAME_NEW_HEIGHT (f
) = 0;
5297 FRAME_NEW_WIDTH (f
) = 0;
5299 /* If an argument is zero, set it to the current value. */
5301 newheight
= FRAME_HEIGHT (f
);
5303 newwidth
= FRAME_WIDTH (f
);
5305 /* Compute width of windows in F.
5306 This is the width of the frame without vertical scroll bars. */
5307 new_frame_window_width
= FRAME_WINDOW_WIDTH_ARG (f
, newwidth
);
5309 /* Round up to the smallest acceptable size. */
5310 check_frame_size (f
, &newheight
, &newwidth
);
5312 /* If we're not changing the frame size, quit now. */
5313 if (newheight
== FRAME_HEIGHT (f
)
5314 && new_frame_window_width
== FRAME_WINDOW_WIDTH (f
))
5320 /* We only can set screen dimensions to certain values supported
5321 by our video hardware. Try to find the smallest size greater
5322 or equal to the requested dimensions. */
5323 dos_set_window_size (&newheight
, &newwidth
);
5326 if (newheight
!= FRAME_HEIGHT (f
))
5328 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
5330 /* Frame has both root and mini-buffer. */
5331 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f
))->top
,
5332 FRAME_TOP_MARGIN (f
));
5333 set_window_height (FRAME_ROOT_WINDOW (f
),
5336 - FRAME_TOP_MARGIN (f
)),
5338 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
,
5340 set_window_height (FRAME_MINIBUF_WINDOW (f
), 1, 0);
5343 /* Frame has just one top-level window. */
5344 set_window_height (FRAME_ROOT_WINDOW (f
),
5345 newheight
- FRAME_TOP_MARGIN (f
), 0);
5347 if (FRAME_TERMCAP_P (f
) && !pretend
)
5348 FrameRows
= newheight
;
5351 if (new_frame_window_width
!= FRAME_WINDOW_WIDTH (f
))
5353 set_window_width (FRAME_ROOT_WINDOW (f
), new_frame_window_width
, 0);
5354 if (FRAME_HAS_MINIBUF_P (f
))
5355 set_window_width (FRAME_MINIBUF_WINDOW (f
), new_frame_window_width
, 0);
5357 if (FRAME_TERMCAP_P (f
) && !pretend
)
5358 FrameCols
= newwidth
;
5360 if (WINDOWP (f
->tool_bar_window
))
5361 XSETFASTINT (XWINDOW (f
->tool_bar_window
)->width
, newwidth
);
5364 FRAME_HEIGHT (f
) = newheight
;
5365 SET_FRAME_WIDTH (f
, newwidth
);
5368 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5369 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
5371 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
5373 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
5374 w
->cursor
.hpos
= w
->cursor
.x
= 0;
5375 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
5376 w
->cursor
.vpos
= w
->cursor
.y
= 0;
5380 SET_FRAME_GARBAGED (f
);
5381 calculate_costs (f
);
5385 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
5387 /* This isn't quite a no-op: it runs window-configuration-change-hook. */
5388 Fset_window_buffer (FRAME_SELECTED_WINDOW (f
),
5389 XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
);
5391 unbind_to (count
, Qnil
);
5396 /***********************************************************************
5397 Terminal Related Lisp Functions
5398 ***********************************************************************/
5400 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
5401 1, 1, "FOpen termscript file: ",
5402 "Start writing all terminal output to FILE as well as the terminal.\n\
5403 FILE = nil means just close any termscript file currently open.")
5407 if (termscript
!= 0) fclose (termscript
);
5412 file
= Fexpand_file_name (file
, Qnil
);
5413 termscript
= fopen (XSTRING (file
)->data
, "w");
5414 if (termscript
== 0)
5415 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
5421 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
5422 Ssend_string_to_terminal
, 1, 1, 0,
5423 "Send STRING to the terminal without alteration.\n\
5424 Control characters in STRING will have terminal-dependent effects.")
5428 /* ??? Perhaps we should do something special for multibyte strings here. */
5429 CHECK_STRING (string
, 0);
5430 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)), stdout
);
5434 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)),
5436 fflush (termscript
);
5442 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
5443 "Beep, or flash the screen.\n\
5444 Also, unless an argument is given,\n\
5445 terminate any keyboard macro currently executing.")
5468 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
5469 error ("Keyboard macro terminated by a command ringing the bell");
5477 /***********************************************************************
5479 ***********************************************************************/
5481 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
5482 "Pause, without updating display, for SECONDS seconds.\n\
5483 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5484 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5485 additional wait period, in milliseconds; this may be useful if your\n\
5486 Emacs was built without floating point support.\n\
5487 \(Not all operating systems support waiting for a fraction of a second.)")
5488 (seconds
, milliseconds
)
5489 Lisp_Object seconds
, milliseconds
;
5493 if (NILP (milliseconds
))
5494 XSETINT (milliseconds
, 0);
5496 CHECK_NUMBER (milliseconds
, 1);
5497 usec
= XINT (milliseconds
) * 1000;
5499 #ifdef LISP_FLOAT_TYPE
5501 double duration
= extract_float (seconds
);
5502 sec
= (int) duration
;
5503 usec
+= (duration
- sec
) * 1000000;
5506 CHECK_NUMBER (seconds
, 0);
5507 sec
= XINT (seconds
);
5510 #ifndef EMACS_HAS_USECS
5511 if (sec
== 0 && usec
!= 0)
5512 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
5515 /* Assure that 0 <= usec < 1000000. */
5518 /* We can't rely on the rounding being correct if user is negative. */
5519 if (-1000000 < usec
)
5520 sec
--, usec
+= 1000000;
5522 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
5525 sec
+= usec
/ 1000000, usec
%= 1000000;
5527 if (sec
< 0 || (sec
== 0 && usec
== 0))
5533 XSETFASTINT (zero
, 0);
5534 wait_reading_process_input (sec
, usec
, zero
, 0);
5537 /* We should always have wait_reading_process_input; we have a dummy
5538 implementation for systems which don't support subprocesses. */
5540 /* No wait_reading_process_input */
5547 /* The reason this is done this way
5548 (rather than defined (H_S) && defined (H_T))
5549 is because the VMS preprocessor doesn't grok `defined' */
5551 EMACS_GET_TIME (end_time
);
5552 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
5553 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
5557 EMACS_GET_TIME (timeout
);
5558 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
5559 if (EMACS_TIME_NEG_P (timeout
)
5560 || !select (1, 0, 0, 0, &timeout
))
5563 #else /* not HAVE_SELECT */
5565 #endif /* HAVE_SELECT */
5566 #endif /* not VMS */
5569 #endif /* no subprocesses */
5575 /* This is just like wait_reading_process_input, except that
5576 it does the redisplay.
5578 It's also much like Fsit_for, except that it can be used for
5579 waiting for input as well. */
5582 sit_for (sec
, usec
, reading
, display
, initial_display
)
5583 int sec
, usec
, reading
, display
, initial_display
;
5585 Lisp_Object read_kbd
;
5587 swallow_events (display
);
5589 if (detect_input_pending_run_timers (display
))
5592 if (initial_display
)
5593 redisplay_preserve_echo_area ();
5595 if (sec
== 0 && usec
== 0)
5602 XSETINT (read_kbd
, reading
? -1 : 1);
5603 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
5605 return detect_input_pending () ? Qnil
: Qt
;
5609 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
5610 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
5611 SECONDS may be a floating-point value, meaning that you can wait for a\n\
5612 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
5613 additional wait period, in milliseconds; this may be useful if your\n\
5614 Emacs was built without floating point support.\n\
5615 \(Not all operating systems support waiting for a fraction of a second.)\n\
5616 Optional third arg NODISP non-nil means don't redisplay, just wait for input.\n\
5617 Redisplay is preempted as always if input arrives, and does not happen\n\
5618 if input is available before it starts.\n\
5619 Value is t if waited the full time with no input arriving.")
5620 (seconds
, milliseconds
, nodisp
)
5621 Lisp_Object seconds
, milliseconds
, nodisp
;
5625 if (NILP (milliseconds
))
5626 XSETINT (milliseconds
, 0);
5628 CHECK_NUMBER (milliseconds
, 1);
5629 usec
= XINT (milliseconds
) * 1000;
5631 #ifdef LISP_FLOAT_TYPE
5633 double duration
= extract_float (seconds
);
5634 sec
= (int) duration
;
5635 usec
+= (duration
- sec
) * 1000000;
5638 CHECK_NUMBER (seconds
, 0);
5639 sec
= XINT (seconds
);
5642 #ifndef EMACS_HAS_USECS
5643 if (usec
!= 0 && sec
== 0)
5644 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
5647 return sit_for (sec
, usec
, 0, NILP (nodisp
), NILP (nodisp
));
5652 /***********************************************************************
5653 Other Lisp Functions
5654 ***********************************************************************/
5656 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
5657 session's frames, frame names, buffers, buffer-read-only flags, and
5658 buffer-modified-flags, and a trailing sentinel (so we don't need to
5659 add length checks). */
5661 static Lisp_Object frame_and_buffer_state
;
5664 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
5665 Sframe_or_buffer_changed_p
, 0, 0, 0,
5666 "Return non-nil if the frame and buffer state appears to have changed.\n\
5667 The state variable is an internal vector containing all frames and buffers,\n\
5668 aside from buffers whose names start with space,\n\
5669 along with the buffers' read-only and modified flags, which allows a fast\n\
5670 check to see whether the menu bars might need to be recomputed.\n\
5671 If this function returns non-nil, it updates the internal vector to reflect\n\
5672 the current state.\n")
5675 Lisp_Object tail
, frame
, buf
;
5679 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5680 FOR_EACH_FRAME (tail
, frame
)
5682 if (!EQ (*vecp
++, frame
))
5684 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
5687 /* Check that the buffer info matches.
5688 No need to test for the end of the vector
5689 because the last element of the vector is lambda
5690 and that will always cause a mismatch. */
5691 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5693 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
5694 /* Ignore buffers that aren't included in buffer lists. */
5695 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5697 if (!EQ (*vecp
++, buf
))
5699 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
5701 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
5704 /* Detect deletion of a buffer at the end of the list. */
5705 if (EQ (*vecp
, Qlambda
))
5708 /* Start with 1 so there is room for at least one lambda at the end. */
5710 FOR_EACH_FRAME (tail
, frame
)
5712 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5714 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
5715 if (n
> XVECTOR (frame_and_buffer_state
)->size
5716 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
5717 /* Add 20 extra so we grow it less often. */
5718 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
5719 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
5720 FOR_EACH_FRAME (tail
, frame
)
5723 *vecp
++ = XFRAME (frame
)->name
;
5725 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5727 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
5728 /* Ignore buffers that aren't included in buffer lists. */
5729 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
5732 *vecp
++ = XBUFFER (buf
)->read_only
;
5733 *vecp
++ = Fbuffer_modified_p (buf
);
5735 /* Fill up the vector with lambdas (always at least one). */
5737 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5738 < XVECTOR (frame_and_buffer_state
)->size
)
5740 /* Make sure we didn't overflow the vector. */
5741 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
5742 > XVECTOR (frame_and_buffer_state
)->size
)
5749 /***********************************************************************
5751 ***********************************************************************/
5753 char *terminal_type
;
5755 /* Initialization done when Emacs fork is started, before doing stty.
5756 Determine terminal type and set terminal_driver. Then invoke its
5757 decoding routine to set up variables in the terminal package. */
5762 #ifdef HAVE_X_WINDOWS
5763 extern int display_arg
;
5766 /* Construct the space glyph. */
5767 space_glyph
.type
= CHAR_GLYPH
;
5768 SET_CHAR_GLYPH_FROM_GLYPH (space_glyph
, ' ');
5769 space_glyph
.charpos
= -1;
5773 cursor_in_echo_area
= 0;
5774 terminal_type
= (char *) 0;
5776 /* Now is the time to initialize this; it's used by init_sys_modes
5778 Vwindow_system
= Qnil
;
5780 /* If the user wants to use a window system, we shouldn't bother
5781 initializing the terminal. This is especially important when the
5782 terminal is so dumb that emacs gives up before and doesn't bother
5783 using the window system.
5785 If the DISPLAY environment variable is set and nonempty,
5786 try to use X, and die with an error message if that doesn't work. */
5788 #ifdef HAVE_X_WINDOWS
5793 display
= getenv ("DECW$DISPLAY");
5795 display
= getenv ("DISPLAY");
5798 display_arg
= (display
!= 0 && *display
!= 0);
5801 if (!inhibit_window_system
&& display_arg
5807 Vwindow_system
= intern ("x");
5809 Vwindow_system_version
= make_number (11);
5811 Vwindow_system_version
= make_number (10);
5813 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
5814 /* In some versions of ncurses,
5815 tputs crashes if we have not called tgetent.
5817 { char b
[2044]; tgetent (b
, "xterm");}
5819 adjust_frame_glyphs_initially ();
5822 #endif /* HAVE_X_WINDOWS */
5825 if (!inhibit_window_system
)
5827 Vwindow_system
= intern ("w32");
5828 Vwindow_system_version
= make_number (1);
5829 adjust_frame_glyphs_initially ();
5832 #endif /* HAVE_NTGUI */
5834 /* If no window system has been specified, try to use the terminal. */
5837 fatal ("standard input is not a tty");
5841 /* Look at the TERM variable */
5842 terminal_type
= (char *) getenv ("TERM");
5846 fprintf (stderr
, "Please specify your terminal type.\n\
5847 For types defined in VMS, use set term /device=TYPE.\n\
5848 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
5849 \(The quotation marks are necessary since terminal types are lower case.)\n");
5851 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
5857 /* VMS DCL tends to up-case things, so down-case term type.
5858 Hardly any uppercase letters in terminal types; should be none. */
5860 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
5863 strcpy (new, terminal_type
);
5865 for (p
= new; *p
; p
++)
5869 terminal_type
= new;
5873 term_init (terminal_type
);
5876 struct frame
*sf
= SELECTED_FRAME ();
5877 int width
= FRAME_WINDOW_WIDTH (sf
);
5878 int height
= FRAME_HEIGHT (sf
);
5880 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (struct glyph
);
5882 /* If these sizes are so big they cause overflow, just ignore the
5883 change. It's not clear what better we could do. */
5884 if (total_glyphs
/ sizeof (struct glyph
) / height
!= width
+ 2)
5885 fatal ("screen size %dx%d too big", width
, height
);
5888 adjust_frame_glyphs_initially ();
5889 calculate_costs (XFRAME (selected_frame
));
5894 #endif /* CANNOT_DUMP */
5895 signal (SIGWINCH
, window_change_signal
);
5896 #endif /* SIGWINCH */
5898 /* Set up faces of the initial terminal frame of a dumped Emacs. */
5902 /* The MSDOS terminal turns on its ``window system'' relatively
5903 late into the startup, so we cannot do the frame faces'
5904 initialization just yet. It will be done later by pc-win.el
5905 and internal_terminal_init. */
5906 && (strcmp (terminal_type
, "internal") != 0 || inhibit_window_system
)
5908 && NILP (Vwindow_system
))
5909 call0 (intern ("tty-set-up-initial-frame-faces"));
5914 /***********************************************************************
5916 ***********************************************************************/
5918 DEFUN ("show-cursor", Fshow_cursor
, Sshow_cursor
, 0, 2, 0,
5919 "Change visibility flag of the text cursor of WINDOW.\n\
5920 ON_P nil means toggle the flag. Otherwise, ON_P must be an integer,\n\
5921 and the flag is set according to the value of ON_P. WINDOW nil or\n\
5922 omitted means use the selected window. The new cursor state takes effect\n\
5923 with the next redisplay.")
5925 Lisp_Object on_p
, window
;
5929 /* Don't change cursor state while redisplaying. This could confuse
5931 if (!redisplaying_p
)
5934 window
= selected_window
;
5936 CHECK_WINDOW (window
, 2);
5937 w
= XWINDOW (window
);
5940 w
->cursor_off_p
= !w
->cursor_off_p
;
5943 CHECK_NUMBER (on_p
, 1);
5944 w
->cursor_off_p
= XINT (on_p
) != 0;
5953 /***********************************************************************
5955 ***********************************************************************/
5960 defsubr (&Sredraw_frame
);
5961 defsubr (&Sredraw_display
);
5962 defsubr (&Sframe_or_buffer_changed_p
);
5963 defsubr (&Sopen_termscript
);
5965 defsubr (&Ssit_for
);
5966 defsubr (&Ssleep_for
);
5967 defsubr (&Ssend_string_to_terminal
);
5968 defsubr (&Sshow_cursor
);
5970 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
5971 staticpro (&frame_and_buffer_state
);
5973 Qdisplay_table
= intern ("display-table");
5974 staticpro (&Qdisplay_table
);
5976 DEFVAR_INT ("baud-rate", &baud_rate
,
5977 "*The output baud rate of the terminal.\n\
5978 On most systems, changing this value will affect the amount of padding\n\
5979 and the other strategic decisions made during redisplay.");
5981 DEFVAR_BOOL ("inverse-video", &inverse_video
,
5982 "*Non-nil means invert the entire frame display.\n\
5983 This means everything is in inverse video which otherwise would not be.");
5985 DEFVAR_BOOL ("visible-bell", &visible_bell
,
5986 "*Non-nil means try to flash the frame to represent a bell.");
5988 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
5989 "*Non-nil means no need to redraw entire frame after suspending.\n\
5990 A non-nil value is useful if the terminal can automatically preserve\n\
5991 Emacs's frame display when you reenter Emacs.\n\
5992 It is up to you to set this variable if your terminal can do that.");
5994 DEFVAR_LISP ("window-system", &Vwindow_system
,
5995 "A symbol naming the window-system under which Emacs is running\n\
5996 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
5998 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
5999 "The version number of the window system in use.\n\
6000 For X windows, this is 10 or 11.");
6002 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
6003 "Non-nil means put cursor in minibuffer, at end of any message there.");
6005 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
6006 "Table defining how to output a glyph code to the frame.\n\
6007 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
6008 Each element can be:\n\
6009 integer: a glyph code which this glyph is an alias for.\n\
6010 string: output this glyph using that string (not impl. in X windows).\n\
6011 nil: this glyph mod 256 is char code to output,\n\
6012 and this glyph / 256 is face code for X windows (see `face-id').");
6013 Vglyph_table
= Qnil
;
6015 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
6016 "Display table to use for buffers that specify none.\n\
6017 See `buffer-display-table' for more information.");
6018 Vstandard_display_table
= Qnil
;
6020 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause
,
6021 "*Non-nil means update isn't paused when input is detected.");
6022 redisplay_dont_pause
= 0;
6024 /* Initialize `window-system', unless init_display already decided it. */
6029 Vwindow_system
= Qnil
;
6030 Vwindow_system_version
= Qnil
;