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/>. */
28 /* cm.h must come after dispextern.h on Windows. */
29 #include "dispextern.h"
31 #include "character.h"
35 #include "termhooks.h"
40 #include "intervals.h"
41 #include "blockinput.h"
44 #include "syssignal.h"
47 #ifdef HAVE_WINDOW_SYSTEM
49 #endif /* HAVE_WINDOW_SYSTEM */
60 /* Structure to pass dimensions around. Used for character bounding
61 boxes, glyph matrix dimensions and alike. */
70 /* Function prototypes. */
72 static void update_frame_line (struct frame
*, int);
73 static int required_matrix_height (struct window
*);
74 static int required_matrix_width (struct window
*);
75 static void change_frame_size_1 (struct frame
*, int, int, bool, bool, bool);
76 static void increment_row_positions (struct glyph_row
*, ptrdiff_t, ptrdiff_t);
77 static void build_frame_matrix_from_window_tree (struct glyph_matrix
*,
79 static void build_frame_matrix_from_leaf_window (struct glyph_matrix
*,
81 static void adjust_decode_mode_spec_buffer (struct frame
*);
82 static void fill_up_glyph_row_with_spaces (struct glyph_row
*);
83 static void clear_window_matrices (struct window
*, bool);
84 static void fill_up_glyph_row_area_with_spaces (struct glyph_row
*, int);
85 static int scrolling_window (struct window
*, bool);
86 static bool update_window_line (struct window
*, int, bool *);
87 static void mirror_make_current (struct window
*, int);
89 static void check_matrix_pointers (struct glyph_matrix
*,
90 struct glyph_matrix
*);
92 static void mirror_line_dance (struct window
*, int, int, int *, char *);
93 static bool update_window_tree (struct window
*, bool);
94 static bool update_window (struct window
*, bool);
95 static bool update_frame_1 (struct frame
*, bool, bool);
96 static bool scrolling (struct frame
*);
97 static void set_window_cursor_after_update (struct window
*);
98 static void adjust_frame_glyphs_for_window_redisplay (struct frame
*);
99 static void adjust_frame_glyphs_for_frame_redisplay (struct frame
*);
100 static void set_window_update_flags (struct window
*w
, bool on_p
);
102 /* True means last display completed. False means it was preempted. */
104 bool display_completed
;
106 Lisp_Object Qdisplay_table
, Qredisplay_dont_pause
;
108 /* True means SIGWINCH happened when not safe. */
110 static bool delayed_size_change
;
112 /* A glyph for a space. */
114 struct glyph space_glyph
;
116 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
118 /* Counts of allocated structures. These counts serve to diagnose
119 memory leaks and double frees. */
121 static int glyph_matrix_count
;
122 static int glyph_pool_count
;
124 #endif /* GLYPH_DEBUG and ENABLE_CHECKING */
126 /* If non-null, the frame whose frame matrices are manipulated. If
127 null, window matrices are worked on. */
129 static struct frame
*frame_matrix_frame
;
131 /* Convert vpos and hpos from frame to window and vice versa.
132 This may only be used for terminal frames. */
136 static int window_to_frame_vpos (struct window
*, int);
137 static int window_to_frame_hpos (struct window
*, int);
138 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
139 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
141 /* One element of the ring buffer containing redisplay history
144 struct redisplay_history
146 char trace
[512 + 100];
149 /* The size of the history buffer. */
151 #define REDISPLAY_HISTORY_SIZE 30
153 /* The redisplay history buffer. */
155 static struct redisplay_history redisplay_history
[REDISPLAY_HISTORY_SIZE
];
157 /* Next free entry in redisplay_history. */
159 static int history_idx
;
161 /* A tick that's incremented each time something is added to the
164 static uprintmax_t history_tick
;
166 /* Add to the redisplay history how window W has been displayed.
167 MSG is a trace containing the information how W's glyph matrix
168 has been constructed. PAUSED_P means that the update
169 has been interrupted for pending input. */
172 add_window_display_history (struct window
*w
, const char *msg
, bool paused_p
)
177 if (history_idx
>= REDISPLAY_HISTORY_SIZE
)
179 buf
= redisplay_history
[history_idx
].trace
;
182 snprintf (buf
, sizeof redisplay_history
[0].trace
,
183 "%"pMu
": window %p (`%s')%s\n%s",
186 ((BUFFERP (w
->contents
)
187 && STRINGP (BVAR (XBUFFER (w
->contents
), name
)))
188 ? SSDATA (BVAR (XBUFFER (w
->contents
), name
))
190 paused_p
? " ***paused***" : "",
195 /* Add to the redisplay history that frame F has been displayed.
196 PAUSED_P means that the update has been interrupted for
200 add_frame_display_history (struct frame
*f
, bool paused_p
)
205 if (history_idx
>= REDISPLAY_HISTORY_SIZE
)
207 buf
= redisplay_history
[history_idx
].trace
;
210 sprintf (buf
, "%"pMu
": update frame %p%s",
212 ptr
, paused_p
? " ***paused***" : "");
216 DEFUN ("dump-redisplay-history", Fdump_redisplay_history
,
217 Sdump_redisplay_history
, 0, 0, "",
218 doc
: /* Dump redisplay history to stderr. */)
223 for (i
= history_idx
- 1; i
!= history_idx
; --i
)
226 i
= REDISPLAY_HISTORY_SIZE
- 1;
227 fprintf (stderr
, "%s\n", redisplay_history
[i
].trace
);
234 #else /* not GLYPH_DEBUG */
236 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + WINDOW_TOP_EDGE_LINE (W))
237 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + WINDOW_LEFT_EDGE_COL (W))
239 #endif /* GLYPH_DEBUG */
242 #if (defined PROFILING \
243 && (defined __FreeBSD__ || defined GNU_LINUX || defined __MINGW32__) \
244 && !HAVE___EXECUTABLE_START)
245 /* This function comes first in the Emacs executable and is used only
246 to estimate the text start for profiling. */
248 __executable_start (void)
254 /***********************************************************************
256 ***********************************************************************/
258 /* Allocate and return a glyph_matrix structure. POOL is the glyph
259 pool from which memory for the matrix should be allocated, or null
260 for window-based redisplay where no glyph pools are used. The
261 member `pool' of the glyph matrix structure returned is set to
262 POOL, the structure is otherwise zeroed. */
264 static struct glyph_matrix
*
265 new_glyph_matrix (struct glyph_pool
*pool
)
267 struct glyph_matrix
*result
= xzalloc (sizeof *result
);
269 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
270 /* Increment number of allocated matrices. This count is used
271 to detect memory leaks. */
272 ++glyph_matrix_count
;
275 /* Set pool and return. */
281 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
283 If GLYPH_DEBUG and ENABLE_CHECKING are in effect, the global counter
284 glyph_matrix_count is decremented when a matrix is freed. If the count
285 gets negative, more structures were freed than allocated, i.e. one matrix
286 was freed more than once or a bogus pointer was passed to this function.
288 If MATRIX->pool is null, this means that the matrix manages its own
289 glyph memory---this is done for matrices on X frames. Freeing the
290 matrix also frees the glyph memory in this case. */
293 free_glyph_matrix (struct glyph_matrix
*matrix
)
299 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
300 /* Detect the case that more matrices are freed than were
302 --glyph_matrix_count
;
303 eassert (glyph_matrix_count
>= 0);
306 /* Free glyph memory if MATRIX owns it. */
307 if (matrix
->pool
== NULL
)
308 for (i
= 0; i
< matrix
->rows_allocated
; ++i
)
309 xfree (matrix
->rows
[i
].glyphs
[LEFT_MARGIN_AREA
]);
311 /* Free row structures and the matrix itself. */
312 xfree (matrix
->rows
);
318 /* Return the number of glyphs to reserve for a marginal area of
319 window W. TOTAL_GLYPHS is the number of glyphs in a complete
320 display line of window W. MARGIN gives the width of the marginal
321 area in canonical character units. */
324 margin_glyphs_to_reserve (struct window
*w
, int total_glyphs
, int margin
)
328 int width
= w
->total_cols
;
329 double d
= max (0, margin
);
330 d
= min (width
/ 2 - 1, d
);
331 return (int) ((double) total_glyphs
/ width
* d
);
336 /* Return true if ROW's hash value is correct.
337 Optimized away if ENABLE_CHECKING is not defined. */
340 verify_row_hash (struct glyph_row
*row
)
342 return row
->hash
== row_hash (row
);
345 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
348 W is null if the function is called for a frame glyph matrix.
349 Otherwise it is the window MATRIX is a member of. X and Y are the
350 indices of the first column and row of MATRIX within the frame
351 matrix, if such a matrix exists. They are zero for purely
352 window-based redisplay. DIM is the needed size of the matrix.
354 In window-based redisplay, where no frame matrices exist, glyph
355 matrices manage their own glyph storage. Otherwise, they allocate
356 storage from a common frame glyph pool which can be found in
359 The reason for this memory management strategy is to avoid complete
360 frame redraws if possible. When we allocate from a common pool, a
361 change of the location or size of a sub-matrix within the pool
362 requires a complete redisplay of the frame because we cannot easily
363 make sure that the current matrices of all windows still agree with
364 what is displayed on the screen. While this is usually fast, it
365 leads to screen flickering. */
368 adjust_glyph_matrix (struct window
*w
, struct glyph_matrix
*matrix
, int x
, int y
, struct dim dim
)
372 bool marginal_areas_changed_p
= 0;
373 bool header_line_changed_p
= 0;
374 bool header_line_p
= 0;
375 int left
= -1, right
= -1;
376 int window_width
= -1, window_height
= -1;
378 /* See if W had a header line that has disappeared now, or vice versa.
382 window_box (w
, ANY_AREA
, 0, 0, &window_width
, &window_height
);
384 header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
385 header_line_changed_p
= header_line_p
!= matrix
->header_line_p
;
387 matrix
->header_line_p
= header_line_p
;
389 /* If POOL is null, MATRIX is a window matrix for window-based redisplay.
390 Do nothing if MATRIX' size, position, vscroll, and marginal areas
391 haven't changed. This optimization is important because preserving
392 the matrix means preventing redisplay. */
393 if (matrix
->pool
== NULL
)
395 left
= margin_glyphs_to_reserve (w
, dim
.width
, w
->left_margin_cols
);
396 right
= margin_glyphs_to_reserve (w
, dim
.width
, w
->right_margin_cols
);
397 eassert (left
>= 0 && right
>= 0);
398 marginal_areas_changed_p
= (left
!= matrix
->left_margin_glyphs
399 || right
!= matrix
->right_margin_glyphs
);
401 if (!marginal_areas_changed_p
402 && !XFRAME (w
->frame
)->fonts_changed
403 && !header_line_changed_p
404 && matrix
->window_left_col
== WINDOW_LEFT_EDGE_COL (w
)
405 && matrix
->window_top_line
== WINDOW_TOP_EDGE_LINE (w
)
406 && matrix
->window_height
== window_height
407 && matrix
->window_vscroll
== w
->vscroll
408 && matrix
->window_width
== window_width
)
412 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
413 if (matrix
->rows_allocated
< dim
.height
)
415 int old_alloc
= matrix
->rows_allocated
;
416 new_rows
= dim
.height
- matrix
->rows_allocated
;
417 matrix
->rows
= xpalloc (matrix
->rows
, &matrix
->rows_allocated
,
418 new_rows
, INT_MAX
, sizeof *matrix
->rows
);
419 memset (matrix
->rows
+ old_alloc
, 0,
420 (matrix
->rows_allocated
- old_alloc
) * sizeof *matrix
->rows
);
425 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
426 on a frame not using window-based redisplay. Set up pointers for
427 each row into the glyph pool. */
430 eassert (matrix
->pool
->glyphs
);
434 left
= margin_glyphs_to_reserve (w
, dim
.width
,
435 w
->left_margin_cols
);
436 right
= margin_glyphs_to_reserve (w
, dim
.width
,
437 w
->right_margin_cols
);
442 for (i
= 0; i
< dim
.height
; ++i
)
444 struct glyph_row
*row
= &matrix
->rows
[i
];
446 row
->glyphs
[LEFT_MARGIN_AREA
]
447 = (matrix
->pool
->glyphs
448 + (y
+ i
) * matrix
->pool
->ncolumns
452 || row
== matrix
->rows
+ dim
.height
- 1
453 || (row
== matrix
->rows
&& matrix
->header_line_p
))
455 row
->glyphs
[TEXT_AREA
]
456 = row
->glyphs
[LEFT_MARGIN_AREA
];
457 row
->glyphs
[RIGHT_MARGIN_AREA
]
458 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
459 row
->glyphs
[LAST_AREA
]
460 = row
->glyphs
[RIGHT_MARGIN_AREA
];
464 row
->glyphs
[TEXT_AREA
]
465 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
466 row
->glyphs
[RIGHT_MARGIN_AREA
]
467 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
468 row
->glyphs
[LAST_AREA
]
469 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
473 matrix
->left_margin_glyphs
= left
;
474 matrix
->right_margin_glyphs
= right
;
478 /* If MATRIX->pool is null, MATRIX is responsible for managing
479 its own memory. It is a window matrix for window-based redisplay.
480 Allocate glyph memory from the heap. */
481 if (dim
.width
> matrix
->matrix_w
483 || header_line_changed_p
484 || marginal_areas_changed_p
)
486 struct glyph_row
*row
= matrix
->rows
;
487 struct glyph_row
*end
= row
+ matrix
->rows_allocated
;
491 row
->glyphs
[LEFT_MARGIN_AREA
]
492 = xnrealloc (row
->glyphs
[LEFT_MARGIN_AREA
],
493 dim
.width
, sizeof (struct glyph
));
495 /* The mode line never has marginal areas. */
496 if (row
== matrix
->rows
+ dim
.height
- 1
497 || (row
== matrix
->rows
&& matrix
->header_line_p
))
499 row
->glyphs
[TEXT_AREA
]
500 = row
->glyphs
[LEFT_MARGIN_AREA
];
501 row
->glyphs
[RIGHT_MARGIN_AREA
]
502 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
503 row
->glyphs
[LAST_AREA
]
504 = row
->glyphs
[RIGHT_MARGIN_AREA
];
508 row
->glyphs
[TEXT_AREA
]
509 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
510 row
->glyphs
[RIGHT_MARGIN_AREA
]
511 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
512 row
->glyphs
[LAST_AREA
]
513 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
519 eassert (left
>= 0 && right
>= 0);
520 matrix
->left_margin_glyphs
= left
;
521 matrix
->right_margin_glyphs
= right
;
524 /* Number of rows to be used by MATRIX. */
525 matrix
->nrows
= dim
.height
;
526 eassert (matrix
->nrows
>= 0);
530 if (matrix
== w
->current_matrix
)
532 /* Mark rows in a current matrix of a window as not having
533 valid contents. It's important to not do this for
534 desired matrices. When Emacs starts, it may already be
535 building desired matrices when this function runs. */
536 if (window_width
< 0)
537 window_width
= window_box_width (w
, -1);
539 /* Optimize the case that only the height has changed (C-x 2,
540 upper window). Invalidate all rows that are no longer part
542 if (!marginal_areas_changed_p
543 && !header_line_changed_p
545 && dim
.width
== matrix
->matrix_w
546 && matrix
->window_left_col
== WINDOW_LEFT_EDGE_COL (w
)
547 && matrix
->window_top_line
== WINDOW_TOP_EDGE_LINE (w
)
548 && matrix
->window_width
== window_width
)
550 /* Find the last row in the window. */
551 for (i
= 0; i
< matrix
->nrows
&& matrix
->rows
[i
].enabled_p
; ++i
)
552 if (MATRIX_ROW_BOTTOM_Y (matrix
->rows
+ i
) >= window_height
)
558 /* Window end is invalid, if inside of the rows that
559 are invalidated below. */
560 if (w
->window_end_vpos
>= i
)
561 w
->window_end_valid
= 0;
563 while (i
< matrix
->nrows
)
564 matrix
->rows
[i
++].enabled_p
= 0;
568 for (i
= 0; i
< matrix
->nrows
; ++i
)
569 matrix
->rows
[i
].enabled_p
= 0;
572 else if (matrix
== w
->desired_matrix
)
574 /* Rows in desired matrices always have to be cleared;
575 redisplay expects this is the case when it runs, so it
576 had better be the case when we adjust matrices between
578 for (i
= 0; i
< matrix
->nrows
; ++i
)
579 matrix
->rows
[i
].enabled_p
= 0;
584 /* Remember last values to be able to optimize frame redraws. */
585 matrix
->matrix_x
= x
;
586 matrix
->matrix_y
= y
;
587 matrix
->matrix_w
= dim
.width
;
588 matrix
->matrix_h
= dim
.height
;
590 /* Record the top y location and height of W at the time the matrix
591 was last adjusted. This is used to optimize redisplay above. */
594 matrix
->window_left_col
= WINDOW_LEFT_EDGE_COL (w
);
595 matrix
->window_top_line
= WINDOW_TOP_EDGE_LINE (w
);
596 matrix
->window_height
= window_height
;
597 matrix
->window_width
= window_width
;
598 matrix
->window_vscroll
= w
->vscroll
;
603 /* Reverse the contents of rows in MATRIX between START and END. The
604 contents of the row at END - 1 end up at START, END - 2 at START +
605 1 etc. This is part of the implementation of rotate_matrix (see
609 reverse_rows (struct glyph_matrix
*matrix
, int start
, int end
)
613 for (i
= start
, j
= end
- 1; i
< j
; ++i
, --j
)
615 /* Non-ISO HP/UX compiler doesn't like auto struct
617 struct glyph_row temp
;
618 temp
= matrix
->rows
[i
];
619 matrix
->rows
[i
] = matrix
->rows
[j
];
620 matrix
->rows
[j
] = temp
;
625 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
626 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
627 indices. (Note: this does not copy glyphs, only glyph pointers in
628 row structures are moved around).
630 The algorithm used for rotating the vector was, I believe, first
631 described by Kernighan. See the vector R as consisting of two
632 sub-vectors AB, where A has length BY for BY >= 0. The result
633 after rotating is then BA. Reverse both sub-vectors to get ArBr
634 and reverse the result to get (ArBr)r which is BA. Similar for
638 rotate_matrix (struct glyph_matrix
*matrix
, int first
, int last
, int by
)
642 /* Up (rotate left, i.e. towards lower indices). */
644 reverse_rows (matrix
, first
, first
+ by
);
645 reverse_rows (matrix
, first
+ by
, last
);
646 reverse_rows (matrix
, first
, last
);
650 /* Down (rotate right, i.e. towards higher indices). */
651 reverse_rows (matrix
, last
- by
, last
);
652 reverse_rows (matrix
, first
, last
- by
);
653 reverse_rows (matrix
, first
, last
);
658 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
659 with indices START <= index < END. Increment positions by DELTA/
663 increment_matrix_positions (struct glyph_matrix
*matrix
, int start
, int end
,
664 ptrdiff_t delta
, ptrdiff_t delta_bytes
)
666 /* Check that START and END are reasonable values. */
667 eassert (start
>= 0 && start
<= matrix
->nrows
);
668 eassert (end
>= 0 && end
<= matrix
->nrows
);
669 eassert (start
<= end
);
671 for (; start
< end
; ++start
)
672 increment_row_positions (matrix
->rows
+ start
, delta
, delta_bytes
);
676 /* Clear the enable_p flags in a range of rows in glyph matrix MATRIX.
677 START and END are the row indices of the first and last + 1 row to clear. */
680 clear_glyph_matrix_rows (struct glyph_matrix
*matrix
, int start
, int end
)
682 eassert (start
<= end
);
683 eassert (start
>= 0 && start
< matrix
->nrows
);
684 eassert (end
>= 0 && end
<= matrix
->nrows
);
686 for (; start
< end
; ++start
)
687 matrix
->rows
[start
].enabled_p
= 0;
693 Empty all rows in MATRIX by clearing their enabled_p flags.
694 The function prepare_desired_row will eventually really clear a row
695 when it sees one with a false enabled_p flag.
697 Reset update hints to default values. The only update hint
698 currently present is the flag MATRIX->no_scrolling_p. */
701 clear_glyph_matrix (struct glyph_matrix
*matrix
)
705 clear_glyph_matrix_rows (matrix
, 0, matrix
->nrows
);
706 matrix
->no_scrolling_p
= 0;
711 /* Shift part of the glyph matrix MATRIX of window W up or down.
712 Increment y-positions in glyph rows between START and END by DY,
713 and recompute their visible height. */
716 shift_glyph_matrix (struct window
*w
, struct glyph_matrix
*matrix
, int start
, int end
, int dy
)
720 eassert (start
<= end
);
721 eassert (start
>= 0 && start
< matrix
->nrows
);
722 eassert (end
>= 0 && end
<= matrix
->nrows
);
724 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
725 max_y
= WINDOW_BOX_HEIGHT_NO_MODE_LINE (w
);
727 for (; start
< end
; ++start
)
729 struct glyph_row
*row
= &matrix
->rows
[start
];
732 row
->visible_height
= row
->height
;
735 row
->visible_height
-= min_y
- row
->y
;
736 if (row
->y
+ row
->height
> max_y
)
737 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
738 if (row
->fringe_bitmap_periodic_p
)
739 row
->redraw_fringe_bitmaps_p
= 1;
744 /* Mark all rows in current matrices of frame F as invalid. Marking
745 invalid is done by setting enabled_p to zero for all rows in a
749 clear_current_matrices (register struct frame
*f
)
751 /* Clear frame current matrix, if we have one. */
752 if (f
->current_matrix
)
753 clear_glyph_matrix (f
->current_matrix
);
755 #if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
756 /* Clear the matrix of the menu bar window, if such a window exists.
757 The menu bar window is currently used to display menus on X when
758 no toolkit support is compiled in. */
759 if (WINDOWP (f
->menu_bar_window
))
760 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->current_matrix
);
763 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (USE_GTK) && ! defined (HAVE_NS)
764 /* Clear the matrix of the tool-bar window, if any. */
765 if (WINDOWP (f
->tool_bar_window
))
766 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
769 /* Clear current window matrices. */
770 eassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
771 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 0);
775 /* Clear out all display lines of F for a coming redisplay. */
778 clear_desired_matrices (register struct frame
*f
)
780 if (f
->desired_matrix
)
781 clear_glyph_matrix (f
->desired_matrix
);
783 #if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
784 if (WINDOWP (f
->menu_bar_window
))
785 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->desired_matrix
);
788 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (USE_GTK) && ! defined (HAVE_NS)
789 if (WINDOWP (f
->tool_bar_window
))
790 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->desired_matrix
);
793 /* Do it for window matrices. */
794 eassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
795 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
799 /* Clear matrices in window tree rooted in W. If DESIRED_P,
800 clear desired matrices, otherwise clear current matrices. */
803 clear_window_matrices (struct window
*w
, bool desired_p
)
807 if (WINDOWP (w
->contents
))
808 clear_window_matrices (XWINDOW (w
->contents
), desired_p
);
812 clear_glyph_matrix (w
->desired_matrix
);
815 clear_glyph_matrix (w
->current_matrix
);
816 w
->window_end_valid
= 0;
820 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
826 /***********************************************************************
829 See dispextern.h for an overall explanation of glyph rows.
830 ***********************************************************************/
832 /* Clear glyph row ROW. NOTE: this code relies on the current
833 layout of `glyphs' and `used' fields of `struct glyph_row'. */
836 clear_glyph_row (struct glyph_row
*row
)
838 enum { off
= offsetof (struct glyph_row
, used
) };
840 /* Zero everything except pointers in `glyphs'. */
841 memset (row
->used
, 0, sizeof *row
- off
);
845 /* Make ROW an empty, enabled row of canonical character height,
846 in window W starting at y-position Y. */
849 blank_row (struct window
*w
, struct glyph_row
*row
, int y
)
853 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
854 max_y
= WINDOW_BOX_HEIGHT_NO_MODE_LINE (w
);
856 clear_glyph_row (row
);
858 row
->ascent
= row
->phys_ascent
= 0;
859 row
->height
= row
->phys_height
= FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
860 row
->visible_height
= row
->height
;
863 row
->visible_height
-= min_y
- row
->y
;
864 if (row
->y
+ row
->height
> max_y
)
865 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
871 /* Increment buffer positions in glyph row ROW. DELTA and DELTA_BYTES
872 are the amounts by which to change positions. Note that the first
873 glyph of the text area of a row can have a buffer position even if
874 the used count of the text area is zero. Such rows display line
878 increment_row_positions (struct glyph_row
*row
,
879 ptrdiff_t delta
, ptrdiff_t delta_bytes
)
883 /* Increment start and end positions. */
884 MATRIX_ROW_START_CHARPOS (row
) += delta
;
885 MATRIX_ROW_START_BYTEPOS (row
) += delta_bytes
;
886 MATRIX_ROW_END_CHARPOS (row
) += delta
;
887 MATRIX_ROW_END_BYTEPOS (row
) += delta_bytes
;
888 CHARPOS (row
->start
.pos
) += delta
;
889 BYTEPOS (row
->start
.pos
) += delta_bytes
;
890 CHARPOS (row
->end
.pos
) += delta
;
891 BYTEPOS (row
->end
.pos
) += delta_bytes
;
896 /* Increment positions in glyphs. */
897 for (area
= 0; area
< LAST_AREA
; ++area
)
898 for (i
= 0; i
< row
->used
[area
]; ++i
)
899 if (BUFFERP (row
->glyphs
[area
][i
].object
)
900 && row
->glyphs
[area
][i
].charpos
> 0)
901 row
->glyphs
[area
][i
].charpos
+= delta
;
903 /* Capture the case of rows displaying a line end. */
904 if (row
->used
[TEXT_AREA
] == 0
905 && MATRIX_ROW_DISPLAYS_TEXT_P (row
))
906 row
->glyphs
[TEXT_AREA
]->charpos
+= delta
;
911 /* Swap glyphs between two glyph rows A and B. This exchanges glyph
912 contents, i.e. glyph structure contents are exchanged between A and
913 B without changing glyph pointers in A and B. */
916 swap_glyphs_in_rows (struct glyph_row
*a
, struct glyph_row
*b
)
920 for (area
= 0; area
< LAST_AREA
; ++area
)
922 /* Number of glyphs to swap. */
923 int max_used
= max (a
->used
[area
], b
->used
[area
]);
925 /* Start of glyphs in area of row A. */
926 struct glyph
*glyph_a
= a
->glyphs
[area
];
928 /* End + 1 of glyphs in area of row A. */
929 struct glyph
*glyph_a_end
= a
->glyphs
[max_used
];
931 /* Start of glyphs in area of row B. */
932 struct glyph
*glyph_b
= b
->glyphs
[area
];
934 while (glyph_a
< glyph_a_end
)
936 /* Non-ISO HP/UX compiler doesn't like auto struct
950 /* Exchange pointers to glyph memory between glyph rows A and B. Also
951 exchange the used[] array and the hash values of the rows, because
952 these should all go together for the row's hash value to be
956 swap_glyph_pointers (struct glyph_row
*a
, struct glyph_row
*b
)
959 unsigned hash_tem
= a
->hash
;
961 for (i
= 0; i
< LAST_AREA
+ 1; ++i
)
963 struct glyph
*temp
= a
->glyphs
[i
];
965 a
->glyphs
[i
] = b
->glyphs
[i
];
969 short used_tem
= a
->used
[i
];
971 a
->used
[i
] = b
->used
[i
];
972 b
->used
[i
] = used_tem
;
980 /* Copy glyph row structure FROM to glyph row structure TO, except that
981 glyph pointers, the `used' counts, and the hash values in the structures
982 are left unchanged. NOTE: this code relies on the current layout of
983 `glyphs', `used', `hash' and `x' fields of `struct glyph_row'. */
986 copy_row_except_pointers (struct glyph_row
*to
, struct glyph_row
*from
)
988 enum { off
= offsetof (struct glyph_row
, x
) };
990 memcpy (&to
->x
, &from
->x
, sizeof *to
- off
);
994 /* Assign glyph row FROM to glyph row TO. This works like a structure
995 assignment TO = FROM, except that glyph pointers are not copied but
996 exchanged between TO and FROM. Pointers must be exchanged to avoid
1000 assign_row (struct glyph_row
*to
, struct glyph_row
*from
)
1002 swap_glyph_pointers (to
, from
);
1003 copy_row_except_pointers (to
, from
);
1007 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1008 a row in a window matrix, is a slice of the glyph memory of the
1009 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1010 is true if the glyph memory of WINDOW_ROW is part of the glyph
1011 memory of FRAME_ROW. */
1016 glyph_row_slice_p (struct glyph_row
*window_row
, struct glyph_row
*frame_row
)
1018 struct glyph
*window_glyph_start
= window_row
->glyphs
[0];
1019 struct glyph
*frame_glyph_start
= frame_row
->glyphs
[0];
1020 struct glyph
*frame_glyph_end
= frame_row
->glyphs
[LAST_AREA
];
1022 return (frame_glyph_start
<= window_glyph_start
1023 && window_glyph_start
< frame_glyph_end
);
1026 #endif /* GLYPH_DEBUG */
1030 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1031 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1032 in WINDOW_MATRIX is found satisfying the condition. */
1034 static struct glyph_row
*
1035 find_glyph_row_slice (struct glyph_matrix
*window_matrix
,
1036 struct glyph_matrix
*frame_matrix
, int row
)
1040 eassert (row
>= 0 && row
< frame_matrix
->nrows
);
1042 for (i
= 0; i
< window_matrix
->nrows
; ++i
)
1043 if (glyph_row_slice_p (window_matrix
->rows
+ i
,
1044 frame_matrix
->rows
+ row
))
1047 return i
< window_matrix
->nrows
? window_matrix
->rows
+ i
: 0;
1052 /* Prepare ROW for display. Desired rows are cleared lazily,
1053 i.e. they are only marked as to be cleared by setting their
1054 enabled_p flag to zero. When a row is to be displayed, a prior
1055 call to this function really clears it. */
1058 prepare_desired_row (struct glyph_row
*row
)
1060 if (!row
->enabled_p
)
1062 bool rp
= row
->reversed_p
;
1064 clear_glyph_row (row
);
1066 row
->reversed_p
= rp
;
1071 /* Return a hash code for glyph row ROW, which may
1072 be from current or desired matrix of frame F. */
1075 line_hash_code (struct frame
*f
, struct glyph_row
*row
)
1081 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
1082 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
1086 int c
= glyph
->u
.ch
;
1087 int face_id
= glyph
->face_id
;
1088 if (FRAME_MUST_WRITE_SPACES (f
))
1090 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + c
;
1091 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + face_id
;
1103 /* Return the cost of drawing line VPOS in MATRIX, which may
1104 be current or desired matrix of frame F. The cost equals
1105 the number of characters in the line. If must_write_spaces
1106 is zero, leading and trailing spaces are ignored. */
1109 line_draw_cost (struct frame
*f
, struct glyph_matrix
*matrix
, int vpos
)
1111 struct glyph_row
*row
= matrix
->rows
+ vpos
;
1112 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
1113 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
];
1115 Lisp_Object
*glyph_table_base
= GLYPH_TABLE_BASE
;
1116 ptrdiff_t glyph_table_len
= GLYPH_TABLE_LENGTH
;
1118 /* Ignore trailing and leading spaces if we can. */
1119 if (!FRAME_MUST_WRITE_SPACES (f
))
1121 /* Skip from the end over trailing spaces. */
1122 while (end
> beg
&& CHAR_GLYPH_SPACE_P (*(end
- 1)))
1125 /* All blank line. */
1129 /* Skip over leading spaces. */
1130 while (CHAR_GLYPH_SPACE_P (*beg
))
1134 /* If we don't have a glyph-table, each glyph is one character,
1135 so return the number of glyphs. */
1136 if (glyph_table_base
== 0)
1140 /* Otherwise, scan the glyphs and accumulate their total length
1147 SET_GLYPH_FROM_CHAR_GLYPH (g
, *beg
);
1149 if (GLYPH_INVALID_P (g
)
1150 || GLYPH_SIMPLE_P (glyph_table_base
, glyph_table_len
, g
))
1153 len
+= GLYPH_LENGTH (glyph_table_base
, g
);
1163 /* Return true if the glyph rows A and B have equal contents.
1164 MOUSE_FACE_P means compare the mouse_face_p flags of A and B, too. */
1167 row_equal_p (struct glyph_row
*a
, struct glyph_row
*b
, bool mouse_face_p
)
1169 eassert (verify_row_hash (a
));
1170 eassert (verify_row_hash (b
));
1174 else if (a
->hash
!= b
->hash
)
1178 struct glyph
*a_glyph
, *b_glyph
, *a_end
;
1181 if (mouse_face_p
&& a
->mouse_face_p
!= b
->mouse_face_p
)
1184 /* Compare glyphs. */
1185 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
1187 if (a
->used
[area
] != b
->used
[area
])
1190 a_glyph
= a
->glyphs
[area
];
1191 a_end
= a_glyph
+ a
->used
[area
];
1192 b_glyph
= b
->glyphs
[area
];
1194 while (a_glyph
< a_end
1195 && GLYPH_EQUAL_P (a_glyph
, b_glyph
))
1196 ++a_glyph
, ++b_glyph
;
1198 if (a_glyph
!= a_end
)
1202 if (a
->fill_line_p
!= b
->fill_line_p
1203 || a
->cursor_in_fringe_p
!= b
->cursor_in_fringe_p
1204 || a
->left_fringe_bitmap
!= b
->left_fringe_bitmap
1205 || a
->left_fringe_face_id
!= b
->left_fringe_face_id
1206 || a
->left_fringe_offset
!= b
->left_fringe_offset
1207 || a
->right_fringe_bitmap
!= b
->right_fringe_bitmap
1208 || a
->right_fringe_face_id
!= b
->right_fringe_face_id
1209 || a
->right_fringe_offset
!= b
->right_fringe_offset
1210 || a
->fringe_bitmap_periodic_p
!= b
->fringe_bitmap_periodic_p
1211 || a
->overlay_arrow_bitmap
!= b
->overlay_arrow_bitmap
1212 || a
->exact_window_width_line_p
!= b
->exact_window_width_line_p
1213 || a
->overlapped_p
!= b
->overlapped_p
1214 || (MATRIX_ROW_CONTINUATION_LINE_P (a
)
1215 != MATRIX_ROW_CONTINUATION_LINE_P (b
))
1216 || a
->reversed_p
!= b
->reversed_p
1217 /* Different partially visible characters on left margin. */
1219 /* Different height. */
1220 || a
->ascent
!= b
->ascent
1221 || a
->phys_ascent
!= b
->phys_ascent
1222 || a
->phys_height
!= b
->phys_height
1223 || a
->visible_height
!= b
->visible_height
)
1232 /***********************************************************************
1235 See dispextern.h for an overall explanation of glyph pools.
1236 ***********************************************************************/
1238 /* Allocate a glyph_pool structure. The structure returned is initialized
1239 with zeros. If GLYPH_DEBUG and ENABLE_CHECKING are in effect, the global
1240 variable glyph_pool_count is incremented for each pool allocated. */
1242 static struct glyph_pool
*
1243 new_glyph_pool (void)
1245 struct glyph_pool
*result
= xzalloc (sizeof *result
);
1247 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
1248 /* For memory leak and double deletion checking. */
1256 /* Free a glyph_pool structure POOL. The function may be called with
1257 a null POOL pointer. If GLYPH_DEBUG and ENABLE_CHECKING are in effect,
1258 global variable glyph_pool_count is decremented with every pool structure
1259 freed. If this count gets negative, more structures were freed than
1260 allocated, i.e. one structure must have been freed more than once or
1261 a bogus pointer was passed to free_glyph_pool. */
1264 free_glyph_pool (struct glyph_pool
*pool
)
1268 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
1269 /* More freed than allocated? */
1271 eassert (glyph_pool_count
>= 0);
1273 xfree (pool
->glyphs
);
1279 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1280 columns we need. This function never shrinks a pool. The only
1281 case in which this would make sense, would be when a frame's size
1282 is changed from a large value to a smaller one. But, if someone
1283 does it once, we can expect that he will do it again.
1285 Return true if the pool changed in a way which makes
1286 re-adjusting window glyph matrices necessary. */
1289 realloc_glyph_pool (struct glyph_pool
*pool
, struct dim matrix_dim
)
1294 changed_p
= (pool
->glyphs
== 0
1295 || matrix_dim
.height
!= pool
->nrows
1296 || matrix_dim
.width
!= pool
->ncolumns
);
1298 /* Enlarge the glyph pool. */
1299 needed
= matrix_dim
.width
;
1300 if (INT_MULTIPLY_OVERFLOW (needed
, matrix_dim
.height
))
1301 memory_full (SIZE_MAX
);
1302 needed
*= matrix_dim
.height
;
1303 if (needed
> pool
->nglyphs
)
1305 ptrdiff_t old_nglyphs
= pool
->nglyphs
;
1306 pool
->glyphs
= xpalloc (pool
->glyphs
, &pool
->nglyphs
,
1307 needed
- old_nglyphs
, -1, sizeof *pool
->glyphs
);
1308 memset (pool
->glyphs
+ old_nglyphs
, 0,
1309 (pool
->nglyphs
- old_nglyphs
) * sizeof *pool
->glyphs
);
1312 /* Remember the number of rows and columns because (a) we use them
1313 to do sanity checks, and (b) the number of columns determines
1314 where rows in the frame matrix start---this must be available to
1315 determine pointers to rows of window sub-matrices. */
1316 pool
->nrows
= matrix_dim
.height
;
1317 pool
->ncolumns
= matrix_dim
.width
;
1324 /***********************************************************************
1326 ***********************************************************************/
1331 /* Flush standard output. This is sometimes useful to call from the debugger.
1332 XXX Maybe this should be changed to flush the current terminal instead of
1336 void flush_stdout (void) EXTERNALLY_VISIBLE
;
1345 /* Check that no glyph pointers have been lost in MATRIX. If a
1346 pointer has been lost, e.g. by using a structure assignment between
1347 rows, at least one pointer must occur more than once in the rows of
1351 check_matrix_pointer_lossage (struct glyph_matrix
*matrix
)
1355 for (i
= 0; i
< matrix
->nrows
; ++i
)
1356 for (j
= 0; j
< matrix
->nrows
; ++j
)
1358 || (matrix
->rows
[i
].glyphs
[TEXT_AREA
]
1359 != matrix
->rows
[j
].glyphs
[TEXT_AREA
]));
1363 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1366 matrix_row (struct glyph_matrix
*matrix
, int row
)
1368 eassert (matrix
&& matrix
->rows
);
1369 eassert (row
>= 0 && row
< matrix
->nrows
);
1371 /* That's really too slow for normal testing because this function
1372 is called almost everywhere. Although---it's still astonishingly
1373 fast, so it is valuable to have for debugging purposes. */
1375 check_matrix_pointer_lossage (matrix
);
1378 return matrix
->rows
+ row
;
1382 #if 0 /* This function makes invalid assumptions when text is
1383 partially invisible. But it might come handy for debugging
1386 /* Check invariants that must hold for an up to date current matrix of
1390 check_matrix_invariants (struct window
*w
)
1392 struct glyph_matrix
*matrix
= w
->current_matrix
;
1393 int yb
= window_text_bottom_y (w
);
1394 struct glyph_row
*row
= matrix
->rows
;
1395 struct glyph_row
*last_text_row
= NULL
;
1396 struct buffer
*saved
= current_buffer
;
1397 struct buffer
*buffer
= XBUFFER (w
->contents
);
1400 /* This can sometimes happen for a fresh window. */
1401 if (matrix
->nrows
< 2)
1404 set_buffer_temp (buffer
);
1406 /* Note: last row is always reserved for the mode line. */
1407 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1408 && MATRIX_ROW_BOTTOM_Y (row
) < yb
)
1410 struct glyph_row
*next
= row
+ 1;
1412 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1413 last_text_row
= row
;
1415 /* Check that character and byte positions are in sync. */
1416 eassert (MATRIX_ROW_START_BYTEPOS (row
)
1417 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row
)));
1418 eassert (BYTEPOS (row
->start
.pos
)
1419 == CHAR_TO_BYTE (CHARPOS (row
->start
.pos
)));
1421 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1422 have such a position temporarily in case of a minibuffer
1423 displaying something like `[Sole completion]' at its end. */
1424 if (MATRIX_ROW_END_CHARPOS (row
) < BUF_ZV (current_buffer
))
1426 eassert (MATRIX_ROW_END_BYTEPOS (row
)
1427 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row
)));
1428 eassert (BYTEPOS (row
->end
.pos
)
1429 == CHAR_TO_BYTE (CHARPOS (row
->end
.pos
)));
1432 /* Check that end position of `row' is equal to start position
1434 if (next
->enabled_p
&& MATRIX_ROW_DISPLAYS_TEXT_P (next
))
1436 eassert (MATRIX_ROW_END_CHARPOS (row
)
1437 == MATRIX_ROW_START_CHARPOS (next
));
1438 eassert (MATRIX_ROW_END_BYTEPOS (row
)
1439 == MATRIX_ROW_START_BYTEPOS (next
));
1440 eassert (CHARPOS (row
->end
.pos
) == CHARPOS (next
->start
.pos
));
1441 eassert (BYTEPOS (row
->end
.pos
) == BYTEPOS (next
->start
.pos
));
1446 eassert (w
->current_matrix
->nrows
== w
->desired_matrix
->nrows
);
1447 eassert (w
->desired_matrix
->rows
!= NULL
);
1448 set_buffer_temp (saved
);
1453 #endif /* GLYPH_DEBUG */
1457 /**********************************************************************
1458 Allocating/ Adjusting Glyph Matrices
1459 **********************************************************************/
1461 /* Allocate glyph matrices over a window tree for a frame-based
1464 X and Y are column/row within the frame glyph matrix where
1465 sub-matrices for the window tree rooted at WINDOW must be
1466 allocated. DIM_ONLY_P means that the caller of this
1467 function is only interested in the result matrix dimension, and
1468 matrix adjustments should not be performed.
1470 The function returns the total width/height of the sub-matrices of
1471 the window tree. If called on a frame root window, the computation
1472 will take the mini-buffer window into account.
1474 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1476 NEW_LEAF_MATRIX set if any window in the tree did not have a
1477 glyph matrices yet, and
1479 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1480 any window in the tree will be changed or have been changed (see
1483 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1486 Windows are arranged into chains of windows on the same level
1487 through the next fields of window structures. Such a level can be
1488 either a sequence of horizontally adjacent windows from left to
1489 right, or a sequence of vertically adjacent windows from top to
1490 bottom. Each window in a horizontal sequence can be either a leaf
1491 window or a vertical sequence; a window in a vertical sequence can
1492 be either a leaf or a horizontal sequence. All windows in a
1493 horizontal sequence have the same height, and all windows in a
1494 vertical sequence have the same width.
1496 This function uses, for historical reasons, a more general
1497 algorithm to determine glyph matrix dimensions that would be
1500 The matrix height of a horizontal sequence is determined by the
1501 maximum height of any matrix in the sequence. The matrix width of
1502 a horizontal sequence is computed by adding up matrix widths of
1503 windows in the sequence.
1505 |<------- result width ------->|
1506 +---------+----------+---------+ ---
1509 +---------+ | | result height
1514 The matrix width of a vertical sequence is the maximum matrix width
1515 of any window in the sequence. Its height is computed by adding up
1516 matrix heights of windows in the sequence.
1518 |<---- result width -->|
1526 +------------+---------+ |
1529 +------------+---------+ --- */
1531 /* Bit indicating that a new matrix will be allocated or has been
1534 #define NEW_LEAF_MATRIX (1 << 0)
1536 /* Bit indicating that a matrix will or has changed its location or
1539 #define CHANGED_LEAF_MATRIX (1 << 1)
1542 allocate_matrices_for_frame_redisplay (Lisp_Object window
, int x
, int y
,
1543 bool dim_only_p
, int *window_change_flags
)
1545 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1547 int wmax
= 0, hmax
= 0;
1551 bool in_horz_combination_p
;
1553 /* What combination is WINDOW part of? Compute this once since the
1554 result is the same for all windows in the `next' chain. The
1555 special case of a root window (parent equal to nil) is treated
1556 like a vertical combination because a root window's `next'
1557 points to the mini-buffer window, if any, which is arranged
1558 vertically below other windows. */
1559 in_horz_combination_p
1560 = (!NILP (XWINDOW (window
)->parent
)
1561 && WINDOW_HORIZONTAL_COMBINATION_P (XWINDOW (XWINDOW (window
)->parent
)));
1563 /* For WINDOW and all windows on the same level. */
1566 w
= XWINDOW (window
);
1568 /* Get the dimension of the window sub-matrix for W, depending
1569 on whether this is a combination or a leaf window. */
1570 if (WINDOWP (w
->contents
))
1571 dim
= allocate_matrices_for_frame_redisplay (w
->contents
, x
, y
,
1573 window_change_flags
);
1576 /* If not already done, allocate sub-matrix structures. */
1577 if (w
->desired_matrix
== NULL
)
1579 w
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1580 w
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1581 *window_change_flags
|= NEW_LEAF_MATRIX
;
1584 /* Width and height MUST be chosen so that there are no
1585 holes in the frame matrix. */
1586 dim
.width
= required_matrix_width (w
);
1587 dim
.height
= required_matrix_height (w
);
1589 /* Will matrix be re-allocated? */
1590 if (x
!= w
->desired_matrix
->matrix_x
1591 || y
!= w
->desired_matrix
->matrix_y
1592 || dim
.width
!= w
->desired_matrix
->matrix_w
1593 || dim
.height
!= w
->desired_matrix
->matrix_h
1594 || (margin_glyphs_to_reserve (w
, dim
.width
,
1595 w
->left_margin_cols
)
1596 != w
->desired_matrix
->left_margin_glyphs
)
1597 || (margin_glyphs_to_reserve (w
, dim
.width
,
1598 w
->right_margin_cols
)
1599 != w
->desired_matrix
->right_margin_glyphs
))
1600 *window_change_flags
|= CHANGED_LEAF_MATRIX
;
1602 /* Actually change matrices, if allowed. Do not consider
1603 CHANGED_LEAF_MATRIX computed above here because the pool
1604 may have been changed which we don't now here. We trust
1605 that we only will be called with DIM_ONLY_P when
1609 adjust_glyph_matrix (w
, w
->desired_matrix
, x
, y
, dim
);
1610 adjust_glyph_matrix (w
, w
->current_matrix
, x
, y
, dim
);
1614 /* If we are part of a horizontal combination, advance x for
1615 windows to the right of W; otherwise advance y for windows
1617 if (in_horz_combination_p
)
1622 /* Remember maximum glyph matrix dimensions. */
1623 wmax
= max (wmax
, dim
.width
);
1624 hmax
= max (hmax
, dim
.height
);
1626 /* Next window on same level. */
1629 while (!NILP (window
));
1631 /* Set `total' to the total glyph matrix dimension of this window
1632 level. In a vertical combination, the width is the width of the
1633 widest window; the height is the y we finally reached, corrected
1634 by the y we started with. In a horizontal combination, the total
1635 height is the height of the tallest window, and the width is the
1636 x we finally reached, corrected by the x we started with. */
1637 if (in_horz_combination_p
)
1639 total
.width
= x
- x0
;
1640 total
.height
= hmax
;
1645 total
.height
= y
- y0
;
1652 /* Return the required height of glyph matrices for window W. */
1655 required_matrix_height (struct window
*w
)
1657 #ifdef HAVE_WINDOW_SYSTEM
1658 struct frame
*f
= XFRAME (w
->frame
);
1660 if (FRAME_WINDOW_P (f
))
1662 int ch_height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
1663 int window_pixel_height
= window_box_height (w
) + eabs (w
->vscroll
);
1664 return (((window_pixel_height
+ ch_height
- 1)
1665 / ch_height
) * w
->nrows_scale_factor
1666 /* One partially visible line at the top and
1667 bottom of the window. */
1669 /* 2 for header and mode line. */
1672 #endif /* HAVE_WINDOW_SYSTEM */
1674 return WINDOW_TOTAL_LINES (w
);
1678 /* Return the required width of glyph matrices for window W. */
1681 required_matrix_width (struct window
*w
)
1683 #ifdef HAVE_WINDOW_SYSTEM
1684 struct frame
*f
= XFRAME (w
->frame
);
1685 if (FRAME_WINDOW_P (f
))
1687 int ch_width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
1688 int window_pixel_width
= WINDOW_TOTAL_WIDTH (w
);
1690 /* Compute number of glyphs needed in a glyph row. */
1691 return (((window_pixel_width
+ ch_width
- 1)
1692 / ch_width
) * w
->ncols_scale_factor
1693 /* 2 partially visible columns in the text area. */
1695 /* One partially visible column at the right
1696 edge of each marginal area. */
1699 #endif /* HAVE_WINDOW_SYSTEM */
1701 return w
->total_cols
;
1705 /* Allocate window matrices for window-based redisplay. W is the
1706 window whose matrices must be allocated/reallocated. */
1709 allocate_matrices_for_window_redisplay (struct window
*w
)
1713 if (WINDOWP (w
->contents
))
1714 allocate_matrices_for_window_redisplay (XWINDOW (w
->contents
));
1717 /* W is a leaf window. */
1720 /* If matrices are not yet allocated, allocate them now. */
1721 if (w
->desired_matrix
== NULL
)
1723 w
->desired_matrix
= new_glyph_matrix (NULL
);
1724 w
->current_matrix
= new_glyph_matrix (NULL
);
1727 dim
.width
= required_matrix_width (w
);
1728 dim
.height
= required_matrix_height (w
);
1729 adjust_glyph_matrix (w
, w
->desired_matrix
, 0, 0, dim
);
1730 adjust_glyph_matrix (w
, w
->current_matrix
, 0, 0, dim
);
1733 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
1737 /* Allocate/reallocate glyph matrices of a single frame F.
1738 This function must be called when a new frame is created,
1739 its size changes, or its window configuration changes. */
1742 adjust_frame_glyphs (struct frame
*f
)
1744 /* Block input so that expose events and other events that access
1745 glyph matrices are not processed while we are changing them. */
1748 if (FRAME_WINDOW_P (f
))
1749 adjust_frame_glyphs_for_window_redisplay (f
);
1751 adjust_frame_glyphs_for_frame_redisplay (f
);
1753 /* Don't forget the buffer for decode_mode_spec. */
1754 adjust_decode_mode_spec_buffer (f
);
1756 f
->glyphs_initialized_p
= 1;
1761 /* Return true if any window in the tree has nonzero window margins. See
1762 the hack at the end of adjust_frame_glyphs_for_frame_redisplay. */
1764 showing_window_margins_p (struct window
*w
)
1768 if (WINDOWP (w
->contents
))
1770 if (showing_window_margins_p (XWINDOW (w
->contents
)))
1773 else if (w
->left_margin_cols
> 0 || w
->right_margin_cols
> 0)
1776 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
1782 /* In the window tree with root W, build current matrices of leaf
1783 windows from the frame's current matrix. */
1786 fake_current_matrices (Lisp_Object window
)
1790 for (; !NILP (window
); window
= w
->next
)
1792 w
= XWINDOW (window
);
1794 if (WINDOWP (w
->contents
))
1795 fake_current_matrices (w
->contents
);
1799 struct frame
*f
= XFRAME (w
->frame
);
1800 struct glyph_matrix
*m
= w
->current_matrix
;
1801 struct glyph_matrix
*fm
= f
->current_matrix
;
1803 eassert (m
->matrix_h
== WINDOW_TOTAL_LINES (w
));
1804 eassert (m
->matrix_w
== WINDOW_TOTAL_COLS (w
));
1806 for (i
= 0; i
< m
->matrix_h
; ++i
)
1808 struct glyph_row
*r
= m
->rows
+ i
;
1809 struct glyph_row
*fr
= fm
->rows
+ i
+ WINDOW_TOP_EDGE_LINE (w
);
1811 eassert (r
->glyphs
[TEXT_AREA
] >= fr
->glyphs
[TEXT_AREA
]
1812 && r
->glyphs
[LAST_AREA
] <= fr
->glyphs
[LAST_AREA
]);
1814 r
->enabled_p
= fr
->enabled_p
;
1817 r
->used
[LEFT_MARGIN_AREA
] = m
->left_margin_glyphs
;
1818 r
->used
[RIGHT_MARGIN_AREA
] = m
->right_margin_glyphs
;
1819 r
->used
[TEXT_AREA
] = (m
->matrix_w
1820 - r
->used
[LEFT_MARGIN_AREA
]
1821 - r
->used
[RIGHT_MARGIN_AREA
]);
1830 /* Save away the contents of frame F's current frame matrix. Value is
1831 a glyph matrix holding the contents of F's current frame matrix. */
1833 static struct glyph_matrix
*
1834 save_current_matrix (struct frame
*f
)
1837 struct glyph_matrix
*saved
= xzalloc (sizeof *saved
);
1838 saved
->nrows
= f
->current_matrix
->nrows
;
1839 saved
->rows
= xzalloc (saved
->nrows
* sizeof *saved
->rows
);
1841 for (i
= 0; i
< saved
->nrows
; ++i
)
1843 struct glyph_row
*from
= f
->current_matrix
->rows
+ i
;
1844 struct glyph_row
*to
= saved
->rows
+ i
;
1845 ptrdiff_t nbytes
= from
->used
[TEXT_AREA
] * sizeof (struct glyph
);
1847 to
->glyphs
[TEXT_AREA
] = xmalloc (nbytes
);
1848 memcpy (to
->glyphs
[TEXT_AREA
], from
->glyphs
[TEXT_AREA
], nbytes
);
1849 to
->used
[TEXT_AREA
] = from
->used
[TEXT_AREA
];
1850 to
->enabled_p
= from
->enabled_p
;
1851 to
->hash
= from
->hash
;
1852 if (from
->used
[LEFT_MARGIN_AREA
])
1854 nbytes
= from
->used
[LEFT_MARGIN_AREA
] * sizeof (struct glyph
);
1855 to
->glyphs
[LEFT_MARGIN_AREA
] = xmalloc (nbytes
);
1856 memcpy (to
->glyphs
[LEFT_MARGIN_AREA
],
1857 from
->glyphs
[LEFT_MARGIN_AREA
], nbytes
);
1858 to
->used
[LEFT_MARGIN_AREA
] = from
->used
[LEFT_MARGIN_AREA
];
1860 if (from
->used
[RIGHT_MARGIN_AREA
])
1862 nbytes
= from
->used
[RIGHT_MARGIN_AREA
] * sizeof (struct glyph
);
1863 to
->glyphs
[RIGHT_MARGIN_AREA
] = xmalloc (nbytes
);
1864 memcpy (to
->glyphs
[RIGHT_MARGIN_AREA
],
1865 from
->glyphs
[RIGHT_MARGIN_AREA
], nbytes
);
1866 to
->used
[RIGHT_MARGIN_AREA
] = from
->used
[RIGHT_MARGIN_AREA
];
1874 /* Restore the contents of frame F's current frame matrix from SAVED,
1875 and free memory associated with SAVED. */
1878 restore_current_matrix (struct frame
*f
, struct glyph_matrix
*saved
)
1882 for (i
= 0; i
< saved
->nrows
; ++i
)
1884 struct glyph_row
*from
= saved
->rows
+ i
;
1885 struct glyph_row
*to
= f
->current_matrix
->rows
+ i
;
1886 ptrdiff_t nbytes
= from
->used
[TEXT_AREA
] * sizeof (struct glyph
);
1888 memcpy (to
->glyphs
[TEXT_AREA
], from
->glyphs
[TEXT_AREA
], nbytes
);
1889 to
->used
[TEXT_AREA
] = from
->used
[TEXT_AREA
];
1890 xfree (from
->glyphs
[TEXT_AREA
]);
1891 nbytes
= from
->used
[LEFT_MARGIN_AREA
] * sizeof (struct glyph
);
1894 memcpy (to
->glyphs
[LEFT_MARGIN_AREA
],
1895 from
->glyphs
[LEFT_MARGIN_AREA
], nbytes
);
1896 to
->used
[LEFT_MARGIN_AREA
] = from
->used
[LEFT_MARGIN_AREA
];
1897 xfree (from
->glyphs
[LEFT_MARGIN_AREA
]);
1900 to
->used
[LEFT_MARGIN_AREA
] = 0;
1901 nbytes
= from
->used
[RIGHT_MARGIN_AREA
] * sizeof (struct glyph
);
1904 memcpy (to
->glyphs
[RIGHT_MARGIN_AREA
],
1905 from
->glyphs
[RIGHT_MARGIN_AREA
], nbytes
);
1906 to
->used
[RIGHT_MARGIN_AREA
] = from
->used
[RIGHT_MARGIN_AREA
];
1907 xfree (from
->glyphs
[RIGHT_MARGIN_AREA
]);
1910 to
->used
[RIGHT_MARGIN_AREA
] = 0;
1913 xfree (saved
->rows
);
1919 /* Allocate/reallocate glyph matrices of a single frame F for
1920 frame-based redisplay. */
1923 adjust_frame_glyphs_for_frame_redisplay (struct frame
*f
)
1925 struct dim matrix_dim
;
1926 bool pool_changed_p
;
1927 int window_change_flags
;
1930 if (!FRAME_LIVE_P (f
))
1933 top_window_y
= FRAME_TOP_MARGIN (f
);
1935 /* Allocate glyph pool structures if not already done. */
1936 if (f
->desired_pool
== NULL
)
1938 f
->desired_pool
= new_glyph_pool ();
1939 f
->current_pool
= new_glyph_pool ();
1942 /* Allocate frames matrix structures if needed. */
1943 if (f
->desired_matrix
== NULL
)
1945 f
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1946 f
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1949 /* Compute window glyph matrices. (This takes the mini-buffer
1950 window into account). The result is the size of the frame glyph
1951 matrix needed. The variable window_change_flags is set to a bit
1952 mask indicating whether new matrices will be allocated or
1953 existing matrices change their size or location within the frame
1955 window_change_flags
= 0;
1957 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
1960 &window_change_flags
);
1962 /* Add in menu bar lines, if any. */
1963 matrix_dim
.height
+= top_window_y
;
1965 /* Enlarge pools as necessary. */
1966 pool_changed_p
= realloc_glyph_pool (f
->desired_pool
, matrix_dim
);
1967 realloc_glyph_pool (f
->current_pool
, matrix_dim
);
1969 /* Set up glyph pointers within window matrices. Do this only if
1970 absolutely necessary since it requires a frame redraw. */
1971 if (pool_changed_p
|| window_change_flags
)
1973 /* Do it for window matrices. */
1974 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
1976 &window_change_flags
);
1978 /* Size of frame matrices must equal size of frame. Note
1979 that we are called for X frames with window widths NOT equal
1980 to the frame width (from CHANGE_FRAME_SIZE_1). */
1981 eassert (matrix_dim
.width
== FRAME_COLS (f
)
1982 && matrix_dim
.height
== FRAME_LINES (f
));
1984 /* Pointers to glyph memory in glyph rows are exchanged during
1985 the update phase of redisplay, which means in general that a
1986 frame's current matrix consists of pointers into both the
1987 desired and current glyph pool of the frame. Adjusting a
1988 matrix sets the frame matrix up so that pointers are all into
1989 the same pool. If we want to preserve glyph contents of the
1990 current matrix over a call to adjust_glyph_matrix, we must
1991 make a copy of the current glyphs, and restore the current
1992 matrix' contents from that copy. */
1993 if (display_completed
1994 && !FRAME_GARBAGED_P (f
)
1995 && matrix_dim
.width
== f
->current_matrix
->matrix_w
1996 && matrix_dim
.height
== f
->current_matrix
->matrix_h
1997 /* For some reason, the frame glyph matrix gets corrupted if
1998 any of the windows contain margins. I haven't been able
1999 to hunt down the reason, but for the moment this prevents
2000 the problem from manifesting. -- cyd */
2001 && !showing_window_margins_p (XWINDOW (FRAME_ROOT_WINDOW (f
))))
2003 struct glyph_matrix
*copy
= save_current_matrix (f
);
2004 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2005 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2006 restore_current_matrix (f
, copy
);
2007 fake_current_matrices (FRAME_ROOT_WINDOW (f
));
2011 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2012 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2013 SET_FRAME_GARBAGED (f
);
2019 /* Allocate/reallocate glyph matrices of a single frame F for
2020 window-based redisplay. */
2023 adjust_frame_glyphs_for_window_redisplay (struct frame
*f
)
2025 eassert (FRAME_WINDOW_P (f
) && FRAME_LIVE_P (f
));
2027 /* Allocate/reallocate window matrices. */
2028 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2030 #if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
2031 /* Allocate/ reallocate matrices of the dummy window used to display
2032 the menu bar under X when no X toolkit support is available. */
2034 /* Allocate a dummy window if not already done. */
2036 if (NILP (f
->menu_bar_window
))
2039 fset_menu_bar_window (f
, make_window ());
2040 w
= XWINDOW (f
->menu_bar_window
);
2041 XSETFRAME (frame
, f
);
2042 wset_frame (w
, frame
);
2043 w
->pseudo_window_p
= 1;
2046 w
= XWINDOW (f
->menu_bar_window
);
2048 /* Set window dimensions to frame dimensions and allocate or
2049 adjust glyph matrices of W. */
2052 w
->total_lines
= FRAME_MENU_BAR_LINES (f
);
2053 w
->total_cols
= FRAME_TOTAL_COLS (f
);
2054 allocate_matrices_for_window_redisplay (w
);
2058 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (USE_GTK) && ! defined (HAVE_NS)
2060 /* Allocate/ reallocate matrices of the tool bar window. If we
2061 don't have a tool bar window yet, make one. */
2063 if (NILP (f
->tool_bar_window
))
2066 fset_tool_bar_window (f
, make_window ());
2067 w
= XWINDOW (f
->tool_bar_window
);
2068 XSETFRAME (frame
, f
);
2069 wset_frame (w
, frame
);
2070 w
->pseudo_window_p
= 1;
2073 w
= XWINDOW (f
->tool_bar_window
);
2075 w
->top_line
= FRAME_MENU_BAR_LINES (f
);
2077 w
->total_lines
= FRAME_TOOL_BAR_LINES (f
);
2078 w
->total_cols
= FRAME_TOTAL_COLS (f
);
2079 allocate_matrices_for_window_redisplay (w
);
2085 /* Re-allocate buffer for decode_mode_spec on frame F. */
2088 adjust_decode_mode_spec_buffer (struct frame
*f
)
2090 f
->decode_mode_spec_buffer
= xrealloc (f
->decode_mode_spec_buffer
,
2091 FRAME_MESSAGE_BUF_SIZE (f
) + 1);
2096 /**********************************************************************
2097 Freeing Glyph Matrices
2098 **********************************************************************/
2100 /* Free glyph memory for a frame F. F may be null. This function can
2101 be called for the same frame more than once. The root window of
2102 F may be nil when this function is called. This is the case when
2103 the function is called when F is destroyed. */
2106 free_glyphs (struct frame
*f
)
2108 if (f
&& f
->glyphs_initialized_p
)
2110 /* Block interrupt input so that we don't get surprised by an X
2111 event while we're in an inconsistent state. */
2113 f
->glyphs_initialized_p
= 0;
2115 /* Release window sub-matrices. */
2116 if (!NILP (f
->root_window
))
2117 free_window_matrices (XWINDOW (f
->root_window
));
2119 #if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
2120 /* Free the dummy window for menu bars without X toolkit and its
2122 if (!NILP (f
->menu_bar_window
))
2124 struct window
*w
= XWINDOW (f
->menu_bar_window
);
2125 free_glyph_matrix (w
->desired_matrix
);
2126 free_glyph_matrix (w
->current_matrix
);
2127 w
->desired_matrix
= w
->current_matrix
= NULL
;
2128 fset_menu_bar_window (f
, Qnil
);
2132 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (USE_GTK) && ! defined (HAVE_NS)
2133 /* Free the tool bar window and its glyph matrices. */
2134 if (!NILP (f
->tool_bar_window
))
2136 struct window
*w
= XWINDOW (f
->tool_bar_window
);
2137 free_glyph_matrix (w
->desired_matrix
);
2138 free_glyph_matrix (w
->current_matrix
);
2139 w
->desired_matrix
= w
->current_matrix
= NULL
;
2140 fset_tool_bar_window (f
, Qnil
);
2144 /* Release frame glyph matrices. Reset fields to zero in
2145 case we are called a second time. */
2146 if (f
->desired_matrix
)
2148 free_glyph_matrix (f
->desired_matrix
);
2149 free_glyph_matrix (f
->current_matrix
);
2150 f
->desired_matrix
= f
->current_matrix
= NULL
;
2153 /* Release glyph pools. */
2154 if (f
->desired_pool
)
2156 free_glyph_pool (f
->desired_pool
);
2157 free_glyph_pool (f
->current_pool
);
2158 f
->desired_pool
= f
->current_pool
= NULL
;
2166 /* Free glyph sub-matrices in the window tree rooted at W. This
2167 function may be called with a null pointer, and it may be called on
2168 the same tree more than once. */
2171 free_window_matrices (struct window
*w
)
2175 if (WINDOWP (w
->contents
))
2176 free_window_matrices (XWINDOW (w
->contents
));
2179 /* This is a leaf window. Free its memory and reset fields
2180 to zero in case this function is called a second time for
2182 free_glyph_matrix (w
->current_matrix
);
2183 free_glyph_matrix (w
->desired_matrix
);
2184 w
->current_matrix
= w
->desired_matrix
= NULL
;
2187 /* Next window on same level. */
2188 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2193 /* Check glyph memory leaks. This function is called from
2194 shut_down_emacs. Note that frames are not destroyed when Emacs
2195 exits. We therefore free all glyph memory for all active frames
2196 explicitly and check that nothing is left allocated. */
2199 check_glyph_memory (void)
2201 Lisp_Object tail
, frame
;
2203 /* Free glyph memory for all frames. */
2204 FOR_EACH_FRAME (tail
, frame
)
2205 free_glyphs (XFRAME (frame
));
2207 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
2208 /* Check that nothing is left allocated. */
2209 eassert (glyph_matrix_count
== 0);
2210 eassert (glyph_pool_count
== 0);
2216 /**********************************************************************
2217 Building a Frame Matrix
2218 **********************************************************************/
2220 /* Most of the redisplay code works on glyph matrices attached to
2221 windows. This is a good solution most of the time, but it is not
2222 suitable for terminal code. Terminal output functions cannot rely
2223 on being able to set an arbitrary terminal window. Instead they
2224 must be provided with a view of the whole frame, i.e. the whole
2225 screen. We build such a view by constructing a frame matrix from
2226 window matrices in this section.
2228 Windows that must be updated have their must_be_updated_p flag set.
2229 For all such windows, their desired matrix is made part of the
2230 desired frame matrix. For other windows, their current matrix is
2231 made part of the desired frame matrix.
2233 +-----------------+----------------+
2234 | desired | desired |
2236 +-----------------+----------------+
2239 +----------------------------------+
2241 Desired window matrices can be made part of the frame matrix in a
2242 cheap way: We exploit the fact that the desired frame matrix and
2243 desired window matrices share their glyph memory. This is not
2244 possible for current window matrices. Their glyphs are copied to
2245 the desired frame matrix. The latter is equivalent to
2246 preserve_other_columns in the old redisplay.
2248 Used glyphs counters for frame matrix rows are the result of adding
2249 up glyph lengths of the window matrices. A line in the frame
2250 matrix is enabled, if a corresponding line in a window matrix is
2253 After building the desired frame matrix, it will be passed to
2254 terminal code, which will manipulate both the desired and current
2255 frame matrix. Changes applied to the frame's current matrix have
2256 to be visible in current window matrices afterwards, of course.
2258 This problem is solved like this:
2260 1. Window and frame matrices share glyphs. Window matrices are
2261 constructed in a way that their glyph contents ARE the glyph
2262 contents needed in a frame matrix. Thus, any modification of
2263 glyphs done in terminal code will be reflected in window matrices
2266 2. Exchanges of rows in a frame matrix done by terminal code are
2267 intercepted by hook functions so that corresponding row operations
2268 on window matrices can be performed. This is necessary because we
2269 use pointers to glyphs in glyph row structures. To satisfy the
2270 assumption of point 1 above that glyphs are updated implicitly in
2271 window matrices when they are manipulated via the frame matrix,
2272 window and frame matrix must of course agree where to find the
2273 glyphs for their rows. Possible manipulations that must be
2274 mirrored are assignments of rows of the desired frame matrix to the
2275 current frame matrix and scrolling the current frame matrix. */
2277 /* Build frame F's desired matrix from window matrices. Only windows
2278 which have the flag must_be_updated_p set have to be updated. Menu
2279 bar lines of a frame are not covered by window matrices, so make
2280 sure not to touch them in this function. */
2283 build_frame_matrix (struct frame
*f
)
2287 /* F must have a frame matrix when this function is called. */
2288 eassert (!FRAME_WINDOW_P (f
));
2290 /* Clear all rows in the frame matrix covered by window matrices.
2291 Menu bar lines are not covered by windows. */
2292 for (i
= FRAME_TOP_MARGIN (f
); i
< f
->desired_matrix
->nrows
; ++i
)
2293 clear_glyph_row (MATRIX_ROW (f
->desired_matrix
, i
));
2295 /* Build the matrix by walking the window tree. */
2296 build_frame_matrix_from_window_tree (f
->desired_matrix
,
2297 XWINDOW (FRAME_ROOT_WINDOW (f
)));
2301 /* Walk a window tree, building a frame matrix MATRIX from window
2302 matrices. W is the root of a window tree. */
2305 build_frame_matrix_from_window_tree (struct glyph_matrix
*matrix
, struct window
*w
)
2309 if (WINDOWP (w
->contents
))
2310 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->contents
));
2312 build_frame_matrix_from_leaf_window (matrix
, w
);
2314 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2319 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2320 desired frame matrix built. W is a leaf window whose desired or
2321 current matrix is to be added to FRAME_MATRIX. W's flag
2322 must_be_updated_p determines which matrix it contributes to
2323 FRAME_MATRIX. If W->must_be_updated_p, W's desired matrix
2324 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2325 Adding a desired matrix means setting up used counters and such in
2326 frame rows, while adding a current window matrix to FRAME_MATRIX
2327 means copying glyphs. The latter case corresponds to
2328 preserve_other_columns in the old redisplay. */
2331 build_frame_matrix_from_leaf_window (struct glyph_matrix
*frame_matrix
, struct window
*w
)
2333 struct glyph_matrix
*window_matrix
;
2334 int window_y
, frame_y
;
2335 /* If non-zero, a glyph to insert at the right border of W. */
2336 GLYPH right_border_glyph
;
2338 SET_GLYPH_FROM_CHAR (right_border_glyph
, 0);
2340 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2341 if (w
->must_be_updated_p
)
2343 window_matrix
= w
->desired_matrix
;
2345 /* Decide whether we want to add a vertical border glyph. */
2346 if (!WINDOW_RIGHTMOST_P (w
))
2348 struct Lisp_Char_Table
*dp
= window_display_table (w
);
2351 SET_GLYPH_FROM_CHAR (right_border_glyph
, '|');
2353 && (gc
= DISP_BORDER_GLYPH (dp
), GLYPH_CODE_P (gc
)))
2355 SET_GLYPH_FROM_GLYPH_CODE (right_border_glyph
, gc
);
2356 spec_glyph_lookup_face (w
, &right_border_glyph
);
2359 if (GLYPH_FACE (right_border_glyph
) <= 0)
2360 SET_GLYPH_FACE (right_border_glyph
, VERTICAL_BORDER_FACE_ID
);
2364 window_matrix
= w
->current_matrix
;
2366 /* For all rows in the window matrix and corresponding rows in the
2369 frame_y
= window_matrix
->matrix_y
;
2370 while (window_y
< window_matrix
->nrows
)
2372 struct glyph_row
*frame_row
= frame_matrix
->rows
+ frame_y
;
2373 struct glyph_row
*window_row
= window_matrix
->rows
+ window_y
;
2374 bool current_row_p
= window_matrix
== w
->current_matrix
;
2376 /* Fill up the frame row with spaces up to the left margin of the
2378 fill_up_frame_row_with_spaces (frame_row
, window_matrix
->matrix_x
);
2380 /* Fill up areas in the window matrix row with spaces. */
2381 fill_up_glyph_row_with_spaces (window_row
);
2383 /* If only part of W's desired matrix has been built, and
2384 window_row wasn't displayed, use the corresponding current
2386 if (window_matrix
== w
->desired_matrix
2387 && !window_row
->enabled_p
)
2389 window_row
= w
->current_matrix
->rows
+ window_y
;
2395 /* Copy window row to frame row. */
2396 memcpy (frame_row
->glyphs
[TEXT_AREA
] + window_matrix
->matrix_x
,
2397 window_row
->glyphs
[0],
2398 window_matrix
->matrix_w
* sizeof (struct glyph
));
2402 eassert (window_row
->enabled_p
);
2404 /* Only when a desired row has been displayed, we want
2405 the corresponding frame row to be updated. */
2406 frame_row
->enabled_p
= 1;
2408 /* Maybe insert a vertical border between horizontally adjacent
2410 if (GLYPH_CHAR (right_border_glyph
) != 0)
2412 struct glyph
*border
= window_row
->glyphs
[LAST_AREA
] - 1;
2413 SET_CHAR_GLYPH_FROM_GLYPH (*border
, right_border_glyph
);
2417 /* Window row window_y must be a slice of frame row
2419 eassert (glyph_row_slice_p (window_row
, frame_row
));
2421 /* If rows are in sync, we don't have to copy glyphs because
2422 frame and window share glyphs. */
2424 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
2425 add_window_display_history (w
, w
->current_matrix
->method
, 0);
2429 /* Set number of used glyphs in the frame matrix. Since we fill
2430 up with spaces, and visit leaf windows from left to right it
2431 can be done simply. */
2432 frame_row
->used
[TEXT_AREA
]
2433 = window_matrix
->matrix_x
+ window_matrix
->matrix_w
;
2441 /* Given a user-specified glyph, possibly including a Lisp-level face
2442 ID, return a glyph that has a realized face ID.
2443 This is used for glyphs displayed specially and not part of the text;
2444 for instance, vertical separators, truncation markers, etc. */
2447 spec_glyph_lookup_face (struct window
*w
, GLYPH
*glyph
)
2449 int lface_id
= GLYPH_FACE (*glyph
);
2450 /* Convert the glyph's specified face to a realized (cache) face. */
2453 int face_id
= merge_faces (XFRAME (w
->frame
),
2454 Qt
, lface_id
, DEFAULT_FACE_ID
);
2455 SET_GLYPH_FACE (*glyph
, face_id
);
2459 /* Add spaces to a glyph row ROW in a window matrix.
2461 Each row has the form:
2463 +---------+-----------------------------+------------+
2464 | left | text | right |
2465 +---------+-----------------------------+------------+
2467 Left and right marginal areas are optional. This function adds
2468 spaces to areas so that there are no empty holes between areas.
2469 In other words: If the right area is not empty, the text area
2470 is filled up with spaces up to the right area. If the text area
2471 is not empty, the left area is filled up.
2473 To be called for frame-based redisplay, only. */
2476 fill_up_glyph_row_with_spaces (struct glyph_row
*row
)
2478 fill_up_glyph_row_area_with_spaces (row
, LEFT_MARGIN_AREA
);
2479 fill_up_glyph_row_area_with_spaces (row
, TEXT_AREA
);
2480 fill_up_glyph_row_area_with_spaces (row
, RIGHT_MARGIN_AREA
);
2484 /* Fill area AREA of glyph row ROW with spaces. To be called for
2485 frame-based redisplay only. */
2488 fill_up_glyph_row_area_with_spaces (struct glyph_row
*row
, int area
)
2490 if (row
->glyphs
[area
] < row
->glyphs
[area
+ 1])
2492 struct glyph
*end
= row
->glyphs
[area
+ 1];
2493 struct glyph
*text
= row
->glyphs
[area
] + row
->used
[area
];
2496 *text
++ = space_glyph
;
2497 row
->used
[area
] = text
- row
->glyphs
[area
];
2502 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2503 reached. In frame matrices only one area, TEXT_AREA, is used. */
2506 fill_up_frame_row_with_spaces (struct glyph_row
*row
, int upto
)
2508 int i
= row
->used
[TEXT_AREA
];
2509 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
2512 glyph
[i
++] = space_glyph
;
2514 row
->used
[TEXT_AREA
] = i
;
2519 /**********************************************************************
2520 Mirroring operations on frame matrices in window matrices
2521 **********************************************************************/
2523 /* Set frame being updated via frame-based redisplay to F. This
2524 function must be called before updates to make explicit that we are
2525 working on frame matrices or not. */
2528 set_frame_matrix_frame (struct frame
*f
)
2530 frame_matrix_frame
= f
;
2534 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2535 DESIRED_MATRIX is the desired matrix corresponding to
2536 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2537 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2538 frame_matrix_frame is non-null, this indicates that the exchange is
2539 done in frame matrices, and that we have to perform analogous
2540 operations in window matrices of frame_matrix_frame. */
2543 make_current (struct glyph_matrix
*desired_matrix
, struct glyph_matrix
*current_matrix
, int row
)
2545 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, row
);
2546 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, row
);
2547 bool mouse_face_p
= current_row
->mouse_face_p
;
2549 /* Do current_row = desired_row. This exchanges glyph pointers
2550 between both rows, and does a structure assignment otherwise. */
2551 assign_row (current_row
, desired_row
);
2553 /* Enable current_row to mark it as valid. */
2554 current_row
->enabled_p
= 1;
2555 current_row
->mouse_face_p
= mouse_face_p
;
2557 /* If we are called on frame matrices, perform analogous operations
2558 for window matrices. */
2559 if (frame_matrix_frame
)
2560 mirror_make_current (XWINDOW (frame_matrix_frame
->root_window
), row
);
2564 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2565 W's frame which has been made current (by swapping pointers between
2566 current and desired matrix). Perform analogous operations in the
2567 matrices of leaf windows in the window tree rooted at W. */
2570 mirror_make_current (struct window
*w
, int frame_row
)
2574 if (WINDOWP (w
->contents
))
2575 mirror_make_current (XWINDOW (w
->contents
), frame_row
);
2578 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2579 here because the checks performed in debug mode there
2580 will not allow the conversion. */
2581 int row
= frame_row
- w
->desired_matrix
->matrix_y
;
2583 /* If FRAME_ROW is within W, assign the desired row to the
2584 current row (exchanging glyph pointers). */
2585 if (row
>= 0 && row
< w
->desired_matrix
->matrix_h
)
2587 struct glyph_row
*current_row
2588 = MATRIX_ROW (w
->current_matrix
, row
);
2589 struct glyph_row
*desired_row
2590 = MATRIX_ROW (w
->desired_matrix
, row
);
2592 if (desired_row
->enabled_p
)
2593 assign_row (current_row
, desired_row
);
2595 swap_glyph_pointers (desired_row
, current_row
);
2596 current_row
->enabled_p
= 1;
2598 /* Set the Y coordinate of the mode/header line's row.
2599 It is needed in draw_row_with_mouse_face to find the
2600 screen coordinates. (Window-based redisplay sets
2601 this in update_window, but no one seems to do that
2602 for frame-based redisplay.) */
2603 if (current_row
->mode_line_p
)
2604 current_row
->y
= row
;
2608 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2613 /* Perform row dance after scrolling. We are working on the range of
2614 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2615 including) in MATRIX. COPY_FROM is a vector containing, for each
2616 row I in the range 0 <= I < NLINES, the index of the original line
2617 to move to I. This index is relative to the row range, i.e. 0 <=
2618 index < NLINES. RETAINED_P is a vector containing zero for each
2619 row 0 <= I < NLINES which is empty.
2621 This function is called from do_scrolling and do_direct_scrolling. */
2624 mirrored_line_dance (struct glyph_matrix
*matrix
, int unchanged_at_top
, int nlines
,
2625 int *copy_from
, char *retained_p
)
2627 /* A copy of original rows. */
2628 struct glyph_row
*old_rows
;
2630 /* Rows to assign to. */
2631 struct glyph_row
*new_rows
= MATRIX_ROW (matrix
, unchanged_at_top
);
2635 /* Make a copy of the original rows. */
2636 old_rows
= alloca (nlines
* sizeof *old_rows
);
2637 memcpy (old_rows
, new_rows
, nlines
* sizeof *old_rows
);
2639 /* Assign new rows, maybe clear lines. */
2640 for (i
= 0; i
< nlines
; ++i
)
2642 bool enabled_before_p
= new_rows
[i
].enabled_p
;
2644 eassert (i
+ unchanged_at_top
< matrix
->nrows
);
2645 eassert (unchanged_at_top
+ copy_from
[i
] < matrix
->nrows
);
2646 new_rows
[i
] = old_rows
[copy_from
[i
]];
2647 new_rows
[i
].enabled_p
= enabled_before_p
;
2649 /* RETAINED_P is zero for empty lines. */
2650 if (!retained_p
[copy_from
[i
]])
2651 new_rows
[i
].enabled_p
= 0;
2654 /* Do the same for window matrices, if MATRIX is a frame matrix. */
2655 if (frame_matrix_frame
)
2656 mirror_line_dance (XWINDOW (frame_matrix_frame
->root_window
),
2657 unchanged_at_top
, nlines
, copy_from
, retained_p
);
2661 /* Synchronize glyph pointers in the current matrix of window W with
2662 the current frame matrix. */
2665 sync_window_with_frame_matrix_rows (struct window
*w
)
2667 struct frame
*f
= XFRAME (w
->frame
);
2668 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
2669 int left
, right
, x
, width
;
2671 /* Preconditions: W must be a live window on a tty frame. */
2672 eassert (BUFFERP (w
->contents
));
2673 eassert (!FRAME_WINDOW_P (f
));
2675 left
= margin_glyphs_to_reserve (w
, 1, w
->left_margin_cols
);
2676 right
= margin_glyphs_to_reserve (w
, 1, w
->right_margin_cols
);
2677 x
= w
->current_matrix
->matrix_x
;
2678 width
= w
->current_matrix
->matrix_w
;
2680 window_row
= w
->current_matrix
->rows
;
2681 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
2682 frame_row
= f
->current_matrix
->rows
+ WINDOW_TOP_EDGE_LINE (w
);
2684 for (; window_row
< window_row_end
; ++window_row
, ++frame_row
)
2686 window_row
->glyphs
[LEFT_MARGIN_AREA
]
2687 = frame_row
->glyphs
[0] + x
;
2688 window_row
->glyphs
[TEXT_AREA
]
2689 = window_row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
2690 window_row
->glyphs
[LAST_AREA
]
2691 = window_row
->glyphs
[LEFT_MARGIN_AREA
] + width
;
2692 window_row
->glyphs
[RIGHT_MARGIN_AREA
]
2693 = window_row
->glyphs
[LAST_AREA
] - right
;
2698 /* Return the window in the window tree rooted in W containing frame
2699 row ROW. Value is null if none is found. */
2701 static struct window
*
2702 frame_row_to_window (struct window
*w
, int row
)
2704 struct window
*found
= NULL
;
2708 if (WINDOWP (w
->contents
))
2709 found
= frame_row_to_window (XWINDOW (w
->contents
), row
);
2710 else if (row
>= WINDOW_TOP_EDGE_LINE (w
)
2711 && row
< WINDOW_BOTTOM_EDGE_LINE (w
))
2714 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2721 /* Perform a line dance in the window tree rooted at W, after
2722 scrolling a frame matrix in mirrored_line_dance.
2724 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
2725 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
2726 COPY_FROM is a vector containing, for each row I in the range 0 <=
2727 I < NLINES, the index of the original line to move to I. This
2728 index is relative to the row range, i.e. 0 <= index < NLINES.
2729 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
2733 mirror_line_dance (struct window
*w
, int unchanged_at_top
, int nlines
, int *copy_from
, char *retained_p
)
2737 if (WINDOWP (w
->contents
))
2738 mirror_line_dance (XWINDOW (w
->contents
), unchanged_at_top
,
2739 nlines
, copy_from
, retained_p
);
2742 /* W is a leaf window, and we are working on its current
2744 struct glyph_matrix
*m
= w
->current_matrix
;
2747 struct glyph_row
*old_rows
;
2749 /* Make a copy of the original rows of matrix m. */
2750 old_rows
= alloca (m
->nrows
* sizeof *old_rows
);
2751 memcpy (old_rows
, m
->rows
, m
->nrows
* sizeof *old_rows
);
2753 for (i
= 0; i
< nlines
; ++i
)
2755 /* Frame relative line assigned to. */
2756 int frame_to
= i
+ unchanged_at_top
;
2758 /* Frame relative line assigned. */
2759 int frame_from
= copy_from
[i
] + unchanged_at_top
;
2761 /* Window relative line assigned to. */
2762 int window_to
= frame_to
- m
->matrix_y
;
2764 /* Window relative line assigned. */
2765 int window_from
= frame_from
- m
->matrix_y
;
2767 /* Is assigned line inside window? */
2768 bool from_inside_window_p
2769 = window_from
>= 0 && window_from
< m
->matrix_h
;
2771 /* Is assigned to line inside window? */
2772 bool to_inside_window_p
2773 = window_to
>= 0 && window_to
< m
->matrix_h
;
2775 if (from_inside_window_p
&& to_inside_window_p
)
2777 /* Do the assignment. The enabled_p flag is saved
2778 over the assignment because the old redisplay did
2780 bool enabled_before_p
= m
->rows
[window_to
].enabled_p
;
2781 m
->rows
[window_to
] = old_rows
[window_from
];
2782 m
->rows
[window_to
].enabled_p
= enabled_before_p
;
2784 /* If frame line is empty, window line is empty, too. */
2785 if (!retained_p
[copy_from
[i
]])
2786 m
->rows
[window_to
].enabled_p
= 0;
2788 else if (to_inside_window_p
)
2790 /* A copy between windows. This is an infrequent
2791 case not worth optimizing. */
2792 struct frame
*f
= XFRAME (w
->frame
);
2793 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
2795 struct glyph_matrix
*m2
;
2798 w2
= frame_row_to_window (root
, frame_from
);
2799 /* ttn@surf.glug.org: when enabling menu bar using `emacs
2800 -nw', FROM_FRAME sometimes has no associated window.
2801 This check avoids a segfault if W2 is null. */
2804 m2
= w2
->current_matrix
;
2805 m2_from
= frame_from
- m2
->matrix_y
;
2806 copy_row_except_pointers (m
->rows
+ window_to
,
2807 m2
->rows
+ m2_from
);
2809 /* If frame line is empty, window line is empty, too. */
2810 if (!retained_p
[copy_from
[i
]])
2811 m
->rows
[window_to
].enabled_p
= 0;
2815 else if (from_inside_window_p
)
2819 /* If there was a copy between windows, make sure glyph
2820 pointers are in sync with the frame matrix. */
2822 sync_window_with_frame_matrix_rows (w
);
2824 /* Check that no pointers are lost. */
2828 /* Next window on same level. */
2829 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2836 /* Check that window and frame matrices agree about their
2837 understanding where glyphs of the rows are to find. For each
2838 window in the window tree rooted at W, check that rows in the
2839 matrices of leaf window agree with their frame matrices about
2843 check_window_matrix_pointers (struct window
*w
)
2847 if (WINDOWP (w
->contents
))
2848 check_window_matrix_pointers (XWINDOW (w
->contents
));
2851 struct frame
*f
= XFRAME (w
->frame
);
2852 check_matrix_pointers (w
->desired_matrix
, f
->desired_matrix
);
2853 check_matrix_pointers (w
->current_matrix
, f
->current_matrix
);
2856 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2861 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
2862 a window and FRAME_MATRIX is the corresponding frame matrix. For
2863 each row in WINDOW_MATRIX check that it's a slice of the
2864 corresponding frame row. If it isn't, abort. */
2867 check_matrix_pointers (struct glyph_matrix
*window_matrix
,
2868 struct glyph_matrix
*frame_matrix
)
2870 /* Row number in WINDOW_MATRIX. */
2873 /* Row number corresponding to I in FRAME_MATRIX. */
2874 int j
= window_matrix
->matrix_y
;
2876 /* For all rows check that the row in the window matrix is a
2877 slice of the row in the frame matrix. If it isn't we didn't
2878 mirror an operation on the frame matrix correctly. */
2879 while (i
< window_matrix
->nrows
)
2881 if (!glyph_row_slice_p (window_matrix
->rows
+ i
,
2882 frame_matrix
->rows
+ j
))
2888 #endif /* GLYPH_DEBUG */
2892 /**********************************************************************
2893 VPOS and HPOS translations
2894 **********************************************************************/
2898 /* Translate vertical position VPOS which is relative to window W to a
2899 vertical position relative to W's frame. */
2902 window_to_frame_vpos (struct window
*w
, int vpos
)
2904 eassert (!FRAME_WINDOW_P (XFRAME (w
->frame
)));
2905 eassert (vpos
>= 0 && vpos
<= w
->desired_matrix
->nrows
);
2906 vpos
+= WINDOW_TOP_EDGE_LINE (w
);
2907 eassert (vpos
>= 0 && vpos
<= FRAME_LINES (XFRAME (w
->frame
)));
2912 /* Translate horizontal position HPOS which is relative to window W to
2913 a horizontal position relative to W's frame. */
2916 window_to_frame_hpos (struct window
*w
, int hpos
)
2918 eassert (!FRAME_WINDOW_P (XFRAME (w
->frame
)));
2919 hpos
+= WINDOW_LEFT_EDGE_COL (w
);
2923 #endif /* GLYPH_DEBUG */
2927 /**********************************************************************
2929 **********************************************************************/
2931 /* Redraw frame F. */
2934 redraw_frame (struct frame
*f
)
2936 /* Error if F has no glyphs. */
2937 eassert (f
->glyphs_initialized_p
);
2939 if (FRAME_MSDOS_P (f
))
2940 FRAME_TERMINAL (f
)->set_terminal_modes_hook (FRAME_TERMINAL (f
));
2942 clear_current_matrices (f
);
2944 windows_or_buffers_changed
= 13;
2945 /* Mark all windows as inaccurate, so that every window will have
2946 its redisplay done. */
2947 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
2948 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f
)), true);
2949 f
->garbaged
= false;
2952 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 0, 1, 0,
2953 doc
: /* Clear frame FRAME and output again what is supposed to appear on it.
2954 If FRAME is omitted or nil, the selected frame is used. */)
2957 redraw_frame (decode_live_frame (frame
));
2961 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
2962 doc
: /* Clear and redisplay all visible frames. */)
2965 Lisp_Object tail
, frame
;
2967 FOR_EACH_FRAME (tail
, frame
)
2968 if (FRAME_VISIBLE_P (XFRAME (frame
)))
2969 redraw_frame (XFRAME (frame
));
2976 /***********************************************************************
2978 ***********************************************************************/
2980 /* Update frame F based on the data in desired matrices.
2982 If FORCE_P, don't let redisplay be stopped by detecting pending input.
2983 If INHIBIT_HAIRY_ID_P, don't try scrolling.
2985 Value is true if redisplay was stopped due to pending input. */
2988 update_frame (struct frame
*f
, bool force_p
, bool inhibit_hairy_id_p
)
2990 /* True means display has been paused because of pending input. */
2992 struct window
*root_window
= XWINDOW (f
->root_window
);
2994 if (redisplay_dont_pause
)
2996 else if (!force_p
&& detect_input_pending_ignore_squeezables ())
3002 if (FRAME_WINDOW_P (f
))
3004 /* We are working on window matrix basis. All windows whose
3005 flag must_be_updated_p is set have to be updated. */
3007 /* Record that we are not working on frame matrices. */
3008 set_frame_matrix_frame (NULL
);
3010 /* Update all windows in the window tree of F, maybe stopping
3011 when pending input is detected. */
3014 #if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
3015 /* Update the menu bar on X frames that don't have toolkit
3017 if (WINDOWP (f
->menu_bar_window
))
3018 update_window (XWINDOW (f
->menu_bar_window
), 1);
3021 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (USE_GTK) && ! defined (HAVE_NS)
3022 /* Update the tool-bar window, if present. */
3023 if (WINDOWP (f
->tool_bar_window
))
3025 struct window
*w
= XWINDOW (f
->tool_bar_window
);
3027 /* Update tool-bar window. */
3028 if (w
->must_be_updated_p
)
3032 update_window (w
, 1);
3033 w
->must_be_updated_p
= false;
3035 /* Swap tool-bar strings. We swap because we want to
3037 tem
= f
->current_tool_bar_string
;
3038 fset_current_tool_bar_string (f
, f
->desired_tool_bar_string
);
3039 fset_desired_tool_bar_string (f
, tem
);
3044 /* Update windows. */
3045 paused_p
= update_window_tree (root_window
, force_p
);
3050 /* We are working on frame matrix basis. Set the frame on whose
3051 frame matrix we operate. */
3052 set_frame_matrix_frame (f
);
3054 /* Build F's desired matrix from window matrices. */
3055 build_frame_matrix (f
);
3057 /* Update the display */
3059 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3062 if (FRAME_TERMCAP_P (f
) || FRAME_MSDOS_P (f
))
3064 if (FRAME_TTY (f
)->termscript
)
3065 fflush (FRAME_TTY (f
)->termscript
);
3066 if (FRAME_TERMCAP_P (f
))
3067 fflush (FRAME_TTY (f
)->output
);
3070 /* Check window matrices for lost pointers. */
3072 check_window_matrix_pointers (root_window
);
3073 add_frame_display_history (f
, paused_p
);
3078 /* Reset flags indicating that a window should be updated. */
3079 set_window_update_flags (root_window
, false);
3081 display_completed
= !paused_p
;
3085 /* Update a TTY frame F that has a menu dropped down over some of its
3086 glyphs. This is like the second part of update_frame, but it
3087 doesn't call build_frame_matrix, because we already have the
3088 desired matrix prepared, and don't want it to be overwritten by the
3089 text of the normal display. */
3091 update_frame_with_menu (struct frame
*f
)
3093 struct window
*root_window
= XWINDOW (f
->root_window
);
3096 eassert (FRAME_TERMCAP_P (f
));
3098 /* We are working on frame matrix basis. Set the frame on whose
3099 frame matrix we operate. */
3100 set_frame_matrix_frame (f
);
3102 /* Update the display. */
3104 /* Force update_frame_1 not to stop due to pending input, and not
3106 paused_p
= update_frame_1 (f
, 1, 1);
3109 if (FRAME_TTY (f
)->termscript
)
3110 fflush (FRAME_TTY (f
)->termscript
);
3111 fflush (FRAME_TTY (f
)->output
);
3112 /* Check window matrices for lost pointers. */
3115 /* We cannot possibly survive the matrix pointers check, since
3116 we have overwritten parts of the frame glyph matrix without
3117 making any updates to the window matrices. */
3118 check_window_matrix_pointers (root_window
);
3120 add_frame_display_history (f
, paused_p
);
3122 IF_LINT ((void) paused_p
);
3125 /* Reset flags indicating that a window should be updated. */
3126 set_window_update_flags (root_window
, false);
3130 /************************************************************************
3131 Window-based updates
3132 ************************************************************************/
3134 /* Perform updates in window tree rooted at W.
3135 If FORCE_P, don't stop updating if input is pending. */
3138 update_window_tree (struct window
*w
, bool force_p
)
3142 while (w
&& !paused_p
)
3144 if (WINDOWP (w
->contents
))
3145 paused_p
|= update_window_tree (XWINDOW (w
->contents
), force_p
);
3146 else if (w
->must_be_updated_p
)
3147 paused_p
|= update_window (w
, force_p
);
3149 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3156 /* Update window W if its flag must_be_updated_p is set.
3157 If FORCE_P, don't stop updating if input is pending. */
3160 update_single_window (struct window
*w
, bool force_p
)
3162 if (w
->must_be_updated_p
)
3164 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3166 /* Record that this is not a frame-based redisplay. */
3167 set_frame_matrix_frame (NULL
);
3169 if (redisplay_dont_pause
)
3174 update_window (w
, force_p
);
3177 /* Reset flag in W. */
3178 w
->must_be_updated_p
= false;
3182 #ifdef HAVE_WINDOW_SYSTEM
3184 /* Redraw lines from the current matrix of window W that are
3185 overlapped by other rows. YB is bottom-most y-position in W. */
3188 redraw_overlapped_rows (struct window
*w
, int yb
)
3191 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3193 /* If rows overlapping others have been changed, the rows being
3194 overlapped have to be redrawn. This won't draw lines that have
3195 already been drawn in update_window_line because overlapped_p in
3196 desired rows is 0, so after row assignment overlapped_p in
3197 current rows is 0. */
3198 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3200 struct glyph_row
*row
= w
->current_matrix
->rows
+ i
;
3202 if (!row
->enabled_p
)
3204 else if (row
->mode_line_p
)
3207 if (row
->overlapped_p
)
3209 enum glyph_row_area area
;
3211 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3213 output_cursor_to (w
, i
, 0, row
->y
,
3214 area
== TEXT_AREA
? row
->x
: 0);
3215 if (row
->used
[area
])
3216 FRAME_RIF (f
)->write_glyphs (w
, row
, row
->glyphs
[area
],
3217 area
, row
->used
[area
]);
3218 FRAME_RIF (f
)->clear_end_of_line (w
, row
, area
, -1);
3221 row
->overlapped_p
= 0;
3224 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3230 /* Redraw lines from the current matrix of window W that overlap
3231 others. YB is bottom-most y-position in W. */
3234 redraw_overlapping_rows (struct window
*w
, int yb
)
3237 struct glyph_row
*row
;
3238 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
3240 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3242 row
= w
->current_matrix
->rows
+ i
;
3244 if (!row
->enabled_p
)
3246 else if (row
->mode_line_p
)
3249 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3251 if (row
->overlapping_p
)
3255 if (MATRIX_ROW_OVERLAPS_PRED_P (row
) && i
> 0
3256 && !MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
)
3257 overlaps
|= OVERLAPS_PRED
;
3258 if (MATRIX_ROW_OVERLAPS_SUCC_P (row
) && bottom_y
< yb
3259 && !MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
)
3260 overlaps
|= OVERLAPS_SUCC
;
3264 if (row
->used
[LEFT_MARGIN_AREA
])
3265 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
, overlaps
);
3267 if (row
->used
[TEXT_AREA
])
3268 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
, overlaps
);
3270 if (row
->used
[RIGHT_MARGIN_AREA
])
3271 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
, overlaps
);
3273 /* Record in neighbor rows that ROW overwrites part of
3275 if (overlaps
& OVERLAPS_PRED
)
3276 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3277 if (overlaps
& OVERLAPS_SUCC
)
3278 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
3287 #endif /* HAVE_WINDOW_SYSTEM */
3290 #if defined GLYPH_DEBUG && 0
3292 /* Check that no row in the current matrix of window W is enabled
3293 which is below what's displayed in the window. */
3296 check_current_matrix_flags (struct window
*w
)
3298 bool last_seen_p
= 0;
3299 int i
, yb
= window_text_bottom_y (w
);
3301 for (i
= 0; i
< w
->current_matrix
->nrows
- 1; ++i
)
3303 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
3304 if (!last_seen_p
&& MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3306 else if (last_seen_p
&& row
->enabled_p
)
3311 #endif /* GLYPH_DEBUG */
3314 /* Update display of window W.
3315 If FORCE_P, don't stop updating when input is pending. */
3318 update_window (struct window
*w
, bool force_p
)
3320 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
3322 int preempt_count
= baud_rate
/ 2400 + 1;
3323 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
3325 /* Check that W's frame doesn't have glyph matrices. */
3326 eassert (FRAME_WINDOW_P (XFRAME (WINDOW_FRAME (w
))));
3329 /* Check pending input the first time so that we can quickly return. */
3331 detect_input_pending_ignore_squeezables ();
3333 /* If forced to complete the update, or if no input is pending, do
3335 if (force_p
|| !input_pending
|| !NILP (do_mouse_tracking
))
3337 struct glyph_row
*row
, *end
;
3338 struct glyph_row
*mode_line_row
;
3339 struct glyph_row
*header_line_row
;
3341 bool changed_p
= 0, mouse_face_overwritten_p
= 0;
3344 rif
->update_window_begin_hook (w
);
3345 yb
= window_text_bottom_y (w
);
3346 row
= MATRIX_ROW (desired_matrix
, 0);
3347 end
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3349 /* Take note of the header line, if there is one. We will
3350 update it below, after updating all of the window's lines. */
3351 if (row
->mode_line_p
)
3353 header_line_row
= row
;
3357 header_line_row
= NULL
;
3359 /* Update the mode line, if necessary. */
3360 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3361 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
3363 mode_line_row
->y
= yb
;
3364 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
3366 &mouse_face_overwritten_p
);
3369 /* Find first enabled row. Optimizations in redisplay_internal
3370 may lead to an update with only one row enabled. There may
3371 be also completely empty matrices. */
3372 while (row
< end
&& !row
->enabled_p
)
3375 /* Try reusing part of the display by copying. */
3376 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
3378 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
3381 /* All rows were found to be equal. */
3387 /* We've scrolled the display. */
3393 /* Update the rest of the lines. */
3394 for (; row
< end
&& (force_p
|| !input_pending
); ++row
)
3395 /* scrolling_window resets the enabled_p flag of the rows it
3396 reuses from current_matrix. */
3399 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
3402 /* We'll have to play a little bit with when to
3403 detect_input_pending. If it's done too often,
3404 scrolling large windows with repeated scroll-up
3405 commands will too quickly pause redisplay. */
3406 if (!force_p
&& ++n_updated
% preempt_count
== 0)
3407 detect_input_pending_ignore_squeezables ();
3408 changed_p
|= update_window_line (w
, vpos
,
3409 &mouse_face_overwritten_p
);
3411 /* Mark all rows below the last visible one in the current
3412 matrix as invalid. This is necessary because of
3413 variable line heights. Consider the case of three
3414 successive redisplays, where the first displays 5
3415 lines, the second 3 lines, and the third 5 lines again.
3416 If the second redisplay wouldn't mark rows in the
3417 current matrix invalid, the third redisplay might be
3418 tempted to optimize redisplay based on lines displayed
3419 in the first redisplay. */
3420 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3421 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
3422 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
3425 /* Was display preempted? */
3426 paused_p
= row
< end
;
3430 /* Update the header line after scrolling because a new header
3431 line would otherwise overwrite lines at the top of the window
3432 that can be scrolled. */
3433 if (header_line_row
&& header_line_row
->enabled_p
)
3435 header_line_row
->y
= 0;
3436 update_window_line (w
, 0, &mouse_face_overwritten_p
);
3439 /* Fix the appearance of overlapping/overlapped rows. */
3440 if (!paused_p
&& !w
->pseudo_window_p
)
3442 #ifdef HAVE_WINDOW_SYSTEM
3443 if (changed_p
&& rif
->fix_overlapping_area
)
3445 redraw_overlapped_rows (w
, yb
);
3446 redraw_overlapping_rows (w
, yb
);
3450 /* Make cursor visible at cursor position of W. */
3451 set_window_cursor_after_update (w
);
3453 #if 0 /* Check that current matrix invariants are satisfied. This is
3454 for debugging only. See the comment of check_matrix_invariants. */
3455 IF_DEBUG (check_matrix_invariants (w
));
3460 /* Remember the redisplay method used to display the matrix. */
3461 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
3464 #ifdef HAVE_WINDOW_SYSTEM
3465 update_window_fringes (w
, 0);
3468 /* End the update of window W. Don't set the cursor if we
3469 paused updating the display because in this case,
3470 set_window_cursor_after_update hasn't been called, and
3471 W->output_cursor doesn't contain the cursor location. */
3472 rif
->update_window_end_hook (w
, !paused_p
, mouse_face_overwritten_p
);
3478 /* check_current_matrix_flags (w); */
3479 add_window_display_history (w
, w
->current_matrix
->method
, paused_p
);
3482 clear_glyph_matrix (desired_matrix
);
3488 /* Update the display of area AREA in window W, row number VPOS.
3489 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3492 update_marginal_area (struct window
*w
, struct glyph_row
*updated_row
,
3493 enum glyph_row_area area
, int vpos
)
3495 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3496 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
3498 /* Set cursor to start of glyphs, write them, and clear to the end
3499 of the area. I don't think that something more sophisticated is
3500 necessary here, since marginal areas will not be the default. */
3501 output_cursor_to (w
, vpos
, 0, desired_row
->y
, 0);
3502 if (desired_row
->used
[area
])
3503 rif
->write_glyphs (w
, updated_row
, desired_row
->glyphs
[area
],
3504 area
, desired_row
->used
[area
]);
3505 rif
->clear_end_of_line (w
, updated_row
, area
, -1);
3509 /* Update the display of the text area of row VPOS in window W.
3510 Value is true if display has changed. */
3513 update_text_area (struct window
*w
, struct glyph_row
*updated_row
, int vpos
)
3515 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3516 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3517 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
3520 /* If rows are at different X or Y, or rows have different height,
3521 or the current row is marked invalid, write the entire line. */
3522 if (!current_row
->enabled_p
3523 || desired_row
->y
!= current_row
->y
3524 || desired_row
->ascent
!= current_row
->ascent
3525 || desired_row
->phys_ascent
!= current_row
->phys_ascent
3526 || desired_row
->phys_height
!= current_row
->phys_height
3527 || desired_row
->visible_height
!= current_row
->visible_height
3528 || current_row
->overlapped_p
3529 /* This next line is necessary for correctly redrawing
3530 mouse-face areas after scrolling and other operations.
3531 However, it causes excessive flickering when mouse is moved
3532 across the mode line. Luckily, turning it off for the mode
3533 line doesn't seem to hurt anything. -- cyd.
3534 But it is still needed for the header line. -- kfs. */
3535 || (current_row
->mouse_face_p
3536 && !(current_row
->mode_line_p
&& vpos
> 0))
3537 || current_row
->x
!= desired_row
->x
)
3539 output_cursor_to (w
, vpos
, 0, desired_row
->y
, desired_row
->x
);
3541 if (desired_row
->used
[TEXT_AREA
])
3542 rif
->write_glyphs (w
, updated_row
, desired_row
->glyphs
[TEXT_AREA
],
3543 TEXT_AREA
, desired_row
->used
[TEXT_AREA
]);
3545 /* Clear to end of window. */
3546 rif
->clear_end_of_line (w
, updated_row
, TEXT_AREA
, -1);
3549 /* This erases the cursor. We do this here because
3550 notice_overwritten_cursor cannot easily check this, which
3551 might indicate that the whole functionality of
3552 notice_overwritten_cursor would better be implemented here.
3553 On the other hand, we need notice_overwritten_cursor as long
3554 as mouse highlighting is done asynchronously outside of
3556 if (vpos
== w
->phys_cursor
.vpos
)
3557 w
->phys_cursor_on_p
= 0;
3562 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
3563 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
3564 bool overlapping_glyphs_p
= current_row
->contains_overlapping_glyphs_p
;
3565 int desired_stop_pos
= desired_row
->used
[TEXT_AREA
];
3566 bool abort_skipping
= 0;
3568 /* If the desired row extends its face to the text area end, and
3569 unless the current row also does so at the same position,
3570 make sure we write at least one glyph, so that the face
3571 extension actually takes place. */
3572 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
)
3573 && (desired_stop_pos
< current_row
->used
[TEXT_AREA
]
3574 || (desired_stop_pos
== current_row
->used
[TEXT_AREA
]
3575 && !MATRIX_ROW_EXTENDS_FACE_P (current_row
))))
3578 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
3582 /* Loop over glyphs that current and desired row may have
3586 bool can_skip_p
= !abort_skipping
;
3588 /* Skip over glyphs that both rows have in common. These
3589 don't have to be written. We can't skip if the last
3590 current glyph overlaps the glyph to its right. For
3591 example, consider a current row of `if ' with the `f' in
3592 Courier bold so that it overlaps the ` ' to its right.
3593 If the desired row is ` ', we would skip over the space
3594 after the `if' and there would remain a pixel from the
3595 `f' on the screen. */
3596 if (overlapping_glyphs_p
&& i
> 0)
3598 struct glyph
*glyph
= ¤t_row
->glyphs
[TEXT_AREA
][i
- 1];
3601 rif
->get_glyph_overhangs (glyph
, XFRAME (w
->frame
),
3603 can_skip_p
= (right
== 0 && !abort_skipping
);
3611 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3613 x
+= desired_glyph
->pixel_width
;
3614 ++desired_glyph
, ++current_glyph
, ++i
;
3617 /* Consider the case that the current row contains "xxx
3618 ppp ggg" in italic Courier font, and the desired row
3619 is "xxx ggg". The character `p' has lbearing, `g'
3620 has not. The loop above will stop in front of the
3621 first `p' in the current row. If we would start
3622 writing glyphs there, we wouldn't erase the lbearing
3623 of the `p'. The rest of the lbearing problem is then
3624 taken care of by draw_glyphs. */
3625 if (overlapping_glyphs_p
3627 && i
< current_row
->used
[TEXT_AREA
]
3628 && (current_row
->used
[TEXT_AREA
]
3629 != desired_row
->used
[TEXT_AREA
]))
3633 rif
->get_glyph_overhangs (current_glyph
,
3636 while (left
> 0 && i
> 0)
3638 --i
, --desired_glyph
, --current_glyph
;
3639 x
-= desired_glyph
->pixel_width
;
3640 left
-= desired_glyph
->pixel_width
;
3643 /* Abort the skipping algorithm if we end up before
3644 our starting point, to avoid looping (bug#1070).
3645 This can happen when the lbearing is larger than
3647 abort_skipping
= (i
< start_hpos
);
3651 /* Try to avoid writing the entire rest of the desired row
3652 by looking for a resync point. This mainly prevents
3653 mode line flickering in the case the mode line is in
3654 fixed-pitch font, which it usually will be. */
3655 if (i
< desired_row
->used
[TEXT_AREA
])
3657 int start_x
= x
, start_hpos
= i
;
3658 struct glyph
*start
= desired_glyph
;
3660 bool skip_first_p
= !can_skip_p
;
3662 /* Find the next glyph that's equal again. */
3665 || !GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3668 x
+= desired_glyph
->pixel_width
;
3669 current_x
+= current_glyph
->pixel_width
;
3670 ++desired_glyph
, ++current_glyph
, ++i
;
3674 if (i
== start_hpos
|| x
!= current_x
)
3678 desired_glyph
= start
;
3682 output_cursor_to (w
, vpos
, start_hpos
, desired_row
->y
, start_x
);
3683 rif
->write_glyphs (w
, updated_row
, start
,
3684 TEXT_AREA
, i
- start_hpos
);
3689 /* Write the rest. */
3690 if (i
< desired_row
->used
[TEXT_AREA
])
3692 output_cursor_to (w
, vpos
, i
, desired_row
->y
, x
);
3693 rif
->write_glyphs (w
, updated_row
, desired_glyph
,
3694 TEXT_AREA
, desired_row
->used
[TEXT_AREA
] - i
);
3698 /* Maybe clear to end of line. */
3699 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
3701 /* If new row extends to the end of the text area, nothing
3702 has to be cleared, if and only if we did a write_glyphs
3703 above. This is made sure by setting desired_stop_pos
3704 appropriately above. */
3705 eassert (i
< desired_row
->used
[TEXT_AREA
]
3706 || ((desired_row
->used
[TEXT_AREA
]
3707 == current_row
->used
[TEXT_AREA
])
3708 && MATRIX_ROW_EXTENDS_FACE_P (current_row
)));
3710 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
3712 /* If old row extends to the end of the text area, clear. */
3713 if (i
>= desired_row
->used
[TEXT_AREA
])
3714 output_cursor_to (w
, vpos
, i
, desired_row
->y
,
3715 desired_row
->pixel_width
);
3716 rif
->clear_end_of_line (w
, updated_row
, TEXT_AREA
, -1);
3719 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
3721 /* Otherwise clear to the end of the old row. Everything
3722 after that position should be clear already. */
3725 if (i
>= desired_row
->used
[TEXT_AREA
])
3726 output_cursor_to (w
, vpos
, i
, desired_row
->y
,
3727 desired_row
->pixel_width
);
3729 /* If cursor is displayed at the end of the line, make sure
3730 it's cleared. Nowadays we don't have a phys_cursor_glyph
3731 with which to erase the cursor (because this method
3732 doesn't work with lbearing/rbearing), so we must do it
3734 if (vpos
== w
->phys_cursor
.vpos
3735 && (desired_row
->reversed_p
3736 ? (w
->phys_cursor
.hpos
< 0)
3737 : (w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])))
3739 w
->phys_cursor_on_p
= 0;
3743 xlim
= current_row
->pixel_width
;
3744 rif
->clear_end_of_line (w
, updated_row
, TEXT_AREA
, xlim
);
3753 /* Update row VPOS in window W. Value is true if display has been changed. */
3756 update_window_line (struct window
*w
, int vpos
, bool *mouse_face_overwritten_p
)
3758 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3759 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3760 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
3763 /* A row can be completely invisible in case a desired matrix was
3764 built with a vscroll and then make_cursor_line_fully_visible shifts
3765 the matrix. Make sure to make such rows current anyway, since
3766 we need the correct y-position, for example, in the current matrix. */
3767 if (desired_row
->mode_line_p
3768 || desired_row
->visible_height
> 0)
3770 eassert (desired_row
->enabled_p
);
3772 /* Update display of the left margin area, if there is one. */
3773 if (!desired_row
->full_width_p
&& w
->left_margin_cols
> 0)
3776 update_marginal_area (w
, desired_row
, LEFT_MARGIN_AREA
, vpos
);
3777 /* Setting this flag will ensure the vertical border, if
3778 any, between this window and the one on its left will be
3779 redrawn. This is necessary because updating the left
3780 margin area can potentially draw over the border. */
3781 current_row
->redraw_fringe_bitmaps_p
= 1;
3784 /* Update the display of the text area. */
3785 if (update_text_area (w
, desired_row
, vpos
))
3788 if (current_row
->mouse_face_p
)
3789 *mouse_face_overwritten_p
= 1;
3792 /* Update display of the right margin area, if there is one. */
3793 if (!desired_row
->full_width_p
&& w
->right_margin_cols
> 0)
3796 update_marginal_area (w
, desired_row
, RIGHT_MARGIN_AREA
, vpos
);
3799 /* Draw truncation marks etc. */
3800 if (!current_row
->enabled_p
3801 || desired_row
->y
!= current_row
->y
3802 || desired_row
->visible_height
!= current_row
->visible_height
3803 || desired_row
->cursor_in_fringe_p
!= current_row
->cursor_in_fringe_p
3804 || desired_row
->overlay_arrow_bitmap
!= current_row
->overlay_arrow_bitmap
3805 || current_row
->redraw_fringe_bitmaps_p
3806 || desired_row
->mode_line_p
!= current_row
->mode_line_p
3807 || desired_row
->exact_window_width_line_p
!= current_row
->exact_window_width_line_p
3808 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
3809 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
3810 rif
->after_update_window_line_hook (w
, desired_row
);
3813 /* Update current_row from desired_row. */
3814 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
3819 /* Set the cursor after an update of window W. This function may only
3820 be called from update_window. */
3823 set_window_cursor_after_update (struct window
*w
)
3825 struct frame
*f
= XFRAME (w
->frame
);
3826 int cx
, cy
, vpos
, hpos
;
3828 /* Not intended for frame matrix updates. */
3829 eassert (FRAME_WINDOW_P (f
));
3831 if (cursor_in_echo_area
3832 && !NILP (echo_area_buffer
[0])
3833 /* If we are showing a message instead of the mini-buffer,
3834 show the cursor for the message instead. */
3835 && XWINDOW (minibuf_window
) == w
3836 && EQ (minibuf_window
, echo_area_window
)
3837 /* These cases apply only to the frame that contains
3838 the active mini-buffer window. */
3839 && FRAME_HAS_MINIBUF_P (f
)
3840 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
3842 cx
= cy
= vpos
= hpos
= 0;
3844 if (cursor_in_echo_area
>= 0)
3846 /* If the mini-buffer is several lines high, find the last
3847 line that has any text on it. Note: either all lines
3848 are enabled or none. Otherwise we wouldn't be able to
3850 struct glyph_row
*row
, *last_row
;
3851 struct glyph
*glyph
;
3852 int yb
= window_text_bottom_y (w
);
3855 row
= w
->current_matrix
->rows
;
3856 while (row
->enabled_p
3857 && (last_row
== NULL
3858 || MATRIX_ROW_BOTTOM_Y (row
) <= yb
))
3860 if (row
->used
[TEXT_AREA
]
3861 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
3868 struct glyph
*start
= last_row
->glyphs
[TEXT_AREA
];
3869 struct glyph
*last
= start
+ last_row
->used
[TEXT_AREA
] - 1;
3871 while (last
> start
&& last
->charpos
< 0)
3874 for (glyph
= start
; glyph
< last
; ++glyph
)
3876 cx
+= glyph
->pixel_width
;
3881 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
3889 hpos
= w
->cursor
.hpos
;
3890 vpos
= w
->cursor
.vpos
;
3893 /* Window cursor can be out of sync for horizontally split windows.
3894 Horizontal position is -1 when cursor is on the left fringe. */
3895 hpos
= clip_to_bounds (-1, hpos
, w
->current_matrix
->matrix_w
- 1);
3896 vpos
= clip_to_bounds (0, vpos
, w
->current_matrix
->nrows
- 1);
3897 output_cursor_to (w
, vpos
, hpos
, cy
, cx
);
3901 /* Set WINDOW->must_be_updated_p to ON_P for all windows in
3902 the window tree rooted at W. */
3905 set_window_update_flags (struct window
*w
, bool on_p
)
3909 if (WINDOWP (w
->contents
))
3910 set_window_update_flags (XWINDOW (w
->contents
), on_p
);
3912 w
->must_be_updated_p
= on_p
;
3914 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3920 /***********************************************************************
3921 Window-Based Scrolling
3922 ***********************************************************************/
3924 /* Structure describing rows in scrolling_window. */
3928 /* Number of occurrences of this row in desired and current matrix. */
3929 int old_uses
, new_uses
;
3931 /* Vpos of row in new matrix. */
3932 int new_line_number
;
3934 /* Bucket index of this row_entry in the hash table row_table. */
3937 /* The row described by this entry. */
3938 struct glyph_row
*row
;
3940 /* Hash collision chain. */
3941 struct row_entry
*next
;
3944 /* A pool to allocate row_entry structures from, and the size of the
3945 pool. The pool is reallocated in scrolling_window when we find
3946 that we need a larger one. */
3948 static struct row_entry
*row_entry_pool
;
3949 static ptrdiff_t row_entry_pool_size
;
3951 /* Index of next free entry in row_entry_pool. */
3953 static ptrdiff_t row_entry_idx
;
3955 /* The hash table used during scrolling, and the table's size. This
3956 table is used to quickly identify equal rows in the desired and
3959 static struct row_entry
**row_table
;
3960 static ptrdiff_t row_table_size
;
3962 /* Vectors of pointers to row_entry structures belonging to the
3963 current and desired matrix, and the size of the vectors. */
3965 static struct row_entry
**old_lines
, **new_lines
;
3966 static ptrdiff_t old_lines_size
, new_lines_size
;
3968 /* A pool to allocate run structures from, and its size. */
3970 static struct run
*run_pool
;
3971 static ptrdiff_t runs_size
;
3973 /* A vector of runs of lines found during scrolling. */
3975 static struct run
**runs
;
3977 /* Add glyph row ROW to the scrolling hash table. */
3979 static struct row_entry
*
3980 add_row_entry (struct glyph_row
*row
)
3982 struct row_entry
*entry
;
3983 ptrdiff_t i
= row
->hash
% row_table_size
;
3985 entry
= row_table
[i
];
3986 eassert (entry
|| verify_row_hash (row
));
3987 while (entry
&& !row_equal_p (entry
->row
, row
, 1))
3988 entry
= entry
->next
;
3992 entry
= row_entry_pool
+ row_entry_idx
++;
3994 entry
->old_uses
= entry
->new_uses
= 0;
3995 entry
->new_line_number
= 0;
3997 entry
->next
= row_table
[i
];
3998 row_table
[i
] = entry
;
4005 /* Try to reuse part of the current display of W by scrolling lines.
4006 HEADER_LINE_P means W has a header line.
4008 The algorithm is taken from Communications of the ACM, Apr78 "A
4009 Technique for Isolating Differences Between Files." It should take
4012 A short outline of the steps of the algorithm
4014 1. Skip lines equal at the start and end of both matrices.
4016 2. Enter rows in the current and desired matrix into a symbol
4017 table, counting how often they appear in both matrices.
4019 3. Rows that appear exactly once in both matrices serve as anchors,
4020 i.e. we assume that such lines are likely to have been moved.
4022 4. Starting from anchor lines, extend regions to be scrolled both
4023 forward and backward.
4027 -1 if all rows were found to be equal.
4028 0 to indicate that we did not scroll the display, or
4029 1 if we did scroll. */
4032 scrolling_window (struct window
*w
, bool header_line_p
)
4034 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4035 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4036 int yb
= window_text_bottom_y (w
);
4038 int j
, first_old
, first_new
, last_old
, last_new
;
4041 struct row_entry
*entry
;
4042 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
4044 /* Skip over rows equal at the start. */
4045 for (i
= header_line_p
; i
< current_matrix
->nrows
- 1; ++i
)
4047 struct glyph_row
*d
= MATRIX_ROW (desired_matrix
, i
);
4048 struct glyph_row
*c
= MATRIX_ROW (current_matrix
, i
);
4052 && !d
->redraw_fringe_bitmaps_p
4054 && MATRIX_ROW_BOTTOM_Y (c
) <= yb
4055 && MATRIX_ROW_BOTTOM_Y (d
) <= yb
4056 && row_equal_p (c
, d
, 1))
4065 /* Give up if some rows in the desired matrix are not enabled. */
4066 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4069 first_old
= first_new
= i
;
4071 /* Set last_new to the index + 1 of the row that reaches the
4072 bottom boundary in the desired matrix. Give up if we find a
4073 disabled row before we reach the bottom boundary. */
4075 while (i
< desired_matrix
->nrows
- 1)
4079 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4081 bottom
= MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
));
4090 /* Set last_old to the index + 1 of the row that reaches the bottom
4091 boundary in the current matrix. We don't look at the enabled
4092 flag here because we plan to reuse part of the display even if
4093 other parts are disabled. */
4095 while (i
< current_matrix
->nrows
- 1)
4097 int bottom
= MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
));
4106 /* Skip over rows equal at the bottom. */
4109 while (i
- 1 > first_new
4110 && j
- 1 > first_old
4111 && MATRIX_ROW (current_matrix
, j
- 1)->enabled_p
4112 && (MATRIX_ROW (current_matrix
, j
- 1)->y
4113 == MATRIX_ROW (desired_matrix
, i
- 1)->y
)
4114 && !MATRIX_ROW (desired_matrix
, i
- 1)->redraw_fringe_bitmaps_p
4115 && row_equal_p (MATRIX_ROW (desired_matrix
, i
- 1),
4116 MATRIX_ROW (current_matrix
, j
- 1), 1))
4121 /* Nothing to do if all rows are equal. */
4122 if (last_new
== first_new
)
4125 /* Check for integer overflow in size calculation.
4127 If next_almost_prime checks (N) for divisibility by 2..10, then
4128 it can return at most N + 10, e.g., next_almost_prime (1) == 11.
4129 So, set next_almost_prime_increment_max to 10.
4131 It's just a coincidence that next_almost_prime_increment_max ==
4132 NEXT_ALMOST_PRIME_LIMIT - 1. If NEXT_ALMOST_PRIME_LIMIT were
4133 13, then next_almost_prime_increment_max would be 14, e.g.,
4134 because next_almost_prime (113) would be 127. */
4136 verify (NEXT_ALMOST_PRIME_LIMIT
== 11);
4137 enum { next_almost_prime_increment_max
= 10 };
4138 ptrdiff_t row_table_max
=
4139 (min (PTRDIFF_MAX
, SIZE_MAX
) / (3 * sizeof *row_table
)
4140 - next_almost_prime_increment_max
);
4141 ptrdiff_t current_nrows_max
= row_table_max
- desired_matrix
->nrows
;
4142 if (current_nrows_max
< current_matrix
->nrows
)
4143 memory_full (SIZE_MAX
);
4146 /* Reallocate vectors, tables etc. if necessary. */
4148 if (current_matrix
->nrows
> old_lines_size
)
4149 old_lines
= xpalloc (old_lines
, &old_lines_size
,
4150 current_matrix
->nrows
- old_lines_size
,
4151 INT_MAX
, sizeof *old_lines
);
4153 if (desired_matrix
->nrows
> new_lines_size
)
4154 new_lines
= xpalloc (new_lines
, &new_lines_size
,
4155 desired_matrix
->nrows
- new_lines_size
,
4156 INT_MAX
, sizeof *new_lines
);
4158 n
= desired_matrix
->nrows
;
4159 n
+= current_matrix
->nrows
;
4160 if (row_table_size
< 3 * n
)
4162 ptrdiff_t size
= next_almost_prime (3 * n
);
4163 row_table
= xnrealloc (row_table
, size
, sizeof *row_table
);
4164 row_table_size
= size
;
4165 memset (row_table
, 0, size
* sizeof *row_table
);
4168 if (n
> row_entry_pool_size
)
4169 row_entry_pool
= xpalloc (row_entry_pool
, &row_entry_pool_size
,
4170 n
- row_entry_pool_size
,
4171 -1, sizeof *row_entry_pool
);
4173 if (desired_matrix
->nrows
> runs_size
)
4175 runs
= xnrealloc (runs
, desired_matrix
->nrows
, sizeof *runs
);
4176 run_pool
= xnrealloc (run_pool
, desired_matrix
->nrows
, sizeof *run_pool
);
4177 runs_size
= desired_matrix
->nrows
;
4180 nruns
= run_idx
= 0;
4183 /* Add rows from the current and desired matrix to the hash table
4184 row_hash_table to be able to find equal ones quickly. */
4186 for (i
= first_old
; i
< last_old
; ++i
)
4188 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4190 entry
= add_row_entry (MATRIX_ROW (current_matrix
, i
));
4191 old_lines
[i
] = entry
;
4195 old_lines
[i
] = NULL
;
4198 for (i
= first_new
; i
< last_new
; ++i
)
4200 eassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4201 entry
= add_row_entry (MATRIX_ROW (desired_matrix
, i
));
4203 entry
->new_line_number
= i
;
4204 new_lines
[i
] = entry
;
4207 /* Identify moves based on lines that are unique and equal
4208 in both matrices. */
4209 for (i
= first_old
; i
< last_old
;)
4211 && old_lines
[i
]->old_uses
== 1
4212 && old_lines
[i
]->new_uses
== 1)
4215 int new_line
= old_lines
[i
]->new_line_number
;
4216 struct run
*run
= run_pool
+ run_idx
++;
4219 run
->current_vpos
= i
;
4220 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4221 run
->desired_vpos
= new_line
;
4222 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4224 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4226 /* Extend backward. */
4229 while (p
> first_old
4231 && old_lines
[p
] == new_lines
[q
])
4233 int h
= MATRIX_ROW (current_matrix
, p
)->height
;
4234 --run
->current_vpos
;
4235 --run
->desired_vpos
;
4238 run
->desired_y
-= h
;
4239 run
->current_y
-= h
;
4243 /* Extend forward. */
4248 && old_lines
[p
] == new_lines
[q
])
4250 int h
= MATRIX_ROW (current_matrix
, p
)->height
;
4256 /* Insert run into list of all runs. Order runs by copied
4257 pixel lines. Note that we record runs that don't have to
4258 be copied because they are already in place. This is done
4259 because we can avoid calling update_window_line in this
4261 for (p
= 0; p
< nruns
&& runs
[p
]->height
> run
->height
; ++p
)
4263 for (q
= nruns
; q
> p
; --q
)
4264 runs
[q
] = runs
[q
- 1];
4273 /* Do the moves. Do it in a way that we don't overwrite something
4274 we want to copy later on. This is not solvable in general
4275 because there is only one display and we don't have a way to
4276 exchange areas on this display. Example:
4278 +-----------+ +-----------+
4280 +-----------+ --> +-----------+
4282 +-----------+ +-----------+
4284 Instead, prefer bigger moves, and invalidate moves that would
4285 copy from where we copied to. */
4287 for (i
= 0; i
< nruns
; ++i
)
4288 if (runs
[i
]->nrows
> 0)
4290 struct run
*r
= runs
[i
];
4292 /* Copy on the display. */
4293 if (r
->current_y
!= r
->desired_y
)
4295 rif
->clear_window_mouse_face (w
);
4296 rif
->scroll_run_hook (w
, r
);
4299 /* Truncate runs that copy to where we copied to, and
4300 invalidate runs that copy from where we copied to. */
4301 for (j
= nruns
- 1; j
> i
; --j
)
4303 struct run
*p
= runs
[j
];
4304 bool truncated_p
= 0;
4307 && p
->desired_y
< r
->desired_y
+ r
->height
4308 && p
->desired_y
+ p
->height
> r
->desired_y
)
4310 if (p
->desired_y
< r
->desired_y
)
4312 p
->nrows
= r
->desired_vpos
- p
->desired_vpos
;
4313 p
->height
= r
->desired_y
- p
->desired_y
;
4318 int nrows_copied
= (r
->desired_vpos
+ r
->nrows
4321 if (p
->nrows
<= nrows_copied
)
4325 int height_copied
= (r
->desired_y
+ r
->height
4328 p
->current_vpos
+= nrows_copied
;
4329 p
->desired_vpos
+= nrows_copied
;
4330 p
->nrows
-= nrows_copied
;
4331 p
->current_y
+= height_copied
;
4332 p
->desired_y
+= height_copied
;
4333 p
->height
-= height_copied
;
4339 if (r
->current_y
!= r
->desired_y
4340 /* The condition below is equivalent to
4341 ((p->current_y >= r->desired_y
4342 && p->current_y < r->desired_y + r->height)
4343 || (p->current_y + p->height > r->desired_y
4344 && (p->current_y + p->height
4345 <= r->desired_y + r->height)))
4346 because we have 0 < p->height <= r->height. */
4347 && p
->current_y
< r
->desired_y
+ r
->height
4348 && p
->current_y
+ p
->height
> r
->desired_y
)
4351 /* Reorder runs by copied pixel lines if truncated. */
4352 if (truncated_p
&& p
->nrows
> 0)
4356 while (runs
[k
]->nrows
== 0 || runs
[k
]->height
< p
->height
)
4358 memmove (runs
+ j
, runs
+ j
+ 1, (k
- j
) * sizeof (*runs
));
4363 /* Assign matrix rows. */
4364 for (j
= 0; j
< r
->nrows
; ++j
)
4366 struct glyph_row
*from
, *to
;
4367 bool to_overlapped_p
;
4369 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
4370 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
4371 to_overlapped_p
= to
->overlapped_p
;
4372 from
->redraw_fringe_bitmaps_p
= from
->fringe_bitmap_periodic_p
;
4373 assign_row (to
, from
);
4374 /* The above `assign_row' actually does swap, so if we had
4375 an overlap in the copy destination of two runs, then
4376 the second run would assign a previously disabled bogus
4377 row. But thanks to the truncation code in the
4378 preceding for-loop, we no longer have such an overlap,
4379 and thus the assigned row should always be enabled. */
4380 eassert (to
->enabled_p
);
4381 from
->enabled_p
= 0;
4382 to
->overlapped_p
= to_overlapped_p
;
4386 /* Clear the hash table, for the next time. */
4387 for (i
= 0; i
< row_entry_idx
; ++i
)
4388 row_table
[row_entry_pool
[i
].bucket
] = NULL
;
4390 /* Value is 1 to indicate that we scrolled the display. */
4396 /************************************************************************
4398 ************************************************************************/
4400 /* Update the desired frame matrix of frame F.
4402 FORCE_P means that the update should not be stopped by pending input.
4403 INHIBIT_HAIRY_ID_P means that scrolling should not be tried.
4405 Value is true if update was stopped due to pending input. */
4408 update_frame_1 (struct frame
*f
, bool force_p
, bool inhibit_id_p
)
4410 /* Frame matrices to work on. */
4411 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4412 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4415 int preempt_count
= baud_rate
/ 2400 + 1;
4417 eassert (current_matrix
&& desired_matrix
);
4419 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
4420 calculate_costs (f
);
4422 if (preempt_count
<= 0)
4425 if (!force_p
&& detect_input_pending_ignore_squeezables ())
4431 /* If we cannot insert/delete lines, it's no use trying it. */
4432 if (!FRAME_LINE_INS_DEL_OK (f
))
4435 /* See if any of the desired lines are enabled; don't compute for
4436 i/d line if just want cursor motion. */
4437 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
4438 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4441 /* Try doing i/d line, if not yet inhibited. */
4442 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
4443 force_p
|= scrolling (f
);
4445 /* Update the individual lines as needed. Do bottom line first. */
4446 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
4447 update_frame_line (f
, desired_matrix
->nrows
- 1);
4449 /* Now update the rest of the lines. */
4450 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
4452 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4454 if (FRAME_TERMCAP_P (f
))
4456 /* Flush out every so many lines.
4457 Also flush out if likely to have more than 1k buffered
4458 otherwise. I'm told that some telnet connections get
4459 really screwed by more than 1k output at once. */
4460 FILE *display_output
= FRAME_TTY (f
)->output
;
4463 ptrdiff_t outq
= __fpending (display_output
);
4465 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
4466 fflush (display_output
);
4470 if (!force_p
&& (i
- 1) % preempt_count
== 0)
4471 detect_input_pending_ignore_squeezables ();
4473 update_frame_line (f
, i
);
4477 pause_p
= 0 < i
&& i
< FRAME_LINES (f
) - 1;
4479 /* Now just clean up termcap drivers and set cursor, etc. */
4482 if ((cursor_in_echo_area
4483 /* If we are showing a message instead of the mini-buffer,
4484 show the cursor for the message instead of for the
4485 (now hidden) mini-buffer contents. */
4486 || (EQ (minibuf_window
, selected_window
)
4487 && EQ (minibuf_window
, echo_area_window
)
4488 && !NILP (echo_area_buffer
[0])))
4489 /* These cases apply only to the frame that contains
4490 the active mini-buffer window. */
4491 && FRAME_HAS_MINIBUF_P (f
)
4492 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4494 int top
= WINDOW_TOP_EDGE_LINE (XWINDOW (FRAME_MINIBUF_WINDOW (f
)));
4497 if (cursor_in_echo_area
< 0)
4499 /* Negative value of cursor_in_echo_area means put
4500 cursor at beginning of line. */
4506 /* Positive value of cursor_in_echo_area means put
4507 cursor at the end of the prompt. If the mini-buffer
4508 is several lines high, find the last line that has
4510 row
= FRAME_LINES (f
);
4516 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
4518 /* Frame rows are filled up with spaces that
4519 must be ignored here. */
4520 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
4522 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
4523 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
4526 && (last
- 1)->charpos
< 0)
4532 while (row
> top
&& col
== 0);
4534 /* Make sure COL is not out of range. */
4535 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
4537 /* If we have another row, advance cursor into it. */
4538 if (row
< FRAME_LINES (f
) - 1)
4540 col
= FRAME_LEFT_SCROLL_BAR_COLS (f
);
4543 /* Otherwise move it back in range. */
4545 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
4549 cursor_to (f
, row
, col
);
4553 /* We have only one cursor on terminal frames. Use it to
4554 display the cursor of the selected window. */
4555 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
4556 if (w
->cursor
.vpos
>= 0
4557 /* The cursor vpos may be temporarily out of bounds
4558 in the following situation: There is one window,
4559 with the cursor in the lower half of it. The window
4560 is split, and a message causes a redisplay before
4561 a new cursor position has been computed. */
4562 && w
->cursor
.vpos
< WINDOW_TOTAL_LINES (w
))
4564 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
4565 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
4567 x
+= max (0, w
->left_margin_cols
);
4568 cursor_to (f
, y
, x
);
4575 clear_desired_matrices (f
);
4580 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4583 scrolling (struct frame
*frame
)
4585 int unchanged_at_top
, unchanged_at_bottom
;
4588 int *old_hash
= alloca (FRAME_LINES (frame
) * sizeof (int));
4589 int *new_hash
= alloca (FRAME_LINES (frame
) * sizeof (int));
4590 int *draw_cost
= alloca (FRAME_LINES (frame
) * sizeof (int));
4591 int *old_draw_cost
= alloca (FRAME_LINES (frame
) * sizeof (int));
4593 int free_at_end_vpos
= FRAME_LINES (frame
);
4594 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4595 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4597 eassert (current_matrix
);
4599 /* Compute hash codes of all the lines. Also calculate number of
4600 changed lines, number of unchanged lines at the beginning, and
4601 number of unchanged lines at the end. */
4603 unchanged_at_top
= 0;
4604 unchanged_at_bottom
= FRAME_LINES (frame
);
4605 for (i
= 0; i
< FRAME_LINES (frame
); i
++)
4607 /* Give up on this scrolling if some old lines are not enabled. */
4608 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
4610 old_hash
[i
] = line_hash_code (frame
, MATRIX_ROW (current_matrix
, i
));
4611 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4613 /* This line cannot be redrawn, so don't let scrolling mess it. */
4614 new_hash
[i
] = old_hash
[i
];
4615 #define INFINITY 1000000 /* Taken from scroll.c */
4616 draw_cost
[i
] = INFINITY
;
4620 new_hash
[i
] = line_hash_code (frame
, MATRIX_ROW (desired_matrix
, i
));
4621 draw_cost
[i
] = line_draw_cost (frame
, desired_matrix
, i
);
4624 if (old_hash
[i
] != new_hash
[i
])
4627 unchanged_at_bottom
= FRAME_LINES (frame
) - i
- 1;
4629 else if (i
== unchanged_at_top
)
4631 old_draw_cost
[i
] = line_draw_cost (frame
, current_matrix
, i
);
4634 /* If changed lines are few, don't allow preemption, don't scroll. */
4635 if ((!FRAME_SCROLL_REGION_OK (frame
)
4636 && changed_lines
< baud_rate
/ 2400)
4637 || unchanged_at_bottom
== FRAME_LINES (frame
))
4640 window_size
= (FRAME_LINES (frame
) - unchanged_at_top
4641 - unchanged_at_bottom
);
4643 if (FRAME_SCROLL_REGION_OK (frame
))
4644 free_at_end_vpos
-= unchanged_at_bottom
;
4645 else if (FRAME_MEMORY_BELOW_FRAME (frame
))
4646 free_at_end_vpos
= -1;
4648 /* If large window, fast terminal and few lines in common between
4649 current frame and desired frame, don't bother with i/d calc. */
4650 if (!FRAME_SCROLL_REGION_OK (frame
)
4651 && window_size
>= 18 && baud_rate
> 2400
4653 10 * scrolling_max_lines_saved (unchanged_at_top
,
4654 FRAME_LINES (frame
) - unchanged_at_bottom
,
4655 old_hash
, new_hash
, draw_cost
)))
4658 if (window_size
< 2)
4661 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
4662 draw_cost
+ unchanged_at_top
- 1,
4663 old_draw_cost
+ unchanged_at_top
- 1,
4664 old_hash
+ unchanged_at_top
- 1,
4665 new_hash
+ unchanged_at_top
- 1,
4666 free_at_end_vpos
- unchanged_at_top
);
4672 /* Count the number of blanks at the start of the vector of glyphs R
4673 which is LEN glyphs long. */
4676 count_blanks (struct glyph
*r
, int len
)
4680 for (i
= 0; i
< len
; ++i
)
4681 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
4688 /* Count the number of glyphs in common at the start of the glyph
4689 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
4690 of STR2. Value is the number of equal glyphs equal at the start. */
4693 count_match (struct glyph
*str1
, struct glyph
*end1
, struct glyph
*str2
, struct glyph
*end2
)
4695 struct glyph
*p1
= str1
;
4696 struct glyph
*p2
= str2
;
4700 && GLYPH_CHAR_AND_FACE_EQUAL_P (p1
, p2
))
4707 /* Char insertion/deletion cost vector, from term.c */
4709 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_TOTAL_COLS ((f))])
4712 /* Perform a frame-based update on line VPOS in frame FRAME. */
4715 update_frame_line (struct frame
*f
, int vpos
)
4717 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
4719 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
4720 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4721 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4722 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
4723 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
4724 bool must_write_whole_line_p
;
4725 bool write_spaces_p
= FRAME_MUST_WRITE_SPACES (f
);
4726 bool colored_spaces_p
= (FACE_FROM_ID (f
, DEFAULT_FACE_ID
)->background
4727 != FACE_TTY_DEFAULT_BG_COLOR
);
4729 if (colored_spaces_p
)
4732 /* Current row not enabled means it has unknown contents. We must
4733 write the whole desired line in that case. */
4734 must_write_whole_line_p
= !current_row
->enabled_p
;
4735 if (must_write_whole_line_p
)
4742 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
4743 olen
= current_row
->used
[TEXT_AREA
];
4745 /* Ignore trailing spaces, if we can. */
4746 if (!write_spaces_p
)
4747 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
4751 current_row
->enabled_p
= 1;
4752 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
4754 /* If desired line is empty, just clear the line. */
4755 if (!desired_row
->enabled_p
)
4761 nbody
= desired_row
->glyphs
[TEXT_AREA
];
4762 nlen
= desired_row
->used
[TEXT_AREA
];
4763 nend
= nbody
+ nlen
;
4765 /* If display line has unknown contents, write the whole line. */
4766 if (must_write_whole_line_p
)
4768 /* Ignore spaces at the end, if we can. */
4769 if (!write_spaces_p
)
4770 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4773 /* Write the contents of the desired line. */
4776 cursor_to (f
, vpos
, 0);
4777 write_glyphs (f
, nbody
, nlen
);
4780 /* Don't call clear_end_of_line if we already wrote the whole
4781 line. The cursor will not be at the right margin in that
4782 case but in the line below. */
4783 if (nlen
< FRAME_TOTAL_COLS (f
))
4785 cursor_to (f
, vpos
, nlen
);
4786 clear_end_of_line (f
, FRAME_TOTAL_COLS (f
));
4789 /* Make sure we are in the right row, otherwise cursor movement
4790 with cmgoto might use `ch' in the wrong row. */
4791 cursor_to (f
, vpos
, 0);
4793 make_current (desired_matrix
, current_matrix
, vpos
);
4797 /* Pretend trailing spaces are not there at all,
4798 unless for one reason or another we must write all spaces. */
4799 if (!write_spaces_p
)
4800 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
4803 /* If there's no i/d char, quickly do the best we can without it. */
4804 if (!FRAME_CHAR_INS_DEL_OK (f
))
4808 /* Find the first glyph in desired row that doesn't agree with
4809 a glyph in the current row, and write the rest from there on. */
4810 for (i
= 0; i
< nlen
; i
++)
4812 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
4814 /* Find the end of the run of different glyphs. */
4818 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
4819 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
4822 /* Output this run of non-matching chars. */
4823 cursor_to (f
, vpos
, i
);
4824 write_glyphs (f
, nbody
+ i
, j
- i
);
4827 /* Now find the next non-match. */
4831 /* Clear the rest of the line, or the non-clear part of it. */
4834 cursor_to (f
, vpos
, nlen
);
4835 clear_end_of_line (f
, olen
);
4838 /* Make current row = desired row. */
4839 make_current (desired_matrix
, current_matrix
, vpos
);
4843 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
4844 characters in a row. */
4848 /* If current line is blank, skip over initial spaces, if
4849 possible, and write the rest. */
4853 nsp
= count_blanks (nbody
, nlen
);
4857 cursor_to (f
, vpos
, nsp
);
4858 write_glyphs (f
, nbody
+ nsp
, nlen
- nsp
);
4861 /* Exchange contents between current_frame and new_frame. */
4862 make_current (desired_matrix
, current_matrix
, vpos
);
4866 /* Compute number of leading blanks in old and new contents. */
4867 osp
= count_blanks (obody
, olen
);
4868 nsp
= (colored_spaces_p
? 0 : count_blanks (nbody
, nlen
));
4870 /* Compute number of matching chars starting with first non-blank. */
4871 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
4872 nbody
+ nsp
, nbody
+ nlen
);
4874 /* Spaces in new match implicit space past the end of old. */
4875 /* A bug causing this to be a no-op was fixed in 18.29. */
4876 if (!write_spaces_p
&& osp
+ begmatch
== olen
)
4879 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
4883 /* Avoid doing insert/delete char
4884 just cause number of leading spaces differs
4885 when the following text does not match. */
4886 if (begmatch
== 0 && osp
!= nsp
)
4887 osp
= nsp
= min (osp
, nsp
);
4889 /* Find matching characters at end of line */
4892 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
4894 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
4899 endmatch
= obody
+ olen
- op1
;
4901 /* tem gets the distance to insert or delete.
4902 endmatch is how many characters we save by doing so.
4905 tem
= (nlen
- nsp
) - (olen
- osp
);
4907 && (!FRAME_CHAR_INS_DEL_OK (f
)
4908 || endmatch
<= char_ins_del_cost (f
)[tem
]))
4911 /* nsp - osp is the distance to insert or delete.
4912 If that is nonzero, begmatch is known to be nonzero also.
4913 begmatch + endmatch is how much we save by doing the ins/del.
4917 && (!FRAME_CHAR_INS_DEL_OK (f
)
4918 || begmatch
+ endmatch
<= char_ins_del_cost (f
)[nsp
- osp
]))
4922 osp
= nsp
= min (osp
, nsp
);
4925 /* Now go through the line, inserting, writing and
4926 deleting as appropriate. */
4930 cursor_to (f
, vpos
, nsp
);
4931 delete_glyphs (f
, osp
- nsp
);
4935 /* If going to delete chars later in line
4936 and insert earlier in the line,
4937 must delete first to avoid losing data in the insert */
4938 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
4940 cursor_to (f
, vpos
, nlen
- endmatch
+ osp
- nsp
);
4941 delete_glyphs (f
, olen
+ nsp
- osp
- nlen
);
4942 olen
= nlen
- (nsp
- osp
);
4944 cursor_to (f
, vpos
, osp
);
4945 insert_glyphs (f
, 0, nsp
- osp
);
4949 tem
= nsp
+ begmatch
+ endmatch
;
4950 if (nlen
!= tem
|| olen
!= tem
)
4952 if (!endmatch
|| nlen
== olen
)
4954 /* If new text being written reaches right margin, there is
4955 no need to do clear-to-eol at the end of this function
4956 (and it would not be safe, since cursor is not going to
4957 be "at the margin" after the text is done). */
4958 if (nlen
== FRAME_TOTAL_COLS (f
))
4961 /* Function write_glyphs is prepared to do nothing
4962 if passed a length <= 0. Check it here to avoid
4963 unnecessary cursor movement. */
4966 cursor_to (f
, vpos
, nsp
+ begmatch
);
4967 write_glyphs (f
, nbody
+ nsp
+ begmatch
, nlen
- tem
);
4970 else if (nlen
> olen
)
4972 /* Here, we used to have the following simple code:
4973 ----------------------------------------
4974 write_glyphs (nbody + nsp + begmatch, olen - tem);
4975 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
4976 ----------------------------------------
4977 but it doesn't work if nbody[nsp + begmatch + olen - tem]
4978 is a padding glyph. */
4979 int out
= olen
- tem
; /* Columns to be overwritten originally. */
4982 cursor_to (f
, vpos
, nsp
+ begmatch
);
4984 /* Calculate columns we can actually overwrite. */
4985 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
]))
4987 write_glyphs (f
, nbody
+ nsp
+ begmatch
, out
);
4989 /* If we left columns to be overwritten, we must delete them. */
4990 del
= olen
- tem
- out
;
4992 delete_glyphs (f
, del
);
4994 /* At last, we insert columns not yet written out. */
4995 insert_glyphs (f
, nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
4998 else if (olen
> nlen
)
5000 cursor_to (f
, vpos
, nsp
+ begmatch
);
5001 write_glyphs (f
, nbody
+ nsp
+ begmatch
, nlen
- tem
);
5002 delete_glyphs (f
, olen
- nlen
);
5008 /* If any unerased characters remain after the new line, erase them. */
5011 cursor_to (f
, vpos
, nlen
);
5012 clear_end_of_line (f
, olen
);
5015 /* Exchange contents between current_frame and new_frame. */
5016 make_current (desired_matrix
, current_matrix
, vpos
);
5021 /***********************************************************************
5022 X/Y Position -> Buffer Position
5023 ***********************************************************************/
5025 /* Determine what's under window-relative pixel position (*X, *Y).
5026 Return the OBJECT (string or buffer) that's there.
5027 Return in *POS the position in that object.
5028 Adjust *X and *Y to character positions.
5029 Return in *DX and *DY the pixel coordinates of the click,
5030 relative to the top left corner of OBJECT, or relative to
5031 the top left corner of the character glyph at (*X, *Y)
5033 Return WIDTH and HEIGHT of the object at (*X, *Y), or zero
5034 if the coordinates point to an empty area of the display. */
5037 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
)
5040 Lisp_Object old_current_buffer
= Fcurrent_buffer ();
5041 struct text_pos startp
;
5043 struct glyph_row
*row
;
5044 #ifdef HAVE_WINDOW_SYSTEM
5045 struct image
*img
= 0;
5048 void *itdata
= NULL
;
5050 /* We used to set current_buffer directly here, but that does the
5051 wrong thing with `face-remapping-alist' (bug#2044). */
5052 Fset_buffer (w
->contents
);
5053 itdata
= bidi_shelve_cache ();
5054 CLIP_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5055 start_display (&it
, w
, startp
);
5056 /* start_display takes into account the header-line row, but IT's
5057 vpos still counts from the glyph row that includes the window's
5058 start position. Adjust for a possible header-line row. */
5059 it
.vpos
+= WINDOW_WANTS_HEADER_LINE_P (w
);
5063 /* First, move to the beginning of the row corresponding to *Y. We
5064 need to be in that row to get the correct value of base paragraph
5065 direction for the text at (*X, *Y). */
5066 move_it_to (&it
, -1, 0, *y
, -1, MOVE_TO_X
| MOVE_TO_Y
);
5068 /* TO_X is the pixel position that the iterator will compute for the
5069 glyph at *X. We add it.first_visible_x because iterator
5070 positions include the hscroll. */
5071 to_x
= x0
+ it
.first_visible_x
;
5072 if (it
.bidi_it
.paragraph_dir
== R2L
)
5073 /* For lines in an R2L paragraph, we need to mirror TO_X wrt the
5074 text area. This is because the iterator, even in R2L
5075 paragraphs, delivers glyphs as if they started at the left
5076 margin of the window. (When we actually produce glyphs for
5077 display, we reverse their order in PRODUCE_GLYPHS, but the
5078 iterator doesn't know about that.) The following line adjusts
5079 the pixel position to the iterator geometry, which is what
5080 move_it_* routines use. (The -1 is because in a window whose
5081 text-area width is W, the rightmost pixel position is W-1, and
5082 it should be mirrored into zero pixel position.) */
5083 to_x
= window_box_width (w
, TEXT_AREA
) - to_x
- 1;
5085 /* Now move horizontally in the row to the glyph under *X. Second
5086 argument is ZV to prevent move_it_in_display_line from matching
5087 based on buffer positions. */
5088 move_it_in_display_line (&it
, ZV
, to_x
, MOVE_TO_X
);
5089 bidi_unshelve_cache (itdata
, 0);
5091 Fset_buffer (old_current_buffer
);
5093 *dx
= x0
+ it
.first_visible_x
- it
.current_x
;
5094 *dy
= *y
- it
.current_y
;
5096 string
= w
->contents
;
5097 if (STRINGP (it
.string
))
5100 if (it
.what
== IT_COMPOSITION
5101 && it
.cmp_it
.nchars
> 1
5102 && it
.cmp_it
.reversed_p
)
5104 /* The current display element is a grapheme cluster in a
5105 composition. In that case, we need the position of the first
5106 character of the cluster. But, as it.cmp_it.reversed_p is 1,
5107 it.current points to the last character of the cluster, thus
5108 we must move back to the first character of the same
5110 CHARPOS (pos
->pos
) -= it
.cmp_it
.nchars
- 1;
5111 if (STRINGP (it
.string
))
5112 BYTEPOS (pos
->pos
) = string_char_to_byte (string
, CHARPOS (pos
->pos
));
5114 BYTEPOS (pos
->pos
) = buf_charpos_to_bytepos (XBUFFER (w
->contents
),
5115 CHARPOS (pos
->pos
));
5118 #ifdef HAVE_WINDOW_SYSTEM
5119 if (it
.what
== IT_IMAGE
)
5121 if ((img
= IMAGE_FROM_ID (it
.f
, it
.image_id
)) != NULL
5122 && !NILP (img
->spec
))
5123 *object
= img
->spec
;
5127 if (it
.vpos
< w
->current_matrix
->nrows
5128 && (row
= MATRIX_ROW (w
->current_matrix
, it
.vpos
),
5131 if (it
.hpos
< row
->used
[TEXT_AREA
])
5133 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + it
.hpos
;
5134 #ifdef HAVE_WINDOW_SYSTEM
5137 *dy
-= row
->ascent
- glyph
->ascent
;
5138 *dx
+= glyph
->slice
.img
.x
;
5139 *dy
+= glyph
->slice
.img
.y
;
5140 /* Image slices positions are still relative to the entire image */
5141 *width
= img
->width
;
5142 *height
= img
->height
;
5147 *width
= glyph
->pixel_width
;
5148 *height
= glyph
->ascent
+ glyph
->descent
;
5154 *height
= row
->height
;
5159 *width
= *height
= 0;
5162 /* Add extra (default width) columns if clicked after EOL. */
5163 x1
= max (0, it
.current_x
+ it
.pixel_width
- it
.first_visible_x
);
5165 it
.hpos
+= (x0
- x1
) / WINDOW_FRAME_COLUMN_WIDTH (w
);
5174 /* Value is the string under window-relative coordinates X/Y in the
5175 mode line or header line (PART says which) of window W, or nil if none.
5176 *CHARPOS is set to the position in the string returned. */
5179 mode_line_string (struct window
*w
, enum window_part part
,
5180 int *x
, int *y
, ptrdiff_t *charpos
, Lisp_Object
*object
,
5181 int *dx
, int *dy
, int *width
, int *height
)
5183 struct glyph_row
*row
;
5184 struct glyph
*glyph
, *end
;
5186 Lisp_Object string
= Qnil
;
5188 if (part
== ON_MODE_LINE
)
5189 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5191 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
5193 *y
= row
- MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
5195 if (row
->mode_line_p
&& row
->enabled_p
)
5197 /* Find the glyph under X. If we find one with a string object,
5198 it's the one we were looking for. */
5199 glyph
= row
->glyphs
[TEXT_AREA
];
5200 end
= glyph
+ row
->used
[TEXT_AREA
];
5201 for (x0
= *x
; glyph
< end
&& x0
>= glyph
->pixel_width
; ++glyph
)
5202 x0
-= glyph
->pixel_width
;
5203 *x
= glyph
- row
->glyphs
[TEXT_AREA
];
5206 string
= glyph
->object
;
5207 *charpos
= glyph
->charpos
;
5208 *width
= glyph
->pixel_width
;
5209 *height
= glyph
->ascent
+ glyph
->descent
;
5210 #ifdef HAVE_WINDOW_SYSTEM
5211 if (glyph
->type
== IMAGE_GLYPH
)
5214 img
= IMAGE_FROM_ID (WINDOW_XFRAME (w
), glyph
->u
.img_id
);
5216 *object
= img
->spec
;
5217 y0
-= row
->ascent
- glyph
->ascent
;
5223 /* Add extra (default width) columns if clicked after EOL. */
5224 *x
+= x0
/ WINDOW_FRAME_COLUMN_WIDTH (w
);
5226 *height
= row
->height
;
5233 *width
= *height
= 0;
5243 /* Value is the string under window-relative coordinates X/Y in either
5244 marginal area, or nil if none. *CHARPOS is set to the position in
5245 the string returned. */
5248 marginal_area_string (struct window
*w
, enum window_part part
,
5249 int *x
, int *y
, ptrdiff_t *charpos
, Lisp_Object
*object
,
5250 int *dx
, int *dy
, int *width
, int *height
)
5252 struct glyph_row
*row
= w
->current_matrix
->rows
;
5253 struct glyph
*glyph
, *end
;
5254 int x0
, y0
, i
, wy
= *y
;
5256 Lisp_Object string
= Qnil
;
5258 if (part
== ON_LEFT_MARGIN
)
5259 area
= LEFT_MARGIN_AREA
;
5260 else if (part
== ON_RIGHT_MARGIN
)
5261 area
= RIGHT_MARGIN_AREA
;
5265 for (i
= 0; row
->enabled_p
&& i
< w
->current_matrix
->nrows
; ++i
, ++row
)
5266 if (wy
>= row
->y
&& wy
< MATRIX_ROW_BOTTOM_Y (row
))
5269 *y
= row
- MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
5273 /* Find the glyph under X. If we find one with a string object,
5274 it's the one we were looking for. */
5275 if (area
== RIGHT_MARGIN_AREA
)
5276 x0
= ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5277 ? WINDOW_LEFT_FRINGE_WIDTH (w
)
5278 : WINDOW_TOTAL_FRINGE_WIDTH (w
))
5279 + window_box_width (w
, LEFT_MARGIN_AREA
)
5280 + window_box_width (w
, TEXT_AREA
));
5282 x0
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5283 ? WINDOW_LEFT_FRINGE_WIDTH (w
)
5286 glyph
= row
->glyphs
[area
];
5287 end
= glyph
+ row
->used
[area
];
5288 for (x0
= *x
- x0
; glyph
< end
&& x0
>= glyph
->pixel_width
; ++glyph
)
5289 x0
-= glyph
->pixel_width
;
5290 *x
= glyph
- row
->glyphs
[area
];
5293 string
= glyph
->object
;
5294 *charpos
= glyph
->charpos
;
5295 *width
= glyph
->pixel_width
;
5296 *height
= glyph
->ascent
+ glyph
->descent
;
5297 #ifdef HAVE_WINDOW_SYSTEM
5298 if (glyph
->type
== IMAGE_GLYPH
)
5301 img
= IMAGE_FROM_ID (WINDOW_XFRAME (w
), glyph
->u
.img_id
);
5303 *object
= img
->spec
;
5304 y0
-= row
->ascent
- glyph
->ascent
;
5305 x0
+= glyph
->slice
.img
.x
;
5306 y0
+= glyph
->slice
.img
.y
;
5312 /* Add extra (default width) columns if clicked after EOL. */
5313 *x
+= x0
/ WINDOW_FRAME_COLUMN_WIDTH (w
);
5315 *height
= row
->height
;
5322 *width
= *height
= 0;
5332 /***********************************************************************
5333 Changing Frame Sizes
5334 ***********************************************************************/
5338 static void deliver_window_change_signal (int);
5341 handle_window_change_signal (int sig
)
5344 struct tty_display_info
*tty
;
5346 /* The frame size change obviously applies to a single
5347 termcap-controlled terminal, but we can't decide which.
5348 Therefore, we resize the frames corresponding to each tty.
5350 for (tty
= tty_list
; tty
; tty
= tty
->next
) {
5352 if (! tty
->term_initted
)
5355 /* Suspended tty frames have tty->input == NULL avoid trying to
5360 get_tty_size (fileno (tty
->input
), &width
, &height
);
5362 if (width
> 5 && height
> 2) {
5363 Lisp_Object tail
, frame
;
5365 FOR_EACH_FRAME (tail
, frame
)
5366 if (FRAME_TERMCAP_P (XFRAME (frame
)) && FRAME_TTY (XFRAME (frame
)) == tty
)
5367 /* Record the new sizes, but don't reallocate the data
5368 structures now. Let that be done later outside of the
5370 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5376 deliver_window_change_signal (int sig
)
5378 deliver_process_signal (sig
, handle_window_change_signal
);
5380 #endif /* SIGWINCH */
5383 /* Do any change in frame size that was requested by a signal.
5384 SAFE means this function is called from a place where it is
5385 safe to change frame sizes while a redisplay is in progress. */
5388 do_pending_window_change (bool safe
)
5390 /* If window change signal handler should have run before, run it now. */
5391 if (redisplaying_p
&& !safe
)
5394 while (delayed_size_change
)
5396 Lisp_Object tail
, frame
;
5398 delayed_size_change
= 0;
5400 FOR_EACH_FRAME (tail
, frame
)
5402 struct frame
*f
= XFRAME (frame
);
5404 if (f
->new_text_lines
!= 0 || f
->new_text_cols
!= 0)
5405 change_frame_size (f
, f
->new_text_lines
, f
->new_text_cols
,
5412 /* Change the frame height and/or width. Values may be given as zero to
5413 indicate no change is to take place.
5415 If DELAY, assume we're being called from a signal handler, and
5416 queue the change for later - perhaps the next redisplay.
5417 Since this tries to resize windows, we can't call it
5418 from a signal handler.
5420 SAFE means this function is called from a place where it's
5421 safe to change frame sizes while a redisplay is in progress. */
5424 change_frame_size (struct frame
*f
, int newheight
, int newwidth
,
5425 bool pretend
, bool delay
, bool safe
)
5427 Lisp_Object tail
, frame
;
5429 if (FRAME_MSDOS_P (f
))
5431 /* On MS-DOS, all frames use the same screen, so a change in
5432 size affects all frames. Termcap now supports multiple
5434 FOR_EACH_FRAME (tail
, frame
)
5435 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5436 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5437 pretend
, delay
, safe
);
5440 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
5444 change_frame_size_1 (struct frame
*f
, int newheight
, int newwidth
,
5445 bool pretend
, bool delay
, bool safe
)
5447 int new_frame_total_cols
;
5448 ptrdiff_t count
= SPECPDL_INDEX ();
5450 /* If we can't deal with the change now, queue it for later. */
5451 if (delay
|| (redisplaying_p
&& !safe
))
5453 f
->new_text_lines
= newheight
;
5454 f
->new_text_cols
= newwidth
;
5455 delayed_size_change
= 1;
5459 /* This size-change overrides any pending one for this frame. */
5460 f
->new_text_lines
= 0;
5461 f
->new_text_cols
= 0;
5463 /* If an argument is zero, set it to the current value. */
5465 newheight
= FRAME_LINES (f
);
5467 newwidth
= FRAME_COLS (f
);
5469 /* Compute width of windows in F. */
5470 /* Round up to the smallest acceptable size. */
5471 check_frame_size (f
, &newheight
, &newwidth
);
5473 /* This is the width of the frame with vertical scroll bars and fringe
5474 columns. Do this after rounding - see discussion of bug#9723. */
5475 new_frame_total_cols
= FRAME_TOTAL_COLS_ARG (f
, newwidth
);
5477 /* If we're not changing the frame size, quit now. */
5478 /* Frame width may be unchanged but the text portion may change, for
5479 example, fullscreen and remove/add scroll bar. */
5480 if (newheight
== FRAME_LINES (f
)
5481 /* Text portion unchanged? */
5482 && newwidth
== FRAME_COLS (f
)
5483 /* Frame width unchanged? */
5484 && new_frame_total_cols
== FRAME_TOTAL_COLS (f
))
5490 /* We only can set screen dimensions to certain values supported
5491 by our video hardware. Try to find the smallest size greater
5492 or equal to the requested dimensions. */
5493 dos_set_window_size (&newheight
, &newwidth
);
5496 if (newheight
!= FRAME_LINES (f
))
5498 resize_frame_windows (f
, newheight
, 0);
5500 /* MSDOS frames cannot PRETEND, as they change frame size by
5501 manipulating video hardware. */
5502 if ((FRAME_TERMCAP_P (f
) && !pretend
) || FRAME_MSDOS_P (f
))
5503 FrameRows (FRAME_TTY (f
)) = newheight
;
5506 if (new_frame_total_cols
!= FRAME_TOTAL_COLS (f
))
5508 resize_frame_windows (f
, new_frame_total_cols
, 1);
5510 /* MSDOS frames cannot PRETEND, as they change frame size by
5511 manipulating video hardware. */
5512 if ((FRAME_TERMCAP_P (f
) && !pretend
) || FRAME_MSDOS_P (f
))
5513 FrameCols (FRAME_TTY (f
)) = newwidth
;
5515 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (USE_GTK) && ! defined (HAVE_NS)
5516 if (WINDOWP (f
->tool_bar_window
))
5517 XWINDOW (f
->tool_bar_window
)->total_cols
= newwidth
;
5521 FRAME_LINES (f
) = newheight
;
5522 SET_FRAME_COLS (f
, newwidth
);
5525 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5526 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
5528 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
5530 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
5531 w
->cursor
.hpos
= w
->cursor
.x
= 0;
5532 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
5533 w
->cursor
.vpos
= w
->cursor
.y
= 0;
5536 adjust_frame_glyphs (f
);
5537 calculate_costs (f
);
5538 SET_FRAME_GARBAGED (f
);
5543 record_unwind_current_buffer ();
5545 run_window_configuration_change_hook (f
);
5547 unbind_to (count
, Qnil
);
5552 /***********************************************************************
5553 Terminal Related Lisp Functions
5554 ***********************************************************************/
5556 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
5557 1, 1, "FOpen termscript file: ",
5558 doc
: /* Start writing all terminal output to FILE as well as the terminal.
5559 FILE = nil means just close any termscript file currently open. */)
5562 struct tty_display_info
*tty
;
5564 if (! FRAME_TERMCAP_P (SELECTED_FRAME ())
5565 && ! FRAME_MSDOS_P (SELECTED_FRAME ()))
5566 error ("Current frame is not on a tty device");
5570 if (tty
->termscript
!= 0)
5573 fclose (tty
->termscript
);
5574 tty
->termscript
= 0;
5580 file
= Fexpand_file_name (file
, Qnil
);
5581 tty
->termscript
= emacs_fopen (SSDATA (file
), "w");
5582 if (tty
->termscript
== 0)
5583 report_file_error ("Opening termscript", file
);
5589 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
5590 Ssend_string_to_terminal
, 1, 2, 0,
5591 doc
: /* Send STRING to the terminal without alteration.
5592 Control characters in STRING will have terminal-dependent effects.
5594 Optional parameter TERMINAL specifies the tty terminal device to use.
5595 It may be a terminal object, a frame, or nil for the terminal used by
5596 the currently selected frame. In batch mode, STRING is sent to stdout
5597 when TERMINAL is nil. */)
5598 (Lisp_Object string
, Lisp_Object terminal
)
5600 struct terminal
*t
= get_terminal (terminal
, 1);
5603 /* ??? Perhaps we should do something special for multibyte strings here. */
5604 CHECK_STRING (string
);
5608 error ("Unknown terminal device");
5610 if (t
->type
== output_initial
)
5612 else if (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
)
5613 error ("Device %d is not a termcap terminal device", t
->id
);
5616 struct tty_display_info
*tty
= t
->display_info
.tty
;
5619 error ("Terminal is currently suspended");
5621 if (tty
->termscript
)
5623 fwrite (SDATA (string
), 1, SBYTES (string
), tty
->termscript
);
5624 fflush (tty
->termscript
);
5628 fwrite (SDATA (string
), 1, SBYTES (string
), out
);
5635 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
5636 doc
: /* Beep, or flash the screen.
5637 Also, unless an argument is given,
5638 terminate any keyboard macro currently executing. */)
5646 ring_bell (XFRAME (selected_frame
));
5655 bitch_at_user (void)
5659 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
5662 = "Keyboard macro terminated by a command ringing the bell";
5663 Fsignal (Quser_error
, list1 (build_string (msg
)));
5666 ring_bell (XFRAME (selected_frame
));
5671 /***********************************************************************
5673 ***********************************************************************/
5675 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
5676 doc
: /* Pause, without updating display, for SECONDS seconds.
5677 SECONDS may be a floating-point value, meaning that you can wait for a
5678 fraction of a second. Optional second arg MILLISECONDS specifies an
5679 additional wait period, in milliseconds; this is for backwards compatibility.
5680 \(Not all operating systems support waiting for a fraction of a second.) */)
5681 (Lisp_Object seconds
, Lisp_Object milliseconds
)
5683 double duration
= extract_float (seconds
);
5685 if (!NILP (milliseconds
))
5687 CHECK_NUMBER (milliseconds
);
5688 duration
+= XINT (milliseconds
) / 1000.0;
5693 struct timespec t
= dtotimespec (duration
);
5694 wait_reading_process_output (min (t
.tv_sec
, WAIT_READING_MAX
),
5695 t
.tv_nsec
, 0, 0, Qnil
, NULL
, 0);
5702 /* This is just like wait_reading_process_output, except that
5705 TIMEOUT is number of seconds to wait (float or integer),
5706 or t to wait forever.
5707 READING is true if reading input.
5708 If DISPLAY_OPTION is >0 display process output while waiting.
5709 If DISPLAY_OPTION is >1 perform an initial redisplay before waiting.
5713 sit_for (Lisp_Object timeout
, bool reading
, int display_option
)
5717 bool do_display
= display_option
> 0;
5719 swallow_events (do_display
);
5721 if ((detect_input_pending_run_timers (do_display
))
5722 || !NILP (Vexecuting_kbd_macro
))
5725 if (display_option
> 1)
5726 redisplay_preserve_echo_area (2);
5728 if (INTEGERP (timeout
))
5730 sec
= XINT (timeout
);
5735 else if (FLOATP (timeout
))
5737 double seconds
= XFLOAT_DATA (timeout
);
5738 if (! (0 < seconds
))
5742 struct timespec t
= dtotimespec (seconds
);
5743 sec
= min (t
.tv_sec
, WAIT_READING_MAX
);
5747 else if (EQ (timeout
, Qt
))
5753 wrong_type_argument (Qnumberp
, timeout
);
5760 wait_reading_process_output (sec
, nsec
, reading
? -1 : 1, do_display
,
5763 return detect_input_pending () ? Qnil
: Qt
;
5767 DEFUN ("redisplay", Fredisplay
, Sredisplay
, 0, 1, 0,
5768 doc
: /* Perform redisplay.
5769 Optional arg FORCE, if non-nil, prevents redisplay from being
5770 preempted by arriving input, even if `redisplay-dont-pause' is nil.
5771 If `redisplay-dont-pause' is non-nil (the default), redisplay is never
5772 preempted by arriving input, so FORCE does nothing.
5774 Return t if redisplay was performed, nil if redisplay was preempted
5775 immediately by pending input. */)
5781 if ((detect_input_pending_run_timers (1)
5782 && NILP (force
) && !redisplay_dont_pause
)
5783 || !NILP (Vexecuting_kbd_macro
))
5786 count
= SPECPDL_INDEX ();
5787 if (!NILP (force
) && !redisplay_dont_pause
)
5788 specbind (Qredisplay_dont_pause
, Qt
);
5789 redisplay_preserve_echo_area (2);
5790 unbind_to (count
, Qnil
);
5796 /***********************************************************************
5797 Other Lisp Functions
5798 ***********************************************************************/
5800 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
5801 session's frames, frame names, buffers, buffer-read-only flags, and
5802 buffer-modified-flags. */
5804 static Lisp_Object frame_and_buffer_state
;
5807 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
5808 Sframe_or_buffer_changed_p
, 0, 1, 0,
5809 doc
: /* Return non-nil if the frame and buffer state appears to have changed.
5810 VARIABLE is a variable name whose value is either nil or a state vector
5811 that will be updated to contain all frames and buffers,
5812 aside from buffers whose names start with space,
5813 along with the buffers' read-only and modified flags. This allows a fast
5814 check to see whether buffer menus might need to be recomputed.
5815 If this function returns non-nil, it updates the internal vector to reflect
5818 If VARIABLE is nil, an internal variable is used. Users should not
5819 pass nil for VARIABLE. */)
5820 (Lisp_Object variable
)
5822 Lisp_Object state
, tail
, frame
, buf
;
5825 if (! NILP (variable
))
5827 CHECK_SYMBOL (variable
);
5828 state
= Fsymbol_value (variable
);
5829 if (! VECTORP (state
))
5833 state
= frame_and_buffer_state
;
5836 FOR_EACH_FRAME (tail
, frame
)
5838 if (idx
== ASIZE (state
))
5840 if (!EQ (AREF (state
, idx
++), frame
))
5842 if (idx
== ASIZE (state
))
5844 if (!EQ (AREF (state
, idx
++), XFRAME (frame
)->name
))
5847 /* Check that the buffer info matches. */
5848 FOR_EACH_LIVE_BUFFER (tail
, buf
)
5850 /* Ignore buffers that aren't included in buffer lists. */
5851 if (SREF (BVAR (XBUFFER (buf
), name
), 0) == ' ')
5853 if (idx
== ASIZE (state
))
5855 if (!EQ (AREF (state
, idx
++), buf
))
5857 if (idx
== ASIZE (state
))
5859 if (!EQ (AREF (state
, idx
++), BVAR (XBUFFER (buf
), read_only
)))
5861 if (idx
== ASIZE (state
))
5863 if (!EQ (AREF (state
, idx
++), Fbuffer_modified_p (buf
)))
5866 if (idx
== ASIZE (state
))
5868 /* Detect deletion of a buffer at the end of the list. */
5869 if (EQ (AREF (state
, idx
), Qlambda
))
5872 /* Come here if we decide the data has changed. */
5874 /* Count the size we will need.
5875 Start with 1 so there is room for at least one lambda at the end. */
5877 FOR_EACH_FRAME (tail
, frame
)
5879 FOR_EACH_LIVE_BUFFER (tail
, buf
)
5881 /* Reallocate the vector if data has grown to need it,
5882 or if it has shrunk a lot. */
5883 if (! VECTORP (state
)
5884 || n
> ASIZE (state
)
5885 || n
+ 20 < ASIZE (state
) / 2)
5886 /* Add 20 extra so we grow it less often. */
5888 state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
5889 if (! NILP (variable
))
5890 Fset (variable
, state
);
5892 frame_and_buffer_state
= state
;
5895 /* Record the new data in the (possibly reallocated) vector. */
5897 FOR_EACH_FRAME (tail
, frame
)
5899 ASET (state
, idx
, frame
);
5901 ASET (state
, idx
, XFRAME (frame
)->name
);
5904 FOR_EACH_LIVE_BUFFER (tail
, buf
)
5906 /* Ignore buffers that aren't included in buffer lists. */
5907 if (SREF (BVAR (XBUFFER (buf
), name
), 0) == ' ')
5909 ASET (state
, idx
, buf
);
5911 ASET (state
, idx
, BVAR (XBUFFER (buf
), read_only
));
5913 ASET (state
, idx
, Fbuffer_modified_p (buf
));
5916 /* Fill up the vector with lambdas (always at least one). */
5917 ASET (state
, idx
, Qlambda
);
5919 while (idx
< ASIZE (state
))
5921 ASET (state
, idx
, Qlambda
);
5924 /* Make sure we didn't overflow the vector. */
5925 eassert (idx
<= ASIZE (state
));
5931 /***********************************************************************
5933 ***********************************************************************/
5935 /* Initialization done when Emacs fork is started, before doing stty.
5936 Determine terminal type and set terminal_driver. Then invoke its
5937 decoding routine to set up variables in the terminal package. */
5942 char *terminal_type
;
5944 /* Construct the space glyph. */
5945 space_glyph
.type
= CHAR_GLYPH
;
5946 SET_CHAR_GLYPH (space_glyph
, ' ', DEFAULT_FACE_ID
, 0);
5947 space_glyph
.charpos
= -1;
5950 cursor_in_echo_area
= 0;
5952 /* Now is the time to initialize this; it's used by init_sys_modes
5954 Vinitial_window_system
= Qnil
;
5956 /* SIGWINCH needs to be handled no matter what display we start
5957 with. Otherwise newly opened tty frames will not resize
5962 #endif /* CANNOT_DUMP */
5964 struct sigaction action
;
5965 emacs_sigaction_init (&action
, deliver_window_change_signal
);
5966 sigaction (SIGWINCH
, &action
, 0);
5968 #endif /* SIGWINCH */
5970 /* If running as a daemon, no need to initialize any frames/terminal. */
5974 /* If the user wants to use a window system, we shouldn't bother
5975 initializing the terminal. This is especially important when the
5976 terminal is so dumb that emacs gives up before and doesn't bother
5977 using the window system.
5979 If the DISPLAY environment variable is set and nonempty,
5980 try to use X, and die with an error message if that doesn't work. */
5982 #ifdef HAVE_X_WINDOWS
5983 if (! inhibit_window_system
&& ! display_arg
)
5986 display
= getenv ("DISPLAY");
5987 display_arg
= (display
!= 0 && *display
!= 0);
5989 if (display_arg
&& !x_display_ok (display
))
5991 fprintf (stderr
, "Display %s unavailable, simulating -nw\n",
5993 inhibit_window_system
= 1;
5997 if (!inhibit_window_system
&& display_arg
)
5999 Vinitial_window_system
= Qx
;
6001 Vwindow_system_version
= make_number (11);
6004 /* In some versions of ncurses,
6005 tputs crashes if we have not called tgetent.
6007 { char b
[2044]; tgetent (b
, "xterm");}
6011 #endif /* HAVE_X_WINDOWS */
6014 if (!inhibit_window_system
)
6016 Vinitial_window_system
= Qw32
;
6017 Vwindow_system_version
= make_number (1);
6020 #endif /* HAVE_NTGUI */
6023 if (!inhibit_window_system
6029 Vinitial_window_system
= Qns
;
6030 Vwindow_system_version
= make_number (10);
6035 /* If no window system has been specified, try to use the terminal. */
6037 fatal ("standard input is not a tty");
6040 terminal_type
= "w32console";
6042 terminal_type
= getenv ("TERM");
6046 #ifdef HAVE_WINDOW_SYSTEM
6047 if (! inhibit_window_system
)
6048 fprintf (stderr
, "Please set the environment variable DISPLAY or TERM (see `tset').\n");
6050 #endif /* HAVE_WINDOW_SYSTEM */
6051 fprintf (stderr
, "Please set the environment variable TERM; see `tset'.\n");
6057 struct frame
*f
= XFRAME (selected_frame
);
6059 init_foreground_group ();
6061 /* Open a display on the controlling tty. */
6062 t
= init_tty (0, terminal_type
, 1); /* Errors are fatal. */
6064 /* Convert the initial frame to use the new display. */
6065 if (f
->output_method
!= output_initial
)
6067 f
->output_method
= t
->type
;
6070 t
->reference_count
++;
6072 f
->output_data
.tty
->display_info
= &the_only_display_info
;
6074 if (f
->output_method
== output_termcap
)
6075 create_tty_output (f
);
6077 t
->display_info
.tty
->top_frame
= selected_frame
;
6078 change_frame_size (XFRAME (selected_frame
),
6079 FrameRows (t
->display_info
.tty
),
6080 FrameCols (t
->display_info
.tty
), 0, 0, 1);
6082 /* Delete the initial terminal. */
6083 if (--initial_terminal
->reference_count
== 0
6084 && initial_terminal
->delete_terminal_hook
)
6085 (*initial_terminal
->delete_terminal_hook
) (initial_terminal
);
6087 /* Update frame parameters to reflect the new type. */
6088 Fmodify_frame_parameters
6089 (selected_frame
, list1 (Fcons (Qtty_type
,
6090 Ftty_type (selected_frame
))));
6091 if (t
->display_info
.tty
->name
)
6092 Fmodify_frame_parameters
6094 list1 (Fcons (Qtty
, build_string (t
->display_info
.tty
->name
))));
6096 Fmodify_frame_parameters (selected_frame
, list1 (Fcons (Qtty
, Qnil
)));
6100 struct frame
*sf
= SELECTED_FRAME ();
6101 int width
= FRAME_TOTAL_COLS (sf
);
6102 int height
= FRAME_LINES (sf
);
6104 /* If these sizes are so big they cause overflow, just ignore the
6105 change. It's not clear what better we could do. The rest of
6106 the code assumes that (width + 2) * height * sizeof (struct glyph)
6107 does not overflow and does not exceed PTRDIFF_MAX or SIZE_MAX. */
6108 if (INT_ADD_RANGE_OVERFLOW (width
, 2, INT_MIN
, INT_MAX
)
6109 || INT_MULTIPLY_RANGE_OVERFLOW (width
+ 2, height
, INT_MIN
, INT_MAX
)
6110 || (min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof (struct glyph
)
6111 < (width
+ 2) * height
))
6112 fatal ("screen size %dx%d too big", width
, height
);
6115 calculate_costs (XFRAME (selected_frame
));
6117 /* Set up faces of the initial terminal frame of a dumped Emacs. */
6120 && NILP (Vinitial_window_system
))
6122 /* For the initial frame, we don't have any way of knowing what
6123 are the foreground and background colors of the terminal. */
6124 struct frame
*sf
= SELECTED_FRAME ();
6126 FRAME_FOREGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_FG_COLOR
;
6127 FRAME_BACKGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_BG_COLOR
;
6128 call0 (intern ("tty-set-up-initial-frame-faces"));
6134 /***********************************************************************
6136 ***********************************************************************/
6138 DEFUN ("internal-show-cursor", Finternal_show_cursor
,
6139 Sinternal_show_cursor
, 2, 2, 0,
6140 doc
: /* Set the cursor-visibility flag of WINDOW to SHOW.
6141 WINDOW nil means use the selected window. SHOW non-nil means
6142 show a cursor in WINDOW in the next redisplay. SHOW nil means
6143 don't show a cursor. */)
6144 (Lisp_Object window
, Lisp_Object show
)
6146 /* Don't change cursor state while redisplaying. This could confuse
6148 if (!redisplaying_p
)
6149 decode_any_window (window
)->cursor_off_p
= NILP (show
);
6154 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p
,
6155 Sinternal_show_cursor_p
, 0, 1, 0,
6156 doc
: /* Value is non-nil if next redisplay will display a cursor in WINDOW.
6157 WINDOW nil or omitted means report on the selected window. */)
6158 (Lisp_Object window
)
6160 return decode_any_window (window
)->cursor_off_p
? Qnil
: Qt
;
6163 /***********************************************************************
6165 ***********************************************************************/
6168 syms_of_display (void)
6170 defsubr (&Sredraw_frame
);
6171 defsubr (&Sredraw_display
);
6172 defsubr (&Sframe_or_buffer_changed_p
);
6173 defsubr (&Sopen_termscript
);
6175 defsubr (&Sredisplay
);
6176 defsubr (&Ssleep_for
);
6177 defsubr (&Ssend_string_to_terminal
);
6178 defsubr (&Sinternal_show_cursor
);
6179 defsubr (&Sinternal_show_cursor_p
);
6182 defsubr (&Sdump_redisplay_history
);
6185 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
6186 staticpro (&frame_and_buffer_state
);
6188 DEFSYM (Qdisplay_table
, "display-table");
6189 DEFSYM (Qredisplay_dont_pause
, "redisplay-dont-pause");
6191 DEFVAR_INT ("baud-rate", baud_rate
,
6192 doc
: /* The output baud rate of the terminal.
6193 On most systems, changing this value will affect the amount of padding
6194 and the other strategic decisions made during redisplay. */);
6196 DEFVAR_BOOL ("inverse-video", inverse_video
,
6197 doc
: /* Non-nil means invert the entire frame display.
6198 This means everything is in inverse video which otherwise would not be. */);
6200 DEFVAR_BOOL ("visible-bell", visible_bell
,
6201 doc
: /* Non-nil means try to flash the frame to represent a bell.
6203 See also `ring-bell-function'. */);
6205 DEFVAR_BOOL ("no-redraw-on-reenter", no_redraw_on_reenter
,
6206 doc
: /* Non-nil means no need to redraw entire frame after suspending.
6207 A non-nil value is useful if the terminal can automatically preserve
6208 Emacs's frame display when you reenter Emacs.
6209 It is up to you to set this variable if your terminal can do that. */);
6211 DEFVAR_LISP ("initial-window-system", Vinitial_window_system
,
6212 doc
: /* Name of the window system that Emacs uses for the first frame.
6213 The value is a symbol:
6214 nil for a termcap frame (a character-only terminal),
6215 'x' for an Emacs frame that is really an X window,
6216 'w32' for an Emacs frame that is a window on MS-Windows display,
6217 'ns' for an Emacs frame on a GNUstep or Macintosh Cocoa display,
6218 'pc' for a direct-write MS-DOS frame.
6220 Use of this variable as a boolean is deprecated. Instead,
6221 use `display-graphic-p' or any of the other `display-*-p'
6222 predicates which report frame's specific UI-related capabilities. */);
6224 DEFVAR_KBOARD ("window-system", Vwindow_system
,
6225 doc
: /* Name of window system through which the selected frame is displayed.
6226 The value is a symbol:
6227 nil for a termcap frame (a character-only terminal),
6228 'x' for an Emacs frame that is really an X window,
6229 'w32' for an Emacs frame that is a window on MS-Windows display,
6230 'ns' for an Emacs frame on a GNUstep or Macintosh Cocoa display,
6231 'pc' for a direct-write MS-DOS frame.
6233 Use of this variable as a boolean is deprecated. Instead,
6234 use `display-graphic-p' or any of the other `display-*-p'
6235 predicates which report frame's specific UI-related capabilities. */);
6237 DEFVAR_LISP ("window-system-version", Vwindow_system_version
,
6238 doc
: /* The version number of the window system in use.
6239 For X windows, this is 11. */);
6241 DEFVAR_BOOL ("cursor-in-echo-area", cursor_in_echo_area
,
6242 doc
: /* Non-nil means put cursor in minibuffer, at end of any message there. */);
6244 DEFVAR_LISP ("glyph-table", Vglyph_table
,
6245 doc
: /* Table defining how to output a glyph code to the frame.
6246 If not nil, this is a vector indexed by glyph code to define the glyph.
6247 Each element can be:
6248 integer: a glyph code which this glyph is an alias for.
6249 string: output this glyph using that string (not impl. in X windows).
6250 nil: this glyph mod 524288 is the code of a character to output,
6251 and this glyph / 524288 is the face number (see `face-id') to use
6252 while outputting it. */);
6253 Vglyph_table
= Qnil
;
6255 DEFVAR_LISP ("standard-display-table", Vstandard_display_table
,
6256 doc
: /* Display table to use for buffers that specify none.
6257 See `buffer-display-table' for more information. */);
6258 Vstandard_display_table
= Qnil
;
6260 DEFVAR_BOOL ("redisplay-dont-pause", redisplay_dont_pause
,
6261 doc
: /* Non-nil means display update isn't paused when input is detected. */);
6262 redisplay_dont_pause
= 1;
6268 Vinitial_window_system
= Qnil
;
6269 Vwindow_system_version
= Qnil
;