1 /* Updating of data structures for redisplay.
3 Copyright (C) 1985-1988, 1993-1995, 1997-2013 Free Software Foundation,
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/>. */
23 #define DISPEXTERN_INLINE EXTERN_INLINE
30 /* cm.h must come after dispextern.h on Windows. */
31 #include "dispextern.h"
33 #include "character.h"
37 #include "termhooks.h"
42 #include "intervals.h"
43 #include "blockinput.h"
46 #include "syssignal.h"
48 #ifdef HAVE_WINDOW_SYSTEM
50 #endif /* HAVE_WINDOW_SYSTEM */
57 #if defined (HAVE_TERM_H) && defined (GNU_LINUX)
58 #include <term.h> /* for tgetent */
65 /* Structure to pass dimensions around. Used for character bounding
66 boxes, glyph matrix dimensions and alike. */
75 /* Function prototypes. */
77 static void update_frame_line (struct frame
*, int);
78 static int required_matrix_height (struct window
*);
79 static int required_matrix_width (struct window
*);
80 static void adjust_frame_glyphs (struct frame
*);
81 static void change_frame_size_1 (struct frame
*, int, int, bool, bool, bool);
82 static void increment_row_positions (struct glyph_row
*, ptrdiff_t, ptrdiff_t);
83 static void fill_up_frame_row_with_spaces (struct glyph_row
*, int);
84 static void build_frame_matrix_from_window_tree (struct glyph_matrix
*,
86 static void build_frame_matrix_from_leaf_window (struct glyph_matrix
*,
88 static void adjust_decode_mode_spec_buffer (struct frame
*);
89 static void fill_up_glyph_row_with_spaces (struct glyph_row
*);
90 static void clear_window_matrices (struct window
*, bool);
91 static void fill_up_glyph_row_area_with_spaces (struct glyph_row
*, int);
92 static int scrolling_window (struct window
*, bool);
93 static bool update_window_line (struct window
*, int, bool *);
94 static void mirror_make_current (struct window
*, int);
96 static void check_matrix_pointers (struct glyph_matrix
*,
97 struct glyph_matrix
*);
99 static void mirror_line_dance (struct window
*, int, int, int *, char *);
100 static bool update_window_tree (struct window
*, bool);
101 static bool update_window (struct window
*, bool);
102 static bool update_frame_1 (struct frame
*, bool, bool);
103 static bool scrolling (struct frame
*);
104 static void set_window_cursor_after_update (struct window
*);
105 static void adjust_frame_glyphs_for_window_redisplay (struct frame
*);
106 static void adjust_frame_glyphs_for_frame_redisplay (struct frame
*);
108 /* True upon entry to redisplay means do not assume anything about
109 current contents of actual terminal frame; clear and redraw it. */
113 /* True means last display completed. False means it was preempted. */
115 bool display_completed
;
117 Lisp_Object Qdisplay_table
, Qredisplay_dont_pause
;
120 /* The currently selected frame. In a single-frame version, this
121 variable always equals the_only_frame. */
123 Lisp_Object selected_frame
;
125 /* A frame which is not just a mini-buffer, or 0 if there are no such
126 frames. This is usually the most recent such frame that was
127 selected. In a single-frame version, this variable always holds
128 the address of the_only_frame. */
130 struct frame
*last_nonminibuf_frame
;
132 /* True means SIGWINCH happened when not safe. */
134 static bool delayed_size_change
;
136 /* A glyph for a space. */
138 struct glyph space_glyph
;
140 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
142 /* Counts of allocated structures. These counts serve to diagnose
143 memory leaks and double frees. */
145 static int glyph_matrix_count
;
146 static int glyph_pool_count
;
148 #endif /* GLYPH_DEBUG and ENABLE_CHECKING */
150 /* If non-null, the frame whose frame matrices are manipulated. If
151 null, window matrices are worked on. */
153 static struct frame
*frame_matrix_frame
;
155 /* True means that fonts have been loaded since the last glyph
156 matrix adjustments. Redisplay must stop, and glyph matrices must
157 be adjusted when this flag becomes true during display. The
158 reason fonts can be loaded so late is that fonts of fontsets are
159 loaded on demand. Another reason is that a line contains many
160 characters displayed by zero width or very narrow glyphs of
161 variable-width fonts. */
163 bool fonts_changed_p
;
165 /* Convert vpos and hpos from frame to window and vice versa.
166 This may only be used for terminal frames. */
170 static int window_to_frame_vpos (struct window
*, int);
171 static int window_to_frame_hpos (struct window
*, int);
172 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
173 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
175 /* One element of the ring buffer containing redisplay history
178 struct redisplay_history
180 char trace
[512 + 100];
183 /* The size of the history buffer. */
185 #define REDISPLAY_HISTORY_SIZE 30
187 /* The redisplay history buffer. */
189 static struct redisplay_history redisplay_history
[REDISPLAY_HISTORY_SIZE
];
191 /* Next free entry in redisplay_history. */
193 static int history_idx
;
195 /* A tick that's incremented each time something is added to the
198 static uprintmax_t history_tick
;
200 /* Add to the redisplay history how window W has been displayed.
201 MSG is a trace containing the information how W's glyph matrix
202 has been constructed. PAUSED_P means that the update
203 has been interrupted for pending input. */
206 add_window_display_history (struct window
*w
, const char *msg
, bool paused_p
)
211 if (history_idx
>= REDISPLAY_HISTORY_SIZE
)
213 buf
= redisplay_history
[history_idx
].trace
;
216 snprintf (buf
, sizeof redisplay_history
[0].trace
,
217 "%"pMu
": window %p (`%s')%s\n%s",
220 ((BUFFERP (w
->contents
)
221 && STRINGP (BVAR (XBUFFER (w
->contents
), name
)))
222 ? SSDATA (BVAR (XBUFFER (w
->contents
), name
))
224 paused_p
? " ***paused***" : "",
229 /* Add to the redisplay history that frame F has been displayed.
230 PAUSED_P means that the update has been interrupted for
234 add_frame_display_history (struct frame
*f
, bool paused_p
)
239 if (history_idx
>= REDISPLAY_HISTORY_SIZE
)
241 buf
= redisplay_history
[history_idx
].trace
;
244 sprintf (buf
, "%"pMu
": update frame %p%s",
246 ptr
, paused_p
? " ***paused***" : "");
250 DEFUN ("dump-redisplay-history", Fdump_redisplay_history
,
251 Sdump_redisplay_history
, 0, 0, "",
252 doc
: /* Dump redisplay history to stderr. */)
257 for (i
= history_idx
- 1; i
!= history_idx
; --i
)
260 i
= REDISPLAY_HISTORY_SIZE
- 1;
261 fprintf (stderr
, "%s\n", redisplay_history
[i
].trace
);
268 #else /* not GLYPH_DEBUG */
270 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + WINDOW_TOP_EDGE_LINE (W))
271 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + WINDOW_LEFT_EDGE_COL (W))
273 #endif /* GLYPH_DEBUG */
276 #if (defined PROFILING \
277 && (defined __FreeBSD__ || defined GNU_LINUX || defined __MINGW32__) \
278 && !HAVE___EXECUTABLE_START)
279 /* This function comes first in the Emacs executable and is used only
280 to estimate the text start for profiling. */
282 __executable_start (void)
288 /***********************************************************************
290 ***********************************************************************/
292 /* Allocate and return a glyph_matrix structure. POOL is the glyph
293 pool from which memory for the matrix should be allocated, or null
294 for window-based redisplay where no glyph pools are used. The
295 member `pool' of the glyph matrix structure returned is set to
296 POOL, the structure is otherwise zeroed. */
298 static struct glyph_matrix
*
299 new_glyph_matrix (struct glyph_pool
*pool
)
301 struct glyph_matrix
*result
= xzalloc (sizeof *result
);
303 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
304 /* Increment number of allocated matrices. This count is used
305 to detect memory leaks. */
306 ++glyph_matrix_count
;
309 /* Set pool and return. */
315 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
317 If GLYPH_DEBUG and ENABLE_CHECKING are in effect, the global counter
318 glyph_matrix_count is decremented when a matrix is freed. If the count
319 gets negative, more structures were freed than allocated, i.e. one matrix
320 was freed more than once or a bogus pointer was passed to this function.
322 If MATRIX->pool is null, this means that the matrix manages its own
323 glyph memory---this is done for matrices on X frames. Freeing the
324 matrix also frees the glyph memory in this case. */
327 free_glyph_matrix (struct glyph_matrix
*matrix
)
333 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
334 /* Detect the case that more matrices are freed than were
336 --glyph_matrix_count
;
337 eassert (glyph_matrix_count
>= 0);
340 /* Free glyph memory if MATRIX owns it. */
341 if (matrix
->pool
== NULL
)
342 for (i
= 0; i
< matrix
->rows_allocated
; ++i
)
343 xfree (matrix
->rows
[i
].glyphs
[LEFT_MARGIN_AREA
]);
345 /* Free row structures and the matrix itself. */
346 xfree (matrix
->rows
);
352 /* Return the number of glyphs to reserve for a marginal area of
353 window W. TOTAL_GLYPHS is the number of glyphs in a complete
354 display line of window W. MARGIN gives the width of the marginal
355 area in canonical character units. */
358 margin_glyphs_to_reserve (struct window
*w
, int total_glyphs
, int margin
)
362 int width
= w
->total_cols
;
363 double d
= max (0, margin
);
364 d
= min (width
/ 2 - 1, d
);
365 return (int) ((double) total_glyphs
/ width
* d
);
370 /* Return true if ROW's hash value is correct.
371 Optimized away if ENABLE_CHECKING is not defined. */
374 verify_row_hash (struct glyph_row
*row
)
376 return row
->hash
== row_hash (row
);
379 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
382 W is null if the function is called for a frame glyph matrix.
383 Otherwise it is the window MATRIX is a member of. X and Y are the
384 indices of the first column and row of MATRIX within the frame
385 matrix, if such a matrix exists. They are zero for purely
386 window-based redisplay. DIM is the needed size of the matrix.
388 In window-based redisplay, where no frame matrices exist, glyph
389 matrices manage their own glyph storage. Otherwise, they allocate
390 storage from a common frame glyph pool which can be found in
393 The reason for this memory management strategy is to avoid complete
394 frame redraws if possible. When we allocate from a common pool, a
395 change of the location or size of a sub-matrix within the pool
396 requires a complete redisplay of the frame because we cannot easily
397 make sure that the current matrices of all windows still agree with
398 what is displayed on the screen. While this is usually fast, it
399 leads to screen flickering. */
402 adjust_glyph_matrix (struct window
*w
, struct glyph_matrix
*matrix
, int x
, int y
, struct dim dim
)
406 bool marginal_areas_changed_p
= 0;
407 bool header_line_changed_p
= 0;
408 bool header_line_p
= 0;
409 int left
= -1, right
= -1;
410 int window_width
= -1, window_height
= -1;
412 /* See if W had a header line that has disappeared now, or vice versa.
416 window_box (w
, -1, 0, 0, &window_width
, &window_height
);
418 header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
419 header_line_changed_p
= header_line_p
!= matrix
->header_line_p
;
421 matrix
->header_line_p
= header_line_p
;
423 /* If POOL is null, MATRIX is a window matrix for window-based redisplay.
424 Do nothing if MATRIX' size, position, vscroll, and marginal areas
425 haven't changed. This optimization is important because preserving
426 the matrix means preventing redisplay. */
427 if (matrix
->pool
== NULL
)
429 left
= margin_glyphs_to_reserve (w
, dim
.width
, w
->left_margin_cols
);
430 right
= margin_glyphs_to_reserve (w
, dim
.width
, w
->right_margin_cols
);
431 eassert (left
>= 0 && right
>= 0);
432 marginal_areas_changed_p
= (left
!= matrix
->left_margin_glyphs
433 || right
!= matrix
->right_margin_glyphs
);
435 if (!marginal_areas_changed_p
437 && !header_line_changed_p
438 && matrix
->window_left_col
== WINDOW_LEFT_EDGE_COL (w
)
439 && matrix
->window_top_line
== WINDOW_TOP_EDGE_LINE (w
)
440 && matrix
->window_height
== window_height
441 && matrix
->window_vscroll
== w
->vscroll
442 && matrix
->window_width
== window_width
)
446 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
447 if (matrix
->rows_allocated
< dim
.height
)
449 int old_alloc
= matrix
->rows_allocated
;
450 new_rows
= dim
.height
- matrix
->rows_allocated
;
451 matrix
->rows
= xpalloc (matrix
->rows
, &matrix
->rows_allocated
,
452 new_rows
, INT_MAX
, sizeof *matrix
->rows
);
453 memset (matrix
->rows
+ old_alloc
, 0,
454 (matrix
->rows_allocated
- old_alloc
) * sizeof *matrix
->rows
);
459 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
460 on a frame not using window-based redisplay. Set up pointers for
461 each row into the glyph pool. */
464 eassert (matrix
->pool
->glyphs
);
468 left
= margin_glyphs_to_reserve (w
, dim
.width
,
469 w
->left_margin_cols
);
470 right
= margin_glyphs_to_reserve (w
, dim
.width
,
471 w
->right_margin_cols
);
476 for (i
= 0; i
< dim
.height
; ++i
)
478 struct glyph_row
*row
= &matrix
->rows
[i
];
480 row
->glyphs
[LEFT_MARGIN_AREA
]
481 = (matrix
->pool
->glyphs
482 + (y
+ i
) * matrix
->pool
->ncolumns
486 || row
== matrix
->rows
+ dim
.height
- 1
487 || (row
== matrix
->rows
&& matrix
->header_line_p
))
489 row
->glyphs
[TEXT_AREA
]
490 = row
->glyphs
[LEFT_MARGIN_AREA
];
491 row
->glyphs
[RIGHT_MARGIN_AREA
]
492 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
493 row
->glyphs
[LAST_AREA
]
494 = row
->glyphs
[RIGHT_MARGIN_AREA
];
498 row
->glyphs
[TEXT_AREA
]
499 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
500 row
->glyphs
[RIGHT_MARGIN_AREA
]
501 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
502 row
->glyphs
[LAST_AREA
]
503 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
507 matrix
->left_margin_glyphs
= left
;
508 matrix
->right_margin_glyphs
= right
;
512 /* If MATRIX->pool is null, MATRIX is responsible for managing
513 its own memory. It is a window matrix for window-based redisplay.
514 Allocate glyph memory from the heap. */
515 if (dim
.width
> matrix
->matrix_w
517 || header_line_changed_p
518 || marginal_areas_changed_p
)
520 struct glyph_row
*row
= matrix
->rows
;
521 struct glyph_row
*end
= row
+ matrix
->rows_allocated
;
525 row
->glyphs
[LEFT_MARGIN_AREA
]
526 = xnrealloc (row
->glyphs
[LEFT_MARGIN_AREA
],
527 dim
.width
, sizeof (struct glyph
));
529 /* The mode line never has marginal areas. */
530 if (row
== matrix
->rows
+ dim
.height
- 1
531 || (row
== matrix
->rows
&& matrix
->header_line_p
))
533 row
->glyphs
[TEXT_AREA
]
534 = row
->glyphs
[LEFT_MARGIN_AREA
];
535 row
->glyphs
[RIGHT_MARGIN_AREA
]
536 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
537 row
->glyphs
[LAST_AREA
]
538 = row
->glyphs
[RIGHT_MARGIN_AREA
];
542 row
->glyphs
[TEXT_AREA
]
543 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
544 row
->glyphs
[RIGHT_MARGIN_AREA
]
545 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
546 row
->glyphs
[LAST_AREA
]
547 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
553 eassert (left
>= 0 && right
>= 0);
554 matrix
->left_margin_glyphs
= left
;
555 matrix
->right_margin_glyphs
= right
;
558 /* Number of rows to be used by MATRIX. */
559 matrix
->nrows
= dim
.height
;
560 eassert (matrix
->nrows
>= 0);
564 if (matrix
== w
->current_matrix
)
566 /* Mark rows in a current matrix of a window as not having
567 valid contents. It's important to not do this for
568 desired matrices. When Emacs starts, it may already be
569 building desired matrices when this function runs. */
570 if (window_width
< 0)
571 window_width
= window_box_width (w
, -1);
573 /* Optimize the case that only the height has changed (C-x 2,
574 upper window). Invalidate all rows that are no longer part
576 if (!marginal_areas_changed_p
577 && !header_line_changed_p
579 && dim
.width
== matrix
->matrix_w
580 && matrix
->window_left_col
== WINDOW_LEFT_EDGE_COL (w
)
581 && matrix
->window_top_line
== WINDOW_TOP_EDGE_LINE (w
)
582 && matrix
->window_width
== window_width
)
584 /* Find the last row in the window. */
585 for (i
= 0; i
< matrix
->nrows
&& matrix
->rows
[i
].enabled_p
; ++i
)
586 if (MATRIX_ROW_BOTTOM_Y (matrix
->rows
+ i
) >= window_height
)
592 /* Window end is invalid, if inside of the rows that
593 are invalidated below. */
594 if (w
->window_end_vpos
>= i
)
595 w
->window_end_valid
= 0;
597 while (i
< matrix
->nrows
)
598 matrix
->rows
[i
++].enabled_p
= 0;
602 for (i
= 0; i
< matrix
->nrows
; ++i
)
603 matrix
->rows
[i
].enabled_p
= 0;
606 else if (matrix
== w
->desired_matrix
)
608 /* Rows in desired matrices always have to be cleared;
609 redisplay expects this is the case when it runs, so it
610 had better be the case when we adjust matrices between
612 for (i
= 0; i
< matrix
->nrows
; ++i
)
613 matrix
->rows
[i
].enabled_p
= 0;
618 /* Remember last values to be able to optimize frame redraws. */
619 matrix
->matrix_x
= x
;
620 matrix
->matrix_y
= y
;
621 matrix
->matrix_w
= dim
.width
;
622 matrix
->matrix_h
= dim
.height
;
624 /* Record the top y location and height of W at the time the matrix
625 was last adjusted. This is used to optimize redisplay above. */
628 matrix
->window_left_col
= WINDOW_LEFT_EDGE_COL (w
);
629 matrix
->window_top_line
= WINDOW_TOP_EDGE_LINE (w
);
630 matrix
->window_height
= window_height
;
631 matrix
->window_width
= window_width
;
632 matrix
->window_vscroll
= w
->vscroll
;
637 /* Reverse the contents of rows in MATRIX between START and END. The
638 contents of the row at END - 1 end up at START, END - 2 at START +
639 1 etc. This is part of the implementation of rotate_matrix (see
643 reverse_rows (struct glyph_matrix
*matrix
, int start
, int end
)
647 for (i
= start
, j
= end
- 1; i
< j
; ++i
, --j
)
649 /* Non-ISO HP/UX compiler doesn't like auto struct
651 struct glyph_row temp
;
652 temp
= matrix
->rows
[i
];
653 matrix
->rows
[i
] = matrix
->rows
[j
];
654 matrix
->rows
[j
] = temp
;
659 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
660 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
661 indices. (Note: this does not copy glyphs, only glyph pointers in
662 row structures are moved around).
664 The algorithm used for rotating the vector was, I believe, first
665 described by Kernighan. See the vector R as consisting of two
666 sub-vectors AB, where A has length BY for BY >= 0. The result
667 after rotating is then BA. Reverse both sub-vectors to get ArBr
668 and reverse the result to get (ArBr)r which is BA. Similar for
672 rotate_matrix (struct glyph_matrix
*matrix
, int first
, int last
, int by
)
676 /* Up (rotate left, i.e. towards lower indices). */
678 reverse_rows (matrix
, first
, first
+ by
);
679 reverse_rows (matrix
, first
+ by
, last
);
680 reverse_rows (matrix
, first
, last
);
684 /* Down (rotate right, i.e. towards higher indices). */
685 reverse_rows (matrix
, last
- by
, last
);
686 reverse_rows (matrix
, first
, last
- by
);
687 reverse_rows (matrix
, first
, last
);
692 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
693 with indices START <= index < END. Increment positions by DELTA/
697 increment_matrix_positions (struct glyph_matrix
*matrix
, int start
, int end
,
698 ptrdiff_t delta
, ptrdiff_t delta_bytes
)
700 /* Check that START and END are reasonable values. */
701 eassert (start
>= 0 && start
<= matrix
->nrows
);
702 eassert (end
>= 0 && end
<= matrix
->nrows
);
703 eassert (start
<= end
);
705 for (; start
< end
; ++start
)
706 increment_row_positions (matrix
->rows
+ start
, delta
, delta_bytes
);
710 /* Clear the enable_p flags in a range of rows in glyph matrix MATRIX.
711 START and END are the row indices of the first and last + 1 row to clear. */
714 clear_glyph_matrix_rows (struct glyph_matrix
*matrix
, int start
, int end
)
716 eassert (start
<= end
);
717 eassert (start
>= 0 && start
< matrix
->nrows
);
718 eassert (end
>= 0 && end
<= matrix
->nrows
);
720 for (; start
< end
; ++start
)
721 matrix
->rows
[start
].enabled_p
= 0;
727 Empty all rows in MATRIX by clearing their enabled_p flags.
728 The function prepare_desired_row will eventually really clear a row
729 when it sees one with a false enabled_p flag.
731 Reset update hints to default values. The only update hint
732 currently present is the flag MATRIX->no_scrolling_p. */
735 clear_glyph_matrix (struct glyph_matrix
*matrix
)
739 clear_glyph_matrix_rows (matrix
, 0, matrix
->nrows
);
740 matrix
->no_scrolling_p
= 0;
745 /* Shift part of the glyph matrix MATRIX of window W up or down.
746 Increment y-positions in glyph rows between START and END by DY,
747 and recompute their visible height. */
750 shift_glyph_matrix (struct window
*w
, struct glyph_matrix
*matrix
, int start
, int end
, int dy
)
754 eassert (start
<= end
);
755 eassert (start
>= 0 && start
< matrix
->nrows
);
756 eassert (end
>= 0 && end
<= matrix
->nrows
);
758 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
759 max_y
= WINDOW_BOX_HEIGHT_NO_MODE_LINE (w
);
761 for (; start
< end
; ++start
)
763 struct glyph_row
*row
= &matrix
->rows
[start
];
766 row
->visible_height
= row
->height
;
769 row
->visible_height
-= min_y
- row
->y
;
770 if (row
->y
+ row
->height
> max_y
)
771 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
772 if (row
->fringe_bitmap_periodic_p
)
773 row
->redraw_fringe_bitmaps_p
= 1;
778 /* Mark all rows in current matrices of frame F as invalid. Marking
779 invalid is done by setting enabled_p to zero for all rows in a
783 clear_current_matrices (register struct frame
*f
)
785 /* Clear frame current matrix, if we have one. */
786 if (f
->current_matrix
)
787 clear_glyph_matrix (f
->current_matrix
);
789 #if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
790 /* Clear the matrix of the menu bar window, if such a window exists.
791 The menu bar window is currently used to display menus on X when
792 no toolkit support is compiled in. */
793 if (WINDOWP (f
->menu_bar_window
))
794 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->current_matrix
);
797 /* Clear the matrix of the tool-bar window, if any. */
798 if (WINDOWP (f
->tool_bar_window
))
799 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
801 /* Clear current window matrices. */
802 eassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
803 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 0);
807 /* Clear out all display lines of F for a coming redisplay. */
810 clear_desired_matrices (register struct frame
*f
)
812 if (f
->desired_matrix
)
813 clear_glyph_matrix (f
->desired_matrix
);
815 #if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
816 if (WINDOWP (f
->menu_bar_window
))
817 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->desired_matrix
);
820 if (WINDOWP (f
->tool_bar_window
))
821 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->desired_matrix
);
823 /* Do it for window matrices. */
824 eassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
825 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
829 /* Clear matrices in window tree rooted in W. If DESIRED_P,
830 clear desired matrices, otherwise clear current matrices. */
833 clear_window_matrices (struct window
*w
, bool desired_p
)
837 if (WINDOWP (w
->contents
))
838 clear_window_matrices (XWINDOW (w
->contents
), desired_p
);
842 clear_glyph_matrix (w
->desired_matrix
);
845 clear_glyph_matrix (w
->current_matrix
);
846 w
->window_end_valid
= 0;
850 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
856 /***********************************************************************
859 See dispextern.h for an overall explanation of glyph rows.
860 ***********************************************************************/
862 /* Clear glyph row ROW. Do it in a way that makes it robust against
863 changes in the glyph_row structure, i.e. addition or removal of
864 structure members. */
866 static struct glyph_row null_row
;
869 clear_glyph_row (struct glyph_row
*row
)
871 struct glyph
*p
[1 + LAST_AREA
];
874 p
[LEFT_MARGIN_AREA
] = row
->glyphs
[LEFT_MARGIN_AREA
];
875 p
[TEXT_AREA
] = row
->glyphs
[TEXT_AREA
];
876 p
[RIGHT_MARGIN_AREA
] = row
->glyphs
[RIGHT_MARGIN_AREA
];
877 p
[LAST_AREA
] = row
->glyphs
[LAST_AREA
];
882 /* Restore pointers. */
883 row
->glyphs
[LEFT_MARGIN_AREA
] = p
[LEFT_MARGIN_AREA
];
884 row
->glyphs
[TEXT_AREA
] = p
[TEXT_AREA
];
885 row
->glyphs
[RIGHT_MARGIN_AREA
] = p
[RIGHT_MARGIN_AREA
];
886 row
->glyphs
[LAST_AREA
] = p
[LAST_AREA
];
888 #if 0 /* At some point, some bit-fields of struct glyph were not set,
889 which made glyphs unequal when compared with GLYPH_EQUAL_P.
890 Redisplay outputs such glyphs, and flickering effects were
891 the result. This also depended on the contents of memory
892 returned by xmalloc. If flickering happens again, activate
893 the code below. If the flickering is gone with that, chances
894 are that the flickering has the same reason as here. */
895 memset (p
[0], 0, (char *) p
[LAST_AREA
] - (char *) p
[0]);
900 /* Make ROW an empty, enabled row of canonical character height,
901 in window W starting at y-position Y. */
904 blank_row (struct window
*w
, struct glyph_row
*row
, int y
)
908 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
909 max_y
= WINDOW_BOX_HEIGHT_NO_MODE_LINE (w
);
911 clear_glyph_row (row
);
913 row
->ascent
= row
->phys_ascent
= 0;
914 row
->height
= row
->phys_height
= FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
915 row
->visible_height
= row
->height
;
918 row
->visible_height
-= min_y
- row
->y
;
919 if (row
->y
+ row
->height
> max_y
)
920 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
926 /* Increment buffer positions in glyph row ROW. DELTA and DELTA_BYTES
927 are the amounts by which to change positions. Note that the first
928 glyph of the text area of a row can have a buffer position even if
929 the used count of the text area is zero. Such rows display line
933 increment_row_positions (struct glyph_row
*row
,
934 ptrdiff_t delta
, ptrdiff_t delta_bytes
)
938 /* Increment start and end positions. */
939 MATRIX_ROW_START_CHARPOS (row
) += delta
;
940 MATRIX_ROW_START_BYTEPOS (row
) += delta_bytes
;
941 MATRIX_ROW_END_CHARPOS (row
) += delta
;
942 MATRIX_ROW_END_BYTEPOS (row
) += delta_bytes
;
943 CHARPOS (row
->start
.pos
) += delta
;
944 BYTEPOS (row
->start
.pos
) += delta_bytes
;
945 CHARPOS (row
->end
.pos
) += delta
;
946 BYTEPOS (row
->end
.pos
) += delta_bytes
;
951 /* Increment positions in glyphs. */
952 for (area
= 0; area
< LAST_AREA
; ++area
)
953 for (i
= 0; i
< row
->used
[area
]; ++i
)
954 if (BUFFERP (row
->glyphs
[area
][i
].object
)
955 && row
->glyphs
[area
][i
].charpos
> 0)
956 row
->glyphs
[area
][i
].charpos
+= delta
;
958 /* Capture the case of rows displaying a line end. */
959 if (row
->used
[TEXT_AREA
] == 0
960 && MATRIX_ROW_DISPLAYS_TEXT_P (row
))
961 row
->glyphs
[TEXT_AREA
]->charpos
+= delta
;
966 /* Swap glyphs between two glyph rows A and B. This exchanges glyph
967 contents, i.e. glyph structure contents are exchanged between A and
968 B without changing glyph pointers in A and B. */
971 swap_glyphs_in_rows (struct glyph_row
*a
, struct glyph_row
*b
)
975 for (area
= 0; area
< LAST_AREA
; ++area
)
977 /* Number of glyphs to swap. */
978 int max_used
= max (a
->used
[area
], b
->used
[area
]);
980 /* Start of glyphs in area of row A. */
981 struct glyph
*glyph_a
= a
->glyphs
[area
];
983 /* End + 1 of glyphs in area of row A. */
984 struct glyph
*glyph_a_end
= a
->glyphs
[max_used
];
986 /* Start of glyphs in area of row B. */
987 struct glyph
*glyph_b
= b
->glyphs
[area
];
989 while (glyph_a
< glyph_a_end
)
991 /* Non-ISO HP/UX compiler doesn't like auto struct
1005 /* Exchange pointers to glyph memory between glyph rows A and B. Also
1006 exchange the used[] array and the hash values of the rows, because
1007 these should all go together for the row's hash value to be
1011 swap_glyph_pointers (struct glyph_row
*a
, struct glyph_row
*b
)
1014 unsigned hash_tem
= a
->hash
;
1016 for (i
= 0; i
< LAST_AREA
+ 1; ++i
)
1018 struct glyph
*temp
= a
->glyphs
[i
];
1020 a
->glyphs
[i
] = b
->glyphs
[i
];
1021 b
->glyphs
[i
] = temp
;
1024 short used_tem
= a
->used
[i
];
1026 a
->used
[i
] = b
->used
[i
];
1027 b
->used
[i
] = used_tem
;
1035 /* Copy glyph row structure FROM to glyph row structure TO, except
1036 that glyph pointers, the `used' counts, and the hash values in the
1037 structures are left unchanged. */
1040 copy_row_except_pointers (struct glyph_row
*to
, struct glyph_row
*from
)
1042 struct glyph
*pointers
[1 + LAST_AREA
];
1043 short used
[LAST_AREA
];
1046 /* Save glyph pointers of TO. */
1047 memcpy (pointers
, to
->glyphs
, sizeof to
->glyphs
);
1048 memcpy (used
, to
->used
, sizeof to
->used
);
1051 /* Do a structure assignment. */
1054 /* Restore original pointers of TO. */
1055 memcpy (to
->glyphs
, pointers
, sizeof to
->glyphs
);
1056 memcpy (to
->used
, used
, sizeof to
->used
);
1061 /* Assign glyph row FROM to glyph row TO. This works like a structure
1062 assignment TO = FROM, except that glyph pointers are not copied but
1063 exchanged between TO and FROM. Pointers must be exchanged to avoid
1067 assign_row (struct glyph_row
*to
, struct glyph_row
*from
)
1069 swap_glyph_pointers (to
, from
);
1070 copy_row_except_pointers (to
, from
);
1074 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1075 a row in a window matrix, is a slice of the glyph memory of the
1076 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1077 is true if the glyph memory of WINDOW_ROW is part of the glyph
1078 memory of FRAME_ROW. */
1083 glyph_row_slice_p (struct glyph_row
*window_row
, struct glyph_row
*frame_row
)
1085 struct glyph
*window_glyph_start
= window_row
->glyphs
[0];
1086 struct glyph
*frame_glyph_start
= frame_row
->glyphs
[0];
1087 struct glyph
*frame_glyph_end
= frame_row
->glyphs
[LAST_AREA
];
1089 return (frame_glyph_start
<= window_glyph_start
1090 && window_glyph_start
< frame_glyph_end
);
1093 #endif /* GLYPH_DEBUG */
1097 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1098 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1099 in WINDOW_MATRIX is found satisfying the condition. */
1101 static struct glyph_row
*
1102 find_glyph_row_slice (struct glyph_matrix
*window_matrix
,
1103 struct glyph_matrix
*frame_matrix
, int row
)
1107 eassert (row
>= 0 && row
< frame_matrix
->nrows
);
1109 for (i
= 0; i
< window_matrix
->nrows
; ++i
)
1110 if (glyph_row_slice_p (window_matrix
->rows
+ i
,
1111 frame_matrix
->rows
+ row
))
1114 return i
< window_matrix
->nrows
? window_matrix
->rows
+ i
: 0;
1119 /* Prepare ROW for display. Desired rows are cleared lazily,
1120 i.e. they are only marked as to be cleared by setting their
1121 enabled_p flag to zero. When a row is to be displayed, a prior
1122 call to this function really clears it. */
1125 prepare_desired_row (struct glyph_row
*row
)
1127 if (!row
->enabled_p
)
1129 bool rp
= row
->reversed_p
;
1131 clear_glyph_row (row
);
1133 row
->reversed_p
= rp
;
1138 /* Return a hash code for glyph row ROW. */
1141 line_hash_code (struct glyph_row
*row
)
1147 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
1148 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
1152 int c
= glyph
->u
.ch
;
1153 int face_id
= glyph
->face_id
;
1154 if (FRAME_MUST_WRITE_SPACES (SELECTED_FRAME ())) /* XXX Is SELECTED_FRAME OK here? */
1156 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + c
;
1157 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + face_id
;
1169 /* Return the cost of drawing line VPOS in MATRIX. The cost equals
1170 the number of characters in the line. If must_write_spaces is
1171 zero, leading and trailing spaces are ignored. */
1174 line_draw_cost (struct glyph_matrix
*matrix
, int vpos
)
1176 struct glyph_row
*row
= matrix
->rows
+ vpos
;
1177 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
1178 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
];
1180 Lisp_Object
*glyph_table_base
= GLYPH_TABLE_BASE
;
1181 ptrdiff_t glyph_table_len
= GLYPH_TABLE_LENGTH
;
1183 /* Ignore trailing and leading spaces if we can. */
1184 if (!FRAME_MUST_WRITE_SPACES (SELECTED_FRAME ())) /* XXX Is SELECTED_FRAME OK here? */
1186 /* Skip from the end over trailing spaces. */
1187 while (end
> beg
&& CHAR_GLYPH_SPACE_P (*(end
- 1)))
1190 /* All blank line. */
1194 /* Skip over leading spaces. */
1195 while (CHAR_GLYPH_SPACE_P (*beg
))
1199 /* If we don't have a glyph-table, each glyph is one character,
1200 so return the number of glyphs. */
1201 if (glyph_table_base
== 0)
1205 /* Otherwise, scan the glyphs and accumulate their total length
1212 SET_GLYPH_FROM_CHAR_GLYPH (g
, *beg
);
1214 if (GLYPH_INVALID_P (g
)
1215 || GLYPH_SIMPLE_P (glyph_table_base
, glyph_table_len
, g
))
1218 len
+= GLYPH_LENGTH (glyph_table_base
, g
);
1228 /* Return true if the glyph rows A and B have equal contents.
1229 MOUSE_FACE_P means compare the mouse_face_p flags of A and B, too. */
1232 row_equal_p (struct glyph_row
*a
, struct glyph_row
*b
, bool mouse_face_p
)
1234 eassert (verify_row_hash (a
));
1235 eassert (verify_row_hash (b
));
1239 else if (a
->hash
!= b
->hash
)
1243 struct glyph
*a_glyph
, *b_glyph
, *a_end
;
1246 if (mouse_face_p
&& a
->mouse_face_p
!= b
->mouse_face_p
)
1249 /* Compare glyphs. */
1250 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
1252 if (a
->used
[area
] != b
->used
[area
])
1255 a_glyph
= a
->glyphs
[area
];
1256 a_end
= a_glyph
+ a
->used
[area
];
1257 b_glyph
= b
->glyphs
[area
];
1259 while (a_glyph
< a_end
1260 && GLYPH_EQUAL_P (a_glyph
, b_glyph
))
1261 ++a_glyph
, ++b_glyph
;
1263 if (a_glyph
!= a_end
)
1267 if (a
->fill_line_p
!= b
->fill_line_p
1268 || a
->cursor_in_fringe_p
!= b
->cursor_in_fringe_p
1269 || a
->left_fringe_bitmap
!= b
->left_fringe_bitmap
1270 || a
->left_fringe_face_id
!= b
->left_fringe_face_id
1271 || a
->left_fringe_offset
!= b
->left_fringe_offset
1272 || a
->right_fringe_bitmap
!= b
->right_fringe_bitmap
1273 || a
->right_fringe_face_id
!= b
->right_fringe_face_id
1274 || a
->right_fringe_offset
!= b
->right_fringe_offset
1275 || a
->fringe_bitmap_periodic_p
!= b
->fringe_bitmap_periodic_p
1276 || a
->overlay_arrow_bitmap
!= b
->overlay_arrow_bitmap
1277 || a
->exact_window_width_line_p
!= b
->exact_window_width_line_p
1278 || a
->overlapped_p
!= b
->overlapped_p
1279 || (MATRIX_ROW_CONTINUATION_LINE_P (a
)
1280 != MATRIX_ROW_CONTINUATION_LINE_P (b
))
1281 || a
->reversed_p
!= b
->reversed_p
1282 /* Different partially visible characters on left margin. */
1284 /* Different height. */
1285 || a
->ascent
!= b
->ascent
1286 || a
->phys_ascent
!= b
->phys_ascent
1287 || a
->phys_height
!= b
->phys_height
1288 || a
->visible_height
!= b
->visible_height
)
1297 /***********************************************************************
1300 See dispextern.h for an overall explanation of glyph pools.
1301 ***********************************************************************/
1303 /* Allocate a glyph_pool structure. The structure returned is initialized
1304 with zeros. If GLYPH_DEBUG and ENABLE_CHECKING are in effect, the global
1305 variable glyph_pool_count is incremented for each pool allocated. */
1307 static struct glyph_pool
*
1308 new_glyph_pool (void)
1310 struct glyph_pool
*result
= xzalloc (sizeof *result
);
1312 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
1313 /* For memory leak and double deletion checking. */
1321 /* Free a glyph_pool structure POOL. The function may be called with
1322 a null POOL pointer. If GLYPH_DEBUG and ENABLE_CHECKING are in effect,
1323 global variable glyph_pool_count is decremented with every pool structure
1324 freed. If this count gets negative, more structures were freed than
1325 allocated, i.e. one structure must have been freed more than once or
1326 a bogus pointer was passed to free_glyph_pool. */
1329 free_glyph_pool (struct glyph_pool
*pool
)
1333 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
1334 /* More freed than allocated? */
1336 eassert (glyph_pool_count
>= 0);
1338 xfree (pool
->glyphs
);
1344 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1345 columns we need. This function never shrinks a pool. The only
1346 case in which this would make sense, would be when a frame's size
1347 is changed from a large value to a smaller one. But, if someone
1348 does it once, we can expect that he will do it again.
1350 Return true if the pool changed in a way which makes
1351 re-adjusting window glyph matrices necessary. */
1354 realloc_glyph_pool (struct glyph_pool
*pool
, struct dim matrix_dim
)
1359 changed_p
= (pool
->glyphs
== 0
1360 || matrix_dim
.height
!= pool
->nrows
1361 || matrix_dim
.width
!= pool
->ncolumns
);
1363 /* Enlarge the glyph pool. */
1364 needed
= matrix_dim
.width
;
1365 if (INT_MULTIPLY_OVERFLOW (needed
, matrix_dim
.height
))
1366 memory_full (SIZE_MAX
);
1367 needed
*= matrix_dim
.height
;
1368 if (needed
> pool
->nglyphs
)
1370 ptrdiff_t old_nglyphs
= pool
->nglyphs
;
1371 pool
->glyphs
= xpalloc (pool
->glyphs
, &pool
->nglyphs
,
1372 needed
- old_nglyphs
, -1, sizeof *pool
->glyphs
);
1373 memset (pool
->glyphs
+ old_nglyphs
, 0,
1374 (pool
->nglyphs
- old_nglyphs
) * sizeof *pool
->glyphs
);
1377 /* Remember the number of rows and columns because (a) we use them
1378 to do sanity checks, and (b) the number of columns determines
1379 where rows in the frame matrix start---this must be available to
1380 determine pointers to rows of window sub-matrices. */
1381 pool
->nrows
= matrix_dim
.height
;
1382 pool
->ncolumns
= matrix_dim
.width
;
1389 /***********************************************************************
1391 ***********************************************************************/
1396 /* Flush standard output. This is sometimes useful to call from the debugger.
1397 XXX Maybe this should be changed to flush the current terminal instead of
1401 void flush_stdout (void) EXTERNALLY_VISIBLE
;
1410 /* Check that no glyph pointers have been lost in MATRIX. If a
1411 pointer has been lost, e.g. by using a structure assignment between
1412 rows, at least one pointer must occur more than once in the rows of
1416 check_matrix_pointer_lossage (struct glyph_matrix
*matrix
)
1420 for (i
= 0; i
< matrix
->nrows
; ++i
)
1421 for (j
= 0; j
< matrix
->nrows
; ++j
)
1423 || (matrix
->rows
[i
].glyphs
[TEXT_AREA
]
1424 != matrix
->rows
[j
].glyphs
[TEXT_AREA
]));
1428 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1431 matrix_row (struct glyph_matrix
*matrix
, int row
)
1433 eassert (matrix
&& matrix
->rows
);
1434 eassert (row
>= 0 && row
< matrix
->nrows
);
1436 /* That's really too slow for normal testing because this function
1437 is called almost everywhere. Although---it's still astonishingly
1438 fast, so it is valuable to have for debugging purposes. */
1440 check_matrix_pointer_lossage (matrix
);
1443 return matrix
->rows
+ row
;
1447 #if 0 /* This function makes invalid assumptions when text is
1448 partially invisible. But it might come handy for debugging
1451 /* Check invariants that must hold for an up to date current matrix of
1455 check_matrix_invariants (struct window
*w
)
1457 struct glyph_matrix
*matrix
= w
->current_matrix
;
1458 int yb
= window_text_bottom_y (w
);
1459 struct glyph_row
*row
= matrix
->rows
;
1460 struct glyph_row
*last_text_row
= NULL
;
1461 struct buffer
*saved
= current_buffer
;
1462 struct buffer
*buffer
= XBUFFER (w
->contents
);
1465 /* This can sometimes happen for a fresh window. */
1466 if (matrix
->nrows
< 2)
1469 set_buffer_temp (buffer
);
1471 /* Note: last row is always reserved for the mode line. */
1472 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1473 && MATRIX_ROW_BOTTOM_Y (row
) < yb
)
1475 struct glyph_row
*next
= row
+ 1;
1477 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1478 last_text_row
= row
;
1480 /* Check that character and byte positions are in sync. */
1481 eassert (MATRIX_ROW_START_BYTEPOS (row
)
1482 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row
)));
1483 eassert (BYTEPOS (row
->start
.pos
)
1484 == CHAR_TO_BYTE (CHARPOS (row
->start
.pos
)));
1486 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1487 have such a position temporarily in case of a minibuffer
1488 displaying something like `[Sole completion]' at its end. */
1489 if (MATRIX_ROW_END_CHARPOS (row
) < BUF_ZV (current_buffer
))
1491 eassert (MATRIX_ROW_END_BYTEPOS (row
)
1492 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row
)));
1493 eassert (BYTEPOS (row
->end
.pos
)
1494 == CHAR_TO_BYTE (CHARPOS (row
->end
.pos
)));
1497 /* Check that end position of `row' is equal to start position
1499 if (next
->enabled_p
&& MATRIX_ROW_DISPLAYS_TEXT_P (next
))
1501 eassert (MATRIX_ROW_END_CHARPOS (row
)
1502 == MATRIX_ROW_START_CHARPOS (next
));
1503 eassert (MATRIX_ROW_END_BYTEPOS (row
)
1504 == MATRIX_ROW_START_BYTEPOS (next
));
1505 eassert (CHARPOS (row
->end
.pos
) == CHARPOS (next
->start
.pos
));
1506 eassert (BYTEPOS (row
->end
.pos
) == BYTEPOS (next
->start
.pos
));
1511 eassert (w
->current_matrix
->nrows
== w
->desired_matrix
->nrows
);
1512 eassert (w
->desired_matrix
->rows
!= NULL
);
1513 set_buffer_temp (saved
);
1518 #endif /* GLYPH_DEBUG */
1522 /**********************************************************************
1523 Allocating/ Adjusting Glyph Matrices
1524 **********************************************************************/
1526 /* Allocate glyph matrices over a window tree for a frame-based
1529 X and Y are column/row within the frame glyph matrix where
1530 sub-matrices for the window tree rooted at WINDOW must be
1531 allocated. DIM_ONLY_P means that the caller of this
1532 function is only interested in the result matrix dimension, and
1533 matrix adjustments should not be performed.
1535 The function returns the total width/height of the sub-matrices of
1536 the window tree. If called on a frame root window, the computation
1537 will take the mini-buffer window into account.
1539 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1541 NEW_LEAF_MATRIX set if any window in the tree did not have a
1542 glyph matrices yet, and
1544 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1545 any window in the tree will be changed or have been changed (see
1548 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1551 Windows are arranged into chains of windows on the same level
1552 through the next fields of window structures. Such a level can be
1553 either a sequence of horizontally adjacent windows from left to
1554 right, or a sequence of vertically adjacent windows from top to
1555 bottom. Each window in a horizontal sequence can be either a leaf
1556 window or a vertical sequence; a window in a vertical sequence can
1557 be either a leaf or a horizontal sequence. All windows in a
1558 horizontal sequence have the same height, and all windows in a
1559 vertical sequence have the same width.
1561 This function uses, for historical reasons, a more general
1562 algorithm to determine glyph matrix dimensions that would be
1565 The matrix height of a horizontal sequence is determined by the
1566 maximum height of any matrix in the sequence. The matrix width of
1567 a horizontal sequence is computed by adding up matrix widths of
1568 windows in the sequence.
1570 |<------- result width ------->|
1571 +---------+----------+---------+ ---
1574 +---------+ | | result height
1579 The matrix width of a vertical sequence is the maximum matrix width
1580 of any window in the sequence. Its height is computed by adding up
1581 matrix heights of windows in the sequence.
1583 |<---- result width -->|
1591 +------------+---------+ |
1594 +------------+---------+ --- */
1596 /* Bit indicating that a new matrix will be allocated or has been
1599 #define NEW_LEAF_MATRIX (1 << 0)
1601 /* Bit indicating that a matrix will or has changed its location or
1604 #define CHANGED_LEAF_MATRIX (1 << 1)
1607 allocate_matrices_for_frame_redisplay (Lisp_Object window
, int x
, int y
,
1608 bool dim_only_p
, int *window_change_flags
)
1610 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1612 int wmax
= 0, hmax
= 0;
1616 bool in_horz_combination_p
;
1618 /* What combination is WINDOW part of? Compute this once since the
1619 result is the same for all windows in the `next' chain. The
1620 special case of a root window (parent equal to nil) is treated
1621 like a vertical combination because a root window's `next'
1622 points to the mini-buffer window, if any, which is arranged
1623 vertically below other windows. */
1624 in_horz_combination_p
1625 = (!NILP (XWINDOW (window
)->parent
)
1626 && WINDOW_HORIZONTAL_COMBINATION_P (XWINDOW (XWINDOW (window
)->parent
)));
1628 /* For WINDOW and all windows on the same level. */
1631 w
= XWINDOW (window
);
1633 /* Get the dimension of the window sub-matrix for W, depending
1634 on whether this is a combination or a leaf window. */
1635 if (WINDOWP (w
->contents
))
1636 dim
= allocate_matrices_for_frame_redisplay (w
->contents
, x
, y
,
1638 window_change_flags
);
1641 /* If not already done, allocate sub-matrix structures. */
1642 if (w
->desired_matrix
== NULL
)
1644 w
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1645 w
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1646 *window_change_flags
|= NEW_LEAF_MATRIX
;
1649 /* Width and height MUST be chosen so that there are no
1650 holes in the frame matrix. */
1651 dim
.width
= required_matrix_width (w
);
1652 dim
.height
= required_matrix_height (w
);
1654 /* Will matrix be re-allocated? */
1655 if (x
!= w
->desired_matrix
->matrix_x
1656 || y
!= w
->desired_matrix
->matrix_y
1657 || dim
.width
!= w
->desired_matrix
->matrix_w
1658 || dim
.height
!= w
->desired_matrix
->matrix_h
1659 || (margin_glyphs_to_reserve (w
, dim
.width
,
1660 w
->left_margin_cols
)
1661 != w
->desired_matrix
->left_margin_glyphs
)
1662 || (margin_glyphs_to_reserve (w
, dim
.width
,
1663 w
->right_margin_cols
)
1664 != w
->desired_matrix
->right_margin_glyphs
))
1665 *window_change_flags
|= CHANGED_LEAF_MATRIX
;
1667 /* Actually change matrices, if allowed. Do not consider
1668 CHANGED_LEAF_MATRIX computed above here because the pool
1669 may have been changed which we don't now here. We trust
1670 that we only will be called with DIM_ONLY_P when
1674 adjust_glyph_matrix (w
, w
->desired_matrix
, x
, y
, dim
);
1675 adjust_glyph_matrix (w
, w
->current_matrix
, x
, y
, dim
);
1679 /* If we are part of a horizontal combination, advance x for
1680 windows to the right of W; otherwise advance y for windows
1682 if (in_horz_combination_p
)
1687 /* Remember maximum glyph matrix dimensions. */
1688 wmax
= max (wmax
, dim
.width
);
1689 hmax
= max (hmax
, dim
.height
);
1691 /* Next window on same level. */
1694 while (!NILP (window
));
1696 /* Set `total' to the total glyph matrix dimension of this window
1697 level. In a vertical combination, the width is the width of the
1698 widest window; the height is the y we finally reached, corrected
1699 by the y we started with. In a horizontal combination, the total
1700 height is the height of the tallest window, and the width is the
1701 x we finally reached, corrected by the x we started with. */
1702 if (in_horz_combination_p
)
1704 total
.width
= x
- x0
;
1705 total
.height
= hmax
;
1710 total
.height
= y
- y0
;
1717 /* Return the required height of glyph matrices for window W. */
1720 required_matrix_height (struct window
*w
)
1722 #ifdef HAVE_WINDOW_SYSTEM
1723 struct frame
*f
= XFRAME (w
->frame
);
1725 if (FRAME_WINDOW_P (f
))
1727 int ch_height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
1728 int window_pixel_height
= window_box_height (w
) + eabs (w
->vscroll
);
1729 return (((window_pixel_height
+ ch_height
- 1)
1730 / ch_height
) * w
->nrows_scale_factor
1731 /* One partially visible line at the top and
1732 bottom of the window. */
1734 /* 2 for header and mode line. */
1737 #endif /* HAVE_WINDOW_SYSTEM */
1739 return WINDOW_TOTAL_LINES (w
);
1743 /* Return the required width of glyph matrices for window W. */
1746 required_matrix_width (struct window
*w
)
1748 #ifdef HAVE_WINDOW_SYSTEM
1749 struct frame
*f
= XFRAME (w
->frame
);
1750 if (FRAME_WINDOW_P (f
))
1752 int ch_width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
1753 int window_pixel_width
= WINDOW_TOTAL_WIDTH (w
);
1755 /* Compute number of glyphs needed in a glyph row. */
1756 return (((window_pixel_width
+ ch_width
- 1)
1757 / ch_width
) * w
->ncols_scale_factor
1758 /* 2 partially visible columns in the text area. */
1760 /* One partially visible column at the right
1761 edge of each marginal area. */
1764 #endif /* HAVE_WINDOW_SYSTEM */
1766 return w
->total_cols
;
1770 /* Allocate window matrices for window-based redisplay. W is the
1771 window whose matrices must be allocated/reallocated. */
1774 allocate_matrices_for_window_redisplay (struct window
*w
)
1778 if (WINDOWP (w
->contents
))
1779 allocate_matrices_for_window_redisplay (XWINDOW (w
->contents
));
1782 /* W is a leaf window. */
1785 /* If matrices are not yet allocated, allocate them now. */
1786 if (w
->desired_matrix
== NULL
)
1788 w
->desired_matrix
= new_glyph_matrix (NULL
);
1789 w
->current_matrix
= new_glyph_matrix (NULL
);
1792 dim
.width
= required_matrix_width (w
);
1793 dim
.height
= required_matrix_height (w
);
1794 adjust_glyph_matrix (w
, w
->desired_matrix
, 0, 0, dim
);
1795 adjust_glyph_matrix (w
, w
->current_matrix
, 0, 0, dim
);
1798 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
1803 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
1804 do it for all frames; otherwise do it just for the given frame.
1805 This function must be called when a new frame is created, its size
1806 changes, or its window configuration changes. */
1809 adjust_glyphs (struct frame
*f
)
1811 /* Block input so that expose events and other events that access
1812 glyph matrices are not processed while we are changing them. */
1816 adjust_frame_glyphs (f
);
1819 Lisp_Object tail
, lisp_frame
;
1821 FOR_EACH_FRAME (tail
, lisp_frame
)
1822 adjust_frame_glyphs (XFRAME (lisp_frame
));
1828 /* Allocate/reallocate glyph matrices of a single frame F. */
1831 adjust_frame_glyphs (struct frame
*f
)
1833 if (FRAME_WINDOW_P (f
))
1834 adjust_frame_glyphs_for_window_redisplay (f
);
1836 adjust_frame_glyphs_for_frame_redisplay (f
);
1838 /* Don't forget the buffer for decode_mode_spec. */
1839 adjust_decode_mode_spec_buffer (f
);
1841 f
->glyphs_initialized_p
= 1;
1844 /* Return true if any window in the tree has nonzero window margins. See
1845 the hack at the end of adjust_frame_glyphs_for_frame_redisplay. */
1847 showing_window_margins_p (struct window
*w
)
1851 if (WINDOWP (w
->contents
))
1853 if (showing_window_margins_p (XWINDOW (w
->contents
)))
1856 else if (w
->left_margin_cols
> 0 || w
->right_margin_cols
> 0)
1859 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
1865 /* In the window tree with root W, build current matrices of leaf
1866 windows from the frame's current matrix. */
1869 fake_current_matrices (Lisp_Object window
)
1873 for (; !NILP (window
); window
= w
->next
)
1875 w
= XWINDOW (window
);
1877 if (WINDOWP (w
->contents
))
1878 fake_current_matrices (w
->contents
);
1882 struct frame
*f
= XFRAME (w
->frame
);
1883 struct glyph_matrix
*m
= w
->current_matrix
;
1884 struct glyph_matrix
*fm
= f
->current_matrix
;
1886 eassert (m
->matrix_h
== WINDOW_TOTAL_LINES (w
));
1887 eassert (m
->matrix_w
== WINDOW_TOTAL_COLS (w
));
1889 for (i
= 0; i
< m
->matrix_h
; ++i
)
1891 struct glyph_row
*r
= m
->rows
+ i
;
1892 struct glyph_row
*fr
= fm
->rows
+ i
+ WINDOW_TOP_EDGE_LINE (w
);
1894 eassert (r
->glyphs
[TEXT_AREA
] >= fr
->glyphs
[TEXT_AREA
]
1895 && r
->glyphs
[LAST_AREA
] <= fr
->glyphs
[LAST_AREA
]);
1897 r
->enabled_p
= fr
->enabled_p
;
1900 r
->used
[LEFT_MARGIN_AREA
] = m
->left_margin_glyphs
;
1901 r
->used
[RIGHT_MARGIN_AREA
] = m
->right_margin_glyphs
;
1902 r
->used
[TEXT_AREA
] = (m
->matrix_w
1903 - r
->used
[LEFT_MARGIN_AREA
]
1904 - r
->used
[RIGHT_MARGIN_AREA
]);
1913 /* Save away the contents of frame F's current frame matrix. Value is
1914 a glyph matrix holding the contents of F's current frame matrix. */
1916 static struct glyph_matrix
*
1917 save_current_matrix (struct frame
*f
)
1920 struct glyph_matrix
*saved
= xzalloc (sizeof *saved
);
1921 saved
->nrows
= f
->current_matrix
->nrows
;
1922 saved
->rows
= xzalloc (saved
->nrows
* sizeof *saved
->rows
);
1924 for (i
= 0; i
< saved
->nrows
; ++i
)
1926 struct glyph_row
*from
= f
->current_matrix
->rows
+ i
;
1927 struct glyph_row
*to
= saved
->rows
+ i
;
1928 ptrdiff_t nbytes
= from
->used
[TEXT_AREA
] * sizeof (struct glyph
);
1929 to
->glyphs
[TEXT_AREA
] = xmalloc (nbytes
);
1930 memcpy (to
->glyphs
[TEXT_AREA
], from
->glyphs
[TEXT_AREA
], nbytes
);
1931 to
->used
[TEXT_AREA
] = from
->used
[TEXT_AREA
];
1938 /* Restore the contents of frame F's current frame matrix from SAVED,
1939 and free memory associated with SAVED. */
1942 restore_current_matrix (struct frame
*f
, struct glyph_matrix
*saved
)
1946 for (i
= 0; i
< saved
->nrows
; ++i
)
1948 struct glyph_row
*from
= saved
->rows
+ i
;
1949 struct glyph_row
*to
= f
->current_matrix
->rows
+ i
;
1950 ptrdiff_t nbytes
= from
->used
[TEXT_AREA
] * sizeof (struct glyph
);
1951 memcpy (to
->glyphs
[TEXT_AREA
], from
->glyphs
[TEXT_AREA
], nbytes
);
1952 to
->used
[TEXT_AREA
] = from
->used
[TEXT_AREA
];
1953 xfree (from
->glyphs
[TEXT_AREA
]);
1956 xfree (saved
->rows
);
1962 /* Allocate/reallocate glyph matrices of a single frame F for
1963 frame-based redisplay. */
1966 adjust_frame_glyphs_for_frame_redisplay (struct frame
*f
)
1968 struct dim matrix_dim
;
1969 bool pool_changed_p
;
1970 int window_change_flags
;
1973 if (!FRAME_LIVE_P (f
))
1976 top_window_y
= FRAME_TOP_MARGIN (f
);
1978 /* Allocate glyph pool structures if not already done. */
1979 if (f
->desired_pool
== NULL
)
1981 f
->desired_pool
= new_glyph_pool ();
1982 f
->current_pool
= new_glyph_pool ();
1985 /* Allocate frames matrix structures if needed. */
1986 if (f
->desired_matrix
== NULL
)
1988 f
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1989 f
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1992 /* Compute window glyph matrices. (This takes the mini-buffer
1993 window into account). The result is the size of the frame glyph
1994 matrix needed. The variable window_change_flags is set to a bit
1995 mask indicating whether new matrices will be allocated or
1996 existing matrices change their size or location within the frame
1998 window_change_flags
= 0;
2000 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2003 &window_change_flags
);
2005 /* Add in menu bar lines, if any. */
2006 matrix_dim
.height
+= top_window_y
;
2008 /* Enlarge pools as necessary. */
2009 pool_changed_p
= realloc_glyph_pool (f
->desired_pool
, matrix_dim
);
2010 realloc_glyph_pool (f
->current_pool
, matrix_dim
);
2012 /* Set up glyph pointers within window matrices. Do this only if
2013 absolutely necessary since it requires a frame redraw. */
2014 if (pool_changed_p
|| window_change_flags
)
2016 /* Do it for window matrices. */
2017 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2019 &window_change_flags
);
2021 /* Size of frame matrices must equal size of frame. Note
2022 that we are called for X frames with window widths NOT equal
2023 to the frame width (from CHANGE_FRAME_SIZE_1). */
2024 eassert (matrix_dim
.width
== FRAME_COLS (f
)
2025 && matrix_dim
.height
== FRAME_LINES (f
));
2027 /* Pointers to glyph memory in glyph rows are exchanged during
2028 the update phase of redisplay, which means in general that a
2029 frame's current matrix consists of pointers into both the
2030 desired and current glyph pool of the frame. Adjusting a
2031 matrix sets the frame matrix up so that pointers are all into
2032 the same pool. If we want to preserve glyph contents of the
2033 current matrix over a call to adjust_glyph_matrix, we must
2034 make a copy of the current glyphs, and restore the current
2035 matrix' contents from that copy. */
2036 if (display_completed
2037 && !FRAME_GARBAGED_P (f
)
2038 && matrix_dim
.width
== f
->current_matrix
->matrix_w
2039 && matrix_dim
.height
== f
->current_matrix
->matrix_h
2040 /* For some reason, the frame glyph matrix gets corrupted if
2041 any of the windows contain margins. I haven't been able
2042 to hunt down the reason, but for the moment this prevents
2043 the problem from manifesting. -- cyd */
2044 && !showing_window_margins_p (XWINDOW (FRAME_ROOT_WINDOW (f
))))
2046 struct glyph_matrix
*copy
= save_current_matrix (f
);
2047 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2048 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2049 restore_current_matrix (f
, copy
);
2050 fake_current_matrices (FRAME_ROOT_WINDOW (f
));
2054 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2055 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2056 SET_FRAME_GARBAGED (f
);
2062 /* Allocate/reallocate glyph matrices of a single frame F for
2063 window-based redisplay. */
2066 adjust_frame_glyphs_for_window_redisplay (struct frame
*f
)
2068 eassert (FRAME_WINDOW_P (f
) && FRAME_LIVE_P (f
));
2070 /* Allocate/reallocate window matrices. */
2071 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2073 #ifdef HAVE_X_WINDOWS
2074 /* Allocate/ reallocate matrices of the dummy window used to display
2075 the menu bar under X when no X toolkit support is available. */
2076 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
2078 /* Allocate a dummy window if not already done. */
2080 if (NILP (f
->menu_bar_window
))
2083 fset_menu_bar_window (f
, make_window ());
2084 w
= XWINDOW (f
->menu_bar_window
);
2085 XSETFRAME (frame
, f
);
2086 wset_frame (w
, frame
);
2087 w
->pseudo_window_p
= 1;
2090 w
= XWINDOW (f
->menu_bar_window
);
2092 /* Set window dimensions to frame dimensions and allocate or
2093 adjust glyph matrices of W. */
2096 w
->total_lines
= FRAME_MENU_BAR_LINES (f
);
2097 w
->total_cols
= FRAME_TOTAL_COLS (f
);
2098 allocate_matrices_for_window_redisplay (w
);
2100 #endif /* not USE_X_TOOLKIT && not USE_GTK */
2101 #endif /* HAVE_X_WINDOWS */
2105 /* Allocate/ reallocate matrices of the tool bar window. If we
2106 don't have a tool bar window yet, make one. */
2108 if (NILP (f
->tool_bar_window
))
2111 fset_tool_bar_window (f
, make_window ());
2112 w
= XWINDOW (f
->tool_bar_window
);
2113 XSETFRAME (frame
, f
);
2114 wset_frame (w
, frame
);
2115 w
->pseudo_window_p
= 1;
2118 w
= XWINDOW (f
->tool_bar_window
);
2120 w
->top_line
= FRAME_MENU_BAR_LINES (f
);
2122 w
->total_lines
= FRAME_TOOL_BAR_LINES (f
);
2123 w
->total_cols
= FRAME_TOTAL_COLS (f
);
2124 allocate_matrices_for_window_redisplay (w
);
2130 /* Re-allocate buffer for decode_mode_spec on frame F. */
2133 adjust_decode_mode_spec_buffer (struct frame
*f
)
2135 f
->decode_mode_spec_buffer
= xrealloc (f
->decode_mode_spec_buffer
,
2136 FRAME_MESSAGE_BUF_SIZE (f
) + 1);
2141 /**********************************************************************
2142 Freeing Glyph Matrices
2143 **********************************************************************/
2145 /* Free glyph memory for a frame F. F may be null. This function can
2146 be called for the same frame more than once. The root window of
2147 F may be nil when this function is called. This is the case when
2148 the function is called when F is destroyed. */
2151 free_glyphs (struct frame
*f
)
2153 if (f
&& f
->glyphs_initialized_p
)
2155 /* Block interrupt input so that we don't get surprised by an X
2156 event while we're in an inconsistent state. */
2158 f
->glyphs_initialized_p
= 0;
2160 /* Release window sub-matrices. */
2161 if (!NILP (f
->root_window
))
2162 free_window_matrices (XWINDOW (f
->root_window
));
2164 #if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
2165 /* Free the dummy window for menu bars without X toolkit and its
2167 if (!NILP (f
->menu_bar_window
))
2169 struct window
*w
= XWINDOW (f
->menu_bar_window
);
2170 free_glyph_matrix (w
->desired_matrix
);
2171 free_glyph_matrix (w
->current_matrix
);
2172 w
->desired_matrix
= w
->current_matrix
= NULL
;
2173 fset_menu_bar_window (f
, Qnil
);
2177 /* Free the tool bar window and its glyph matrices. */
2178 if (!NILP (f
->tool_bar_window
))
2180 struct window
*w
= XWINDOW (f
->tool_bar_window
);
2181 free_glyph_matrix (w
->desired_matrix
);
2182 free_glyph_matrix (w
->current_matrix
);
2183 w
->desired_matrix
= w
->current_matrix
= NULL
;
2184 fset_tool_bar_window (f
, Qnil
);
2187 /* Release frame glyph matrices. Reset fields to zero in
2188 case we are called a second time. */
2189 if (f
->desired_matrix
)
2191 free_glyph_matrix (f
->desired_matrix
);
2192 free_glyph_matrix (f
->current_matrix
);
2193 f
->desired_matrix
= f
->current_matrix
= NULL
;
2196 /* Release glyph pools. */
2197 if (f
->desired_pool
)
2199 free_glyph_pool (f
->desired_pool
);
2200 free_glyph_pool (f
->current_pool
);
2201 f
->desired_pool
= f
->current_pool
= NULL
;
2209 /* Free glyph sub-matrices in the window tree rooted at W. This
2210 function may be called with a null pointer, and it may be called on
2211 the same tree more than once. */
2214 free_window_matrices (struct window
*w
)
2218 if (WINDOWP (w
->contents
))
2219 free_window_matrices (XWINDOW (w
->contents
));
2222 /* This is a leaf window. Free its memory and reset fields
2223 to zero in case this function is called a second time for
2225 free_glyph_matrix (w
->current_matrix
);
2226 free_glyph_matrix (w
->desired_matrix
);
2227 w
->current_matrix
= w
->desired_matrix
= NULL
;
2230 /* Next window on same level. */
2231 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2236 /* Check glyph memory leaks. This function is called from
2237 shut_down_emacs. Note that frames are not destroyed when Emacs
2238 exits. We therefore free all glyph memory for all active frames
2239 explicitly and check that nothing is left allocated. */
2242 check_glyph_memory (void)
2244 Lisp_Object tail
, frame
;
2246 /* Free glyph memory for all frames. */
2247 FOR_EACH_FRAME (tail
, frame
)
2248 free_glyphs (XFRAME (frame
));
2250 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
2251 /* Check that nothing is left allocated. */
2252 eassert (glyph_matrix_count
== 0);
2253 eassert (glyph_pool_count
== 0);
2259 /**********************************************************************
2260 Building a Frame Matrix
2261 **********************************************************************/
2263 /* Most of the redisplay code works on glyph matrices attached to
2264 windows. This is a good solution most of the time, but it is not
2265 suitable for terminal code. Terminal output functions cannot rely
2266 on being able to set an arbitrary terminal window. Instead they
2267 must be provided with a view of the whole frame, i.e. the whole
2268 screen. We build such a view by constructing a frame matrix from
2269 window matrices in this section.
2271 Windows that must be updated have their must_be_updated_p flag set.
2272 For all such windows, their desired matrix is made part of the
2273 desired frame matrix. For other windows, their current matrix is
2274 made part of the desired frame matrix.
2276 +-----------------+----------------+
2277 | desired | desired |
2279 +-----------------+----------------+
2282 +----------------------------------+
2284 Desired window matrices can be made part of the frame matrix in a
2285 cheap way: We exploit the fact that the desired frame matrix and
2286 desired window matrices share their glyph memory. This is not
2287 possible for current window matrices. Their glyphs are copied to
2288 the desired frame matrix. The latter is equivalent to
2289 preserve_other_columns in the old redisplay.
2291 Used glyphs counters for frame matrix rows are the result of adding
2292 up glyph lengths of the window matrices. A line in the frame
2293 matrix is enabled, if a corresponding line in a window matrix is
2296 After building the desired frame matrix, it will be passed to
2297 terminal code, which will manipulate both the desired and current
2298 frame matrix. Changes applied to the frame's current matrix have
2299 to be visible in current window matrices afterwards, of course.
2301 This problem is solved like this:
2303 1. Window and frame matrices share glyphs. Window matrices are
2304 constructed in a way that their glyph contents ARE the glyph
2305 contents needed in a frame matrix. Thus, any modification of
2306 glyphs done in terminal code will be reflected in window matrices
2309 2. Exchanges of rows in a frame matrix done by terminal code are
2310 intercepted by hook functions so that corresponding row operations
2311 on window matrices can be performed. This is necessary because we
2312 use pointers to glyphs in glyph row structures. To satisfy the
2313 assumption of point 1 above that glyphs are updated implicitly in
2314 window matrices when they are manipulated via the frame matrix,
2315 window and frame matrix must of course agree where to find the
2316 glyphs for their rows. Possible manipulations that must be
2317 mirrored are assignments of rows of the desired frame matrix to the
2318 current frame matrix and scrolling the current frame matrix. */
2320 /* Build frame F's desired matrix from window matrices. Only windows
2321 which have the flag must_be_updated_p set have to be updated. Menu
2322 bar lines of a frame are not covered by window matrices, so make
2323 sure not to touch them in this function. */
2326 build_frame_matrix (struct frame
*f
)
2330 /* F must have a frame matrix when this function is called. */
2331 eassert (!FRAME_WINDOW_P (f
));
2333 /* Clear all rows in the frame matrix covered by window matrices.
2334 Menu bar lines are not covered by windows. */
2335 for (i
= FRAME_TOP_MARGIN (f
); i
< f
->desired_matrix
->nrows
; ++i
)
2336 clear_glyph_row (MATRIX_ROW (f
->desired_matrix
, i
));
2338 /* Build the matrix by walking the window tree. */
2339 build_frame_matrix_from_window_tree (f
->desired_matrix
,
2340 XWINDOW (FRAME_ROOT_WINDOW (f
)));
2344 /* Walk a window tree, building a frame matrix MATRIX from window
2345 matrices. W is the root of a window tree. */
2348 build_frame_matrix_from_window_tree (struct glyph_matrix
*matrix
, struct window
*w
)
2352 if (WINDOWP (w
->contents
))
2353 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->contents
));
2355 build_frame_matrix_from_leaf_window (matrix
, w
);
2357 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2362 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2363 desired frame matrix built. W is a leaf window whose desired or
2364 current matrix is to be added to FRAME_MATRIX. W's flag
2365 must_be_updated_p determines which matrix it contributes to
2366 FRAME_MATRIX. If W->must_be_updated_p, W's desired matrix
2367 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2368 Adding a desired matrix means setting up used counters and such in
2369 frame rows, while adding a current window matrix to FRAME_MATRIX
2370 means copying glyphs. The latter case corresponds to
2371 preserve_other_columns in the old redisplay. */
2374 build_frame_matrix_from_leaf_window (struct glyph_matrix
*frame_matrix
, struct window
*w
)
2376 struct glyph_matrix
*window_matrix
;
2377 int window_y
, frame_y
;
2378 /* If non-zero, a glyph to insert at the right border of W. */
2379 GLYPH right_border_glyph
;
2381 SET_GLYPH_FROM_CHAR (right_border_glyph
, 0);
2383 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2384 if (w
->must_be_updated_p
)
2386 window_matrix
= w
->desired_matrix
;
2388 /* Decide whether we want to add a vertical border glyph. */
2389 if (!WINDOW_RIGHTMOST_P (w
))
2391 struct Lisp_Char_Table
*dp
= window_display_table (w
);
2394 SET_GLYPH_FROM_CHAR (right_border_glyph
, '|');
2396 && (gc
= DISP_BORDER_GLYPH (dp
), GLYPH_CODE_P (gc
)))
2398 SET_GLYPH_FROM_GLYPH_CODE (right_border_glyph
, gc
);
2399 spec_glyph_lookup_face (w
, &right_border_glyph
);
2402 if (GLYPH_FACE (right_border_glyph
) <= 0)
2403 SET_GLYPH_FACE (right_border_glyph
, VERTICAL_BORDER_FACE_ID
);
2407 window_matrix
= w
->current_matrix
;
2409 /* For all rows in the window matrix and corresponding rows in the
2412 frame_y
= window_matrix
->matrix_y
;
2413 while (window_y
< window_matrix
->nrows
)
2415 struct glyph_row
*frame_row
= frame_matrix
->rows
+ frame_y
;
2416 struct glyph_row
*window_row
= window_matrix
->rows
+ window_y
;
2417 bool current_row_p
= window_matrix
== w
->current_matrix
;
2419 /* Fill up the frame row with spaces up to the left margin of the
2421 fill_up_frame_row_with_spaces (frame_row
, window_matrix
->matrix_x
);
2423 /* Fill up areas in the window matrix row with spaces. */
2424 fill_up_glyph_row_with_spaces (window_row
);
2426 /* If only part of W's desired matrix has been built, and
2427 window_row wasn't displayed, use the corresponding current
2429 if (window_matrix
== w
->desired_matrix
2430 && !window_row
->enabled_p
)
2432 window_row
= w
->current_matrix
->rows
+ window_y
;
2438 /* Copy window row to frame row. */
2439 memcpy (frame_row
->glyphs
[TEXT_AREA
] + window_matrix
->matrix_x
,
2440 window_row
->glyphs
[0],
2441 window_matrix
->matrix_w
* sizeof (struct glyph
));
2445 eassert (window_row
->enabled_p
);
2447 /* Only when a desired row has been displayed, we want
2448 the corresponding frame row to be updated. */
2449 frame_row
->enabled_p
= 1;
2451 /* Maybe insert a vertical border between horizontally adjacent
2453 if (GLYPH_CHAR (right_border_glyph
) != 0)
2455 struct glyph
*border
= window_row
->glyphs
[LAST_AREA
] - 1;
2456 SET_CHAR_GLYPH_FROM_GLYPH (*border
, right_border_glyph
);
2460 /* Window row window_y must be a slice of frame row
2462 eassert (glyph_row_slice_p (window_row
, frame_row
));
2464 /* If rows are in sync, we don't have to copy glyphs because
2465 frame and window share glyphs. */
2467 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
2468 add_window_display_history (w
, w
->current_matrix
->method
, 0);
2472 /* Set number of used glyphs in the frame matrix. Since we fill
2473 up with spaces, and visit leaf windows from left to right it
2474 can be done simply. */
2475 frame_row
->used
[TEXT_AREA
]
2476 = window_matrix
->matrix_x
+ window_matrix
->matrix_w
;
2484 /* Given a user-specified glyph, possibly including a Lisp-level face
2485 ID, return a glyph that has a realized face ID.
2486 This is used for glyphs displayed specially and not part of the text;
2487 for instance, vertical separators, truncation markers, etc. */
2490 spec_glyph_lookup_face (struct window
*w
, GLYPH
*glyph
)
2492 int lface_id
= GLYPH_FACE (*glyph
);
2493 /* Convert the glyph's specified face to a realized (cache) face. */
2496 int face_id
= merge_faces (XFRAME (w
->frame
),
2497 Qt
, lface_id
, DEFAULT_FACE_ID
);
2498 SET_GLYPH_FACE (*glyph
, face_id
);
2502 /* Add spaces to a glyph row ROW in a window matrix.
2504 Each row has the form:
2506 +---------+-----------------------------+------------+
2507 | left | text | right |
2508 +---------+-----------------------------+------------+
2510 Left and right marginal areas are optional. This function adds
2511 spaces to areas so that there are no empty holes between areas.
2512 In other words: If the right area is not empty, the text area
2513 is filled up with spaces up to the right area. If the text area
2514 is not empty, the left area is filled up.
2516 To be called for frame-based redisplay, only. */
2519 fill_up_glyph_row_with_spaces (struct glyph_row
*row
)
2521 fill_up_glyph_row_area_with_spaces (row
, LEFT_MARGIN_AREA
);
2522 fill_up_glyph_row_area_with_spaces (row
, TEXT_AREA
);
2523 fill_up_glyph_row_area_with_spaces (row
, RIGHT_MARGIN_AREA
);
2527 /* Fill area AREA of glyph row ROW with spaces. To be called for
2528 frame-based redisplay only. */
2531 fill_up_glyph_row_area_with_spaces (struct glyph_row
*row
, int area
)
2533 if (row
->glyphs
[area
] < row
->glyphs
[area
+ 1])
2535 struct glyph
*end
= row
->glyphs
[area
+ 1];
2536 struct glyph
*text
= row
->glyphs
[area
] + row
->used
[area
];
2539 *text
++ = space_glyph
;
2540 row
->used
[area
] = text
- row
->glyphs
[area
];
2545 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2546 reached. In frame matrices only one area, TEXT_AREA, is used. */
2549 fill_up_frame_row_with_spaces (struct glyph_row
*row
, int upto
)
2551 int i
= row
->used
[TEXT_AREA
];
2552 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
2555 glyph
[i
++] = space_glyph
;
2557 row
->used
[TEXT_AREA
] = i
;
2562 /**********************************************************************
2563 Mirroring operations on frame matrices in window matrices
2564 **********************************************************************/
2566 /* Set frame being updated via frame-based redisplay to F. This
2567 function must be called before updates to make explicit that we are
2568 working on frame matrices or not. */
2571 set_frame_matrix_frame (struct frame
*f
)
2573 frame_matrix_frame
= f
;
2577 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2578 DESIRED_MATRIX is the desired matrix corresponding to
2579 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2580 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2581 frame_matrix_frame is non-null, this indicates that the exchange is
2582 done in frame matrices, and that we have to perform analogous
2583 operations in window matrices of frame_matrix_frame. */
2586 make_current (struct glyph_matrix
*desired_matrix
, struct glyph_matrix
*current_matrix
, int row
)
2588 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, row
);
2589 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, row
);
2590 bool mouse_face_p
= current_row
->mouse_face_p
;
2592 /* Do current_row = desired_row. This exchanges glyph pointers
2593 between both rows, and does a structure assignment otherwise. */
2594 assign_row (current_row
, desired_row
);
2596 /* Enable current_row to mark it as valid. */
2597 current_row
->enabled_p
= 1;
2598 current_row
->mouse_face_p
= mouse_face_p
;
2600 /* If we are called on frame matrices, perform analogous operations
2601 for window matrices. */
2602 if (frame_matrix_frame
)
2603 mirror_make_current (XWINDOW (frame_matrix_frame
->root_window
), row
);
2607 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2608 W's frame which has been made current (by swapping pointers between
2609 current and desired matrix). Perform analogous operations in the
2610 matrices of leaf windows in the window tree rooted at W. */
2613 mirror_make_current (struct window
*w
, int frame_row
)
2617 if (WINDOWP (w
->contents
))
2618 mirror_make_current (XWINDOW (w
->contents
), frame_row
);
2621 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2622 here because the checks performed in debug mode there
2623 will not allow the conversion. */
2624 int row
= frame_row
- w
->desired_matrix
->matrix_y
;
2626 /* If FRAME_ROW is within W, assign the desired row to the
2627 current row (exchanging glyph pointers). */
2628 if (row
>= 0 && row
< w
->desired_matrix
->matrix_h
)
2630 struct glyph_row
*current_row
2631 = MATRIX_ROW (w
->current_matrix
, row
);
2632 struct glyph_row
*desired_row
2633 = MATRIX_ROW (w
->desired_matrix
, row
);
2635 if (desired_row
->enabled_p
)
2636 assign_row (current_row
, desired_row
);
2638 swap_glyph_pointers (desired_row
, current_row
);
2639 current_row
->enabled_p
= 1;
2641 /* Set the Y coordinate of the mode/header line's row.
2642 It is needed in draw_row_with_mouse_face to find the
2643 screen coordinates. (Window-based redisplay sets
2644 this in update_window, but no one seems to do that
2645 for frame-based redisplay.) */
2646 if (current_row
->mode_line_p
)
2647 current_row
->y
= row
;
2651 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2656 /* Perform row dance after scrolling. We are working on the range of
2657 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2658 including) in MATRIX. COPY_FROM is a vector containing, for each
2659 row I in the range 0 <= I < NLINES, the index of the original line
2660 to move to I. This index is relative to the row range, i.e. 0 <=
2661 index < NLINES. RETAINED_P is a vector containing zero for each
2662 row 0 <= I < NLINES which is empty.
2664 This function is called from do_scrolling and do_direct_scrolling. */
2667 mirrored_line_dance (struct glyph_matrix
*matrix
, int unchanged_at_top
, int nlines
,
2668 int *copy_from
, char *retained_p
)
2670 /* A copy of original rows. */
2671 struct glyph_row
*old_rows
;
2673 /* Rows to assign to. */
2674 struct glyph_row
*new_rows
= MATRIX_ROW (matrix
, unchanged_at_top
);
2678 /* Make a copy of the original rows. */
2679 old_rows
= alloca (nlines
* sizeof *old_rows
);
2680 memcpy (old_rows
, new_rows
, nlines
* sizeof *old_rows
);
2682 /* Assign new rows, maybe clear lines. */
2683 for (i
= 0; i
< nlines
; ++i
)
2685 bool enabled_before_p
= new_rows
[i
].enabled_p
;
2687 eassert (i
+ unchanged_at_top
< matrix
->nrows
);
2688 eassert (unchanged_at_top
+ copy_from
[i
] < matrix
->nrows
);
2689 new_rows
[i
] = old_rows
[copy_from
[i
]];
2690 new_rows
[i
].enabled_p
= enabled_before_p
;
2692 /* RETAINED_P is zero for empty lines. */
2693 if (!retained_p
[copy_from
[i
]])
2694 new_rows
[i
].enabled_p
= 0;
2697 /* Do the same for window matrices, if MATRIX is a frame matrix. */
2698 if (frame_matrix_frame
)
2699 mirror_line_dance (XWINDOW (frame_matrix_frame
->root_window
),
2700 unchanged_at_top
, nlines
, copy_from
, retained_p
);
2704 /* Synchronize glyph pointers in the current matrix of window W with
2705 the current frame matrix. */
2708 sync_window_with_frame_matrix_rows (struct window
*w
)
2710 struct frame
*f
= XFRAME (w
->frame
);
2711 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
2712 int left
, right
, x
, width
;
2714 /* Preconditions: W must be a live window on a tty frame. */
2715 eassert (BUFFERP (w
->contents
));
2716 eassert (!FRAME_WINDOW_P (f
));
2718 left
= margin_glyphs_to_reserve (w
, 1, w
->left_margin_cols
);
2719 right
= margin_glyphs_to_reserve (w
, 1, w
->right_margin_cols
);
2720 x
= w
->current_matrix
->matrix_x
;
2721 width
= w
->current_matrix
->matrix_w
;
2723 window_row
= w
->current_matrix
->rows
;
2724 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
2725 frame_row
= f
->current_matrix
->rows
+ WINDOW_TOP_EDGE_LINE (w
);
2727 for (; window_row
< window_row_end
; ++window_row
, ++frame_row
)
2729 window_row
->glyphs
[LEFT_MARGIN_AREA
]
2730 = frame_row
->glyphs
[0] + x
;
2731 window_row
->glyphs
[TEXT_AREA
]
2732 = window_row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
2733 window_row
->glyphs
[LAST_AREA
]
2734 = window_row
->glyphs
[LEFT_MARGIN_AREA
] + width
;
2735 window_row
->glyphs
[RIGHT_MARGIN_AREA
]
2736 = window_row
->glyphs
[LAST_AREA
] - right
;
2741 /* Return the window in the window tree rooted in W containing frame
2742 row ROW. Value is null if none is found. */
2744 static struct window
*
2745 frame_row_to_window (struct window
*w
, int row
)
2747 struct window
*found
= NULL
;
2751 if (WINDOWP (w
->contents
))
2752 found
= frame_row_to_window (XWINDOW (w
->contents
), row
);
2753 else if (row
>= WINDOW_TOP_EDGE_LINE (w
)
2754 && row
< WINDOW_BOTTOM_EDGE_LINE (w
))
2757 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2764 /* Perform a line dance in the window tree rooted at W, after
2765 scrolling a frame matrix in mirrored_line_dance.
2767 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
2768 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
2769 COPY_FROM is a vector containing, for each row I in the range 0 <=
2770 I < NLINES, the index of the original line to move to I. This
2771 index is relative to the row range, i.e. 0 <= index < NLINES.
2772 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
2776 mirror_line_dance (struct window
*w
, int unchanged_at_top
, int nlines
, int *copy_from
, char *retained_p
)
2780 if (WINDOWP (w
->contents
))
2781 mirror_line_dance (XWINDOW (w
->contents
), unchanged_at_top
,
2782 nlines
, copy_from
, retained_p
);
2785 /* W is a leaf window, and we are working on its current
2787 struct glyph_matrix
*m
= w
->current_matrix
;
2790 struct glyph_row
*old_rows
;
2792 /* Make a copy of the original rows of matrix m. */
2793 old_rows
= alloca (m
->nrows
* sizeof *old_rows
);
2794 memcpy (old_rows
, m
->rows
, m
->nrows
* sizeof *old_rows
);
2796 for (i
= 0; i
< nlines
; ++i
)
2798 /* Frame relative line assigned to. */
2799 int frame_to
= i
+ unchanged_at_top
;
2801 /* Frame relative line assigned. */
2802 int frame_from
= copy_from
[i
] + unchanged_at_top
;
2804 /* Window relative line assigned to. */
2805 int window_to
= frame_to
- m
->matrix_y
;
2807 /* Window relative line assigned. */
2808 int window_from
= frame_from
- m
->matrix_y
;
2810 /* Is assigned line inside window? */
2811 bool from_inside_window_p
2812 = window_from
>= 0 && window_from
< m
->matrix_h
;
2814 /* Is assigned to line inside window? */
2815 bool to_inside_window_p
2816 = window_to
>= 0 && window_to
< m
->matrix_h
;
2818 if (from_inside_window_p
&& to_inside_window_p
)
2820 /* Do the assignment. The enabled_p flag is saved
2821 over the assignment because the old redisplay did
2823 bool enabled_before_p
= m
->rows
[window_to
].enabled_p
;
2824 m
->rows
[window_to
] = old_rows
[window_from
];
2825 m
->rows
[window_to
].enabled_p
= enabled_before_p
;
2827 /* If frame line is empty, window line is empty, too. */
2828 if (!retained_p
[copy_from
[i
]])
2829 m
->rows
[window_to
].enabled_p
= 0;
2831 else if (to_inside_window_p
)
2833 /* A copy between windows. This is an infrequent
2834 case not worth optimizing. */
2835 struct frame
*f
= XFRAME (w
->frame
);
2836 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
2838 struct glyph_matrix
*m2
;
2841 w2
= frame_row_to_window (root
, frame_from
);
2842 /* ttn@surf.glug.org: when enabling menu bar using `emacs
2843 -nw', FROM_FRAME sometimes has no associated window.
2844 This check avoids a segfault if W2 is null. */
2847 m2
= w2
->current_matrix
;
2848 m2_from
= frame_from
- m2
->matrix_y
;
2849 copy_row_except_pointers (m
->rows
+ window_to
,
2850 m2
->rows
+ m2_from
);
2852 /* If frame line is empty, window line is empty, too. */
2853 if (!retained_p
[copy_from
[i
]])
2854 m
->rows
[window_to
].enabled_p
= 0;
2858 else if (from_inside_window_p
)
2862 /* If there was a copy between windows, make sure glyph
2863 pointers are in sync with the frame matrix. */
2865 sync_window_with_frame_matrix_rows (w
);
2867 /* Check that no pointers are lost. */
2871 /* Next window on same level. */
2872 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2879 /* Check that window and frame matrices agree about their
2880 understanding where glyphs of the rows are to find. For each
2881 window in the window tree rooted at W, check that rows in the
2882 matrices of leaf window agree with their frame matrices about
2886 check_window_matrix_pointers (struct window
*w
)
2890 if (WINDOWP (w
->contents
))
2891 check_window_matrix_pointers (XWINDOW (w
->contents
));
2894 struct frame
*f
= XFRAME (w
->frame
);
2895 check_matrix_pointers (w
->desired_matrix
, f
->desired_matrix
);
2896 check_matrix_pointers (w
->current_matrix
, f
->current_matrix
);
2899 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2904 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
2905 a window and FRAME_MATRIX is the corresponding frame matrix. For
2906 each row in WINDOW_MATRIX check that it's a slice of the
2907 corresponding frame row. If it isn't, abort. */
2910 check_matrix_pointers (struct glyph_matrix
*window_matrix
,
2911 struct glyph_matrix
*frame_matrix
)
2913 /* Row number in WINDOW_MATRIX. */
2916 /* Row number corresponding to I in FRAME_MATRIX. */
2917 int j
= window_matrix
->matrix_y
;
2919 /* For all rows check that the row in the window matrix is a
2920 slice of the row in the frame matrix. If it isn't we didn't
2921 mirror an operation on the frame matrix correctly. */
2922 while (i
< window_matrix
->nrows
)
2924 if (!glyph_row_slice_p (window_matrix
->rows
+ i
,
2925 frame_matrix
->rows
+ j
))
2931 #endif /* GLYPH_DEBUG */
2935 /**********************************************************************
2936 VPOS and HPOS translations
2937 **********************************************************************/
2941 /* Translate vertical position VPOS which is relative to window W to a
2942 vertical position relative to W's frame. */
2945 window_to_frame_vpos (struct window
*w
, int vpos
)
2947 eassert (!FRAME_WINDOW_P (XFRAME (w
->frame
)));
2948 eassert (vpos
>= 0 && vpos
<= w
->desired_matrix
->nrows
);
2949 vpos
+= WINDOW_TOP_EDGE_LINE (w
);
2950 eassert (vpos
>= 0 && vpos
<= FRAME_LINES (XFRAME (w
->frame
)));
2955 /* Translate horizontal position HPOS which is relative to window W to
2956 a horizontal position relative to W's frame. */
2959 window_to_frame_hpos (struct window
*w
, int hpos
)
2961 eassert (!FRAME_WINDOW_P (XFRAME (w
->frame
)));
2962 hpos
+= WINDOW_LEFT_EDGE_COL (w
);
2966 #endif /* GLYPH_DEBUG */
2970 /**********************************************************************
2972 **********************************************************************/
2974 /* Redraw frame F. */
2977 redraw_frame (struct frame
*f
)
2979 /* Error if F has no glyphs. */
2980 eassert (f
->glyphs_initialized_p
);
2983 if (FRAME_MSDOS_P (f
))
2984 FRAME_TERMINAL (f
)->set_terminal_modes_hook (FRAME_TERMINAL (f
));
2987 clear_current_matrices (f
);
2989 if (FRAME_TERMCAP_P (f
))
2990 fflush (FRAME_TTY (f
)->output
);
2991 windows_or_buffers_changed
++;
2992 /* Mark all windows as inaccurate, so that every window will have
2993 its redisplay done. */
2994 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
2995 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
2999 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 0, 1, 0,
3000 doc
: /* Clear frame FRAME and output again what is supposed to appear on it.
3001 If FRAME is omitted or nil, the selected frame is used. */)
3004 redraw_frame (decode_live_frame (frame
));
3008 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
3009 doc
: /* Clear and redisplay all visible frames. */)
3012 Lisp_Object tail
, frame
;
3014 FOR_EACH_FRAME (tail
, frame
)
3015 if (FRAME_VISIBLE_P (XFRAME (frame
)))
3016 redraw_frame (XFRAME (frame
));
3023 /***********************************************************************
3025 ***********************************************************************/
3027 /* Update frame F based on the data in desired matrices.
3029 If FORCE_P, don't let redisplay be stopped by detecting pending input.
3030 If INHIBIT_HAIRY_ID_P, don't try scrolling.
3032 Value is true if redisplay was stopped due to pending input. */
3035 update_frame (struct frame
*f
, bool force_p
, bool inhibit_hairy_id_p
)
3037 /* True means display has been paused because of pending input. */
3039 struct window
*root_window
= XWINDOW (f
->root_window
);
3041 if (redisplay_dont_pause
)
3043 else if (!force_p
&& detect_input_pending_ignore_squeezables ())
3049 if (FRAME_WINDOW_P (f
))
3051 /* We are working on window matrix basis. All windows whose
3052 flag must_be_updated_p is set have to be updated. */
3054 /* Record that we are not working on frame matrices. */
3055 set_frame_matrix_frame (NULL
);
3057 /* Update all windows in the window tree of F, maybe stopping
3058 when pending input is detected. */
3061 #if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
3062 /* Update the menu bar on X frames that don't have toolkit
3064 if (WINDOWP (f
->menu_bar_window
))
3065 update_window (XWINDOW (f
->menu_bar_window
), 1);
3068 /* Update the tool-bar window, if present. */
3069 if (WINDOWP (f
->tool_bar_window
))
3071 struct window
*w
= XWINDOW (f
->tool_bar_window
);
3073 /* Update tool-bar window. */
3074 if (w
->must_be_updated_p
)
3078 update_window (w
, 1);
3079 w
->must_be_updated_p
= 0;
3081 /* Swap tool-bar strings. We swap because we want to
3083 tem
= f
->current_tool_bar_string
;
3084 fset_current_tool_bar_string (f
, f
->desired_tool_bar_string
);
3085 fset_desired_tool_bar_string (f
, tem
);
3090 /* Update windows. */
3091 paused_p
= update_window_tree (root_window
, force_p
);
3094 /* This flush is a performance bottleneck under X,
3095 and it doesn't seem to be necessary anyway (in general).
3096 It is necessary when resizing the window with the mouse, or
3097 at least the fringes are not redrawn in a timely manner. ++kfs */
3098 if (f
->force_flush_display_p
)
3100 FRAME_RIF (f
)->flush_display (f
);
3101 f
->force_flush_display_p
= 0;
3106 /* We are working on frame matrix basis. Set the frame on whose
3107 frame matrix we operate. */
3108 set_frame_matrix_frame (f
);
3110 /* Build F's desired matrix from window matrices. */
3111 build_frame_matrix (f
);
3113 /* Update the display */
3115 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3118 if (FRAME_TERMCAP_P (f
) || FRAME_MSDOS_P (f
))
3120 if (FRAME_TTY (f
)->termscript
)
3121 fflush (FRAME_TTY (f
)->termscript
);
3122 if (FRAME_TERMCAP_P (f
))
3123 fflush (FRAME_TTY (f
)->output
);
3126 /* Check window matrices for lost pointers. */
3128 check_window_matrix_pointers (root_window
);
3129 add_frame_display_history (f
, paused_p
);
3134 /* Reset flags indicating that a window should be updated. */
3135 set_window_update_flags (root_window
, 0);
3137 display_completed
= !paused_p
;
3143 /************************************************************************
3144 Window-based updates
3145 ************************************************************************/
3147 /* Perform updates in window tree rooted at W.
3148 If FORCE_P, don't stop updating if input is pending. */
3151 update_window_tree (struct window
*w
, bool force_p
)
3155 while (w
&& !paused_p
)
3157 if (WINDOWP (w
->contents
))
3158 paused_p
|= update_window_tree (XWINDOW (w
->contents
), force_p
);
3159 else if (w
->must_be_updated_p
)
3160 paused_p
|= update_window (w
, force_p
);
3162 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3169 /* Update window W if its flag must_be_updated_p is set.
3170 If FORCE_P, don't stop updating if input is pending. */
3173 update_single_window (struct window
*w
, bool force_p
)
3175 if (w
->must_be_updated_p
)
3177 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3179 /* Record that this is not a frame-based redisplay. */
3180 set_frame_matrix_frame (NULL
);
3182 if (redisplay_dont_pause
)
3187 update_window (w
, force_p
);
3190 /* Reset flag in W. */
3191 w
->must_be_updated_p
= 0;
3195 #ifdef HAVE_WINDOW_SYSTEM
3197 /* Redraw lines from the current matrix of window W that are
3198 overlapped by other rows. YB is bottom-most y-position in W. */
3201 redraw_overlapped_rows (struct window
*w
, int yb
)
3204 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3206 /* If rows overlapping others have been changed, the rows being
3207 overlapped have to be redrawn. This won't draw lines that have
3208 already been drawn in update_window_line because overlapped_p in
3209 desired rows is 0, so after row assignment overlapped_p in
3210 current rows is 0. */
3211 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3213 struct glyph_row
*row
= w
->current_matrix
->rows
+ i
;
3215 if (!row
->enabled_p
)
3217 else if (row
->mode_line_p
)
3220 if (row
->overlapped_p
)
3222 enum glyph_row_area area
;
3224 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3226 output_cursor_to (w
, i
, 0, row
->y
,
3227 area
== TEXT_AREA
? row
->x
: 0);
3228 if (row
->used
[area
])
3229 FRAME_RIF (f
)->write_glyphs (w
, row
, row
->glyphs
[area
],
3230 area
, row
->used
[area
]);
3231 FRAME_RIF (f
)->clear_end_of_line (w
, row
, area
, -1);
3234 row
->overlapped_p
= 0;
3237 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3243 /* Redraw lines from the current matrix of window W that overlap
3244 others. YB is bottom-most y-position in W. */
3247 redraw_overlapping_rows (struct window
*w
, int yb
)
3250 struct glyph_row
*row
;
3251 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
3253 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3255 row
= w
->current_matrix
->rows
+ i
;
3257 if (!row
->enabled_p
)
3259 else if (row
->mode_line_p
)
3262 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3264 if (row
->overlapping_p
)
3268 if (MATRIX_ROW_OVERLAPS_PRED_P (row
) && i
> 0
3269 && !MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
)
3270 overlaps
|= OVERLAPS_PRED
;
3271 if (MATRIX_ROW_OVERLAPS_SUCC_P (row
) && bottom_y
< yb
3272 && !MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
)
3273 overlaps
|= OVERLAPS_SUCC
;
3277 if (row
->used
[LEFT_MARGIN_AREA
])
3278 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
, overlaps
);
3280 if (row
->used
[TEXT_AREA
])
3281 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
, overlaps
);
3283 if (row
->used
[RIGHT_MARGIN_AREA
])
3284 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
, overlaps
);
3286 /* Record in neighbor rows that ROW overwrites part of
3288 if (overlaps
& OVERLAPS_PRED
)
3289 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3290 if (overlaps
& OVERLAPS_SUCC
)
3291 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
3300 #endif /* HAVE_WINDOW_SYSTEM */
3303 #if defined GLYPH_DEBUG && 0
3305 /* Check that no row in the current matrix of window W is enabled
3306 which is below what's displayed in the window. */
3309 check_current_matrix_flags (struct window
*w
)
3311 bool last_seen_p
= 0;
3312 int i
, yb
= window_text_bottom_y (w
);
3314 for (i
= 0; i
< w
->current_matrix
->nrows
- 1; ++i
)
3316 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
3317 if (!last_seen_p
&& MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3319 else if (last_seen_p
&& row
->enabled_p
)
3324 #endif /* GLYPH_DEBUG */
3327 /* Update display of window W.
3328 If FORCE_P, don't stop updating when input is pending. */
3331 update_window (struct window
*w
, bool force_p
)
3333 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
3335 int preempt_count
= baud_rate
/ 2400 + 1;
3336 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
3338 /* Check that W's frame doesn't have glyph matrices. */
3339 eassert (FRAME_WINDOW_P (XFRAME (WINDOW_FRAME (w
))));
3342 /* Check pending input the first time so that we can quickly return. */
3344 detect_input_pending_ignore_squeezables ();
3346 /* If forced to complete the update, or if no input is pending, do
3348 if (force_p
|| !input_pending
|| !NILP (do_mouse_tracking
))
3350 struct glyph_row
*row
, *end
;
3351 struct glyph_row
*mode_line_row
;
3352 struct glyph_row
*header_line_row
;
3354 bool changed_p
= 0, mouse_face_overwritten_p
= 0;
3357 rif
->update_window_begin_hook (w
);
3358 yb
= window_text_bottom_y (w
);
3359 row
= MATRIX_ROW (desired_matrix
, 0);
3360 end
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3362 /* Take note of the header line, if there is one. We will
3363 update it below, after updating all of the window's lines. */
3364 if (row
->mode_line_p
)
3366 header_line_row
= row
;
3370 header_line_row
= NULL
;
3372 /* Update the mode line, if necessary. */
3373 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3374 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
3376 mode_line_row
->y
= yb
;
3377 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
3379 &mouse_face_overwritten_p
);
3382 /* Find first enabled row. Optimizations in redisplay_internal
3383 may lead to an update with only one row enabled. There may
3384 be also completely empty matrices. */
3385 while (row
< end
&& !row
->enabled_p
)
3388 /* Try reusing part of the display by copying. */
3389 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
3391 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
3394 /* All rows were found to be equal. */
3400 /* We've scrolled the display. */
3406 /* Update the rest of the lines. */
3407 for (; row
< end
&& (force_p
|| !input_pending
); ++row
)
3408 /* scrolling_window resets the enabled_p flag of the rows it
3409 reuses from current_matrix. */
3412 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
3415 /* We'll have to play a little bit with when to
3416 detect_input_pending. If it's done too often,
3417 scrolling large windows with repeated scroll-up
3418 commands will too quickly pause redisplay. */
3419 if (!force_p
&& ++n_updated
% preempt_count
== 0)
3420 detect_input_pending_ignore_squeezables ();
3421 changed_p
|= update_window_line (w
, vpos
,
3422 &mouse_face_overwritten_p
);
3424 /* Mark all rows below the last visible one in the current
3425 matrix as invalid. This is necessary because of
3426 variable line heights. Consider the case of three
3427 successive redisplays, where the first displays 5
3428 lines, the second 3 lines, and the third 5 lines again.
3429 If the second redisplay wouldn't mark rows in the
3430 current matrix invalid, the third redisplay might be
3431 tempted to optimize redisplay based on lines displayed
3432 in the first redisplay. */
3433 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3434 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
3435 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
3438 /* Was display preempted? */
3439 paused_p
= row
< end
;
3443 /* Update the header line after scrolling because a new header
3444 line would otherwise overwrite lines at the top of the window
3445 that can be scrolled. */
3446 if (header_line_row
&& header_line_row
->enabled_p
)
3448 header_line_row
->y
= 0;
3449 update_window_line (w
, 0, &mouse_face_overwritten_p
);
3452 /* Fix the appearance of overlapping/overlapped rows. */
3453 if (!paused_p
&& !w
->pseudo_window_p
)
3455 #ifdef HAVE_WINDOW_SYSTEM
3456 if (changed_p
&& rif
->fix_overlapping_area
)
3458 redraw_overlapped_rows (w
, yb
);
3459 redraw_overlapping_rows (w
, yb
);
3463 /* Make cursor visible at cursor position of W. */
3464 set_window_cursor_after_update (w
);
3466 #if 0 /* Check that current matrix invariants are satisfied. This is
3467 for debugging only. See the comment of check_matrix_invariants. */
3468 IF_DEBUG (check_matrix_invariants (w
));
3473 /* Remember the redisplay method used to display the matrix. */
3474 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
3477 #ifdef HAVE_WINDOW_SYSTEM
3478 update_window_fringes (w
, 0);
3481 /* End the update of window W. Don't set the cursor if we
3482 paused updating the display because in this case,
3483 set_window_cursor_after_update hasn't been called, and
3484 W->output_cursor doesn't contain the cursor location. */
3485 rif
->update_window_end_hook (w
, !paused_p
, mouse_face_overwritten_p
);
3491 /* check_current_matrix_flags (w); */
3492 add_window_display_history (w
, w
->current_matrix
->method
, paused_p
);
3495 clear_glyph_matrix (desired_matrix
);
3501 /* Update the display of area AREA in window W, row number VPOS.
3502 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3505 update_marginal_area (struct window
*w
, struct glyph_row
*updated_row
,
3506 enum glyph_row_area area
, int vpos
)
3508 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3509 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
3511 /* Set cursor to start of glyphs, write them, and clear to the end
3512 of the area. I don't think that something more sophisticated is
3513 necessary here, since marginal areas will not be the default. */
3514 output_cursor_to (w
, vpos
, 0, desired_row
->y
, 0);
3515 if (desired_row
->used
[area
])
3516 rif
->write_glyphs (w
, updated_row
, desired_row
->glyphs
[area
],
3517 area
, desired_row
->used
[area
]);
3518 rif
->clear_end_of_line (w
, updated_row
, area
, -1);
3522 /* Update the display of the text area of row VPOS in window W.
3523 Value is true if display has changed. */
3526 update_text_area (struct window
*w
, struct glyph_row
*updated_row
, int vpos
)
3528 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3529 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3530 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
3533 /* If rows are at different X or Y, or rows have different height,
3534 or the current row is marked invalid, write the entire line. */
3535 if (!current_row
->enabled_p
3536 || desired_row
->y
!= current_row
->y
3537 || desired_row
->ascent
!= current_row
->ascent
3538 || desired_row
->phys_ascent
!= current_row
->phys_ascent
3539 || desired_row
->phys_height
!= current_row
->phys_height
3540 || desired_row
->visible_height
!= current_row
->visible_height
3541 || current_row
->overlapped_p
3542 /* This next line is necessary for correctly redrawing
3543 mouse-face areas after scrolling and other operations.
3544 However, it causes excessive flickering when mouse is moved
3545 across the mode line. Luckily, turning it off for the mode
3546 line doesn't seem to hurt anything. -- cyd.
3547 But it is still needed for the header line. -- kfs. */
3548 || (current_row
->mouse_face_p
3549 && !(current_row
->mode_line_p
&& vpos
> 0))
3550 || current_row
->x
!= desired_row
->x
)
3552 output_cursor_to (w
, vpos
, 0, desired_row
->y
, desired_row
->x
);
3554 if (desired_row
->used
[TEXT_AREA
])
3555 rif
->write_glyphs (w
, updated_row
, desired_row
->glyphs
[TEXT_AREA
],
3556 TEXT_AREA
, desired_row
->used
[TEXT_AREA
]);
3558 /* Clear to end of window. */
3559 rif
->clear_end_of_line (w
, updated_row
, TEXT_AREA
, -1);
3562 /* This erases the cursor. We do this here because
3563 notice_overwritten_cursor cannot easily check this, which
3564 might indicate that the whole functionality of
3565 notice_overwritten_cursor would better be implemented here.
3566 On the other hand, we need notice_overwritten_cursor as long
3567 as mouse highlighting is done asynchronously outside of
3569 if (vpos
== w
->phys_cursor
.vpos
)
3570 w
->phys_cursor_on_p
= 0;
3575 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
3576 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
3577 bool overlapping_glyphs_p
= current_row
->contains_overlapping_glyphs_p
;
3578 int desired_stop_pos
= desired_row
->used
[TEXT_AREA
];
3579 bool abort_skipping
= 0;
3581 /* If the desired row extends its face to the text area end, and
3582 unless the current row also does so at the same position,
3583 make sure we write at least one glyph, so that the face
3584 extension actually takes place. */
3585 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
)
3586 && (desired_stop_pos
< current_row
->used
[TEXT_AREA
]
3587 || (desired_stop_pos
== current_row
->used
[TEXT_AREA
]
3588 && !MATRIX_ROW_EXTENDS_FACE_P (current_row
))))
3591 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
3595 /* Loop over glyphs that current and desired row may have
3599 bool can_skip_p
= !abort_skipping
;
3601 /* Skip over glyphs that both rows have in common. These
3602 don't have to be written. We can't skip if the last
3603 current glyph overlaps the glyph to its right. For
3604 example, consider a current row of `if ' with the `f' in
3605 Courier bold so that it overlaps the ` ' to its right.
3606 If the desired row is ` ', we would skip over the space
3607 after the `if' and there would remain a pixel from the
3608 `f' on the screen. */
3609 if (overlapping_glyphs_p
&& i
> 0)
3611 struct glyph
*glyph
= ¤t_row
->glyphs
[TEXT_AREA
][i
- 1];
3614 rif
->get_glyph_overhangs (glyph
, XFRAME (w
->frame
),
3616 can_skip_p
= (right
== 0 && !abort_skipping
);
3624 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3626 x
+= desired_glyph
->pixel_width
;
3627 ++desired_glyph
, ++current_glyph
, ++i
;
3630 /* Consider the case that the current row contains "xxx
3631 ppp ggg" in italic Courier font, and the desired row
3632 is "xxx ggg". The character `p' has lbearing, `g'
3633 has not. The loop above will stop in front of the
3634 first `p' in the current row. If we would start
3635 writing glyphs there, we wouldn't erase the lbearing
3636 of the `p'. The rest of the lbearing problem is then
3637 taken care of by draw_glyphs. */
3638 if (overlapping_glyphs_p
3640 && i
< current_row
->used
[TEXT_AREA
]
3641 && (current_row
->used
[TEXT_AREA
]
3642 != desired_row
->used
[TEXT_AREA
]))
3646 rif
->get_glyph_overhangs (current_glyph
,
3649 while (left
> 0 && i
> 0)
3651 --i
, --desired_glyph
, --current_glyph
;
3652 x
-= desired_glyph
->pixel_width
;
3653 left
-= desired_glyph
->pixel_width
;
3656 /* Abort the skipping algorithm if we end up before
3657 our starting point, to avoid looping (bug#1070).
3658 This can happen when the lbearing is larger than
3660 abort_skipping
= (i
< start_hpos
);
3664 /* Try to avoid writing the entire rest of the desired row
3665 by looking for a resync point. This mainly prevents
3666 mode line flickering in the case the mode line is in
3667 fixed-pitch font, which it usually will be. */
3668 if (i
< desired_row
->used
[TEXT_AREA
])
3670 int start_x
= x
, start_hpos
= i
;
3671 struct glyph
*start
= desired_glyph
;
3673 bool skip_first_p
= !can_skip_p
;
3675 /* Find the next glyph that's equal again. */
3678 || !GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3681 x
+= desired_glyph
->pixel_width
;
3682 current_x
+= current_glyph
->pixel_width
;
3683 ++desired_glyph
, ++current_glyph
, ++i
;
3687 if (i
== start_hpos
|| x
!= current_x
)
3691 desired_glyph
= start
;
3695 output_cursor_to (w
, vpos
, start_hpos
, desired_row
->y
, start_x
);
3696 rif
->write_glyphs (w
, updated_row
, start
,
3697 TEXT_AREA
, i
- start_hpos
);
3702 /* Write the rest. */
3703 if (i
< desired_row
->used
[TEXT_AREA
])
3705 output_cursor_to (w
, vpos
, i
, desired_row
->y
, x
);
3706 rif
->write_glyphs (w
, updated_row
, desired_glyph
,
3707 TEXT_AREA
, desired_row
->used
[TEXT_AREA
] - i
);
3711 /* Maybe clear to end of line. */
3712 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
3714 /* If new row extends to the end of the text area, nothing
3715 has to be cleared, if and only if we did a write_glyphs
3716 above. This is made sure by setting desired_stop_pos
3717 appropriately above. */
3718 eassert (i
< desired_row
->used
[TEXT_AREA
]
3719 || ((desired_row
->used
[TEXT_AREA
]
3720 == current_row
->used
[TEXT_AREA
])
3721 && MATRIX_ROW_EXTENDS_FACE_P (current_row
)));
3723 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
3725 /* If old row extends to the end of the text area, clear. */
3726 if (i
>= desired_row
->used
[TEXT_AREA
])
3727 output_cursor_to (w
, vpos
, i
, desired_row
->y
,
3728 desired_row
->pixel_width
);
3729 rif
->clear_end_of_line (w
, updated_row
, TEXT_AREA
, -1);
3732 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
3734 /* Otherwise clear to the end of the old row. Everything
3735 after that position should be clear already. */
3738 if (i
>= desired_row
->used
[TEXT_AREA
])
3739 output_cursor_to (w
, vpos
, i
, desired_row
->y
,
3740 desired_row
->pixel_width
);
3742 /* If cursor is displayed at the end of the line, make sure
3743 it's cleared. Nowadays we don't have a phys_cursor_glyph
3744 with which to erase the cursor (because this method
3745 doesn't work with lbearing/rbearing), so we must do it
3747 if (vpos
== w
->phys_cursor
.vpos
3748 && (desired_row
->reversed_p
3749 ? (w
->phys_cursor
.hpos
< 0)
3750 : (w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])))
3752 w
->phys_cursor_on_p
= 0;
3756 xlim
= current_row
->pixel_width
;
3757 rif
->clear_end_of_line (w
, updated_row
, TEXT_AREA
, xlim
);
3766 /* Update row VPOS in window W. Value is true if display has been changed. */
3769 update_window_line (struct window
*w
, int vpos
, bool *mouse_face_overwritten_p
)
3771 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3772 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3773 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
3776 /* A row can be completely invisible in case a desired matrix was
3777 built with a vscroll and then make_cursor_line_fully_visible shifts
3778 the matrix. Make sure to make such rows current anyway, since
3779 we need the correct y-position, for example, in the current matrix. */
3780 if (desired_row
->mode_line_p
3781 || desired_row
->visible_height
> 0)
3783 eassert (desired_row
->enabled_p
);
3785 /* Update display of the left margin area, if there is one. */
3786 if (!desired_row
->full_width_p
&& w
->left_margin_cols
> 0)
3789 update_marginal_area (w
, desired_row
, LEFT_MARGIN_AREA
, vpos
);
3790 /* Setting this flag will ensure the vertical border, if
3791 any, between this window and the one on its left will be
3792 redrawn. This is necessary because updating the left
3793 margin area can potentially draw over the border. */
3794 current_row
->redraw_fringe_bitmaps_p
= 1;
3797 /* Update the display of the text area. */
3798 if (update_text_area (w
, desired_row
, vpos
))
3801 if (current_row
->mouse_face_p
)
3802 *mouse_face_overwritten_p
= 1;
3805 /* Update display of the right margin area, if there is one. */
3806 if (!desired_row
->full_width_p
&& w
->right_margin_cols
> 0)
3809 update_marginal_area (w
, desired_row
, RIGHT_MARGIN_AREA
, vpos
);
3812 /* Draw truncation marks etc. */
3813 if (!current_row
->enabled_p
3814 || desired_row
->y
!= current_row
->y
3815 || desired_row
->visible_height
!= current_row
->visible_height
3816 || desired_row
->cursor_in_fringe_p
!= current_row
->cursor_in_fringe_p
3817 || desired_row
->overlay_arrow_bitmap
!= current_row
->overlay_arrow_bitmap
3818 || current_row
->redraw_fringe_bitmaps_p
3819 || desired_row
->mode_line_p
!= current_row
->mode_line_p
3820 || desired_row
->exact_window_width_line_p
!= current_row
->exact_window_width_line_p
3821 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
3822 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
3823 rif
->after_update_window_line_hook (w
, desired_row
);
3826 /* Update current_row from desired_row. */
3827 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
3832 /* Set the cursor after an update of window W. This function may only
3833 be called from update_window. */
3836 set_window_cursor_after_update (struct window
*w
)
3838 struct frame
*f
= XFRAME (w
->frame
);
3839 int cx
, cy
, vpos
, hpos
;
3841 /* Not intended for frame matrix updates. */
3842 eassert (FRAME_WINDOW_P (f
));
3844 if (cursor_in_echo_area
3845 && !NILP (echo_area_buffer
[0])
3846 /* If we are showing a message instead of the mini-buffer,
3847 show the cursor for the message instead. */
3848 && XWINDOW (minibuf_window
) == w
3849 && EQ (minibuf_window
, echo_area_window
)
3850 /* These cases apply only to the frame that contains
3851 the active mini-buffer window. */
3852 && FRAME_HAS_MINIBUF_P (f
)
3853 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
3855 cx
= cy
= vpos
= hpos
= 0;
3857 if (cursor_in_echo_area
>= 0)
3859 /* If the mini-buffer is several lines high, find the last
3860 line that has any text on it. Note: either all lines
3861 are enabled or none. Otherwise we wouldn't be able to
3863 struct glyph_row
*row
, *last_row
;
3864 struct glyph
*glyph
;
3865 int yb
= window_text_bottom_y (w
);
3868 row
= w
->current_matrix
->rows
;
3869 while (row
->enabled_p
3870 && (last_row
== NULL
3871 || MATRIX_ROW_BOTTOM_Y (row
) <= yb
))
3873 if (row
->used
[TEXT_AREA
]
3874 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
3881 struct glyph
*start
= last_row
->glyphs
[TEXT_AREA
];
3882 struct glyph
*last
= start
+ last_row
->used
[TEXT_AREA
] - 1;
3884 while (last
> start
&& last
->charpos
< 0)
3887 for (glyph
= start
; glyph
< last
; ++glyph
)
3889 cx
+= glyph
->pixel_width
;
3894 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
3902 hpos
= w
->cursor
.hpos
;
3903 vpos
= w
->cursor
.vpos
;
3906 /* Window cursor can be out of sync for horizontally split windows.
3907 Horizontal position is -1 when cursor is on the left fringe. */
3908 hpos
= clip_to_bounds (-1, hpos
, w
->current_matrix
->matrix_w
- 1);
3909 vpos
= clip_to_bounds (0, vpos
, w
->current_matrix
->nrows
- 1);
3910 output_cursor_to (w
, vpos
, hpos
, cy
, cx
);
3914 /* Set WINDOW->must_be_updated_p to ON_P for all windows in the window
3915 tree rooted at W. */
3918 set_window_update_flags (struct window
*w
, bool on_p
)
3922 if (WINDOWP (w
->contents
))
3923 set_window_update_flags (XWINDOW (w
->contents
), on_p
);
3925 w
->must_be_updated_p
= on_p
;
3927 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3933 /***********************************************************************
3934 Window-Based Scrolling
3935 ***********************************************************************/
3937 /* Structure describing rows in scrolling_window. */
3941 /* Number of occurrences of this row in desired and current matrix. */
3942 int old_uses
, new_uses
;
3944 /* Vpos of row in new matrix. */
3945 int new_line_number
;
3947 /* Bucket index of this row_entry in the hash table row_table. */
3950 /* The row described by this entry. */
3951 struct glyph_row
*row
;
3953 /* Hash collision chain. */
3954 struct row_entry
*next
;
3957 /* A pool to allocate row_entry structures from, and the size of the
3958 pool. The pool is reallocated in scrolling_window when we find
3959 that we need a larger one. */
3961 static struct row_entry
*row_entry_pool
;
3962 static ptrdiff_t row_entry_pool_size
;
3964 /* Index of next free entry in row_entry_pool. */
3966 static ptrdiff_t row_entry_idx
;
3968 /* The hash table used during scrolling, and the table's size. This
3969 table is used to quickly identify equal rows in the desired and
3972 static struct row_entry
**row_table
;
3973 static ptrdiff_t row_table_size
;
3975 /* Vectors of pointers to row_entry structures belonging to the
3976 current and desired matrix, and the size of the vectors. */
3978 static struct row_entry
**old_lines
, **new_lines
;
3979 static ptrdiff_t old_lines_size
, new_lines_size
;
3981 /* A pool to allocate run structures from, and its size. */
3983 static struct run
*run_pool
;
3984 static ptrdiff_t runs_size
;
3986 /* A vector of runs of lines found during scrolling. */
3988 static struct run
**runs
;
3990 /* Add glyph row ROW to the scrolling hash table. */
3992 static struct row_entry
*
3993 add_row_entry (struct glyph_row
*row
)
3995 struct row_entry
*entry
;
3996 ptrdiff_t i
= row
->hash
% row_table_size
;
3998 entry
= row_table
[i
];
3999 eassert (entry
|| verify_row_hash (row
));
4000 while (entry
&& !row_equal_p (entry
->row
, row
, 1))
4001 entry
= entry
->next
;
4005 entry
= row_entry_pool
+ row_entry_idx
++;
4007 entry
->old_uses
= entry
->new_uses
= 0;
4008 entry
->new_line_number
= 0;
4010 entry
->next
= row_table
[i
];
4011 row_table
[i
] = entry
;
4018 /* Try to reuse part of the current display of W by scrolling lines.
4019 HEADER_LINE_P means W has a header line.
4021 The algorithm is taken from Communications of the ACM, Apr78 "A
4022 Technique for Isolating Differences Between Files." It should take
4025 A short outline of the steps of the algorithm
4027 1. Skip lines equal at the start and end of both matrices.
4029 2. Enter rows in the current and desired matrix into a symbol
4030 table, counting how often they appear in both matrices.
4032 3. Rows that appear exactly once in both matrices serve as anchors,
4033 i.e. we assume that such lines are likely to have been moved.
4035 4. Starting from anchor lines, extend regions to be scrolled both
4036 forward and backward.
4040 -1 if all rows were found to be equal.
4041 0 to indicate that we did not scroll the display, or
4042 1 if we did scroll. */
4045 scrolling_window (struct window
*w
, bool header_line_p
)
4047 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4048 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4049 int yb
= window_text_bottom_y (w
);
4051 int j
, first_old
, first_new
, last_old
, last_new
;
4054 struct row_entry
*entry
;
4055 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
4057 /* Skip over rows equal at the start. */
4058 for (i
= header_line_p
; i
< current_matrix
->nrows
- 1; ++i
)
4060 struct glyph_row
*d
= MATRIX_ROW (desired_matrix
, i
);
4061 struct glyph_row
*c
= MATRIX_ROW (current_matrix
, i
);
4065 && !d
->redraw_fringe_bitmaps_p
4067 && MATRIX_ROW_BOTTOM_Y (c
) <= yb
4068 && MATRIX_ROW_BOTTOM_Y (d
) <= yb
4069 && row_equal_p (c
, d
, 1))
4078 /* Give up if some rows in the desired matrix are not enabled. */
4079 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4082 first_old
= first_new
= i
;
4084 /* Set last_new to the index + 1 of the row that reaches the
4085 bottom boundary in the desired matrix. Give up if we find a
4086 disabled row before we reach the bottom boundary. */
4088 while (i
< desired_matrix
->nrows
- 1)
4092 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4094 bottom
= MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
));
4103 /* Set last_old to the index + 1 of the row that reaches the bottom
4104 boundary in the current matrix. We don't look at the enabled
4105 flag here because we plan to reuse part of the display even if
4106 other parts are disabled. */
4108 while (i
< current_matrix
->nrows
- 1)
4110 int bottom
= MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
));
4119 /* Skip over rows equal at the bottom. */
4122 while (i
- 1 > first_new
4123 && j
- 1 > first_old
4124 && MATRIX_ROW (current_matrix
, j
- 1)->enabled_p
4125 && (MATRIX_ROW (current_matrix
, j
- 1)->y
4126 == MATRIX_ROW (desired_matrix
, i
- 1)->y
)
4127 && !MATRIX_ROW (desired_matrix
, i
- 1)->redraw_fringe_bitmaps_p
4128 && row_equal_p (MATRIX_ROW (desired_matrix
, i
- 1),
4129 MATRIX_ROW (current_matrix
, j
- 1), 1))
4134 /* Nothing to do if all rows are equal. */
4135 if (last_new
== first_new
)
4138 /* Check for integer overflow in size calculation.
4140 If next_almost_prime checks (N) for divisibility by 2..10, then
4141 it can return at most N + 10, e.g., next_almost_prime (1) == 11.
4142 So, set next_almost_prime_increment_max to 10.
4144 It's just a coincidence that next_almost_prime_increment_max ==
4145 NEXT_ALMOST_PRIME_LIMIT - 1. If NEXT_ALMOST_PRIME_LIMIT were
4146 13, then next_almost_prime_increment_max would be 14, e.g.,
4147 because next_almost_prime (113) would be 127. */
4149 verify (NEXT_ALMOST_PRIME_LIMIT
== 11);
4150 enum { next_almost_prime_increment_max
= 10 };
4151 ptrdiff_t row_table_max
=
4152 (min (PTRDIFF_MAX
, SIZE_MAX
) / (3 * sizeof *row_table
)
4153 - next_almost_prime_increment_max
);
4154 ptrdiff_t current_nrows_max
= row_table_max
- desired_matrix
->nrows
;
4155 if (current_nrows_max
< current_matrix
->nrows
)
4156 memory_full (SIZE_MAX
);
4159 /* Reallocate vectors, tables etc. if necessary. */
4161 if (current_matrix
->nrows
> old_lines_size
)
4162 old_lines
= xpalloc (old_lines
, &old_lines_size
,
4163 current_matrix
->nrows
- old_lines_size
,
4164 INT_MAX
, sizeof *old_lines
);
4166 if (desired_matrix
->nrows
> new_lines_size
)
4167 new_lines
= xpalloc (new_lines
, &new_lines_size
,
4168 desired_matrix
->nrows
- new_lines_size
,
4169 INT_MAX
, sizeof *new_lines
);
4171 n
= desired_matrix
->nrows
;
4172 n
+= current_matrix
->nrows
;
4173 if (row_table_size
< 3 * n
)
4175 ptrdiff_t size
= next_almost_prime (3 * n
);
4176 row_table
= xnrealloc (row_table
, size
, sizeof *row_table
);
4177 row_table_size
= size
;
4178 memset (row_table
, 0, size
* sizeof *row_table
);
4181 if (n
> row_entry_pool_size
)
4182 row_entry_pool
= xpalloc (row_entry_pool
, &row_entry_pool_size
,
4183 n
- row_entry_pool_size
,
4184 -1, sizeof *row_entry_pool
);
4186 if (desired_matrix
->nrows
> runs_size
)
4188 runs
= xnrealloc (runs
, desired_matrix
->nrows
, sizeof *runs
);
4189 run_pool
= xnrealloc (run_pool
, desired_matrix
->nrows
, sizeof *run_pool
);
4190 runs_size
= desired_matrix
->nrows
;
4193 nruns
= run_idx
= 0;
4196 /* Add rows from the current and desired matrix to the hash table
4197 row_hash_table to be able to find equal ones quickly. */
4199 for (i
= first_old
; i
< last_old
; ++i
)
4201 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4203 entry
= add_row_entry (MATRIX_ROW (current_matrix
, i
));
4204 old_lines
[i
] = entry
;
4208 old_lines
[i
] = NULL
;
4211 for (i
= first_new
; i
< last_new
; ++i
)
4213 eassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4214 entry
= add_row_entry (MATRIX_ROW (desired_matrix
, i
));
4216 entry
->new_line_number
= i
;
4217 new_lines
[i
] = entry
;
4220 /* Identify moves based on lines that are unique and equal
4221 in both matrices. */
4222 for (i
= first_old
; i
< last_old
;)
4224 && old_lines
[i
]->old_uses
== 1
4225 && old_lines
[i
]->new_uses
== 1)
4228 int new_line
= old_lines
[i
]->new_line_number
;
4229 struct run
*run
= run_pool
+ run_idx
++;
4232 run
->current_vpos
= i
;
4233 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4234 run
->desired_vpos
= new_line
;
4235 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4237 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4239 /* Extend backward. */
4242 while (p
> first_old
4244 && old_lines
[p
] == new_lines
[q
])
4246 int h
= MATRIX_ROW (current_matrix
, p
)->height
;
4247 --run
->current_vpos
;
4248 --run
->desired_vpos
;
4251 run
->desired_y
-= h
;
4252 run
->current_y
-= h
;
4256 /* Extend forward. */
4261 && old_lines
[p
] == new_lines
[q
])
4263 int h
= MATRIX_ROW (current_matrix
, p
)->height
;
4269 /* Insert run into list of all runs. Order runs by copied
4270 pixel lines. Note that we record runs that don't have to
4271 be copied because they are already in place. This is done
4272 because we can avoid calling update_window_line in this
4274 for (p
= 0; p
< nruns
&& runs
[p
]->height
> run
->height
; ++p
)
4276 for (q
= nruns
; q
> p
; --q
)
4277 runs
[q
] = runs
[q
- 1];
4286 /* Do the moves. Do it in a way that we don't overwrite something
4287 we want to copy later on. This is not solvable in general
4288 because there is only one display and we don't have a way to
4289 exchange areas on this display. Example:
4291 +-----------+ +-----------+
4293 +-----------+ --> +-----------+
4295 +-----------+ +-----------+
4297 Instead, prefer bigger moves, and invalidate moves that would
4298 copy from where we copied to. */
4300 for (i
= 0; i
< nruns
; ++i
)
4301 if (runs
[i
]->nrows
> 0)
4303 struct run
*r
= runs
[i
];
4305 /* Copy on the display. */
4306 if (r
->current_y
!= r
->desired_y
)
4308 rif
->clear_window_mouse_face (w
);
4309 rif
->scroll_run_hook (w
, r
);
4312 /* Truncate runs that copy to where we copied to, and
4313 invalidate runs that copy from where we copied to. */
4314 for (j
= nruns
- 1; j
> i
; --j
)
4316 struct run
*p
= runs
[j
];
4317 bool truncated_p
= 0;
4320 && p
->desired_y
< r
->desired_y
+ r
->height
4321 && p
->desired_y
+ p
->height
> r
->desired_y
)
4323 if (p
->desired_y
< r
->desired_y
)
4325 p
->nrows
= r
->desired_vpos
- p
->desired_vpos
;
4326 p
->height
= r
->desired_y
- p
->desired_y
;
4331 int nrows_copied
= (r
->desired_vpos
+ r
->nrows
4334 if (p
->nrows
<= nrows_copied
)
4338 int height_copied
= (r
->desired_y
+ r
->height
4341 p
->current_vpos
+= nrows_copied
;
4342 p
->desired_vpos
+= nrows_copied
;
4343 p
->nrows
-= nrows_copied
;
4344 p
->current_y
+= height_copied
;
4345 p
->desired_y
+= height_copied
;
4346 p
->height
-= height_copied
;
4352 if (r
->current_y
!= r
->desired_y
4353 /* The condition below is equivalent to
4354 ((p->current_y >= r->desired_y
4355 && p->current_y < r->desired_y + r->height)
4356 || (p->current_y + p->height > r->desired_y
4357 && (p->current_y + p->height
4358 <= r->desired_y + r->height)))
4359 because we have 0 < p->height <= r->height. */
4360 && p
->current_y
< r
->desired_y
+ r
->height
4361 && p
->current_y
+ p
->height
> r
->desired_y
)
4364 /* Reorder runs by copied pixel lines if truncated. */
4365 if (truncated_p
&& p
->nrows
> 0)
4369 while (runs
[k
]->nrows
== 0 || runs
[k
]->height
< p
->height
)
4371 memmove (runs
+ j
, runs
+ j
+ 1, (k
- j
) * sizeof (*runs
));
4376 /* Assign matrix rows. */
4377 for (j
= 0; j
< r
->nrows
; ++j
)
4379 struct glyph_row
*from
, *to
;
4380 bool to_overlapped_p
;
4382 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
4383 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
4384 to_overlapped_p
= to
->overlapped_p
;
4385 from
->redraw_fringe_bitmaps_p
= from
->fringe_bitmap_periodic_p
;
4386 assign_row (to
, from
);
4387 /* The above `assign_row' actually does swap, so if we had
4388 an overlap in the copy destination of two runs, then
4389 the second run would assign a previously disabled bogus
4390 row. But thanks to the truncation code in the
4391 preceding for-loop, we no longer have such an overlap,
4392 and thus the assigned row should always be enabled. */
4393 eassert (to
->enabled_p
);
4394 from
->enabled_p
= 0;
4395 to
->overlapped_p
= to_overlapped_p
;
4399 /* Clear the hash table, for the next time. */
4400 for (i
= 0; i
< row_entry_idx
; ++i
)
4401 row_table
[row_entry_pool
[i
].bucket
] = NULL
;
4403 /* Value is 1 to indicate that we scrolled the display. */
4409 /************************************************************************
4411 ************************************************************************/
4413 /* Update the desired frame matrix of frame F.
4415 FORCE_P means that the update should not be stopped by pending input.
4416 INHIBIT_HAIRY_ID_P means that scrolling should not be tried.
4418 Value is true if update was stopped due to pending input. */
4421 update_frame_1 (struct frame
*f
, bool force_p
, bool inhibit_id_p
)
4423 /* Frame matrices to work on. */
4424 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4425 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4428 int preempt_count
= baud_rate
/ 2400 + 1;
4430 eassert (current_matrix
&& desired_matrix
);
4432 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
4433 calculate_costs (f
);
4435 if (preempt_count
<= 0)
4438 if (!force_p
&& detect_input_pending_ignore_squeezables ())
4444 /* If we cannot insert/delete lines, it's no use trying it. */
4445 if (!FRAME_LINE_INS_DEL_OK (f
))
4448 /* See if any of the desired lines are enabled; don't compute for
4449 i/d line if just want cursor motion. */
4450 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
4451 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4454 /* Try doing i/d line, if not yet inhibited. */
4455 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
4456 force_p
|= scrolling (f
);
4458 /* Update the individual lines as needed. Do bottom line first. */
4459 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
4460 update_frame_line (f
, desired_matrix
->nrows
- 1);
4462 /* Now update the rest of the lines. */
4463 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
4465 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4467 if (FRAME_TERMCAP_P (f
))
4469 /* Flush out every so many lines.
4470 Also flush out if likely to have more than 1k buffered
4471 otherwise. I'm told that some telnet connections get
4472 really screwed by more than 1k output at once. */
4473 FILE *display_output
= FRAME_TTY (f
)->output
;
4476 ptrdiff_t outq
= __fpending (display_output
);
4478 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
4479 fflush (display_output
);
4483 if (!force_p
&& (i
- 1) % preempt_count
== 0)
4484 detect_input_pending_ignore_squeezables ();
4486 update_frame_line (f
, i
);
4490 lint_assume (0 <= FRAME_LINES (f
));
4491 pause_p
= 0 < i
&& i
< FRAME_LINES (f
) - 1;
4493 /* Now just clean up termcap drivers and set cursor, etc. */
4496 if ((cursor_in_echo_area
4497 /* If we are showing a message instead of the mini-buffer,
4498 show the cursor for the message instead of for the
4499 (now hidden) mini-buffer contents. */
4500 || (EQ (minibuf_window
, selected_window
)
4501 && EQ (minibuf_window
, echo_area_window
)
4502 && !NILP (echo_area_buffer
[0])))
4503 /* These cases apply only to the frame that contains
4504 the active mini-buffer window. */
4505 && FRAME_HAS_MINIBUF_P (f
)
4506 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4508 int top
= WINDOW_TOP_EDGE_LINE (XWINDOW (FRAME_MINIBUF_WINDOW (f
)));
4511 if (cursor_in_echo_area
< 0)
4513 /* Negative value of cursor_in_echo_area means put
4514 cursor at beginning of line. */
4520 /* Positive value of cursor_in_echo_area means put
4521 cursor at the end of the prompt. If the mini-buffer
4522 is several lines high, find the last line that has
4524 row
= FRAME_LINES (f
);
4530 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
4532 /* Frame rows are filled up with spaces that
4533 must be ignored here. */
4534 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
4536 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
4537 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
4540 && (last
- 1)->charpos
< 0)
4546 while (row
> top
&& col
== 0);
4548 /* Make sure COL is not out of range. */
4549 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
4551 /* If we have another row, advance cursor into it. */
4552 if (row
< FRAME_LINES (f
) - 1)
4554 col
= FRAME_LEFT_SCROLL_BAR_COLS (f
);
4557 /* Otherwise move it back in range. */
4559 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
4563 cursor_to (f
, row
, col
);
4567 /* We have only one cursor on terminal frames. Use it to
4568 display the cursor of the selected window. */
4569 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
4570 if (w
->cursor
.vpos
>= 0
4571 /* The cursor vpos may be temporarily out of bounds
4572 in the following situation: There is one window,
4573 with the cursor in the lower half of it. The window
4574 is split, and a message causes a redisplay before
4575 a new cursor position has been computed. */
4576 && w
->cursor
.vpos
< WINDOW_TOTAL_LINES (w
))
4578 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
4579 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
4581 x
+= max (0, w
->left_margin_cols
);
4582 cursor_to (f
, y
, x
);
4589 clear_desired_matrices (f
);
4594 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4597 scrolling (struct frame
*frame
)
4599 int unchanged_at_top
, unchanged_at_bottom
;
4602 int *old_hash
= alloca (FRAME_LINES (frame
) * sizeof (int));
4603 int *new_hash
= alloca (FRAME_LINES (frame
) * sizeof (int));
4604 int *draw_cost
= alloca (FRAME_LINES (frame
) * sizeof (int));
4605 int *old_draw_cost
= alloca (FRAME_LINES (frame
) * sizeof (int));
4607 int free_at_end_vpos
= FRAME_LINES (frame
);
4608 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4609 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4611 if (!current_matrix
)
4614 /* Compute hash codes of all the lines. Also calculate number of
4615 changed lines, number of unchanged lines at the beginning, and
4616 number of unchanged lines at the end. */
4618 unchanged_at_top
= 0;
4619 unchanged_at_bottom
= FRAME_LINES (frame
);
4620 for (i
= 0; i
< FRAME_LINES (frame
); i
++)
4622 /* Give up on this scrolling if some old lines are not enabled. */
4623 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
4625 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
4626 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4628 /* This line cannot be redrawn, so don't let scrolling mess it. */
4629 new_hash
[i
] = old_hash
[i
];
4630 #define INFINITY 1000000 /* Taken from scroll.c */
4631 draw_cost
[i
] = INFINITY
;
4635 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
4636 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
4639 if (old_hash
[i
] != new_hash
[i
])
4642 unchanged_at_bottom
= FRAME_LINES (frame
) - i
- 1;
4644 else if (i
== unchanged_at_top
)
4646 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
4649 /* If changed lines are few, don't allow preemption, don't scroll. */
4650 if ((!FRAME_SCROLL_REGION_OK (frame
)
4651 && changed_lines
< baud_rate
/ 2400)
4652 || unchanged_at_bottom
== FRAME_LINES (frame
))
4655 window_size
= (FRAME_LINES (frame
) - unchanged_at_top
4656 - unchanged_at_bottom
);
4658 if (FRAME_SCROLL_REGION_OK (frame
))
4659 free_at_end_vpos
-= unchanged_at_bottom
;
4660 else if (FRAME_MEMORY_BELOW_FRAME (frame
))
4661 free_at_end_vpos
= -1;
4663 /* If large window, fast terminal and few lines in common between
4664 current frame and desired frame, don't bother with i/d calc. */
4665 if (!FRAME_SCROLL_REGION_OK (frame
)
4666 && window_size
>= 18 && baud_rate
> 2400
4668 10 * scrolling_max_lines_saved (unchanged_at_top
,
4669 FRAME_LINES (frame
) - unchanged_at_bottom
,
4670 old_hash
, new_hash
, draw_cost
)))
4673 if (window_size
< 2)
4676 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
4677 draw_cost
+ unchanged_at_top
- 1,
4678 old_draw_cost
+ unchanged_at_top
- 1,
4679 old_hash
+ unchanged_at_top
- 1,
4680 new_hash
+ unchanged_at_top
- 1,
4681 free_at_end_vpos
- unchanged_at_top
);
4687 /* Count the number of blanks at the start of the vector of glyphs R
4688 which is LEN glyphs long. */
4691 count_blanks (struct glyph
*r
, int len
)
4695 for (i
= 0; i
< len
; ++i
)
4696 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
4703 /* Count the number of glyphs in common at the start of the glyph
4704 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
4705 of STR2. Value is the number of equal glyphs equal at the start. */
4708 count_match (struct glyph
*str1
, struct glyph
*end1
, struct glyph
*str2
, struct glyph
*end2
)
4710 struct glyph
*p1
= str1
;
4711 struct glyph
*p2
= str2
;
4715 && GLYPH_CHAR_AND_FACE_EQUAL_P (p1
, p2
))
4722 /* Char insertion/deletion cost vector, from term.c */
4724 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_TOTAL_COLS ((f))])
4727 /* Perform a frame-based update on line VPOS in frame FRAME. */
4730 update_frame_line (struct frame
*f
, int vpos
)
4732 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
4734 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
4735 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4736 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4737 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
4738 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
4739 bool must_write_whole_line_p
;
4740 bool write_spaces_p
= FRAME_MUST_WRITE_SPACES (f
);
4741 bool colored_spaces_p
= (FACE_FROM_ID (f
, DEFAULT_FACE_ID
)->background
4742 != FACE_TTY_DEFAULT_BG_COLOR
);
4744 if (colored_spaces_p
)
4747 /* Current row not enabled means it has unknown contents. We must
4748 write the whole desired line in that case. */
4749 must_write_whole_line_p
= !current_row
->enabled_p
;
4750 if (must_write_whole_line_p
)
4757 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
4758 olen
= current_row
->used
[TEXT_AREA
];
4760 /* Ignore trailing spaces, if we can. */
4761 if (!write_spaces_p
)
4762 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
4766 current_row
->enabled_p
= 1;
4767 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
4769 /* If desired line is empty, just clear the line. */
4770 if (!desired_row
->enabled_p
)
4776 nbody
= desired_row
->glyphs
[TEXT_AREA
];
4777 nlen
= desired_row
->used
[TEXT_AREA
];
4778 nend
= nbody
+ nlen
;
4780 /* If display line has unknown contents, write the whole line. */
4781 if (must_write_whole_line_p
)
4783 /* Ignore spaces at the end, if we can. */
4784 if (!write_spaces_p
)
4785 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4788 /* Write the contents of the desired line. */
4791 cursor_to (f
, vpos
, 0);
4792 write_glyphs (f
, nbody
, nlen
);
4795 /* Don't call clear_end_of_line if we already wrote the whole
4796 line. The cursor will not be at the right margin in that
4797 case but in the line below. */
4798 if (nlen
< FRAME_TOTAL_COLS (f
))
4800 cursor_to (f
, vpos
, nlen
);
4801 clear_end_of_line (f
, FRAME_TOTAL_COLS (f
));
4804 /* Make sure we are in the right row, otherwise cursor movement
4805 with cmgoto might use `ch' in the wrong row. */
4806 cursor_to (f
, vpos
, 0);
4808 make_current (desired_matrix
, current_matrix
, vpos
);
4812 /* Pretend trailing spaces are not there at all,
4813 unless for one reason or another we must write all spaces. */
4814 if (!write_spaces_p
)
4815 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4818 /* If there's no i/d char, quickly do the best we can without it. */
4819 if (!FRAME_CHAR_INS_DEL_OK (f
))
4823 /* Find the first glyph in desired row that doesn't agree with
4824 a glyph in the current row, and write the rest from there on. */
4825 for (i
= 0; i
< nlen
; i
++)
4827 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
4829 /* Find the end of the run of different glyphs. */
4833 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
4834 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
4837 /* Output this run of non-matching chars. */
4838 cursor_to (f
, vpos
, i
);
4839 write_glyphs (f
, nbody
+ i
, j
- i
);
4842 /* Now find the next non-match. */
4846 /* Clear the rest of the line, or the non-clear part of it. */
4849 cursor_to (f
, vpos
, nlen
);
4850 clear_end_of_line (f
, olen
);
4853 /* Make current row = desired row. */
4854 make_current (desired_matrix
, current_matrix
, vpos
);
4858 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
4859 characters in a row. */
4863 /* If current line is blank, skip over initial spaces, if
4864 possible, and write the rest. */
4868 nsp
= count_blanks (nbody
, nlen
);
4872 cursor_to (f
, vpos
, nsp
);
4873 write_glyphs (f
, nbody
+ nsp
, nlen
- nsp
);
4876 /* Exchange contents between current_frame and new_frame. */
4877 make_current (desired_matrix
, current_matrix
, vpos
);
4881 /* Compute number of leading blanks in old and new contents. */
4882 osp
= count_blanks (obody
, olen
);
4883 nsp
= (colored_spaces_p
? 0 : count_blanks (nbody
, nlen
));
4885 /* Compute number of matching chars starting with first non-blank. */
4886 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
4887 nbody
+ nsp
, nbody
+ nlen
);
4889 /* Spaces in new match implicit space past the end of old. */
4890 /* A bug causing this to be a no-op was fixed in 18.29. */
4891 if (!write_spaces_p
&& osp
+ begmatch
== olen
)
4894 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
4898 /* Avoid doing insert/delete char
4899 just cause number of leading spaces differs
4900 when the following text does not match. */
4901 if (begmatch
== 0 && osp
!= nsp
)
4902 osp
= nsp
= min (osp
, nsp
);
4904 /* Find matching characters at end of line */
4907 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
4909 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
4914 endmatch
= obody
+ olen
- op1
;
4916 /* tem gets the distance to insert or delete.
4917 endmatch is how many characters we save by doing so.
4920 tem
= (nlen
- nsp
) - (olen
- osp
);
4922 && (!FRAME_CHAR_INS_DEL_OK (f
)
4923 || endmatch
<= char_ins_del_cost (f
)[tem
]))
4926 /* nsp - osp is the distance to insert or delete.
4927 If that is nonzero, begmatch is known to be nonzero also.
4928 begmatch + endmatch is how much we save by doing the ins/del.
4932 && (!FRAME_CHAR_INS_DEL_OK (f
)
4933 || begmatch
+ endmatch
<= char_ins_del_cost (f
)[nsp
- osp
]))
4937 osp
= nsp
= min (osp
, nsp
);
4940 /* Now go through the line, inserting, writing and
4941 deleting as appropriate. */
4945 cursor_to (f
, vpos
, nsp
);
4946 delete_glyphs (f
, osp
- nsp
);
4950 /* If going to delete chars later in line
4951 and insert earlier in the line,
4952 must delete first to avoid losing data in the insert */
4953 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
4955 cursor_to (f
, vpos
, nlen
- endmatch
+ osp
- nsp
);
4956 delete_glyphs (f
, olen
+ nsp
- osp
- nlen
);
4957 olen
= nlen
- (nsp
- osp
);
4959 cursor_to (f
, vpos
, osp
);
4960 insert_glyphs (f
, 0, nsp
- osp
);
4964 tem
= nsp
+ begmatch
+ endmatch
;
4965 if (nlen
!= tem
|| olen
!= tem
)
4967 if (!endmatch
|| nlen
== olen
)
4969 /* If new text being written reaches right margin, there is
4970 no need to do clear-to-eol at the end of this function
4971 (and it would not be safe, since cursor is not going to
4972 be "at the margin" after the text is done). */
4973 if (nlen
== FRAME_TOTAL_COLS (f
))
4976 /* Function write_glyphs is prepared to do nothing
4977 if passed a length <= 0. Check it here to avoid
4978 unnecessary cursor movement. */
4981 cursor_to (f
, vpos
, nsp
+ begmatch
);
4982 write_glyphs (f
, nbody
+ nsp
+ begmatch
, nlen
- tem
);
4985 else if (nlen
> olen
)
4987 /* Here, we used to have the following simple code:
4988 ----------------------------------------
4989 write_glyphs (nbody + nsp + begmatch, olen - tem);
4990 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
4991 ----------------------------------------
4992 but it doesn't work if nbody[nsp + begmatch + olen - tem]
4993 is a padding glyph. */
4994 int out
= olen
- tem
; /* Columns to be overwritten originally. */
4997 cursor_to (f
, vpos
, nsp
+ begmatch
);
4999 /* Calculate columns we can actually overwrite. */
5000 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
]))
5002 write_glyphs (f
, nbody
+ nsp
+ begmatch
, out
);
5004 /* If we left columns to be overwritten, we must delete them. */
5005 del
= olen
- tem
- out
;
5007 delete_glyphs (f
, del
);
5009 /* At last, we insert columns not yet written out. */
5010 insert_glyphs (f
, nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5013 else if (olen
> nlen
)
5015 cursor_to (f
, vpos
, nsp
+ begmatch
);
5016 write_glyphs (f
, nbody
+ nsp
+ begmatch
, nlen
- tem
);
5017 delete_glyphs (f
, olen
- nlen
);
5023 /* If any unerased characters remain after the new line, erase them. */
5026 cursor_to (f
, vpos
, nlen
);
5027 clear_end_of_line (f
, olen
);
5030 /* Exchange contents between current_frame and new_frame. */
5031 make_current (desired_matrix
, current_matrix
, vpos
);
5036 /***********************************************************************
5037 X/Y Position -> Buffer Position
5038 ***********************************************************************/
5040 /* Determine what's under window-relative pixel position (*X, *Y).
5041 Return the OBJECT (string or buffer) that's there.
5042 Return in *POS the position in that object.
5043 Adjust *X and *Y to character positions.
5044 Return in *DX and *DY the pixel coordinates of the click,
5045 relative to the top left corner of OBJECT, or relative to
5046 the top left corner of the character glyph at (*X, *Y)
5048 Return WIDTH and HEIGHT of the object at (*X, *Y), or zero
5049 if the coordinates point to an empty area of the display. */
5052 buffer_posn_from_coords (struct window
*w
, int *x
, int *y
, struct display_pos
*pos
, Lisp_Object
*object
, int *dx
, int *dy
, int *width
, int *height
)
5055 Lisp_Object old_current_buffer
= Fcurrent_buffer ();
5056 struct text_pos startp
;
5058 struct glyph_row
*row
;
5059 #ifdef HAVE_WINDOW_SYSTEM
5060 struct image
*img
= 0;
5063 void *itdata
= NULL
;
5065 /* We used to set current_buffer directly here, but that does the
5066 wrong thing with `face-remapping-alist' (bug#2044). */
5067 Fset_buffer (w
->contents
);
5068 itdata
= bidi_shelve_cache ();
5069 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5070 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5071 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5072 start_display (&it
, w
, startp
);
5073 /* start_display takes into account the header-line row, but IT's
5074 vpos still counts from the glyph row that includes the window's
5075 start position. Adjust for a possible header-line row. */
5076 it
.vpos
+= WINDOW_WANTS_HEADER_LINE_P (w
);
5080 /* First, move to the beginning of the row corresponding to *Y. We
5081 need to be in that row to get the correct value of base paragraph
5082 direction for the text at (*X, *Y). */
5083 move_it_to (&it
, -1, 0, *y
, -1, MOVE_TO_X
| MOVE_TO_Y
);
5085 /* TO_X is the pixel position that the iterator will compute for the
5086 glyph at *X. We add it.first_visible_x because iterator
5087 positions include the hscroll. */
5088 to_x
= x0
+ it
.first_visible_x
;
5089 if (it
.bidi_it
.paragraph_dir
== R2L
)
5090 /* For lines in an R2L paragraph, we need to mirror TO_X wrt the
5091 text area. This is because the iterator, even in R2L
5092 paragraphs, delivers glyphs as if they started at the left
5093 margin of the window. (When we actually produce glyphs for
5094 display, we reverse their order in PRODUCE_GLYPHS, but the
5095 iterator doesn't know about that.) The following line adjusts
5096 the pixel position to the iterator geometry, which is what
5097 move_it_* routines use. (The -1 is because in a window whose
5098 text-area width is W, the rightmost pixel position is W-1, and
5099 it should be mirrored into zero pixel position.) */
5100 to_x
= window_box_width (w
, TEXT_AREA
) - to_x
- 1;
5102 /* Now move horizontally in the row to the glyph under *X. Second
5103 argument is ZV to prevent move_it_in_display_line from matching
5104 based on buffer positions. */
5105 move_it_in_display_line (&it
, ZV
, to_x
, MOVE_TO_X
);
5106 bidi_unshelve_cache (itdata
, 0);
5108 Fset_buffer (old_current_buffer
);
5110 *dx
= x0
+ it
.first_visible_x
- it
.current_x
;
5111 *dy
= *y
- it
.current_y
;
5113 string
= w
->contents
;
5114 if (STRINGP (it
.string
))
5117 if (it
.what
== IT_COMPOSITION
5118 && it
.cmp_it
.nchars
> 1
5119 && it
.cmp_it
.reversed_p
)
5121 /* The current display element is a grapheme cluster in a
5122 composition. In that case, we need the position of the first
5123 character of the cluster. But, as it.cmp_it.reversed_p is 1,
5124 it.current points to the last character of the cluster, thus
5125 we must move back to the first character of the same
5127 CHARPOS (pos
->pos
) -= it
.cmp_it
.nchars
- 1;
5128 if (STRINGP (it
.string
))
5129 BYTEPOS (pos
->pos
) = string_char_to_byte (string
, CHARPOS (pos
->pos
));
5131 BYTEPOS (pos
->pos
) = buf_charpos_to_bytepos (XBUFFER (w
->contents
),
5132 CHARPOS (pos
->pos
));
5135 #ifdef HAVE_WINDOW_SYSTEM
5136 if (it
.what
== IT_IMAGE
)
5138 if ((img
= IMAGE_FROM_ID (it
.f
, it
.image_id
)) != NULL
5139 && !NILP (img
->spec
))
5140 *object
= img
->spec
;
5144 if (it
.vpos
< w
->current_matrix
->nrows
5145 && (row
= MATRIX_ROW (w
->current_matrix
, it
.vpos
),
5148 if (it
.hpos
< row
->used
[TEXT_AREA
])
5150 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + it
.hpos
;
5151 #ifdef HAVE_WINDOW_SYSTEM
5154 *dy
-= row
->ascent
- glyph
->ascent
;
5155 *dx
+= glyph
->slice
.img
.x
;
5156 *dy
+= glyph
->slice
.img
.y
;
5157 /* Image slices positions are still relative to the entire image */
5158 *width
= img
->width
;
5159 *height
= img
->height
;
5164 *width
= glyph
->pixel_width
;
5165 *height
= glyph
->ascent
+ glyph
->descent
;
5171 *height
= row
->height
;
5176 *width
= *height
= 0;
5179 /* Add extra (default width) columns if clicked after EOL. */
5180 x1
= max (0, it
.current_x
+ it
.pixel_width
- it
.first_visible_x
);
5182 it
.hpos
+= (x0
- x1
) / WINDOW_FRAME_COLUMN_WIDTH (w
);
5191 /* Value is the string under window-relative coordinates X/Y in the
5192 mode line or header line (PART says which) of window W, or nil if none.
5193 *CHARPOS is set to the position in the string returned. */
5196 mode_line_string (struct window
*w
, enum window_part part
,
5197 int *x
, int *y
, ptrdiff_t *charpos
, Lisp_Object
*object
,
5198 int *dx
, int *dy
, int *width
, int *height
)
5200 struct glyph_row
*row
;
5201 struct glyph
*glyph
, *end
;
5203 Lisp_Object string
= Qnil
;
5205 if (part
== ON_MODE_LINE
)
5206 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5208 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
5210 *y
= row
- MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
5212 if (row
->mode_line_p
&& row
->enabled_p
)
5214 /* Find the glyph under X. If we find one with a string object,
5215 it's the one we were looking for. */
5216 glyph
= row
->glyphs
[TEXT_AREA
];
5217 end
= glyph
+ row
->used
[TEXT_AREA
];
5218 for (x0
= *x
; glyph
< end
&& x0
>= glyph
->pixel_width
; ++glyph
)
5219 x0
-= glyph
->pixel_width
;
5220 *x
= glyph
- row
->glyphs
[TEXT_AREA
];
5223 string
= glyph
->object
;
5224 *charpos
= glyph
->charpos
;
5225 *width
= glyph
->pixel_width
;
5226 *height
= glyph
->ascent
+ glyph
->descent
;
5227 #ifdef HAVE_WINDOW_SYSTEM
5228 if (glyph
->type
== IMAGE_GLYPH
)
5231 img
= IMAGE_FROM_ID (WINDOW_XFRAME (w
), glyph
->u
.img_id
);
5233 *object
= img
->spec
;
5234 y0
-= row
->ascent
- glyph
->ascent
;
5240 /* Add extra (default width) columns if clicked after EOL. */
5241 *x
+= x0
/ WINDOW_FRAME_COLUMN_WIDTH (w
);
5243 *height
= row
->height
;
5250 *width
= *height
= 0;
5260 /* Value is the string under window-relative coordinates X/Y in either
5261 marginal area, or nil if none. *CHARPOS is set to the position in
5262 the string returned. */
5265 marginal_area_string (struct window
*w
, enum window_part part
,
5266 int *x
, int *y
, ptrdiff_t *charpos
, Lisp_Object
*object
,
5267 int *dx
, int *dy
, int *width
, int *height
)
5269 struct glyph_row
*row
= w
->current_matrix
->rows
;
5270 struct glyph
*glyph
, *end
;
5271 int x0
, y0
, i
, wy
= *y
;
5273 Lisp_Object string
= Qnil
;
5275 if (part
== ON_LEFT_MARGIN
)
5276 area
= LEFT_MARGIN_AREA
;
5277 else if (part
== ON_RIGHT_MARGIN
)
5278 area
= RIGHT_MARGIN_AREA
;
5282 for (i
= 0; row
->enabled_p
&& i
< w
->current_matrix
->nrows
; ++i
, ++row
)
5283 if (wy
>= row
->y
&& wy
< MATRIX_ROW_BOTTOM_Y (row
))
5286 *y
= row
- MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
5290 /* Find the glyph under X. If we find one with a string object,
5291 it's the one we were looking for. */
5292 if (area
== RIGHT_MARGIN_AREA
)
5293 x0
= ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5294 ? WINDOW_LEFT_FRINGE_WIDTH (w
)
5295 : WINDOW_TOTAL_FRINGE_WIDTH (w
))
5296 + window_box_width (w
, LEFT_MARGIN_AREA
)
5297 + window_box_width (w
, TEXT_AREA
));
5299 x0
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5300 ? WINDOW_LEFT_FRINGE_WIDTH (w
)
5303 glyph
= row
->glyphs
[area
];
5304 end
= glyph
+ row
->used
[area
];
5305 for (x0
= *x
- x0
; glyph
< end
&& x0
>= glyph
->pixel_width
; ++glyph
)
5306 x0
-= glyph
->pixel_width
;
5307 *x
= glyph
- row
->glyphs
[area
];
5310 string
= glyph
->object
;
5311 *charpos
= glyph
->charpos
;
5312 *width
= glyph
->pixel_width
;
5313 *height
= glyph
->ascent
+ glyph
->descent
;
5314 #ifdef HAVE_WINDOW_SYSTEM
5315 if (glyph
->type
== IMAGE_GLYPH
)
5318 img
= IMAGE_FROM_ID (WINDOW_XFRAME (w
), glyph
->u
.img_id
);
5320 *object
= img
->spec
;
5321 y0
-= row
->ascent
- glyph
->ascent
;
5322 x0
+= glyph
->slice
.img
.x
;
5323 y0
+= glyph
->slice
.img
.y
;
5329 /* Add extra (default width) columns if clicked after EOL. */
5330 *x
+= x0
/ WINDOW_FRAME_COLUMN_WIDTH (w
);
5332 *height
= row
->height
;
5339 *width
= *height
= 0;
5349 /***********************************************************************
5350 Changing Frame Sizes
5351 ***********************************************************************/
5355 static void deliver_window_change_signal (int);
5358 handle_window_change_signal (int sig
)
5361 struct tty_display_info
*tty
;
5363 /* The frame size change obviously applies to a single
5364 termcap-controlled terminal, but we can't decide which.
5365 Therefore, we resize the frames corresponding to each tty.
5367 for (tty
= tty_list
; tty
; tty
= tty
->next
) {
5369 if (! tty
->term_initted
)
5372 /* Suspended tty frames have tty->input == NULL avoid trying to
5377 get_tty_size (fileno (tty
->input
), &width
, &height
);
5379 if (width
> 5 && height
> 2) {
5380 Lisp_Object tail
, frame
;
5382 FOR_EACH_FRAME (tail
, frame
)
5383 if (FRAME_TERMCAP_P (XFRAME (frame
)) && FRAME_TTY (XFRAME (frame
)) == tty
)
5384 /* Record the new sizes, but don't reallocate the data
5385 structures now. Let that be done later outside of the
5387 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5393 deliver_window_change_signal (int sig
)
5395 deliver_process_signal (sig
, handle_window_change_signal
);
5397 #endif /* SIGWINCH */
5400 /* Do any change in frame size that was requested by a signal.
5401 SAFE means this function is called from a place where it is
5402 safe to change frame sizes while a redisplay is in progress. */
5405 do_pending_window_change (bool safe
)
5407 /* If window change signal handler should have run before, run it now. */
5408 if (redisplaying_p
&& !safe
)
5411 while (delayed_size_change
)
5413 Lisp_Object tail
, frame
;
5415 delayed_size_change
= 0;
5417 FOR_EACH_FRAME (tail
, frame
)
5419 struct frame
*f
= XFRAME (frame
);
5421 if (f
->new_text_lines
!= 0 || f
->new_text_cols
!= 0)
5422 change_frame_size (f
, f
->new_text_lines
, f
->new_text_cols
,
5429 /* Change the frame height and/or width. Values may be given as zero to
5430 indicate no change is to take place.
5432 If DELAY, assume we're being called from a signal handler, and
5433 queue the change for later - perhaps the next redisplay.
5434 Since this tries to resize windows, we can't call it
5435 from a signal handler.
5437 SAFE means this function is called from a place where it's
5438 safe to change frame sizes while a redisplay is in progress. */
5441 change_frame_size (struct frame
*f
, int newheight
, int newwidth
,
5442 bool pretend
, bool delay
, bool safe
)
5444 Lisp_Object tail
, frame
;
5446 if (FRAME_MSDOS_P (f
))
5448 /* On MS-DOS, all frames use the same screen, so a change in
5449 size affects all frames. Termcap now supports multiple
5451 FOR_EACH_FRAME (tail
, frame
)
5452 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5453 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5454 pretend
, delay
, safe
);
5457 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
5461 change_frame_size_1 (struct frame
*f
, int newheight
, int newwidth
,
5462 bool pretend
, bool delay
, bool safe
)
5464 int new_frame_total_cols
;
5465 ptrdiff_t count
= SPECPDL_INDEX ();
5467 /* If we can't deal with the change now, queue it for later. */
5468 if (delay
|| (redisplaying_p
&& !safe
))
5470 f
->new_text_lines
= newheight
;
5471 f
->new_text_cols
= newwidth
;
5472 delayed_size_change
= 1;
5476 /* This size-change overrides any pending one for this frame. */
5477 f
->new_text_lines
= 0;
5478 f
->new_text_cols
= 0;
5480 /* If an argument is zero, set it to the current value. */
5482 newheight
= FRAME_LINES (f
);
5484 newwidth
= FRAME_COLS (f
);
5486 /* Compute width of windows in F. */
5487 /* Round up to the smallest acceptable size. */
5488 check_frame_size (f
, &newheight
, &newwidth
);
5490 /* This is the width of the frame with vertical scroll bars and fringe
5491 columns. Do this after rounding - see discussion of bug#9723. */
5492 new_frame_total_cols
= FRAME_TOTAL_COLS_ARG (f
, newwidth
);
5494 /* If we're not changing the frame size, quit now. */
5495 /* Frame width may be unchanged but the text portion may change, for
5496 example, fullscreen and remove/add scroll bar. */
5497 if (newheight
== FRAME_LINES (f
)
5498 /* Text portion unchanged? */
5499 && newwidth
== FRAME_COLS (f
)
5500 /* Frame width unchanged? */
5501 && new_frame_total_cols
== FRAME_TOTAL_COLS (f
))
5507 /* We only can set screen dimensions to certain values supported
5508 by our video hardware. Try to find the smallest size greater
5509 or equal to the requested dimensions. */
5510 dos_set_window_size (&newheight
, &newwidth
);
5513 if (newheight
!= FRAME_LINES (f
))
5515 resize_frame_windows (f
, newheight
, 0);
5517 /* MSDOS frames cannot PRETEND, as they change frame size by
5518 manipulating video hardware. */
5519 if ((FRAME_TERMCAP_P (f
) && !pretend
) || FRAME_MSDOS_P (f
))
5520 FrameRows (FRAME_TTY (f
)) = newheight
;
5523 if (new_frame_total_cols
!= FRAME_TOTAL_COLS (f
))
5525 resize_frame_windows (f
, new_frame_total_cols
, 1);
5527 /* MSDOS frames cannot PRETEND, as they change frame size by
5528 manipulating video hardware. */
5529 if ((FRAME_TERMCAP_P (f
) && !pretend
) || FRAME_MSDOS_P (f
))
5530 FrameCols (FRAME_TTY (f
)) = newwidth
;
5532 if (WINDOWP (f
->tool_bar_window
))
5533 XWINDOW (f
->tool_bar_window
)->total_cols
= newwidth
;
5536 FRAME_LINES (f
) = newheight
;
5537 SET_FRAME_COLS (f
, newwidth
);
5540 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5541 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
5543 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
5545 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
5546 w
->cursor
.hpos
= w
->cursor
.x
= 0;
5547 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
5548 w
->cursor
.vpos
= w
->cursor
.y
= 0;
5552 calculate_costs (f
);
5553 SET_FRAME_GARBAGED (f
);
5558 record_unwind_current_buffer ();
5560 run_window_configuration_change_hook (f
);
5562 unbind_to (count
, Qnil
);
5567 /***********************************************************************
5568 Terminal Related Lisp Functions
5569 ***********************************************************************/
5571 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
5572 1, 1, "FOpen termscript file: ",
5573 doc
: /* Start writing all terminal output to FILE as well as the terminal.
5574 FILE = nil means just close any termscript file currently open. */)
5577 struct tty_display_info
*tty
;
5579 if (! FRAME_TERMCAP_P (SELECTED_FRAME ())
5580 && ! FRAME_MSDOS_P (SELECTED_FRAME ()))
5581 error ("Current frame is not on a tty device");
5585 if (tty
->termscript
!= 0)
5588 fclose (tty
->termscript
);
5589 tty
->termscript
= 0;
5595 file
= Fexpand_file_name (file
, Qnil
);
5596 tty
->termscript
= emacs_fopen (SSDATA (file
), "w");
5597 if (tty
->termscript
== 0)
5598 report_file_error ("Opening termscript", file
);
5604 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
5605 Ssend_string_to_terminal
, 1, 2, 0,
5606 doc
: /* Send STRING to the terminal without alteration.
5607 Control characters in STRING will have terminal-dependent effects.
5609 Optional parameter TERMINAL specifies the tty terminal device to use.
5610 It may be a terminal object, a frame, or nil for the terminal used by
5611 the currently selected frame. In batch mode, STRING is sent to stdout
5612 when TERMINAL is nil. */)
5613 (Lisp_Object string
, Lisp_Object terminal
)
5615 struct terminal
*t
= get_terminal (terminal
, 1);
5618 /* ??? Perhaps we should do something special for multibyte strings here. */
5619 CHECK_STRING (string
);
5623 error ("Unknown terminal device");
5625 if (t
->type
== output_initial
)
5627 else if (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
)
5628 error ("Device %d is not a termcap terminal device", t
->id
);
5631 struct tty_display_info
*tty
= t
->display_info
.tty
;
5634 error ("Terminal is currently suspended");
5636 if (tty
->termscript
)
5638 fwrite (SDATA (string
), 1, SBYTES (string
), tty
->termscript
);
5639 fflush (tty
->termscript
);
5643 fwrite (SDATA (string
), 1, SBYTES (string
), out
);
5650 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
5651 doc
: /* Beep, or flash the screen.
5652 Also, unless an argument is given,
5653 terminate any keyboard macro currently executing. */)
5661 ring_bell (XFRAME (selected_frame
));
5670 bitch_at_user (void)
5674 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
5677 = "Keyboard macro terminated by a command ringing the bell";
5678 Fsignal (Quser_error
, list1 (build_string (msg
)));
5681 ring_bell (XFRAME (selected_frame
));
5686 /***********************************************************************
5688 ***********************************************************************/
5690 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
5691 doc
: /* Pause, without updating display, for SECONDS seconds.
5692 SECONDS may be a floating-point value, meaning that you can wait for a
5693 fraction of a second. Optional second arg MILLISECONDS specifies an
5694 additional wait period, in milliseconds; this is for backwards compatibility.
5695 \(Not all operating systems support waiting for a fraction of a second.) */)
5696 (Lisp_Object seconds
, Lisp_Object milliseconds
)
5698 double duration
= extract_float (seconds
);
5700 if (!NILP (milliseconds
))
5702 CHECK_NUMBER (milliseconds
);
5703 duration
+= XINT (milliseconds
) / 1000.0;
5708 struct timespec t
= dtotimespec (duration
);
5709 wait_reading_process_output (min (t
.tv_sec
, WAIT_READING_MAX
),
5710 t
.tv_nsec
, 0, 0, Qnil
, NULL
, 0);
5717 /* This is just like wait_reading_process_output, except that
5720 TIMEOUT is number of seconds to wait (float or integer),
5721 or t to wait forever.
5722 READING is true if reading input.
5723 If DISPLAY_OPTION is >0 display process output while waiting.
5724 If DISPLAY_OPTION is >1 perform an initial redisplay before waiting.
5728 sit_for (Lisp_Object timeout
, bool reading
, int display_option
)
5732 bool do_display
= display_option
> 0;
5734 swallow_events (do_display
);
5736 if ((detect_input_pending_run_timers (do_display
))
5737 || !NILP (Vexecuting_kbd_macro
))
5740 if (display_option
> 1)
5741 redisplay_preserve_echo_area (2);
5743 if (INTEGERP (timeout
))
5745 sec
= XINT (timeout
);
5750 else if (FLOATP (timeout
))
5752 double seconds
= XFLOAT_DATA (timeout
);
5753 if (! (0 < seconds
))
5757 struct timespec t
= dtotimespec (seconds
);
5758 sec
= min (t
.tv_sec
, WAIT_READING_MAX
);
5762 else if (EQ (timeout
, Qt
))
5768 wrong_type_argument (Qnumberp
, timeout
);
5775 wait_reading_process_output (sec
, nsec
, reading
? -1 : 1, do_display
,
5778 return detect_input_pending () ? Qnil
: Qt
;
5782 DEFUN ("redisplay", Fredisplay
, Sredisplay
, 0, 1, 0,
5783 doc
: /* Perform redisplay.
5784 Optional arg FORCE, if non-nil, prevents redisplay from being
5785 preempted by arriving input, even if `redisplay-dont-pause' is nil.
5786 If `redisplay-dont-pause' is non-nil (the default), redisplay is never
5787 preempted by arriving input, so FORCE does nothing.
5789 Return t if redisplay was performed, nil if redisplay was preempted
5790 immediately by pending input. */)
5796 if ((detect_input_pending_run_timers (1)
5797 && NILP (force
) && !redisplay_dont_pause
)
5798 || !NILP (Vexecuting_kbd_macro
))
5801 count
= SPECPDL_INDEX ();
5802 if (!NILP (force
) && !redisplay_dont_pause
)
5803 specbind (Qredisplay_dont_pause
, Qt
);
5804 redisplay_preserve_echo_area (2);
5805 unbind_to (count
, Qnil
);
5811 /***********************************************************************
5812 Other Lisp Functions
5813 ***********************************************************************/
5815 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
5816 session's frames, frame names, buffers, buffer-read-only flags, and
5817 buffer-modified-flags. */
5819 static Lisp_Object frame_and_buffer_state
;
5822 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
5823 Sframe_or_buffer_changed_p
, 0, 1, 0,
5824 doc
: /* Return non-nil if the frame and buffer state appears to have changed.
5825 VARIABLE is a variable name whose value is either nil or a state vector
5826 that will be updated to contain all frames and buffers,
5827 aside from buffers whose names start with space,
5828 along with the buffers' read-only and modified flags. This allows a fast
5829 check to see whether buffer menus might need to be recomputed.
5830 If this function returns non-nil, it updates the internal vector to reflect
5833 If VARIABLE is nil, an internal variable is used. Users should not
5834 pass nil for VARIABLE. */)
5835 (Lisp_Object variable
)
5837 Lisp_Object state
, tail
, frame
, buf
;
5840 if (! NILP (variable
))
5842 CHECK_SYMBOL (variable
);
5843 state
= Fsymbol_value (variable
);
5844 if (! VECTORP (state
))
5848 state
= frame_and_buffer_state
;
5851 FOR_EACH_FRAME (tail
, frame
)
5853 if (idx
== ASIZE (state
))
5855 if (!EQ (AREF (state
, idx
++), frame
))
5857 if (idx
== ASIZE (state
))
5859 if (!EQ (AREF (state
, idx
++), XFRAME (frame
)->name
))
5862 /* Check that the buffer info matches. */
5863 FOR_EACH_LIVE_BUFFER (tail
, buf
)
5865 /* Ignore buffers that aren't included in buffer lists. */
5866 if (SREF (BVAR (XBUFFER (buf
), name
), 0) == ' ')
5868 if (idx
== ASIZE (state
))
5870 if (!EQ (AREF (state
, idx
++), buf
))
5872 if (idx
== ASIZE (state
))
5874 if (!EQ (AREF (state
, idx
++), BVAR (XBUFFER (buf
), read_only
)))
5876 if (idx
== ASIZE (state
))
5878 if (!EQ (AREF (state
, idx
++), Fbuffer_modified_p (buf
)))
5881 if (idx
== ASIZE (state
))
5883 /* Detect deletion of a buffer at the end of the list. */
5884 if (EQ (AREF (state
, idx
), Qlambda
))
5887 /* Come here if we decide the data has changed. */
5889 /* Count the size we will need.
5890 Start with 1 so there is room for at least one lambda at the end. */
5892 FOR_EACH_FRAME (tail
, frame
)
5894 FOR_EACH_LIVE_BUFFER (tail
, buf
)
5896 /* Reallocate the vector if data has grown to need it,
5897 or if it has shrunk a lot. */
5898 if (! VECTORP (state
)
5899 || n
> ASIZE (state
)
5900 || n
+ 20 < ASIZE (state
) / 2)
5901 /* Add 20 extra so we grow it less often. */
5903 state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
5904 if (! NILP (variable
))
5905 Fset (variable
, state
);
5907 frame_and_buffer_state
= state
;
5910 /* Record the new data in the (possibly reallocated) vector. */
5912 FOR_EACH_FRAME (tail
, frame
)
5914 ASET (state
, idx
, frame
);
5916 ASET (state
, idx
, XFRAME (frame
)->name
);
5919 FOR_EACH_LIVE_BUFFER (tail
, buf
)
5921 /* Ignore buffers that aren't included in buffer lists. */
5922 if (SREF (BVAR (XBUFFER (buf
), name
), 0) == ' ')
5924 ASET (state
, idx
, buf
);
5926 ASET (state
, idx
, BVAR (XBUFFER (buf
), read_only
));
5928 ASET (state
, idx
, Fbuffer_modified_p (buf
));
5931 /* Fill up the vector with lambdas (always at least one). */
5932 ASET (state
, idx
, Qlambda
);
5934 while (idx
< ASIZE (state
))
5936 ASET (state
, idx
, Qlambda
);
5939 /* Make sure we didn't overflow the vector. */
5940 eassert (idx
<= ASIZE (state
));
5946 /***********************************************************************
5948 ***********************************************************************/
5950 /* Initialization done when Emacs fork is started, before doing stty.
5951 Determine terminal type and set terminal_driver. Then invoke its
5952 decoding routine to set up variables in the terminal package. */
5957 char *terminal_type
;
5959 /* Construct the space glyph. */
5960 space_glyph
.type
= CHAR_GLYPH
;
5961 SET_CHAR_GLYPH (space_glyph
, ' ', DEFAULT_FACE_ID
, 0);
5962 space_glyph
.charpos
= -1;
5965 cursor_in_echo_area
= 0;
5967 /* Now is the time to initialize this; it's used by init_sys_modes
5969 Vinitial_window_system
= Qnil
;
5971 /* SIGWINCH needs to be handled no matter what display we start
5972 with. Otherwise newly opened tty frames will not resize
5977 #endif /* CANNOT_DUMP */
5979 struct sigaction action
;
5980 emacs_sigaction_init (&action
, deliver_window_change_signal
);
5981 sigaction (SIGWINCH
, &action
, 0);
5983 #endif /* SIGWINCH */
5985 /* If running as a daemon, no need to initialize any frames/terminal. */
5989 /* If the user wants to use a window system, we shouldn't bother
5990 initializing the terminal. This is especially important when the
5991 terminal is so dumb that emacs gives up before and doesn't bother
5992 using the window system.
5994 If the DISPLAY environment variable is set and nonempty,
5995 try to use X, and die with an error message if that doesn't work. */
5997 #ifdef HAVE_X_WINDOWS
5998 if (! inhibit_window_system
&& ! display_arg
)
6001 display
= getenv ("DISPLAY");
6002 display_arg
= (display
!= 0 && *display
!= 0);
6004 if (display_arg
&& !x_display_ok (display
))
6006 fprintf (stderr
, "Display %s unavailable, simulating -nw\n",
6008 inhibit_window_system
= 1;
6012 if (!inhibit_window_system
&& display_arg
)
6014 Vinitial_window_system
= Qx
;
6016 Vwindow_system_version
= make_number (11);
6019 /* In some versions of ncurses,
6020 tputs crashes if we have not called tgetent.
6022 { char b
[2044]; tgetent (b
, "xterm");}
6026 #endif /* HAVE_X_WINDOWS */
6029 if (!inhibit_window_system
)
6031 Vinitial_window_system
= Qw32
;
6032 Vwindow_system_version
= make_number (1);
6035 #endif /* HAVE_NTGUI */
6038 if (!inhibit_window_system
6044 Vinitial_window_system
= Qns
;
6045 Vwindow_system_version
= make_number (10);
6050 /* If no window system has been specified, try to use the terminal. */
6052 fatal ("standard input is not a tty");
6055 terminal_type
= "w32console";
6057 terminal_type
= getenv ("TERM");
6061 #ifdef HAVE_WINDOW_SYSTEM
6062 if (! inhibit_window_system
)
6063 fprintf (stderr
, "Please set the environment variable DISPLAY or TERM (see `tset').\n");
6065 #endif /* HAVE_WINDOW_SYSTEM */
6066 fprintf (stderr
, "Please set the environment variable TERM; see `tset'.\n");
6072 struct frame
*f
= XFRAME (selected_frame
);
6074 init_foreground_group ();
6076 /* Open a display on the controlling tty. */
6077 t
= init_tty (0, terminal_type
, 1); /* Errors are fatal. */
6079 /* Convert the initial frame to use the new display. */
6080 if (f
->output_method
!= output_initial
)
6082 f
->output_method
= t
->type
;
6085 t
->reference_count
++;
6087 f
->output_data
.tty
->display_info
= &the_only_display_info
;
6089 if (f
->output_method
== output_termcap
)
6090 create_tty_output (f
);
6092 t
->display_info
.tty
->top_frame
= selected_frame
;
6093 change_frame_size (XFRAME (selected_frame
),
6094 FrameRows (t
->display_info
.tty
),
6095 FrameCols (t
->display_info
.tty
), 0, 0, 1);
6097 /* Delete the initial terminal. */
6098 if (--initial_terminal
->reference_count
== 0
6099 && initial_terminal
->delete_terminal_hook
)
6100 (*initial_terminal
->delete_terminal_hook
) (initial_terminal
);
6102 /* Update frame parameters to reflect the new type. */
6103 Fmodify_frame_parameters
6104 (selected_frame
, list1 (Fcons (Qtty_type
,
6105 Ftty_type (selected_frame
))));
6106 if (t
->display_info
.tty
->name
)
6107 Fmodify_frame_parameters
6109 list1 (Fcons (Qtty
, build_string (t
->display_info
.tty
->name
))));
6111 Fmodify_frame_parameters (selected_frame
, list1 (Fcons (Qtty
, Qnil
)));
6115 struct frame
*sf
= SELECTED_FRAME ();
6116 int width
= FRAME_TOTAL_COLS (sf
);
6117 int height
= FRAME_LINES (sf
);
6119 /* If these sizes are so big they cause overflow, just ignore the
6120 change. It's not clear what better we could do. The rest of
6121 the code assumes that (width + 2) * height * sizeof (struct glyph)
6122 does not overflow and does not exceed PTRDIFF_MAX or SIZE_MAX. */
6123 if (INT_ADD_RANGE_OVERFLOW (width
, 2, INT_MIN
, INT_MAX
)
6124 || INT_MULTIPLY_RANGE_OVERFLOW (width
+ 2, height
, INT_MIN
, INT_MAX
)
6125 || (min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof (struct glyph
)
6126 < (width
+ 2) * height
))
6127 fatal ("screen size %dx%d too big", width
, height
);
6130 calculate_costs (XFRAME (selected_frame
));
6132 /* Set up faces of the initial terminal frame of a dumped Emacs. */
6135 && NILP (Vinitial_window_system
))
6137 /* For the initial frame, we don't have any way of knowing what
6138 are the foreground and background colors of the terminal. */
6139 struct frame
*sf
= SELECTED_FRAME ();
6141 FRAME_FOREGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_FG_COLOR
;
6142 FRAME_BACKGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_BG_COLOR
;
6143 call0 (intern ("tty-set-up-initial-frame-faces"));
6149 /***********************************************************************
6151 ***********************************************************************/
6153 DEFUN ("internal-show-cursor", Finternal_show_cursor
,
6154 Sinternal_show_cursor
, 2, 2, 0,
6155 doc
: /* Set the cursor-visibility flag of WINDOW to SHOW.
6156 WINDOW nil means use the selected window. SHOW non-nil means
6157 show a cursor in WINDOW in the next redisplay. SHOW nil means
6158 don't show a cursor. */)
6159 (Lisp_Object window
, Lisp_Object show
)
6161 /* Don't change cursor state while redisplaying. This could confuse
6163 if (!redisplaying_p
)
6164 decode_any_window (window
)->cursor_off_p
= NILP (show
);
6169 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p
,
6170 Sinternal_show_cursor_p
, 0, 1, 0,
6171 doc
: /* Value is non-nil if next redisplay will display a cursor in WINDOW.
6172 WINDOW nil or omitted means report on the selected window. */)
6173 (Lisp_Object window
)
6175 return decode_any_window (window
)->cursor_off_p
? Qnil
: Qt
;
6178 DEFUN ("last-nonminibuffer-frame", Flast_nonminibuf_frame
,
6179 Slast_nonminibuf_frame
, 0, 0, 0,
6180 doc
: /* Value is last nonminibuffer frame. */)
6183 Lisp_Object frame
= Qnil
;
6185 if (last_nonminibuf_frame
)
6186 XSETFRAME (frame
, last_nonminibuf_frame
);
6191 /***********************************************************************
6193 ***********************************************************************/
6196 syms_of_display (void)
6198 defsubr (&Sredraw_frame
);
6199 defsubr (&Sredraw_display
);
6200 defsubr (&Sframe_or_buffer_changed_p
);
6201 defsubr (&Sopen_termscript
);
6203 defsubr (&Sredisplay
);
6204 defsubr (&Ssleep_for
);
6205 defsubr (&Ssend_string_to_terminal
);
6206 defsubr (&Sinternal_show_cursor
);
6207 defsubr (&Sinternal_show_cursor_p
);
6208 defsubr (&Slast_nonminibuf_frame
);
6211 defsubr (&Sdump_redisplay_history
);
6214 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
6215 staticpro (&frame_and_buffer_state
);
6217 DEFSYM (Qdisplay_table
, "display-table");
6218 DEFSYM (Qredisplay_dont_pause
, "redisplay-dont-pause");
6220 DEFVAR_INT ("baud-rate", baud_rate
,
6221 doc
: /* The output baud rate of the terminal.
6222 On most systems, changing this value will affect the amount of padding
6223 and the other strategic decisions made during redisplay. */);
6225 DEFVAR_BOOL ("inverse-video", inverse_video
,
6226 doc
: /* Non-nil means invert the entire frame display.
6227 This means everything is in inverse video which otherwise would not be. */);
6229 DEFVAR_BOOL ("visible-bell", visible_bell
,
6230 doc
: /* Non-nil means try to flash the frame to represent a bell.
6232 See also `ring-bell-function'. */);
6234 DEFVAR_BOOL ("no-redraw-on-reenter", no_redraw_on_reenter
,
6235 doc
: /* Non-nil means no need to redraw entire frame after suspending.
6236 A non-nil value is useful if the terminal can automatically preserve
6237 Emacs's frame display when you reenter Emacs.
6238 It is up to you to set this variable if your terminal can do that. */);
6240 DEFVAR_LISP ("initial-window-system", Vinitial_window_system
,
6241 doc
: /* Name of the window system that Emacs uses for the first frame.
6242 The value is a symbol:
6243 nil for a termcap frame (a character-only terminal),
6244 'x' for an Emacs frame that is really an X window,
6245 'w32' for an Emacs frame that is a window on MS-Windows display,
6246 'ns' for an Emacs frame on a GNUstep or Macintosh Cocoa display,
6247 'pc' for a direct-write MS-DOS frame.
6249 Use of this variable as a boolean is deprecated. Instead,
6250 use `display-graphic-p' or any of the other `display-*-p'
6251 predicates which report frame's specific UI-related capabilities. */);
6253 DEFVAR_KBOARD ("window-system", Vwindow_system
,
6254 doc
: /* Name of window system through which the selected frame is displayed.
6255 The value is a symbol:
6256 nil for a termcap frame (a character-only terminal),
6257 'x' for an Emacs frame that is really an X window,
6258 'w32' for an Emacs frame that is a window on MS-Windows display,
6259 'ns' for an Emacs frame on a GNUstep or Macintosh Cocoa display,
6260 'pc' for a direct-write MS-DOS frame.
6262 Use of this variable as a boolean is deprecated. Instead,
6263 use `display-graphic-p' or any of the other `display-*-p'
6264 predicates which report frame's specific UI-related capabilities. */);
6266 DEFVAR_LISP ("window-system-version", Vwindow_system_version
,
6267 doc
: /* The version number of the window system in use.
6268 For X windows, this is 11. */);
6270 DEFVAR_BOOL ("cursor-in-echo-area", cursor_in_echo_area
,
6271 doc
: /* Non-nil means put cursor in minibuffer, at end of any message there. */);
6273 DEFVAR_LISP ("glyph-table", Vglyph_table
,
6274 doc
: /* Table defining how to output a glyph code to the frame.
6275 If not nil, this is a vector indexed by glyph code to define the glyph.
6276 Each element can be:
6277 integer: a glyph code which this glyph is an alias for.
6278 string: output this glyph using that string (not impl. in X windows).
6279 nil: this glyph mod 524288 is the code of a character to output,
6280 and this glyph / 524288 is the face number (see `face-id') to use
6281 while outputting it. */);
6282 Vglyph_table
= Qnil
;
6284 DEFVAR_LISP ("standard-display-table", Vstandard_display_table
,
6285 doc
: /* Display table to use for buffers that specify none.
6286 See `buffer-display-table' for more information. */);
6287 Vstandard_display_table
= Qnil
;
6289 DEFVAR_BOOL ("redisplay-dont-pause", redisplay_dont_pause
,
6290 doc
: /* Non-nil means display update isn't paused when input is detected. */);
6291 redisplay_dont_pause
= 1;
6297 Vinitial_window_system
= Qnil
;
6298 Vwindow_system_version
= Qnil
;