1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 97, 98, 1999, 2000, 2001
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"
46 #include "intervals.h"
47 #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 */
65 #endif /* macintosh */
67 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
72 /* To get the prototype for `sleep'. */
78 /* Get number of chars of output now in the buffer of a stdio stream.
79 This ought to be built in in stdio, but it isn't. Some s- files
80 override this because their stdio internals differ. */
82 #ifdef __GNU_LIBRARY__
84 /* The s- file might have overridden the definition with one that
85 works for the system's C library. But we are using the GNU C
86 library, so this is the right definition for every system. */
88 #ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT
89 #define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT
91 #undef PENDING_OUTPUT_COUNT
92 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
94 #else /* not __GNU_LIBRARY__ */
95 #if !defined (PENDING_OUTPUT_COUNT) && HAVE_STDIO_EXT_H && HAVE___FPENDING
96 #include <stdio_ext.h>
97 #define PENDING_OUTPUT_COUNT(FILE) __fpending (FILE)
99 #ifndef PENDING_OUTPUT_COUNT
100 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
102 #endif /* not __GNU_LIBRARY__ */
104 #if defined(HAVE_TERM_H) && defined (LINUX) && defined (HAVE_LIBNCURSES)
105 #include <term.h> /* for tgetent */
108 /* Structure to pass dimensions around. Used for character bounding
109 boxes, glyph matrix dimensions and alike. */
118 /* Function prototypes. */
120 static struct glyph_matrix
*save_current_matrix
P_ ((struct frame
*));
121 static void restore_current_matrix
P_ ((struct frame
*, struct glyph_matrix
*));
122 static void fake_current_matrices
P_ ((Lisp_Object
));
123 static void redraw_overlapping_rows
P_ ((struct window
*, int));
124 static void redraw_overlapped_rows
P_ ((struct window
*, int));
125 static int count_blanks
P_ ((struct glyph
*, int));
126 static int count_match
P_ ((struct glyph
*, struct glyph
*,
127 struct glyph
*, struct glyph
*));
128 static unsigned line_draw_cost
P_ ((struct glyph_matrix
*, int));
129 static void update_frame_line
P_ ((struct frame
*, int));
130 static struct dim allocate_matrices_for_frame_redisplay
131 P_ ((Lisp_Object
, int, int, int, int *));
132 static void allocate_matrices_for_window_redisplay
P_ ((struct window
*));
133 static int realloc_glyph_pool
P_ ((struct glyph_pool
*, struct dim
));
134 static void adjust_frame_glyphs
P_ ((struct frame
*));
135 struct glyph_matrix
*new_glyph_matrix
P_ ((struct glyph_pool
*));
136 static void free_glyph_matrix
P_ ((struct glyph_matrix
*));
137 static void adjust_glyph_matrix
P_ ((struct window
*, struct glyph_matrix
*,
138 int, int, struct dim
));
139 static void change_frame_size_1
P_ ((struct frame
*, int, int, int, int, int));
140 static void swap_glyph_pointers
P_ ((struct glyph_row
*, struct glyph_row
*));
142 static int glyph_row_slice_p
P_ ((struct glyph_row
*, struct glyph_row
*));
144 static void fill_up_frame_row_with_spaces
P_ ((struct glyph_row
*, int));
145 static void build_frame_matrix_from_window_tree
P_ ((struct glyph_matrix
*,
147 static void build_frame_matrix_from_leaf_window
P_ ((struct glyph_matrix
*,
149 static struct glyph_pool
*new_glyph_pool
P_ ((void));
150 static void free_glyph_pool
P_ ((struct glyph_pool
*));
151 static void adjust_frame_glyphs_initially
P_ ((void));
152 static void adjust_frame_message_buffer
P_ ((struct frame
*));
153 static void adjust_decode_mode_spec_buffer
P_ ((struct frame
*));
154 static void fill_up_glyph_row_with_spaces
P_ ((struct glyph_row
*));
155 static void build_frame_matrix
P_ ((struct frame
*));
156 void clear_current_matrices
P_ ((struct frame
*));
157 void scroll_glyph_matrix_range
P_ ((struct glyph_matrix
*, int, int,
159 static void clear_window_matrices
P_ ((struct window
*, int));
160 static void fill_up_glyph_row_area_with_spaces
P_ ((struct glyph_row
*, int));
161 static int scrolling_window
P_ ((struct window
*, int));
162 static int update_window_line
P_ ((struct window
*, int, int *));
163 static void update_marginal_area
P_ ((struct window
*, int, int));
164 static int update_text_area
P_ ((struct window
*, int));
165 static void make_current
P_ ((struct glyph_matrix
*, struct glyph_matrix
*,
167 static void mirror_make_current
P_ ((struct window
*, int));
168 void check_window_matrix_pointers
P_ ((struct window
*));
170 static void check_matrix_pointers
P_ ((struct glyph_matrix
*,
171 struct glyph_matrix
*));
173 static void mirror_line_dance
P_ ((struct window
*, int, int, int *, char *));
174 static int update_window_tree
P_ ((struct window
*, int));
175 static int update_window
P_ ((struct window
*, int));
176 static int update_frame_1
P_ ((struct frame
*, int, int));
177 static void set_window_cursor_after_update
P_ ((struct window
*));
178 static int row_equal_p
P_ ((struct window
*, struct glyph_row
*,
179 struct glyph_row
*, int));
180 static void adjust_frame_glyphs_for_window_redisplay
P_ ((struct frame
*));
181 static void adjust_frame_glyphs_for_frame_redisplay
P_ ((struct frame
*));
182 static void reverse_rows
P_ ((struct glyph_matrix
*, int, int));
183 static int margin_glyphs_to_reserve
P_ ((struct window
*, int, Lisp_Object
));
184 static void sync_window_with_frame_matrix_rows
P_ ((struct window
*));
185 struct window
*frame_row_to_window
P_ ((struct window
*, int));
188 /* Non-zero means don't pause redisplay for pending input. (This is
189 for debugging and for a future implementation of EDT-like
192 int redisplay_dont_pause
;
194 /* Nonzero upon entry to redisplay means do not assume anything about
195 current contents of actual terminal frame; clear and redraw it. */
199 /* Nonzero means last display completed. Zero means it was preempted. */
201 int display_completed
;
203 /* Lisp variable visible-bell; enables use of screen-flash instead of
208 /* Invert the color of the whole frame, at a low level. */
212 /* Line speed of the terminal. */
216 /* Either nil or a symbol naming the window system under which Emacs
219 Lisp_Object Vwindow_system
;
221 /* Version number of X windows: 10, 11 or nil. */
223 Lisp_Object Vwindow_system_version
;
225 /* Vector of glyph definitions. Indexed by glyph number, the contents
226 are a string which is how to output the glyph.
228 If Vglyph_table is nil, a glyph is output by using its low 8 bits
231 This is an obsolete feature that is no longer used. The variable
232 is retained for compatibility. */
234 Lisp_Object Vglyph_table
;
236 /* Display table to use for vectors that don't specify their own. */
238 Lisp_Object Vstandard_display_table
;
240 /* Nonzero means reading single-character input with prompt so put
241 cursor on mini-buffer after the prompt. positive means at end of
242 text in echo area; negative means at beginning of line. */
244 int cursor_in_echo_area
;
246 Lisp_Object Qdisplay_table
, Qredisplay_dont_pause
;
249 /* The currently selected frame. In a single-frame version, this
250 variable always equals the_only_frame. */
252 Lisp_Object selected_frame
;
254 /* A frame which is not just a mini-buffer, or 0 if there are no such
255 frames. This is usually the most recent such frame that was
256 selected. In a single-frame version, this variable always holds
257 the address of the_only_frame. */
259 struct frame
*last_nonminibuf_frame
;
261 /* Stdio stream being used for copy of all output. */
265 /* Structure for info on cursor positioning. */
269 /* 1 means SIGWINCH happened when not safe. */
271 int delayed_size_change
;
273 /* 1 means glyph initialization has been completed at startup. */
275 static int glyphs_initialized_initially_p
;
277 /* Updated window if != 0. Set by update_window. */
279 struct window
*updated_window
;
281 /* Glyph row updated in update_window_line, and area that is updated. */
283 struct glyph_row
*updated_row
;
286 /* A glyph for a space. */
288 struct glyph space_glyph
;
290 /* Non-zero means update has been performed directly, so that there's
291 no need for redisplay_internal to do much work. Set by
292 direct_output_for_insert. */
294 int redisplay_performed_directly_p
;
296 /* Counts of allocated structures. These counts serve to diagnose
297 memory leaks and double frees. */
299 int glyph_matrix_count
;
300 int glyph_pool_count
;
302 /* If non-null, the frame whose frame matrices are manipulated. If
303 null, window matrices are worked on. */
305 static struct frame
*frame_matrix_frame
;
307 /* Current interface for window-based redisplay. Set from init_xterm.
308 A null value means we are not using window-based redisplay. */
310 struct redisplay_interface
*rif
;
312 /* Non-zero means that fonts have been loaded since the last glyph
313 matrix adjustments. Redisplay must stop, and glyph matrices must
314 be adjusted when this flag becomes non-zero during display. The
315 reason fonts can be loaded so late is that fonts of fontsets are
320 /* Convert vpos and hpos from frame to window and vice versa.
321 This may only be used for terminal frames. */
325 static int window_to_frame_vpos
P_ ((struct window
*, int));
326 static int window_to_frame_hpos
P_ ((struct window
*, int));
327 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
328 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
330 /* One element of the ring buffer containing redisplay history
333 struct redisplay_history
335 char trace
[512 + 100];
338 /* The size of the history buffer. */
340 #define REDISPLAY_HISTORY_SIZE 30
342 /* The redisplay history buffer. */
344 static struct redisplay_history redisplay_history
[REDISPLAY_HISTORY_SIZE
];
346 /* Next free entry in redisplay_history. */
348 static int history_idx
;
350 /* A tick that's incremented each time something is added to the
353 static unsigned history_tick
;
355 static void add_frame_display_history
P_ ((struct frame
*, int));
356 static void add_window_display_history
P_ ((struct window
*, char *, int));
359 /* Add to the redisplay history how window W has been displayed.
360 MSG is a trace containing the information how W's glyph matrix
361 has been contructed. PAUSED_P non-zero means that the update
362 has been interrupted for pending input. */
365 add_window_display_history (w
, msg
, paused_p
)
372 if (history_idx
>= REDISPLAY_HISTORY_SIZE
)
374 buf
= redisplay_history
[history_idx
].trace
;
377 sprintf (buf
, "%d: window %p (`%s')%s\n",
380 ((BUFFERP (w
->buffer
)
381 && STRINGP (XBUFFER (w
->buffer
)->name
))
382 ? (char *) XSTRING (XBUFFER (w
->buffer
)->name
)->data
384 paused_p
? " ***paused***" : "");
389 /* Add to the redisplay history that frame F has been displayed.
390 PAUSED_P non-zero means that the update has been interrupted for
394 add_frame_display_history (f
, paused_p
)
400 if (history_idx
>= REDISPLAY_HISTORY_SIZE
)
402 buf
= redisplay_history
[history_idx
].trace
;
405 sprintf (buf
, "%d: update frame %p%s",
407 f
, paused_p
? " ***paused***" : "");
411 DEFUN ("dump-redisplay-history", Fdump_redisplay_history
,
412 Sdump_redisplay_history
, 0, 0, "",
413 doc
: /* Dump redisplay history to stderr. */)
418 for (i
= history_idx
- 1; i
!= history_idx
; --i
)
421 i
= REDISPLAY_HISTORY_SIZE
- 1;
422 fprintf (stderr
, "%s\n", redisplay_history
[i
].trace
);
429 #else /* GLYPH_DEBUG == 0 */
431 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + XFASTINT ((W)->top))
432 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + XFASTINT ((W)->left))
434 #endif /* GLYPH_DEBUG == 0 */
437 /* Like bcopy except never gets confused by overlap. Let this be the
438 first function defined in this file, or change emacs.c where the
439 address of this function is used. */
442 safe_bcopy (from
, to
, size
)
446 if (size
<= 0 || from
== to
)
449 /* If the source and destination don't overlap, then bcopy can
450 handle it. If they do overlap, but the destination is lower in
451 memory than the source, we'll assume bcopy can handle that. */
452 if (to
< from
|| from
+ size
<= to
)
453 bcopy (from
, to
, size
);
455 /* Otherwise, we'll copy from the end. */
458 register char *endf
= from
+ size
;
459 register char *endt
= to
+ size
;
461 /* If TO - FROM is large, then we should break the copy into
462 nonoverlapping chunks of TO - FROM bytes each. However, if
463 TO - FROM is small, then the bcopy function call overhead
464 makes this not worth it. The crossover point could be about
465 anywhere. Since I don't think the obvious copy loop is too
466 bad, I'm trying to err in its favor. */
471 while (endf
!= from
);
483 bcopy (endf
, endt
, to
- from
);
486 /* If SIZE wasn't a multiple of TO - FROM, there will be a
487 little left over. The amount left over is (endt + (to -
488 from)) - to, which is endt - from. */
489 bcopy (from
, to
, endt
- from
);
496 /***********************************************************************
498 ***********************************************************************/
500 /* Allocate and return a glyph_matrix structure. POOL is the glyph
501 pool from which memory for the matrix should be allocated, or null
502 for window-based redisplay where no glyph pools are used. The
503 member `pool' of the glyph matrix structure returned is set to
504 POOL, the structure is otherwise zeroed. */
506 struct glyph_matrix
*
507 new_glyph_matrix (pool
)
508 struct glyph_pool
*pool
;
510 struct glyph_matrix
*result
;
512 /* Allocate and clear. */
513 result
= (struct glyph_matrix
*) xmalloc (sizeof *result
);
514 bzero (result
, sizeof *result
);
516 /* Increment number of allocated matrices. This count is used
517 to detect memory leaks. */
518 ++glyph_matrix_count
;
520 /* Set pool and return. */
526 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
528 The global counter glyph_matrix_count is decremented when a matrix
529 is freed. If the count gets negative, more structures were freed
530 than allocated, i.e. one matrix was freed more than once or a bogus
531 pointer was passed to this function.
533 If MATRIX->pool is null, this means that the matrix manages its own
534 glyph memory---this is done for matrices on X frames. Freeing the
535 matrix also frees the glyph memory in this case. */
538 free_glyph_matrix (matrix
)
539 struct glyph_matrix
*matrix
;
545 /* Detect the case that more matrices are freed than were
547 if (--glyph_matrix_count
< 0)
550 /* Free glyph memory if MATRIX owns it. */
551 if (matrix
->pool
== NULL
)
552 for (i
= 0; i
< matrix
->rows_allocated
; ++i
)
553 xfree (matrix
->rows
[i
].glyphs
[LEFT_MARGIN_AREA
]);
555 /* Free row structures and the matrix itself. */
556 xfree (matrix
->rows
);
562 /* Return the number of glyphs to reserve for a marginal area of
563 window W. TOTAL_GLYPHS is the number of glyphs in a complete
564 display line of window W. MARGIN gives the width of the marginal
565 area in canonical character units. MARGIN should be an integer
569 margin_glyphs_to_reserve (w
, total_glyphs
, margin
)
576 if (NUMBERP (margin
))
578 int width
= XFASTINT (w
->width
);
579 double d
= max (0, XFLOATINT (margin
));
580 d
= min (width
/ 2 - 1, d
);
581 n
= (int) ((double) total_glyphs
/ width
* d
);
590 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
593 W is null if the function is called for a frame glyph matrix.
594 Otherwise it is the window MATRIX is a member of. X and Y are the
595 indices of the first column and row of MATRIX within the frame
596 matrix, if such a matrix exists. They are zero for purely
597 window-based redisplay. DIM is the needed size of the matrix.
599 In window-based redisplay, where no frame matrices exist, glyph
600 matrices manage their own glyph storage. Otherwise, they allocate
601 storage from a common frame glyph pool which can be found in
604 The reason for this memory management strategy is to avoid complete
605 frame redraws if possible. When we allocate from a common pool, a
606 change of the location or size of a sub-matrix within the pool
607 requires a complete redisplay of the frame because we cannot easily
608 make sure that the current matrices of all windows still agree with
609 what is displayed on the screen. While this is usually fast, it
610 leads to screen flickering. */
613 adjust_glyph_matrix (w
, matrix
, x
, y
, dim
)
615 struct glyph_matrix
*matrix
;
621 int marginal_areas_changed_p
= 0;
622 int header_line_changed_p
= 0;
623 int header_line_p
= 0;
624 int left
= -1, right
= -1;
625 int window_x
, window_y
, window_width
= -1, window_height
;
627 /* See if W had a top line that has disappeared now, or vice versa. */
630 header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
631 header_line_changed_p
= header_line_p
!= matrix
->header_line_p
;
633 matrix
->header_line_p
= header_line_p
;
635 /* Do nothing if MATRIX' size, position, vscroll, and marginal areas
636 haven't changed. This optimization is important because preserving
637 the matrix means preventing redisplay. */
638 if (matrix
->pool
== NULL
)
640 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
641 left
= margin_glyphs_to_reserve (w
, dim
.width
, w
->left_margin_width
);
642 right
= margin_glyphs_to_reserve (w
, dim
.width
, w
->right_margin_width
);
643 xassert (left
>= 0 && right
>= 0);
644 marginal_areas_changed_p
= (left
!= matrix
->left_margin_glyphs
645 || right
!= matrix
->right_margin_glyphs
);
647 if (!marginal_areas_changed_p
649 && !header_line_changed_p
650 && matrix
->window_left_x
== XFASTINT (w
->left
)
651 && matrix
->window_top_y
== XFASTINT (w
->top
)
652 && matrix
->window_height
== window_height
653 && matrix
->window_vscroll
== w
->vscroll
654 && matrix
->window_width
== window_width
)
658 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
659 if (matrix
->rows_allocated
< dim
.height
)
661 int size
= dim
.height
* sizeof (struct glyph_row
);
662 new_rows
= dim
.height
- matrix
->rows_allocated
;
663 matrix
->rows
= (struct glyph_row
*) xrealloc (matrix
->rows
, size
);
664 bzero (matrix
->rows
+ matrix
->rows_allocated
,
665 new_rows
* sizeof *matrix
->rows
);
666 matrix
->rows_allocated
= dim
.height
;
671 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
672 on a frame not using window-based redisplay. Set up pointers for
673 each row into the glyph pool. */
676 xassert (matrix
->pool
->glyphs
);
680 left
= margin_glyphs_to_reserve (w
, dim
.width
,
681 w
->left_margin_width
);
682 right
= margin_glyphs_to_reserve (w
, dim
.width
,
683 w
->right_margin_width
);
688 for (i
= 0; i
< dim
.height
; ++i
)
690 struct glyph_row
*row
= &matrix
->rows
[i
];
692 row
->glyphs
[LEFT_MARGIN_AREA
]
693 = (matrix
->pool
->glyphs
694 + (y
+ i
) * matrix
->pool
->ncolumns
698 || row
== matrix
->rows
+ dim
.height
- 1
699 || (row
== matrix
->rows
&& matrix
->header_line_p
))
701 row
->glyphs
[TEXT_AREA
]
702 = row
->glyphs
[LEFT_MARGIN_AREA
];
703 row
->glyphs
[RIGHT_MARGIN_AREA
]
704 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
705 row
->glyphs
[LAST_AREA
]
706 = row
->glyphs
[RIGHT_MARGIN_AREA
];
710 row
->glyphs
[TEXT_AREA
]
711 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
712 row
->glyphs
[RIGHT_MARGIN_AREA
]
713 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
714 row
->glyphs
[LAST_AREA
]
715 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
719 matrix
->left_margin_glyphs
= left
;
720 matrix
->right_margin_glyphs
= right
;
724 /* If MATRIX->pool is null, MATRIX is responsible for managing
725 its own memory. Allocate glyph memory from the heap. */
726 if (dim
.width
> matrix
->matrix_w
728 || header_line_changed_p
729 || marginal_areas_changed_p
)
731 struct glyph_row
*row
= matrix
->rows
;
732 struct glyph_row
*end
= row
+ matrix
->rows_allocated
;
736 row
->glyphs
[LEFT_MARGIN_AREA
]
737 = (struct glyph
*) xrealloc (row
->glyphs
[LEFT_MARGIN_AREA
],
739 * sizeof (struct glyph
)));
741 /* The mode line never has marginal areas. */
742 if (row
== matrix
->rows
+ dim
.height
- 1
743 || (row
== matrix
->rows
&& matrix
->header_line_p
))
745 row
->glyphs
[TEXT_AREA
]
746 = row
->glyphs
[LEFT_MARGIN_AREA
];
747 row
->glyphs
[RIGHT_MARGIN_AREA
]
748 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
749 row
->glyphs
[LAST_AREA
]
750 = row
->glyphs
[RIGHT_MARGIN_AREA
];
754 row
->glyphs
[TEXT_AREA
]
755 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
756 row
->glyphs
[RIGHT_MARGIN_AREA
]
757 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
758 row
->glyphs
[LAST_AREA
]
759 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
765 xassert (left
>= 0 && right
>= 0);
766 matrix
->left_margin_glyphs
= left
;
767 matrix
->right_margin_glyphs
= right
;
770 /* Number of rows to be used by MATRIX. */
771 matrix
->nrows
= dim
.height
;
772 xassert (matrix
->nrows
>= 0);
776 if (matrix
== w
->current_matrix
)
778 /* Mark rows in a current matrix of a window as not having
779 valid contents. It's important to not do this for
780 desired matrices. When Emacs starts, it may already be
781 building desired matrices when this function runs. */
782 if (window_width
< 0)
783 window_width
= window_box_width (w
, -1);
785 /* Optimize the case that only the height has changed (C-x 2,
786 upper window). Invalidate all rows that are no longer part
788 if (!marginal_areas_changed_p
789 && !header_line_changed_p
791 && dim
.width
== matrix
->matrix_w
792 && matrix
->window_left_x
== XFASTINT (w
->left
)
793 && matrix
->window_top_y
== XFASTINT (w
->top
)
794 && matrix
->window_width
== window_width
)
796 /* Find the last row in the window. */
797 for (i
= 0; i
< matrix
->nrows
&& matrix
->rows
[i
].enabled_p
; ++i
)
798 if (MATRIX_ROW_BOTTOM_Y (matrix
->rows
+ i
) >= window_height
)
804 /* Window end is invalid, if inside of the rows that
805 are invalidated below. */
806 if (INTEGERP (w
->window_end_vpos
)
807 && XFASTINT (w
->window_end_vpos
) >= i
)
808 w
->window_end_valid
= Qnil
;
810 while (i
< matrix
->nrows
)
811 matrix
->rows
[i
++].enabled_p
= 0;
815 for (i
= 0; i
< matrix
->nrows
; ++i
)
816 matrix
->rows
[i
].enabled_p
= 0;
819 else if (matrix
== w
->desired_matrix
)
821 /* Rows in desired matrices always have to be cleared;
822 redisplay expects this is the case when it runs, so it
823 had better be the case when we adjust matrices between
825 for (i
= 0; i
< matrix
->nrows
; ++i
)
826 matrix
->rows
[i
].enabled_p
= 0;
831 /* Remember last values to be able to optimize frame redraws. */
832 matrix
->matrix_x
= x
;
833 matrix
->matrix_y
= y
;
834 matrix
->matrix_w
= dim
.width
;
835 matrix
->matrix_h
= dim
.height
;
837 /* Record the top y location and height of W at the time the matrix
838 was last adjusted. This is used to optimize redisplay above. */
841 matrix
->window_left_x
= XFASTINT (w
->left
);
842 matrix
->window_top_y
= XFASTINT (w
->top
);
843 matrix
->window_height
= window_height
;
844 matrix
->window_width
= window_width
;
845 matrix
->window_vscroll
= w
->vscroll
;
850 /* Reverse the contents of rows in MATRIX between START and END. The
851 contents of the row at END - 1 end up at START, END - 2 at START +
852 1 etc. This is part of the implementation of rotate_matrix (see
856 reverse_rows (matrix
, start
, end
)
857 struct glyph_matrix
*matrix
;
862 for (i
= start
, j
= end
- 1; i
< j
; ++i
, --j
)
864 /* Non-ISO HP/UX compiler doesn't like auto struct
866 struct glyph_row temp
;
867 temp
= matrix
->rows
[i
];
868 matrix
->rows
[i
] = matrix
->rows
[j
];
869 matrix
->rows
[j
] = temp
;
874 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
875 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
876 indices. (Note: this does not copy glyphs, only glyph pointers in
877 row structures are moved around).
879 The algorithm used for rotating the vector was, I believe, first
880 described by Kernighan. See the vector R as consisting of two
881 sub-vectors AB, where A has length BY for BY >= 0. The result
882 after rotating is then BA. Reverse both sub-vectors to get ArBr
883 and reverse the result to get (ArBr)r which is BA. Similar for
887 rotate_matrix (matrix
, first
, last
, by
)
888 struct glyph_matrix
*matrix
;
893 /* Up (rotate left, i.e. towards lower indices). */
895 reverse_rows (matrix
, first
, first
+ by
);
896 reverse_rows (matrix
, first
+ by
, last
);
897 reverse_rows (matrix
, first
, last
);
901 /* Down (rotate right, i.e. towards higher indices). */
902 reverse_rows (matrix
, last
- by
, last
);
903 reverse_rows (matrix
, first
, last
- by
);
904 reverse_rows (matrix
, first
, last
);
909 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
910 with indices START <= index < END. Increment positions by DELTA/
914 increment_matrix_positions (matrix
, start
, end
, delta
, delta_bytes
)
915 struct glyph_matrix
*matrix
;
916 int start
, end
, delta
, delta_bytes
;
918 /* Check that START and END are reasonable values. */
919 xassert (start
>= 0 && start
<= matrix
->nrows
);
920 xassert (end
>= 0 && end
<= matrix
->nrows
);
921 xassert (start
<= end
);
923 for (; start
< end
; ++start
)
924 increment_row_positions (matrix
->rows
+ start
, delta
, delta_bytes
);
928 /* Enable a range of rows in glyph matrix MATRIX. START and END are
929 the row indices of the first and last + 1 row to enable. If
930 ENABLED_P is non-zero, enabled_p flags in rows will be set to 1. */
933 enable_glyph_matrix_rows (matrix
, start
, end
, enabled_p
)
934 struct glyph_matrix
*matrix
;
938 xassert (start
<= end
);
939 xassert (start
>= 0 && start
< matrix
->nrows
);
940 xassert (end
>= 0 && end
<= matrix
->nrows
);
942 for (; start
< end
; ++start
)
943 matrix
->rows
[start
].enabled_p
= enabled_p
!= 0;
949 This empties all rows in MATRIX by setting the enabled_p flag for
950 all rows of the matrix to zero. The function prepare_desired_row
951 will eventually really clear a row when it sees one with a zero
954 Resets update hints to defaults value. The only update hint
955 currently present is the flag MATRIX->no_scrolling_p. */
958 clear_glyph_matrix (matrix
)
959 struct glyph_matrix
*matrix
;
963 enable_glyph_matrix_rows (matrix
, 0, matrix
->nrows
, 0);
964 matrix
->no_scrolling_p
= 0;
969 /* Shift part of the glyph matrix MATRIX of window W up or down.
970 Increment y-positions in glyph rows between START and END by DY,
971 and recompute their visible height. */
974 shift_glyph_matrix (w
, matrix
, start
, end
, dy
)
976 struct glyph_matrix
*matrix
;
981 xassert (start
<= end
);
982 xassert (start
>= 0 && start
< matrix
->nrows
);
983 xassert (end
>= 0 && end
<= matrix
->nrows
);
985 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
986 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
988 for (; start
< end
; ++start
)
990 struct glyph_row
*row
= &matrix
->rows
[start
];
993 row
->visible_height
= row
->height
;
996 row
->visible_height
-= min_y
- row
->y
;
997 if (row
->y
+ row
->height
> max_y
)
998 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
1003 /* Mark all rows in current matrices of frame F as invalid. Marking
1004 invalid is done by setting enabled_p to zero for all rows in a
1008 clear_current_matrices (f
)
1009 register struct frame
*f
;
1011 /* Clear frame current matrix, if we have one. */
1012 if (f
->current_matrix
)
1013 clear_glyph_matrix (f
->current_matrix
);
1015 /* Clear the matrix of the menu bar window, if such a window exists.
1016 The menu bar window is currently used to display menus on X when
1017 no toolkit support is compiled in. */
1018 if (WINDOWP (f
->menu_bar_window
))
1019 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->current_matrix
);
1021 /* Clear the matrix of the tool-bar window, if any. */
1022 if (WINDOWP (f
->tool_bar_window
))
1023 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
1025 /* Clear current window matrices. */
1026 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
1027 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 0);
1031 /* Clear out all display lines of F for a coming redisplay. */
1034 clear_desired_matrices (f
)
1035 register struct frame
*f
;
1037 if (f
->desired_matrix
)
1038 clear_glyph_matrix (f
->desired_matrix
);
1040 if (WINDOWP (f
->menu_bar_window
))
1041 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->desired_matrix
);
1043 if (WINDOWP (f
->tool_bar_window
))
1044 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->desired_matrix
);
1046 /* Do it for window matrices. */
1047 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
1048 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
1052 /* Clear matrices in window tree rooted in W. If DESIRED_P is
1053 non-zero clear desired matrices, otherwise clear current matrices. */
1056 clear_window_matrices (w
, desired_p
)
1062 if (!NILP (w
->hchild
))
1064 xassert (WINDOWP (w
->hchild
));
1065 clear_window_matrices (XWINDOW (w
->hchild
), desired_p
);
1067 else if (!NILP (w
->vchild
))
1069 xassert (WINDOWP (w
->vchild
));
1070 clear_window_matrices (XWINDOW (w
->vchild
), desired_p
);
1075 clear_glyph_matrix (w
->desired_matrix
);
1078 clear_glyph_matrix (w
->current_matrix
);
1079 w
->window_end_valid
= Qnil
;
1083 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
1089 /***********************************************************************
1092 See dispextern.h for an overall explanation of glyph rows.
1093 ***********************************************************************/
1095 /* Clear glyph row ROW. Do it in a way that makes it robust against
1096 changes in the glyph_row structure, i.e. addition or removal of
1097 structure members. */
1099 static struct glyph_row null_row
;
1102 clear_glyph_row (row
)
1103 struct glyph_row
*row
;
1105 struct glyph
*p
[1 + LAST_AREA
];
1107 /* Save pointers. */
1108 p
[LEFT_MARGIN_AREA
] = row
->glyphs
[LEFT_MARGIN_AREA
];
1109 p
[TEXT_AREA
] = row
->glyphs
[TEXT_AREA
];
1110 p
[RIGHT_MARGIN_AREA
] = row
->glyphs
[RIGHT_MARGIN_AREA
];
1111 p
[LAST_AREA
] = row
->glyphs
[LAST_AREA
];
1116 /* Restore pointers. */
1117 row
->glyphs
[LEFT_MARGIN_AREA
] = p
[LEFT_MARGIN_AREA
];
1118 row
->glyphs
[TEXT_AREA
] = p
[TEXT_AREA
];
1119 row
->glyphs
[RIGHT_MARGIN_AREA
] = p
[RIGHT_MARGIN_AREA
];
1120 row
->glyphs
[LAST_AREA
] = p
[LAST_AREA
];
1122 #if 0 /* At some point, some bit-fields of struct glyph were not set,
1123 which made glyphs unequal when compared with GLYPH_EQUAL_P.
1124 Redisplay outputs such glyphs, and flickering effects were
1125 the result. This also depended on the contents of memory
1126 returned by xmalloc. If flickering happens again, activate
1127 the code below If the flickering is gone with that, chances
1128 are that the flickering has the same reason as here. */
1129 bzero (p
[0], (char *) p
[LAST_AREA
] - (char *) p
[0]);
1134 /* Make ROW an empty, enabled row of canonical character height,
1135 in window W starting at y-position Y. */
1138 blank_row (w
, row
, y
)
1140 struct glyph_row
*row
;
1145 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
1146 max_y
= WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w
);
1148 clear_glyph_row (row
);
1150 row
->ascent
= row
->phys_ascent
= 0;
1151 row
->height
= row
->phys_height
= CANON_Y_UNIT (XFRAME (w
->frame
));
1152 row
->visible_height
= row
->height
;
1155 row
->visible_height
-= min_y
- row
->y
;
1156 if (row
->y
+ row
->height
> max_y
)
1157 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
1163 /* Increment buffer positions in glyph row ROW. DELTA and DELTA_BYTES
1164 are the amounts by which to change positions. Note that the first
1165 glyph of the text area of a row can have a buffer position even if
1166 the used count of the text area is zero. Such rows display line
1170 increment_row_positions (row
, delta
, delta_bytes
)
1171 struct glyph_row
*row
;
1172 int delta
, delta_bytes
;
1176 /* Increment start and end positions. */
1177 MATRIX_ROW_START_CHARPOS (row
) += delta
;
1178 MATRIX_ROW_START_BYTEPOS (row
) += delta_bytes
;
1179 MATRIX_ROW_END_CHARPOS (row
) += delta
;
1180 MATRIX_ROW_END_BYTEPOS (row
) += delta_bytes
;
1182 /* Increment positions in glyphs. */
1183 for (area
= 0; area
< LAST_AREA
; ++area
)
1184 for (i
= 0; i
< row
->used
[area
]; ++i
)
1185 if (BUFFERP (row
->glyphs
[area
][i
].object
)
1186 && row
->glyphs
[area
][i
].charpos
> 0)
1187 row
->glyphs
[area
][i
].charpos
+= delta
;
1189 /* Capture the case of rows displaying a line end. */
1190 if (row
->used
[TEXT_AREA
] == 0
1191 && MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1192 row
->glyphs
[TEXT_AREA
]->charpos
+= delta
;
1197 /* Swap glyphs between two glyph rows A and B. This exchanges glyph
1198 contents, i.e. glyph structure contents are exchanged between A and
1199 B without changing glyph pointers in A and B. */
1202 swap_glyphs_in_rows (a
, b
)
1203 struct glyph_row
*a
, *b
;
1207 for (area
= 0; area
< LAST_AREA
; ++area
)
1209 /* Number of glyphs to swap. */
1210 int max_used
= max (a
->used
[area
], b
->used
[area
]);
1212 /* Start of glyphs in area of row A. */
1213 struct glyph
*glyph_a
= a
->glyphs
[area
];
1215 /* End + 1 of glyphs in area of row A. */
1216 struct glyph
*glyph_a_end
= a
->glyphs
[max_used
];
1218 /* Start of glyphs in area of row B. */
1219 struct glyph
*glyph_b
= b
->glyphs
[area
];
1221 while (glyph_a
< glyph_a_end
)
1223 /* Non-ISO HP/UX compiler doesn't like auto struct
1227 *glyph_a
= *glyph_b
;
1237 /* Exchange pointers to glyph memory between glyph rows A and B. */
1240 swap_glyph_pointers (a
, b
)
1241 struct glyph_row
*a
, *b
;
1244 for (i
= 0; i
< LAST_AREA
+ 1; ++i
)
1246 struct glyph
*temp
= a
->glyphs
[i
];
1247 a
->glyphs
[i
] = b
->glyphs
[i
];
1248 b
->glyphs
[i
] = temp
;
1253 /* Copy glyph row structure FROM to glyph row structure TO, except
1254 that glyph pointers in the structures are left unchanged. */
1257 copy_row_except_pointers (to
, from
)
1258 struct glyph_row
*to
, *from
;
1260 struct glyph
*pointers
[1 + LAST_AREA
];
1262 /* Save glyph pointers of TO. */
1263 bcopy (to
->glyphs
, pointers
, sizeof to
->glyphs
);
1265 /* Do a structure assignment. */
1268 /* Restore original pointers of TO. */
1269 bcopy (pointers
, to
->glyphs
, sizeof to
->glyphs
);
1273 /* Copy contents of glyph row FROM to glyph row TO. Glyph pointers in
1274 TO and FROM are left unchanged. Glyph contents are copied from the
1275 glyph memory of FROM to the glyph memory of TO. Increment buffer
1276 positions in row TO by DELTA/ DELTA_BYTES. */
1279 copy_glyph_row_contents (to
, from
, delta
, delta_bytes
)
1280 struct glyph_row
*to
, *from
;
1281 int delta
, delta_bytes
;
1285 /* This is like a structure assignment TO = FROM, except that
1286 glyph pointers in the rows are left unchanged. */
1287 copy_row_except_pointers (to
, from
);
1289 /* Copy glyphs from FROM to TO. */
1290 for (area
= 0; area
< LAST_AREA
; ++area
)
1291 if (from
->used
[area
])
1292 bcopy (from
->glyphs
[area
], to
->glyphs
[area
],
1293 from
->used
[area
] * sizeof (struct glyph
));
1295 /* Increment buffer positions in TO by DELTA. */
1296 increment_row_positions (to
, delta
, delta_bytes
);
1300 /* Assign glyph row FROM to glyph row TO. This works like a structure
1301 assignment TO = FROM, except that glyph pointers are not copied but
1302 exchanged between TO and FROM. Pointers must be exchanged to avoid
1306 assign_row (to
, from
)
1307 struct glyph_row
*to
, *from
;
1309 swap_glyph_pointers (to
, from
);
1310 copy_row_except_pointers (to
, from
);
1314 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1315 a row in a window matrix, is a slice of the glyph memory of the
1316 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1317 is non-zero if the glyph memory of WINDOW_ROW is part of the glyph
1318 memory of FRAME_ROW. */
1323 glyph_row_slice_p (window_row
, frame_row
)
1324 struct glyph_row
*window_row
, *frame_row
;
1326 struct glyph
*window_glyph_start
= window_row
->glyphs
[0];
1327 struct glyph
*frame_glyph_start
= frame_row
->glyphs
[0];
1328 struct glyph
*frame_glyph_end
= frame_row
->glyphs
[LAST_AREA
];
1330 return (frame_glyph_start
<= window_glyph_start
1331 && window_glyph_start
< frame_glyph_end
);
1334 #endif /* GLYPH_DEBUG */
1338 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1339 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1340 in WINDOW_MATRIX is found satisfying the condition. */
1342 static struct glyph_row
*
1343 find_glyph_row_slice (window_matrix
, frame_matrix
, row
)
1344 struct glyph_matrix
*window_matrix
, *frame_matrix
;
1349 xassert (row
>= 0 && row
< frame_matrix
->nrows
);
1351 for (i
= 0; i
< window_matrix
->nrows
; ++i
)
1352 if (glyph_row_slice_p (window_matrix
->rows
+ i
,
1353 frame_matrix
->rows
+ row
))
1356 return i
< window_matrix
->nrows
? window_matrix
->rows
+ i
: 0;
1361 /* Prepare ROW for display. Desired rows are cleared lazily,
1362 i.e. they are only marked as to be cleared by setting their
1363 enabled_p flag to zero. When a row is to be displayed, a prior
1364 call to this function really clears it. */
1367 prepare_desired_row (row
)
1368 struct glyph_row
*row
;
1370 if (!row
->enabled_p
)
1372 clear_glyph_row (row
);
1378 /* Return a hash code for glyph row ROW. */
1381 line_hash_code (row
)
1382 struct glyph_row
*row
;
1390 /* Give all highlighted lines the same hash code
1391 so as to encourage scrolling to leave them in place. */
1396 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
1397 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
1401 int c
= glyph
->u
.ch
;
1402 int face_id
= glyph
->face_id
;
1403 if (must_write_spaces
)
1405 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + c
;
1406 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + face_id
;
1419 /* Return the cost of drawing line VPOS In MATRIX. The cost equals
1420 the number of characters in the line. If must_write_spaces is
1421 zero, leading and trailing spaces are ignored. */
1424 line_draw_cost (matrix
, vpos
)
1425 struct glyph_matrix
*matrix
;
1428 struct glyph_row
*row
= matrix
->rows
+ vpos
;
1429 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
1430 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
];
1432 Lisp_Object
*glyph_table_base
= GLYPH_TABLE_BASE
;
1433 int glyph_table_len
= GLYPH_TABLE_LENGTH
;
1435 /* Ignore trailing and leading spaces if we can. */
1436 if (!must_write_spaces
)
1438 /* Skip from the end over trailing spaces. */
1439 while (end
> beg
&& CHAR_GLYPH_SPACE_P (*(end
- 1)))
1442 /* All blank line. */
1446 /* Skip over leading spaces. */
1447 while (CHAR_GLYPH_SPACE_P (*beg
))
1451 /* If we don't have a glyph-table, each glyph is one character,
1452 so return the number of glyphs. */
1453 if (glyph_table_base
== 0)
1457 /* Otherwise, scan the glyphs and accumulate their total length
1462 GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*beg
);
1465 || GLYPH_SIMPLE_P (glyph_table_base
, glyph_table_len
, g
))
1468 len
+= GLYPH_LENGTH (glyph_table_base
, g
);
1478 /* Test two glyph rows A and B for equality. Value is non-zero if A
1479 and B have equal contents. W is the window to which the glyphs
1480 rows A and B belong. It is needed here to test for partial row
1481 visibility. MOUSE_FACE_P non-zero means compare the mouse_face_p
1482 flags of A and B, too. */
1485 row_equal_p (w
, a
, b
, mouse_face_p
)
1487 struct glyph_row
*a
, *b
;
1492 else if (a
->hash
!= b
->hash
)
1496 struct glyph
*a_glyph
, *b_glyph
, *a_end
;
1499 if (mouse_face_p
&& a
->mouse_face_p
!= b
->mouse_face_p
)
1502 /* Compare glyphs. */
1503 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
1505 if (a
->used
[area
] != b
->used
[area
])
1508 a_glyph
= a
->glyphs
[area
];
1509 a_end
= a_glyph
+ a
->used
[area
];
1510 b_glyph
= b
->glyphs
[area
];
1512 while (a_glyph
< a_end
1513 && GLYPH_EQUAL_P (a_glyph
, b_glyph
))
1514 ++a_glyph
, ++b_glyph
;
1516 if (a_glyph
!= a_end
)
1520 if (a
->truncated_on_left_p
!= b
->truncated_on_left_p
1521 || a
->inverse_p
!= b
->inverse_p
1522 || a
->fill_line_p
!= b
->fill_line_p
1523 || a
->truncated_on_right_p
!= b
->truncated_on_right_p
1524 || a
->overlay_arrow_p
!= b
->overlay_arrow_p
1525 || a
->continued_p
!= b
->continued_p
1526 || a
->indicate_empty_line_p
!= b
->indicate_empty_line_p
1527 || a
->overlapped_p
!= b
->overlapped_p
1528 || (MATRIX_ROW_CONTINUATION_LINE_P (a
)
1529 != MATRIX_ROW_CONTINUATION_LINE_P (b
))
1530 /* Different partially visible characters on left margin. */
1532 /* Different height. */
1533 || a
->ascent
!= b
->ascent
1534 || a
->phys_ascent
!= b
->phys_ascent
1535 || a
->phys_height
!= b
->phys_height
1536 || a
->visible_height
!= b
->visible_height
)
1545 /***********************************************************************
1548 See dispextern.h for an overall explanation of glyph pools.
1549 ***********************************************************************/
1551 /* Allocate a glyph_pool structure. The structure returned is
1552 initialized with zeros. The global variable glyph_pool_count is
1553 incremented for each pool allocated. */
1555 static struct glyph_pool
*
1558 struct glyph_pool
*result
;
1560 /* Allocate a new glyph_pool and clear it. */
1561 result
= (struct glyph_pool
*) xmalloc (sizeof *result
);
1562 bzero (result
, sizeof *result
);
1564 /* For memory leak and double deletion checking. */
1571 /* Free a glyph_pool structure POOL. The function may be called with
1572 a null POOL pointer. The global variable glyph_pool_count is
1573 decremented with every pool structure freed. If this count gets
1574 negative, more structures were freed than allocated, i.e. one
1575 structure must have been freed more than once or a bogus pointer
1576 was passed to free_glyph_pool. */
1579 free_glyph_pool (pool
)
1580 struct glyph_pool
*pool
;
1584 /* More freed than allocated? */
1586 xassert (glyph_pool_count
>= 0);
1588 xfree (pool
->glyphs
);
1594 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1595 columns we need. This function never shrinks a pool. The only
1596 case in which this would make sense, would be when a frame's size
1597 is changed from a large value to a smaller one. But, if someone
1598 does it once, we can expect that he will do it again.
1600 Value is non-zero if the pool changed in a way which makes
1601 re-adjusting window glyph matrices necessary. */
1604 realloc_glyph_pool (pool
, matrix_dim
)
1605 struct glyph_pool
*pool
;
1606 struct dim matrix_dim
;
1611 changed_p
= (pool
->glyphs
== 0
1612 || matrix_dim
.height
!= pool
->nrows
1613 || matrix_dim
.width
!= pool
->ncolumns
);
1615 /* Enlarge the glyph pool. */
1616 needed
= matrix_dim
.width
* matrix_dim
.height
;
1617 if (needed
> pool
->nglyphs
)
1619 int size
= needed
* sizeof (struct glyph
);
1622 pool
->glyphs
= (struct glyph
*) xrealloc (pool
->glyphs
, size
);
1625 pool
->glyphs
= (struct glyph
*) xmalloc (size
);
1626 bzero (pool
->glyphs
, size
);
1629 pool
->nglyphs
= needed
;
1632 /* Remember the number of rows and columns because (a) we use then
1633 to do sanity checks, and (b) the number of columns determines
1634 where rows in the frame matrix start---this must be available to
1635 determine pointers to rows of window sub-matrices. */
1636 pool
->nrows
= matrix_dim
.height
;
1637 pool
->ncolumns
= matrix_dim
.width
;
1644 /***********************************************************************
1646 ***********************************************************************/
1651 /* Flush standard output. This is sometimes useful to call from
1661 /* Check that no glyph pointers have been lost in MATRIX. If a
1662 pointer has been lost, e.g. by using a structure assignment between
1663 rows, at least one pointer must occur more than once in the rows of
1667 check_matrix_pointer_lossage (matrix
)
1668 struct glyph_matrix
*matrix
;
1672 for (i
= 0; i
< matrix
->nrows
; ++i
)
1673 for (j
= 0; j
< matrix
->nrows
; ++j
)
1675 || (matrix
->rows
[i
].glyphs
[TEXT_AREA
]
1676 != matrix
->rows
[j
].glyphs
[TEXT_AREA
]));
1680 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1683 matrix_row (matrix
, row
)
1684 struct glyph_matrix
*matrix
;
1687 xassert (matrix
&& matrix
->rows
);
1688 xassert (row
>= 0 && row
< matrix
->nrows
);
1690 /* That's really too slow for normal testing because this function
1691 is called almost everywhere. Although---it's still astonishingly
1692 fast, so it is valuable to have for debugging purposes. */
1694 check_matrix_pointer_lossage (matrix
);
1697 return matrix
->rows
+ row
;
1701 #if 0 /* This function makes invalid assumptions when text is
1702 partially invisible. But it might come handy for debugging
1705 /* Check invariants that must hold for an up to date current matrix of
1709 check_matrix_invariants (w
)
1712 struct glyph_matrix
*matrix
= w
->current_matrix
;
1713 int yb
= window_text_bottom_y (w
);
1714 struct glyph_row
*row
= matrix
->rows
;
1715 struct glyph_row
*last_text_row
= NULL
;
1716 struct buffer
*saved
= current_buffer
;
1717 struct buffer
*buffer
= XBUFFER (w
->buffer
);
1720 /* This can sometimes happen for a fresh window. */
1721 if (matrix
->nrows
< 2)
1724 set_buffer_temp (buffer
);
1726 /* Note: last row is always reserved for the mode line. */
1727 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1728 && MATRIX_ROW_BOTTOM_Y (row
) < yb
)
1730 struct glyph_row
*next
= row
+ 1;
1732 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1733 last_text_row
= row
;
1735 /* Check that character and byte positions are in sync. */
1736 xassert (MATRIX_ROW_START_BYTEPOS (row
)
1737 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row
)));
1739 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1740 have such a position temporarily in case of a minibuffer
1741 displaying something like `[Sole completion]' at its end. */
1742 if (MATRIX_ROW_END_CHARPOS (row
) < BUF_ZV (current_buffer
))
1743 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1744 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row
)));
1746 /* Check that end position of `row' is equal to start position
1748 if (next
->enabled_p
&& MATRIX_ROW_DISPLAYS_TEXT_P (next
))
1750 xassert (MATRIX_ROW_END_CHARPOS (row
)
1751 == MATRIX_ROW_START_CHARPOS (next
));
1752 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1753 == MATRIX_ROW_START_BYTEPOS (next
));
1758 xassert (w
->current_matrix
->nrows
== w
->desired_matrix
->nrows
);
1759 xassert (w
->desired_matrix
->rows
!= NULL
);
1760 set_buffer_temp (saved
);
1765 #endif /* GLYPH_DEBUG != 0 */
1769 /**********************************************************************
1770 Allocating/ Adjusting Glyph Matrices
1771 **********************************************************************/
1773 /* Allocate glyph matrices over a window tree for a frame-based
1776 X and Y are column/row within the frame glyph matrix where
1777 sub-matrices for the window tree rooted at WINDOW must be
1778 allocated. CH_DIM contains the dimensions of the smallest
1779 character that could be used during display. DIM_ONLY_P non-zero
1780 means that the caller of this function is only interested in the
1781 result matrix dimension, and matrix adjustments should not be
1784 The function returns the total width/height of the sub-matrices of
1785 the window tree. If called on a frame root window, the computation
1786 will take the mini-buffer window into account.
1788 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1790 NEW_LEAF_MATRIX set if any window in the tree did not have a
1791 glyph matrices yet, and
1793 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1794 any window in the tree will be changed or have been changed (see
1797 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1800 Windows are arranged into chains of windows on the same level
1801 through the next fields of window structures. Such a level can be
1802 either a sequence of horizontally adjacent windows from left to
1803 right, or a sequence of vertically adjacent windows from top to
1804 bottom. Each window in a horizontal sequence can be either a leaf
1805 window or a vertical sequence; a window in a vertical sequence can
1806 be either a leaf or a horizontal sequence. All windows in a
1807 horizontal sequence have the same height, and all windows in a
1808 vertical sequence have the same width.
1810 This function uses, for historical reasons, a more general
1811 algorithm to determine glyph matrix dimensions that would be
1814 The matrix height of a horizontal sequence is determined by the
1815 maximum height of any matrix in the sequence. The matrix width of
1816 a horizontal sequence is computed by adding up matrix widths of
1817 windows in the sequence.
1819 |<------- result width ------->|
1820 +---------+----------+---------+ ---
1823 +---------+ | | result height
1828 The matrix width of a vertical sequence is the maximum matrix width
1829 of any window in the sequence. Its height is computed by adding up
1830 matrix heights of windows in the sequence.
1832 |<---- result width -->|
1840 +------------+---------+ |
1843 +------------+---------+ --- */
1845 /* Bit indicating that a new matrix will be allocated or has been
1848 #define NEW_LEAF_MATRIX (1 << 0)
1850 /* Bit indicating that a matrix will or has changed its location or
1853 #define CHANGED_LEAF_MATRIX (1 << 1)
1856 allocate_matrices_for_frame_redisplay (window
, x
, y
, dim_only_p
,
1857 window_change_flags
)
1861 int *window_change_flags
;
1863 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1865 int wmax
= 0, hmax
= 0;
1869 int in_horz_combination_p
;
1871 /* What combination is WINDOW part of? Compute this once since the
1872 result is the same for all windows in the `next' chain. The
1873 special case of a root window (parent equal to nil) is treated
1874 like a vertical combination because a root window's `next'
1875 points to the mini-buffer window, if any, which is arranged
1876 vertically below other windows. */
1877 in_horz_combination_p
1878 = (!NILP (XWINDOW (window
)->parent
)
1879 && !NILP (XWINDOW (XWINDOW (window
)->parent
)->hchild
));
1881 /* For WINDOW and all windows on the same level. */
1884 w
= XWINDOW (window
);
1886 /* Get the dimension of the window sub-matrix for W, depending
1887 on whether this a combination or a leaf window. */
1888 if (!NILP (w
->hchild
))
1889 dim
= allocate_matrices_for_frame_redisplay (w
->hchild
, x
, y
,
1891 window_change_flags
);
1892 else if (!NILP (w
->vchild
))
1893 dim
= allocate_matrices_for_frame_redisplay (w
->vchild
, x
, y
,
1895 window_change_flags
);
1898 /* If not already done, allocate sub-matrix structures. */
1899 if (w
->desired_matrix
== NULL
)
1901 w
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1902 w
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1903 *window_change_flags
|= NEW_LEAF_MATRIX
;
1906 /* Width and height MUST be chosen so that there are no
1907 holes in the frame matrix. */
1908 dim
.width
= required_matrix_width (w
);
1909 dim
.height
= required_matrix_height (w
);
1911 /* Will matrix be re-allocated? */
1912 if (x
!= w
->desired_matrix
->matrix_x
1913 || y
!= w
->desired_matrix
->matrix_y
1914 || dim
.width
!= w
->desired_matrix
->matrix_w
1915 || dim
.height
!= w
->desired_matrix
->matrix_h
1916 || (margin_glyphs_to_reserve (w
, dim
.width
,
1917 w
->right_margin_width
)
1918 != w
->desired_matrix
->left_margin_glyphs
)
1919 || (margin_glyphs_to_reserve (w
, dim
.width
,
1920 w
->left_margin_width
)
1921 != w
->desired_matrix
->right_margin_glyphs
))
1922 *window_change_flags
|= CHANGED_LEAF_MATRIX
;
1924 /* Actually change matrices, if allowed. Do not consider
1925 CHANGED_LEAF_MATRIX computed above here because the pool
1926 may have been changed which we don't now here. We trust
1927 that we only will be called with DIM_ONLY_P != 0 when
1931 adjust_glyph_matrix (w
, w
->desired_matrix
, x
, y
, dim
);
1932 adjust_glyph_matrix (w
, w
->current_matrix
, x
, y
, dim
);
1936 /* If we are part of a horizontal combination, advance x for
1937 windows to the right of W; otherwise advance y for windows
1939 if (in_horz_combination_p
)
1944 /* Remember maximum glyph matrix dimensions. */
1945 wmax
= max (wmax
, dim
.width
);
1946 hmax
= max (hmax
, dim
.height
);
1948 /* Next window on same level. */
1951 while (!NILP (window
));
1953 /* Set `total' to the total glyph matrix dimension of this window
1954 level. In a vertical combination, the width is the width of the
1955 widest window; the height is the y we finally reached, corrected
1956 by the y we started with. In a horizontal combination, the total
1957 height is the height of the tallest window, and the width is the
1958 x we finally reached, corrected by the x we started with. */
1959 if (in_horz_combination_p
)
1961 total
.width
= x
- x0
;
1962 total
.height
= hmax
;
1967 total
.height
= y
- y0
;
1974 /* Return the required height of glyph matrices for window W. */
1977 required_matrix_height (w
)
1980 #ifdef HAVE_WINDOW_SYSTEM
1981 struct frame
*f
= XFRAME (w
->frame
);
1983 if (FRAME_WINDOW_P (f
))
1985 int ch_height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
1986 int window_pixel_height
= window_box_height (w
) + abs (w
->vscroll
);
1987 return (((window_pixel_height
+ ch_height
- 1)
1989 /* One partially visible line at the top and
1990 bottom of the window. */
1992 /* 2 for top and mode line. */
1995 #endif /* HAVE_WINDOW_SYSTEM */
1997 return XINT (w
->height
);
2001 /* Return the required width of glyph matrices for window W. */
2004 required_matrix_width (w
)
2007 #ifdef HAVE_WINDOW_SYSTEM
2008 struct frame
*f
= XFRAME (w
->frame
);
2009 if (FRAME_WINDOW_P (f
))
2011 int ch_width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2012 int window_pixel_width
= XFLOATINT (w
->width
) * CANON_X_UNIT (f
);
2014 /* Compute number of glyphs needed in a glyph row. */
2015 return (((window_pixel_width
+ ch_width
- 1)
2017 /* 2 partially visible columns in the text area. */
2019 /* One partially visible column at the right
2020 edge of each marginal area. */
2023 #endif /* HAVE_WINDOW_SYSTEM */
2025 return XINT (w
->width
);
2029 /* Allocate window matrices for window-based redisplay. W is the
2030 window whose matrices must be allocated/reallocated. CH_DIM is the
2031 size of the smallest character that could potentially be used on W. */
2034 allocate_matrices_for_window_redisplay (w
)
2039 if (!NILP (w
->vchild
))
2040 allocate_matrices_for_window_redisplay (XWINDOW (w
->vchild
));
2041 else if (!NILP (w
->hchild
))
2042 allocate_matrices_for_window_redisplay (XWINDOW (w
->hchild
));
2045 /* W is a leaf window. */
2048 /* If matrices are not yet allocated, allocate them now. */
2049 if (w
->desired_matrix
== NULL
)
2051 w
->desired_matrix
= new_glyph_matrix (NULL
);
2052 w
->current_matrix
= new_glyph_matrix (NULL
);
2055 dim
.width
= required_matrix_width (w
);
2056 dim
.height
= required_matrix_height (w
);
2057 adjust_glyph_matrix (w
, w
->desired_matrix
, 0, 0, dim
);
2058 adjust_glyph_matrix (w
, w
->current_matrix
, 0, 0, dim
);
2061 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
2066 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
2067 do it for all frames; otherwise do it just for the given frame.
2068 This function must be called when a new frame is created, its size
2069 changes, or its window configuration changes. */
2075 /* Block input so that expose events and other events that access
2076 glyph matrices are not processed while we are changing them. */
2080 adjust_frame_glyphs (f
);
2083 Lisp_Object tail
, lisp_frame
;
2085 FOR_EACH_FRAME (tail
, lisp_frame
)
2086 adjust_frame_glyphs (XFRAME (lisp_frame
));
2093 /* Adjust frame glyphs when Emacs is initialized.
2095 To be called from init_display.
2097 We need a glyph matrix because redraw will happen soon.
2098 Unfortunately, window sizes on selected_frame are not yet set to
2099 meaningful values. I believe we can assume that there are only two
2100 windows on the frame---the mini-buffer and the root window. Frame
2101 height and width seem to be correct so far. So, set the sizes of
2102 windows to estimated values. */
2105 adjust_frame_glyphs_initially ()
2107 struct frame
*sf
= SELECTED_FRAME ();
2108 struct window
*root
= XWINDOW (sf
->root_window
);
2109 struct window
*mini
= XWINDOW (root
->next
);
2110 int frame_height
= FRAME_HEIGHT (sf
);
2111 int frame_width
= FRAME_WIDTH (sf
);
2112 int top_margin
= FRAME_TOP_MARGIN (sf
);
2114 /* Do it for the root window. */
2115 XSETFASTINT (root
->top
, top_margin
);
2116 XSETFASTINT (root
->width
, frame_width
);
2117 set_window_height (sf
->root_window
, frame_height
- 1 - top_margin
, 0);
2119 /* Do it for the mini-buffer window. */
2120 XSETFASTINT (mini
->top
, frame_height
- 1);
2121 XSETFASTINT (mini
->width
, frame_width
);
2122 set_window_height (root
->next
, 1, 0);
2124 adjust_frame_glyphs (sf
);
2125 glyphs_initialized_initially_p
= 1;
2129 /* Allocate/reallocate glyph matrices of a single frame F. */
2132 adjust_frame_glyphs (f
)
2135 if (FRAME_WINDOW_P (f
))
2136 adjust_frame_glyphs_for_window_redisplay (f
);
2138 adjust_frame_glyphs_for_frame_redisplay (f
);
2140 /* Don't forget the message buffer and the buffer for
2141 decode_mode_spec. */
2142 adjust_frame_message_buffer (f
);
2143 adjust_decode_mode_spec_buffer (f
);
2145 f
->glyphs_initialized_p
= 1;
2149 /* In the window tree with root W, build current matrices of leaf
2150 windows from the frame's current matrix. */
2153 fake_current_matrices (window
)
2158 for (; !NILP (window
); window
= w
->next
)
2160 w
= XWINDOW (window
);
2162 if (!NILP (w
->hchild
))
2163 fake_current_matrices (w
->hchild
);
2164 else if (!NILP (w
->vchild
))
2165 fake_current_matrices (w
->vchild
);
2169 struct frame
*f
= XFRAME (w
->frame
);
2170 struct glyph_matrix
*m
= w
->current_matrix
;
2171 struct glyph_matrix
*fm
= f
->current_matrix
;
2173 xassert (m
->matrix_h
== XFASTINT (w
->height
));
2174 xassert (m
->matrix_w
== XFASTINT (w
->width
));
2176 for (i
= 0; i
< m
->matrix_h
; ++i
)
2178 struct glyph_row
*r
= m
->rows
+ i
;
2179 struct glyph_row
*fr
= fm
->rows
+ i
+ XFASTINT (w
->top
);
2181 xassert (r
->glyphs
[TEXT_AREA
] >= fr
->glyphs
[TEXT_AREA
]
2182 && r
->glyphs
[LAST_AREA
] <= fr
->glyphs
[LAST_AREA
]);
2184 r
->enabled_p
= fr
->enabled_p
;
2187 r
->used
[LEFT_MARGIN_AREA
] = m
->left_margin_glyphs
;
2188 r
->used
[RIGHT_MARGIN_AREA
] = m
->right_margin_glyphs
;
2189 r
->used
[TEXT_AREA
] = (m
->matrix_w
2190 - r
->used
[LEFT_MARGIN_AREA
]
2191 - r
->used
[RIGHT_MARGIN_AREA
]);
2193 r
->inverse_p
= fr
->inverse_p
;
2201 /* Save away the contents of frame F's current frame matrix. Value is
2202 a glyph matrix holding the contents of F's current frame matrix. '*/
2204 static struct glyph_matrix
*
2205 save_current_matrix (f
)
2209 struct glyph_matrix
*saved
;
2211 saved
= (struct glyph_matrix
*) xmalloc (sizeof *saved
);
2212 bzero (saved
, sizeof *saved
);
2213 saved
->nrows
= f
->current_matrix
->nrows
;
2214 saved
->rows
= (struct glyph_row
*) xmalloc (saved
->nrows
2215 * sizeof *saved
->rows
);
2216 bzero (saved
->rows
, saved
->nrows
* sizeof *saved
->rows
);
2218 for (i
= 0; i
< saved
->nrows
; ++i
)
2220 struct glyph_row
*from
= f
->current_matrix
->rows
+ i
;
2221 struct glyph_row
*to
= saved
->rows
+ i
;
2222 size_t nbytes
= from
->used
[TEXT_AREA
] * sizeof (struct glyph
);
2223 to
->glyphs
[TEXT_AREA
] = (struct glyph
*) xmalloc (nbytes
);
2224 bcopy (from
->glyphs
[TEXT_AREA
], to
->glyphs
[TEXT_AREA
], nbytes
);
2225 to
->used
[TEXT_AREA
] = from
->used
[TEXT_AREA
];
2232 /* Restore the contents of frame F's current frame matrix from SAVED,
2233 and free memory associated with SAVED. */
2236 restore_current_matrix (f
, saved
)
2238 struct glyph_matrix
*saved
;
2242 for (i
= 0; i
< saved
->nrows
; ++i
)
2244 struct glyph_row
*from
= saved
->rows
+ i
;
2245 struct glyph_row
*to
= f
->current_matrix
->rows
+ i
;
2246 size_t nbytes
= from
->used
[TEXT_AREA
] * sizeof (struct glyph
);
2247 bcopy (from
->glyphs
[TEXT_AREA
], to
->glyphs
[TEXT_AREA
], nbytes
);
2248 to
->used
[TEXT_AREA
] = from
->used
[TEXT_AREA
];
2249 xfree (from
->glyphs
[TEXT_AREA
]);
2252 xfree (saved
->rows
);
2258 /* Allocate/reallocate glyph matrices of a single frame F for
2259 frame-based redisplay. */
2262 adjust_frame_glyphs_for_frame_redisplay (f
)
2266 struct dim matrix_dim
;
2268 int window_change_flags
;
2271 if (!FRAME_LIVE_P (f
))
2274 /* Determine the smallest character in any font for F. On
2275 console windows, all characters have dimension (1, 1). */
2276 ch_dim
.width
= ch_dim
.height
= 1;
2278 top_window_y
= FRAME_TOP_MARGIN (f
);
2280 /* Allocate glyph pool structures if not already done. */
2281 if (f
->desired_pool
== NULL
)
2283 f
->desired_pool
= new_glyph_pool ();
2284 f
->current_pool
= new_glyph_pool ();
2287 /* Allocate frames matrix structures if needed. */
2288 if (f
->desired_matrix
== NULL
)
2290 f
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
2291 f
->current_matrix
= new_glyph_matrix (f
->current_pool
);
2294 /* Compute window glyph matrices. (This takes the mini-buffer
2295 window into account). The result is the size of the frame glyph
2296 matrix needed. The variable window_change_flags is set to a bit
2297 mask indicating whether new matrices will be allocated or
2298 existing matrices change their size or location within the frame
2300 window_change_flags
= 0;
2302 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2305 &window_change_flags
);
2307 /* Add in menu bar lines, if any. */
2308 matrix_dim
.height
+= top_window_y
;
2310 /* Enlarge pools as necessary. */
2311 pool_changed_p
= realloc_glyph_pool (f
->desired_pool
, matrix_dim
);
2312 realloc_glyph_pool (f
->current_pool
, matrix_dim
);
2314 /* Set up glyph pointers within window matrices. Do this only if
2315 absolutely necessary since it requires a frame redraw. */
2316 if (pool_changed_p
|| window_change_flags
)
2318 /* Do it for window matrices. */
2319 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2321 &window_change_flags
);
2323 /* Size of frame matrices must equal size of frame. Note
2324 that we are called for X frames with window widths NOT equal
2325 to the frame width (from CHANGE_FRAME_SIZE_1). */
2326 xassert (matrix_dim
.width
== FRAME_WIDTH (f
)
2327 && matrix_dim
.height
== FRAME_HEIGHT (f
));
2329 /* Pointers to glyph memory in glyph rows are exchanged during
2330 the update phase of redisplay, which means in general that a
2331 frame's current matrix consists of pointers into both the
2332 desired and current glyph pool of the frame. Adjusting a
2333 matrix sets the frame matrix up so that pointers are all into
2334 the same pool. If we want to preserve glyph contents of the
2335 current matrix over a call to adjust_glyph_matrix, we must
2336 make a copy of the current glyphs, and restore the current
2337 matrix' contents from that copy. */
2338 if (display_completed
2339 && !FRAME_GARBAGED_P (f
)
2340 && matrix_dim
.width
== f
->current_matrix
->matrix_w
2341 && matrix_dim
.height
== f
->current_matrix
->matrix_h
)
2343 struct glyph_matrix
*copy
= save_current_matrix (f
);
2344 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2345 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2346 restore_current_matrix (f
, copy
);
2347 fake_current_matrices (FRAME_ROOT_WINDOW (f
));
2351 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2352 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2353 SET_FRAME_GARBAGED (f
);
2359 /* Allocate/reallocate glyph matrices of a single frame F for
2360 window-based redisplay. */
2363 adjust_frame_glyphs_for_window_redisplay (f
)
2369 xassert (FRAME_WINDOW_P (f
) && FRAME_LIVE_P (f
));
2371 /* Get minimum sizes. */
2372 #ifdef HAVE_WINDOW_SYSTEM
2373 ch_dim
.width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2374 ch_dim
.height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
2376 ch_dim
.width
= ch_dim
.height
= 1;
2379 /* Allocate/reallocate window matrices. */
2380 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2382 /* Allocate/ reallocate matrices of the dummy window used to display
2383 the menu bar under X when no X toolkit support is available. */
2384 #ifndef USE_X_TOOLKIT
2386 /* Allocate a dummy window if not already done. */
2387 if (NILP (f
->menu_bar_window
))
2389 f
->menu_bar_window
= make_window ();
2390 w
= XWINDOW (f
->menu_bar_window
);
2391 XSETFRAME (w
->frame
, f
);
2392 w
->pseudo_window_p
= 1;
2395 w
= XWINDOW (f
->menu_bar_window
);
2397 /* Set window dimensions to frame dimensions and allocate or
2398 adjust glyph matrices of W. */
2399 XSETFASTINT (w
->top
, 0);
2400 XSETFASTINT (w
->left
, 0);
2401 XSETFASTINT (w
->height
, FRAME_MENU_BAR_LINES (f
));
2402 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2403 allocate_matrices_for_window_redisplay (w
);
2405 #endif /* not USE_X_TOOLKIT */
2407 /* Allocate/ reallocate matrices of the tool bar window. If we
2408 don't have a tool bar window yet, make one. */
2409 if (NILP (f
->tool_bar_window
))
2411 f
->tool_bar_window
= make_window ();
2412 w
= XWINDOW (f
->tool_bar_window
);
2413 XSETFRAME (w
->frame
, f
);
2414 w
->pseudo_window_p
= 1;
2417 w
= XWINDOW (f
->tool_bar_window
);
2419 XSETFASTINT (w
->top
, FRAME_MENU_BAR_LINES (f
));
2420 XSETFASTINT (w
->left
, 0);
2421 XSETFASTINT (w
->height
, FRAME_TOOL_BAR_LINES (f
));
2422 XSETFASTINT (w
->width
, FRAME_WINDOW_WIDTH (f
));
2423 allocate_matrices_for_window_redisplay (w
);
2427 /* Adjust/ allocate message buffer of frame F.
2429 Note that the message buffer is never freed. Since I could not
2430 find a free in 19.34, I assume that freeing it would be
2431 problematic in some way and don't do it either.
2433 (Implementation note: It should be checked if we can free it
2434 eventually without causing trouble). */
2437 adjust_frame_message_buffer (f
)
2440 int size
= FRAME_MESSAGE_BUF_SIZE (f
) + 1;
2442 if (FRAME_MESSAGE_BUF (f
))
2444 char *buffer
= FRAME_MESSAGE_BUF (f
);
2445 char *new_buffer
= (char *) xrealloc (buffer
, size
);
2446 FRAME_MESSAGE_BUF (f
) = new_buffer
;
2449 FRAME_MESSAGE_BUF (f
) = (char *) xmalloc (size
);
2453 /* Re-allocate buffer for decode_mode_spec on frame F. */
2456 adjust_decode_mode_spec_buffer (f
)
2459 f
->decode_mode_spec_buffer
2460 = (char *) xrealloc (f
->decode_mode_spec_buffer
,
2461 FRAME_MESSAGE_BUF_SIZE (f
) + 1);
2466 /**********************************************************************
2467 Freeing Glyph Matrices
2468 **********************************************************************/
2470 /* Free glyph memory for a frame F. F may be null. This function can
2471 be called for the same frame more than once. The root window of
2472 F may be nil when this function is called. This is the case when
2473 the function is called when F is destroyed. */
2479 if (f
&& f
->glyphs_initialized_p
)
2481 /* Block interrupt input so that we don't get surprised by an X
2482 event while we're in an inconsistent state. */
2484 f
->glyphs_initialized_p
= 0;
2486 /* Release window sub-matrices. */
2487 if (!NILP (f
->root_window
))
2488 free_window_matrices (XWINDOW (f
->root_window
));
2490 /* Free the dummy window for menu bars without X toolkit and its
2492 if (!NILP (f
->menu_bar_window
))
2494 struct window
*w
= XWINDOW (f
->menu_bar_window
);
2495 free_glyph_matrix (w
->desired_matrix
);
2496 free_glyph_matrix (w
->current_matrix
);
2497 w
->desired_matrix
= w
->current_matrix
= NULL
;
2498 f
->menu_bar_window
= Qnil
;
2501 /* Free the tool bar window and its glyph matrices. */
2502 if (!NILP (f
->tool_bar_window
))
2504 struct window
*w
= XWINDOW (f
->tool_bar_window
);
2505 free_glyph_matrix (w
->desired_matrix
);
2506 free_glyph_matrix (w
->current_matrix
);
2507 w
->desired_matrix
= w
->current_matrix
= NULL
;
2508 f
->tool_bar_window
= Qnil
;
2511 /* Release frame glyph matrices. Reset fields to zero in
2512 case we are called a second time. */
2513 if (f
->desired_matrix
)
2515 free_glyph_matrix (f
->desired_matrix
);
2516 free_glyph_matrix (f
->current_matrix
);
2517 f
->desired_matrix
= f
->current_matrix
= NULL
;
2520 /* Release glyph pools. */
2521 if (f
->desired_pool
)
2523 free_glyph_pool (f
->desired_pool
);
2524 free_glyph_pool (f
->current_pool
);
2525 f
->desired_pool
= f
->current_pool
= NULL
;
2533 /* Free glyph sub-matrices in the window tree rooted at W. This
2534 function may be called with a null pointer, and it may be called on
2535 the same tree more than once. */
2538 free_window_matrices (w
)
2543 if (!NILP (w
->hchild
))
2544 free_window_matrices (XWINDOW (w
->hchild
));
2545 else if (!NILP (w
->vchild
))
2546 free_window_matrices (XWINDOW (w
->vchild
));
2549 /* This is a leaf window. Free its memory and reset fields
2550 to zero in case this function is called a second time for
2552 free_glyph_matrix (w
->current_matrix
);
2553 free_glyph_matrix (w
->desired_matrix
);
2554 w
->current_matrix
= w
->desired_matrix
= NULL
;
2557 /* Next window on same level. */
2558 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2563 /* Check glyph memory leaks. This function is called from
2564 shut_down_emacs. Note that frames are not destroyed when Emacs
2565 exits. We therefore free all glyph memory for all active frames
2566 explicitly and check that nothing is left allocated. */
2569 check_glyph_memory ()
2571 Lisp_Object tail
, frame
;
2573 /* Free glyph memory for all frames. */
2574 FOR_EACH_FRAME (tail
, frame
)
2575 free_glyphs (XFRAME (frame
));
2577 /* Check that nothing is left allocated. */
2578 if (glyph_matrix_count
)
2580 if (glyph_pool_count
)
2586 /**********************************************************************
2587 Building a Frame Matrix
2588 **********************************************************************/
2590 /* Most of the redisplay code works on glyph matrices attached to
2591 windows. This is a good solution most of the time, but it is not
2592 suitable for terminal code. Terminal output functions cannot rely
2593 on being able to set an arbitrary terminal window. Instead they
2594 must be provided with a view of the whole frame, i.e. the whole
2595 screen. We build such a view by constructing a frame matrix from
2596 window matrices in this section.
2598 Windows that must be updated have their must_be_update_p flag set.
2599 For all such windows, their desired matrix is made part of the
2600 desired frame matrix. For other windows, their current matrix is
2601 made part of the desired frame matrix.
2603 +-----------------+----------------+
2604 | desired | desired |
2606 +-----------------+----------------+
2609 +----------------------------------+
2611 Desired window matrices can be made part of the frame matrix in a
2612 cheap way: We exploit the fact that the desired frame matrix and
2613 desired window matrices share their glyph memory. This is not
2614 possible for current window matrices. Their glyphs are copied to
2615 the desired frame matrix. The latter is equivalent to
2616 preserve_other_columns in the old redisplay.
2618 Used glyphs counters for frame matrix rows are the result of adding
2619 up glyph lengths of the window matrices. A line in the frame
2620 matrix is enabled, if a corresponding line in a window matrix is
2623 After building the desired frame matrix, it will be passed to
2624 terminal code, which will manipulate both the desired and current
2625 frame matrix. Changes applied to the frame's current matrix have
2626 to be visible in current window matrices afterwards, of course.
2628 This problem is solved like this:
2630 1. Window and frame matrices share glyphs. Window matrices are
2631 constructed in a way that their glyph contents ARE the glyph
2632 contents needed in a frame matrix. Thus, any modification of
2633 glyphs done in terminal code will be reflected in window matrices
2636 2. Exchanges of rows in a frame matrix done by terminal code are
2637 intercepted by hook functions so that corresponding row operations
2638 on window matrices can be performed. This is necessary because we
2639 use pointers to glyphs in glyph row structures. To satisfy the
2640 assumption of point 1 above that glyphs are updated implicitly in
2641 window matrices when they are manipulated via the frame matrix,
2642 window and frame matrix must of course agree where to find the
2643 glyphs for their rows. Possible manipulations that must be
2644 mirrored are assignments of rows of the desired frame matrix to the
2645 current frame matrix and scrolling the current frame matrix. */
2647 /* Build frame F's desired matrix from window matrices. Only windows
2648 which have the flag must_be_updated_p set have to be updated. Menu
2649 bar lines of a frame are not covered by window matrices, so make
2650 sure not to touch them in this function. */
2653 build_frame_matrix (f
)
2658 /* F must have a frame matrix when this function is called. */
2659 xassert (!FRAME_WINDOW_P (f
));
2661 /* Clear all rows in the frame matrix covered by window matrices.
2662 Menu bar lines are not covered by windows. */
2663 for (i
= FRAME_TOP_MARGIN (f
); i
< f
->desired_matrix
->nrows
; ++i
)
2664 clear_glyph_row (MATRIX_ROW (f
->desired_matrix
, i
));
2666 /* Build the matrix by walking the window tree. */
2667 build_frame_matrix_from_window_tree (f
->desired_matrix
,
2668 XWINDOW (FRAME_ROOT_WINDOW (f
)));
2672 /* Walk a window tree, building a frame matrix MATRIX from window
2673 matrices. W is the root of a window tree. */
2676 build_frame_matrix_from_window_tree (matrix
, w
)
2677 struct glyph_matrix
*matrix
;
2682 if (!NILP (w
->hchild
))
2683 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->hchild
));
2684 else if (!NILP (w
->vchild
))
2685 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->vchild
));
2687 build_frame_matrix_from_leaf_window (matrix
, w
);
2689 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2694 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2695 desired frame matrix built. W is a leaf window whose desired or
2696 current matrix is to be added to FRAME_MATRIX. W's flag
2697 must_be_updated_p determines which matrix it contributes to
2698 FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix
2699 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2700 Adding a desired matrix means setting up used counters and such in
2701 frame rows, while adding a current window matrix to FRAME_MATRIX
2702 means copying glyphs. The latter case corresponds to
2703 preserve_other_columns in the old redisplay. */
2706 build_frame_matrix_from_leaf_window (frame_matrix
, w
)
2707 struct glyph_matrix
*frame_matrix
;
2710 struct glyph_matrix
*window_matrix
;
2711 int window_y
, frame_y
;
2712 /* If non-zero, a glyph to insert at the right border of W. */
2713 GLYPH right_border_glyph
= 0;
2715 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2716 if (w
->must_be_updated_p
)
2718 window_matrix
= w
->desired_matrix
;
2720 /* Decide whether we want to add a vertical border glyph. */
2721 if (!WINDOW_RIGHTMOST_P (w
))
2723 struct Lisp_Char_Table
*dp
= window_display_table (w
);
2724 right_border_glyph
= (dp
&& INTEGERP (DISP_BORDER_GLYPH (dp
))
2725 ? XINT (DISP_BORDER_GLYPH (dp
))
2730 window_matrix
= w
->current_matrix
;
2732 /* For all rows in the window matrix and corresponding rows in the
2735 frame_y
= window_matrix
->matrix_y
;
2736 while (window_y
< window_matrix
->nrows
)
2738 struct glyph_row
*frame_row
= frame_matrix
->rows
+ frame_y
;
2739 struct glyph_row
*window_row
= window_matrix
->rows
+ window_y
;
2740 int current_row_p
= window_matrix
== w
->current_matrix
;
2742 /* Fill up the frame row with spaces up to the left margin of the
2744 fill_up_frame_row_with_spaces (frame_row
, window_matrix
->matrix_x
);
2746 /* Fill up areas in the window matrix row with spaces. */
2747 fill_up_glyph_row_with_spaces (window_row
);
2749 /* If only part of W's desired matrix has been built, and
2750 window_row wasn't displayed, use the corresponding current
2752 if (window_matrix
== w
->desired_matrix
2753 && !window_row
->enabled_p
)
2755 window_row
= w
->current_matrix
->rows
+ window_y
;
2761 /* Copy window row to frame row. */
2762 bcopy (window_row
->glyphs
[0],
2763 frame_row
->glyphs
[TEXT_AREA
] + window_matrix
->matrix_x
,
2764 window_matrix
->matrix_w
* sizeof (struct glyph
));
2768 xassert (window_row
->enabled_p
);
2770 /* Only when a desired row has been displayed, we want
2771 the corresponding frame row to be updated. */
2772 frame_row
->enabled_p
= 1;
2774 /* Maybe insert a vertical border between horizontally adjacent
2776 if (right_border_glyph
)
2778 struct glyph
*border
= window_row
->glyphs
[LAST_AREA
] - 1;
2779 SET_CHAR_GLYPH_FROM_GLYPH (*border
, right_border_glyph
);
2782 /* Window row window_y must be a slice of frame row
2784 xassert (glyph_row_slice_p (window_row
, frame_row
));
2786 /* If rows are in sync, we don't have to copy glyphs because
2787 frame and window share glyphs. */
2790 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
2791 add_window_display_history (w
, w
->current_matrix
->method
, 0);
2795 /* Set number of used glyphs in the frame matrix. Since we fill
2796 up with spaces, and visit leaf windows from left to right it
2797 can be done simply. */
2798 frame_row
->used
[TEXT_AREA
]
2799 = window_matrix
->matrix_x
+ window_matrix
->matrix_w
;
2801 /* Or in other flags. */
2802 frame_row
->inverse_p
|= window_row
->inverse_p
;
2811 /* Add spaces to a glyph row ROW in a window matrix.
2813 Each row has the form:
2815 +---------+-----------------------------+------------+
2816 | left | text | right |
2817 +---------+-----------------------------+------------+
2819 Left and right marginal areas are optional. This function adds
2820 spaces to areas so that there are no empty holes between areas.
2821 In other words: If the right area is not empty, the text area
2822 is filled up with spaces up to the right area. If the text area
2823 is not empty, the left area is filled up.
2825 To be called for frame-based redisplay, only. */
2828 fill_up_glyph_row_with_spaces (row
)
2829 struct glyph_row
*row
;
2831 fill_up_glyph_row_area_with_spaces (row
, LEFT_MARGIN_AREA
);
2832 fill_up_glyph_row_area_with_spaces (row
, TEXT_AREA
);
2833 fill_up_glyph_row_area_with_spaces (row
, RIGHT_MARGIN_AREA
);
2837 /* Fill area AREA of glyph row ROW with spaces. To be called for
2838 frame-based redisplay only. */
2841 fill_up_glyph_row_area_with_spaces (row
, area
)
2842 struct glyph_row
*row
;
2845 if (row
->glyphs
[area
] < row
->glyphs
[area
+ 1])
2847 struct glyph
*end
= row
->glyphs
[area
+ 1];
2848 struct glyph
*text
= row
->glyphs
[area
] + row
->used
[area
];
2851 *text
++ = space_glyph
;
2852 row
->used
[area
] = text
- row
->glyphs
[area
];
2857 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2858 reached. In frame matrices only one area, TEXT_AREA, is used. */
2861 fill_up_frame_row_with_spaces (row
, upto
)
2862 struct glyph_row
*row
;
2865 int i
= row
->used
[TEXT_AREA
];
2866 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
2869 glyph
[i
++] = space_glyph
;
2871 row
->used
[TEXT_AREA
] = i
;
2876 /**********************************************************************
2877 Mirroring operations on frame matrices in window matrices
2878 **********************************************************************/
2880 /* Set frame being updated via frame-based redisplay to F. This
2881 function must be called before updates to make explicit that we are
2882 working on frame matrices or not. */
2885 set_frame_matrix_frame (f
)
2888 frame_matrix_frame
= f
;
2892 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2893 DESIRED_MATRIX is the desired matrix corresponding to
2894 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2895 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2896 frame_matrix_frame is non-null, this indicates that the exchange is
2897 done in frame matrices, and that we have to perform analogous
2898 operations in window matrices of frame_matrix_frame. */
2901 make_current (desired_matrix
, current_matrix
, row
)
2902 struct glyph_matrix
*desired_matrix
, *current_matrix
;
2905 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, row
);
2906 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, row
);
2907 int mouse_face_p
= current_row
->mouse_face_p
;
2909 /* Do current_row = desired_row. This exchanges glyph pointers
2910 between both rows, and does a structure assignment otherwise. */
2911 assign_row (current_row
, desired_row
);
2913 /* Enable current_row to mark it as valid. */
2914 current_row
->enabled_p
= 1;
2915 current_row
->mouse_face_p
= mouse_face_p
;
2917 /* If we are called on frame matrices, perform analogous operations
2918 for window matrices. */
2919 if (frame_matrix_frame
)
2920 mirror_make_current (XWINDOW (frame_matrix_frame
->root_window
), row
);
2924 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2925 W's frame which has been made current (by swapping pointers between
2926 current and desired matrix). Perform analogous operations in the
2927 matrices of leaf windows in the window tree rooted at W. */
2930 mirror_make_current (w
, frame_row
)
2936 if (!NILP (w
->hchild
))
2937 mirror_make_current (XWINDOW (w
->hchild
), frame_row
);
2938 else if (!NILP (w
->vchild
))
2939 mirror_make_current (XWINDOW (w
->vchild
), frame_row
);
2942 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2943 here because the checks performed in debug mode there
2944 will not allow the conversion. */
2945 int row
= frame_row
- w
->desired_matrix
->matrix_y
;
2947 /* If FRAME_ROW is within W, assign the desired row to the
2948 current row (exchanging glyph pointers). */
2949 if (row
>= 0 && row
< w
->desired_matrix
->matrix_h
)
2951 struct glyph_row
*current_row
2952 = MATRIX_ROW (w
->current_matrix
, row
);
2953 struct glyph_row
*desired_row
2954 = MATRIX_ROW (w
->desired_matrix
, row
);
2956 if (desired_row
->enabled_p
)
2957 assign_row (current_row
, desired_row
);
2959 swap_glyph_pointers (desired_row
, current_row
);
2960 current_row
->enabled_p
= 1;
2964 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2969 /* Perform row dance after scrolling. We are working on the range of
2970 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2971 including) in MATRIX. COPY_FROM is a vector containing, for each
2972 row I in the range 0 <= I < NLINES, the index of the original line
2973 to move to I. This index is relative to the row range, i.e. 0 <=
2974 index < NLINES. RETAINED_P is a vector containing zero for each
2975 row 0 <= I < NLINES which is empty.
2977 This function is called from do_scrolling and do_direct_scrolling. */
2980 mirrored_line_dance (matrix
, unchanged_at_top
, nlines
, copy_from
,
2982 struct glyph_matrix
*matrix
;
2983 int unchanged_at_top
, nlines
;
2987 /* A copy of original rows. */
2988 struct glyph_row
*old_rows
;
2990 /* Rows to assign to. */
2991 struct glyph_row
*new_rows
= MATRIX_ROW (matrix
, unchanged_at_top
);
2995 /* Make a copy of the original rows. */
2996 old_rows
= (struct glyph_row
*) alloca (nlines
* sizeof *old_rows
);
2997 bcopy (new_rows
, old_rows
, nlines
* sizeof *old_rows
);
2999 /* Assign new rows, maybe clear lines. */
3000 for (i
= 0; i
< nlines
; ++i
)
3002 int enabled_before_p
= new_rows
[i
].enabled_p
;
3004 xassert (i
+ unchanged_at_top
< matrix
->nrows
);
3005 xassert (unchanged_at_top
+ copy_from
[i
] < matrix
->nrows
);
3006 new_rows
[i
] = old_rows
[copy_from
[i
]];
3007 new_rows
[i
].enabled_p
= enabled_before_p
;
3009 /* RETAINED_P is zero for empty lines. */
3010 if (!retained_p
[copy_from
[i
]])
3011 new_rows
[i
].enabled_p
= 0;
3014 /* Do the same for window matrices, if MATRIX Is a frame matrix. */
3015 if (frame_matrix_frame
)
3016 mirror_line_dance (XWINDOW (frame_matrix_frame
->root_window
),
3017 unchanged_at_top
, nlines
, copy_from
, retained_p
);
3021 /* Synchronize glyph pointers in the current matrix of window W with
3022 the current frame matrix. W must be full-width, and be on a tty
3026 sync_window_with_frame_matrix_rows (w
)
3029 struct frame
*f
= XFRAME (w
->frame
);
3030 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
3032 /* Preconditions: W must be a leaf window and full-width. Its frame
3033 must have a frame matrix. */
3034 xassert (NILP (w
->hchild
) && NILP (w
->vchild
));
3035 xassert (WINDOW_FULL_WIDTH_P (w
));
3036 xassert (!FRAME_WINDOW_P (f
));
3038 /* If W is a full-width window, glyph pointers in W's current matrix
3039 have, by definition, to be the same as glyph pointers in the
3040 corresponding frame matrix. */
3041 window_row
= w
->current_matrix
->rows
;
3042 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
3043 frame_row
= f
->current_matrix
->rows
+ XFASTINT (w
->top
);
3044 while (window_row
< window_row_end
)
3048 for (area
= LEFT_MARGIN_AREA
; area
<= LAST_AREA
; ++area
)
3049 window_row
->glyphs
[area
] = frame_row
->glyphs
[area
];
3051 ++window_row
, ++frame_row
;
3056 /* Return the window in the window tree rooted in W containing frame
3057 row ROW. Value is null if none is found. */
3060 frame_row_to_window (w
, row
)
3064 struct window
*found
= NULL
;
3068 if (!NILP (w
->hchild
))
3069 found
= frame_row_to_window (XWINDOW (w
->hchild
), row
);
3070 else if (!NILP (w
->vchild
))
3071 found
= frame_row_to_window (XWINDOW (w
->vchild
), row
);
3072 else if (row
>= XFASTINT (w
->top
)
3073 && row
< XFASTINT (w
->top
) + XFASTINT (w
->height
))
3076 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3083 /* Perform a line dance in the window tree rooted at W, after
3084 scrolling a frame matrix in mirrored_line_dance.
3086 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
3087 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
3088 COPY_FROM is a vector containing, for each row I in the range 0 <=
3089 I < NLINES, the index of the original line to move to I. This
3090 index is relative to the row range, i.e. 0 <= index < NLINES.
3091 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
3095 mirror_line_dance (w
, unchanged_at_top
, nlines
, copy_from
, retained_p
)
3097 int unchanged_at_top
, nlines
;
3103 if (!NILP (w
->hchild
))
3104 mirror_line_dance (XWINDOW (w
->hchild
), unchanged_at_top
,
3105 nlines
, copy_from
, retained_p
);
3106 else if (!NILP (w
->vchild
))
3107 mirror_line_dance (XWINDOW (w
->vchild
), unchanged_at_top
,
3108 nlines
, copy_from
, retained_p
);
3111 /* W is a leaf window, and we are working on its current
3113 struct glyph_matrix
*m
= w
->current_matrix
;
3115 struct glyph_row
*old_rows
;
3117 /* Make a copy of the original rows of matrix m. */
3118 old_rows
= (struct glyph_row
*) alloca (m
->nrows
* sizeof *old_rows
);
3119 bcopy (m
->rows
, old_rows
, m
->nrows
* sizeof *old_rows
);
3121 for (i
= 0; i
< nlines
; ++i
)
3123 /* Frame relative line assigned to. */
3124 int frame_to
= i
+ unchanged_at_top
;
3126 /* Frame relative line assigned. */
3127 int frame_from
= copy_from
[i
] + unchanged_at_top
;
3129 /* Window relative line assigned to. */
3130 int window_to
= frame_to
- m
->matrix_y
;
3132 /* Window relative line assigned. */
3133 int window_from
= frame_from
- m
->matrix_y
;
3135 /* Is assigned line inside window? */
3136 int from_inside_window_p
3137 = window_from
>= 0 && window_from
< m
->matrix_h
;
3139 /* Is assigned to line inside window? */
3140 int to_inside_window_p
3141 = window_to
>= 0 && window_to
< m
->matrix_h
;
3143 if (from_inside_window_p
&& to_inside_window_p
)
3145 /* Enabled setting before assignment. */
3146 int enabled_before_p
;
3148 /* Do the assignment. The enabled_p flag is saved
3149 over the assignment because the old redisplay did
3151 enabled_before_p
= m
->rows
[window_to
].enabled_p
;
3152 m
->rows
[window_to
] = old_rows
[window_from
];
3153 m
->rows
[window_to
].enabled_p
= enabled_before_p
;
3155 /* If frame line is empty, window line is empty, too. */
3156 if (!retained_p
[copy_from
[i
]])
3157 m
->rows
[window_to
].enabled_p
= 0;
3159 else if (to_inside_window_p
)
3161 /* A copy between windows. This is an infrequent
3162 case not worth optimizing. */
3163 struct frame
*f
= XFRAME (w
->frame
);
3164 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3166 struct glyph_matrix
*m2
;
3169 w2
= frame_row_to_window (root
, frame_to
);
3170 m2
= w2
->current_matrix
;
3171 m2_from
= frame_from
- m2
->matrix_y
;
3172 copy_row_except_pointers (m
->rows
+ window_to
,
3173 m2
->rows
+ m2_from
);
3175 /* If frame line is empty, window line is empty, too. */
3176 if (!retained_p
[copy_from
[i
]])
3177 m
->rows
[window_to
].enabled_p
= 0;
3180 else if (from_inside_window_p
)
3184 /* If there was a copy between windows, make sure glyph
3185 pointers are in sync with the frame matrix. */
3187 sync_window_with_frame_matrix_rows (w
);
3189 /* Check that no pointers are lost. */
3193 /* Next window on same level. */
3194 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3201 /* Check that window and frame matrices agree about their
3202 understanding where glyphs of the rows are to find. For each
3203 window in the window tree rooted at W, check that rows in the
3204 matrices of leaf window agree with their frame matrices about
3208 check_window_matrix_pointers (w
)
3213 if (!NILP (w
->hchild
))
3214 check_window_matrix_pointers (XWINDOW (w
->hchild
));
3215 else if (!NILP (w
->vchild
))
3216 check_window_matrix_pointers (XWINDOW (w
->vchild
));
3219 struct frame
*f
= XFRAME (w
->frame
);
3220 check_matrix_pointers (w
->desired_matrix
, f
->desired_matrix
);
3221 check_matrix_pointers (w
->current_matrix
, f
->current_matrix
);
3224 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3229 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
3230 a window and FRAME_MATRIX is the corresponding frame matrix. For
3231 each row in WINDOW_MATRIX check that it's a slice of the
3232 corresponding frame row. If it isn't, abort. */
3235 check_matrix_pointers (window_matrix
, frame_matrix
)
3236 struct glyph_matrix
*window_matrix
, *frame_matrix
;
3238 /* Row number in WINDOW_MATRIX. */
3241 /* Row number corresponding to I in FRAME_MATRIX. */
3242 int j
= window_matrix
->matrix_y
;
3244 /* For all rows check that the row in the window matrix is a
3245 slice of the row in the frame matrix. If it isn't we didn't
3246 mirror an operation on the frame matrix correctly. */
3247 while (i
< window_matrix
->nrows
)
3249 if (!glyph_row_slice_p (window_matrix
->rows
+ i
,
3250 frame_matrix
->rows
+ j
))
3256 #endif /* GLYPH_DEBUG != 0 */
3260 /**********************************************************************
3261 VPOS and HPOS translations
3262 **********************************************************************/
3266 /* Translate vertical position VPOS which is relative to window W to a
3267 vertical position relative to W's frame. */
3270 window_to_frame_vpos (w
, vpos
)
3274 struct frame
*f
= XFRAME (w
->frame
);
3276 xassert (!FRAME_WINDOW_P (f
));
3277 xassert (vpos
>= 0 && vpos
<= w
->desired_matrix
->nrows
);
3278 vpos
+= XFASTINT (w
->top
);
3279 xassert (vpos
>= 0 && vpos
<= FRAME_HEIGHT (f
));
3284 /* Translate horizontal position HPOS which is relative to window W to
3285 a vertical position relative to W's frame. */
3288 window_to_frame_hpos (w
, hpos
)
3292 struct frame
*f
= XFRAME (w
->frame
);
3294 xassert (!FRAME_WINDOW_P (f
));
3295 hpos
+= XFASTINT (w
->left
);
3299 #endif /* GLYPH_DEBUG */
3303 /**********************************************************************
3305 **********************************************************************/
3307 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
3308 doc
: /* Clear frame FRAME and output again what is supposed to appear on it. */)
3314 CHECK_LIVE_FRAME (frame
, 0);
3317 /* Ignore redraw requests, if frame has no glyphs yet.
3318 (Implementation note: It still has to be checked why we are
3319 called so early here). */
3320 if (!glyphs_initialized_initially_p
)
3324 if (FRAME_MSDOS_P (f
))
3325 set_terminal_modes ();
3327 clear_current_matrices (f
);
3330 windows_or_buffers_changed
++;
3331 /* Mark all windows as inaccurate, so that every window will have
3332 its redisplay done. */
3333 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
3334 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
3340 /* Redraw frame F. This is nothing more than a call to the Lisp
3341 function redraw-frame. */
3348 XSETFRAME (frame
, f
);
3349 Fredraw_frame (frame
);
3353 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
3354 doc
: /* Clear and redisplay all visible frames. */)
3357 Lisp_Object tail
, frame
;
3359 FOR_EACH_FRAME (tail
, frame
)
3360 if (FRAME_VISIBLE_P (XFRAME (frame
)))
3361 Fredraw_frame (frame
);
3367 /* This is used when frame_garbaged is set. Call Fredraw_frame on all
3368 visible frames marked as garbaged. */
3371 redraw_garbaged_frames ()
3373 Lisp_Object tail
, frame
;
3375 FOR_EACH_FRAME (tail
, frame
)
3376 if (FRAME_VISIBLE_P (XFRAME (frame
))
3377 && FRAME_GARBAGED_P (XFRAME (frame
)))
3378 Fredraw_frame (frame
);
3383 /***********************************************************************
3385 ***********************************************************************/
3387 /* Try to update display and current glyph matrix directly.
3389 This function is called after a character G has been inserted into
3390 current_buffer. It tries to update the current glyph matrix and
3391 perform appropriate screen output to reflect the insertion. If it
3392 succeeds, the global flag redisplay_performed_directly_p will be
3393 set to 1, and thereby prevent the more costly general redisplay
3394 from running (see redisplay_internal).
3396 This function is not called for `hairy' character insertions.
3397 In particular, it is not called when after or before change
3398 functions exist, like they are used by font-lock. See keyboard.c
3399 for details where this function is called. */
3402 direct_output_for_insert (g
)
3405 register struct frame
*f
= SELECTED_FRAME ();
3406 struct window
*w
= XWINDOW (selected_window
);
3408 struct glyph_row
*glyph_row
;
3409 struct glyph
*glyphs
, *glyph
, *end
;
3411 /* Non-null means that Redisplay of W is based on window matrices. */
3412 int window_redisplay_p
= FRAME_WINDOW_P (f
);
3413 /* Non-null means we are in overwrite mode. */
3414 int overwrite_p
= !NILP (current_buffer
->overwrite_mode
);
3416 struct text_pos pos
;
3417 int delta
, delta_bytes
;
3419 /* Not done directly. */
3420 redisplay_performed_directly_p
= 0;
3422 /* Quickly give up for some common cases. */
3423 if (cursor_in_echo_area
3424 /* Give up if fonts have changed. */
3426 /* Give up if face attributes have been changed. */
3427 || face_change_count
3428 /* Give up if cursor position not really known. */
3429 || !display_completed
3430 /* Give up if buffer appears in two places. */
3431 || buffer_shared
> 1
3432 /* Give up if currently displaying a message instead of the
3433 minibuffer contents. */
3434 || (EQ (selected_window
, minibuf_window
)
3435 && EQ (minibuf_window
, echo_area_window
))
3436 /* Give up for hscrolled mini-buffer because display of the prompt
3437 is handled specially there (see display_line). */
3438 || (MINI_WINDOW_P (w
) && XFASTINT (w
->hscroll
))
3439 /* Give up if overwriting in the middle of a line. */
3442 && FETCH_BYTE (PT
) != '\n')
3443 /* Give up for tabs and line ends. */
3447 /* Give up if unable to display the cursor in the window. */
3448 || w
->cursor
.vpos
< 0
3449 /* Give up if we are showing a message or just cleared the message
3450 because we might need to resize the echo area window. */
3451 || !NILP (echo_area_buffer
[0])
3452 || !NILP (echo_area_buffer
[1])
3453 || (glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
),
3454 /* Can't do it in a continued line because continuation
3455 lines would change. */
3456 (glyph_row
->continued_p
3457 /* Can't use this method if the line overlaps others or is
3458 overlapped by others because these other lines would
3459 have to be redisplayed. */
3460 || glyph_row
->overlapping_p
3461 || glyph_row
->overlapped_p
))
3462 /* Can't do it for partial width windows on terminal frames
3463 because we can't clear to eol in such a window. */
3464 || (!window_redisplay_p
&& !WINDOW_FULL_WIDTH_P (w
)))
3467 /* If we can't insert glyphs, we can use this method only
3468 at the end of a line. */
3469 if (!char_ins_del_ok
)
3470 if (PT
!= ZV
&& FETCH_BYTE (PT_BYTE
) != '\n')
3473 /* Set up a display iterator structure for W. Glyphs will be
3474 produced in scratch_glyph_row. Current position is W's cursor
3476 clear_glyph_row (&scratch_glyph_row
);
3477 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
3478 DEC_TEXT_POS (pos
, !NILP (current_buffer
->enable_multibyte_characters
));
3479 init_iterator (&it
, w
, CHARPOS (pos
), BYTEPOS (pos
), &scratch_glyph_row
,
3482 glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3483 if (glyph_row
->mouse_face_p
)
3486 /* Give up if highlighting trailing whitespace and we have trailing
3487 whitespace in glyph_row. We would have to remove the trailing
3488 whitespace face in that case. */
3489 if (!NILP (Vshow_trailing_whitespace
)
3490 && glyph_row
->used
[TEXT_AREA
])
3494 last
= glyph_row
->glyphs
[TEXT_AREA
] + glyph_row
->used
[TEXT_AREA
] - 1;
3495 if (last
->type
== STRETCH_GLYPH
3496 || (last
->type
== CHAR_GLYPH
3497 && last
->u
.ch
== ' '))
3501 /* Give up if there are overlay strings at pos. This would fail
3502 if the overlay string has newlines in it. */
3503 if (STRINGP (it
.string
))
3506 it
.hpos
= w
->cursor
.hpos
;
3507 it
.vpos
= w
->cursor
.vpos
;
3508 it
.current_x
= w
->cursor
.x
+ it
.first_visible_x
;
3509 it
.current_y
= w
->cursor
.y
;
3510 it
.end_charpos
= PT
;
3511 it
.stop_charpos
= min (PT
, it
.stop_charpos
);
3512 it
.stop_charpos
= max (IT_CHARPOS (it
), it
.stop_charpos
);
3514 /* More than one display element may be returned for PT - 1 if
3515 (i) it's a control character which is translated into `\003' or
3516 `^C', or (ii) it has a display table entry, or (iii) it's a
3517 combination of both. */
3518 delta
= delta_bytes
= 0;
3519 while (get_next_display_element (&it
))
3521 PRODUCE_GLYPHS (&it
);
3523 /* Give up if glyph doesn't fit completely on the line. */
3524 if (it
.current_x
>= it
.last_visible_x
)
3527 /* Give up if new glyph has different ascent or descent than
3528 the original row, or if it is not a character glyph. */
3529 if (glyph_row
->ascent
!= it
.ascent
3530 || glyph_row
->height
!= it
.ascent
+ it
.descent
3531 || glyph_row
->phys_ascent
!= it
.phys_ascent
3532 || glyph_row
->phys_height
!= it
.phys_ascent
+ it
.phys_descent
3533 || it
.what
!= IT_CHARACTER
)
3537 delta_bytes
+= it
.len
;
3538 set_iterator_to_next (&it
, 1);
3541 /* Give up if we hit the right edge of the window. We would have
3542 to insert truncation or continuation glyphs. */
3543 added_width
= it
.current_x
- (w
->cursor
.x
+ it
.first_visible_x
);
3544 if (glyph_row
->pixel_width
+ added_width
>= it
.last_visible_x
)
3547 /* Give up if there is a \t following in the line. */
3549 it2
.end_charpos
= ZV
;
3550 it2
.stop_charpos
= min (it2
.stop_charpos
, ZV
);
3551 while (get_next_display_element (&it2
)
3552 && !ITERATOR_AT_END_OF_LINE_P (&it2
))
3556 set_iterator_to_next (&it2
, 1);
3559 /* Number of new glyphs produced. */
3560 n
= it
.glyph_row
->used
[TEXT_AREA
];
3562 /* Start and end of glyphs in original row. */
3563 glyphs
= glyph_row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
3564 end
= glyph_row
->glyphs
[1 + TEXT_AREA
];
3566 /* Make room for new glyphs, then insert them. */
3567 xassert (end
- glyphs
- n
>= 0);
3568 safe_bcopy ((char *) glyphs
, (char *) (glyphs
+ n
),
3569 (end
- glyphs
- n
) * sizeof (*end
));
3570 bcopy (it
.glyph_row
->glyphs
[TEXT_AREA
], glyphs
, n
* sizeof *glyphs
);
3571 glyph_row
->used
[TEXT_AREA
] = min (glyph_row
->used
[TEXT_AREA
] + n
,
3572 end
- glyph_row
->glyphs
[TEXT_AREA
]);
3574 /* Compute new line width. */
3575 glyph
= glyph_row
->glyphs
[TEXT_AREA
];
3576 end
= glyph
+ glyph_row
->used
[TEXT_AREA
];
3577 glyph_row
->pixel_width
= glyph_row
->x
;
3580 glyph_row
->pixel_width
+= glyph
->pixel_width
;
3584 /* Increment buffer positions for glyphs following the newly
3586 for (glyph
= glyphs
+ n
; glyph
< end
; ++glyph
)
3587 if (glyph
->charpos
> 0 && BUFFERP (glyph
->object
))
3588 glyph
->charpos
+= delta
;
3590 if (MATRIX_ROW_END_CHARPOS (glyph_row
) > 0)
3592 MATRIX_ROW_END_CHARPOS (glyph_row
) += delta
;
3593 MATRIX_ROW_END_BYTEPOS (glyph_row
) += delta_bytes
;
3596 /* Adjust positions in lines following the one we are in. */
3597 increment_matrix_positions (w
->current_matrix
,
3599 w
->current_matrix
->nrows
,
3600 delta
, delta_bytes
);
3602 glyph_row
->contains_overlapping_glyphs_p
3603 |= it
.glyph_row
->contains_overlapping_glyphs_p
;
3605 glyph_row
->displays_text_p
= 1;
3606 w
->window_end_vpos
= make_number (max (w
->cursor
.vpos
,
3607 XFASTINT (w
->window_end_vpos
)));
3609 if (!NILP (Vshow_trailing_whitespace
))
3610 highlight_trailing_whitespace (it
.f
, glyph_row
);
3612 /* Write glyphs. If at end of row, we can simply call write_glyphs.
3613 In the middle, we have to insert glyphs. Note that this is now
3614 implemented for X frames. The implementation uses updated_window
3616 updated_row
= glyph_row
;
3617 updated_area
= TEXT_AREA
;
3621 rif
->update_window_begin_hook (w
);
3623 if (glyphs
== end
- n
3624 /* In front of a space added by append_space. */
3625 || (glyphs
== end
- n
- 1
3626 && (end
- n
)->charpos
<= 0))
3627 rif
->write_glyphs (glyphs
, n
);
3629 rif
->insert_glyphs (glyphs
, n
);
3633 if (glyphs
== end
- n
)
3634 write_glyphs (glyphs
, n
);
3636 insert_glyphs (glyphs
, n
);
3639 w
->cursor
.hpos
+= n
;
3640 w
->cursor
.x
= it
.current_x
- it
.first_visible_x
;
3641 xassert (w
->cursor
.hpos
>= 0
3642 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3644 /* How to set the cursor differs depending on whether we are
3645 using a frame matrix or a window matrix. Note that when
3646 a frame matrix is used, cursor_to expects frame coordinates,
3647 and the X and Y parameters are not used. */
3648 if (window_redisplay_p
)
3649 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3650 w
->cursor
.y
, w
->cursor
.x
);
3654 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3655 + (INTEGERP (w
->left_margin_width
)
3656 ? XFASTINT (w
->left_margin_width
)
3658 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3663 rif
->update_window_end_hook (w
, 1, 0);
3668 TRACE ((stderr
, "direct output for insert\n"));
3670 UNCHANGED_MODIFIED
= MODIFF
;
3671 BEG_UNCHANGED
= GPT
- BEG
;
3672 XSETFASTINT (w
->last_point
, PT
);
3673 w
->last_cursor
= w
->cursor
;
3674 XSETFASTINT (w
->last_modified
, MODIFF
);
3675 XSETFASTINT (w
->last_overlay_modified
, OVERLAY_MODIFF
);
3677 redisplay_performed_directly_p
= 1;
3682 /* Perform a direct display update for moving PT by N positions
3683 left or right. N < 0 means a movement backwards. This function
3684 is currently only called for N == 1 or N == -1. */
3687 direct_output_forward_char (n
)
3690 struct frame
*f
= SELECTED_FRAME ();
3691 struct window
*w
= XWINDOW (selected_window
);
3692 struct glyph_row
*row
;
3694 /* Give up if point moved out of or into a composition. */
3695 if (check_point_in_composition (current_buffer
, XINT (w
->last_point
),
3696 current_buffer
, PT
))
3699 /* Give up if face attributes have been changed. */
3700 if (face_change_count
)
3703 /* Give up if current matrix is not up to date or we are
3704 displaying a message. */
3705 if (!display_completed
|| cursor_in_echo_area
)
3708 /* Give up if the buffer's direction is reversed. */
3709 if (!NILP (XBUFFER (w
->buffer
)->direction_reversed
))
3712 /* Can't use direct output if highlighting a region. */
3713 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
3716 /* Can't use direct output if highlighting trailing whitespace. */
3717 if (!NILP (Vshow_trailing_whitespace
))
3720 /* Give up if we are showing a message or just cleared the message
3721 because we might need to resize the echo area window. */
3722 if (!NILP (echo_area_buffer
[0]) || !NILP (echo_area_buffer
[1]))
3725 /* Give up if currently displaying a message instead of the
3726 minibuffer contents. */
3727 if (XWINDOW (minibuf_window
) == w
3728 && EQ (minibuf_window
, echo_area_window
))
3731 /* Give up if we don't know where the cursor is. */
3732 if (w
->cursor
.vpos
< 0)
3735 row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3737 /* Give up if PT is outside of the last known cursor row. */
3738 if (PT
<= MATRIX_ROW_START_BYTEPOS (row
)
3739 || PT
>= MATRIX_ROW_END_BYTEPOS (row
))
3742 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
3744 w
->last_cursor
= w
->cursor
;
3745 XSETFASTINT (w
->last_point
, PT
);
3747 xassert (w
->cursor
.hpos
>= 0
3748 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3750 if (FRAME_WINDOW_P (f
))
3751 rif
->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3752 w
->cursor
.y
, w
->cursor
.x
);
3756 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3757 + (INTEGERP (w
->left_margin_width
)
3758 ? XFASTINT (w
->left_margin_width
)
3760 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3765 redisplay_performed_directly_p
= 1;
3771 /***********************************************************************
3773 ***********************************************************************/
3775 /* Update frame F based on the data in desired matrices.
3777 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3778 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3781 Value is non-zero if redisplay was stopped due to pending input. */
3784 update_frame (f
, force_p
, inhibit_hairy_id_p
)
3787 int inhibit_hairy_id_p
;
3789 /* 1 means display has been paused because of pending input. */
3791 struct window
*root_window
= XWINDOW (f
->root_window
);
3793 if (FRAME_WINDOW_P (f
))
3795 /* We are working on window matrix basis. All windows whose
3796 flag must_be_updated_p is set have to be updated. */
3798 /* Record that we are not working on frame matrices. */
3799 set_frame_matrix_frame (NULL
);
3801 /* Update all windows in the window tree of F, maybe stopping
3802 when pending input is detected. */
3805 /* Update the menu bar on X frames that don't have toolkit
3807 if (WINDOWP (f
->menu_bar_window
))
3808 update_window (XWINDOW (f
->menu_bar_window
), 1);
3810 /* Update the tool-bar window, if present. */
3811 if (WINDOWP (f
->tool_bar_window
))
3814 struct window
*w
= XWINDOW (f
->tool_bar_window
);
3816 /* Update tool-bar window. */
3817 if (w
->must_be_updated_p
)
3819 update_window (w
, 1);
3820 w
->must_be_updated_p
= 0;
3822 /* Swap tool-bar strings. We swap because we want to
3824 tem
= f
->current_tool_bar_string
;
3825 f
->current_tool_bar_string
= f
->desired_tool_bar_string
;
3826 f
->desired_tool_bar_string
= tem
;
3831 /* Update windows. */
3832 paused_p
= update_window_tree (root_window
, force_p
);
3835 #if 0 /* This flush is a performance bottleneck under X,
3836 and it doesn't seem to be necessary anyway. */
3837 rif
->flush_display (f
);
3842 /* We are working on frame matrix basis. Set the frame on whose
3843 frame matrix we operate. */
3844 set_frame_matrix_frame (f
);
3846 /* Build F's desired matrix from window matrices. */
3847 build_frame_matrix (f
);
3849 /* Update the display */
3851 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3855 fflush (termscript
);
3858 /* Check window matrices for lost pointers. */
3860 check_window_matrix_pointers (root_window
);
3861 add_frame_display_history (f
, paused_p
);
3865 /* Reset flags indicating that a window should be updated. */
3866 set_window_update_flags (root_window
, 0);
3868 display_completed
= !paused_p
;
3874 /************************************************************************
3875 Window-based updates
3876 ************************************************************************/
3878 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3879 don't stop updating when input is pending. */
3882 update_window_tree (w
, force_p
)
3888 while (w
&& !paused_p
)
3890 if (!NILP (w
->hchild
))
3891 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
3892 else if (!NILP (w
->vchild
))
3893 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
3894 else if (w
->must_be_updated_p
)
3895 paused_p
|= update_window (w
, force_p
);
3897 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3904 /* Update window W if its flag must_be_updated_p is non-zero. If
3905 FORCE_P is non-zero, don't stop updating if input is pending. */
3908 update_single_window (w
, force_p
)
3912 if (w
->must_be_updated_p
)
3914 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3916 /* Record that this is not a frame-based redisplay. */
3917 set_frame_matrix_frame (NULL
);
3921 update_window (w
, force_p
);
3924 /* Reset flag in W. */
3925 w
->must_be_updated_p
= 0;
3930 /* Redraw lines from the current matrix of window W that are
3931 overlapped by other rows. YB is bottom-most y-position in W. */
3934 redraw_overlapped_rows (w
, yb
)
3940 /* If rows overlapping others have been changed, the rows being
3941 overlapped have to be redrawn. This won't draw lines that have
3942 already been drawn in update_window_line because overlapped_p in
3943 desired rows is 0, so after row assignment overlapped_p in
3944 current rows is 0. */
3945 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3947 struct glyph_row
*row
= w
->current_matrix
->rows
+ i
;
3949 if (!row
->enabled_p
)
3951 else if (row
->mode_line_p
)
3954 if (row
->overlapped_p
)
3956 enum glyph_row_area area
;
3958 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3961 updated_area
= area
;
3962 rif
->cursor_to (i
, 0, row
->y
, area
== TEXT_AREA
? row
->x
: 0);
3963 if (row
->used
[area
])
3964 rif
->write_glyphs (row
->glyphs
[area
], row
->used
[area
]);
3965 rif
->clear_end_of_line (-1);
3968 row
->overlapped_p
= 0;
3971 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3977 /* Redraw lines from the current matrix of window W that overlap
3978 others. YB is bottom-most y-position in W. */
3981 redraw_overlapping_rows (w
, yb
)
3986 struct glyph_row
*row
;
3988 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3990 row
= w
->current_matrix
->rows
+ i
;
3992 if (!row
->enabled_p
)
3994 else if (row
->mode_line_p
)
3997 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3999 if (row
->overlapping_p
&& i
> 0 && bottom_y
< yb
)
4001 if (row
->used
[LEFT_MARGIN_AREA
])
4002 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
);
4004 if (row
->used
[TEXT_AREA
])
4005 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
);
4007 if (row
->used
[RIGHT_MARGIN_AREA
])
4008 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
);
4010 /* Record in neighbor rows that ROW overwrites part of their
4012 if (row
->phys_ascent
> row
->ascent
&& i
> 0)
4013 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
4014 if ((row
->phys_height
- row
->phys_ascent
4015 > row
->height
- row
->ascent
)
4017 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
4028 /* Check that no row in the current matrix of window W is enabled
4029 which is below what's displayed in the window. */
4032 check_current_matrix_flags (w
)
4035 int last_seen_p
= 0;
4036 int i
, yb
= window_text_bottom_y (w
);
4038 for (i
= 0; i
< w
->current_matrix
->nrows
- 1; ++i
)
4040 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
4041 if (!last_seen_p
&& MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4043 else if (last_seen_p
&& row
->enabled_p
)
4048 #endif /* GLYPH_DEBUG */
4051 /* Update display of window W. FORCE_P non-zero means that we should
4052 not stop when detecting pending input. */
4055 update_window (w
, force_p
)
4059 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4061 int preempt_count
= baud_rate
/ 2400 + 1;
4062 extern int input_pending
;
4063 extern Lisp_Object do_mouse_tracking
;
4065 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4066 extern struct frame
*updating_frame
;
4069 /* Check that W's frame doesn't have glyph matrices. */
4070 xassert (FRAME_WINDOW_P (f
));
4071 xassert (updating_frame
!= NULL
);
4073 /* Check pending input the first time so that we can quickly return. */
4074 if (redisplay_dont_pause
)
4077 detect_input_pending ();
4079 /* If forced to complete the update, or if no input is pending, do
4081 if (force_p
|| !input_pending
|| !NILP (do_mouse_tracking
))
4083 struct glyph_row
*row
, *end
;
4084 struct glyph_row
*mode_line_row
;
4085 struct glyph_row
*header_line_row
;
4086 int yb
, changed_p
= 0, mouse_face_overwritten_p
= 0, n_updated
;
4088 rif
->update_window_begin_hook (w
);
4089 yb
= window_text_bottom_y (w
);
4091 /* If window has a top line, update it before everything else.
4092 Adjust y-positions of other rows by the top line height. */
4093 row
= desired_matrix
->rows
;
4094 end
= row
+ desired_matrix
->nrows
- 1;
4096 if (row
->mode_line_p
)
4098 header_line_row
= row
;
4102 header_line_row
= NULL
;
4104 /* Update the mode line, if necessary. */
4105 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
4106 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
4108 mode_line_row
->y
= yb
;
4109 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
4111 &mouse_face_overwritten_p
);
4115 /* Find first enabled row. Optimizations in redisplay_internal
4116 may lead to an update with only one row enabled. There may
4117 be also completely empty matrices. */
4118 while (row
< end
&& !row
->enabled_p
)
4121 /* Try reusing part of the display by copying. */
4122 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
4124 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
4127 /* All rows were found to be equal. */
4132 /* We've scrolled the display. */
4137 /* Update the top mode line after scrolling because a new top
4138 line would otherwise overwrite lines at the top of the window
4139 that can be scrolled. */
4140 if (header_line_row
&& header_line_row
->enabled_p
)
4142 header_line_row
->y
= 0;
4143 update_window_line (w
, 0, &mouse_face_overwritten_p
);
4147 /* Update the rest of the lines. */
4148 for (n_updated
= 0; row
< end
&& (force_p
|| !input_pending
); ++row
)
4151 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
4154 /* We'll Have to play a little bit with when to
4155 detect_input_pending. If it's done too often,
4156 scrolling large windows with repeated scroll-up
4157 commands will too quickly pause redisplay. */
4158 if (!force_p
&& ++n_updated
% preempt_count
== 0)
4159 detect_input_pending ();
4161 changed_p
|= update_window_line (w
, vpos
,
4162 &mouse_face_overwritten_p
);
4164 /* Mark all rows below the last visible one in the current
4165 matrix as invalid. This is necessary because of
4166 variable line heights. Consider the case of three
4167 successive redisplays, where the first displays 5
4168 lines, the second 3 lines, and the third 5 lines again.
4169 If the second redisplay wouldn't mark rows in the
4170 current matrix invalid, the third redisplay might be
4171 tempted to optimize redisplay based on lines displayed
4172 in the first redisplay. */
4173 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4174 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
4175 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
4178 /* Was display preempted? */
4179 paused_p
= row
< end
;
4183 /* Fix the appearance of overlapping(overlapped rows. */
4184 if (!paused_p
&& !w
->pseudo_window_p
)
4186 if (changed_p
&& rif
->fix_overlapping_area
)
4188 redraw_overlapped_rows (w
, yb
);
4189 redraw_overlapping_rows (w
, yb
);
4192 /* Make cursor visible at cursor position of W. */
4193 set_window_cursor_after_update (w
);
4195 #if 0 /* Check that current matrix invariants are satisfied. This is
4196 for debugging only. See the comment of check_matrix_invariants. */
4197 IF_DEBUG (check_matrix_invariants (w
));
4202 /* Remember the redisplay method used to display the matrix. */
4203 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
4206 /* End the update of window W. Don't set the cursor if we
4207 paused updating the display because in this case,
4208 set_window_cursor_after_update hasn't been called, and
4209 output_cursor doesn't contain the cursor location. */
4210 rif
->update_window_end_hook (w
, !paused_p
, mouse_face_overwritten_p
);
4216 /* check_current_matrix_flags (w); */
4217 add_window_display_history (w
, w
->current_matrix
->method
, paused_p
);
4220 clear_glyph_matrix (desired_matrix
);
4226 /* Update the display of area AREA in window W, row number VPOS.
4227 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
4230 update_marginal_area (w
, area
, vpos
)
4234 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
4236 /* Let functions in xterm.c know what area subsequent X positions
4237 will be relative to. */
4238 updated_area
= area
;
4240 /* Set cursor to start of glyphs, write them, and clear to the end
4241 of the area. I don't think that something more sophisticated is
4242 necessary here, since marginal areas will not be the default. */
4243 rif
->cursor_to (vpos
, 0, desired_row
->y
, 0);
4244 if (desired_row
->used
[area
])
4245 rif
->write_glyphs (desired_row
->glyphs
[area
], desired_row
->used
[area
]);
4246 rif
->clear_end_of_line (-1);
4250 /* Update the display of the text area of row VPOS in window W.
4251 Value is non-zero if display has changed. */
4254 update_text_area (w
, vpos
)
4258 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
4259 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
4262 /* Let functions in xterm.c know what area subsequent X positions
4263 will be relative to. */
4264 updated_area
= TEXT_AREA
;
4266 /* If rows are at different X or Y, or rows have different height,
4267 or the current row is marked invalid, write the entire line. */
4268 if (!current_row
->enabled_p
4269 || desired_row
->y
!= current_row
->y
4270 || desired_row
->ascent
!= current_row
->ascent
4271 || desired_row
->phys_ascent
!= current_row
->phys_ascent
4272 || desired_row
->phys_height
!= current_row
->phys_height
4273 || desired_row
->visible_height
!= current_row
->visible_height
4274 || current_row
->overlapped_p
4275 || current_row
->mouse_face_p
4276 || current_row
->x
!= desired_row
->x
)
4278 rif
->cursor_to (vpos
, 0, desired_row
->y
, desired_row
->x
);
4280 if (desired_row
->used
[TEXT_AREA
])
4281 rif
->write_glyphs (desired_row
->glyphs
[TEXT_AREA
],
4282 desired_row
->used
[TEXT_AREA
]);
4284 /* Clear to end of window. */
4285 rif
->clear_end_of_line (-1);
4291 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
4292 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
4293 int overlapping_glyphs_p
= current_row
->contains_overlapping_glyphs_p
;
4294 int desired_stop_pos
= desired_row
->used
[TEXT_AREA
];
4296 /* If the desired row extends its face to the text area end,
4297 make sure we write at least one glyph, so that the face
4298 extension actually takes place. */
4299 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
4302 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
4306 /* Loop over glyphs that current and desired row may have
4312 /* Skip over glyphs that both rows have in common. These
4313 don't have to be written. We can't skip if the last
4314 current glyph overlaps the glyph to its right. For
4315 example, consider a current row of `if ' with the `f' in
4316 Courier bold so that it overlaps the ` ' to its right.
4317 If the desired row is ` ', we would skip over the space
4318 after the `if' and there would remain a pixel from the
4319 `f' on the screen. */
4320 if (overlapping_glyphs_p
&& i
> 0)
4322 struct glyph
*glyph
= ¤t_row
->glyphs
[TEXT_AREA
][i
- 1];
4325 rif
->get_glyph_overhangs (glyph
, XFRAME (w
->frame
),
4327 can_skip_p
= right
== 0;
4333 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
4335 x
+= desired_glyph
->pixel_width
;
4336 ++desired_glyph
, ++current_glyph
, ++i
;
4339 /* Consider the case that the current row contains "xxx
4340 ppp ggg" in italic Courier font, and the desired row
4341 is "xxx ggg". The character `p' has lbearing, `g'
4342 has not. The loop above will stop in front of the
4343 first `p' in the current row. If we would start
4344 writing glyphs there, we wouldn't erase the lbearing
4345 of the `p'. The rest of the lbearing problem is then
4346 taken care of by x_draw_glyphs. */
4347 if (overlapping_glyphs_p
4349 && i
< current_row
->used
[TEXT_AREA
]
4350 && (current_row
->used
[TEXT_AREA
]
4351 != desired_row
->used
[TEXT_AREA
]))
4355 rif
->get_glyph_overhangs (current_glyph
, XFRAME (w
->frame
),
4357 while (left
> 0 && i
> 0)
4359 --i
, --desired_glyph
, --current_glyph
;
4360 x
-= desired_glyph
->pixel_width
;
4361 left
-= desired_glyph
->pixel_width
;
4366 /* Try to avoid writing the entire rest of the desired row
4367 by looking for a resync point. This mainly prevents
4368 mode line flickering in the case the mode line is in
4369 fixed-pitch font, which it usually will be. */
4370 if (i
< desired_row
->used
[TEXT_AREA
])
4372 int start_x
= x
, start_hpos
= i
;
4373 struct glyph
*start
= desired_glyph
;
4375 int skip_first_p
= !can_skip_p
;
4377 /* Find the next glyph that's equal again. */
4380 || !GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
4383 x
+= desired_glyph
->pixel_width
;
4384 current_x
+= current_glyph
->pixel_width
;
4385 ++desired_glyph
, ++current_glyph
, ++i
;
4389 if (i
== start_hpos
|| x
!= current_x
)
4393 desired_glyph
= start
;
4397 rif
->cursor_to (vpos
, start_hpos
, desired_row
->y
, start_x
);
4398 rif
->write_glyphs (start
, i
- start_hpos
);
4403 /* Write the rest. */
4404 if (i
< desired_row
->used
[TEXT_AREA
])
4406 rif
->cursor_to (vpos
, i
, desired_row
->y
, x
);
4407 rif
->write_glyphs (desired_glyph
, desired_row
->used
[TEXT_AREA
] - i
);
4411 /* Maybe clear to end of line. */
4412 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
4414 /* If new row extends to the end of the text area, nothing
4415 has to be cleared, if and only if we did a write_glyphs
4416 above. This is made sure by setting desired_stop_pos
4417 appropriately above. */
4418 xassert (i
< desired_row
->used
[TEXT_AREA
]);
4420 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
4422 /* If old row extends to the end of the text area, clear. */
4423 if (i
>= desired_row
->used
[TEXT_AREA
])
4424 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4425 desired_row
->x
+ desired_row
->pixel_width
);
4426 rif
->clear_end_of_line (-1);
4429 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
4431 /* Otherwise clear to the end of the old row. Everything
4432 after that position should be clear already. */
4435 if (i
>= desired_row
->used
[TEXT_AREA
])
4436 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4437 desired_row
->x
+ desired_row
->pixel_width
);
4439 /* If cursor is displayed at the end of the line, make sure
4440 it's cleared. Nowadays we don't have a phys_cursor_glyph
4441 with which to erase the cursor (because this method
4442 doesn't work with lbearing/rbearing), so we must do it
4444 if (vpos
== w
->phys_cursor
.vpos
4445 && w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])
4447 w
->phys_cursor_on_p
= 0;
4451 x
= current_row
->x
+ current_row
->pixel_width
;
4452 rif
->clear_end_of_line (x
);
4461 /* Update row VPOS in window W. Value is non-zero if display has been
4465 update_window_line (w
, vpos
, mouse_face_overwritten_p
)
4467 int vpos
, *mouse_face_overwritten_p
;
4469 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
4470 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
4473 /* Set the row being updated. This is important to let xterm.c
4474 know what line height values are in effect. */
4475 updated_row
= desired_row
;
4477 /* A row can be completely invisible in case a desired matrix was
4478 built with a vscroll and then make_cursor_line_fully_visible shifts
4479 the matrix. Make sure to make such rows current anyway, since
4480 we need the correct y-position, for example, in the current matrix. */
4481 if (desired_row
->mode_line_p
4482 || desired_row
->visible_height
> 0)
4484 xassert (desired_row
->enabled_p
);
4486 /* Update display of the left margin area, if there is one. */
4487 if (!desired_row
->full_width_p
4488 && !NILP (w
->left_margin_width
))
4491 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
4494 /* Update the display of the text area. */
4495 if (update_text_area (w
, vpos
))
4498 if (current_row
->mouse_face_p
)
4499 *mouse_face_overwritten_p
= 1;
4502 /* Update display of the right margin area, if there is one. */
4503 if (!desired_row
->full_width_p
4504 && !NILP (w
->right_margin_width
))
4507 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
4510 /* Draw truncation marks etc. */
4511 if (!current_row
->enabled_p
4512 || desired_row
->y
!= current_row
->y
4513 || desired_row
->visible_height
!= current_row
->visible_height
4514 || desired_row
->overlay_arrow_p
!= current_row
->overlay_arrow_p
4515 || desired_row
->truncated_on_left_p
!= current_row
->truncated_on_left_p
4516 || desired_row
->truncated_on_right_p
!= current_row
->truncated_on_right_p
4517 || desired_row
->continued_p
!= current_row
->continued_p
4518 || desired_row
->mode_line_p
!= current_row
->mode_line_p
4519 || (desired_row
->indicate_empty_line_p
4520 != current_row
->indicate_empty_line_p
)
4521 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
4522 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
4523 rif
->after_update_window_line_hook (desired_row
);
4526 /* Update current_row from desired_row. */
4527 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4533 /* Set the cursor after an update of window W. This function may only
4534 be called from update_window. */
4537 set_window_cursor_after_update (w
)
4540 struct frame
*f
= XFRAME (w
->frame
);
4541 int cx
, cy
, vpos
, hpos
;
4543 /* Not intended for frame matrix updates. */
4544 xassert (FRAME_WINDOW_P (f
));
4546 if (cursor_in_echo_area
4547 && !NILP (echo_area_buffer
[0])
4548 /* If we are showing a message instead of the mini-buffer,
4549 show the cursor for the message instead. */
4550 && XWINDOW (minibuf_window
) == w
4551 && EQ (minibuf_window
, echo_area_window
)
4552 /* These cases apply only to the frame that contains
4553 the active mini-buffer window. */
4554 && FRAME_HAS_MINIBUF_P (f
)
4555 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4557 cx
= cy
= vpos
= hpos
= 0;
4559 if (cursor_in_echo_area
>= 0)
4561 /* If the mini-buffer is several lines high, find the last
4562 line that has any text on it. Note: either all lines
4563 are enabled or none. Otherwise we wouldn't be able to
4565 struct glyph_row
*row
, *last_row
;
4566 struct glyph
*glyph
;
4567 int yb
= window_text_bottom_y (w
);
4570 row
= w
->current_matrix
->rows
;
4571 while (row
->enabled_p
4572 && (last_row
== NULL
4573 || MATRIX_ROW_BOTTOM_Y (row
) <= yb
))
4575 if (row
->used
[TEXT_AREA
]
4576 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4583 struct glyph
*start
= last_row
->glyphs
[TEXT_AREA
];
4584 struct glyph
*last
= start
+ last_row
->used
[TEXT_AREA
] - 1;
4586 while (last
> start
&& last
->charpos
< 0)
4589 for (glyph
= start
; glyph
< last
; ++glyph
)
4591 cx
+= glyph
->pixel_width
;
4596 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4604 hpos
= w
->cursor
.hpos
;
4605 vpos
= w
->cursor
.vpos
;
4608 /* Window cursor can be out of sync for horizontally split windows. */
4609 hpos
= max (0, hpos
);
4610 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4611 vpos
= max (0, vpos
);
4612 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4613 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4617 /* Set WINDOW->must_be_updated_p to ON_P for all windows in the window
4618 tree rooted at W. */
4621 set_window_update_flags (w
, on_p
)
4627 if (!NILP (w
->hchild
))
4628 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4629 else if (!NILP (w
->vchild
))
4630 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4632 w
->must_be_updated_p
= on_p
;
4634 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4640 /***********************************************************************
4641 Window-Based Scrolling
4642 ***********************************************************************/
4644 /* Structure describing rows in scrolling_window. */
4648 /* Number of occurrences of this row in desired and current matrix. */
4649 int old_uses
, new_uses
;
4651 /* Vpos of row in new matrix. */
4652 int new_line_number
;
4654 /* Bucket index of this row_entry in the hash table row_table. */
4657 /* The row described by this entry. */
4658 struct glyph_row
*row
;
4660 /* Hash collision chain. */
4661 struct row_entry
*next
;
4664 /* A pool to allocate row_entry structures from, and the size of the
4665 pool. The pool is reallocated in scrolling_window when we find
4666 that we need a larger one. */
4668 static struct row_entry
*row_entry_pool
;
4669 static int row_entry_pool_size
;
4671 /* Index of next free entry in row_entry_pool. */
4673 static int row_entry_idx
;
4675 /* The hash table used during scrolling, and the table's size. This
4676 table is used to quickly identify equal rows in the desired and
4679 static struct row_entry
**row_table
;
4680 static int row_table_size
;
4682 /* Vectors of pointers to row_entry structures belonging to the
4683 current and desired matrix, and the size of the vectors. */
4685 static struct row_entry
**old_lines
, **new_lines
;
4686 static int old_lines_size
, new_lines_size
;
4688 /* A pool to allocate run structures from, and its size. */
4690 static struct run
*run_pool
;
4691 static int runs_size
;
4693 /* A vector of runs of lines found during scrolling. */
4695 static struct run
**runs
;
4697 static struct row_entry
*add_row_entry
P_ ((struct window
*,
4698 struct glyph_row
*));
4701 /* Add glyph row ROW to the scrolling hash table during the scrolling
4704 static INLINE
struct row_entry
*
4705 add_row_entry (w
, row
)
4707 struct glyph_row
*row
;
4709 struct row_entry
*entry
;
4710 int i
= row
->hash
% row_table_size
;
4712 entry
= row_table
[i
];
4713 while (entry
&& !row_equal_p (w
, entry
->row
, row
, 1))
4714 entry
= entry
->next
;
4718 entry
= row_entry_pool
+ row_entry_idx
++;
4720 entry
->old_uses
= entry
->new_uses
= 0;
4721 entry
->new_line_number
= 0;
4723 entry
->next
= row_table
[i
];
4724 row_table
[i
] = entry
;
4731 /* Try to reuse part of the current display of W by scrolling lines.
4732 HEADER_LINE_P non-zero means W has a top mode line.
4734 The algorithm is taken from Communications of the ACM, Apr78 "A
4735 Technique for Isolating Differences Between Files." It should take
4738 A short outline of the steps of the algorithm
4740 1. Skip lines equal at the start and end of both matrices.
4742 2. Enter rows in the current and desired matrix into a symbol
4743 table, counting how often they appear in both matrices.
4745 3. Rows that appear exactly once in both matrices serve as anchors,
4746 i.e. we assume that such lines are likely to have been moved.
4748 4. Starting from anchor lines, extend regions to be scrolled both
4749 forward and backward.
4753 -1 if all rows were found to be equal.
4754 0 to indicate that we did not scroll the display, or
4755 1 if we did scroll. */
4758 scrolling_window (w
, header_line_p
)
4762 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4763 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4764 int yb
= window_text_bottom_y (w
);
4765 int i
, j
, first_old
, first_new
, last_old
, last_new
;
4766 int nruns
, nbytes
, n
, run_idx
;
4767 struct row_entry
*entry
;
4769 /* Skip over rows equal at the start. */
4770 for (i
= header_line_p
? 1 : 0; i
< current_matrix
->nrows
- 1; ++i
)
4772 struct glyph_row
*d
= MATRIX_ROW (desired_matrix
, i
);
4773 struct glyph_row
*c
= MATRIX_ROW (current_matrix
, i
);
4778 && MATRIX_ROW_BOTTOM_Y (c
) <= yb
4779 && MATRIX_ROW_BOTTOM_Y (d
) <= yb
4780 && row_equal_p (w
, c
, d
, 1))
4789 /* Give up if some rows in the desired matrix are not enabled. */
4790 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4793 first_old
= first_new
= i
;
4795 /* Set last_new to the index + 1 of the last enabled row in the
4798 while (i
< desired_matrix
->nrows
- 1
4799 && MATRIX_ROW (desired_matrix
, i
)->enabled_p
4800 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) <= yb
)
4803 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4808 /* Set last_old to the index + 1 of the last enabled row in the
4809 current matrix. We don't look at the enabled flag here because
4810 we plan to reuse part of the display even if other parts are
4813 while (i
< current_matrix
->nrows
- 1)
4815 int bottom
= MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
));
4824 /* Skip over rows equal at the bottom. */
4827 while (i
- 1 > first_new
4828 && j
- 1 > first_old
4829 && MATRIX_ROW (current_matrix
, i
- 1)->enabled_p
4830 && (MATRIX_ROW (current_matrix
, i
- 1)->y
4831 == MATRIX_ROW (desired_matrix
, j
- 1)->y
)
4833 MATRIX_ROW (desired_matrix
, i
- 1),
4834 MATRIX_ROW (current_matrix
, j
- 1), 1))
4839 /* Nothing to do if all rows are equal. */
4840 if (last_new
== first_new
)
4843 /* Reallocate vectors, tables etc. if necessary. */
4845 if (current_matrix
->nrows
> old_lines_size
)
4847 old_lines_size
= current_matrix
->nrows
;
4848 nbytes
= old_lines_size
* sizeof *old_lines
;
4849 old_lines
= (struct row_entry
**) xrealloc (old_lines
, nbytes
);
4852 if (desired_matrix
->nrows
> new_lines_size
)
4854 new_lines_size
= desired_matrix
->nrows
;
4855 nbytes
= new_lines_size
* sizeof *new_lines
;
4856 new_lines
= (struct row_entry
**) xrealloc (new_lines
, nbytes
);
4859 n
= desired_matrix
->nrows
+ current_matrix
->nrows
;
4860 if (3 * n
> row_table_size
)
4862 row_table_size
= next_almost_prime (3 * n
);
4863 nbytes
= row_table_size
* sizeof *row_table
;
4864 row_table
= (struct row_entry
**) xrealloc (row_table
, nbytes
);
4865 bzero (row_table
, nbytes
);
4868 if (n
> row_entry_pool_size
)
4870 row_entry_pool_size
= n
;
4871 nbytes
= row_entry_pool_size
* sizeof *row_entry_pool
;
4872 row_entry_pool
= (struct row_entry
*) xrealloc (row_entry_pool
, nbytes
);
4875 if (desired_matrix
->nrows
> runs_size
)
4877 runs_size
= desired_matrix
->nrows
;
4878 nbytes
= runs_size
* sizeof *runs
;
4879 runs
= (struct run
**) xrealloc (runs
, nbytes
);
4880 nbytes
= runs_size
* sizeof *run_pool
;
4881 run_pool
= (struct run
*) xrealloc (run_pool
, nbytes
);
4884 nruns
= run_idx
= 0;
4887 /* Add rows from the current and desired matrix to the hash table
4888 row_hash_table to be able to find equal ones quickly. */
4890 for (i
= first_old
; i
< last_old
; ++i
)
4892 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4894 entry
= add_row_entry (w
, MATRIX_ROW (current_matrix
, i
));
4895 old_lines
[i
] = entry
;
4899 old_lines
[i
] = NULL
;
4902 for (i
= first_new
; i
< last_new
; ++i
)
4904 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4905 entry
= add_row_entry (w
, MATRIX_ROW (desired_matrix
, i
));
4907 entry
->new_line_number
= i
;
4908 new_lines
[i
] = entry
;
4911 /* Identify moves based on lines that are unique and equal
4912 in both matrices. */
4913 for (i
= first_old
; i
< last_old
;)
4915 && old_lines
[i
]->old_uses
== 1
4916 && old_lines
[i
]->new_uses
== 1)
4919 int new_line
= old_lines
[i
]->new_line_number
;
4920 struct run
*run
= run_pool
+ run_idx
++;
4923 run
->current_vpos
= i
;
4924 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4925 run
->desired_vpos
= new_line
;
4926 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4928 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4930 /* Extend backward. */
4933 while (j
> first_old
4935 && old_lines
[j
] == new_lines
[k
])
4937 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4938 --run
->current_vpos
;
4939 --run
->desired_vpos
;
4942 run
->desired_y
-= h
;
4943 run
->current_y
-= h
;
4947 /* Extend forward. */
4952 && old_lines
[j
] == new_lines
[k
])
4954 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
4960 /* Insert run into list of all runs. Order runs by copied
4961 pixel lines. Note that we record runs that don't have to
4962 be copied because they are already in place. This is done
4963 because we can avoid calling update_window_line in this
4965 for (j
= 0; j
< nruns
&& runs
[j
]->height
> run
->height
; ++j
)
4967 for (k
= nruns
; k
> j
; --k
)
4968 runs
[k
] = runs
[k
- 1];
4977 /* Do the moves. Do it in a way that we don't overwrite something
4978 we want to copy later on. This is not solvable in general
4979 because there is only one display and we don't have a way to
4980 exchange areas on this display. Example:
4982 +-----------+ +-----------+
4984 +-----------+ --> +-----------+
4986 +-----------+ +-----------+
4988 Instead, prefer bigger moves, and invalidate moves that would
4989 copy from where we copied to. */
4991 for (i
= 0; i
< nruns
; ++i
)
4992 if (runs
[i
]->nrows
> 0)
4994 struct run
*r
= runs
[i
];
4996 /* Copy on the display. */
4997 if (r
->current_y
!= r
->desired_y
)
4999 rif
->scroll_run_hook (w
, r
);
5001 /* Invalidate runs that copy from where we copied to. */
5002 for (j
= i
+ 1; j
< nruns
; ++j
)
5004 struct run
*p
= runs
[j
];
5006 if ((p
->current_y
>= r
->desired_y
5007 && p
->current_y
< r
->desired_y
+ r
->height
)
5008 || (p
->current_y
+ p
->height
>= r
->desired_y
5009 && (p
->current_y
+ p
->height
5010 < r
->desired_y
+ r
->height
)))
5015 /* Assign matrix rows. */
5016 for (j
= 0; j
< r
->nrows
; ++j
)
5018 struct glyph_row
*from
, *to
;
5019 int to_overlapped_p
;
5021 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
5022 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
5023 to_overlapped_p
= to
->overlapped_p
;
5024 assign_row (to
, from
);
5025 to
->enabled_p
= 1, from
->enabled_p
= 0;
5026 to
->overlapped_p
= to_overlapped_p
;
5030 /* Clear the hash table, for the next time. */
5031 for (i
= 0; i
< row_entry_idx
; ++i
)
5032 row_table
[row_entry_pool
[i
].bucket
] = NULL
;
5034 /* Value is non-zero to indicate that we scrolled the display. */
5040 /************************************************************************
5042 ************************************************************************/
5044 /* Update the desired frame matrix of frame F.
5046 FORCE_P non-zero means that the update should not be stopped by
5047 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
5048 should not be tried.
5050 Value is non-zero if update was stopped due to pending input. */
5053 update_frame_1 (f
, force_p
, inhibit_id_p
)
5058 /* Frame matrices to work on. */
5059 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
5060 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
5063 int preempt_count
= baud_rate
/ 2400 + 1;
5064 extern int input_pending
;
5066 xassert (current_matrix
&& desired_matrix
);
5068 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
5069 calculate_costs (f
);
5071 if (preempt_count
<= 0)
5074 if (redisplay_dont_pause
)
5076 else if (!force_p
&& detect_input_pending ())
5082 /* If we cannot insert/delete lines, it's no use trying it. */
5083 if (!line_ins_del_ok
)
5086 /* See if any of the desired lines are enabled; don't compute for
5087 i/d line if just want cursor motion. */
5088 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
5089 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
5092 /* Try doing i/d line, if not yet inhibited. */
5093 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
5094 force_p
|= scrolling (f
);
5096 /* Update the individual lines as needed. Do bottom line first. */
5097 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
5098 update_frame_line (f
, desired_matrix
->nrows
- 1);
5100 /* Now update the rest of the lines. */
5101 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
5103 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
5105 if (FRAME_TERMCAP_P (f
))
5107 /* Flush out every so many lines.
5108 Also flush out if likely to have more than 1k buffered
5109 otherwise. I'm told that some telnet connections get
5110 really screwed by more than 1k output at once. */
5111 int outq
= PENDING_OUTPUT_COUNT (stdout
);
5113 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
5116 if (preempt_count
== 1)
5118 #ifdef EMACS_OUTQSIZE
5119 if (EMACS_OUTQSIZE (0, &outq
) < 0)
5120 /* Probably not a tty. Ignore the error and reset
5121 * the outq count. */
5122 outq
= PENDING_OUTPUT_COUNT (stdout
);
5125 if (baud_rate
<= outq
&& baud_rate
> 0)
5126 sleep (outq
/ baud_rate
);
5131 if ((i
- 1) % preempt_count
== 0)
5132 detect_input_pending ();
5134 update_frame_line (f
, i
);
5138 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
5140 /* Now just clean up termcap drivers and set cursor, etc. */
5143 if ((cursor_in_echo_area
5144 /* If we are showing a message instead of the mini-buffer,
5145 show the cursor for the message instead of for the
5146 (now hidden) mini-buffer contents. */
5147 || (EQ (minibuf_window
, selected_window
)
5148 && EQ (minibuf_window
, echo_area_window
)
5149 && !NILP (echo_area_buffer
[0])))
5150 /* These cases apply only to the frame that contains
5151 the active mini-buffer window. */
5152 && FRAME_HAS_MINIBUF_P (f
)
5153 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
5155 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
5158 if (cursor_in_echo_area
< 0)
5160 /* Negative value of cursor_in_echo_area means put
5161 cursor at beginning of line. */
5167 /* Positive value of cursor_in_echo_area means put
5168 cursor at the end of the prompt. If the mini-buffer
5169 is several lines high, find the last line that has
5171 row
= FRAME_HEIGHT (f
);
5177 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
5179 /* Frame rows are filled up with spaces that
5180 must be ignored here. */
5181 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
5183 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
5184 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
5187 && (last
- 1)->charpos
< 0)
5193 while (row
> top
&& col
== 0);
5195 /* Make sure COL is not out of range. */
5196 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
5198 /* If we have another row, advance cursor into it. */
5199 if (row
< FRAME_HEIGHT (f
) - 1)
5201 col
= FRAME_LEFT_SCROLL_BAR_WIDTH (f
);
5204 /* Otherwise move it back in range. */
5206 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
5210 cursor_to (row
, col
);
5214 /* We have only one cursor on terminal frames. Use it to
5215 display the cursor of the selected window. */
5216 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5217 if (w
->cursor
.vpos
>= 0
5218 /* The cursor vpos may be temporarily out of bounds
5219 in the following situation: There is one window,
5220 with the cursor in the lower half of it. The window
5221 is split, and a message causes a redisplay before
5222 a new cursor position has been computed. */
5223 && w
->cursor
.vpos
< XFASTINT (w
->height
))
5225 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
5226 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
5228 if (INTEGERP (w
->left_margin_width
))
5229 x
+= XFASTINT (w
->left_margin_width
);
5231 /* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
5239 clear_desired_matrices (f
);
5244 /* Do line insertions/deletions on frame F for frame-based redisplay. */
5248 struct frame
*frame
;
5250 int unchanged_at_top
, unchanged_at_bottom
;
5253 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
5254 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
5255 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
5256 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
5258 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
5259 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
5260 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
5262 if (!current_matrix
)
5265 /* Compute hash codes of all the lines. Also calculate number of
5266 changed lines, number of unchanged lines at the beginning, and
5267 number of unchanged lines at the end. */
5269 unchanged_at_top
= 0;
5270 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
5271 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
5273 /* Give up on this scrolling if some old lines are not enabled. */
5274 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
5276 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
5277 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
5279 /* This line cannot be redrawn, so don't let scrolling mess it. */
5280 new_hash
[i
] = old_hash
[i
];
5281 #define INFINITY 1000000 /* Taken from scroll.c */
5282 draw_cost
[i
] = INFINITY
;
5286 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
5287 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
5290 if (old_hash
[i
] != new_hash
[i
])
5293 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
5295 else if (i
== unchanged_at_top
)
5297 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
5300 /* If changed lines are few, don't allow preemption, don't scroll. */
5301 if ((!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400)
5302 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
5305 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
5306 - unchanged_at_bottom
);
5308 if (scroll_region_ok
)
5309 free_at_end_vpos
-= unchanged_at_bottom
;
5310 else if (memory_below_frame
)
5311 free_at_end_vpos
= -1;
5313 /* If large window, fast terminal and few lines in common between
5314 current frame and desired frame, don't bother with i/d calc. */
5315 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
5317 10 * scrolling_max_lines_saved (unchanged_at_top
,
5318 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
5319 old_hash
, new_hash
, draw_cost
)))
5322 if (window_size
< 2)
5325 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
5326 draw_cost
+ unchanged_at_top
- 1,
5327 old_draw_cost
+ unchanged_at_top
- 1,
5328 old_hash
+ unchanged_at_top
- 1,
5329 new_hash
+ unchanged_at_top
- 1,
5330 free_at_end_vpos
- unchanged_at_top
);
5336 /* Count the number of blanks at the start of the vector of glyphs R
5337 which is LEN glyphs long. */
5340 count_blanks (r
, len
)
5346 for (i
= 0; i
< len
; ++i
)
5347 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
5354 /* Count the number of glyphs in common at the start of the glyph
5355 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
5356 of STR2. Value is the number of equal glyphs equal at the start. */
5359 count_match (str1
, end1
, str2
, end2
)
5360 struct glyph
*str1
, *end1
, *str2
, *end2
;
5362 struct glyph
*p1
= str1
;
5363 struct glyph
*p2
= str2
;
5367 && GLYPH_CHAR_AND_FACE_EQUAL_P (p1
, p2
))
5374 /* Char insertion/deletion cost vector, from term.c */
5376 extern int *char_ins_del_vector
;
5377 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
5380 /* Perform a frame-based update on line VPOS in frame FRAME. */
5383 update_frame_line (f
, vpos
)
5387 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
5389 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
5390 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
5391 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
5392 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
5393 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
5394 int must_write_whole_line_p
;
5395 int write_spaces_p
= must_write_spaces
;
5396 int colored_spaces_p
= (FACE_FROM_ID (f
, DEFAULT_FACE_ID
)->background
5397 != FACE_TTY_DEFAULT_BG_COLOR
);
5399 if (colored_spaces_p
)
5402 if (desired_row
->inverse_p
5403 != (current_row
->enabled_p
&& current_row
->inverse_p
))
5405 int n
= current_row
->enabled_p
? current_row
->used
[TEXT_AREA
] : 0;
5406 change_line_highlight (desired_row
->inverse_p
, vpos
, vpos
, n
);
5407 current_row
->enabled_p
= 0;
5410 reassert_line_highlight (desired_row
->inverse_p
, vpos
);
5412 /* Current row not enabled means it has unknown contents. We must
5413 write the whole desired line in that case. */
5414 must_write_whole_line_p
= !current_row
->enabled_p
;
5415 if (must_write_whole_line_p
)
5422 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
5423 olen
= current_row
->used
[TEXT_AREA
];
5425 if (!current_row
->inverse_p
)
5427 /* Ignore trailing spaces, if we can. */
5428 if (!write_spaces_p
)
5429 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
5434 /* For an inverse-video line, make sure it's filled with
5435 spaces all the way to the frame edge so that the reverse
5436 video extends all the way across. */
5437 while (olen
< FRAME_WIDTH (f
) - 1)
5438 obody
[olen
++] = space_glyph
;
5442 current_row
->enabled_p
= 1;
5443 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
5444 current_row
->inverse_p
= desired_row
->inverse_p
;
5446 /* If desired line is empty, just clear the line. */
5447 if (!desired_row
->enabled_p
)
5453 nbody
= desired_row
->glyphs
[TEXT_AREA
];
5454 nlen
= desired_row
->used
[TEXT_AREA
];
5455 nend
= nbody
+ nlen
;
5457 /* If display line has unknown contents, write the whole line. */
5458 if (must_write_whole_line_p
)
5460 /* Ignore spaces at the end, if we can. */
5461 if (!write_spaces_p
)
5462 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5465 /* Write the contents of the desired line. */
5468 cursor_to (vpos
, 0);
5469 write_glyphs (nbody
, nlen
);
5472 /* Don't call clear_end_of_line if we already wrote the whole
5473 line. The cursor will not be at the right margin in that
5474 case but in the line below. */
5475 if (nlen
< FRAME_WINDOW_WIDTH (f
))
5477 cursor_to (vpos
, nlen
);
5478 clear_end_of_line (FRAME_WINDOW_WIDTH (f
));
5481 /* Make sure we are in the right row, otherwise cursor movement
5482 with cmgoto might use `ch' in the wrong row. */
5483 cursor_to (vpos
, 0);
5485 make_current (desired_matrix
, current_matrix
, vpos
);
5489 /* Pretend trailing spaces are not there at all,
5490 unless for one reason or another we must write all spaces. */
5491 if (!desired_row
->inverse_p
)
5493 if (!write_spaces_p
)
5494 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5499 /* For an inverse-video line, give it extra trailing spaces all
5500 the way to the frame edge so that the reverse video extends
5501 all the way across. */
5502 while (nlen
< FRAME_WIDTH (f
) - 1)
5503 nbody
[nlen
++] = space_glyph
;
5506 /* If there's no i/d char, quickly do the best we can without it. */
5507 if (!char_ins_del_ok
)
5511 /* Find the first glyph in desired row that doesn't agree with
5512 a glyph in the current row, and write the rest from there on. */
5513 for (i
= 0; i
< nlen
; i
++)
5515 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
5517 /* Find the end of the run of different glyphs. */
5521 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
5522 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
5525 /* Output this run of non-matching chars. */
5526 cursor_to (vpos
, i
);
5527 write_glyphs (nbody
+ i
, j
- i
);
5530 /* Now find the next non-match. */
5534 /* Clear the rest of the line, or the non-clear part of it. */
5537 cursor_to (vpos
, nlen
);
5538 clear_end_of_line (olen
);
5541 /* Make current row = desired row. */
5542 make_current (desired_matrix
, current_matrix
, vpos
);
5546 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
5547 characters in a row. */
5551 /* If current line is blank, skip over initial spaces, if
5552 possible, and write the rest. */
5553 if (write_spaces_p
|| desired_row
->inverse_p
)
5556 nsp
= count_blanks (nbody
, nlen
);
5560 cursor_to (vpos
, nsp
);
5561 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
5564 /* Exchange contents between current_frame and new_frame. */
5565 make_current (desired_matrix
, current_matrix
, vpos
);
5569 /* Compute number of leading blanks in old and new contents. */
5570 osp
= count_blanks (obody
, olen
);
5571 nsp
= (desired_row
->inverse_p
|| colored_spaces_p
5573 : count_blanks (nbody
, nlen
));
5575 /* Compute number of matching chars starting with first non-blank. */
5576 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
5577 nbody
+ nsp
, nbody
+ nlen
);
5579 /* Spaces in new match implicit space past the end of old. */
5580 /* A bug causing this to be a no-op was fixed in 18.29. */
5581 if (!write_spaces_p
&& osp
+ begmatch
== olen
)
5584 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
5588 /* Avoid doing insert/delete char
5589 just cause number of leading spaces differs
5590 when the following text does not match. */
5591 if (begmatch
== 0 && osp
!= nsp
)
5592 osp
= nsp
= min (osp
, nsp
);
5594 /* Find matching characters at end of line */
5597 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
5599 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
5604 endmatch
= obody
+ olen
- op1
;
5606 /* tem gets the distance to insert or delete.
5607 endmatch is how many characters we save by doing so.
5610 tem
= (nlen
- nsp
) - (olen
- osp
);
5612 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (f
)[tem
]))
5615 /* nsp - osp is the distance to insert or delete.
5616 If that is nonzero, begmatch is known to be nonzero also.
5617 begmatch + endmatch is how much we save by doing the ins/del.
5621 && (!char_ins_del_ok
5622 || begmatch
+ endmatch
<= char_ins_del_cost (f
)[nsp
- osp
]))
5626 osp
= nsp
= min (osp
, nsp
);
5629 /* Now go through the line, inserting, writing and
5630 deleting as appropriate. */
5634 cursor_to (vpos
, nsp
);
5635 delete_glyphs (osp
- nsp
);
5639 /* If going to delete chars later in line
5640 and insert earlier in the line,
5641 must delete first to avoid losing data in the insert */
5642 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
5644 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
5645 delete_glyphs (olen
+ nsp
- osp
- nlen
);
5646 olen
= nlen
- (nsp
- osp
);
5648 cursor_to (vpos
, osp
);
5649 insert_glyphs (0, nsp
- osp
);
5653 tem
= nsp
+ begmatch
+ endmatch
;
5654 if (nlen
!= tem
|| olen
!= tem
)
5656 if (!endmatch
|| nlen
== olen
)
5658 /* If new text being written reaches right margin, there is
5659 no need to do clear-to-eol at the end of this function
5660 (and it would not be safe, since cursor is not going to
5661 be "at the margin" after the text is done). */
5662 if (nlen
== FRAME_WINDOW_WIDTH (f
))
5665 /* Function write_glyphs is prepared to do nothing
5666 if passed a length <= 0. Check it here to avoid
5667 unnecessary cursor movement. */
5670 cursor_to (vpos
, nsp
+ begmatch
);
5671 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5674 else if (nlen
> olen
)
5676 /* Here, we used to have the following simple code:
5677 ----------------------------------------
5678 write_glyphs (nbody + nsp + begmatch, olen - tem);
5679 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5680 ----------------------------------------
5681 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5682 is a padding glyph. */
5683 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5686 cursor_to (vpos
, nsp
+ begmatch
);
5688 /* Calculate columns we can actually overwrite. */
5689 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
]))
5691 write_glyphs (nbody
+ nsp
+ begmatch
, out
);
5693 /* If we left columns to be overwritten, we must delete them. */
5694 del
= olen
- tem
- out
;
5696 delete_glyphs (del
);
5698 /* At last, we insert columns not yet written out. */
5699 insert_glyphs (nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5702 else if (olen
> nlen
)
5704 cursor_to (vpos
, nsp
+ begmatch
);
5705 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
5706 delete_glyphs (olen
- nlen
);
5712 /* If any unerased characters remain after the new line, erase them. */
5715 cursor_to (vpos
, nlen
);
5716 clear_end_of_line (olen
);
5719 /* Exchange contents between current_frame and new_frame. */
5720 make_current (desired_matrix
, current_matrix
, vpos
);
5725 /***********************************************************************
5726 X/Y Position -> Buffer Position
5727 ***********************************************************************/
5729 /* Determine what's under window-relative pixel position (*X, *Y).
5730 Return in *OBJECT the object (string or buffer) that's there.
5731 Return in *POS the position in that object. Adjust *X and *Y
5732 to character boundaries. */
5735 buffer_posn_from_coords (w
, x
, y
, object
, pos
)
5738 Lisp_Object
*object
;
5739 struct display_pos
*pos
;
5742 struct buffer
*old_current_buffer
= current_buffer
;
5743 struct text_pos startp
;
5744 int left_area_width
;
5746 current_buffer
= XBUFFER (w
->buffer
);
5747 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5748 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5749 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5750 start_display (&it
, w
, startp
);
5752 left_area_width
= WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH (w
);
5753 move_it_to (&it
, -1, *x
+ it
.first_visible_x
- left_area_width
, *y
, -1,
5754 MOVE_TO_X
| MOVE_TO_Y
);
5756 *x
= it
.current_x
- it
.first_visible_x
+ left_area_width
;
5758 current_buffer
= old_current_buffer
;
5760 *object
= STRINGP (it
.string
) ? it
.string
: w
->buffer
;
5765 /* Value is the string under window-relative coordinates X/Y in the
5766 mode or top line of window W, or nil if none. MODE_LINE_P non-zero
5767 means look at the mode line. *CHARPOS is set to the position in
5768 the string returned. */
5771 mode_line_string (w
, x
, y
, mode_line_p
, charpos
)
5773 int x
, y
, mode_line_p
;
5776 struct glyph_row
*row
;
5777 struct glyph
*glyph
, *end
;
5778 struct frame
*f
= XFRAME (w
->frame
);
5780 Lisp_Object string
= Qnil
;
5783 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5785 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
5787 if (row
->mode_line_p
&& row
->enabled_p
)
5789 /* The mode lines are displayed over scroll bars and bitmap
5790 areas, and X is window-relative. Correct X by the scroll bar
5791 and bitmap area width. */
5792 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
5793 x
+= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
5794 x
+= FRAME_LEFT_FLAGS_AREA_WIDTH (f
);
5796 /* Find the glyph under X. If we find one with a string object,
5797 it's the one we were looking for. */
5798 glyph
= row
->glyphs
[TEXT_AREA
];
5799 end
= glyph
+ row
->used
[TEXT_AREA
];
5800 for (x0
= 0; glyph
< end
; x0
+= glyph
->pixel_width
, ++glyph
)
5801 if (x
>= x0
&& x
< x0
+ glyph
->pixel_width
)
5803 string
= glyph
->object
;
5804 *charpos
= glyph
->charpos
;
5813 /***********************************************************************
5814 Changing Frame Sizes
5815 ***********************************************************************/
5820 window_change_signal (signalnum
) /* If we don't have an argument, */
5821 int signalnum
; /* some compilers complain in signal calls. */
5827 int old_errno
= errno
;
5829 get_frame_size (&width
, &height
);
5831 /* The frame size change obviously applies to a termcap-controlled
5832 frame. Find such a frame in the list, and assume it's the only
5833 one (since the redisplay code always writes to stdout, not a
5834 FILE * specified in the frame structure). Record the new size,
5835 but don't reallocate the data structures now. Let that be done
5836 later outside of the signal handler. */
5839 Lisp_Object tail
, frame
;
5841 FOR_EACH_FRAME (tail
, frame
)
5843 if (FRAME_TERMCAP_P (XFRAME (frame
)))
5845 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5851 signal (SIGWINCH
, window_change_signal
);
5854 #endif /* SIGWINCH */
5857 /* Do any change in frame size that was requested by a signal. SAFE
5858 non-zero means this function is called from a place where it is
5859 safe to change frame sizes while a redisplay is in progress. */
5862 do_pending_window_change (safe
)
5865 /* If window_change_signal should have run before, run it now. */
5866 if (redisplaying_p
&& !safe
)
5869 while (delayed_size_change
)
5871 Lisp_Object tail
, frame
;
5873 delayed_size_change
= 0;
5875 FOR_EACH_FRAME (tail
, frame
)
5877 struct frame
*f
= XFRAME (frame
);
5879 int height
= FRAME_NEW_HEIGHT (f
);
5880 int width
= FRAME_NEW_WIDTH (f
);
5882 if (height
!= 0 || width
!= 0)
5883 change_frame_size (f
, height
, width
, 0, 0, safe
);
5889 /* Change the frame height and/or width. Values may be given as zero to
5890 indicate no change is to take place.
5892 If DELAY is non-zero, then assume we're being called from a signal
5893 handler, and queue the change for later - perhaps the next
5894 redisplay. Since this tries to resize windows, we can't call it
5895 from a signal handler.
5897 SAFE non-zero means this function is called from a place where it's
5898 safe to change frame sizes while a redisplay is in progress. */
5901 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5902 register struct frame
*f
;
5903 int newheight
, newwidth
, pretend
, delay
, safe
;
5905 Lisp_Object tail
, frame
;
5907 if (! FRAME_WINDOW_P (f
))
5909 /* When using termcap, or on MS-DOS, all frames use
5910 the same screen, so a change in size affects all frames. */
5911 FOR_EACH_FRAME (tail
, frame
)
5912 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5913 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5914 pretend
, delay
, safe
);
5917 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
5921 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
)
5922 register struct frame
*f
;
5923 int newheight
, newwidth
, pretend
, delay
, safe
;
5925 int new_frame_window_width
;
5926 int count
= specpdl_ptr
- specpdl
;
5928 /* If we can't deal with the change now, queue it for later. */
5929 if (delay
|| (redisplaying_p
&& !safe
))
5931 FRAME_NEW_HEIGHT (f
) = newheight
;
5932 FRAME_NEW_WIDTH (f
) = newwidth
;
5933 delayed_size_change
= 1;
5937 /* This size-change overrides any pending one for this frame. */
5938 FRAME_NEW_HEIGHT (f
) = 0;
5939 FRAME_NEW_WIDTH (f
) = 0;
5941 /* If an argument is zero, set it to the current value. */
5943 newheight
= FRAME_HEIGHT (f
);
5945 newwidth
= FRAME_WIDTH (f
);
5947 /* Compute width of windows in F.
5948 This is the width of the frame without vertical scroll bars. */
5949 new_frame_window_width
= FRAME_WINDOW_WIDTH_ARG (f
, newwidth
);
5951 /* Round up to the smallest acceptable size. */
5952 check_frame_size (f
, &newheight
, &newwidth
);
5954 /* If we're not changing the frame size, quit now. */
5955 if (newheight
== FRAME_HEIGHT (f
)
5956 && new_frame_window_width
== FRAME_WINDOW_WIDTH (f
))
5962 /* We only can set screen dimensions to certain values supported
5963 by our video hardware. Try to find the smallest size greater
5964 or equal to the requested dimensions. */
5965 dos_set_window_size (&newheight
, &newwidth
);
5968 if (newheight
!= FRAME_HEIGHT (f
))
5970 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
5972 /* Frame has both root and mini-buffer. */
5973 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f
))->top
,
5974 FRAME_TOP_MARGIN (f
));
5975 set_window_height (FRAME_ROOT_WINDOW (f
),
5978 - FRAME_TOP_MARGIN (f
)),
5980 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
,
5982 set_window_height (FRAME_MINIBUF_WINDOW (f
), 1, 0);
5985 /* Frame has just one top-level window. */
5986 set_window_height (FRAME_ROOT_WINDOW (f
),
5987 newheight
- FRAME_TOP_MARGIN (f
), 0);
5989 if (FRAME_TERMCAP_P (f
) && !pretend
)
5990 FrameRows
= newheight
;
5993 if (new_frame_window_width
!= FRAME_WINDOW_WIDTH (f
))
5995 set_window_width (FRAME_ROOT_WINDOW (f
), new_frame_window_width
, 0);
5996 if (FRAME_HAS_MINIBUF_P (f
))
5997 set_window_width (FRAME_MINIBUF_WINDOW (f
), new_frame_window_width
, 0);
5999 if (FRAME_TERMCAP_P (f
) && !pretend
)
6000 FrameCols
= newwidth
;
6002 if (WINDOWP (f
->tool_bar_window
))
6003 XSETFASTINT (XWINDOW (f
->tool_bar_window
)->width
, newwidth
);
6006 FRAME_HEIGHT (f
) = newheight
;
6007 SET_FRAME_WIDTH (f
, newwidth
);
6010 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
6011 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
6013 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
6015 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
6016 w
->cursor
.hpos
= w
->cursor
.x
= 0;
6017 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
6018 w
->cursor
.vpos
= w
->cursor
.y
= 0;
6022 SET_FRAME_GARBAGED (f
);
6023 calculate_costs (f
);
6027 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
6029 /* This isn't quite a no-op: it runs window-configuration-change-hook. */
6030 Fset_window_buffer (FRAME_SELECTED_WINDOW (f
),
6031 XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
);
6033 unbind_to (count
, Qnil
);
6038 /***********************************************************************
6039 Terminal Related Lisp Functions
6040 ***********************************************************************/
6042 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
6043 1, 1, "FOpen termscript file: ",
6044 doc
: /* Start writing all terminal output to FILE as well as the terminal.
6045 FILE = nil means just close any termscript file currently open. */)
6049 if (termscript
!= 0) fclose (termscript
);
6054 file
= Fexpand_file_name (file
, Qnil
);
6055 termscript
= fopen (XSTRING (file
)->data
, "w");
6056 if (termscript
== 0)
6057 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
6063 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
6064 Ssend_string_to_terminal
, 1, 1, 0,
6065 doc
: /* Send STRING to the terminal without alteration.
6066 Control characters in STRING will have terminal-dependent effects. */)
6070 /* ??? Perhaps we should do something special for multibyte strings here. */
6071 CHECK_STRING (string
, 0);
6072 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)), stdout
);
6076 fwrite (XSTRING (string
)->data
, 1, STRING_BYTES (XSTRING (string
)),
6078 fflush (termscript
);
6084 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
6085 doc
: /* Beep, or flash the screen.
6086 Also, unless an argument is given,
6087 terminate any keyboard macro currently executing. */)
6110 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
6111 error ("Keyboard macro terminated by a command ringing the bell");
6119 /***********************************************************************
6121 ***********************************************************************/
6123 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
6124 doc
: /* Pause, without updating display, for SECONDS seconds.
6125 SECONDS may be a floating-point value, meaning that you can wait for a
6126 fraction of a second. Optional second arg MILLISECONDS specifies an
6127 additional wait period, in milliseconds; this may be useful if your
6128 Emacs was built without floating point support.
6129 \(Not all operating systems support waiting for a fraction of a second.) */)
6130 (seconds
, milliseconds
)
6131 Lisp_Object seconds
, milliseconds
;
6135 if (NILP (milliseconds
))
6136 XSETINT (milliseconds
, 0);
6138 CHECK_NUMBER (milliseconds
, 1);
6139 usec
= XINT (milliseconds
) * 1000;
6142 double duration
= extract_float (seconds
);
6143 sec
= (int) duration
;
6144 usec
+= (duration
- sec
) * 1000000;
6147 #ifndef EMACS_HAS_USECS
6148 if (sec
== 0 && usec
!= 0)
6149 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
6152 /* Assure that 0 <= usec < 1000000. */
6155 /* We can't rely on the rounding being correct if user is negative. */
6156 if (-1000000 < usec
)
6157 sec
--, usec
+= 1000000;
6159 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
6162 sec
+= usec
/ 1000000, usec
%= 1000000;
6164 if (sec
< 0 || (sec
== 0 && usec
== 0))
6170 XSETFASTINT (zero
, 0);
6171 wait_reading_process_input (sec
, usec
, zero
, 0);
6174 /* We should always have wait_reading_process_input; we have a dummy
6175 implementation for systems which don't support subprocesses. */
6177 /* No wait_reading_process_input */
6184 /* The reason this is done this way
6185 (rather than defined (H_S) && defined (H_T))
6186 is because the VMS preprocessor doesn't grok `defined' */
6188 EMACS_GET_TIME (end_time
);
6189 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
6190 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
6194 EMACS_GET_TIME (timeout
);
6195 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
6196 if (EMACS_TIME_NEG_P (timeout
)
6197 || !select (1, 0, 0, 0, &timeout
))
6200 #else /* not HAVE_SELECT */
6202 #endif /* HAVE_SELECT */
6203 #endif /* not VMS */
6206 #endif /* no subprocesses */
6212 /* This is just like wait_reading_process_input, except that
6213 it does the redisplay.
6215 It's also much like Fsit_for, except that it can be used for
6216 waiting for input as well. */
6219 sit_for (sec
, usec
, reading
, display
, initial_display
)
6220 int sec
, usec
, reading
, display
, initial_display
;
6222 Lisp_Object read_kbd
;
6224 swallow_events (display
);
6226 if (detect_input_pending_run_timers (display
))
6229 if (initial_display
)
6230 redisplay_preserve_echo_area (2);
6232 if (sec
== 0 && usec
== 0)
6239 XSETINT (read_kbd
, reading
? -1 : 1);
6240 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
6242 return detect_input_pending () ? Qnil
: Qt
;
6246 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
6247 doc
: /* Perform redisplay, then wait for SECONDS seconds or until input is available.
6248 SECONDS may be a floating-point value, meaning that you can wait for a
6249 fraction of a second. Optional second arg MILLISECONDS specifies an
6250 additional wait period, in milliseconds; this may be useful if your
6251 Emacs was built without floating point support.
6252 \(Not all operating systems support waiting for a fraction of a second.)
6253 Optional third arg NODISP non-nil means don't redisplay, just wait for input.
6254 Redisplay is preempted as always if input arrives, and does not happen
6255 if input is available before it starts.
6256 Value is t if waited the full time with no input arriving. */)
6257 (seconds
, milliseconds
, nodisp
)
6258 Lisp_Object seconds
, milliseconds
, nodisp
;
6262 if (NILP (milliseconds
))
6263 XSETINT (milliseconds
, 0);
6265 CHECK_NUMBER (milliseconds
, 1);
6266 usec
= XINT (milliseconds
) * 1000;
6269 double duration
= extract_float (seconds
);
6270 sec
= (int) duration
;
6271 usec
+= (duration
- sec
) * 1000000;
6274 #ifndef EMACS_HAS_USECS
6275 if (usec
!= 0 && sec
== 0)
6276 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
6279 return sit_for (sec
, usec
, 0, NILP (nodisp
), NILP (nodisp
));
6284 /***********************************************************************
6285 Other Lisp Functions
6286 ***********************************************************************/
6288 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
6289 session's frames, frame names, buffers, buffer-read-only flags, and
6290 buffer-modified-flags, and a trailing sentinel (so we don't need to
6291 add length checks). */
6293 static Lisp_Object frame_and_buffer_state
;
6296 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
6297 Sframe_or_buffer_changed_p
, 0, 0, 0,
6298 doc
: /* Return non-nil if the frame and buffer state appears to have changed.
6299 The state variable is an internal vector containing all frames and buffers,
6300 aside from buffers whose names start with space,
6301 along with the buffers' read-only and modified flags, which allows a fast
6302 check to see whether the menu bars might need to be recomputed.
6303 If this function returns non-nil, it updates the internal vector to reflect
6304 the current state. */)
6307 Lisp_Object tail
, frame
, buf
;
6311 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
6312 FOR_EACH_FRAME (tail
, frame
)
6314 if (!EQ (*vecp
++, frame
))
6316 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
6319 /* Check that the buffer info matches.
6320 No need to test for the end of the vector
6321 because the last element of the vector is lambda
6322 and that will always cause a mismatch. */
6323 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
6325 buf
= XCDR (XCAR (tail
));
6326 /* Ignore buffers that aren't included in buffer lists. */
6327 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
6329 if (!EQ (*vecp
++, buf
))
6331 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
6333 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
6336 /* Detect deletion of a buffer at the end of the list. */
6337 if (EQ (*vecp
, Qlambda
))
6340 /* Start with 1 so there is room for at least one lambda at the end. */
6342 FOR_EACH_FRAME (tail
, frame
)
6344 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
6346 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
6347 if (n
> XVECTOR (frame_and_buffer_state
)->size
6348 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
6349 /* Add 20 extra so we grow it less often. */
6350 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
6351 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
6352 FOR_EACH_FRAME (tail
, frame
)
6355 *vecp
++ = XFRAME (frame
)->name
;
6357 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
6359 buf
= XCDR (XCAR (tail
));
6360 /* Ignore buffers that aren't included in buffer lists. */
6361 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
6364 *vecp
++ = XBUFFER (buf
)->read_only
;
6365 *vecp
++ = Fbuffer_modified_p (buf
);
6367 /* Fill up the vector with lambdas (always at least one). */
6369 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
6370 < XVECTOR (frame_and_buffer_state
)->size
)
6372 /* Make sure we didn't overflow the vector. */
6373 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
6374 > XVECTOR (frame_and_buffer_state
)->size
)
6381 /***********************************************************************
6383 ***********************************************************************/
6385 char *terminal_type
;
6387 /* Initialization done when Emacs fork is started, before doing stty.
6388 Determine terminal type and set terminal_driver. Then invoke its
6389 decoding routine to set up variables in the terminal package. */
6394 #ifdef HAVE_X_WINDOWS
6395 extern int display_arg
;
6398 /* Construct the space glyph. */
6399 space_glyph
.type
= CHAR_GLYPH
;
6400 SET_CHAR_GLYPH_FROM_GLYPH (space_glyph
, ' ');
6401 space_glyph
.charpos
= -1;
6405 cursor_in_echo_area
= 0;
6406 terminal_type
= (char *) 0;
6408 /* Now is the time to initialize this; it's used by init_sys_modes
6410 Vwindow_system
= Qnil
;
6412 /* If the user wants to use a window system, we shouldn't bother
6413 initializing the terminal. This is especially important when the
6414 terminal is so dumb that emacs gives up before and doesn't bother
6415 using the window system.
6417 If the DISPLAY environment variable is set and nonempty,
6418 try to use X, and die with an error message if that doesn't work. */
6420 #ifdef HAVE_X_WINDOWS
6425 display
= getenv ("DECW$DISPLAY");
6427 display
= getenv ("DISPLAY");
6430 display_arg
= (display
!= 0 && *display
!= 0);
6433 if (!inhibit_window_system
&& display_arg
6439 Vwindow_system
= intern ("x");
6441 Vwindow_system_version
= make_number (11);
6443 Vwindow_system_version
= make_number (10);
6445 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
6446 /* In some versions of ncurses,
6447 tputs crashes if we have not called tgetent.
6449 { char b
[2044]; tgetent (b
, "xterm");}
6451 adjust_frame_glyphs_initially ();
6454 #endif /* HAVE_X_WINDOWS */
6457 if (!inhibit_window_system
)
6459 Vwindow_system
= intern ("w32");
6460 Vwindow_system_version
= make_number (1);
6461 adjust_frame_glyphs_initially ();
6464 #endif /* HAVE_NTGUI */
6467 if (!inhibit_window_system
)
6469 Vwindow_system
= intern ("mac");
6470 Vwindow_system_version
= make_number (1);
6471 adjust_frame_glyphs_initially ();
6474 #endif /* macintosh */
6476 /* If no window system has been specified, try to use the terminal. */
6479 fatal ("standard input is not a tty");
6483 /* Look at the TERM variable */
6484 terminal_type
= (char *) getenv ("TERM");
6488 fprintf (stderr
, "Please specify your terminal type.\n\
6489 For types defined in VMS, use set term /device=TYPE.\n\
6490 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
6491 \(The quotation marks are necessary since terminal types are lower case.)\n");
6493 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
6499 /* VMS DCL tends to up-case things, so down-case term type.
6500 Hardly any uppercase letters in terminal types; should be none. */
6502 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
6505 strcpy (new, terminal_type
);
6507 for (p
= new; *p
; p
++)
6511 terminal_type
= new;
6515 term_init (terminal_type
);
6518 struct frame
*sf
= SELECTED_FRAME ();
6519 int width
= FRAME_WINDOW_WIDTH (sf
);
6520 int height
= FRAME_HEIGHT (sf
);
6522 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (struct glyph
);
6524 /* If these sizes are so big they cause overflow, just ignore the
6525 change. It's not clear what better we could do. */
6526 if (total_glyphs
/ sizeof (struct glyph
) / height
!= width
+ 2)
6527 fatal ("screen size %dx%d too big", width
, height
);
6530 adjust_frame_glyphs_initially ();
6531 calculate_costs (XFRAME (selected_frame
));
6536 #endif /* CANNOT_DUMP */
6537 signal (SIGWINCH
, window_change_signal
);
6538 #endif /* SIGWINCH */
6540 /* Set up faces of the initial terminal frame of a dumped Emacs. */
6544 /* The MSDOS terminal turns on its ``window system'' relatively
6545 late into the startup, so we cannot do the frame faces'
6546 initialization just yet. It will be done later by pc-win.el
6547 and internal_terminal_init. */
6548 && (strcmp (terminal_type
, "internal") != 0 || inhibit_window_system
)
6550 && NILP (Vwindow_system
))
6552 /* For the initial frame, we don't have any way of knowing what
6553 are the foreground and background colors of the terminal. */
6554 struct frame
*sf
= SELECTED_FRAME();
6556 FRAME_FOREGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_FG_COLOR
;
6557 FRAME_BACKGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_BG_COLOR
;
6558 call0 (intern ("tty-set-up-initial-frame-faces"));
6564 /***********************************************************************
6566 ***********************************************************************/
6568 DEFUN ("internal-show-cursor", Finternal_show_cursor
,
6569 Sinternal_show_cursor
, 2, 2, 0,
6570 doc
: /* Set the cursor-visibility flag of WINDOW to SHOW.
6571 WINDOW nil means use the selected window. SHOW non-nil means
6572 show a cursor in WINDOW in the next redisplay. SHOW nil means
6573 don't show a cursor. */)
6575 Lisp_Object window
, show
;
6577 /* Don't change cursor state while redisplaying. This could confuse
6579 if (!redisplaying_p
)
6582 window
= selected_window
;
6584 CHECK_WINDOW (window
, 2);
6586 XWINDOW (window
)->cursor_off_p
= NILP (show
);
6593 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p
,
6594 Sinternal_show_cursor_p
, 0, 1, 0,
6595 doc
: /* Value is non-nil if next redisplay will display a cursor in WINDOW.
6596 WINDOW nil or omitted means report on the selected window. */)
6603 window
= selected_window
;
6605 CHECK_WINDOW (window
, 2);
6607 w
= XWINDOW (window
);
6608 return w
->cursor_off_p
? Qnil
: Qt
;
6612 /***********************************************************************
6614 ***********************************************************************/
6619 defsubr (&Sredraw_frame
);
6620 defsubr (&Sredraw_display
);
6621 defsubr (&Sframe_or_buffer_changed_p
);
6622 defsubr (&Sopen_termscript
);
6624 defsubr (&Ssit_for
);
6625 defsubr (&Ssleep_for
);
6626 defsubr (&Ssend_string_to_terminal
);
6627 defsubr (&Sinternal_show_cursor
);
6628 defsubr (&Sinternal_show_cursor_p
);
6631 defsubr (&Sdump_redisplay_history
);
6634 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
6635 staticpro (&frame_and_buffer_state
);
6637 Qdisplay_table
= intern ("display-table");
6638 staticpro (&Qdisplay_table
);
6639 Qredisplay_dont_pause
= intern ("redisplay-dont-pause");
6640 staticpro (&Qredisplay_dont_pause
);
6642 DEFVAR_INT ("baud-rate", &baud_rate
,
6643 doc
: /* *The output baud rate of the terminal.
6644 On most systems, changing this value will affect the amount of padding
6645 and the other strategic decisions made during redisplay. */);
6647 DEFVAR_BOOL ("inverse-video", &inverse_video
,
6648 doc
: /* *Non-nil means invert the entire frame display.
6649 This means everything is in inverse video which otherwise would not be. */);
6651 DEFVAR_BOOL ("visible-bell", &visible_bell
,
6652 doc
: /* *Non-nil means try to flash the frame to represent a bell. */);
6654 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
6655 doc
: /* *Non-nil means no need to redraw entire frame after suspending.
6656 A non-nil value is useful if the terminal can automatically preserve
6657 Emacs's frame display when you reenter Emacs.
6658 It is up to you to set this variable if your terminal can do that. */);
6660 DEFVAR_LISP ("window-system", &Vwindow_system
,
6661 doc
: /* A symbol naming the window-system under which Emacs is running
6662 \(such as `x'), or nil if emacs is running on an ordinary terminal. */);
6664 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
6665 doc
: /* The version number of the window system in use.
6666 For X windows, this is 10 or 11. */);
6668 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
6669 doc
: /* Non-nil means put cursor in minibuffer, at end of any message there. */);
6671 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
6672 doc
: /* Table defining how to output a glyph code to the frame.
6673 If not nil, this is a vector indexed by glyph code to define the glyph.
6674 Each element can be:
6675 integer: a glyph code which this glyph is an alias for.
6676 string: output this glyph using that string (not impl. in X windows).
6677 nil: this glyph mod 524288 is the code of a character to output,
6678 and this glyph / 524288 is the face number (see `face-id') to use
6679 while outputting it. */);
6680 Vglyph_table
= Qnil
;
6682 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
6683 doc
: /* Display table to use for buffers that specify none.
6684 See `buffer-display-table' for more information. */);
6685 Vstandard_display_table
= Qnil
;
6687 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause
,
6688 doc
: /* *Non-nil means update isn't paused when input is detected. */);
6689 redisplay_dont_pause
= 0;
6691 /* Initialize `window-system', unless init_display already decided it. */
6696 Vwindow_system
= Qnil
;
6697 Vwindow_system_version
= Qnil
;