1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995,
3 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
33 /* cm.h must come after dispextern.h on Windows. */
34 #include "dispextern.h"
37 #include "character.h"
40 #include "termhooks.h"
45 #include "intervals.h"
46 #include "blockinput.h"
49 /* I don't know why DEC Alpha OSF1 fail to compile this file if we
50 include the following file. */
51 /* #include "systty.h" */
52 #include "syssignal.h"
56 #endif /* HAVE_X_WINDOWS */
60 #endif /* HAVE_NTGUI */
70 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
75 /* To get the prototype for `sleep'. */
81 /* Get number of chars of output now in the buffer of a stdio stream.
82 This ought to be built in in stdio, but it isn't. Some s- files
83 override this because their stdio internals differ. */
85 #ifdef __GNU_LIBRARY__
87 /* The s- file might have overridden the definition with one that
88 works for the system's C library. But we are using the GNU C
89 library, so this is the right definition for every system. */
91 #ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT
92 #define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT
94 #undef PENDING_OUTPUT_COUNT
95 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
97 #else /* not __GNU_LIBRARY__ */
98 #if !defined (PENDING_OUTPUT_COUNT) && HAVE_STDIO_EXT_H && HAVE___FPENDING
99 #include <stdio_ext.h>
100 #define PENDING_OUTPUT_COUNT(FILE) __fpending (FILE)
102 #ifndef PENDING_OUTPUT_COUNT
103 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
105 #endif /* not __GNU_LIBRARY__ */
107 #if defined(HAVE_TERM_H) && defined (GNU_LINUX) && defined (HAVE_LIBNCURSES)
108 #include <term.h> /* for tgetent */
111 /* Structure to pass dimensions around. Used for character bounding
112 boxes, glyph matrix dimensions and alike. */
121 /* Function prototypes. */
123 static struct glyph_matrix
*save_current_matrix
P_ ((struct frame
*));
124 static void restore_current_matrix
P_ ((struct frame
*, struct glyph_matrix
*));
125 static int showing_window_margins_p
P_ ((struct window
*));
126 static void fake_current_matrices
P_ ((Lisp_Object
));
127 static void redraw_overlapping_rows
P_ ((struct window
*, int));
128 static void redraw_overlapped_rows
P_ ((struct window
*, int));
129 static int count_blanks
P_ ((struct glyph
*, int));
130 static int count_match
P_ ((struct glyph
*, struct glyph
*,
131 struct glyph
*, struct glyph
*));
132 static unsigned line_draw_cost
P_ ((struct glyph_matrix
*, int));
133 static void update_frame_line
P_ ((struct frame
*, int));
134 static struct dim allocate_matrices_for_frame_redisplay
135 P_ ((Lisp_Object
, int, int, int, int *));
136 static void allocate_matrices_for_window_redisplay
P_ ((struct window
*));
137 static int realloc_glyph_pool
P_ ((struct glyph_pool
*, struct dim
));
138 static void adjust_frame_glyphs
P_ ((struct frame
*));
139 struct glyph_matrix
*new_glyph_matrix
P_ ((struct glyph_pool
*));
140 static void free_glyph_matrix
P_ ((struct glyph_matrix
*));
141 static void adjust_glyph_matrix
P_ ((struct window
*, struct glyph_matrix
*,
142 int, int, struct dim
));
143 static void change_frame_size_1
P_ ((struct frame
*, int, int, int, int, int));
144 static void swap_glyph_pointers
P_ ((struct glyph_row
*, struct glyph_row
*));
146 static int glyph_row_slice_p
P_ ((struct glyph_row
*, struct glyph_row
*));
148 static void fill_up_frame_row_with_spaces
P_ ((struct glyph_row
*, int));
149 static void build_frame_matrix_from_window_tree
P_ ((struct glyph_matrix
*,
151 static void build_frame_matrix_from_leaf_window
P_ ((struct glyph_matrix
*,
153 static struct glyph_pool
*new_glyph_pool
P_ ((void));
154 static void free_glyph_pool
P_ ((struct glyph_pool
*));
155 static void adjust_frame_glyphs_initially
P_ ((void));
156 static void adjust_frame_message_buffer
P_ ((struct frame
*));
157 static void adjust_decode_mode_spec_buffer
P_ ((struct frame
*));
158 static void fill_up_glyph_row_with_spaces
P_ ((struct glyph_row
*));
159 static void build_frame_matrix
P_ ((struct frame
*));
160 void clear_current_matrices
P_ ((struct frame
*));
161 void scroll_glyph_matrix_range
P_ ((struct glyph_matrix
*, int, int,
163 static void clear_window_matrices
P_ ((struct window
*, int));
164 static void fill_up_glyph_row_area_with_spaces
P_ ((struct glyph_row
*, int));
165 static int scrolling_window
P_ ((struct window
*, int));
166 static int update_window_line
P_ ((struct window
*, int, int *));
167 static void update_marginal_area
P_ ((struct window
*, int, int));
168 static int update_text_area
P_ ((struct window
*, int));
169 static void make_current
P_ ((struct glyph_matrix
*, struct glyph_matrix
*,
171 static void mirror_make_current
P_ ((struct window
*, int));
172 void check_window_matrix_pointers
P_ ((struct window
*));
174 static void check_matrix_pointers
P_ ((struct glyph_matrix
*,
175 struct glyph_matrix
*));
177 static void mirror_line_dance
P_ ((struct window
*, int, int, int *, char *));
178 static int update_window_tree
P_ ((struct window
*, int));
179 static int update_window
P_ ((struct window
*, int));
180 static int update_frame_1
P_ ((struct frame
*, int, int));
181 static void set_window_cursor_after_update
P_ ((struct window
*));
182 static int row_equal_p
P_ ((struct window
*, struct glyph_row
*,
183 struct glyph_row
*, int));
184 static void adjust_frame_glyphs_for_window_redisplay
P_ ((struct frame
*));
185 static void adjust_frame_glyphs_for_frame_redisplay
P_ ((struct frame
*));
186 static void reverse_rows
P_ ((struct glyph_matrix
*, int, int));
187 static int margin_glyphs_to_reserve
P_ ((struct window
*, int, Lisp_Object
));
188 static void sync_window_with_frame_matrix_rows
P_ ((struct window
*));
189 struct window
*frame_row_to_window
P_ ((struct window
*, int));
192 /* Non-zero means don't pause redisplay for pending input. (This is
193 for debugging and for a future implementation of EDT-like
196 int redisplay_dont_pause
;
198 /* Define PERIODIC_PREEMPTION_CHECKING to 1, if micro-second timers
199 are supported, so we can check for input during redisplay at
200 regular intervals. */
201 #ifdef EMACS_HAS_USECS
202 #define PERIODIC_PREEMPTION_CHECKING 1
204 #define PERIODIC_PREEMPTION_CHECKING 0
207 #if PERIODIC_PREEMPTION_CHECKING
209 /* If a number (float), check for user input every N seconds. */
211 Lisp_Object Vredisplay_preemption_period
;
213 /* Redisplay preemption timers. */
215 static EMACS_TIME preemption_period
;
216 static EMACS_TIME preemption_next_check
;
220 /* Nonzero upon entry to redisplay means do not assume anything about
221 current contents of actual terminal frame; clear and redraw it. */
225 /* Nonzero means last display completed. Zero means it was preempted. */
227 int display_completed
;
229 /* Lisp variable visible-bell; enables use of screen-flash instead of
234 /* Invert the color of the whole frame, at a low level. */
238 /* Line speed of the terminal. */
242 /* Either nil or a symbol naming the window system under which Emacs
243 creates the first frame. */
245 Lisp_Object Vinitial_window_system
;
247 /* Version number of X windows: 10, 11 or nil. */
249 Lisp_Object Vwindow_system_version
;
251 /* Vector of glyph definitions. Indexed by glyph number, the contents
252 are a string which is how to output the glyph.
254 If Vglyph_table is nil, a glyph is output by using its low 8 bits
257 This is an obsolete feature that is no longer used. The variable
258 is retained for compatibility. */
260 Lisp_Object Vglyph_table
;
262 /* Display table to use for vectors that don't specify their own. */
264 Lisp_Object Vstandard_display_table
;
266 /* Nonzero means reading single-character input with prompt so put
267 cursor on mini-buffer after the prompt. Positive means at end of
268 text in echo area; negative means at beginning of line. */
270 int cursor_in_echo_area
;
272 Lisp_Object Qdisplay_table
, Qredisplay_dont_pause
;
275 /* The currently selected frame. In a single-frame version, this
276 variable always equals the_only_frame. */
278 Lisp_Object selected_frame
;
280 /* A frame which is not just a mini-buffer, or 0 if there are no such
281 frames. This is usually the most recent such frame that was
282 selected. In a single-frame version, this variable always holds
283 the address of the_only_frame. */
285 struct frame
*last_nonminibuf_frame
;
287 /* 1 means SIGWINCH happened when not safe. */
289 int delayed_size_change
;
291 /* 1 means glyph initialization has been completed at startup. */
293 static int glyphs_initialized_initially_p
;
295 /* Updated window if != 0. Set by update_window. */
297 struct window
*updated_window
;
299 /* Glyph row updated in update_window_line, and area that is updated. */
301 struct glyph_row
*updated_row
;
304 /* A glyph for a space. */
306 struct glyph space_glyph
;
308 /* Non-zero means update has been performed directly, so that there's
309 no need for redisplay_internal to do much work. Set by
310 direct_output_for_insert. */
312 int redisplay_performed_directly_p
;
314 /* Counts of allocated structures. These counts serve to diagnose
315 memory leaks and double frees. */
317 int glyph_matrix_count
;
318 int glyph_pool_count
;
320 /* If non-null, the frame whose frame matrices are manipulated. If
321 null, window matrices are worked on. */
323 static struct frame
*frame_matrix_frame
;
325 /* Non-zero means that fonts have been loaded since the last glyph
326 matrix adjustments. Redisplay must stop, and glyph matrices must
327 be adjusted when this flag becomes non-zero during display. The
328 reason fonts can be loaded so late is that fonts of fontsets are
329 loaded on demand. Another reason is that a line contains many
330 characters displayed by zero width or very narrow glyphs of
331 variable-width fonts. */
335 /* Convert vpos and hpos from frame to window and vice versa.
336 This may only be used for terminal frames. */
340 static int window_to_frame_vpos
P_ ((struct window
*, int));
341 static int window_to_frame_hpos
P_ ((struct window
*, int));
342 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
343 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
345 /* One element of the ring buffer containing redisplay history
348 struct redisplay_history
350 char trace
[512 + 100];
353 /* The size of the history buffer. */
355 #define REDISPLAY_HISTORY_SIZE 30
357 /* The redisplay history buffer. */
359 static struct redisplay_history redisplay_history
[REDISPLAY_HISTORY_SIZE
];
361 /* Next free entry in redisplay_history. */
363 static int history_idx
;
365 /* A tick that's incremented each time something is added to the
368 static unsigned history_tick
;
370 static void add_frame_display_history
P_ ((struct frame
*, int));
371 static void add_window_display_history
P_ ((struct window
*, char *, int));
373 /* Add to the redisplay history how window W has been displayed.
374 MSG is a trace containing the information how W's glyph matrix
375 has been constructed. PAUSED_P non-zero means that the update
376 has been interrupted for pending input. */
379 add_window_display_history (w
, msg
, paused_p
)
386 if (history_idx
>= REDISPLAY_HISTORY_SIZE
)
388 buf
= redisplay_history
[history_idx
].trace
;
391 sprintf (buf
, "%d: window %p (`%s')%s\n",
394 ((BUFFERP (w
->buffer
)
395 && STRINGP (XBUFFER (w
->buffer
)->name
))
396 ? (char *) SDATA (XBUFFER (w
->buffer
)->name
)
398 paused_p
? " ***paused***" : "");
403 /* Add to the redisplay history that frame F has been displayed.
404 PAUSED_P non-zero means that the update has been interrupted for
408 add_frame_display_history (f
, paused_p
)
414 if (history_idx
>= REDISPLAY_HISTORY_SIZE
)
416 buf
= redisplay_history
[history_idx
].trace
;
419 sprintf (buf
, "%d: update frame %p%s",
421 f
, paused_p
? " ***paused***" : "");
425 DEFUN ("dump-redisplay-history", Fdump_redisplay_history
,
426 Sdump_redisplay_history
, 0, 0, "",
427 doc
: /* Dump redisplay history to stderr. */)
432 for (i
= history_idx
- 1; i
!= history_idx
; --i
)
435 i
= REDISPLAY_HISTORY_SIZE
- 1;
436 fprintf (stderr
, "%s\n", redisplay_history
[i
].trace
);
443 #else /* GLYPH_DEBUG == 0 */
445 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + WINDOW_TOP_EDGE_LINE (W))
446 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + WINDOW_LEFT_EDGE_COL (W))
448 #endif /* GLYPH_DEBUG == 0 */
451 /* Like bcopy except never gets confused by overlap. Let this be the
452 first function defined in this file, or change emacs.c where the
453 address of this function is used. */
456 safe_bcopy (from
, to
, size
)
461 if (size
<= 0 || from
== to
)
464 /* If the source and destination don't overlap, then bcopy can
465 handle it. If they do overlap, but the destination is lower in
466 memory than the source, we'll assume bcopy can handle that. */
467 if (to
< from
|| from
+ size
<= to
)
468 bcopy (from
, to
, size
);
470 /* Otherwise, we'll copy from the end. */
473 register const char *endf
= from
+ size
;
474 register char *endt
= to
+ size
;
476 /* If TO - FROM is large, then we should break the copy into
477 nonoverlapping chunks of TO - FROM bytes each. However, if
478 TO - FROM is small, then the bcopy function call overhead
479 makes this not worth it. The crossover point could be about
480 anywhere. Since I don't think the obvious copy loop is too
481 bad, I'm trying to err in its favor. */
486 while (endf
!= from
);
498 bcopy (endf
, endt
, to
- from
);
501 /* If SIZE wasn't a multiple of TO - FROM, there will be a
502 little left over. The amount left over is (endt + (to -
503 from)) - to, which is endt - from. */
504 bcopy (from
, to
, endt
- from
);
511 /***********************************************************************
513 ***********************************************************************/
515 /* Allocate and return a glyph_matrix structure. POOL is the glyph
516 pool from which memory for the matrix should be allocated, or null
517 for window-based redisplay where no glyph pools are used. The
518 member `pool' of the glyph matrix structure returned is set to
519 POOL, the structure is otherwise zeroed. */
521 struct glyph_matrix
*
522 new_glyph_matrix (pool
)
523 struct glyph_pool
*pool
;
525 struct glyph_matrix
*result
;
527 /* Allocate and clear. */
528 result
= (struct glyph_matrix
*) xmalloc (sizeof *result
);
529 bzero (result
, sizeof *result
);
531 /* Increment number of allocated matrices. This count is used
532 to detect memory leaks. */
533 ++glyph_matrix_count
;
535 /* Set pool and return. */
541 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
543 The global counter glyph_matrix_count is decremented when a matrix
544 is freed. If the count gets negative, more structures were freed
545 than allocated, i.e. one matrix was freed more than once or a bogus
546 pointer was passed to this function.
548 If MATRIX->pool is null, this means that the matrix manages its own
549 glyph memory---this is done for matrices on X frames. Freeing the
550 matrix also frees the glyph memory in this case. */
553 free_glyph_matrix (matrix
)
554 struct glyph_matrix
*matrix
;
560 /* Detect the case that more matrices are freed than were
562 if (--glyph_matrix_count
< 0)
565 /* Free glyph memory if MATRIX owns it. */
566 if (matrix
->pool
== NULL
)
567 for (i
= 0; i
< matrix
->rows_allocated
; ++i
)
568 xfree (matrix
->rows
[i
].glyphs
[LEFT_MARGIN_AREA
]);
570 /* Free row structures and the matrix itself. */
571 xfree (matrix
->rows
);
577 /* Return the number of glyphs to reserve for a marginal area of
578 window W. TOTAL_GLYPHS is the number of glyphs in a complete
579 display line of window W. MARGIN gives the width of the marginal
580 area in canonical character units. MARGIN should be an integer
584 margin_glyphs_to_reserve (w
, total_glyphs
, margin
)
591 if (NUMBERP (margin
))
593 int width
= XFASTINT (w
->total_cols
);
594 double d
= max (0, XFLOATINT (margin
));
595 d
= min (width
/ 2 - 1, d
);
596 n
= (int) ((double) total_glyphs
/ width
* d
);
605 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
608 W is null if the function is called for a frame glyph matrix.
609 Otherwise it is the window MATRIX is a member of. X and Y are the
610 indices of the first column and row of MATRIX within the frame
611 matrix, if such a matrix exists. They are zero for purely
612 window-based redisplay. DIM is the needed size of the matrix.
614 In window-based redisplay, where no frame matrices exist, glyph
615 matrices manage their own glyph storage. Otherwise, they allocate
616 storage from a common frame glyph pool which can be found in
619 The reason for this memory management strategy is to avoid complete
620 frame redraws if possible. When we allocate from a common pool, a
621 change of the location or size of a sub-matrix within the pool
622 requires a complete redisplay of the frame because we cannot easily
623 make sure that the current matrices of all windows still agree with
624 what is displayed on the screen. While this is usually fast, it
625 leads to screen flickering. */
628 adjust_glyph_matrix (w
, matrix
, x
, y
, dim
)
630 struct glyph_matrix
*matrix
;
636 int marginal_areas_changed_p
= 0;
637 int header_line_changed_p
= 0;
638 int header_line_p
= 0;
639 int left
= -1, right
= -1;
640 int window_width
= -1, window_height
= -1;
642 /* See if W had a header line that has disappeared now, or vice versa.
646 window_box (w
, -1, 0, 0, &window_width
, &window_height
);
648 header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
649 header_line_changed_p
= header_line_p
!= matrix
->header_line_p
;
651 matrix
->header_line_p
= header_line_p
;
653 /* If POOL is null, MATRIX is a window matrix for window-based redisplay.
654 Do nothing if MATRIX' size, position, vscroll, and marginal areas
655 haven't changed. This optimization is important because preserving
656 the matrix means preventing redisplay. */
657 if (matrix
->pool
== NULL
)
659 left
= margin_glyphs_to_reserve (w
, dim
.width
, w
->left_margin_cols
);
660 right
= margin_glyphs_to_reserve (w
, dim
.width
, w
->right_margin_cols
);
661 xassert (left
>= 0 && right
>= 0);
662 marginal_areas_changed_p
= (left
!= matrix
->left_margin_glyphs
663 || right
!= matrix
->right_margin_glyphs
);
665 if (!marginal_areas_changed_p
667 && !header_line_changed_p
668 && matrix
->window_left_col
== WINDOW_LEFT_EDGE_COL (w
)
669 && matrix
->window_top_line
== WINDOW_TOP_EDGE_LINE (w
)
670 && matrix
->window_height
== window_height
671 && matrix
->window_vscroll
== w
->vscroll
672 && matrix
->window_width
== window_width
)
676 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
677 if (matrix
->rows_allocated
< dim
.height
)
679 int size
= dim
.height
* sizeof (struct glyph_row
);
680 new_rows
= dim
.height
- matrix
->rows_allocated
;
681 matrix
->rows
= (struct glyph_row
*) xrealloc (matrix
->rows
, size
);
682 bzero (matrix
->rows
+ matrix
->rows_allocated
,
683 new_rows
* sizeof *matrix
->rows
);
684 matrix
->rows_allocated
= dim
.height
;
689 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
690 on a frame not using window-based redisplay. Set up pointers for
691 each row into the glyph pool. */
694 xassert (matrix
->pool
->glyphs
);
698 left
= margin_glyphs_to_reserve (w
, dim
.width
,
699 w
->left_margin_cols
);
700 right
= margin_glyphs_to_reserve (w
, dim
.width
,
701 w
->right_margin_cols
);
706 for (i
= 0; i
< dim
.height
; ++i
)
708 struct glyph_row
*row
= &matrix
->rows
[i
];
710 row
->glyphs
[LEFT_MARGIN_AREA
]
711 = (matrix
->pool
->glyphs
712 + (y
+ i
) * matrix
->pool
->ncolumns
716 || row
== matrix
->rows
+ dim
.height
- 1
717 || (row
== matrix
->rows
&& matrix
->header_line_p
))
719 row
->glyphs
[TEXT_AREA
]
720 = row
->glyphs
[LEFT_MARGIN_AREA
];
721 row
->glyphs
[RIGHT_MARGIN_AREA
]
722 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
723 row
->glyphs
[LAST_AREA
]
724 = row
->glyphs
[RIGHT_MARGIN_AREA
];
728 row
->glyphs
[TEXT_AREA
]
729 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
730 row
->glyphs
[RIGHT_MARGIN_AREA
]
731 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
732 row
->glyphs
[LAST_AREA
]
733 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
737 matrix
->left_margin_glyphs
= left
;
738 matrix
->right_margin_glyphs
= right
;
742 /* If MATRIX->pool is null, MATRIX is responsible for managing
743 its own memory. It is a window matrix for window-based redisplay.
744 Allocate glyph memory from the heap. */
745 if (dim
.width
> matrix
->matrix_w
747 || header_line_changed_p
748 || marginal_areas_changed_p
)
750 struct glyph_row
*row
= matrix
->rows
;
751 struct glyph_row
*end
= row
+ matrix
->rows_allocated
;
755 row
->glyphs
[LEFT_MARGIN_AREA
]
756 = (struct glyph
*) xrealloc (row
->glyphs
[LEFT_MARGIN_AREA
],
758 * sizeof (struct glyph
)));
760 /* The mode line never has marginal areas. */
761 if (row
== matrix
->rows
+ dim
.height
- 1
762 || (row
== matrix
->rows
&& matrix
->header_line_p
))
764 row
->glyphs
[TEXT_AREA
]
765 = row
->glyphs
[LEFT_MARGIN_AREA
];
766 row
->glyphs
[RIGHT_MARGIN_AREA
]
767 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
768 row
->glyphs
[LAST_AREA
]
769 = row
->glyphs
[RIGHT_MARGIN_AREA
];
773 row
->glyphs
[TEXT_AREA
]
774 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
775 row
->glyphs
[RIGHT_MARGIN_AREA
]
776 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
777 row
->glyphs
[LAST_AREA
]
778 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
784 xassert (left
>= 0 && right
>= 0);
785 matrix
->left_margin_glyphs
= left
;
786 matrix
->right_margin_glyphs
= right
;
789 /* Number of rows to be used by MATRIX. */
790 matrix
->nrows
= dim
.height
;
791 xassert (matrix
->nrows
>= 0);
795 if (matrix
== w
->current_matrix
)
797 /* Mark rows in a current matrix of a window as not having
798 valid contents. It's important to not do this for
799 desired matrices. When Emacs starts, it may already be
800 building desired matrices when this function runs. */
801 if (window_width
< 0)
802 window_width
= window_box_width (w
, -1);
804 /* Optimize the case that only the height has changed (C-x 2,
805 upper window). Invalidate all rows that are no longer part
807 if (!marginal_areas_changed_p
808 && !header_line_changed_p
810 && dim
.width
== matrix
->matrix_w
811 && matrix
->window_left_col
== WINDOW_LEFT_EDGE_COL (w
)
812 && matrix
->window_top_line
== WINDOW_TOP_EDGE_LINE (w
)
813 && matrix
->window_width
== window_width
)
815 /* Find the last row in the window. */
816 for (i
= 0; i
< matrix
->nrows
&& matrix
->rows
[i
].enabled_p
; ++i
)
817 if (MATRIX_ROW_BOTTOM_Y (matrix
->rows
+ i
) >= window_height
)
823 /* Window end is invalid, if inside of the rows that
824 are invalidated below. */
825 if (INTEGERP (w
->window_end_vpos
)
826 && XFASTINT (w
->window_end_vpos
) >= i
)
827 w
->window_end_valid
= Qnil
;
829 while (i
< matrix
->nrows
)
830 matrix
->rows
[i
++].enabled_p
= 0;
834 for (i
= 0; i
< matrix
->nrows
; ++i
)
835 matrix
->rows
[i
].enabled_p
= 0;
838 else if (matrix
== w
->desired_matrix
)
840 /* Rows in desired matrices always have to be cleared;
841 redisplay expects this is the case when it runs, so it
842 had better be the case when we adjust matrices between
844 for (i
= 0; i
< matrix
->nrows
; ++i
)
845 matrix
->rows
[i
].enabled_p
= 0;
850 /* Remember last values to be able to optimize frame redraws. */
851 matrix
->matrix_x
= x
;
852 matrix
->matrix_y
= y
;
853 matrix
->matrix_w
= dim
.width
;
854 matrix
->matrix_h
= dim
.height
;
856 /* Record the top y location and height of W at the time the matrix
857 was last adjusted. This is used to optimize redisplay above. */
860 matrix
->window_left_col
= WINDOW_LEFT_EDGE_COL (w
);
861 matrix
->window_top_line
= WINDOW_TOP_EDGE_LINE (w
);
862 matrix
->window_height
= window_height
;
863 matrix
->window_width
= window_width
;
864 matrix
->window_vscroll
= w
->vscroll
;
869 /* Reverse the contents of rows in MATRIX between START and END. The
870 contents of the row at END - 1 end up at START, END - 2 at START +
871 1 etc. This is part of the implementation of rotate_matrix (see
875 reverse_rows (matrix
, start
, end
)
876 struct glyph_matrix
*matrix
;
881 for (i
= start
, j
= end
- 1; i
< j
; ++i
, --j
)
883 /* Non-ISO HP/UX compiler doesn't like auto struct
885 struct glyph_row temp
;
886 temp
= matrix
->rows
[i
];
887 matrix
->rows
[i
] = matrix
->rows
[j
];
888 matrix
->rows
[j
] = temp
;
893 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
894 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
895 indices. (Note: this does not copy glyphs, only glyph pointers in
896 row structures are moved around).
898 The algorithm used for rotating the vector was, I believe, first
899 described by Kernighan. See the vector R as consisting of two
900 sub-vectors AB, where A has length BY for BY >= 0. The result
901 after rotating is then BA. Reverse both sub-vectors to get ArBr
902 and reverse the result to get (ArBr)r which is BA. Similar for
906 rotate_matrix (matrix
, first
, last
, by
)
907 struct glyph_matrix
*matrix
;
912 /* Up (rotate left, i.e. towards lower indices). */
914 reverse_rows (matrix
, first
, first
+ by
);
915 reverse_rows (matrix
, first
+ by
, last
);
916 reverse_rows (matrix
, first
, last
);
920 /* Down (rotate right, i.e. towards higher indices). */
921 reverse_rows (matrix
, last
- by
, last
);
922 reverse_rows (matrix
, first
, last
- by
);
923 reverse_rows (matrix
, first
, last
);
928 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
929 with indices START <= index < END. Increment positions by DELTA/
933 increment_matrix_positions (matrix
, start
, end
, delta
, delta_bytes
)
934 struct glyph_matrix
*matrix
;
935 int start
, end
, delta
, delta_bytes
;
937 /* Check that START and END are reasonable values. */
938 xassert (start
>= 0 && start
<= matrix
->nrows
);
939 xassert (end
>= 0 && end
<= matrix
->nrows
);
940 xassert (start
<= end
);
942 for (; start
< end
; ++start
)
943 increment_row_positions (matrix
->rows
+ start
, delta
, delta_bytes
);
947 /* Enable a range of rows in glyph matrix MATRIX. START and END are
948 the row indices of the first and last + 1 row to enable. If
949 ENABLED_P is non-zero, enabled_p flags in rows will be set to 1. */
952 enable_glyph_matrix_rows (matrix
, start
, end
, enabled_p
)
953 struct glyph_matrix
*matrix
;
957 xassert (start
<= end
);
958 xassert (start
>= 0 && start
< matrix
->nrows
);
959 xassert (end
>= 0 && end
<= matrix
->nrows
);
961 for (; start
< end
; ++start
)
962 matrix
->rows
[start
].enabled_p
= enabled_p
!= 0;
968 This empties all rows in MATRIX by setting the enabled_p flag for
969 all rows of the matrix to zero. The function prepare_desired_row
970 will eventually really clear a row when it sees one with a zero
973 Resets update hints to defaults value. The only update hint
974 currently present is the flag MATRIX->no_scrolling_p. */
977 clear_glyph_matrix (matrix
)
978 struct glyph_matrix
*matrix
;
982 enable_glyph_matrix_rows (matrix
, 0, matrix
->nrows
, 0);
983 matrix
->no_scrolling_p
= 0;
988 /* Shift part of the glyph matrix MATRIX of window W up or down.
989 Increment y-positions in glyph rows between START and END by DY,
990 and recompute their visible height. */
993 shift_glyph_matrix (w
, matrix
, start
, end
, dy
)
995 struct glyph_matrix
*matrix
;
1000 xassert (start
<= end
);
1001 xassert (start
>= 0 && start
< matrix
->nrows
);
1002 xassert (end
>= 0 && end
<= matrix
->nrows
);
1004 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1005 max_y
= WINDOW_BOX_HEIGHT_NO_MODE_LINE (w
);
1007 for (; start
< end
; ++start
)
1009 struct glyph_row
*row
= &matrix
->rows
[start
];
1012 row
->visible_height
= row
->height
;
1015 row
->visible_height
-= min_y
- row
->y
;
1016 if (row
->y
+ row
->height
> max_y
)
1017 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
1022 /* Mark all rows in current matrices of frame F as invalid. Marking
1023 invalid is done by setting enabled_p to zero for all rows in a
1027 clear_current_matrices (f
)
1028 register struct frame
*f
;
1030 /* Clear frame current matrix, if we have one. */
1031 if (f
->current_matrix
)
1032 clear_glyph_matrix (f
->current_matrix
);
1034 /* Clear the matrix of the menu bar window, if such a window exists.
1035 The menu bar window is currently used to display menus on X when
1036 no toolkit support is compiled in. */
1037 if (WINDOWP (f
->menu_bar_window
))
1038 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->current_matrix
);
1040 /* Clear the matrix of the tool-bar window, if any. */
1041 if (WINDOWP (f
->tool_bar_window
))
1042 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
1044 /* Clear current window matrices. */
1045 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
1046 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 0);
1050 /* Clear out all display lines of F for a coming redisplay. */
1053 clear_desired_matrices (f
)
1054 register struct frame
*f
;
1056 if (f
->desired_matrix
)
1057 clear_glyph_matrix (f
->desired_matrix
);
1059 if (WINDOWP (f
->menu_bar_window
))
1060 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->desired_matrix
);
1062 if (WINDOWP (f
->tool_bar_window
))
1063 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->desired_matrix
);
1065 /* Do it for window matrices. */
1066 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
1067 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
1071 /* Clear matrices in window tree rooted in W. If DESIRED_P is
1072 non-zero clear desired matrices, otherwise clear current matrices. */
1075 clear_window_matrices (w
, desired_p
)
1081 if (!NILP (w
->hchild
))
1083 xassert (WINDOWP (w
->hchild
));
1084 clear_window_matrices (XWINDOW (w
->hchild
), desired_p
);
1086 else if (!NILP (w
->vchild
))
1088 xassert (WINDOWP (w
->vchild
));
1089 clear_window_matrices (XWINDOW (w
->vchild
), desired_p
);
1094 clear_glyph_matrix (w
->desired_matrix
);
1097 clear_glyph_matrix (w
->current_matrix
);
1098 w
->window_end_valid
= Qnil
;
1102 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
1108 /***********************************************************************
1111 See dispextern.h for an overall explanation of glyph rows.
1112 ***********************************************************************/
1114 /* Clear glyph row ROW. Do it in a way that makes it robust against
1115 changes in the glyph_row structure, i.e. addition or removal of
1116 structure members. */
1118 static struct glyph_row null_row
;
1121 clear_glyph_row (row
)
1122 struct glyph_row
*row
;
1124 struct glyph
*p
[1 + LAST_AREA
];
1126 /* Save pointers. */
1127 p
[LEFT_MARGIN_AREA
] = row
->glyphs
[LEFT_MARGIN_AREA
];
1128 p
[TEXT_AREA
] = row
->glyphs
[TEXT_AREA
];
1129 p
[RIGHT_MARGIN_AREA
] = row
->glyphs
[RIGHT_MARGIN_AREA
];
1130 p
[LAST_AREA
] = row
->glyphs
[LAST_AREA
];
1135 /* Restore pointers. */
1136 row
->glyphs
[LEFT_MARGIN_AREA
] = p
[LEFT_MARGIN_AREA
];
1137 row
->glyphs
[TEXT_AREA
] = p
[TEXT_AREA
];
1138 row
->glyphs
[RIGHT_MARGIN_AREA
] = p
[RIGHT_MARGIN_AREA
];
1139 row
->glyphs
[LAST_AREA
] = p
[LAST_AREA
];
1141 #if 0 /* At some point, some bit-fields of struct glyph were not set,
1142 which made glyphs unequal when compared with GLYPH_EQUAL_P.
1143 Redisplay outputs such glyphs, and flickering effects were
1144 the result. This also depended on the contents of memory
1145 returned by xmalloc. If flickering happens again, activate
1146 the code below. If the flickering is gone with that, chances
1147 are that the flickering has the same reason as here. */
1148 bzero (p
[0], (char *) p
[LAST_AREA
] - (char *) p
[0]);
1153 /* Make ROW an empty, enabled row of canonical character height,
1154 in window W starting at y-position Y. */
1157 blank_row (w
, row
, y
)
1159 struct glyph_row
*row
;
1164 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
1165 max_y
= WINDOW_BOX_HEIGHT_NO_MODE_LINE (w
);
1167 clear_glyph_row (row
);
1169 row
->ascent
= row
->phys_ascent
= 0;
1170 row
->height
= row
->phys_height
= FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
1171 row
->visible_height
= row
->height
;
1174 row
->visible_height
-= min_y
- row
->y
;
1175 if (row
->y
+ row
->height
> max_y
)
1176 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
1182 /* Increment buffer positions in glyph row ROW. DELTA and DELTA_BYTES
1183 are the amounts by which to change positions. Note that the first
1184 glyph of the text area of a row can have a buffer position even if
1185 the used count of the text area is zero. Such rows display line
1189 increment_row_positions (row
, delta
, delta_bytes
)
1190 struct glyph_row
*row
;
1191 int delta
, delta_bytes
;
1195 /* Increment start and end positions. */
1196 MATRIX_ROW_START_CHARPOS (row
) += delta
;
1197 MATRIX_ROW_START_BYTEPOS (row
) += delta_bytes
;
1198 MATRIX_ROW_END_CHARPOS (row
) += delta
;
1199 MATRIX_ROW_END_BYTEPOS (row
) += delta_bytes
;
1201 if (!row
->enabled_p
)
1204 /* Increment positions in glyphs. */
1205 for (area
= 0; area
< LAST_AREA
; ++area
)
1206 for (i
= 0; i
< row
->used
[area
]; ++i
)
1207 if (BUFFERP (row
->glyphs
[area
][i
].object
)
1208 && row
->glyphs
[area
][i
].charpos
> 0)
1209 row
->glyphs
[area
][i
].charpos
+= delta
;
1211 /* Capture the case of rows displaying a line end. */
1212 if (row
->used
[TEXT_AREA
] == 0
1213 && MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1214 row
->glyphs
[TEXT_AREA
]->charpos
+= delta
;
1219 /* Swap glyphs between two glyph rows A and B. This exchanges glyph
1220 contents, i.e. glyph structure contents are exchanged between A and
1221 B without changing glyph pointers in A and B. */
1224 swap_glyphs_in_rows (a
, b
)
1225 struct glyph_row
*a
, *b
;
1229 for (area
= 0; area
< LAST_AREA
; ++area
)
1231 /* Number of glyphs to swap. */
1232 int max_used
= max (a
->used
[area
], b
->used
[area
]);
1234 /* Start of glyphs in area of row A. */
1235 struct glyph
*glyph_a
= a
->glyphs
[area
];
1237 /* End + 1 of glyphs in area of row A. */
1238 struct glyph
*glyph_a_end
= a
->glyphs
[max_used
];
1240 /* Start of glyphs in area of row B. */
1241 struct glyph
*glyph_b
= b
->glyphs
[area
];
1243 while (glyph_a
< glyph_a_end
)
1245 /* Non-ISO HP/UX compiler doesn't like auto struct
1249 *glyph_a
= *glyph_b
;
1259 /* Exchange pointers to glyph memory between glyph rows A and B. */
1262 swap_glyph_pointers (a
, b
)
1263 struct glyph_row
*a
, *b
;
1266 for (i
= 0; i
< LAST_AREA
+ 1; ++i
)
1268 struct glyph
*temp
= a
->glyphs
[i
];
1269 a
->glyphs
[i
] = b
->glyphs
[i
];
1270 b
->glyphs
[i
] = temp
;
1275 /* Copy glyph row structure FROM to glyph row structure TO, except
1276 that glyph pointers in the structures are left unchanged. */
1279 copy_row_except_pointers (to
, from
)
1280 struct glyph_row
*to
, *from
;
1282 struct glyph
*pointers
[1 + LAST_AREA
];
1284 /* Save glyph pointers of TO. */
1285 bcopy (to
->glyphs
, pointers
, sizeof to
->glyphs
);
1287 /* Do a structure assignment. */
1290 /* Restore original pointers of TO. */
1291 bcopy (pointers
, to
->glyphs
, sizeof to
->glyphs
);
1295 /* Copy contents of glyph row FROM to glyph row TO. Glyph pointers in
1296 TO and FROM are left unchanged. Glyph contents are copied from the
1297 glyph memory of FROM to the glyph memory of TO. Increment buffer
1298 positions in row TO by DELTA/ DELTA_BYTES. */
1301 copy_glyph_row_contents (to
, from
, delta
, delta_bytes
)
1302 struct glyph_row
*to
, *from
;
1303 int delta
, delta_bytes
;
1307 /* This is like a structure assignment TO = FROM, except that
1308 glyph pointers in the rows are left unchanged. */
1309 copy_row_except_pointers (to
, from
);
1311 /* Copy glyphs from FROM to TO. */
1312 for (area
= 0; area
< LAST_AREA
; ++area
)
1313 if (from
->used
[area
])
1314 bcopy (from
->glyphs
[area
], to
->glyphs
[area
],
1315 from
->used
[area
] * sizeof (struct glyph
));
1317 /* Increment buffer positions in TO by DELTA. */
1318 increment_row_positions (to
, delta
, delta_bytes
);
1322 /* Assign glyph row FROM to glyph row TO. This works like a structure
1323 assignment TO = FROM, except that glyph pointers are not copied but
1324 exchanged between TO and FROM. Pointers must be exchanged to avoid
1328 assign_row (to
, from
)
1329 struct glyph_row
*to
, *from
;
1331 swap_glyph_pointers (to
, from
);
1332 copy_row_except_pointers (to
, from
);
1336 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1337 a row in a window matrix, is a slice of the glyph memory of the
1338 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1339 is non-zero if the glyph memory of WINDOW_ROW is part of the glyph
1340 memory of FRAME_ROW. */
1345 glyph_row_slice_p (window_row
, frame_row
)
1346 struct glyph_row
*window_row
, *frame_row
;
1348 struct glyph
*window_glyph_start
= window_row
->glyphs
[0];
1349 struct glyph
*frame_glyph_start
= frame_row
->glyphs
[0];
1350 struct glyph
*frame_glyph_end
= frame_row
->glyphs
[LAST_AREA
];
1352 return (frame_glyph_start
<= window_glyph_start
1353 && window_glyph_start
< frame_glyph_end
);
1356 #endif /* GLYPH_DEBUG */
1360 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1361 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1362 in WINDOW_MATRIX is found satisfying the condition. */
1364 static struct glyph_row
*
1365 find_glyph_row_slice (window_matrix
, frame_matrix
, row
)
1366 struct glyph_matrix
*window_matrix
, *frame_matrix
;
1371 xassert (row
>= 0 && row
< frame_matrix
->nrows
);
1373 for (i
= 0; i
< window_matrix
->nrows
; ++i
)
1374 if (glyph_row_slice_p (window_matrix
->rows
+ i
,
1375 frame_matrix
->rows
+ row
))
1378 return i
< window_matrix
->nrows
? window_matrix
->rows
+ i
: 0;
1383 /* Prepare ROW for display. Desired rows are cleared lazily,
1384 i.e. they are only marked as to be cleared by setting their
1385 enabled_p flag to zero. When a row is to be displayed, a prior
1386 call to this function really clears it. */
1389 prepare_desired_row (row
)
1390 struct glyph_row
*row
;
1392 if (!row
->enabled_p
)
1394 clear_glyph_row (row
);
1400 /* Return a hash code for glyph row ROW. */
1403 line_hash_code (row
)
1404 struct glyph_row
*row
;
1410 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
1411 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
1415 int c
= glyph
->u
.ch
;
1416 int face_id
= glyph
->face_id
;
1417 if (FRAME_MUST_WRITE_SPACES (SELECTED_FRAME ())) /* XXX Is SELECTED_FRAME OK here? */
1419 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + c
;
1420 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + face_id
;
1432 /* Return the cost of drawing line VPOS in MATRIX. The cost equals
1433 the number of characters in the line. If must_write_spaces is
1434 zero, leading and trailing spaces are ignored. */
1437 line_draw_cost (matrix
, vpos
)
1438 struct glyph_matrix
*matrix
;
1441 struct glyph_row
*row
= matrix
->rows
+ vpos
;
1442 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
1443 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
];
1445 Lisp_Object
*glyph_table_base
= GLYPH_TABLE_BASE
;
1446 int glyph_table_len
= GLYPH_TABLE_LENGTH
;
1448 /* Ignore trailing and leading spaces if we can. */
1449 if (!FRAME_MUST_WRITE_SPACES (SELECTED_FRAME ())) /* XXX Is SELECTED_FRAME OK here? */
1451 /* Skip from the end over trailing spaces. */
1452 while (end
> beg
&& CHAR_GLYPH_SPACE_P (*(end
- 1)))
1455 /* All blank line. */
1459 /* Skip over leading spaces. */
1460 while (CHAR_GLYPH_SPACE_P (*beg
))
1464 /* If we don't have a glyph-table, each glyph is one character,
1465 so return the number of glyphs. */
1466 if (glyph_table_base
== 0)
1470 /* Otherwise, scan the glyphs and accumulate their total length
1477 SET_GLYPH_FROM_CHAR_GLYPH (g
, *beg
);
1479 if (GLYPH_INVALID_P (g
)
1480 || GLYPH_SIMPLE_P (glyph_table_base
, glyph_table_len
, g
))
1483 len
+= GLYPH_LENGTH (glyph_table_base
, g
);
1493 /* Test two glyph rows A and B for equality. Value is non-zero if A
1494 and B have equal contents. W is the window to which the glyphs
1495 rows A and B belong. It is needed here to test for partial row
1496 visibility. MOUSE_FACE_P non-zero means compare the mouse_face_p
1497 flags of A and B, too. */
1500 row_equal_p (w
, a
, b
, mouse_face_p
)
1502 struct glyph_row
*a
, *b
;
1507 else if (a
->hash
!= b
->hash
)
1511 struct glyph
*a_glyph
, *b_glyph
, *a_end
;
1514 if (mouse_face_p
&& a
->mouse_face_p
!= b
->mouse_face_p
)
1517 /* Compare glyphs. */
1518 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
1520 if (a
->used
[area
] != b
->used
[area
])
1523 a_glyph
= a
->glyphs
[area
];
1524 a_end
= a_glyph
+ a
->used
[area
];
1525 b_glyph
= b
->glyphs
[area
];
1527 while (a_glyph
< a_end
1528 && GLYPH_EQUAL_P (a_glyph
, b_glyph
))
1529 ++a_glyph
, ++b_glyph
;
1531 if (a_glyph
!= a_end
)
1535 if (a
->fill_line_p
!= b
->fill_line_p
1536 || a
->cursor_in_fringe_p
!= b
->cursor_in_fringe_p
1537 || a
->left_fringe_bitmap
!= b
->left_fringe_bitmap
1538 || a
->left_fringe_face_id
!= b
->left_fringe_face_id
1539 || a
->right_fringe_bitmap
!= b
->right_fringe_bitmap
1540 || a
->right_fringe_face_id
!= b
->right_fringe_face_id
1541 || a
->overlay_arrow_bitmap
!= b
->overlay_arrow_bitmap
1542 || a
->exact_window_width_line_p
!= b
->exact_window_width_line_p
1543 || a
->overlapped_p
!= b
->overlapped_p
1544 || (MATRIX_ROW_CONTINUATION_LINE_P (a
)
1545 != MATRIX_ROW_CONTINUATION_LINE_P (b
))
1546 /* Different partially visible characters on left margin. */
1548 /* Different height. */
1549 || a
->ascent
!= b
->ascent
1550 || a
->phys_ascent
!= b
->phys_ascent
1551 || a
->phys_height
!= b
->phys_height
1552 || a
->visible_height
!= b
->visible_height
)
1561 /***********************************************************************
1564 See dispextern.h for an overall explanation of glyph pools.
1565 ***********************************************************************/
1567 /* Allocate a glyph_pool structure. The structure returned is
1568 initialized with zeros. The global variable glyph_pool_count is
1569 incremented for each pool allocated. */
1571 static struct glyph_pool
*
1574 struct glyph_pool
*result
;
1576 /* Allocate a new glyph_pool and clear it. */
1577 result
= (struct glyph_pool
*) xmalloc (sizeof *result
);
1578 bzero (result
, sizeof *result
);
1580 /* For memory leak and double deletion checking. */
1587 /* Free a glyph_pool structure POOL. The function may be called with
1588 a null POOL pointer. The global variable glyph_pool_count is
1589 decremented with every pool structure freed. If this count gets
1590 negative, more structures were freed than allocated, i.e. one
1591 structure must have been freed more than once or a bogus pointer
1592 was passed to free_glyph_pool. */
1595 free_glyph_pool (pool
)
1596 struct glyph_pool
*pool
;
1600 /* More freed than allocated? */
1602 xassert (glyph_pool_count
>= 0);
1604 xfree (pool
->glyphs
);
1610 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1611 columns we need. This function never shrinks a pool. The only
1612 case in which this would make sense, would be when a frame's size
1613 is changed from a large value to a smaller one. But, if someone
1614 does it once, we can expect that he will do it again.
1616 Value is non-zero if the pool changed in a way which makes
1617 re-adjusting window glyph matrices necessary. */
1620 realloc_glyph_pool (pool
, matrix_dim
)
1621 struct glyph_pool
*pool
;
1622 struct dim matrix_dim
;
1627 changed_p
= (pool
->glyphs
== 0
1628 || matrix_dim
.height
!= pool
->nrows
1629 || matrix_dim
.width
!= pool
->ncolumns
);
1631 /* Enlarge the glyph pool. */
1632 needed
= matrix_dim
.width
* matrix_dim
.height
;
1633 if (needed
> pool
->nglyphs
)
1635 int size
= needed
* sizeof (struct glyph
);
1638 pool
->glyphs
= (struct glyph
*) xrealloc (pool
->glyphs
, size
);
1641 pool
->glyphs
= (struct glyph
*) xmalloc (size
);
1642 bzero (pool
->glyphs
, size
);
1645 pool
->nglyphs
= needed
;
1648 /* Remember the number of rows and columns because (a) we use them
1649 to do sanity checks, and (b) the number of columns determines
1650 where rows in the frame matrix start---this must be available to
1651 determine pointers to rows of window sub-matrices. */
1652 pool
->nrows
= matrix_dim
.height
;
1653 pool
->ncolumns
= matrix_dim
.width
;
1660 /***********************************************************************
1662 ***********************************************************************/
1667 /* Flush standard output. This is sometimes useful to call from the debugger.
1668 XXX Maybe this should be changed to flush the current terminal instead of
1679 /* Check that no glyph pointers have been lost in MATRIX. If a
1680 pointer has been lost, e.g. by using a structure assignment between
1681 rows, at least one pointer must occur more than once in the rows of
1685 check_matrix_pointer_lossage (matrix
)
1686 struct glyph_matrix
*matrix
;
1690 for (i
= 0; i
< matrix
->nrows
; ++i
)
1691 for (j
= 0; j
< matrix
->nrows
; ++j
)
1693 || (matrix
->rows
[i
].glyphs
[TEXT_AREA
]
1694 != matrix
->rows
[j
].glyphs
[TEXT_AREA
]));
1698 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1701 matrix_row (matrix
, row
)
1702 struct glyph_matrix
*matrix
;
1705 xassert (matrix
&& matrix
->rows
);
1706 xassert (row
>= 0 && row
< matrix
->nrows
);
1708 /* That's really too slow for normal testing because this function
1709 is called almost everywhere. Although---it's still astonishingly
1710 fast, so it is valuable to have for debugging purposes. */
1712 check_matrix_pointer_lossage (matrix
);
1715 return matrix
->rows
+ row
;
1719 #if 0 /* This function makes invalid assumptions when text is
1720 partially invisible. But it might come handy for debugging
1723 /* Check invariants that must hold for an up to date current matrix of
1727 check_matrix_invariants (w
)
1730 struct glyph_matrix
*matrix
= w
->current_matrix
;
1731 int yb
= window_text_bottom_y (w
);
1732 struct glyph_row
*row
= matrix
->rows
;
1733 struct glyph_row
*last_text_row
= NULL
;
1734 struct buffer
*saved
= current_buffer
;
1735 struct buffer
*buffer
= XBUFFER (w
->buffer
);
1738 /* This can sometimes happen for a fresh window. */
1739 if (matrix
->nrows
< 2)
1742 set_buffer_temp (buffer
);
1744 /* Note: last row is always reserved for the mode line. */
1745 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1746 && MATRIX_ROW_BOTTOM_Y (row
) < yb
)
1748 struct glyph_row
*next
= row
+ 1;
1750 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1751 last_text_row
= row
;
1753 /* Check that character and byte positions are in sync. */
1754 xassert (MATRIX_ROW_START_BYTEPOS (row
)
1755 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row
)));
1757 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1758 have such a position temporarily in case of a minibuffer
1759 displaying something like `[Sole completion]' at its end. */
1760 if (MATRIX_ROW_END_CHARPOS (row
) < BUF_ZV (current_buffer
))
1761 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1762 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row
)));
1764 /* Check that end position of `row' is equal to start position
1766 if (next
->enabled_p
&& MATRIX_ROW_DISPLAYS_TEXT_P (next
))
1768 xassert (MATRIX_ROW_END_CHARPOS (row
)
1769 == MATRIX_ROW_START_CHARPOS (next
));
1770 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1771 == MATRIX_ROW_START_BYTEPOS (next
));
1776 xassert (w
->current_matrix
->nrows
== w
->desired_matrix
->nrows
);
1777 xassert (w
->desired_matrix
->rows
!= NULL
);
1778 set_buffer_temp (saved
);
1783 #endif /* GLYPH_DEBUG != 0 */
1787 /**********************************************************************
1788 Allocating/ Adjusting Glyph Matrices
1789 **********************************************************************/
1791 /* Allocate glyph matrices over a window tree for a frame-based
1794 X and Y are column/row within the frame glyph matrix where
1795 sub-matrices for the window tree rooted at WINDOW must be
1796 allocated. DIM_ONLY_P non-zero means that the caller of this
1797 function is only interested in the result matrix dimension, and
1798 matrix adjustments should not be performed.
1800 The function returns the total width/height of the sub-matrices of
1801 the window tree. If called on a frame root window, the computation
1802 will take the mini-buffer window into account.
1804 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1806 NEW_LEAF_MATRIX set if any window in the tree did not have a
1807 glyph matrices yet, and
1809 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1810 any window in the tree will be changed or have been changed (see
1813 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1816 Windows are arranged into chains of windows on the same level
1817 through the next fields of window structures. Such a level can be
1818 either a sequence of horizontally adjacent windows from left to
1819 right, or a sequence of vertically adjacent windows from top to
1820 bottom. Each window in a horizontal sequence can be either a leaf
1821 window or a vertical sequence; a window in a vertical sequence can
1822 be either a leaf or a horizontal sequence. All windows in a
1823 horizontal sequence have the same height, and all windows in a
1824 vertical sequence have the same width.
1826 This function uses, for historical reasons, a more general
1827 algorithm to determine glyph matrix dimensions that would be
1830 The matrix height of a horizontal sequence is determined by the
1831 maximum height of any matrix in the sequence. The matrix width of
1832 a horizontal sequence is computed by adding up matrix widths of
1833 windows in the sequence.
1835 |<------- result width ------->|
1836 +---------+----------+---------+ ---
1839 +---------+ | | result height
1844 The matrix width of a vertical sequence is the maximum matrix width
1845 of any window in the sequence. Its height is computed by adding up
1846 matrix heights of windows in the sequence.
1848 |<---- result width -->|
1856 +------------+---------+ |
1859 +------------+---------+ --- */
1861 /* Bit indicating that a new matrix will be allocated or has been
1864 #define NEW_LEAF_MATRIX (1 << 0)
1866 /* Bit indicating that a matrix will or has changed its location or
1869 #define CHANGED_LEAF_MATRIX (1 << 1)
1872 allocate_matrices_for_frame_redisplay (window
, x
, y
, dim_only_p
,
1873 window_change_flags
)
1877 int *window_change_flags
;
1879 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1881 int wmax
= 0, hmax
= 0;
1885 int in_horz_combination_p
;
1887 /* What combination is WINDOW part of? Compute this once since the
1888 result is the same for all windows in the `next' chain. The
1889 special case of a root window (parent equal to nil) is treated
1890 like a vertical combination because a root window's `next'
1891 points to the mini-buffer window, if any, which is arranged
1892 vertically below other windows. */
1893 in_horz_combination_p
1894 = (!NILP (XWINDOW (window
)->parent
)
1895 && !NILP (XWINDOW (XWINDOW (window
)->parent
)->hchild
));
1897 /* For WINDOW and all windows on the same level. */
1900 w
= XWINDOW (window
);
1902 /* Get the dimension of the window sub-matrix for W, depending
1903 on whether this is a combination or a leaf window. */
1904 if (!NILP (w
->hchild
))
1905 dim
= allocate_matrices_for_frame_redisplay (w
->hchild
, x
, y
,
1907 window_change_flags
);
1908 else if (!NILP (w
->vchild
))
1909 dim
= allocate_matrices_for_frame_redisplay (w
->vchild
, x
, y
,
1911 window_change_flags
);
1914 /* If not already done, allocate sub-matrix structures. */
1915 if (w
->desired_matrix
== NULL
)
1917 w
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1918 w
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1919 *window_change_flags
|= NEW_LEAF_MATRIX
;
1922 /* Width and height MUST be chosen so that there are no
1923 holes in the frame matrix. */
1924 dim
.width
= required_matrix_width (w
);
1925 dim
.height
= required_matrix_height (w
);
1927 /* Will matrix be re-allocated? */
1928 if (x
!= w
->desired_matrix
->matrix_x
1929 || y
!= w
->desired_matrix
->matrix_y
1930 || dim
.width
!= w
->desired_matrix
->matrix_w
1931 || dim
.height
!= w
->desired_matrix
->matrix_h
1932 || (margin_glyphs_to_reserve (w
, dim
.width
,
1933 w
->left_margin_cols
)
1934 != w
->desired_matrix
->left_margin_glyphs
)
1935 || (margin_glyphs_to_reserve (w
, dim
.width
,
1936 w
->right_margin_cols
)
1937 != w
->desired_matrix
->right_margin_glyphs
))
1938 *window_change_flags
|= CHANGED_LEAF_MATRIX
;
1940 /* Actually change matrices, if allowed. Do not consider
1941 CHANGED_LEAF_MATRIX computed above here because the pool
1942 may have been changed which we don't now here. We trust
1943 that we only will be called with DIM_ONLY_P != 0 when
1947 adjust_glyph_matrix (w
, w
->desired_matrix
, x
, y
, dim
);
1948 adjust_glyph_matrix (w
, w
->current_matrix
, x
, y
, dim
);
1952 /* If we are part of a horizontal combination, advance x for
1953 windows to the right of W; otherwise advance y for windows
1955 if (in_horz_combination_p
)
1960 /* Remember maximum glyph matrix dimensions. */
1961 wmax
= max (wmax
, dim
.width
);
1962 hmax
= max (hmax
, dim
.height
);
1964 /* Next window on same level. */
1967 while (!NILP (window
));
1969 /* Set `total' to the total glyph matrix dimension of this window
1970 level. In a vertical combination, the width is the width of the
1971 widest window; the height is the y we finally reached, corrected
1972 by the y we started with. In a horizontal combination, the total
1973 height is the height of the tallest window, and the width is the
1974 x we finally reached, corrected by the x we started with. */
1975 if (in_horz_combination_p
)
1977 total
.width
= x
- x0
;
1978 total
.height
= hmax
;
1983 total
.height
= y
- y0
;
1990 /* Return the required height of glyph matrices for window W. */
1993 required_matrix_height (w
)
1996 #ifdef HAVE_WINDOW_SYSTEM
1997 struct frame
*f
= XFRAME (w
->frame
);
1999 if (FRAME_WINDOW_P (f
))
2001 int ch_height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
2002 int window_pixel_height
= window_box_height (w
) + eabs (w
->vscroll
);
2003 return (((window_pixel_height
+ ch_height
- 1)
2004 / ch_height
) * w
->nrows_scale_factor
2005 /* One partially visible line at the top and
2006 bottom of the window. */
2008 /* 2 for header and mode line. */
2011 #endif /* HAVE_WINDOW_SYSTEM */
2013 return WINDOW_TOTAL_LINES (w
);
2017 /* Return the required width of glyph matrices for window W. */
2020 required_matrix_width (w
)
2023 #ifdef HAVE_WINDOW_SYSTEM
2024 struct frame
*f
= XFRAME (w
->frame
);
2025 if (FRAME_WINDOW_P (f
))
2027 int ch_width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
2028 int window_pixel_width
= WINDOW_TOTAL_WIDTH (w
);
2030 /* Compute number of glyphs needed in a glyph row. */
2031 return (((window_pixel_width
+ ch_width
- 1)
2032 / ch_width
) * w
->ncols_scale_factor
2033 /* 2 partially visible columns in the text area. */
2035 /* One partially visible column at the right
2036 edge of each marginal area. */
2039 #endif /* HAVE_WINDOW_SYSTEM */
2041 return XINT (w
->total_cols
);
2045 /* Allocate window matrices for window-based redisplay. W is the
2046 window whose matrices must be allocated/reallocated. */
2049 allocate_matrices_for_window_redisplay (w
)
2054 if (!NILP (w
->vchild
))
2055 allocate_matrices_for_window_redisplay (XWINDOW (w
->vchild
));
2056 else if (!NILP (w
->hchild
))
2057 allocate_matrices_for_window_redisplay (XWINDOW (w
->hchild
));
2060 /* W is a leaf window. */
2063 /* If matrices are not yet allocated, allocate them now. */
2064 if (w
->desired_matrix
== NULL
)
2066 w
->desired_matrix
= new_glyph_matrix (NULL
);
2067 w
->current_matrix
= new_glyph_matrix (NULL
);
2070 dim
.width
= required_matrix_width (w
);
2071 dim
.height
= required_matrix_height (w
);
2072 adjust_glyph_matrix (w
, w
->desired_matrix
, 0, 0, dim
);
2073 adjust_glyph_matrix (w
, w
->current_matrix
, 0, 0, dim
);
2076 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
2081 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
2082 do it for all frames; otherwise do it just for the given frame.
2083 This function must be called when a new frame is created, its size
2084 changes, or its window configuration changes. */
2090 /* Block input so that expose events and other events that access
2091 glyph matrices are not processed while we are changing them. */
2095 adjust_frame_glyphs (f
);
2098 Lisp_Object tail
, lisp_frame
;
2100 FOR_EACH_FRAME (tail
, lisp_frame
)
2101 adjust_frame_glyphs (XFRAME (lisp_frame
));
2108 /* Adjust frame glyphs when Emacs is initialized.
2110 To be called from init_display.
2112 We need a glyph matrix because redraw will happen soon.
2113 Unfortunately, window sizes on selected_frame are not yet set to
2114 meaningful values. I believe we can assume that there are only two
2115 windows on the frame---the mini-buffer and the root window. Frame
2116 height and width seem to be correct so far. So, set the sizes of
2117 windows to estimated values. */
2120 adjust_frame_glyphs_initially ()
2122 struct frame
*sf
= SELECTED_FRAME ();
2123 struct window
*root
= XWINDOW (sf
->root_window
);
2124 struct window
*mini
= XWINDOW (root
->next
);
2125 int frame_lines
= FRAME_LINES (sf
);
2126 int frame_cols
= FRAME_COLS (sf
);
2127 int top_margin
= FRAME_TOP_MARGIN (sf
);
2129 /* Do it for the root window. */
2130 XSETFASTINT (root
->top_line
, top_margin
);
2131 XSETFASTINT (root
->total_cols
, frame_cols
);
2132 set_window_height (sf
->root_window
, frame_lines
- 1 - top_margin
, 0);
2134 /* Do it for the mini-buffer window. */
2135 XSETFASTINT (mini
->top_line
, frame_lines
- 1);
2136 XSETFASTINT (mini
->total_cols
, frame_cols
);
2137 set_window_height (root
->next
, 1, 0);
2139 adjust_frame_glyphs (sf
);
2140 glyphs_initialized_initially_p
= 1;
2144 /* Allocate/reallocate glyph matrices of a single frame F. */
2147 adjust_frame_glyphs (f
)
2150 if (FRAME_WINDOW_P (f
))
2151 adjust_frame_glyphs_for_window_redisplay (f
);
2153 adjust_frame_glyphs_for_frame_redisplay (f
);
2155 /* Don't forget the message buffer and the buffer for
2156 decode_mode_spec. */
2157 adjust_frame_message_buffer (f
);
2158 adjust_decode_mode_spec_buffer (f
);
2160 f
->glyphs_initialized_p
= 1;
2163 /* Return 1 if any window in the tree has nonzero window margins. See
2164 the hack at the end of adjust_frame_glyphs_for_frame_redisplay. */
2166 showing_window_margins_p (w
)
2171 if (!NILP (w
->hchild
))
2173 if (showing_window_margins_p (XWINDOW (w
->hchild
)))
2176 else if (!NILP (w
->vchild
))
2178 if (showing_window_margins_p (XWINDOW (w
->vchild
)))
2181 else if (!NILP (w
->left_margin_cols
)
2182 || !NILP (w
->right_margin_cols
))
2185 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2191 /* In the window tree with root W, build current matrices of leaf
2192 windows from the frame's current matrix. */
2195 fake_current_matrices (window
)
2200 for (; !NILP (window
); window
= w
->next
)
2202 w
= XWINDOW (window
);
2204 if (!NILP (w
->hchild
))
2205 fake_current_matrices (w
->hchild
);
2206 else if (!NILP (w
->vchild
))
2207 fake_current_matrices (w
->vchild
);
2211 struct frame
*f
= XFRAME (w
->frame
);
2212 struct glyph_matrix
*m
= w
->current_matrix
;
2213 struct glyph_matrix
*fm
= f
->current_matrix
;
2215 xassert (m
->matrix_h
== WINDOW_TOTAL_LINES (w
));
2216 xassert (m
->matrix_w
== WINDOW_TOTAL_COLS (w
));
2218 for (i
= 0; i
< m
->matrix_h
; ++i
)
2220 struct glyph_row
*r
= m
->rows
+ i
;
2221 struct glyph_row
*fr
= fm
->rows
+ i
+ WINDOW_TOP_EDGE_LINE (w
);
2223 xassert (r
->glyphs
[TEXT_AREA
] >= fr
->glyphs
[TEXT_AREA
]
2224 && r
->glyphs
[LAST_AREA
] <= fr
->glyphs
[LAST_AREA
]);
2226 r
->enabled_p
= fr
->enabled_p
;
2229 r
->used
[LEFT_MARGIN_AREA
] = m
->left_margin_glyphs
;
2230 r
->used
[RIGHT_MARGIN_AREA
] = m
->right_margin_glyphs
;
2231 r
->used
[TEXT_AREA
] = (m
->matrix_w
2232 - r
->used
[LEFT_MARGIN_AREA
]
2233 - r
->used
[RIGHT_MARGIN_AREA
]);
2242 /* Save away the contents of frame F's current frame matrix. Value is
2243 a glyph matrix holding the contents of F's current frame matrix. */
2245 static struct glyph_matrix
*
2246 save_current_matrix (f
)
2250 struct glyph_matrix
*saved
;
2252 saved
= (struct glyph_matrix
*) xmalloc (sizeof *saved
);
2253 bzero (saved
, sizeof *saved
);
2254 saved
->nrows
= f
->current_matrix
->nrows
;
2255 saved
->rows
= (struct glyph_row
*) xmalloc (saved
->nrows
2256 * sizeof *saved
->rows
);
2257 bzero (saved
->rows
, saved
->nrows
* sizeof *saved
->rows
);
2259 for (i
= 0; i
< saved
->nrows
; ++i
)
2261 struct glyph_row
*from
= f
->current_matrix
->rows
+ i
;
2262 struct glyph_row
*to
= saved
->rows
+ i
;
2263 size_t nbytes
= from
->used
[TEXT_AREA
] * sizeof (struct glyph
);
2264 to
->glyphs
[TEXT_AREA
] = (struct glyph
*) xmalloc (nbytes
);
2265 bcopy (from
->glyphs
[TEXT_AREA
], to
->glyphs
[TEXT_AREA
], nbytes
);
2266 to
->used
[TEXT_AREA
] = from
->used
[TEXT_AREA
];
2273 /* Restore the contents of frame F's current frame matrix from SAVED,
2274 and free memory associated with SAVED. */
2277 restore_current_matrix (f
, saved
)
2279 struct glyph_matrix
*saved
;
2283 for (i
= 0; i
< saved
->nrows
; ++i
)
2285 struct glyph_row
*from
= saved
->rows
+ i
;
2286 struct glyph_row
*to
= f
->current_matrix
->rows
+ i
;
2287 size_t nbytes
= from
->used
[TEXT_AREA
] * sizeof (struct glyph
);
2288 bcopy (from
->glyphs
[TEXT_AREA
], to
->glyphs
[TEXT_AREA
], nbytes
);
2289 to
->used
[TEXT_AREA
] = from
->used
[TEXT_AREA
];
2290 xfree (from
->glyphs
[TEXT_AREA
]);
2293 xfree (saved
->rows
);
2299 /* Allocate/reallocate glyph matrices of a single frame F for
2300 frame-based redisplay. */
2303 adjust_frame_glyphs_for_frame_redisplay (f
)
2306 struct dim matrix_dim
;
2308 int window_change_flags
;
2311 if (!FRAME_LIVE_P (f
))
2314 top_window_y
= FRAME_TOP_MARGIN (f
);
2316 /* Allocate glyph pool structures if not already done. */
2317 if (f
->desired_pool
== NULL
)
2319 f
->desired_pool
= new_glyph_pool ();
2320 f
->current_pool
= new_glyph_pool ();
2323 /* Allocate frames matrix structures if needed. */
2324 if (f
->desired_matrix
== NULL
)
2326 f
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
2327 f
->current_matrix
= new_glyph_matrix (f
->current_pool
);
2330 /* Compute window glyph matrices. (This takes the mini-buffer
2331 window into account). The result is the size of the frame glyph
2332 matrix needed. The variable window_change_flags is set to a bit
2333 mask indicating whether new matrices will be allocated or
2334 existing matrices change their size or location within the frame
2336 window_change_flags
= 0;
2338 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2341 &window_change_flags
);
2343 /* Add in menu bar lines, if any. */
2344 matrix_dim
.height
+= top_window_y
;
2346 /* Enlarge pools as necessary. */
2347 pool_changed_p
= realloc_glyph_pool (f
->desired_pool
, matrix_dim
);
2348 realloc_glyph_pool (f
->current_pool
, matrix_dim
);
2350 /* Set up glyph pointers within window matrices. Do this only if
2351 absolutely necessary since it requires a frame redraw. */
2352 if (pool_changed_p
|| window_change_flags
)
2354 /* Do it for window matrices. */
2355 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2357 &window_change_flags
);
2359 /* Size of frame matrices must equal size of frame. Note
2360 that we are called for X frames with window widths NOT equal
2361 to the frame width (from CHANGE_FRAME_SIZE_1). */
2362 xassert (matrix_dim
.width
== FRAME_COLS (f
)
2363 && matrix_dim
.height
== FRAME_LINES (f
));
2365 /* Pointers to glyph memory in glyph rows are exchanged during
2366 the update phase of redisplay, which means in general that a
2367 frame's current matrix consists of pointers into both the
2368 desired and current glyph pool of the frame. Adjusting a
2369 matrix sets the frame matrix up so that pointers are all into
2370 the same pool. If we want to preserve glyph contents of the
2371 current matrix over a call to adjust_glyph_matrix, we must
2372 make a copy of the current glyphs, and restore the current
2373 matrix' contents from that copy. */
2374 if (display_completed
2375 && !FRAME_GARBAGED_P (f
)
2376 && matrix_dim
.width
== f
->current_matrix
->matrix_w
2377 && matrix_dim
.height
== f
->current_matrix
->matrix_h
2378 /* For some reason, the frame glyph matrix gets corrupted if
2379 any of the windows contain margins. I haven't been able
2380 to hunt down the reason, but for the moment this prevents
2381 the problem from manifesting. -- cyd */
2382 && !showing_window_margins_p (XWINDOW (FRAME_ROOT_WINDOW (f
))))
2384 struct glyph_matrix
*copy
= save_current_matrix (f
);
2385 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2386 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2387 restore_current_matrix (f
, copy
);
2388 fake_current_matrices (FRAME_ROOT_WINDOW (f
));
2392 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2393 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2394 SET_FRAME_GARBAGED (f
);
2400 /* Allocate/reallocate glyph matrices of a single frame F for
2401 window-based redisplay. */
2404 adjust_frame_glyphs_for_window_redisplay (f
)
2409 xassert (FRAME_WINDOW_P (f
) && FRAME_LIVE_P (f
));
2411 /* Allocate/reallocate window matrices. */
2412 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2414 #ifdef HAVE_X_WINDOWS
2415 /* Allocate/ reallocate matrices of the dummy window used to display
2416 the menu bar under X when no X toolkit support is available. */
2417 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
2419 /* Allocate a dummy window if not already done. */
2420 if (NILP (f
->menu_bar_window
))
2422 f
->menu_bar_window
= make_window ();
2423 w
= XWINDOW (f
->menu_bar_window
);
2424 XSETFRAME (w
->frame
, f
);
2425 w
->pseudo_window_p
= 1;
2428 w
= XWINDOW (f
->menu_bar_window
);
2430 /* Set window dimensions to frame dimensions and allocate or
2431 adjust glyph matrices of W. */
2432 XSETFASTINT (w
->top_line
, 0);
2433 XSETFASTINT (w
->left_col
, 0);
2434 XSETFASTINT (w
->total_lines
, FRAME_MENU_BAR_LINES (f
));
2435 XSETFASTINT (w
->total_cols
, FRAME_TOTAL_COLS (f
));
2436 allocate_matrices_for_window_redisplay (w
);
2438 #endif /* not USE_X_TOOLKIT && not USE_GTK */
2439 #endif /* HAVE_X_WINDOWS */
2442 /* Allocate/ reallocate matrices of the tool bar window. If we
2443 don't have a tool bar window yet, make one. */
2444 if (NILP (f
->tool_bar_window
))
2446 f
->tool_bar_window
= make_window ();
2447 w
= XWINDOW (f
->tool_bar_window
);
2448 XSETFRAME (w
->frame
, f
);
2449 w
->pseudo_window_p
= 1;
2452 w
= XWINDOW (f
->tool_bar_window
);
2454 XSETFASTINT (w
->top_line
, FRAME_MENU_BAR_LINES (f
));
2455 XSETFASTINT (w
->left_col
, 0);
2456 XSETFASTINT (w
->total_lines
, FRAME_TOOL_BAR_LINES (f
));
2457 XSETFASTINT (w
->total_cols
, FRAME_TOTAL_COLS (f
));
2458 allocate_matrices_for_window_redisplay (w
);
2463 /* Adjust/ allocate message buffer of frame F.
2465 Note that the message buffer is never freed. Since I could not
2466 find a free in 19.34, I assume that freeing it would be
2467 problematic in some way and don't do it either.
2469 (Implementation note: It should be checked if we can free it
2470 eventually without causing trouble). */
2473 adjust_frame_message_buffer (f
)
2476 int size
= FRAME_MESSAGE_BUF_SIZE (f
) + 1;
2478 if (FRAME_MESSAGE_BUF (f
))
2480 char *buffer
= FRAME_MESSAGE_BUF (f
);
2481 char *new_buffer
= (char *) xrealloc (buffer
, size
);
2482 FRAME_MESSAGE_BUF (f
) = new_buffer
;
2485 FRAME_MESSAGE_BUF (f
) = (char *) xmalloc (size
);
2489 /* Re-allocate buffer for decode_mode_spec on frame F. */
2492 adjust_decode_mode_spec_buffer (f
)
2495 f
->decode_mode_spec_buffer
2496 = (char *) xrealloc (f
->decode_mode_spec_buffer
,
2497 FRAME_MESSAGE_BUF_SIZE (f
) + 1);
2502 /**********************************************************************
2503 Freeing Glyph Matrices
2504 **********************************************************************/
2506 /* Free glyph memory for a frame F. F may be null. This function can
2507 be called for the same frame more than once. The root window of
2508 F may be nil when this function is called. This is the case when
2509 the function is called when F is destroyed. */
2515 if (f
&& f
->glyphs_initialized_p
)
2517 /* Block interrupt input so that we don't get surprised by an X
2518 event while we're in an inconsistent state. */
2520 f
->glyphs_initialized_p
= 0;
2522 /* Release window sub-matrices. */
2523 if (!NILP (f
->root_window
))
2524 free_window_matrices (XWINDOW (f
->root_window
));
2526 /* Free the dummy window for menu bars without X toolkit and its
2528 if (!NILP (f
->menu_bar_window
))
2530 struct window
*w
= XWINDOW (f
->menu_bar_window
);
2531 free_glyph_matrix (w
->desired_matrix
);
2532 free_glyph_matrix (w
->current_matrix
);
2533 w
->desired_matrix
= w
->current_matrix
= NULL
;
2534 f
->menu_bar_window
= Qnil
;
2537 /* Free the tool bar window and its glyph matrices. */
2538 if (!NILP (f
->tool_bar_window
))
2540 struct window
*w
= XWINDOW (f
->tool_bar_window
);
2541 free_glyph_matrix (w
->desired_matrix
);
2542 free_glyph_matrix (w
->current_matrix
);
2543 w
->desired_matrix
= w
->current_matrix
= NULL
;
2544 f
->tool_bar_window
= Qnil
;
2547 /* Release frame glyph matrices. Reset fields to zero in
2548 case we are called a second time. */
2549 if (f
->desired_matrix
)
2551 free_glyph_matrix (f
->desired_matrix
);
2552 free_glyph_matrix (f
->current_matrix
);
2553 f
->desired_matrix
= f
->current_matrix
= NULL
;
2556 /* Release glyph pools. */
2557 if (f
->desired_pool
)
2559 free_glyph_pool (f
->desired_pool
);
2560 free_glyph_pool (f
->current_pool
);
2561 f
->desired_pool
= f
->current_pool
= NULL
;
2569 /* Free glyph sub-matrices in the window tree rooted at W. This
2570 function may be called with a null pointer, and it may be called on
2571 the same tree more than once. */
2574 free_window_matrices (w
)
2579 if (!NILP (w
->hchild
))
2580 free_window_matrices (XWINDOW (w
->hchild
));
2581 else if (!NILP (w
->vchild
))
2582 free_window_matrices (XWINDOW (w
->vchild
));
2585 /* This is a leaf window. Free its memory and reset fields
2586 to zero in case this function is called a second time for
2588 free_glyph_matrix (w
->current_matrix
);
2589 free_glyph_matrix (w
->desired_matrix
);
2590 w
->current_matrix
= w
->desired_matrix
= NULL
;
2593 /* Next window on same level. */
2594 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2599 /* Check glyph memory leaks. This function is called from
2600 shut_down_emacs. Note that frames are not destroyed when Emacs
2601 exits. We therefore free all glyph memory for all active frames
2602 explicitly and check that nothing is left allocated. */
2605 check_glyph_memory ()
2607 Lisp_Object tail
, frame
;
2609 /* Free glyph memory for all frames. */
2610 FOR_EACH_FRAME (tail
, frame
)
2611 free_glyphs (XFRAME (frame
));
2613 /* Check that nothing is left allocated. */
2614 if (glyph_matrix_count
)
2616 if (glyph_pool_count
)
2622 /**********************************************************************
2623 Building a Frame Matrix
2624 **********************************************************************/
2626 /* Most of the redisplay code works on glyph matrices attached to
2627 windows. This is a good solution most of the time, but it is not
2628 suitable for terminal code. Terminal output functions cannot rely
2629 on being able to set an arbitrary terminal window. Instead they
2630 must be provided with a view of the whole frame, i.e. the whole
2631 screen. We build such a view by constructing a frame matrix from
2632 window matrices in this section.
2634 Windows that must be updated have their must_be_update_p flag set.
2635 For all such windows, their desired matrix is made part of the
2636 desired frame matrix. For other windows, their current matrix is
2637 made part of the desired frame matrix.
2639 +-----------------+----------------+
2640 | desired | desired |
2642 +-----------------+----------------+
2645 +----------------------------------+
2647 Desired window matrices can be made part of the frame matrix in a
2648 cheap way: We exploit the fact that the desired frame matrix and
2649 desired window matrices share their glyph memory. This is not
2650 possible for current window matrices. Their glyphs are copied to
2651 the desired frame matrix. The latter is equivalent to
2652 preserve_other_columns in the old redisplay.
2654 Used glyphs counters for frame matrix rows are the result of adding
2655 up glyph lengths of the window matrices. A line in the frame
2656 matrix is enabled, if a corresponding line in a window matrix is
2659 After building the desired frame matrix, it will be passed to
2660 terminal code, which will manipulate both the desired and current
2661 frame matrix. Changes applied to the frame's current matrix have
2662 to be visible in current window matrices afterwards, of course.
2664 This problem is solved like this:
2666 1. Window and frame matrices share glyphs. Window matrices are
2667 constructed in a way that their glyph contents ARE the glyph
2668 contents needed in a frame matrix. Thus, any modification of
2669 glyphs done in terminal code will be reflected in window matrices
2672 2. Exchanges of rows in a frame matrix done by terminal code are
2673 intercepted by hook functions so that corresponding row operations
2674 on window matrices can be performed. This is necessary because we
2675 use pointers to glyphs in glyph row structures. To satisfy the
2676 assumption of point 1 above that glyphs are updated implicitly in
2677 window matrices when they are manipulated via the frame matrix,
2678 window and frame matrix must of course agree where to find the
2679 glyphs for their rows. Possible manipulations that must be
2680 mirrored are assignments of rows of the desired frame matrix to the
2681 current frame matrix and scrolling the current frame matrix. */
2683 /* Build frame F's desired matrix from window matrices. Only windows
2684 which have the flag must_be_updated_p set have to be updated. Menu
2685 bar lines of a frame are not covered by window matrices, so make
2686 sure not to touch them in this function. */
2689 build_frame_matrix (f
)
2694 /* F must have a frame matrix when this function is called. */
2695 xassert (!FRAME_WINDOW_P (f
));
2697 /* Clear all rows in the frame matrix covered by window matrices.
2698 Menu bar lines are not covered by windows. */
2699 for (i
= FRAME_TOP_MARGIN (f
); i
< f
->desired_matrix
->nrows
; ++i
)
2700 clear_glyph_row (MATRIX_ROW (f
->desired_matrix
, i
));
2702 /* Build the matrix by walking the window tree. */
2703 build_frame_matrix_from_window_tree (f
->desired_matrix
,
2704 XWINDOW (FRAME_ROOT_WINDOW (f
)));
2708 /* Walk a window tree, building a frame matrix MATRIX from window
2709 matrices. W is the root of a window tree. */
2712 build_frame_matrix_from_window_tree (matrix
, w
)
2713 struct glyph_matrix
*matrix
;
2718 if (!NILP (w
->hchild
))
2719 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->hchild
));
2720 else if (!NILP (w
->vchild
))
2721 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->vchild
));
2723 build_frame_matrix_from_leaf_window (matrix
, w
);
2725 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2730 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2731 desired frame matrix built. W is a leaf window whose desired or
2732 current matrix is to be added to FRAME_MATRIX. W's flag
2733 must_be_updated_p determines which matrix it contributes to
2734 FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix
2735 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2736 Adding a desired matrix means setting up used counters and such in
2737 frame rows, while adding a current window matrix to FRAME_MATRIX
2738 means copying glyphs. The latter case corresponds to
2739 preserve_other_columns in the old redisplay. */
2742 build_frame_matrix_from_leaf_window (frame_matrix
, w
)
2743 struct glyph_matrix
*frame_matrix
;
2746 struct glyph_matrix
*window_matrix
;
2747 int window_y
, frame_y
;
2748 /* If non-zero, a glyph to insert at the right border of W. */
2749 GLYPH right_border_glyph
;
2751 SET_GLYPH_FROM_CHAR (right_border_glyph
, 0);
2753 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2754 if (w
->must_be_updated_p
)
2756 window_matrix
= w
->desired_matrix
;
2758 /* Decide whether we want to add a vertical border glyph. */
2759 if (!WINDOW_RIGHTMOST_P (w
))
2761 struct Lisp_Char_Table
*dp
= window_display_table (w
);
2764 SET_GLYPH_FROM_CHAR (right_border_glyph
, '|');
2766 && (gc
= DISP_BORDER_GLYPH (dp
), GLYPH_CODE_P (gc
))
2767 && GLYPH_CODE_CHAR_VALID_P (gc
))
2769 SET_GLYPH_FROM_GLYPH_CODE (right_border_glyph
, gc
);
2770 spec_glyph_lookup_face (w
, &right_border_glyph
);
2773 if (GLYPH_FACE (right_border_glyph
) <= 0)
2774 SET_GLYPH_FACE (right_border_glyph
, VERTICAL_BORDER_FACE_ID
);
2778 window_matrix
= w
->current_matrix
;
2780 /* For all rows in the window matrix and corresponding rows in the
2783 frame_y
= window_matrix
->matrix_y
;
2784 while (window_y
< window_matrix
->nrows
)
2786 struct glyph_row
*frame_row
= frame_matrix
->rows
+ frame_y
;
2787 struct glyph_row
*window_row
= window_matrix
->rows
+ window_y
;
2788 int current_row_p
= window_matrix
== w
->current_matrix
;
2790 /* Fill up the frame row with spaces up to the left margin of the
2792 fill_up_frame_row_with_spaces (frame_row
, window_matrix
->matrix_x
);
2794 /* Fill up areas in the window matrix row with spaces. */
2795 fill_up_glyph_row_with_spaces (window_row
);
2797 /* If only part of W's desired matrix has been built, and
2798 window_row wasn't displayed, use the corresponding current
2800 if (window_matrix
== w
->desired_matrix
2801 && !window_row
->enabled_p
)
2803 window_row
= w
->current_matrix
->rows
+ window_y
;
2809 /* Copy window row to frame row. */
2810 bcopy (window_row
->glyphs
[0],
2811 frame_row
->glyphs
[TEXT_AREA
] + window_matrix
->matrix_x
,
2812 window_matrix
->matrix_w
* sizeof (struct glyph
));
2816 xassert (window_row
->enabled_p
);
2818 /* Only when a desired row has been displayed, we want
2819 the corresponding frame row to be updated. */
2820 frame_row
->enabled_p
= 1;
2822 /* Maybe insert a vertical border between horizontally adjacent
2824 if (GLYPH_CHAR (right_border_glyph
) != 0)
2826 struct glyph
*border
= window_row
->glyphs
[LAST_AREA
] - 1;
2827 SET_CHAR_GLYPH_FROM_GLYPH (*border
, right_border_glyph
);
2831 /* Window row window_y must be a slice of frame row
2833 xassert (glyph_row_slice_p (window_row
, frame_row
));
2835 /* If rows are in sync, we don't have to copy glyphs because
2836 frame and window share glyphs. */
2838 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
2839 add_window_display_history (w
, w
->current_matrix
->method
, 0);
2843 /* Set number of used glyphs in the frame matrix. Since we fill
2844 up with spaces, and visit leaf windows from left to right it
2845 can be done simply. */
2846 frame_row
->used
[TEXT_AREA
]
2847 = window_matrix
->matrix_x
+ window_matrix
->matrix_w
;
2855 /* Given a user-specified glyph, possibly including a Lisp-level face
2856 ID, return a glyph that has a realized face ID.
2857 This is used for glyphs displayed specially and not part of the text;
2858 for instance, vertical separators, truncation markers, etc. */
2861 spec_glyph_lookup_face (w
, glyph
)
2865 int lface_id
= GLYPH_FACE (*glyph
);
2866 /* Convert the glyph's specified face to a realized (cache) face. */
2869 int face_id
= merge_faces (XFRAME (w
->frame
),
2870 Qt
, lface_id
, DEFAULT_FACE_ID
);
2871 SET_GLYPH_FACE (*glyph
, face_id
);
2875 /* Add spaces to a glyph row ROW in a window matrix.
2877 Each row has the form:
2879 +---------+-----------------------------+------------+
2880 | left | text | right |
2881 +---------+-----------------------------+------------+
2883 Left and right marginal areas are optional. This function adds
2884 spaces to areas so that there are no empty holes between areas.
2885 In other words: If the right area is not empty, the text area
2886 is filled up with spaces up to the right area. If the text area
2887 is not empty, the left area is filled up.
2889 To be called for frame-based redisplay, only. */
2892 fill_up_glyph_row_with_spaces (row
)
2893 struct glyph_row
*row
;
2895 fill_up_glyph_row_area_with_spaces (row
, LEFT_MARGIN_AREA
);
2896 fill_up_glyph_row_area_with_spaces (row
, TEXT_AREA
);
2897 fill_up_glyph_row_area_with_spaces (row
, RIGHT_MARGIN_AREA
);
2901 /* Fill area AREA of glyph row ROW with spaces. To be called for
2902 frame-based redisplay only. */
2905 fill_up_glyph_row_area_with_spaces (row
, area
)
2906 struct glyph_row
*row
;
2909 if (row
->glyphs
[area
] < row
->glyphs
[area
+ 1])
2911 struct glyph
*end
= row
->glyphs
[area
+ 1];
2912 struct glyph
*text
= row
->glyphs
[area
] + row
->used
[area
];
2915 *text
++ = space_glyph
;
2916 row
->used
[area
] = text
- row
->glyphs
[area
];
2921 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2922 reached. In frame matrices only one area, TEXT_AREA, is used. */
2925 fill_up_frame_row_with_spaces (row
, upto
)
2926 struct glyph_row
*row
;
2929 int i
= row
->used
[TEXT_AREA
];
2930 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
2933 glyph
[i
++] = space_glyph
;
2935 row
->used
[TEXT_AREA
] = i
;
2940 /**********************************************************************
2941 Mirroring operations on frame matrices in window matrices
2942 **********************************************************************/
2944 /* Set frame being updated via frame-based redisplay to F. This
2945 function must be called before updates to make explicit that we are
2946 working on frame matrices or not. */
2949 set_frame_matrix_frame (f
)
2952 frame_matrix_frame
= f
;
2956 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2957 DESIRED_MATRIX is the desired matrix corresponding to
2958 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2959 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2960 frame_matrix_frame is non-null, this indicates that the exchange is
2961 done in frame matrices, and that we have to perform analogous
2962 operations in window matrices of frame_matrix_frame. */
2965 make_current (desired_matrix
, current_matrix
, row
)
2966 struct glyph_matrix
*desired_matrix
, *current_matrix
;
2969 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, row
);
2970 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, row
);
2971 int mouse_face_p
= current_row
->mouse_face_p
;
2973 /* Do current_row = desired_row. This exchanges glyph pointers
2974 between both rows, and does a structure assignment otherwise. */
2975 assign_row (current_row
, desired_row
);
2977 /* Enable current_row to mark it as valid. */
2978 current_row
->enabled_p
= 1;
2979 current_row
->mouse_face_p
= mouse_face_p
;
2981 /* If we are called on frame matrices, perform analogous operations
2982 for window matrices. */
2983 if (frame_matrix_frame
)
2984 mirror_make_current (XWINDOW (frame_matrix_frame
->root_window
), row
);
2988 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2989 W's frame which has been made current (by swapping pointers between
2990 current and desired matrix). Perform analogous operations in the
2991 matrices of leaf windows in the window tree rooted at W. */
2994 mirror_make_current (w
, frame_row
)
3000 if (!NILP (w
->hchild
))
3001 mirror_make_current (XWINDOW (w
->hchild
), frame_row
);
3002 else if (!NILP (w
->vchild
))
3003 mirror_make_current (XWINDOW (w
->vchild
), frame_row
);
3006 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
3007 here because the checks performed in debug mode there
3008 will not allow the conversion. */
3009 int row
= frame_row
- w
->desired_matrix
->matrix_y
;
3011 /* If FRAME_ROW is within W, assign the desired row to the
3012 current row (exchanging glyph pointers). */
3013 if (row
>= 0 && row
< w
->desired_matrix
->matrix_h
)
3015 struct glyph_row
*current_row
3016 = MATRIX_ROW (w
->current_matrix
, row
);
3017 struct glyph_row
*desired_row
3018 = MATRIX_ROW (w
->desired_matrix
, row
);
3020 if (desired_row
->enabled_p
)
3021 assign_row (current_row
, desired_row
);
3023 swap_glyph_pointers (desired_row
, current_row
);
3024 current_row
->enabled_p
= 1;
3028 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3033 /* Perform row dance after scrolling. We are working on the range of
3034 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
3035 including) in MATRIX. COPY_FROM is a vector containing, for each
3036 row I in the range 0 <= I < NLINES, the index of the original line
3037 to move to I. This index is relative to the row range, i.e. 0 <=
3038 index < NLINES. RETAINED_P is a vector containing zero for each
3039 row 0 <= I < NLINES which is empty.
3041 This function is called from do_scrolling and do_direct_scrolling. */
3044 mirrored_line_dance (matrix
, unchanged_at_top
, nlines
, copy_from
,
3046 struct glyph_matrix
*matrix
;
3047 int unchanged_at_top
, nlines
;
3051 /* A copy of original rows. */
3052 struct glyph_row
*old_rows
;
3054 /* Rows to assign to. */
3055 struct glyph_row
*new_rows
= MATRIX_ROW (matrix
, unchanged_at_top
);
3059 /* Make a copy of the original rows. */
3060 old_rows
= (struct glyph_row
*) alloca (nlines
* sizeof *old_rows
);
3061 bcopy (new_rows
, old_rows
, nlines
* sizeof *old_rows
);
3063 /* Assign new rows, maybe clear lines. */
3064 for (i
= 0; i
< nlines
; ++i
)
3066 int enabled_before_p
= new_rows
[i
].enabled_p
;
3068 xassert (i
+ unchanged_at_top
< matrix
->nrows
);
3069 xassert (unchanged_at_top
+ copy_from
[i
] < matrix
->nrows
);
3070 new_rows
[i
] = old_rows
[copy_from
[i
]];
3071 new_rows
[i
].enabled_p
= enabled_before_p
;
3073 /* RETAINED_P is zero for empty lines. */
3074 if (!retained_p
[copy_from
[i
]])
3075 new_rows
[i
].enabled_p
= 0;
3078 /* Do the same for window matrices, if MATRIX is a frame matrix. */
3079 if (frame_matrix_frame
)
3080 mirror_line_dance (XWINDOW (frame_matrix_frame
->root_window
),
3081 unchanged_at_top
, nlines
, copy_from
, retained_p
);
3085 /* Synchronize glyph pointers in the current matrix of window W with
3086 the current frame matrix. */
3089 sync_window_with_frame_matrix_rows (w
)
3092 struct frame
*f
= XFRAME (w
->frame
);
3093 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
3094 int left
, right
, x
, width
;
3096 /* Preconditions: W must be a leaf window on a tty frame. */
3097 xassert (NILP (w
->hchild
) && NILP (w
->vchild
));
3098 xassert (!FRAME_WINDOW_P (f
));
3100 left
= margin_glyphs_to_reserve (w
, 1, w
->left_margin_cols
);
3101 right
= margin_glyphs_to_reserve (w
, 1, w
->right_margin_cols
);
3102 x
= w
->current_matrix
->matrix_x
;
3103 width
= w
->current_matrix
->matrix_w
;
3105 window_row
= w
->current_matrix
->rows
;
3106 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
3107 frame_row
= f
->current_matrix
->rows
+ WINDOW_TOP_EDGE_LINE (w
);
3109 for (; window_row
< window_row_end
; ++window_row
, ++frame_row
)
3111 window_row
->glyphs
[LEFT_MARGIN_AREA
]
3112 = frame_row
->glyphs
[0] + x
;
3113 window_row
->glyphs
[TEXT_AREA
]
3114 = window_row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
3115 window_row
->glyphs
[LAST_AREA
]
3116 = window_row
->glyphs
[LEFT_MARGIN_AREA
] + width
;
3117 window_row
->glyphs
[RIGHT_MARGIN_AREA
]
3118 = window_row
->glyphs
[LAST_AREA
] - right
;
3123 /* Return the window in the window tree rooted in W containing frame
3124 row ROW. Value is null if none is found. */
3127 frame_row_to_window (w
, row
)
3131 struct window
*found
= NULL
;
3135 if (!NILP (w
->hchild
))
3136 found
= frame_row_to_window (XWINDOW (w
->hchild
), row
);
3137 else if (!NILP (w
->vchild
))
3138 found
= frame_row_to_window (XWINDOW (w
->vchild
), row
);
3139 else if (row
>= WINDOW_TOP_EDGE_LINE (w
)
3140 && row
< WINDOW_BOTTOM_EDGE_LINE (w
))
3143 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3150 /* Perform a line dance in the window tree rooted at W, after
3151 scrolling a frame matrix in mirrored_line_dance.
3153 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
3154 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
3155 COPY_FROM is a vector containing, for each row I in the range 0 <=
3156 I < NLINES, the index of the original line to move to I. This
3157 index is relative to the row range, i.e. 0 <= index < NLINES.
3158 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
3162 mirror_line_dance (w
, unchanged_at_top
, nlines
, copy_from
, retained_p
)
3164 int unchanged_at_top
, nlines
;
3170 if (!NILP (w
->hchild
))
3171 mirror_line_dance (XWINDOW (w
->hchild
), unchanged_at_top
,
3172 nlines
, copy_from
, retained_p
);
3173 else if (!NILP (w
->vchild
))
3174 mirror_line_dance (XWINDOW (w
->vchild
), unchanged_at_top
,
3175 nlines
, copy_from
, retained_p
);
3178 /* W is a leaf window, and we are working on its current
3180 struct glyph_matrix
*m
= w
->current_matrix
;
3182 struct glyph_row
*old_rows
;
3184 /* Make a copy of the original rows of matrix m. */
3185 old_rows
= (struct glyph_row
*) alloca (m
->nrows
* sizeof *old_rows
);
3186 bcopy (m
->rows
, old_rows
, m
->nrows
* sizeof *old_rows
);
3188 for (i
= 0; i
< nlines
; ++i
)
3190 /* Frame relative line assigned to. */
3191 int frame_to
= i
+ unchanged_at_top
;
3193 /* Frame relative line assigned. */
3194 int frame_from
= copy_from
[i
] + unchanged_at_top
;
3196 /* Window relative line assigned to. */
3197 int window_to
= frame_to
- m
->matrix_y
;
3199 /* Window relative line assigned. */
3200 int window_from
= frame_from
- m
->matrix_y
;
3202 /* Is assigned line inside window? */
3203 int from_inside_window_p
3204 = window_from
>= 0 && window_from
< m
->matrix_h
;
3206 /* Is assigned to line inside window? */
3207 int to_inside_window_p
3208 = window_to
>= 0 && window_to
< m
->matrix_h
;
3210 if (from_inside_window_p
&& to_inside_window_p
)
3212 /* Enabled setting before assignment. */
3213 int enabled_before_p
;
3215 /* Do the assignment. The enabled_p flag is saved
3216 over the assignment because the old redisplay did
3218 enabled_before_p
= m
->rows
[window_to
].enabled_p
;
3219 m
->rows
[window_to
] = old_rows
[window_from
];
3220 m
->rows
[window_to
].enabled_p
= enabled_before_p
;
3222 /* If frame line is empty, window line is empty, too. */
3223 if (!retained_p
[copy_from
[i
]])
3224 m
->rows
[window_to
].enabled_p
= 0;
3226 else if (to_inside_window_p
)
3228 /* A copy between windows. This is an infrequent
3229 case not worth optimizing. */
3230 struct frame
*f
= XFRAME (w
->frame
);
3231 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3233 struct glyph_matrix
*m2
;
3236 w2
= frame_row_to_window (root
, frame_from
);
3237 /* ttn@surf.glug.org: when enabling menu bar using `emacs
3238 -nw', FROM_FRAME sometimes has no associated window.
3239 This check avoids a segfault if W2 is null. */
3242 m2
= w2
->current_matrix
;
3243 m2_from
= frame_from
- m2
->matrix_y
;
3244 copy_row_except_pointers (m
->rows
+ window_to
,
3245 m2
->rows
+ m2_from
);
3247 /* If frame line is empty, window line is empty, too. */
3248 if (!retained_p
[copy_from
[i
]])
3249 m
->rows
[window_to
].enabled_p
= 0;
3253 else if (from_inside_window_p
)
3257 /* If there was a copy between windows, make sure glyph
3258 pointers are in sync with the frame matrix. */
3260 sync_window_with_frame_matrix_rows (w
);
3262 /* Check that no pointers are lost. */
3266 /* Next window on same level. */
3267 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3274 /* Check that window and frame matrices agree about their
3275 understanding where glyphs of the rows are to find. For each
3276 window in the window tree rooted at W, check that rows in the
3277 matrices of leaf window agree with their frame matrices about
3281 check_window_matrix_pointers (w
)
3286 if (!NILP (w
->hchild
))
3287 check_window_matrix_pointers (XWINDOW (w
->hchild
));
3288 else if (!NILP (w
->vchild
))
3289 check_window_matrix_pointers (XWINDOW (w
->vchild
));
3292 struct frame
*f
= XFRAME (w
->frame
);
3293 check_matrix_pointers (w
->desired_matrix
, f
->desired_matrix
);
3294 check_matrix_pointers (w
->current_matrix
, f
->current_matrix
);
3297 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3302 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
3303 a window and FRAME_MATRIX is the corresponding frame matrix. For
3304 each row in WINDOW_MATRIX check that it's a slice of the
3305 corresponding frame row. If it isn't, abort. */
3308 check_matrix_pointers (window_matrix
, frame_matrix
)
3309 struct glyph_matrix
*window_matrix
, *frame_matrix
;
3311 /* Row number in WINDOW_MATRIX. */
3314 /* Row number corresponding to I in FRAME_MATRIX. */
3315 int j
= window_matrix
->matrix_y
;
3317 /* For all rows check that the row in the window matrix is a
3318 slice of the row in the frame matrix. If it isn't we didn't
3319 mirror an operation on the frame matrix correctly. */
3320 while (i
< window_matrix
->nrows
)
3322 if (!glyph_row_slice_p (window_matrix
->rows
+ i
,
3323 frame_matrix
->rows
+ j
))
3329 #endif /* GLYPH_DEBUG != 0 */
3333 /**********************************************************************
3334 VPOS and HPOS translations
3335 **********************************************************************/
3339 /* Translate vertical position VPOS which is relative to window W to a
3340 vertical position relative to W's frame. */
3343 window_to_frame_vpos (w
, vpos
)
3347 struct frame
*f
= XFRAME (w
->frame
);
3349 xassert (!FRAME_WINDOW_P (f
));
3350 xassert (vpos
>= 0 && vpos
<= w
->desired_matrix
->nrows
);
3351 vpos
+= WINDOW_TOP_EDGE_LINE (w
);
3352 xassert (vpos
>= 0 && vpos
<= FRAME_LINES (f
));
3357 /* Translate horizontal position HPOS which is relative to window W to
3358 a horizontal position relative to W's frame. */
3361 window_to_frame_hpos (w
, hpos
)
3365 xassert (!FRAME_WINDOW_P (XFRAME (w
->frame
)));
3366 hpos
+= WINDOW_LEFT_EDGE_COL (w
);
3370 #endif /* GLYPH_DEBUG */
3374 /**********************************************************************
3376 **********************************************************************/
3378 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
3379 doc
: /* Clear frame FRAME and output again what is supposed to appear on it. */)
3385 CHECK_LIVE_FRAME (frame
);
3388 /* Ignore redraw requests, if frame has no glyphs yet.
3389 (Implementation note: It still has to be checked why we are
3390 called so early here). */
3391 if (!glyphs_initialized_initially_p
)
3396 if (FRAME_MSDOS_P (f
))
3397 set_terminal_modes (FRAME_TERMINAL (f
));
3400 clear_current_matrices (f
);
3402 if (FRAME_TERMCAP_P (f
))
3403 fflush (FRAME_TTY (f
)->output
);
3404 windows_or_buffers_changed
++;
3405 /* Mark all windows as inaccurate, so that every window will have
3406 its redisplay done. */
3407 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
3408 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
3414 /* Redraw frame F. This is nothing more than a call to the Lisp
3415 function redraw-frame. */
3422 XSETFRAME (frame
, f
);
3423 Fredraw_frame (frame
);
3427 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
3428 doc
: /* Clear and redisplay all visible frames. */)
3431 Lisp_Object tail
, frame
;
3433 FOR_EACH_FRAME (tail
, frame
)
3434 if (FRAME_VISIBLE_P (XFRAME (frame
)))
3435 Fredraw_frame (frame
);
3441 /* This is used when frame_garbaged is set. Call Fredraw_frame on all
3442 visible frames marked as garbaged. */
3445 redraw_garbaged_frames ()
3447 Lisp_Object tail
, frame
;
3449 FOR_EACH_FRAME (tail
, frame
)
3450 if (FRAME_VISIBLE_P (XFRAME (frame
))
3451 && FRAME_GARBAGED_P (XFRAME (frame
)))
3452 Fredraw_frame (frame
);
3457 /***********************************************************************
3459 ***********************************************************************/
3461 /* Try to update display and current glyph matrix directly.
3463 This function is called after a character G has been inserted into
3464 current_buffer. It tries to update the current glyph matrix and
3465 perform appropriate screen output to reflect the insertion. If it
3466 succeeds, the global flag redisplay_performed_directly_p will be
3467 set to 1, and thereby prevent the more costly general redisplay
3468 from running (see redisplay_internal).
3470 This function is not called for `hairy' character insertions.
3471 In particular, it is not called when after or before change
3472 functions exist, like they are used by font-lock. See keyboard.c
3473 for details where this function is called. */
3476 direct_output_for_insert (g
)
3479 register struct frame
*f
= SELECTED_FRAME ();
3480 struct window
*w
= XWINDOW (selected_window
);
3482 struct glyph_row
*glyph_row
;
3483 struct glyph
*glyphs
, *glyph
, *end
;
3485 /* Non-null means that redisplay of W is based on window matrices. */
3486 int window_redisplay_p
= FRAME_WINDOW_P (f
);
3487 /* Non-null means we are in overwrite mode. */
3488 int overwrite_p
= !NILP (current_buffer
->overwrite_mode
);
3490 struct text_pos pos
;
3491 int delta
, delta_bytes
;
3493 /* Not done directly. */
3494 redisplay_performed_directly_p
= 0;
3496 /* Quickly give up for some common cases. */
3497 if (cursor_in_echo_area
3498 /* Give up if fonts have changed. */
3500 /* Give up if face attributes have been changed. */
3501 || face_change_count
3502 /* Give up if cursor position not really known. */
3503 || !display_completed
3504 /* Give up if buffer appears in two places. */
3505 || buffer_shared
> 1
3506 /* Give up if currently displaying a message instead of the
3507 minibuffer contents. */
3508 || (EQ (selected_window
, minibuf_window
)
3509 && EQ (minibuf_window
, echo_area_window
))
3510 /* Give up for hscrolled mini-buffer because display of the prompt
3511 is handled specially there (see display_line). */
3512 || (MINI_WINDOW_P (w
) && XFASTINT (w
->hscroll
))
3513 /* Give up if overwriting in the middle of a line. */
3516 && FETCH_BYTE (PT
) != '\n')
3517 /* Give up for tabs and line ends. */
3521 || (g
== ' ' && !NILP (current_buffer
->word_wrap
))
3522 /* Give up if unable to display the cursor in the window. */
3523 || w
->cursor
.vpos
< 0
3524 /* Give up if we are showing a message or just cleared the message
3525 because we might need to resize the echo area window. */
3526 || !NILP (echo_area_buffer
[0])
3527 || !NILP (echo_area_buffer
[1])
3528 || (glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
),
3529 /* Can't do it in a continued line because continuation
3530 lines would change. */
3531 (glyph_row
->continued_p
3532 || glyph_row
->exact_window_width_line_p
3533 /* Can't use this method if the line overlaps others or is
3534 overlapped by others because these other lines would
3535 have to be redisplayed. */
3536 || glyph_row
->overlapping_p
3537 || glyph_row
->overlapped_p
))
3538 /* Can't do it for partial width windows on terminal frames
3539 because we can't clear to eol in such a window. */
3540 || (!window_redisplay_p
&& !WINDOW_FULL_WIDTH_P (w
)))
3543 /* If we can't insert glyphs, we can use this method only
3544 at the end of a line. */
3545 if (!FRAME_CHAR_INS_DEL_OK (f
))
3546 if (PT
!= ZV
&& FETCH_BYTE (PT_BYTE
) != '\n')
3549 /* Set up a display iterator structure for W. Glyphs will be
3550 produced in scratch_glyph_row. Current position is W's cursor
3552 clear_glyph_row (&scratch_glyph_row
);
3553 SET_TEXT_POS (pos
, PT
, PT_BYTE
);
3554 DEC_TEXT_POS (pos
, !NILP (current_buffer
->enable_multibyte_characters
));
3555 init_iterator (&it
, w
, CHARPOS (pos
), BYTEPOS (pos
), &scratch_glyph_row
,
3558 glyph_row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3559 if (glyph_row
->mouse_face_p
)
3562 /* Give up if highlighting trailing whitespace and we have trailing
3563 whitespace in glyph_row. We would have to remove the trailing
3564 whitespace face in that case. */
3565 if (!NILP (Vshow_trailing_whitespace
)
3566 && glyph_row
->used
[TEXT_AREA
])
3570 last
= glyph_row
->glyphs
[TEXT_AREA
] + glyph_row
->used
[TEXT_AREA
] - 1;
3571 if (last
->type
== STRETCH_GLYPH
3572 || (last
->type
== CHAR_GLYPH
3573 && last
->u
.ch
== ' '))
3577 /* Give up if there are overlay strings at pos. This would fail
3578 if the overlay string has newlines in it. */
3579 if (STRINGP (it
.string
))
3582 it
.hpos
= w
->cursor
.hpos
;
3583 it
.vpos
= w
->cursor
.vpos
;
3584 it
.current_x
= w
->cursor
.x
+ it
.first_visible_x
;
3585 it
.current_y
= w
->cursor
.y
;
3586 it
.end_charpos
= PT
;
3587 it
.stop_charpos
= min (PT
, it
.stop_charpos
);
3588 it
.stop_charpos
= max (IT_CHARPOS (it
), it
.stop_charpos
);
3590 /* More than one display element may be returned for PT - 1 if
3591 (i) it's a control character which is translated into `\003' or
3592 `^C', or (ii) it has a display table entry, or (iii) it's a
3593 combination of both. */
3594 delta
= delta_bytes
= 0;
3595 while (get_next_display_element (&it
))
3597 PRODUCE_GLYPHS (&it
);
3599 /* Give up if glyph doesn't fit completely on the line. */
3600 if (it
.current_x
>= it
.last_visible_x
)
3603 /* Give up if new glyph has different ascent or descent than
3604 the original row, or if it is not a character glyph. */
3605 if (glyph_row
->ascent
!= it
.ascent
3606 || glyph_row
->height
!= it
.ascent
+ it
.descent
3607 || glyph_row
->phys_ascent
!= it
.phys_ascent
3608 || glyph_row
->phys_height
!= it
.phys_ascent
+ it
.phys_descent
3609 || it
.what
!= IT_CHARACTER
)
3613 delta_bytes
+= it
.len
;
3614 set_iterator_to_next (&it
, 1);
3617 /* Give up if we hit the right edge of the window. We would have
3618 to insert truncation or continuation glyphs. */
3619 added_width
= it
.current_x
- (w
->cursor
.x
+ it
.first_visible_x
);
3620 if (glyph_row
->pixel_width
+ added_width
>= it
.last_visible_x
)
3623 /* Give up if there is a \t following in the line. */
3625 it2
.end_charpos
= ZV
;
3626 it2
.stop_charpos
= min (it2
.stop_charpos
, ZV
);
3627 while (get_next_display_element (&it2
)
3628 && !ITERATOR_AT_END_OF_LINE_P (&it2
))
3632 set_iterator_to_next (&it2
, 1);
3635 /* Number of new glyphs produced. */
3636 n
= it
.glyph_row
->used
[TEXT_AREA
];
3638 /* Start and end of glyphs in original row. */
3639 glyphs
= glyph_row
->glyphs
[TEXT_AREA
] + w
->cursor
.hpos
;
3640 end
= glyph_row
->glyphs
[1 + TEXT_AREA
];
3642 /* Make room for new glyphs, then insert them. */
3643 xassert (end
- glyphs
- n
>= 0);
3644 safe_bcopy ((char *) glyphs
, (char *) (glyphs
+ n
),
3645 (end
- glyphs
- n
) * sizeof (*end
));
3646 bcopy (it
.glyph_row
->glyphs
[TEXT_AREA
], glyphs
, n
* sizeof *glyphs
);
3647 glyph_row
->used
[TEXT_AREA
] = min (glyph_row
->used
[TEXT_AREA
] + n
,
3648 end
- glyph_row
->glyphs
[TEXT_AREA
]);
3650 /* Compute new line width. */
3651 glyph
= glyph_row
->glyphs
[TEXT_AREA
];
3652 end
= glyph
+ glyph_row
->used
[TEXT_AREA
];
3653 glyph_row
->pixel_width
= glyph_row
->x
;
3656 glyph_row
->pixel_width
+= glyph
->pixel_width
;
3660 /* Increment buffer positions for glyphs following the newly
3662 for (glyph
= glyphs
+ n
; glyph
< end
; ++glyph
)
3663 if (glyph
->charpos
> 0 && BUFFERP (glyph
->object
))
3664 glyph
->charpos
+= delta
;
3666 if (MATRIX_ROW_END_CHARPOS (glyph_row
) > 0)
3668 MATRIX_ROW_END_CHARPOS (glyph_row
) += delta
;
3669 MATRIX_ROW_END_BYTEPOS (glyph_row
) += delta_bytes
;
3672 /* Adjust positions in lines following the one we are in. */
3673 increment_matrix_positions (w
->current_matrix
,
3675 w
->current_matrix
->nrows
,
3676 delta
, delta_bytes
);
3678 glyph_row
->contains_overlapping_glyphs_p
3679 |= it
.glyph_row
->contains_overlapping_glyphs_p
;
3681 glyph_row
->displays_text_p
= 1;
3682 w
->window_end_vpos
= make_number (max (w
->cursor
.vpos
,
3683 XFASTINT (w
->window_end_vpos
)));
3685 if (!NILP (Vshow_trailing_whitespace
))
3686 highlight_trailing_whitespace (it
.f
, glyph_row
);
3688 /* Write glyphs. If at end of row, we can simply call write_glyphs.
3689 In the middle, we have to insert glyphs. Note that this is now
3690 implemented for X frames. The implementation uses updated_window
3692 updated_row
= glyph_row
;
3693 updated_area
= TEXT_AREA
;
3697 FRAME_RIF (f
)->update_window_begin_hook (w
);
3699 if (glyphs
== end
- n
3700 /* In front of a space added by append_space. */
3701 || (glyphs
== end
- n
- 1
3702 && (end
- n
)->charpos
<= 0))
3703 FRAME_RIF (f
)->write_glyphs (glyphs
, n
);
3705 FRAME_RIF (f
)->insert_glyphs (glyphs
, n
);
3709 if (glyphs
== end
- n
)
3710 write_glyphs (f
, glyphs
, n
);
3712 insert_glyphs (f
, glyphs
, n
);
3715 w
->cursor
.hpos
+= n
;
3716 w
->cursor
.x
= it
.current_x
- it
.first_visible_x
;
3717 xassert (w
->cursor
.hpos
>= 0
3718 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3720 /* How to set the cursor differs depending on whether we are
3721 using a frame matrix or a window matrix. Note that when
3722 a frame matrix is used, cursor_to expects frame coordinates,
3723 and the X and Y parameters are not used. */
3724 if (window_redisplay_p
)
3725 FRAME_RIF (f
)->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3726 w
->cursor
.y
, w
->cursor
.x
);
3730 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3731 + (INTEGERP (w
->left_margin_cols
)
3732 ? XFASTINT (w
->left_margin_cols
)
3734 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3735 cursor_to (f
, y
, x
);
3738 #ifdef HAVE_WINDOW_SYSTEM
3739 update_window_fringes (w
, 0);
3743 FRAME_RIF (f
)->update_window_end_hook (w
, 1, 0);
3746 if (FRAME_TERMCAP_P (f
))
3747 fflush (FRAME_TTY (f
)->output
);
3749 TRACE ((stderr
, "direct output for insert\n"));
3750 mark_window_display_accurate (it
.window
, 1);
3751 redisplay_performed_directly_p
= 1;
3756 /* Perform a direct display update for moving PT by N positions
3757 left or right. N < 0 means a movement backwards. This function
3758 is currently only called for N == 1 or N == -1. */
3761 direct_output_forward_char (n
)
3764 struct frame
*f
= SELECTED_FRAME ();
3765 struct window
*w
= XWINDOW (selected_window
);
3766 struct glyph_row
*row
;
3768 /* Give up if point moved out of or into a composition. */
3769 if (check_point_in_composition (current_buffer
, XINT (w
->last_point
),
3770 current_buffer
, PT
))
3773 /* Give up if face attributes have been changed. */
3774 if (face_change_count
)
3777 /* Give up if current matrix is not up to date or we are
3778 displaying a message. */
3779 if (!display_completed
|| cursor_in_echo_area
)
3782 /* Give up if the buffer's direction is reversed. */
3783 if (!NILP (XBUFFER (w
->buffer
)->direction_reversed
))
3786 /* Can't use direct output if highlighting a region. */
3787 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
3790 /* Can't use direct output if highlighting trailing whitespace. */
3791 if (!NILP (Vshow_trailing_whitespace
))
3794 /* Give up if we are showing a message or just cleared the message
3795 because we might need to resize the echo area window. */
3796 if (!NILP (echo_area_buffer
[0]) || !NILP (echo_area_buffer
[1]))
3799 /* Give up if currently displaying a message instead of the
3800 minibuffer contents. */
3801 if (XWINDOW (minibuf_window
) == w
3802 && EQ (minibuf_window
, echo_area_window
))
3805 /* Give up if we don't know where the cursor is. */
3806 if (w
->cursor
.vpos
< 0)
3809 row
= MATRIX_ROW (w
->current_matrix
, w
->cursor
.vpos
);
3811 /* Give up if PT is outside of the last known cursor row. */
3812 if (PT
<= MATRIX_ROW_START_CHARPOS (row
)
3813 || PT
>= MATRIX_ROW_END_CHARPOS (row
))
3816 set_cursor_from_row (w
, row
, w
->current_matrix
, 0, 0, 0, 0);
3818 w
->last_cursor
= w
->cursor
;
3819 XSETFASTINT (w
->last_point
, PT
);
3821 xassert (w
->cursor
.hpos
>= 0
3822 && w
->cursor
.hpos
< w
->desired_matrix
->matrix_w
);
3824 if (FRAME_WINDOW_P (f
))
3825 FRAME_RIF (f
)->cursor_to (w
->cursor
.vpos
, w
->cursor
.hpos
,
3826 w
->cursor
.y
, w
->cursor
.x
);
3830 x
= (WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
)
3831 + (INTEGERP (w
->left_margin_cols
)
3832 ? XFASTINT (w
->left_margin_cols
)
3834 y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
3835 cursor_to (f
, y
, x
);
3838 if (FRAME_TERMCAP_P (f
))
3839 fflush (FRAME_TTY (f
)->output
);
3840 redisplay_performed_directly_p
= 1;
3846 /***********************************************************************
3848 ***********************************************************************/
3850 /* Update frame F based on the data in desired matrices.
3852 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3853 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3856 Value is non-zero if redisplay was stopped due to pending input. */
3859 update_frame (f
, force_p
, inhibit_hairy_id_p
)
3862 int inhibit_hairy_id_p
;
3864 /* 1 means display has been paused because of pending input. */
3866 struct window
*root_window
= XWINDOW (f
->root_window
);
3868 if (redisplay_dont_pause
)
3870 #if PERIODIC_PREEMPTION_CHECKING
3871 else if (NILP (Vredisplay_preemption_period
))
3873 else if (!force_p
&& NUMBERP (Vredisplay_preemption_period
))
3876 double p
= XFLOATINT (Vredisplay_preemption_period
);
3879 if (detect_input_pending_ignore_squeezables ())
3886 usec
= (p
- sec
) * 1000000;
3888 EMACS_GET_TIME (tm
);
3889 EMACS_SET_SECS_USECS (preemption_period
, sec
, usec
);
3890 EMACS_ADD_TIME (preemption_next_check
, tm
, preemption_period
);
3894 if (FRAME_WINDOW_P (f
))
3896 /* We are working on window matrix basis. All windows whose
3897 flag must_be_updated_p is set have to be updated. */
3899 /* Record that we are not working on frame matrices. */
3900 set_frame_matrix_frame (NULL
);
3902 /* Update all windows in the window tree of F, maybe stopping
3903 when pending input is detected. */
3906 /* Update the menu bar on X frames that don't have toolkit
3908 if (WINDOWP (f
->menu_bar_window
))
3909 update_window (XWINDOW (f
->menu_bar_window
), 1);
3911 /* Update the tool-bar window, if present. */
3912 if (WINDOWP (f
->tool_bar_window
))
3914 struct window
*w
= XWINDOW (f
->tool_bar_window
);
3916 /* Update tool-bar window. */
3917 if (w
->must_be_updated_p
)
3921 update_window (w
, 1);
3922 w
->must_be_updated_p
= 0;
3924 /* Swap tool-bar strings. We swap because we want to
3926 tem
= f
->current_tool_bar_string
;
3927 f
->current_tool_bar_string
= f
->desired_tool_bar_string
;
3928 f
->desired_tool_bar_string
= tem
;
3933 /* Update windows. */
3934 paused_p
= update_window_tree (root_window
, force_p
);
3937 /* This flush is a performance bottleneck under X,
3938 and it doesn't seem to be necessary anyway (in general).
3939 It is necessary when resizing the window with the mouse, or
3940 at least the fringes are not redrawn in a timely manner. ++kfs */
3941 if (f
->force_flush_display_p
)
3943 FRAME_RIF (f
)->flush_display (f
);
3944 f
->force_flush_display_p
= 0;
3949 /* We are working on frame matrix basis. Set the frame on whose
3950 frame matrix we operate. */
3951 set_frame_matrix_frame (f
);
3953 /* Build F's desired matrix from window matrices. */
3954 build_frame_matrix (f
);
3956 /* Update the display */
3958 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3961 if (FRAME_TERMCAP_P (f
))
3963 if (FRAME_TTY (f
)->termscript
)
3964 fflush (FRAME_TTY (f
)->termscript
);
3965 fflush (FRAME_TTY (f
)->output
);
3968 /* Check window matrices for lost pointers. */
3970 check_window_matrix_pointers (root_window
);
3971 add_frame_display_history (f
, paused_p
);
3976 /* Reset flags indicating that a window should be updated. */
3977 set_window_update_flags (root_window
, 0);
3979 display_completed
= !paused_p
;
3985 /************************************************************************
3986 Window-based updates
3987 ************************************************************************/
3989 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3990 don't stop updating when input is pending. */
3993 update_window_tree (w
, force_p
)
3999 while (w
&& !paused_p
)
4001 if (!NILP (w
->hchild
))
4002 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
4003 else if (!NILP (w
->vchild
))
4004 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
4005 else if (w
->must_be_updated_p
)
4006 paused_p
|= update_window (w
, force_p
);
4008 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4015 /* Update window W if its flag must_be_updated_p is non-zero. If
4016 FORCE_P is non-zero, don't stop updating if input is pending. */
4019 update_single_window (w
, force_p
)
4023 if (w
->must_be_updated_p
)
4025 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4027 /* Record that this is not a frame-based redisplay. */
4028 set_frame_matrix_frame (NULL
);
4030 if (redisplay_dont_pause
)
4032 #if PERIODIC_PREEMPTION_CHECKING
4033 else if (NILP (Vredisplay_preemption_period
))
4035 else if (!force_p
&& NUMBERP (Vredisplay_preemption_period
))
4038 double p
= XFLOATINT (Vredisplay_preemption_period
);
4042 usec
= (p
- sec
) * 1000000;
4044 EMACS_GET_TIME (tm
);
4045 EMACS_SET_SECS_USECS (preemption_period
, sec
, usec
);
4046 EMACS_ADD_TIME (preemption_next_check
, tm
, preemption_period
);
4052 update_window (w
, force_p
);
4055 /* Reset flag in W. */
4056 w
->must_be_updated_p
= 0;
4060 #ifdef HAVE_WINDOW_SYSTEM
4062 /* Redraw lines from the current matrix of window W that are
4063 overlapped by other rows. YB is bottom-most y-position in W. */
4066 redraw_overlapped_rows (w
, yb
)
4071 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4073 /* If rows overlapping others have been changed, the rows being
4074 overlapped have to be redrawn. This won't draw lines that have
4075 already been drawn in update_window_line because overlapped_p in
4076 desired rows is 0, so after row assignment overlapped_p in
4077 current rows is 0. */
4078 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
4080 struct glyph_row
*row
= w
->current_matrix
->rows
+ i
;
4082 if (!row
->enabled_p
)
4084 else if (row
->mode_line_p
)
4087 if (row
->overlapped_p
)
4089 enum glyph_row_area area
;
4091 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
4094 updated_area
= area
;
4095 FRAME_RIF (f
)->cursor_to (i
, 0, row
->y
,
4096 area
== TEXT_AREA
? row
->x
: 0);
4097 if (row
->used
[area
])
4098 FRAME_RIF (f
)->write_glyphs (row
->glyphs
[area
],
4100 FRAME_RIF (f
)->clear_end_of_line (-1);
4103 row
->overlapped_p
= 0;
4106 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4112 /* Redraw lines from the current matrix of window W that overlap
4113 others. YB is bottom-most y-position in W. */
4116 redraw_overlapping_rows (w
, yb
)
4121 struct glyph_row
*row
;
4122 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
4124 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
4126 row
= w
->current_matrix
->rows
+ i
;
4128 if (!row
->enabled_p
)
4130 else if (row
->mode_line_p
)
4133 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
4135 if (row
->overlapping_p
&& i
> 0 && bottom_y
< yb
)
4139 if (MATRIX_ROW_OVERLAPS_PRED_P (row
)
4140 && !MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
)
4141 overlaps
|= OVERLAPS_PRED
;
4142 if (MATRIX_ROW_OVERLAPS_SUCC_P (row
)
4143 && !MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
)
4144 overlaps
|= OVERLAPS_SUCC
;
4148 if (row
->used
[LEFT_MARGIN_AREA
])
4149 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
, overlaps
);
4151 if (row
->used
[TEXT_AREA
])
4152 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
, overlaps
);
4154 if (row
->used
[RIGHT_MARGIN_AREA
])
4155 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
, overlaps
);
4157 /* Record in neighbour rows that ROW overwrites part of
4159 if (overlaps
& OVERLAPS_PRED
)
4160 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
4161 if (overlaps
& OVERLAPS_SUCC
)
4162 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
4171 #endif /* HAVE_WINDOW_SYSTEM */
4176 /* Check that no row in the current matrix of window W is enabled
4177 which is below what's displayed in the window. */
4180 check_current_matrix_flags (w
)
4183 int last_seen_p
= 0;
4184 int i
, yb
= window_text_bottom_y (w
);
4186 for (i
= 0; i
< w
->current_matrix
->nrows
- 1; ++i
)
4188 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
4189 if (!last_seen_p
&& MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4191 else if (last_seen_p
&& row
->enabled_p
)
4196 #endif /* GLYPH_DEBUG */
4199 /* Update display of window W. FORCE_P non-zero means that we should
4200 not stop when detecting pending input. */
4203 update_window (w
, force_p
)
4207 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4209 #if !PERIODIC_PREEMPTION_CHECKING
4210 int preempt_count
= baud_rate
/ 2400 + 1;
4212 extern int input_pending
;
4213 extern Lisp_Object do_mouse_tracking
;
4214 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
4216 /* Check that W's frame doesn't have glyph matrices. */
4217 xassert (FRAME_WINDOW_P (XFRAME (WINDOW_FRAME (w
))));
4220 /* Check pending input the first time so that we can quickly return. */
4221 #if !PERIODIC_PREEMPTION_CHECKING
4223 detect_input_pending_ignore_squeezables ();
4226 /* If forced to complete the update, or if no input is pending, do
4228 if (force_p
|| !input_pending
|| !NILP (do_mouse_tracking
))
4230 struct glyph_row
*row
, *end
;
4231 struct glyph_row
*mode_line_row
;
4232 struct glyph_row
*header_line_row
;
4233 int yb
, changed_p
= 0, mouse_face_overwritten_p
= 0, n_updated
;
4235 rif
->update_window_begin_hook (w
);
4236 yb
= window_text_bottom_y (w
);
4238 /* If window has a header line, update it before everything else.
4239 Adjust y-positions of other rows by the header line height. */
4240 row
= desired_matrix
->rows
;
4241 end
= row
+ desired_matrix
->nrows
- 1;
4243 if (row
->mode_line_p
)
4245 header_line_row
= row
;
4249 header_line_row
= NULL
;
4251 /* Update the mode line, if necessary. */
4252 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
4253 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
4255 mode_line_row
->y
= yb
;
4256 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
4258 &mouse_face_overwritten_p
);
4261 /* Find first enabled row. Optimizations in redisplay_internal
4262 may lead to an update with only one row enabled. There may
4263 be also completely empty matrices. */
4264 while (row
< end
&& !row
->enabled_p
)
4267 /* Try reusing part of the display by copying. */
4268 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
4270 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
4273 /* All rows were found to be equal. */
4279 /* We've scrolled the display. */
4285 /* Update the rest of the lines. */
4286 for (n_updated
= 0; row
< end
&& (force_p
|| !input_pending
); ++row
)
4289 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
4292 /* We'll have to play a little bit with when to
4293 detect_input_pending. If it's done too often,
4294 scrolling large windows with repeated scroll-up
4295 commands will too quickly pause redisplay. */
4296 #if PERIODIC_PREEMPTION_CHECKING
4300 EMACS_GET_TIME (tm
);
4301 EMACS_SUB_TIME (dif
, preemption_next_check
, tm
);
4302 if (EMACS_TIME_NEG_P (dif
))
4304 EMACS_ADD_TIME (preemption_next_check
, tm
, preemption_period
);
4305 if (detect_input_pending_ignore_squeezables ())
4310 if (!force_p
&& ++n_updated
% preempt_count
== 0)
4311 detect_input_pending_ignore_squeezables ();
4313 changed_p
|= update_window_line (w
, vpos
,
4314 &mouse_face_overwritten_p
);
4316 /* Mark all rows below the last visible one in the current
4317 matrix as invalid. This is necessary because of
4318 variable line heights. Consider the case of three
4319 successive redisplays, where the first displays 5
4320 lines, the second 3 lines, and the third 5 lines again.
4321 If the second redisplay wouldn't mark rows in the
4322 current matrix invalid, the third redisplay might be
4323 tempted to optimize redisplay based on lines displayed
4324 in the first redisplay. */
4325 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
4326 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
4327 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
4330 /* Was display preempted? */
4331 paused_p
= row
< end
;
4335 /* Update the header line after scrolling because a new header
4336 line would otherwise overwrite lines at the top of the window
4337 that can be scrolled. */
4338 if (header_line_row
&& header_line_row
->enabled_p
)
4340 header_line_row
->y
= 0;
4341 update_window_line (w
, 0, &mouse_face_overwritten_p
);
4344 /* Fix the appearance of overlapping/overlapped rows. */
4345 if (!paused_p
&& !w
->pseudo_window_p
)
4347 #ifdef HAVE_WINDOW_SYSTEM
4348 if (changed_p
&& rif
->fix_overlapping_area
)
4350 redraw_overlapped_rows (w
, yb
);
4351 redraw_overlapping_rows (w
, yb
);
4355 /* Make cursor visible at cursor position of W. */
4356 set_window_cursor_after_update (w
);
4358 #if 0 /* Check that current matrix invariants are satisfied. This is
4359 for debugging only. See the comment of check_matrix_invariants. */
4360 IF_DEBUG (check_matrix_invariants (w
));
4365 /* Remember the redisplay method used to display the matrix. */
4366 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
4369 #ifdef HAVE_WINDOW_SYSTEM
4370 update_window_fringes (w
, 0);
4373 /* End the update of window W. Don't set the cursor if we
4374 paused updating the display because in this case,
4375 set_window_cursor_after_update hasn't been called, and
4376 output_cursor doesn't contain the cursor location. */
4377 rif
->update_window_end_hook (w
, !paused_p
, mouse_face_overwritten_p
);
4383 /* check_current_matrix_flags (w); */
4384 add_window_display_history (w
, w
->current_matrix
->method
, paused_p
);
4387 clear_glyph_matrix (desired_matrix
);
4393 /* Update the display of area AREA in window W, row number VPOS.
4394 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
4397 update_marginal_area (w
, area
, vpos
)
4401 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
4402 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
4404 /* Let functions in xterm.c know what area subsequent X positions
4405 will be relative to. */
4406 updated_area
= area
;
4408 /* Set cursor to start of glyphs, write them, and clear to the end
4409 of the area. I don't think that something more sophisticated is
4410 necessary here, since marginal areas will not be the default. */
4411 rif
->cursor_to (vpos
, 0, desired_row
->y
, 0);
4412 if (desired_row
->used
[area
])
4413 rif
->write_glyphs (desired_row
->glyphs
[area
], desired_row
->used
[area
]);
4414 rif
->clear_end_of_line (-1);
4418 /* Update the display of the text area of row VPOS in window W.
4419 Value is non-zero if display has changed. */
4422 update_text_area (w
, vpos
)
4426 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
4427 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
4428 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
4431 /* Let functions in xterm.c know what area subsequent X positions
4432 will be relative to. */
4433 updated_area
= TEXT_AREA
;
4435 /* If rows are at different X or Y, or rows have different height,
4436 or the current row is marked invalid, write the entire line. */
4437 if (!current_row
->enabled_p
4438 || desired_row
->y
!= current_row
->y
4439 || desired_row
->ascent
!= current_row
->ascent
4440 || desired_row
->phys_ascent
!= current_row
->phys_ascent
4441 || desired_row
->phys_height
!= current_row
->phys_height
4442 || desired_row
->visible_height
!= current_row
->visible_height
4443 || current_row
->overlapped_p
4444 /* This next line is necessary for correctly redrawing
4445 mouse-face areas after scrolling and other operations.
4446 However, it causes excessive flickering when mouse is moved
4447 across the mode line. Luckily, turning it off for the mode
4448 line doesn't seem to hurt anything. -- cyd.
4449 But it is still needed for the header line. -- kfs. */
4450 || (current_row
->mouse_face_p
4451 && !(current_row
->mode_line_p
&& vpos
> 0))
4452 || current_row
->x
!= desired_row
->x
)
4454 rif
->cursor_to (vpos
, 0, desired_row
->y
, desired_row
->x
);
4456 if (desired_row
->used
[TEXT_AREA
])
4457 rif
->write_glyphs (desired_row
->glyphs
[TEXT_AREA
],
4458 desired_row
->used
[TEXT_AREA
]);
4460 /* Clear to end of window. */
4461 rif
->clear_end_of_line (-1);
4464 /* This erases the cursor. We do this here because
4465 notice_overwritten_cursor cannot easily check this, which
4466 might indicate that the whole functionality of
4467 notice_overwritten_cursor would better be implemented here.
4468 On the other hand, we need notice_overwritten_cursor as long
4469 as mouse highlighting is done asynchronously outside of
4471 if (vpos
== w
->phys_cursor
.vpos
)
4472 w
->phys_cursor_on_p
= 0;
4477 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
4478 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
4479 int overlapping_glyphs_p
= current_row
->contains_overlapping_glyphs_p
;
4480 int desired_stop_pos
= desired_row
->used
[TEXT_AREA
];
4482 /* If the desired row extends its face to the text area end, and
4483 unless the current row also does so at the same position,
4484 make sure we write at least one glyph, so that the face
4485 extension actually takes place. */
4486 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
)
4487 && (desired_stop_pos
< current_row
->used
[TEXT_AREA
]
4488 || (desired_stop_pos
== current_row
->used
[TEXT_AREA
]
4489 && !MATRIX_ROW_EXTENDS_FACE_P (current_row
))))
4492 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
4496 /* Loop over glyphs that current and desired row may have
4502 /* Skip over glyphs that both rows have in common. These
4503 don't have to be written. We can't skip if the last
4504 current glyph overlaps the glyph to its right. For
4505 example, consider a current row of `if ' with the `f' in
4506 Courier bold so that it overlaps the ` ' to its right.
4507 If the desired row is ` ', we would skip over the space
4508 after the `if' and there would remain a pixel from the
4509 `f' on the screen. */
4510 if (overlapping_glyphs_p
&& i
> 0)
4512 struct glyph
*glyph
= ¤t_row
->glyphs
[TEXT_AREA
][i
- 1];
4515 rif
->get_glyph_overhangs (glyph
, XFRAME (w
->frame
),
4517 can_skip_p
= right
== 0;
4523 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
4525 x
+= desired_glyph
->pixel_width
;
4526 ++desired_glyph
, ++current_glyph
, ++i
;
4529 /* Consider the case that the current row contains "xxx
4530 ppp ggg" in italic Courier font, and the desired row
4531 is "xxx ggg". The character `p' has lbearing, `g'
4532 has not. The loop above will stop in front of the
4533 first `p' in the current row. If we would start
4534 writing glyphs there, we wouldn't erase the lbearing
4535 of the `p'. The rest of the lbearing problem is then
4536 taken care of by draw_glyphs. */
4537 if (overlapping_glyphs_p
4539 && i
< current_row
->used
[TEXT_AREA
]
4540 && (current_row
->used
[TEXT_AREA
]
4541 != desired_row
->used
[TEXT_AREA
]))
4545 rif
->get_glyph_overhangs (current_glyph
, XFRAME (w
->frame
),
4547 while (left
> 0 && i
> 0)
4549 --i
, --desired_glyph
, --current_glyph
;
4550 x
-= desired_glyph
->pixel_width
;
4551 left
-= desired_glyph
->pixel_width
;
4556 /* Try to avoid writing the entire rest of the desired row
4557 by looking for a resync point. This mainly prevents
4558 mode line flickering in the case the mode line is in
4559 fixed-pitch font, which it usually will be. */
4560 if (i
< desired_row
->used
[TEXT_AREA
])
4562 int start_x
= x
, start_hpos
= i
;
4563 struct glyph
*start
= desired_glyph
;
4565 int skip_first_p
= !can_skip_p
;
4567 /* Find the next glyph that's equal again. */
4570 || !GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
4573 x
+= desired_glyph
->pixel_width
;
4574 current_x
+= current_glyph
->pixel_width
;
4575 ++desired_glyph
, ++current_glyph
, ++i
;
4579 if (i
== start_hpos
|| x
!= current_x
)
4583 desired_glyph
= start
;
4587 rif
->cursor_to (vpos
, start_hpos
, desired_row
->y
, start_x
);
4588 rif
->write_glyphs (start
, i
- start_hpos
);
4593 /* Write the rest. */
4594 if (i
< desired_row
->used
[TEXT_AREA
])
4596 rif
->cursor_to (vpos
, i
, desired_row
->y
, x
);
4597 rif
->write_glyphs (desired_glyph
, desired_row
->used
[TEXT_AREA
] - i
);
4601 /* Maybe clear to end of line. */
4602 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
4604 /* If new row extends to the end of the text area, nothing
4605 has to be cleared, if and only if we did a write_glyphs
4606 above. This is made sure by setting desired_stop_pos
4607 appropriately above. */
4608 xassert (i
< desired_row
->used
[TEXT_AREA
]
4609 || ((desired_row
->used
[TEXT_AREA
]
4610 == current_row
->used
[TEXT_AREA
])
4611 && MATRIX_ROW_EXTENDS_FACE_P (current_row
)));
4613 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
4615 /* If old row extends to the end of the text area, clear. */
4616 if (i
>= desired_row
->used
[TEXT_AREA
])
4617 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4618 desired_row
->pixel_width
);
4619 rif
->clear_end_of_line (-1);
4622 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
4624 /* Otherwise clear to the end of the old row. Everything
4625 after that position should be clear already. */
4628 if (i
>= desired_row
->used
[TEXT_AREA
])
4629 rif
->cursor_to (vpos
, i
, desired_row
->y
,
4630 desired_row
->pixel_width
);
4632 /* If cursor is displayed at the end of the line, make sure
4633 it's cleared. Nowadays we don't have a phys_cursor_glyph
4634 with which to erase the cursor (because this method
4635 doesn't work with lbearing/rbearing), so we must do it
4637 if (vpos
== w
->phys_cursor
.vpos
4638 && w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])
4640 w
->phys_cursor_on_p
= 0;
4644 x
= current_row
->pixel_width
;
4645 rif
->clear_end_of_line (x
);
4654 /* Update row VPOS in window W. Value is non-zero if display has been
4658 update_window_line (w
, vpos
, mouse_face_overwritten_p
)
4660 int vpos
, *mouse_face_overwritten_p
;
4662 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
4663 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
4664 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
4667 /* Set the row being updated. This is important to let xterm.c
4668 know what line height values are in effect. */
4669 updated_row
= desired_row
;
4671 /* A row can be completely invisible in case a desired matrix was
4672 built with a vscroll and then make_cursor_line_fully_visible shifts
4673 the matrix. Make sure to make such rows current anyway, since
4674 we need the correct y-position, for example, in the current matrix. */
4675 if (desired_row
->mode_line_p
4676 || desired_row
->visible_height
> 0)
4678 xassert (desired_row
->enabled_p
);
4680 /* Update display of the left margin area, if there is one. */
4681 if (!desired_row
->full_width_p
4682 && !NILP (w
->left_margin_cols
))
4685 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
4688 /* Update the display of the text area. */
4689 if (update_text_area (w
, vpos
))
4692 if (current_row
->mouse_face_p
)
4693 *mouse_face_overwritten_p
= 1;
4696 /* Update display of the right margin area, if there is one. */
4697 if (!desired_row
->full_width_p
4698 && !NILP (w
->right_margin_cols
))
4701 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
4704 /* Draw truncation marks etc. */
4705 if (!current_row
->enabled_p
4706 || desired_row
->y
!= current_row
->y
4707 || desired_row
->visible_height
!= current_row
->visible_height
4708 || desired_row
->cursor_in_fringe_p
!= current_row
->cursor_in_fringe_p
4709 || desired_row
->overlay_arrow_bitmap
!= current_row
->overlay_arrow_bitmap
4710 || current_row
->redraw_fringe_bitmaps_p
4711 || desired_row
->mode_line_p
!= current_row
->mode_line_p
4712 || desired_row
->exact_window_width_line_p
!= current_row
->exact_window_width_line_p
4713 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
4714 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
4715 rif
->after_update_window_line_hook (desired_row
);
4718 /* Update current_row from desired_row. */
4719 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4725 /* Set the cursor after an update of window W. This function may only
4726 be called from update_window. */
4729 set_window_cursor_after_update (w
)
4732 struct frame
*f
= XFRAME (w
->frame
);
4733 struct redisplay_interface
*rif
= FRAME_RIF (f
);
4734 int cx
, cy
, vpos
, hpos
;
4736 /* Not intended for frame matrix updates. */
4737 xassert (FRAME_WINDOW_P (f
));
4739 if (cursor_in_echo_area
4740 && !NILP (echo_area_buffer
[0])
4741 /* If we are showing a message instead of the mini-buffer,
4742 show the cursor for the message instead. */
4743 && XWINDOW (minibuf_window
) == w
4744 && EQ (minibuf_window
, echo_area_window
)
4745 /* These cases apply only to the frame that contains
4746 the active mini-buffer window. */
4747 && FRAME_HAS_MINIBUF_P (f
)
4748 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4750 cx
= cy
= vpos
= hpos
= 0;
4752 if (cursor_in_echo_area
>= 0)
4754 /* If the mini-buffer is several lines high, find the last
4755 line that has any text on it. Note: either all lines
4756 are enabled or none. Otherwise we wouldn't be able to
4758 struct glyph_row
*row
, *last_row
;
4759 struct glyph
*glyph
;
4760 int yb
= window_text_bottom_y (w
);
4763 row
= w
->current_matrix
->rows
;
4764 while (row
->enabled_p
4765 && (last_row
== NULL
4766 || MATRIX_ROW_BOTTOM_Y (row
) <= yb
))
4768 if (row
->used
[TEXT_AREA
]
4769 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4776 struct glyph
*start
= last_row
->glyphs
[TEXT_AREA
];
4777 struct glyph
*last
= start
+ last_row
->used
[TEXT_AREA
] - 1;
4779 while (last
> start
&& last
->charpos
< 0)
4782 for (glyph
= start
; glyph
< last
; ++glyph
)
4784 cx
+= glyph
->pixel_width
;
4789 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4797 hpos
= w
->cursor
.hpos
;
4798 vpos
= w
->cursor
.vpos
;
4801 /* Window cursor can be out of sync for horizontally split windows. */
4802 hpos
= max (0, hpos
);
4803 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4804 vpos
= max (0, vpos
);
4805 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4806 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4810 /* Set WINDOW->must_be_updated_p to ON_P for all windows in the window
4811 tree rooted at W. */
4814 set_window_update_flags (w
, on_p
)
4820 if (!NILP (w
->hchild
))
4821 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4822 else if (!NILP (w
->vchild
))
4823 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4825 w
->must_be_updated_p
= on_p
;
4827 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4833 /***********************************************************************
4834 Window-Based Scrolling
4835 ***********************************************************************/
4837 /* Structure describing rows in scrolling_window. */
4841 /* Number of occurrences of this row in desired and current matrix. */
4842 int old_uses
, new_uses
;
4844 /* Vpos of row in new matrix. */
4845 int new_line_number
;
4847 /* Bucket index of this row_entry in the hash table row_table. */
4850 /* The row described by this entry. */
4851 struct glyph_row
*row
;
4853 /* Hash collision chain. */
4854 struct row_entry
*next
;
4857 /* A pool to allocate row_entry structures from, and the size of the
4858 pool. The pool is reallocated in scrolling_window when we find
4859 that we need a larger one. */
4861 static struct row_entry
*row_entry_pool
;
4862 static int row_entry_pool_size
;
4864 /* Index of next free entry in row_entry_pool. */
4866 static int row_entry_idx
;
4868 /* The hash table used during scrolling, and the table's size. This
4869 table is used to quickly identify equal rows in the desired and
4872 static struct row_entry
**row_table
;
4873 static int row_table_size
;
4875 /* Vectors of pointers to row_entry structures belonging to the
4876 current and desired matrix, and the size of the vectors. */
4878 static struct row_entry
**old_lines
, **new_lines
;
4879 static int old_lines_size
, new_lines_size
;
4881 /* A pool to allocate run structures from, and its size. */
4883 static struct run
*run_pool
;
4884 static int runs_size
;
4886 /* A vector of runs of lines found during scrolling. */
4888 static struct run
**runs
;
4890 /* Add glyph row ROW to the scrolling hash table during the scrolling
4893 static INLINE
struct row_entry
*
4894 add_row_entry (w
, row
)
4896 struct glyph_row
*row
;
4898 struct row_entry
*entry
;
4899 int i
= row
->hash
% row_table_size
;
4901 entry
= row_table
[i
];
4902 while (entry
&& !row_equal_p (w
, entry
->row
, row
, 1))
4903 entry
= entry
->next
;
4907 entry
= row_entry_pool
+ row_entry_idx
++;
4909 entry
->old_uses
= entry
->new_uses
= 0;
4910 entry
->new_line_number
= 0;
4912 entry
->next
= row_table
[i
];
4913 row_table
[i
] = entry
;
4920 /* Try to reuse part of the current display of W by scrolling lines.
4921 HEADER_LINE_P non-zero means W has a header line.
4923 The algorithm is taken from Communications of the ACM, Apr78 "A
4924 Technique for Isolating Differences Between Files." It should take
4927 A short outline of the steps of the algorithm
4929 1. Skip lines equal at the start and end of both matrices.
4931 2. Enter rows in the current and desired matrix into a symbol
4932 table, counting how often they appear in both matrices.
4934 3. Rows that appear exactly once in both matrices serve as anchors,
4935 i.e. we assume that such lines are likely to have been moved.
4937 4. Starting from anchor lines, extend regions to be scrolled both
4938 forward and backward.
4942 -1 if all rows were found to be equal.
4943 0 to indicate that we did not scroll the display, or
4944 1 if we did scroll. */
4947 scrolling_window (w
, header_line_p
)
4951 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4952 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4953 int yb
= window_text_bottom_y (w
);
4954 int i
, j
, first_old
, first_new
, last_old
, last_new
;
4955 int nruns
, nbytes
, n
, run_idx
;
4956 struct row_entry
*entry
;
4957 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
4959 /* Skip over rows equal at the start. */
4960 for (i
= header_line_p
? 1 : 0; i
< current_matrix
->nrows
- 1; ++i
)
4962 struct glyph_row
*d
= MATRIX_ROW (desired_matrix
, i
);
4963 struct glyph_row
*c
= MATRIX_ROW (current_matrix
, i
);
4967 && !d
->redraw_fringe_bitmaps_p
4969 && MATRIX_ROW_BOTTOM_Y (c
) <= yb
4970 && MATRIX_ROW_BOTTOM_Y (d
) <= yb
4971 && row_equal_p (w
, c
, d
, 1))
4980 /* Give up if some rows in the desired matrix are not enabled. */
4981 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4984 first_old
= first_new
= i
;
4986 /* Set last_new to the index + 1 of the last enabled row in the
4989 while (i
< desired_matrix
->nrows
- 1
4990 && MATRIX_ROW (desired_matrix
, i
)->enabled_p
4991 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
)) <= yb
)
4994 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4999 /* Set last_old to the index + 1 of the last enabled row in the
5000 current matrix. We don't look at the enabled flag here because
5001 we plan to reuse part of the display even if other parts are
5004 while (i
< current_matrix
->nrows
- 1)
5006 int bottom
= MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
));
5015 /* Skip over rows equal at the bottom. */
5018 while (i
- 1 > first_new
5019 && j
- 1 > first_old
5020 && MATRIX_ROW (current_matrix
, i
- 1)->enabled_p
5021 && (MATRIX_ROW (current_matrix
, i
- 1)->y
5022 == MATRIX_ROW (desired_matrix
, j
- 1)->y
)
5023 && !MATRIX_ROW (desired_matrix
, j
- 1)->redraw_fringe_bitmaps_p
5025 MATRIX_ROW (desired_matrix
, i
- 1),
5026 MATRIX_ROW (current_matrix
, j
- 1), 1))
5031 /* Nothing to do if all rows are equal. */
5032 if (last_new
== first_new
)
5035 /* Reallocate vectors, tables etc. if necessary. */
5037 if (current_matrix
->nrows
> old_lines_size
)
5039 old_lines_size
= current_matrix
->nrows
;
5040 nbytes
= old_lines_size
* sizeof *old_lines
;
5041 old_lines
= (struct row_entry
**) xrealloc (old_lines
, nbytes
);
5044 if (desired_matrix
->nrows
> new_lines_size
)
5046 new_lines_size
= desired_matrix
->nrows
;
5047 nbytes
= new_lines_size
* sizeof *new_lines
;
5048 new_lines
= (struct row_entry
**) xrealloc (new_lines
, nbytes
);
5051 n
= desired_matrix
->nrows
+ current_matrix
->nrows
;
5052 if (3 * n
> row_table_size
)
5054 row_table_size
= next_almost_prime (3 * n
);
5055 nbytes
= row_table_size
* sizeof *row_table
;
5056 row_table
= (struct row_entry
**) xrealloc (row_table
, nbytes
);
5057 bzero (row_table
, nbytes
);
5060 if (n
> row_entry_pool_size
)
5062 row_entry_pool_size
= n
;
5063 nbytes
= row_entry_pool_size
* sizeof *row_entry_pool
;
5064 row_entry_pool
= (struct row_entry
*) xrealloc (row_entry_pool
, nbytes
);
5067 if (desired_matrix
->nrows
> runs_size
)
5069 runs_size
= desired_matrix
->nrows
;
5070 nbytes
= runs_size
* sizeof *runs
;
5071 runs
= (struct run
**) xrealloc (runs
, nbytes
);
5072 nbytes
= runs_size
* sizeof *run_pool
;
5073 run_pool
= (struct run
*) xrealloc (run_pool
, nbytes
);
5076 nruns
= run_idx
= 0;
5079 /* Add rows from the current and desired matrix to the hash table
5080 row_hash_table to be able to find equal ones quickly. */
5082 for (i
= first_old
; i
< last_old
; ++i
)
5084 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
5086 entry
= add_row_entry (w
, MATRIX_ROW (current_matrix
, i
));
5087 old_lines
[i
] = entry
;
5091 old_lines
[i
] = NULL
;
5094 for (i
= first_new
; i
< last_new
; ++i
)
5096 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
5097 entry
= add_row_entry (w
, MATRIX_ROW (desired_matrix
, i
));
5099 entry
->new_line_number
= i
;
5100 new_lines
[i
] = entry
;
5103 /* Identify moves based on lines that are unique and equal
5104 in both matrices. */
5105 for (i
= first_old
; i
< last_old
;)
5107 && old_lines
[i
]->old_uses
== 1
5108 && old_lines
[i
]->new_uses
== 1)
5111 int new_line
= old_lines
[i
]->new_line_number
;
5112 struct run
*run
= run_pool
+ run_idx
++;
5115 run
->current_vpos
= i
;
5116 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
5117 run
->desired_vpos
= new_line
;
5118 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
5120 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
5122 /* Extend backward. */
5125 while (j
> first_old
5127 && old_lines
[j
] == new_lines
[k
])
5129 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
5130 --run
->current_vpos
;
5131 --run
->desired_vpos
;
5134 run
->desired_y
-= h
;
5135 run
->current_y
-= h
;
5139 /* Extend forward. */
5144 && old_lines
[j
] == new_lines
[k
])
5146 int h
= MATRIX_ROW (current_matrix
, j
)->height
;
5152 /* Insert run into list of all runs. Order runs by copied
5153 pixel lines. Note that we record runs that don't have to
5154 be copied because they are already in place. This is done
5155 because we can avoid calling update_window_line in this
5157 for (j
= 0; j
< nruns
&& runs
[j
]->height
> run
->height
; ++j
)
5159 for (k
= nruns
; k
> j
; --k
)
5160 runs
[k
] = runs
[k
- 1];
5169 /* Do the moves. Do it in a way that we don't overwrite something
5170 we want to copy later on. This is not solvable in general
5171 because there is only one display and we don't have a way to
5172 exchange areas on this display. Example:
5174 +-----------+ +-----------+
5176 +-----------+ --> +-----------+
5178 +-----------+ +-----------+
5180 Instead, prefer bigger moves, and invalidate moves that would
5181 copy from where we copied to. */
5183 for (i
= 0; i
< nruns
; ++i
)
5184 if (runs
[i
]->nrows
> 0)
5186 struct run
*r
= runs
[i
];
5188 /* Copy on the display. */
5189 if (r
->current_y
!= r
->desired_y
)
5191 rif
->scroll_run_hook (w
, r
);
5193 /* Invalidate runs that copy from where we copied to. */
5194 for (j
= i
+ 1; j
< nruns
; ++j
)
5196 struct run
*p
= runs
[j
];
5198 if ((p
->current_y
>= r
->desired_y
5199 && p
->current_y
< r
->desired_y
+ r
->height
)
5200 || (p
->current_y
+ p
->height
>= r
->desired_y
5201 && (p
->current_y
+ p
->height
5202 < r
->desired_y
+ r
->height
)))
5207 /* Assign matrix rows. */
5208 for (j
= 0; j
< r
->nrows
; ++j
)
5210 struct glyph_row
*from
, *to
;
5211 int to_overlapped_p
;
5213 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
5214 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
5215 to_overlapped_p
= to
->overlapped_p
;
5216 if (!from
->mode_line_p
&& !w
->pseudo_window_p
5217 && (to
->left_fringe_bitmap
!= from
->left_fringe_bitmap
5218 || to
->right_fringe_bitmap
!= from
->right_fringe_bitmap
5219 || to
->left_fringe_face_id
!= from
->left_fringe_face_id
5220 || to
->right_fringe_face_id
!= from
->right_fringe_face_id
5221 || to
->overlay_arrow_bitmap
!= from
->overlay_arrow_bitmap
))
5222 from
->redraw_fringe_bitmaps_p
= 1;
5223 assign_row (to
, from
);
5224 to
->enabled_p
= 1, from
->enabled_p
= 0;
5225 to
->overlapped_p
= to_overlapped_p
;
5229 /* Clear the hash table, for the next time. */
5230 for (i
= 0; i
< row_entry_idx
; ++i
)
5231 row_table
[row_entry_pool
[i
].bucket
] = NULL
;
5233 /* Value is > 0 to indicate that we scrolled the display. */
5239 /************************************************************************
5241 ************************************************************************/
5243 /* Update the desired frame matrix of frame F.
5245 FORCE_P non-zero means that the update should not be stopped by
5246 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
5247 should not be tried.
5249 Value is non-zero if update was stopped due to pending input. */
5252 update_frame_1 (f
, force_p
, inhibit_id_p
)
5257 /* Frame matrices to work on. */
5258 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
5259 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
5262 int preempt_count
= baud_rate
/ 2400 + 1;
5263 extern int input_pending
;
5265 xassert (current_matrix
&& desired_matrix
);
5267 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
5268 calculate_costs (f
);
5270 if (preempt_count
<= 0)
5273 #if !PERIODIC_PREEMPTION_CHECKING
5274 if (!force_p
&& detect_input_pending_ignore_squeezables ())
5281 /* If we cannot insert/delete lines, it's no use trying it. */
5282 if (!FRAME_LINE_INS_DEL_OK (f
))
5285 /* See if any of the desired lines are enabled; don't compute for
5286 i/d line if just want cursor motion. */
5287 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
5288 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
5291 /* Try doing i/d line, if not yet inhibited. */
5292 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
5293 force_p
|= scrolling (f
);
5295 /* Update the individual lines as needed. Do bottom line first. */
5296 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
5297 update_frame_line (f
, desired_matrix
->nrows
- 1);
5299 /* Now update the rest of the lines. */
5300 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
5302 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
5304 if (FRAME_TERMCAP_P (f
))
5306 /* Flush out every so many lines.
5307 Also flush out if likely to have more than 1k buffered
5308 otherwise. I'm told that some telnet connections get
5309 really screwed by more than 1k output at once. */
5310 FILE *display_output
= FRAME_TTY (f
)->output
;
5313 int outq
= PENDING_OUTPUT_COUNT (display_output
);
5315 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
5317 fflush (display_output
);
5318 if (preempt_count
== 1)
5320 #ifdef EMACS_OUTQSIZE
5321 if (EMACS_OUTQSIZE (0, &outq
) < 0)
5322 /* Probably not a tty. Ignore the error and reset
5324 outq
= PENDING_OUTPUT_COUNT (FRAME_TTY (f
->output
));
5327 if (baud_rate
<= outq
&& baud_rate
> 0)
5328 sleep (outq
/ baud_rate
);
5334 #if PERIODIC_PREEMPTION_CHECKING
5338 EMACS_GET_TIME (tm
);
5339 EMACS_SUB_TIME (dif
, preemption_next_check
, tm
);
5340 if (EMACS_TIME_NEG_P (dif
))
5342 EMACS_ADD_TIME (preemption_next_check
, tm
, preemption_period
);
5343 if (detect_input_pending_ignore_squeezables ())
5348 if (!force_p
&& (i
- 1) % preempt_count
== 0)
5349 detect_input_pending_ignore_squeezables ();
5352 update_frame_line (f
, i
);
5356 pause
= (i
< FRAME_LINES (f
) - 1) ? i
: 0;
5358 /* Now just clean up termcap drivers and set cursor, etc. */
5361 if ((cursor_in_echo_area
5362 /* If we are showing a message instead of the mini-buffer,
5363 show the cursor for the message instead of for the
5364 (now hidden) mini-buffer contents. */
5365 || (EQ (minibuf_window
, selected_window
)
5366 && EQ (minibuf_window
, echo_area_window
)
5367 && !NILP (echo_area_buffer
[0])))
5368 /* These cases apply only to the frame that contains
5369 the active mini-buffer window. */
5370 && FRAME_HAS_MINIBUF_P (f
)
5371 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
5373 int top
= WINDOW_TOP_EDGE_LINE (XWINDOW (FRAME_MINIBUF_WINDOW (f
)));
5376 if (cursor_in_echo_area
< 0)
5378 /* Negative value of cursor_in_echo_area means put
5379 cursor at beginning of line. */
5385 /* Positive value of cursor_in_echo_area means put
5386 cursor at the end of the prompt. If the mini-buffer
5387 is several lines high, find the last line that has
5389 row
= FRAME_LINES (f
);
5395 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
5397 /* Frame rows are filled up with spaces that
5398 must be ignored here. */
5399 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
5401 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
5402 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
5405 && (last
- 1)->charpos
< 0)
5411 while (row
> top
&& col
== 0);
5413 /* Make sure COL is not out of range. */
5414 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
5416 /* If we have another row, advance cursor into it. */
5417 if (row
< FRAME_LINES (f
) - 1)
5419 col
= FRAME_LEFT_SCROLL_BAR_COLS (f
);
5422 /* Otherwise move it back in range. */
5424 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
5428 cursor_to (f
, row
, col
);
5432 /* We have only one cursor on terminal frames. Use it to
5433 display the cursor of the selected window. */
5434 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5435 if (w
->cursor
.vpos
>= 0
5436 /* The cursor vpos may be temporarily out of bounds
5437 in the following situation: There is one window,
5438 with the cursor in the lower half of it. The window
5439 is split, and a message causes a redisplay before
5440 a new cursor position has been computed. */
5441 && w
->cursor
.vpos
< WINDOW_TOTAL_LINES (w
))
5443 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
5444 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
5446 if (INTEGERP (w
->left_margin_cols
))
5447 x
+= XFASTINT (w
->left_margin_cols
);
5449 /* x = max (min (x, FRAME_TOTAL_COLS (f) - 1), 0); */
5450 cursor_to (f
, y
, x
);
5457 clear_desired_matrices (f
);
5462 /* Do line insertions/deletions on frame F for frame-based redisplay. */
5466 struct frame
*frame
;
5468 int unchanged_at_top
, unchanged_at_bottom
;
5471 int *old_hash
= (int *) alloca (FRAME_LINES (frame
) * sizeof (int));
5472 int *new_hash
= (int *) alloca (FRAME_LINES (frame
) * sizeof (int));
5473 int *draw_cost
= (int *) alloca (FRAME_LINES (frame
) * sizeof (int));
5474 int *old_draw_cost
= (int *) alloca (FRAME_LINES (frame
) * sizeof (int));
5476 int free_at_end_vpos
= FRAME_LINES (frame
);
5477 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
5478 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
5480 if (!current_matrix
)
5483 /* Compute hash codes of all the lines. Also calculate number of
5484 changed lines, number of unchanged lines at the beginning, and
5485 number of unchanged lines at the end. */
5487 unchanged_at_top
= 0;
5488 unchanged_at_bottom
= FRAME_LINES (frame
);
5489 for (i
= 0; i
< FRAME_LINES (frame
); i
++)
5491 /* Give up on this scrolling if some old lines are not enabled. */
5492 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
5494 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
5495 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
5497 /* This line cannot be redrawn, so don't let scrolling mess it. */
5498 new_hash
[i
] = old_hash
[i
];
5499 #define INFINITY 1000000 /* Taken from scroll.c */
5500 draw_cost
[i
] = INFINITY
;
5504 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
5505 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
5508 if (old_hash
[i
] != new_hash
[i
])
5511 unchanged_at_bottom
= FRAME_LINES (frame
) - i
- 1;
5513 else if (i
== unchanged_at_top
)
5515 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
5518 /* If changed lines are few, don't allow preemption, don't scroll. */
5519 if ((!FRAME_SCROLL_REGION_OK (frame
)
5520 && changed_lines
< baud_rate
/ 2400)
5521 || unchanged_at_bottom
== FRAME_LINES (frame
))
5524 window_size
= (FRAME_LINES (frame
) - unchanged_at_top
5525 - unchanged_at_bottom
);
5527 if (FRAME_SCROLL_REGION_OK (frame
))
5528 free_at_end_vpos
-= unchanged_at_bottom
;
5529 else if (FRAME_MEMORY_BELOW_FRAME (frame
))
5530 free_at_end_vpos
= -1;
5532 /* If large window, fast terminal and few lines in common between
5533 current frame and desired frame, don't bother with i/d calc. */
5534 if (!FRAME_SCROLL_REGION_OK (frame
)
5535 && window_size
>= 18 && baud_rate
> 2400
5537 10 * scrolling_max_lines_saved (unchanged_at_top
,
5538 FRAME_LINES (frame
) - unchanged_at_bottom
,
5539 old_hash
, new_hash
, draw_cost
)))
5542 if (window_size
< 2)
5545 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
5546 draw_cost
+ unchanged_at_top
- 1,
5547 old_draw_cost
+ unchanged_at_top
- 1,
5548 old_hash
+ unchanged_at_top
- 1,
5549 new_hash
+ unchanged_at_top
- 1,
5550 free_at_end_vpos
- unchanged_at_top
);
5556 /* Count the number of blanks at the start of the vector of glyphs R
5557 which is LEN glyphs long. */
5560 count_blanks (r
, len
)
5566 for (i
= 0; i
< len
; ++i
)
5567 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
5574 /* Count the number of glyphs in common at the start of the glyph
5575 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
5576 of STR2. Value is the number of equal glyphs equal at the start. */
5579 count_match (str1
, end1
, str2
, end2
)
5580 struct glyph
*str1
, *end1
, *str2
, *end2
;
5582 struct glyph
*p1
= str1
;
5583 struct glyph
*p2
= str2
;
5587 && GLYPH_CHAR_AND_FACE_EQUAL_P (p1
, p2
))
5594 /* Char insertion/deletion cost vector, from term.c */
5596 extern int *char_ins_del_vector
;
5597 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_TOTAL_COLS((f))])
5600 /* Perform a frame-based update on line VPOS in frame FRAME. */
5603 update_frame_line (f
, vpos
)
5607 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
5609 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
5610 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
5611 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
5612 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
5613 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
5614 int must_write_whole_line_p
;
5615 int write_spaces_p
= FRAME_MUST_WRITE_SPACES (f
);
5616 int colored_spaces_p
= (FACE_FROM_ID (f
, DEFAULT_FACE_ID
)->background
5617 != FACE_TTY_DEFAULT_BG_COLOR
);
5619 if (colored_spaces_p
)
5622 /* Current row not enabled means it has unknown contents. We must
5623 write the whole desired line in that case. */
5624 must_write_whole_line_p
= !current_row
->enabled_p
;
5625 if (must_write_whole_line_p
)
5632 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
5633 olen
= current_row
->used
[TEXT_AREA
];
5635 /* Ignore trailing spaces, if we can. */
5636 if (!write_spaces_p
)
5637 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
5641 current_row
->enabled_p
= 1;
5642 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
5644 /* If desired line is empty, just clear the line. */
5645 if (!desired_row
->enabled_p
)
5651 nbody
= desired_row
->glyphs
[TEXT_AREA
];
5652 nlen
= desired_row
->used
[TEXT_AREA
];
5653 nend
= nbody
+ nlen
;
5655 /* If display line has unknown contents, write the whole line. */
5656 if (must_write_whole_line_p
)
5658 /* Ignore spaces at the end, if we can. */
5659 if (!write_spaces_p
)
5660 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5663 /* Write the contents of the desired line. */
5666 cursor_to (f
, vpos
, 0);
5667 write_glyphs (f
, nbody
, nlen
);
5670 /* Don't call clear_end_of_line if we already wrote the whole
5671 line. The cursor will not be at the right margin in that
5672 case but in the line below. */
5673 if (nlen
< FRAME_TOTAL_COLS (f
))
5675 cursor_to (f
, vpos
, nlen
);
5676 clear_end_of_line (f
, FRAME_TOTAL_COLS (f
));
5679 /* Make sure we are in the right row, otherwise cursor movement
5680 with cmgoto might use `ch' in the wrong row. */
5681 cursor_to (f
, vpos
, 0);
5683 make_current (desired_matrix
, current_matrix
, vpos
);
5687 /* Pretend trailing spaces are not there at all,
5688 unless for one reason or another we must write all spaces. */
5689 if (!write_spaces_p
)
5690 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5693 /* If there's no i/d char, quickly do the best we can without it. */
5694 if (!FRAME_CHAR_INS_DEL_OK (f
))
5698 /* Find the first glyph in desired row that doesn't agree with
5699 a glyph in the current row, and write the rest from there on. */
5700 for (i
= 0; i
< nlen
; i
++)
5702 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
5704 /* Find the end of the run of different glyphs. */
5708 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
5709 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
5712 /* Output this run of non-matching chars. */
5713 cursor_to (f
, vpos
, i
);
5714 write_glyphs (f
, nbody
+ i
, j
- i
);
5717 /* Now find the next non-match. */
5721 /* Clear the rest of the line, or the non-clear part of it. */
5724 cursor_to (f
, vpos
, nlen
);
5725 clear_end_of_line (f
, olen
);
5728 /* Make current row = desired row. */
5729 make_current (desired_matrix
, current_matrix
, vpos
);
5733 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
5734 characters in a row. */
5738 /* If current line is blank, skip over initial spaces, if
5739 possible, and write the rest. */
5743 nsp
= count_blanks (nbody
, nlen
);
5747 cursor_to (f
, vpos
, nsp
);
5748 write_glyphs (f
, nbody
+ nsp
, nlen
- nsp
);
5751 /* Exchange contents between current_frame and new_frame. */
5752 make_current (desired_matrix
, current_matrix
, vpos
);
5756 /* Compute number of leading blanks in old and new contents. */
5757 osp
= count_blanks (obody
, olen
);
5758 nsp
= (colored_spaces_p
? 0 : count_blanks (nbody
, nlen
));
5760 /* Compute number of matching chars starting with first non-blank. */
5761 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
5762 nbody
+ nsp
, nbody
+ nlen
);
5764 /* Spaces in new match implicit space past the end of old. */
5765 /* A bug causing this to be a no-op was fixed in 18.29. */
5766 if (!write_spaces_p
&& osp
+ begmatch
== olen
)
5769 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
5773 /* Avoid doing insert/delete char
5774 just cause number of leading spaces differs
5775 when the following text does not match. */
5776 if (begmatch
== 0 && osp
!= nsp
)
5777 osp
= nsp
= min (osp
, nsp
);
5779 /* Find matching characters at end of line */
5782 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
5784 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
5789 endmatch
= obody
+ olen
- op1
;
5791 /* tem gets the distance to insert or delete.
5792 endmatch is how many characters we save by doing so.
5795 tem
= (nlen
- nsp
) - (olen
- osp
);
5797 && (!FRAME_CHAR_INS_DEL_OK (f
)
5798 || endmatch
<= char_ins_del_cost (f
)[tem
]))
5801 /* nsp - osp is the distance to insert or delete.
5802 If that is nonzero, begmatch is known to be nonzero also.
5803 begmatch + endmatch is how much we save by doing the ins/del.
5807 && (!FRAME_CHAR_INS_DEL_OK (f
)
5808 || begmatch
+ endmatch
<= char_ins_del_cost (f
)[nsp
- osp
]))
5812 osp
= nsp
= min (osp
, nsp
);
5815 /* Now go through the line, inserting, writing and
5816 deleting as appropriate. */
5820 cursor_to (f
, vpos
, nsp
);
5821 delete_glyphs (f
, osp
- nsp
);
5825 /* If going to delete chars later in line
5826 and insert earlier in the line,
5827 must delete first to avoid losing data in the insert */
5828 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
5830 cursor_to (f
, vpos
, nlen
- endmatch
+ osp
- nsp
);
5831 delete_glyphs (f
, olen
+ nsp
- osp
- nlen
);
5832 olen
= nlen
- (nsp
- osp
);
5834 cursor_to (f
, vpos
, osp
);
5835 insert_glyphs (f
, 0, nsp
- osp
);
5839 tem
= nsp
+ begmatch
+ endmatch
;
5840 if (nlen
!= tem
|| olen
!= tem
)
5842 if (!endmatch
|| nlen
== olen
)
5844 /* If new text being written reaches right margin, there is
5845 no need to do clear-to-eol at the end of this function
5846 (and it would not be safe, since cursor is not going to
5847 be "at the margin" after the text is done). */
5848 if (nlen
== FRAME_TOTAL_COLS (f
))
5851 /* Function write_glyphs is prepared to do nothing
5852 if passed a length <= 0. Check it here to avoid
5853 unnecessary cursor movement. */
5856 cursor_to (f
, vpos
, nsp
+ begmatch
);
5857 write_glyphs (f
, nbody
+ nsp
+ begmatch
, nlen
- tem
);
5860 else if (nlen
> olen
)
5862 /* Here, we used to have the following simple code:
5863 ----------------------------------------
5864 write_glyphs (nbody + nsp + begmatch, olen - tem);
5865 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5866 ----------------------------------------
5867 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5868 is a padding glyph. */
5869 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5872 cursor_to (f
, vpos
, nsp
+ begmatch
);
5874 /* Calculate columns we can actually overwrite. */
5875 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
]))
5877 write_glyphs (f
, nbody
+ nsp
+ begmatch
, out
);
5879 /* If we left columns to be overwritten, we must delete them. */
5880 del
= olen
- tem
- out
;
5882 delete_glyphs (f
, del
);
5884 /* At last, we insert columns not yet written out. */
5885 insert_glyphs (f
, nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5888 else if (olen
> nlen
)
5890 cursor_to (f
, vpos
, nsp
+ begmatch
);
5891 write_glyphs (f
, nbody
+ nsp
+ begmatch
, nlen
- tem
);
5892 delete_glyphs (f
, olen
- nlen
);
5898 /* If any unerased characters remain after the new line, erase them. */
5901 cursor_to (f
, vpos
, nlen
);
5902 clear_end_of_line (f
, olen
);
5905 /* Exchange contents between current_frame and new_frame. */
5906 make_current (desired_matrix
, current_matrix
, vpos
);
5911 /***********************************************************************
5912 X/Y Position -> Buffer Position
5913 ***********************************************************************/
5915 /* Determine what's under window-relative pixel position (*X, *Y).
5916 Return the object (string or buffer) that's there.
5917 Return in *POS the position in that object.
5918 Adjust *X and *Y to character positions. */
5921 buffer_posn_from_coords (w
, x
, y
, pos
, object
, dx
, dy
, width
, height
)
5924 struct display_pos
*pos
;
5925 Lisp_Object
*object
;
5927 int *width
, *height
;
5930 struct buffer
*old_current_buffer
= current_buffer
;
5931 struct text_pos startp
;
5933 struct glyph_row
*row
;
5934 #ifdef HAVE_WINDOW_SYSTEM
5935 struct image
*img
= 0;
5939 current_buffer
= XBUFFER (w
->buffer
);
5940 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5941 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5942 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5943 start_display (&it
, w
, startp
);
5945 x0
= *x
- WINDOW_LEFT_MARGIN_WIDTH (w
);
5946 move_it_to (&it
, -1, x0
+ it
.first_visible_x
, *y
, -1,
5947 MOVE_TO_X
| MOVE_TO_Y
);
5949 current_buffer
= old_current_buffer
;
5951 *dx
= x0
+ it
.first_visible_x
- it
.current_x
;
5952 *dy
= *y
- it
.current_y
;
5955 if (STRINGP (it
.string
))
5959 #ifdef HAVE_WINDOW_SYSTEM
5960 if (it
.what
== IT_IMAGE
)
5962 if ((img
= IMAGE_FROM_ID (it
.f
, it
.image_id
)) != NULL
5963 && !NILP (img
->spec
))
5964 *object
= img
->spec
;
5968 if (it
.vpos
< w
->current_matrix
->nrows
5969 && (row
= MATRIX_ROW (w
->current_matrix
, it
.vpos
),
5972 if (it
.hpos
< row
->used
[TEXT_AREA
])
5974 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + it
.hpos
;
5975 #ifdef HAVE_WINDOW_SYSTEM
5978 *dy
-= row
->ascent
- glyph
->ascent
;
5979 *dx
+= glyph
->slice
.x
;
5980 *dy
+= glyph
->slice
.y
;
5981 /* Image slices positions are still relative to the entire image */
5982 *width
= img
->width
;
5983 *height
= img
->height
;
5988 *width
= glyph
->pixel_width
;
5989 *height
= glyph
->ascent
+ glyph
->descent
;
5995 *height
= row
->height
;
6000 *width
= *height
= 0;
6003 /* Add extra (default width) columns if clicked after EOL. */
6004 x1
= max(0, it
.current_x
+ it
.pixel_width
- it
.first_visible_x
);
6006 it
.hpos
+= (x0
- x1
) / WINDOW_FRAME_COLUMN_WIDTH (w
);
6015 /* Value is the string under window-relative coordinates X/Y in the
6016 mode line or header line (PART says which) of window W, or nil if none.
6017 *CHARPOS is set to the position in the string returned. */
6020 mode_line_string (w
, part
, x
, y
, charpos
, object
, dx
, dy
, width
, height
)
6022 enum window_part part
;
6025 Lisp_Object
*object
;
6027 int *width
, *height
;
6029 struct glyph_row
*row
;
6030 struct glyph
*glyph
, *end
;
6032 Lisp_Object string
= Qnil
;
6034 if (part
== ON_MODE_LINE
)
6035 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
6037 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
6039 *y
= row
- MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
6041 if (row
->mode_line_p
&& row
->enabled_p
)
6043 /* Find the glyph under X. If we find one with a string object,
6044 it's the one we were looking for. */
6045 glyph
= row
->glyphs
[TEXT_AREA
];
6046 end
= glyph
+ row
->used
[TEXT_AREA
];
6047 for (x0
= *x
; glyph
< end
&& x0
>= glyph
->pixel_width
; ++glyph
)
6048 x0
-= glyph
->pixel_width
;
6049 *x
= glyph
- row
->glyphs
[TEXT_AREA
];
6052 string
= glyph
->object
;
6053 *charpos
= glyph
->charpos
;
6054 *width
= glyph
->pixel_width
;
6055 *height
= glyph
->ascent
+ glyph
->descent
;
6056 #ifdef HAVE_WINDOW_SYSTEM
6057 if (glyph
->type
== IMAGE_GLYPH
)
6060 img
= IMAGE_FROM_ID (WINDOW_XFRAME (w
), glyph
->u
.img_id
);
6062 *object
= img
->spec
;
6063 y0
-= row
->ascent
- glyph
->ascent
;
6069 /* Add extra (default width) columns if clicked after EOL. */
6070 *x
+= x0
/ WINDOW_FRAME_COLUMN_WIDTH (w
);
6072 *height
= row
->height
;
6079 *width
= *height
= 0;
6089 /* Value is the string under window-relative coordinates X/Y in either
6090 marginal area, or nil if none. *CHARPOS is set to the position in
6091 the string returned. */
6094 marginal_area_string (w
, part
, x
, y
, charpos
, object
, dx
, dy
, width
, height
)
6096 enum window_part part
;
6099 Lisp_Object
*object
;
6101 int *width
, *height
;
6103 struct glyph_row
*row
= w
->current_matrix
->rows
;
6104 struct glyph
*glyph
, *end
;
6105 int x0
, y0
, i
, wy
= *y
;
6107 Lisp_Object string
= Qnil
;
6109 if (part
== ON_LEFT_MARGIN
)
6110 area
= LEFT_MARGIN_AREA
;
6111 else if (part
== ON_RIGHT_MARGIN
)
6112 area
= RIGHT_MARGIN_AREA
;
6116 for (i
= 0; row
->enabled_p
&& i
< w
->current_matrix
->nrows
; ++i
, ++row
)
6117 if (wy
>= row
->y
&& wy
< MATRIX_ROW_BOTTOM_Y (row
))
6120 *y
= row
- MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
6124 /* Find the glyph under X. If we find one with a string object,
6125 it's the one we were looking for. */
6126 if (area
== RIGHT_MARGIN_AREA
)
6127 x0
= ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6128 ? WINDOW_LEFT_FRINGE_WIDTH (w
)
6129 : WINDOW_TOTAL_FRINGE_WIDTH (w
))
6130 + window_box_width (w
, LEFT_MARGIN_AREA
)
6131 + window_box_width (w
, TEXT_AREA
));
6133 x0
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
6134 ? WINDOW_LEFT_FRINGE_WIDTH (w
)
6137 glyph
= row
->glyphs
[area
];
6138 end
= glyph
+ row
->used
[area
];
6139 for (x0
= *x
- x0
; glyph
< end
&& x0
>= glyph
->pixel_width
; ++glyph
)
6140 x0
-= glyph
->pixel_width
;
6141 *x
= glyph
- row
->glyphs
[area
];
6144 string
= glyph
->object
;
6145 *charpos
= glyph
->charpos
;
6146 *width
= glyph
->pixel_width
;
6147 *height
= glyph
->ascent
+ glyph
->descent
;
6148 #ifdef HAVE_WINDOW_SYSTEM
6149 if (glyph
->type
== IMAGE_GLYPH
)
6152 img
= IMAGE_FROM_ID (WINDOW_XFRAME (w
), glyph
->u
.img_id
);
6154 *object
= img
->spec
;
6155 y0
-= row
->ascent
- glyph
->ascent
;
6156 x0
+= glyph
->slice
.x
;
6157 y0
+= glyph
->slice
.y
;
6163 /* Add extra (default width) columns if clicked after EOL. */
6164 *x
+= x0
/ WINDOW_FRAME_COLUMN_WIDTH (w
);
6166 *height
= row
->height
;
6173 *width
= *height
= 0;
6183 /***********************************************************************
6184 Changing Frame Sizes
6185 ***********************************************************************/
6190 window_change_signal (signalnum
) /* If we don't have an argument, */
6191 int signalnum
; /* some compilers complain in signal calls. */
6197 int old_errno
= errno
;
6199 struct tty_display_info
*tty
;
6201 signal (SIGWINCH
, window_change_signal
);
6202 SIGNAL_THREAD_CHECK (signalnum
);
6204 /* The frame size change obviously applies to a single
6205 termcap-controlled terminal, but we can't decide which.
6206 Therefore, we resize the frames corresponding to each tty.
6208 for (tty
= tty_list
; tty
; tty
= tty
->next
) {
6210 if (! tty
->term_initted
)
6213 get_tty_size (fileno (tty
->input
), &width
, &height
);
6215 if (width
> 5 && height
> 2) {
6216 Lisp_Object tail
, frame
;
6218 FOR_EACH_FRAME (tail
, frame
)
6219 if (FRAME_TERMCAP_P (XFRAME (frame
)) && FRAME_TTY (XFRAME (frame
)) == tty
)
6220 /* Record the new sizes, but don't reallocate the data
6221 structures now. Let that be done later outside of the
6223 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
6229 #endif /* SIGWINCH */
6232 /* Do any change in frame size that was requested by a signal. SAFE
6233 non-zero means this function is called from a place where it is
6234 safe to change frame sizes while a redisplay is in progress. */
6237 do_pending_window_change (safe
)
6240 /* If window_change_signal should have run before, run it now. */
6241 if (redisplaying_p
&& !safe
)
6244 while (delayed_size_change
)
6246 Lisp_Object tail
, frame
;
6248 delayed_size_change
= 0;
6250 FOR_EACH_FRAME (tail
, frame
)
6252 struct frame
*f
= XFRAME (frame
);
6254 if (f
->new_text_lines
!= 0 || f
->new_text_cols
!= 0)
6255 change_frame_size (f
, f
->new_text_lines
, f
->new_text_cols
,
6262 /* Change the frame height and/or width. Values may be given as zero to
6263 indicate no change is to take place.
6265 If DELAY is non-zero, then assume we're being called from a signal
6266 handler, and queue the change for later - perhaps the next
6267 redisplay. Since this tries to resize windows, we can't call it
6268 from a signal handler.
6270 SAFE non-zero means this function is called from a place where it's
6271 safe to change frame sizes while a redisplay is in progress. */
6274 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
, safe
)
6275 register struct frame
*f
;
6276 int newheight
, newwidth
, pretend
, delay
, safe
;
6278 Lisp_Object tail
, frame
;
6280 if (FRAME_MSDOS_P (f
))
6282 /* On MS-DOS, all frames use the same screen, so a change in
6283 size affects all frames. Termcap now supports multiple
6285 FOR_EACH_FRAME (tail
, frame
)
6286 if (! FRAME_WINDOW_P (XFRAME (frame
)))
6287 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
6288 pretend
, delay
, safe
);
6291 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
6295 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
)
6296 register struct frame
*f
;
6297 int newheight
, newwidth
, pretend
, delay
, safe
;
6299 int new_frame_total_cols
;
6300 int count
= SPECPDL_INDEX ();
6302 /* If we can't deal with the change now, queue it for later. */
6303 if (delay
|| (redisplaying_p
&& !safe
))
6305 f
->new_text_lines
= newheight
;
6306 f
->new_text_cols
= newwidth
;
6307 delayed_size_change
= 1;
6311 /* This size-change overrides any pending one for this frame. */
6312 f
->new_text_lines
= 0;
6313 f
->new_text_cols
= 0;
6315 /* If an argument is zero, set it to the current value. */
6317 newheight
= FRAME_LINES (f
);
6319 newwidth
= FRAME_COLS (f
);
6321 /* Compute width of windows in F.
6322 This is the width of the frame without vertical scroll bars. */
6323 new_frame_total_cols
= FRAME_TOTAL_COLS_ARG (f
, newwidth
);
6325 /* Round up to the smallest acceptable size. */
6326 check_frame_size (f
, &newheight
, &newwidth
);
6328 /* If we're not changing the frame size, quit now. */
6329 if (newheight
== FRAME_LINES (f
)
6330 && new_frame_total_cols
== FRAME_TOTAL_COLS (f
))
6336 /* We only can set screen dimensions to certain values supported
6337 by our video hardware. Try to find the smallest size greater
6338 or equal to the requested dimensions. */
6339 dos_set_window_size (&newheight
, &newwidth
);
6342 if (newheight
!= FRAME_LINES (f
))
6344 if (FRAME_HAS_MINIBUF_P (f
) && !FRAME_MINIBUF_ONLY_P (f
))
6346 /* Frame has both root and mini-buffer. */
6347 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f
))->top_line
,
6348 FRAME_TOP_MARGIN (f
));
6349 set_window_height (FRAME_ROOT_WINDOW (f
),
6352 - FRAME_TOP_MARGIN (f
)),
6354 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top_line
,
6356 set_window_height (FRAME_MINIBUF_WINDOW (f
), 1, 0);
6359 /* Frame has just one top-level window. */
6360 set_window_height (FRAME_ROOT_WINDOW (f
),
6361 newheight
- FRAME_TOP_MARGIN (f
), 2);
6363 if (FRAME_TERMCAP_P (f
) && !pretend
)
6364 FrameRows (FRAME_TTY (f
)) = newheight
;
6367 if (new_frame_total_cols
!= FRAME_TOTAL_COLS (f
))
6369 set_window_width (FRAME_ROOT_WINDOW (f
), new_frame_total_cols
, 2);
6370 if (FRAME_HAS_MINIBUF_P (f
))
6371 set_window_width (FRAME_MINIBUF_WINDOW (f
), new_frame_total_cols
, 0);
6373 if (FRAME_TERMCAP_P (f
) && !pretend
)
6374 FrameCols (FRAME_TTY (f
)) = newwidth
;
6376 if (WINDOWP (f
->tool_bar_window
))
6377 XSETFASTINT (XWINDOW (f
->tool_bar_window
)->total_cols
, newwidth
);
6380 FRAME_LINES (f
) = newheight
;
6381 SET_FRAME_COLS (f
, newwidth
);
6384 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
6385 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
6387 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
6389 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
6390 w
->cursor
.hpos
= w
->cursor
.x
= 0;
6391 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
6392 w
->cursor
.vpos
= w
->cursor
.y
= 0;
6396 calculate_costs (f
);
6397 SET_FRAME_GARBAGED (f
);
6402 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
6404 run_window_configuration_change_hook (f
);
6406 unbind_to (count
, Qnil
);
6411 /***********************************************************************
6412 Terminal Related Lisp Functions
6413 ***********************************************************************/
6415 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
6416 1, 1, "FOpen termscript file: ",
6417 doc
: /* Start writing all terminal output to FILE as well as the terminal.
6418 FILE = nil means just close any termscript file currently open. */)
6422 struct tty_display_info
*tty
;
6424 if (! FRAME_TERMCAP_P (SELECTED_FRAME ()))
6425 error ("Current frame is not on a tty device");
6429 if (tty
->termscript
!= 0)
6432 fclose (tty
->termscript
);
6435 tty
->termscript
= 0;
6439 file
= Fexpand_file_name (file
, Qnil
);
6440 tty
->termscript
= fopen (SDATA (file
), "w");
6441 if (tty
->termscript
== 0)
6442 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
6448 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
6449 Ssend_string_to_terminal
, 1, 2, 0,
6450 doc
: /* Send STRING to the terminal without alteration.
6451 Control characters in STRING will have terminal-dependent effects.
6453 Optional parameter TERMINAL specifies the tty terminal device to use.
6454 It may be a terminal id, a frame, or nil for the terminal used by the
6455 currently selected frame. */)
6458 Lisp_Object terminal
;
6460 struct terminal
*t
= get_tty_terminal (terminal
, 1);
6461 struct tty_display_info
*tty
;
6463 /* ??? Perhaps we should do something special for multibyte strings here. */
6464 CHECK_STRING (string
);
6468 error ("Unknown terminal device");
6470 tty
= t
->display_info
.tty
;
6472 if (tty
->termscript
)
6474 fwrite (SDATA (string
), 1, SBYTES (string
), tty
->termscript
);
6475 fflush (tty
->termscript
);
6477 fwrite (SDATA (string
), 1, SBYTES (string
), tty
->output
);
6478 fflush (tty
->output
);
6484 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
6485 doc
: /* Beep, or flash the screen.
6486 Also, unless an argument is given,
6487 terminate any keyboard macro currently executing. */)
6496 ring_bell (XFRAME (selected_frame
));
6509 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
6510 error ("Keyboard macro terminated by a command ringing the bell");
6512 ring_bell (XFRAME (selected_frame
));
6517 /***********************************************************************
6519 ***********************************************************************/
6521 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
6522 doc
: /* Pause, without updating display, for SECONDS seconds.
6523 SECONDS may be a floating-point value, meaning that you can wait for a
6524 fraction of a second. Optional second arg MILLISECONDS specifies an
6525 additional wait period, in milliseconds; this may be useful if your
6526 Emacs was built without floating point support.
6527 \(Not all operating systems support waiting for a fraction of a second.) */)
6528 (seconds
, milliseconds
)
6529 Lisp_Object seconds
, milliseconds
;
6533 if (NILP (milliseconds
))
6534 XSETINT (milliseconds
, 0);
6536 CHECK_NUMBER (milliseconds
);
6537 usec
= XINT (milliseconds
) * 1000;
6540 double duration
= extract_float (seconds
);
6541 sec
= (int) duration
;
6542 usec
+= (duration
- sec
) * 1000000;
6545 #ifndef EMACS_HAS_USECS
6546 if (sec
== 0 && usec
!= 0)
6547 error ("Millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
6550 /* Assure that 0 <= usec < 1000000. */
6553 /* We can't rely on the rounding being correct if usec is negative. */
6554 if (-1000000 < usec
)
6555 sec
--, usec
+= 1000000;
6557 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
6560 sec
+= usec
/ 1000000, usec
%= 1000000;
6562 if (sec
< 0 || (sec
== 0 && usec
== 0))
6565 wait_reading_process_output (sec
, usec
, 0, 0, Qnil
, NULL
, 0);
6571 /* This is just like wait_reading_process_output, except that
6574 TIMEOUT is number of seconds to wait (float or integer),
6575 or t to wait forever.
6576 READING is 1 if reading input.
6577 If DO_DISPLAY is >0 display process output while waiting.
6578 If DO_DISPLAY is >1 perform an initial redisplay before waiting.
6582 sit_for (timeout
, reading
, do_display
)
6583 Lisp_Object timeout
;
6584 int reading
, do_display
;
6588 swallow_events (do_display
);
6590 if ((detect_input_pending_run_timers (do_display
))
6591 || !NILP (Vexecuting_kbd_macro
))
6594 if (do_display
>= 2)
6595 redisplay_preserve_echo_area (2);
6597 if (INTEGERP (timeout
))
6599 sec
= XINT (timeout
);
6602 else if (FLOATP (timeout
))
6604 double seconds
= XFLOAT_DATA (timeout
);
6605 sec
= (int) seconds
;
6606 usec
= (int) ((seconds
- sec
) * 1000000);
6608 else if (EQ (timeout
, Qt
))
6614 wrong_type_argument (Qnumberp
, timeout
);
6616 if (sec
== 0 && usec
== 0 && !EQ (timeout
, Qt
))
6623 wait_reading_process_output (sec
, usec
, reading
? -1 : 1, do_display
,
6626 return detect_input_pending () ? Qnil
: Qt
;
6630 DEFUN ("redisplay", Fredisplay
, Sredisplay
, 0, 1, 0,
6631 doc
: /* Perform redisplay if no input is available.
6632 If optional arg FORCE is non-nil or `redisplay-dont-pause' is non-nil,
6633 perform a full redisplay even if input is available.
6634 Return t if redisplay was performed, nil otherwise. */)
6641 if ((detect_input_pending_run_timers (1)
6642 && NILP (force
) && !redisplay_dont_pause
)
6643 || !NILP (Vexecuting_kbd_macro
))
6646 count
= SPECPDL_INDEX ();
6647 if (!NILP (force
) && !redisplay_dont_pause
)
6648 specbind (Qredisplay_dont_pause
, Qt
);
6649 redisplay_preserve_echo_area (2);
6650 unbind_to (count
, Qnil
);
6656 /***********************************************************************
6657 Other Lisp Functions
6658 ***********************************************************************/
6660 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
6661 session's frames, frame names, buffers, buffer-read-only flags, and
6662 buffer-modified-flags. */
6664 static Lisp_Object frame_and_buffer_state
;
6667 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
6668 Sframe_or_buffer_changed_p
, 0, 1, 0,
6669 doc
: /* Return non-nil if the frame and buffer state appears to have changed.
6670 VARIABLE is a variable name whose value is either nil or a state vector
6671 that will be updated to contain all frames and buffers,
6672 aside from buffers whose names start with space,
6673 along with the buffers' read-only and modified flags. This allows a fast
6674 check to see whether buffer menus might need to be recomputed.
6675 If this function returns non-nil, it updates the internal vector to reflect
6678 If VARIABLE is nil, an internal variable is used. Users should not
6679 pass nil for VARIABLE. */)
6681 Lisp_Object variable
;
6683 Lisp_Object state
, tail
, frame
, buf
;
6684 Lisp_Object
*vecp
, *end
;
6687 if (! NILP (variable
))
6689 CHECK_SYMBOL (variable
);
6690 state
= Fsymbol_value (variable
);
6691 if (! VECTORP (state
))
6695 state
= frame_and_buffer_state
;
6697 vecp
= XVECTOR (state
)->contents
;
6698 end
= vecp
+ XVECTOR (state
)->size
;
6700 FOR_EACH_FRAME (tail
, frame
)
6704 if (!EQ (*vecp
++, frame
))
6708 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
6711 /* Check that the buffer info matches. */
6712 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
6714 buf
= XCDR (XCAR (tail
));
6715 /* Ignore buffers that aren't included in buffer lists. */
6716 if (SREF (XBUFFER (buf
)->name
, 0) == ' ')
6720 if (!EQ (*vecp
++, buf
))
6724 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
6728 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
6733 /* Detect deletion of a buffer at the end of the list. */
6734 if (EQ (*vecp
, Qlambda
))
6737 /* Come here if we decide the data has changed. */
6739 /* Count the size we will need.
6740 Start with 1 so there is room for at least one lambda at the end. */
6742 FOR_EACH_FRAME (tail
, frame
)
6744 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
6746 /* Reallocate the vector if data has grown to need it,
6747 or if it has shrunk a lot. */
6748 if (! VECTORP (state
)
6749 || n
> XVECTOR (state
)->size
6750 || n
+ 20 < XVECTOR (state
)->size
/ 2)
6751 /* Add 20 extra so we grow it less often. */
6753 state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
6754 if (! NILP (variable
))
6755 Fset (variable
, state
);
6757 frame_and_buffer_state
= state
;
6760 /* Record the new data in the (possibly reallocated) vector. */
6761 vecp
= XVECTOR (state
)->contents
;
6762 FOR_EACH_FRAME (tail
, frame
)
6765 *vecp
++ = XFRAME (frame
)->name
;
6767 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
6769 buf
= XCDR (XCAR (tail
));
6770 /* Ignore buffers that aren't included in buffer lists. */
6771 if (SREF (XBUFFER (buf
)->name
, 0) == ' ')
6774 *vecp
++ = XBUFFER (buf
)->read_only
;
6775 *vecp
++ = Fbuffer_modified_p (buf
);
6777 /* Fill up the vector with lambdas (always at least one). */
6779 while (vecp
- XVECTOR (state
)->contents
6780 < XVECTOR (state
)->size
)
6782 /* Make sure we didn't overflow the vector. */
6783 if (vecp
- XVECTOR (state
)->contents
6784 > XVECTOR (state
)->size
)
6791 /***********************************************************************
6793 ***********************************************************************/
6795 /* Initialization done when Emacs fork is started, before doing stty.
6796 Determine terminal type and set terminal_driver. Then invoke its
6797 decoding routine to set up variables in the terminal package. */
6802 char *terminal_type
;
6804 #ifdef HAVE_X_WINDOWS
6805 extern int display_arg
;
6808 /* Construct the space glyph. */
6809 space_glyph
.type
= CHAR_GLYPH
;
6810 SET_CHAR_GLYPH (space_glyph
, ' ', DEFAULT_FACE_ID
, 0);
6811 space_glyph
.charpos
= -1;
6814 cursor_in_echo_area
= 0;
6815 terminal_type
= (char *) 0;
6817 /* Now is the time to initialize this; it's used by init_sys_modes
6819 Vinitial_window_system
= Qnil
;
6821 /* SIGWINCH needs to be handled no matter what display we start
6822 with. Otherwise newly opened tty frames will not resize
6827 #endif /* CANNOT_DUMP */
6828 signal (SIGWINCH
, window_change_signal
);
6829 #endif /* SIGWINCH */
6831 /* If the user wants to use a window system, we shouldn't bother
6832 initializing the terminal. This is especially important when the
6833 terminal is so dumb that emacs gives up before and doesn't bother
6834 using the window system.
6836 If the DISPLAY environment variable is set and nonempty,
6837 try to use X, and die with an error message if that doesn't work. */
6839 #ifdef HAVE_X_WINDOWS
6840 if (! inhibit_window_system
&& ! display_arg
)
6844 display
= getenv ("DECW$DISPLAY");
6846 display
= getenv ("DISPLAY");
6849 display_arg
= (display
!= 0 && *display
!= 0);
6851 if (display_arg
&& !x_display_ok (display
))
6853 fprintf (stderr
, "Display %s unavailable, simulating -nw\n",
6855 inhibit_window_system
= 1;
6859 if (!inhibit_window_system
&& display_arg
6865 Vinitial_window_system
= intern ("x");
6867 Vwindow_system_version
= make_number (11);
6869 #if defined (GNU_LINUX) && defined (HAVE_LIBNCURSES)
6870 /* In some versions of ncurses,
6871 tputs crashes if we have not called tgetent.
6873 { char b
[2044]; tgetent (b
, "xterm");}
6875 adjust_frame_glyphs_initially ();
6878 #endif /* HAVE_X_WINDOWS */
6881 if (!inhibit_window_system
)
6883 Vinitial_window_system
= intern ("w32");
6884 Vwindow_system_version
= make_number (1);
6885 adjust_frame_glyphs_initially ();
6888 #endif /* HAVE_NTGUI */
6891 if (!inhibit_window_system
)
6893 Vinitial_window_system
= intern ("mac");
6894 Vwindow_system_version
= make_number (1);
6895 adjust_frame_glyphs_initially ();
6901 if (!inhibit_window_system
6907 Vinitial_window_system
= intern("ns");
6908 Vwindow_system_version
= make_number(10);
6909 adjust_frame_glyphs_initially ();
6914 /* If no window system has been specified, try to use the terminal. */
6917 fatal ("standard input is not a tty");
6922 terminal_type
= "w32console";
6924 /* Look at the TERM variable. */
6925 terminal_type
= (char *) getenv ("TERM");
6930 fprintf (stderr
, "Please specify your terminal type.\n\
6931 For types defined in VMS, use set term /device=TYPE.\n\
6932 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
6933 \(The quotation marks are necessary since terminal types are lower case.)\n");
6936 #ifdef HAVE_WINDOW_SYSTEM
6937 if (! inhibit_window_system
)
6938 fprintf (stderr
, "Please set the environment variable DISPLAY or TERM (see `tset').\n");
6940 #endif /* HAVE_WINDOW_SYSTEM */
6941 fprintf (stderr
, "Please set the environment variable TERM; see `tset'.\n");
6942 #endif /* not VMS */
6947 /* VMS DCL tends to up-case things, so down-case term type.
6948 Hardly any uppercase letters in terminal types; should be none. */
6950 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
6953 strcpy (new, terminal_type
);
6955 for (p
= new; *p
; p
++)
6959 terminal_type
= new;
6965 struct frame
*f
= XFRAME (selected_frame
);
6967 /* Open a display on the controlling tty. */
6968 t
= init_tty (0, terminal_type
, 1); /* Errors are fatal. */
6970 /* Convert the initial frame to use the new display. */
6971 if (f
->output_method
!= output_initial
)
6973 f
->output_method
= t
->type
;
6976 t
->reference_count
++;
6977 t
->display_info
.tty
->top_frame
= selected_frame
;
6978 change_frame_size (XFRAME (selected_frame
),
6979 FrameRows (t
->display_info
.tty
),
6980 FrameCols (t
->display_info
.tty
), 0, 0, 1);
6982 /* Delete the initial terminal. */
6983 if (--initial_terminal
->reference_count
== 0
6984 && initial_terminal
->delete_terminal_hook
)
6985 (*initial_terminal
->delete_terminal_hook
) (initial_terminal
);
6987 /* Update frame parameters to reflect the new type. */
6988 Fmodify_frame_parameters
6989 (selected_frame
, Fcons (Fcons (Qtty_type
,
6990 Ftty_type (selected_frame
)), Qnil
));
6991 Fmodify_frame_parameters (selected_frame
, Fcons (Fcons (Qtty
, Qnil
), Qnil
));
6995 struct frame
*sf
= SELECTED_FRAME ();
6996 int width
= FRAME_TOTAL_COLS (sf
);
6997 int height
= FRAME_LINES (sf
);
6999 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (struct glyph
);
7001 /* If these sizes are so big they cause overflow, just ignore the
7002 change. It's not clear what better we could do. */
7003 if (total_glyphs
/ sizeof (struct glyph
) / height
!= width
+ 2)
7004 fatal ("screen size %dx%d too big", width
, height
);
7007 adjust_frame_glyphs_initially ();
7008 calculate_costs (XFRAME (selected_frame
));
7010 /* Set up faces of the initial terminal frame of a dumped Emacs. */
7014 /* The MSDOS terminal turns on its ``window system'' relatively
7015 late into the startup, so we cannot do the frame faces'
7016 initialization just yet. It will be done later by pc-win.el
7017 and internal_terminal_init. */
7018 && (strcmp (terminal_type
, "internal") != 0 || inhibit_window_system
)
7020 && NILP (Vinitial_window_system
))
7022 /* For the initial frame, we don't have any way of knowing what
7023 are the foreground and background colors of the terminal. */
7024 struct frame
*sf
= SELECTED_FRAME();
7026 FRAME_FOREGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_FG_COLOR
;
7027 FRAME_BACKGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_BG_COLOR
;
7028 call0 (intern ("tty-set-up-initial-frame-faces"));
7034 /***********************************************************************
7036 ***********************************************************************/
7038 DEFUN ("internal-show-cursor", Finternal_show_cursor
,
7039 Sinternal_show_cursor
, 2, 2, 0,
7040 doc
: /* Set the cursor-visibility flag of WINDOW to SHOW.
7041 WINDOW nil means use the selected window. SHOW non-nil means
7042 show a cursor in WINDOW in the next redisplay. SHOW nil means
7043 don't show a cursor. */)
7045 Lisp_Object window
, show
;
7047 /* Don't change cursor state while redisplaying. This could confuse
7049 if (!redisplaying_p
)
7052 window
= selected_window
;
7054 CHECK_WINDOW (window
);
7056 XWINDOW (window
)->cursor_off_p
= NILP (show
);
7063 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p
,
7064 Sinternal_show_cursor_p
, 0, 1, 0,
7065 doc
: /* Value is non-nil if next redisplay will display a cursor in WINDOW.
7066 WINDOW nil or omitted means report on the selected window. */)
7073 window
= selected_window
;
7075 CHECK_WINDOW (window
);
7077 w
= XWINDOW (window
);
7078 return w
->cursor_off_p
? Qnil
: Qt
;
7081 DEFUN ("last-nonminibuffer-frame", Flast_nonminibuf_frame
,
7082 Slast_nonminibuf_frame
, 0, 0, 0,
7083 doc
: /* Value is last nonminibuffer frame. */)
7086 Lisp_Object frame
= Qnil
;
7088 if (last_nonminibuf_frame
)
7089 XSETFRAME (frame
, last_nonminibuf_frame
);
7094 /***********************************************************************
7096 ***********************************************************************/
7101 defsubr (&Sredraw_frame
);
7102 defsubr (&Sredraw_display
);
7103 defsubr (&Sframe_or_buffer_changed_p
);
7104 defsubr (&Sopen_termscript
);
7106 defsubr (&Sredisplay
);
7107 defsubr (&Ssleep_for
);
7108 defsubr (&Ssend_string_to_terminal
);
7109 defsubr (&Sinternal_show_cursor
);
7110 defsubr (&Sinternal_show_cursor_p
);
7111 defsubr (&Slast_nonminibuf_frame
);
7114 defsubr (&Sdump_redisplay_history
);
7117 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
7118 staticpro (&frame_and_buffer_state
);
7120 Qdisplay_table
= intern ("display-table");
7121 staticpro (&Qdisplay_table
);
7122 Qredisplay_dont_pause
= intern ("redisplay-dont-pause");
7123 staticpro (&Qredisplay_dont_pause
);
7125 DEFVAR_INT ("baud-rate", &baud_rate
,
7126 doc
: /* *The output baud rate of the terminal.
7127 On most systems, changing this value will affect the amount of padding
7128 and the other strategic decisions made during redisplay. */);
7130 DEFVAR_BOOL ("inverse-video", &inverse_video
,
7131 doc
: /* *Non-nil means invert the entire frame display.
7132 This means everything is in inverse video which otherwise would not be. */);
7134 DEFVAR_BOOL ("visible-bell", &visible_bell
,
7135 doc
: /* *Non-nil means try to flash the frame to represent a bell.
7137 See also `ring-bell-function'. */);
7139 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
7140 doc
: /* *Non-nil means no need to redraw entire frame after suspending.
7141 A non-nil value is useful if the terminal can automatically preserve
7142 Emacs's frame display when you reenter Emacs.
7143 It is up to you to set this variable if your terminal can do that. */);
7145 DEFVAR_LISP ("initial-window-system", &Vinitial_window_system
,
7146 doc
: /* Name of the window system that Emacs uses for the first frame.
7147 The value is a symbol--for instance, `x' for X windows.
7148 The value is nil if Emacs is using a text-only terminal. */);
7150 DEFVAR_KBOARD ("window-system", Vwindow_system
,
7151 doc
: /* Name of window system through which the selected frame is displayed.
7152 The value is a symbol--for instance, `x' for X windows.
7153 The value is nil if the selected frame is on a text-only-terminal. */);
7155 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
7156 doc
: /* The version number of the window system in use.
7157 For X windows, this is 11. */);
7159 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
7160 doc
: /* Non-nil means put cursor in minibuffer, at end of any message there. */);
7162 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
7163 doc
: /* Table defining how to output a glyph code to the frame.
7164 If not nil, this is a vector indexed by glyph code to define the glyph.
7165 Each element can be:
7166 integer: a glyph code which this glyph is an alias for.
7167 string: output this glyph using that string (not impl. in X windows).
7168 nil: this glyph mod 524288 is the code of a character to output,
7169 and this glyph / 524288 is the face number (see `face-id') to use
7170 while outputting it. */);
7171 Vglyph_table
= Qnil
;
7173 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
7174 doc
: /* Display table to use for buffers that specify none.
7175 See `buffer-display-table' for more information. */);
7176 Vstandard_display_table
= Qnil
;
7178 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause
,
7179 doc
: /* *Non-nil means update isn't paused when input is detected. */);
7180 redisplay_dont_pause
= 0;
7182 #if PERIODIC_PREEMPTION_CHECKING
7183 DEFVAR_LISP ("redisplay-preemption-period", &Vredisplay_preemption_period
,
7184 doc
: /* *The period in seconds between checking for input during redisplay.
7185 If input is detected, redisplay is pre-empted, and the input is processed.
7186 If nil, never pre-empt redisplay. */);
7187 Vredisplay_preemption_period
= make_float (0.10);
7194 Vinitial_window_system
= Qnil
;
7195 Vwindow_system_version
= Qnil
;
7199 /* arch-tag: 8d812b1f-04a2-4195-a9c4-381f8457a413
7200 (do not change this comment) */