Update CC Mode version to 5.32.3.
[emacs.git] / src / dispnew.c
blobb313852efe286967f6ae8946bbb41945a60b423d
1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985-1988, 1993-1995, 1997-2012 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
19 #include <config.h>
20 #include <signal.h>
21 #include <stdio.h>
22 #include <ctype.h>
23 #include <setjmp.h>
24 #include <unistd.h>
26 #include "lisp.h"
27 #include "termchar.h"
28 #include "termopts.h"
29 /* cm.h must come after dispextern.h on Windows. */
30 #include "dispextern.h"
31 #include "cm.h"
32 #include "buffer.h"
33 #include "character.h"
34 #include "keyboard.h"
35 #include "frame.h"
36 #include "termhooks.h"
37 #include "window.h"
38 #include "commands.h"
39 #include "disptab.h"
40 #include "indent.h"
41 #include "intervals.h"
42 #include "blockinput.h"
43 #include "process.h"
45 #include "syssignal.h"
47 #ifdef HAVE_X_WINDOWS
48 #include "xterm.h"
49 #endif /* HAVE_X_WINDOWS */
51 #ifdef HAVE_NTGUI
52 #include "w32term.h"
53 #endif /* HAVE_NTGUI */
55 #ifdef HAVE_NS
56 #include "nsterm.h"
57 #endif
59 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
61 #include "systime.h"
62 #include <errno.h>
64 /* Get number of chars of output now in the buffer of a stdio stream.
65 This ought to be built in stdio, but it isn't. Some s- files
66 override this because their stdio internals differ. */
68 #ifdef __GNU_LIBRARY__
70 /* The s- file might have overridden the definition with one that
71 works for the system's C library. But we are using the GNU C
72 library, so this is the right definition for every system. */
74 #ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT
75 #define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT
76 #else
77 #undef PENDING_OUTPUT_COUNT
78 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
79 #endif
80 #else /* not __GNU_LIBRARY__ */
81 #if !defined (PENDING_OUTPUT_COUNT) && HAVE_STDIO_EXT_H && HAVE___FPENDING
82 #include <stdio_ext.h>
83 #define PENDING_OUTPUT_COUNT(FILE) __fpending (FILE)
84 #endif
85 #ifndef PENDING_OUTPUT_COUNT
86 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
87 #endif
88 #endif /* not __GNU_LIBRARY__ */
90 #if defined (HAVE_TERM_H) && defined (GNU_LINUX) && defined (HAVE_LIBNCURSES)
91 #include <term.h> /* for tgetent */
92 #endif
94 /* Structure to pass dimensions around. Used for character bounding
95 boxes, glyph matrix dimensions and alike. */
97 struct dim
99 int width;
100 int height;
104 /* Function prototypes. */
106 static void update_frame_line (struct frame *, int);
107 static int required_matrix_height (struct window *);
108 static int required_matrix_width (struct window *);
109 static void adjust_frame_glyphs (struct frame *);
110 static void change_frame_size_1 (struct frame *, int, int, int, int, int);
111 static void increment_row_positions (struct glyph_row *, EMACS_INT, EMACS_INT);
112 static void fill_up_frame_row_with_spaces (struct glyph_row *, int);
113 static void build_frame_matrix_from_window_tree (struct glyph_matrix *,
114 struct window *);
115 static void build_frame_matrix_from_leaf_window (struct glyph_matrix *,
116 struct window *);
117 static void adjust_frame_message_buffer (struct frame *);
118 static void adjust_decode_mode_spec_buffer (struct frame *);
119 static void fill_up_glyph_row_with_spaces (struct glyph_row *);
120 static void clear_window_matrices (struct window *, int);
121 static void fill_up_glyph_row_area_with_spaces (struct glyph_row *, int);
122 static int scrolling_window (struct window *, int);
123 static int update_window_line (struct window *, int, int *);
124 static void mirror_make_current (struct window *, int);
125 #if GLYPH_DEBUG
126 static void check_matrix_pointers (struct glyph_matrix *,
127 struct glyph_matrix *);
128 #endif
129 static void mirror_line_dance (struct window *, int, int, int *, char *);
130 static int update_window_tree (struct window *, int);
131 static int update_window (struct window *, int);
132 static int update_frame_1 (struct frame *, int, int);
133 static int scrolling (struct frame *);
134 static void set_window_cursor_after_update (struct window *);
135 static void adjust_frame_glyphs_for_window_redisplay (struct frame *);
136 static void adjust_frame_glyphs_for_frame_redisplay (struct frame *);
139 /* Define PERIODIC_PREEMPTION_CHECKING to 1, if micro-second timers
140 are supported, so we can check for input during redisplay at
141 regular intervals. */
142 #ifdef EMACS_HAS_USECS
143 #define PERIODIC_PREEMPTION_CHECKING 1
144 #else
145 #define PERIODIC_PREEMPTION_CHECKING 0
146 #endif
148 #if PERIODIC_PREEMPTION_CHECKING
150 /* Redisplay preemption timers. */
152 static EMACS_TIME preemption_period;
153 static EMACS_TIME preemption_next_check;
155 #endif
157 /* Nonzero upon entry to redisplay means do not assume anything about
158 current contents of actual terminal frame; clear and redraw it. */
160 int frame_garbaged;
162 /* Nonzero means last display completed. Zero means it was preempted. */
164 int display_completed;
166 Lisp_Object Qdisplay_table, Qredisplay_dont_pause;
169 /* The currently selected frame. In a single-frame version, this
170 variable always equals the_only_frame. */
172 Lisp_Object selected_frame;
174 /* A frame which is not just a mini-buffer, or 0 if there are no such
175 frames. This is usually the most recent such frame that was
176 selected. In a single-frame version, this variable always holds
177 the address of the_only_frame. */
179 struct frame *last_nonminibuf_frame;
181 /* 1 means SIGWINCH happened when not safe. */
183 static int delayed_size_change;
185 /* 1 means glyph initialization has been completed at startup. */
187 static int glyphs_initialized_initially_p;
189 /* Updated window if != 0. Set by update_window. */
191 struct window *updated_window;
193 /* Glyph row updated in update_window_line, and area that is updated. */
195 struct glyph_row *updated_row;
196 int updated_area;
198 /* A glyph for a space. */
200 struct glyph space_glyph;
202 /* Counts of allocated structures. These counts serve to diagnose
203 memory leaks and double frees. */
205 static int glyph_matrix_count;
206 static int glyph_pool_count;
208 /* If non-null, the frame whose frame matrices are manipulated. If
209 null, window matrices are worked on. */
211 static struct frame *frame_matrix_frame;
213 /* Non-zero means that fonts have been loaded since the last glyph
214 matrix adjustments. Redisplay must stop, and glyph matrices must
215 be adjusted when this flag becomes non-zero during display. The
216 reason fonts can be loaded so late is that fonts of fontsets are
217 loaded on demand. Another reason is that a line contains many
218 characters displayed by zero width or very narrow glyphs of
219 variable-width fonts. */
221 int fonts_changed_p;
223 /* Convert vpos and hpos from frame to window and vice versa.
224 This may only be used for terminal frames. */
226 #if GLYPH_DEBUG
228 static int window_to_frame_vpos (struct window *, int);
229 static int window_to_frame_hpos (struct window *, int);
230 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
231 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
233 /* One element of the ring buffer containing redisplay history
234 information. */
236 struct redisplay_history
238 char trace[512 + 100];
241 /* The size of the history buffer. */
243 #define REDISPLAY_HISTORY_SIZE 30
245 /* The redisplay history buffer. */
247 static struct redisplay_history redisplay_history[REDISPLAY_HISTORY_SIZE];
249 /* Next free entry in redisplay_history. */
251 static int history_idx;
253 /* A tick that's incremented each time something is added to the
254 history. */
256 static uprintmax_t history_tick;
258 static void add_frame_display_history (struct frame *, int);
260 /* Add to the redisplay history how window W has been displayed.
261 MSG is a trace containing the information how W's glyph matrix
262 has been constructed. PAUSED_P non-zero means that the update
263 has been interrupted for pending input. */
265 static void
266 add_window_display_history (struct window *w, const char *msg, int paused_p)
268 char *buf;
270 if (history_idx >= REDISPLAY_HISTORY_SIZE)
271 history_idx = 0;
272 buf = redisplay_history[history_idx].trace;
273 ++history_idx;
275 snprintf (buf, sizeof redisplay_history[0].trace,
276 "%"pMu": window %p (`%s')%s\n%s",
277 history_tick++,
279 ((BUFFERP (w->buffer)
280 && STRINGP (BVAR (XBUFFER (w->buffer), name)))
281 ? SSDATA (BVAR (XBUFFER (w->buffer), name))
282 : "???"),
283 paused_p ? " ***paused***" : "",
284 msg);
288 /* Add to the redisplay history that frame F has been displayed.
289 PAUSED_P non-zero means that the update has been interrupted for
290 pending input. */
292 static void
293 add_frame_display_history (struct frame *f, int paused_p)
295 char *buf;
297 if (history_idx >= REDISPLAY_HISTORY_SIZE)
298 history_idx = 0;
299 buf = redisplay_history[history_idx].trace;
300 ++history_idx;
302 sprintf (buf, "%"pMu": update frame %p%s",
303 history_tick++,
304 f, paused_p ? " ***paused***" : "");
308 DEFUN ("dump-redisplay-history", Fdump_redisplay_history,
309 Sdump_redisplay_history, 0, 0, "",
310 doc: /* Dump redisplay history to stderr. */)
311 (void)
313 int i;
315 for (i = history_idx - 1; i != history_idx; --i)
317 if (i < 0)
318 i = REDISPLAY_HISTORY_SIZE - 1;
319 fprintf (stderr, "%s\n", redisplay_history[i].trace);
322 return Qnil;
326 #else /* GLYPH_DEBUG == 0 */
328 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + WINDOW_TOP_EDGE_LINE (W))
329 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + WINDOW_LEFT_EDGE_COL (W))
331 #endif /* GLYPH_DEBUG == 0 */
334 #if defined PROFILING && !HAVE___EXECUTABLE_START
335 /* FIXME: only used to find text start for profiling. */
337 void
338 safe_bcopy (const char *from, char *to, int size)
340 abort ();
342 #endif
344 /***********************************************************************
345 Glyph Matrices
346 ***********************************************************************/
348 /* Allocate and return a glyph_matrix structure. POOL is the glyph
349 pool from which memory for the matrix should be allocated, or null
350 for window-based redisplay where no glyph pools are used. The
351 member `pool' of the glyph matrix structure returned is set to
352 POOL, the structure is otherwise zeroed. */
354 static struct glyph_matrix *
355 new_glyph_matrix (struct glyph_pool *pool)
357 struct glyph_matrix *result;
359 /* Allocate and clear. */
360 result = (struct glyph_matrix *) xmalloc (sizeof *result);
361 memset (result, 0, sizeof *result);
363 /* Increment number of allocated matrices. This count is used
364 to detect memory leaks. */
365 ++glyph_matrix_count;
367 /* Set pool and return. */
368 result->pool = pool;
369 return result;
373 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
375 The global counter glyph_matrix_count is decremented when a matrix
376 is freed. If the count gets negative, more structures were freed
377 than allocated, i.e. one matrix was freed more than once or a bogus
378 pointer was passed to this function.
380 If MATRIX->pool is null, this means that the matrix manages its own
381 glyph memory---this is done for matrices on X frames. Freeing the
382 matrix also frees the glyph memory in this case. */
384 static void
385 free_glyph_matrix (struct glyph_matrix *matrix)
387 if (matrix)
389 int i;
391 /* Detect the case that more matrices are freed than were
392 allocated. */
393 if (--glyph_matrix_count < 0)
394 abort ();
396 /* Free glyph memory if MATRIX owns it. */
397 if (matrix->pool == NULL)
398 for (i = 0; i < matrix->rows_allocated; ++i)
399 xfree (matrix->rows[i].glyphs[LEFT_MARGIN_AREA]);
401 /* Free row structures and the matrix itself. */
402 xfree (matrix->rows);
403 xfree (matrix);
408 /* Return the number of glyphs to reserve for a marginal area of
409 window W. TOTAL_GLYPHS is the number of glyphs in a complete
410 display line of window W. MARGIN gives the width of the marginal
411 area in canonical character units. MARGIN should be an integer
412 or a float. */
414 static int
415 margin_glyphs_to_reserve (struct window *w, int total_glyphs, Lisp_Object margin)
417 int n;
419 if (NUMBERP (margin))
421 int width = XFASTINT (w->total_cols);
422 double d = max (0, XFLOATINT (margin));
423 d = min (width / 2 - 1, d);
424 n = (int) ((double) total_glyphs / width * d);
426 else
427 n = 0;
429 return n;
432 #if XASSERTS
433 /* Return non-zero if ROW's hash value is correct, zero if not. */
435 verify_row_hash (struct glyph_row *row)
437 return row->hash == row_hash (row);
439 #endif
441 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
442 window sizes.
444 W is null if the function is called for a frame glyph matrix.
445 Otherwise it is the window MATRIX is a member of. X and Y are the
446 indices of the first column and row of MATRIX within the frame
447 matrix, if such a matrix exists. They are zero for purely
448 window-based redisplay. DIM is the needed size of the matrix.
450 In window-based redisplay, where no frame matrices exist, glyph
451 matrices manage their own glyph storage. Otherwise, they allocate
452 storage from a common frame glyph pool which can be found in
453 MATRIX->pool.
455 The reason for this memory management strategy is to avoid complete
456 frame redraws if possible. When we allocate from a common pool, a
457 change of the location or size of a sub-matrix within the pool
458 requires a complete redisplay of the frame because we cannot easily
459 make sure that the current matrices of all windows still agree with
460 what is displayed on the screen. While this is usually fast, it
461 leads to screen flickering. */
463 static void
464 adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y, struct dim dim)
466 int i;
467 int new_rows;
468 int marginal_areas_changed_p = 0;
469 int header_line_changed_p = 0;
470 int header_line_p = 0;
471 int left = -1, right = -1;
472 int window_width = -1, window_height = -1;
474 /* See if W had a header line that has disappeared now, or vice versa.
475 Get W's size. */
476 if (w)
478 window_box (w, -1, 0, 0, &window_width, &window_height);
480 header_line_p = WINDOW_WANTS_HEADER_LINE_P (w);
481 header_line_changed_p = header_line_p != matrix->header_line_p;
483 matrix->header_line_p = header_line_p;
485 /* If POOL is null, MATRIX is a window matrix for window-based redisplay.
486 Do nothing if MATRIX' size, position, vscroll, and marginal areas
487 haven't changed. This optimization is important because preserving
488 the matrix means preventing redisplay. */
489 if (matrix->pool == NULL)
491 left = margin_glyphs_to_reserve (w, dim.width, w->left_margin_cols);
492 right = margin_glyphs_to_reserve (w, dim.width, w->right_margin_cols);
493 xassert (left >= 0 && right >= 0);
494 marginal_areas_changed_p = (left != matrix->left_margin_glyphs
495 || right != matrix->right_margin_glyphs);
497 if (!marginal_areas_changed_p
498 && !fonts_changed_p
499 && !header_line_changed_p
500 && matrix->window_left_col == WINDOW_LEFT_EDGE_COL (w)
501 && matrix->window_top_line == WINDOW_TOP_EDGE_LINE (w)
502 && matrix->window_height == window_height
503 && matrix->window_vscroll == w->vscroll
504 && matrix->window_width == window_width)
505 return;
508 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
509 if (matrix->rows_allocated < dim.height)
511 int old_alloc = matrix->rows_allocated;
512 new_rows = dim.height - matrix->rows_allocated;
513 matrix->rows = xpalloc (matrix->rows, &matrix->rows_allocated,
514 new_rows, INT_MAX, sizeof *matrix->rows);
515 memset (matrix->rows + old_alloc, 0,
516 (matrix->rows_allocated - old_alloc) * sizeof *matrix->rows);
518 else
519 new_rows = 0;
521 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
522 on a frame not using window-based redisplay. Set up pointers for
523 each row into the glyph pool. */
524 if (matrix->pool)
526 xassert (matrix->pool->glyphs);
528 if (w)
530 left = margin_glyphs_to_reserve (w, dim.width,
531 w->left_margin_cols);
532 right = margin_glyphs_to_reserve (w, dim.width,
533 w->right_margin_cols);
535 else
536 left = right = 0;
538 for (i = 0; i < dim.height; ++i)
540 struct glyph_row *row = &matrix->rows[i];
542 row->glyphs[LEFT_MARGIN_AREA]
543 = (matrix->pool->glyphs
544 + (y + i) * matrix->pool->ncolumns
545 + x);
547 if (w == NULL
548 || row == matrix->rows + dim.height - 1
549 || (row == matrix->rows && matrix->header_line_p))
551 row->glyphs[TEXT_AREA]
552 = row->glyphs[LEFT_MARGIN_AREA];
553 row->glyphs[RIGHT_MARGIN_AREA]
554 = row->glyphs[TEXT_AREA] + dim.width;
555 row->glyphs[LAST_AREA]
556 = row->glyphs[RIGHT_MARGIN_AREA];
558 else
560 row->glyphs[TEXT_AREA]
561 = row->glyphs[LEFT_MARGIN_AREA] + left;
562 row->glyphs[RIGHT_MARGIN_AREA]
563 = row->glyphs[TEXT_AREA] + dim.width - left - right;
564 row->glyphs[LAST_AREA]
565 = row->glyphs[LEFT_MARGIN_AREA] + dim.width;
569 matrix->left_margin_glyphs = left;
570 matrix->right_margin_glyphs = right;
572 else
574 /* If MATRIX->pool is null, MATRIX is responsible for managing
575 its own memory. It is a window matrix for window-based redisplay.
576 Allocate glyph memory from the heap. */
577 if (dim.width > matrix->matrix_w
578 || new_rows
579 || header_line_changed_p
580 || marginal_areas_changed_p)
582 struct glyph_row *row = matrix->rows;
583 struct glyph_row *end = row + matrix->rows_allocated;
585 while (row < end)
587 row->glyphs[LEFT_MARGIN_AREA]
588 = xnrealloc (row->glyphs[LEFT_MARGIN_AREA],
589 dim.width, sizeof (struct glyph));
591 /* The mode line never has marginal areas. */
592 if (row == matrix->rows + dim.height - 1
593 || (row == matrix->rows && matrix->header_line_p))
595 row->glyphs[TEXT_AREA]
596 = row->glyphs[LEFT_MARGIN_AREA];
597 row->glyphs[RIGHT_MARGIN_AREA]
598 = row->glyphs[TEXT_AREA] + dim.width;
599 row->glyphs[LAST_AREA]
600 = row->glyphs[RIGHT_MARGIN_AREA];
602 else
604 row->glyphs[TEXT_AREA]
605 = row->glyphs[LEFT_MARGIN_AREA] + left;
606 row->glyphs[RIGHT_MARGIN_AREA]
607 = row->glyphs[TEXT_AREA] + dim.width - left - right;
608 row->glyphs[LAST_AREA]
609 = row->glyphs[LEFT_MARGIN_AREA] + dim.width;
611 ++row;
615 xassert (left >= 0 && right >= 0);
616 matrix->left_margin_glyphs = left;
617 matrix->right_margin_glyphs = right;
620 /* Number of rows to be used by MATRIX. */
621 matrix->nrows = dim.height;
622 xassert (matrix->nrows >= 0);
624 if (w)
626 if (matrix == w->current_matrix)
628 /* Mark rows in a current matrix of a window as not having
629 valid contents. It's important to not do this for
630 desired matrices. When Emacs starts, it may already be
631 building desired matrices when this function runs. */
632 if (window_width < 0)
633 window_width = window_box_width (w, -1);
635 /* Optimize the case that only the height has changed (C-x 2,
636 upper window). Invalidate all rows that are no longer part
637 of the window. */
638 if (!marginal_areas_changed_p
639 && !header_line_changed_p
640 && new_rows == 0
641 && dim.width == matrix->matrix_w
642 && matrix->window_left_col == WINDOW_LEFT_EDGE_COL (w)
643 && matrix->window_top_line == WINDOW_TOP_EDGE_LINE (w)
644 && matrix->window_width == window_width)
646 /* Find the last row in the window. */
647 for (i = 0; i < matrix->nrows && matrix->rows[i].enabled_p; ++i)
648 if (MATRIX_ROW_BOTTOM_Y (matrix->rows + i) >= window_height)
650 ++i;
651 break;
654 /* Window end is invalid, if inside of the rows that
655 are invalidated below. */
656 if (INTEGERP (w->window_end_vpos)
657 && XFASTINT (w->window_end_vpos) >= i)
658 w->window_end_valid = Qnil;
660 while (i < matrix->nrows)
661 matrix->rows[i++].enabled_p = 0;
663 else
665 for (i = 0; i < matrix->nrows; ++i)
666 matrix->rows[i].enabled_p = 0;
669 else if (matrix == w->desired_matrix)
671 /* Rows in desired matrices always have to be cleared;
672 redisplay expects this is the case when it runs, so it
673 had better be the case when we adjust matrices between
674 redisplays. */
675 for (i = 0; i < matrix->nrows; ++i)
676 matrix->rows[i].enabled_p = 0;
681 /* Remember last values to be able to optimize frame redraws. */
682 matrix->matrix_x = x;
683 matrix->matrix_y = y;
684 matrix->matrix_w = dim.width;
685 matrix->matrix_h = dim.height;
687 /* Record the top y location and height of W at the time the matrix
688 was last adjusted. This is used to optimize redisplay above. */
689 if (w)
691 matrix->window_left_col = WINDOW_LEFT_EDGE_COL (w);
692 matrix->window_top_line = WINDOW_TOP_EDGE_LINE (w);
693 matrix->window_height = window_height;
694 matrix->window_width = window_width;
695 matrix->window_vscroll = w->vscroll;
700 /* Reverse the contents of rows in MATRIX between START and END. The
701 contents of the row at END - 1 end up at START, END - 2 at START +
702 1 etc. This is part of the implementation of rotate_matrix (see
703 below). */
705 static void
706 reverse_rows (struct glyph_matrix *matrix, int start, int end)
708 int i, j;
710 for (i = start, j = end - 1; i < j; ++i, --j)
712 /* Non-ISO HP/UX compiler doesn't like auto struct
713 initialization. */
714 struct glyph_row temp;
715 temp = matrix->rows[i];
716 matrix->rows[i] = matrix->rows[j];
717 matrix->rows[j] = temp;
722 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
723 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
724 indices. (Note: this does not copy glyphs, only glyph pointers in
725 row structures are moved around).
727 The algorithm used for rotating the vector was, I believe, first
728 described by Kernighan. See the vector R as consisting of two
729 sub-vectors AB, where A has length BY for BY >= 0. The result
730 after rotating is then BA. Reverse both sub-vectors to get ArBr
731 and reverse the result to get (ArBr)r which is BA. Similar for
732 rotating right. */
734 void
735 rotate_matrix (struct glyph_matrix *matrix, int first, int last, int by)
737 if (by < 0)
739 /* Up (rotate left, i.e. towards lower indices). */
740 by = -by;
741 reverse_rows (matrix, first, first + by);
742 reverse_rows (matrix, first + by, last);
743 reverse_rows (matrix, first, last);
745 else if (by > 0)
747 /* Down (rotate right, i.e. towards higher indices). */
748 reverse_rows (matrix, last - by, last);
749 reverse_rows (matrix, first, last - by);
750 reverse_rows (matrix, first, last);
755 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
756 with indices START <= index < END. Increment positions by DELTA/
757 DELTA_BYTES. */
759 void
760 increment_matrix_positions (struct glyph_matrix *matrix, int start, int end,
761 EMACS_INT delta, EMACS_INT delta_bytes)
763 /* Check that START and END are reasonable values. */
764 xassert (start >= 0 && start <= matrix->nrows);
765 xassert (end >= 0 && end <= matrix->nrows);
766 xassert (start <= end);
768 for (; start < end; ++start)
769 increment_row_positions (matrix->rows + start, delta, delta_bytes);
773 /* Enable a range of rows in glyph matrix MATRIX. START and END are
774 the row indices of the first and last + 1 row to enable. If
775 ENABLED_P is non-zero, enabled_p flags in rows will be set to 1. */
777 void
778 enable_glyph_matrix_rows (struct glyph_matrix *matrix, int start, int end, int enabled_p)
780 xassert (start <= end);
781 xassert (start >= 0 && start < matrix->nrows);
782 xassert (end >= 0 && end <= matrix->nrows);
784 for (; start < end; ++start)
785 matrix->rows[start].enabled_p = enabled_p != 0;
789 /* Clear MATRIX.
791 This empties all rows in MATRIX by setting the enabled_p flag for
792 all rows of the matrix to zero. The function prepare_desired_row
793 will eventually really clear a row when it sees one with a zero
794 enabled_p flag.
796 Resets update hints to defaults value. The only update hint
797 currently present is the flag MATRIX->no_scrolling_p. */
799 void
800 clear_glyph_matrix (struct glyph_matrix *matrix)
802 if (matrix)
804 enable_glyph_matrix_rows (matrix, 0, matrix->nrows, 0);
805 matrix->no_scrolling_p = 0;
810 /* Shift part of the glyph matrix MATRIX of window W up or down.
811 Increment y-positions in glyph rows between START and END by DY,
812 and recompute their visible height. */
814 void
815 shift_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int start, int end, int dy)
817 int min_y, max_y;
819 xassert (start <= end);
820 xassert (start >= 0 && start < matrix->nrows);
821 xassert (end >= 0 && end <= matrix->nrows);
823 min_y = WINDOW_HEADER_LINE_HEIGHT (w);
824 max_y = WINDOW_BOX_HEIGHT_NO_MODE_LINE (w);
826 for (; start < end; ++start)
828 struct glyph_row *row = &matrix->rows[start];
830 row->y += dy;
831 row->visible_height = row->height;
833 if (row->y < min_y)
834 row->visible_height -= min_y - row->y;
835 if (row->y + row->height > max_y)
836 row->visible_height -= row->y + row->height - max_y;
837 if (row->fringe_bitmap_periodic_p)
838 row->redraw_fringe_bitmaps_p = 1;
843 /* Mark all rows in current matrices of frame F as invalid. Marking
844 invalid is done by setting enabled_p to zero for all rows in a
845 current matrix. */
847 void
848 clear_current_matrices (register struct frame *f)
850 /* Clear frame current matrix, if we have one. */
851 if (f->current_matrix)
852 clear_glyph_matrix (f->current_matrix);
854 /* Clear the matrix of the menu bar window, if such a window exists.
855 The menu bar window is currently used to display menus on X when
856 no toolkit support is compiled in. */
857 if (WINDOWP (f->menu_bar_window))
858 clear_glyph_matrix (XWINDOW (f->menu_bar_window)->current_matrix);
860 /* Clear the matrix of the tool-bar window, if any. */
861 if (WINDOWP (f->tool_bar_window))
862 clear_glyph_matrix (XWINDOW (f->tool_bar_window)->current_matrix);
864 /* Clear current window matrices. */
865 xassert (WINDOWP (FRAME_ROOT_WINDOW (f)));
866 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f)), 0);
870 /* Clear out all display lines of F for a coming redisplay. */
872 void
873 clear_desired_matrices (register struct frame *f)
875 if (f->desired_matrix)
876 clear_glyph_matrix (f->desired_matrix);
878 if (WINDOWP (f->menu_bar_window))
879 clear_glyph_matrix (XWINDOW (f->menu_bar_window)->desired_matrix);
881 if (WINDOWP (f->tool_bar_window))
882 clear_glyph_matrix (XWINDOW (f->tool_bar_window)->desired_matrix);
884 /* Do it for window matrices. */
885 xassert (WINDOWP (FRAME_ROOT_WINDOW (f)));
886 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f)), 1);
890 /* Clear matrices in window tree rooted in W. If DESIRED_P is
891 non-zero clear desired matrices, otherwise clear current matrices. */
893 static void
894 clear_window_matrices (struct window *w, int desired_p)
896 while (w)
898 if (!NILP (w->hchild))
900 xassert (WINDOWP (w->hchild));
901 clear_window_matrices (XWINDOW (w->hchild), desired_p);
903 else if (!NILP (w->vchild))
905 xassert (WINDOWP (w->vchild));
906 clear_window_matrices (XWINDOW (w->vchild), desired_p);
908 else
910 if (desired_p)
911 clear_glyph_matrix (w->desired_matrix);
912 else
914 clear_glyph_matrix (w->current_matrix);
915 w->window_end_valid = Qnil;
919 w = NILP (w->next) ? 0 : XWINDOW (w->next);
925 /***********************************************************************
926 Glyph Rows
928 See dispextern.h for an overall explanation of glyph rows.
929 ***********************************************************************/
931 /* Clear glyph row ROW. Do it in a way that makes it robust against
932 changes in the glyph_row structure, i.e. addition or removal of
933 structure members. */
935 static struct glyph_row null_row;
937 void
938 clear_glyph_row (struct glyph_row *row)
940 struct glyph *p[1 + LAST_AREA];
942 /* Save pointers. */
943 p[LEFT_MARGIN_AREA] = row->glyphs[LEFT_MARGIN_AREA];
944 p[TEXT_AREA] = row->glyphs[TEXT_AREA];
945 p[RIGHT_MARGIN_AREA] = row->glyphs[RIGHT_MARGIN_AREA];
946 p[LAST_AREA] = row->glyphs[LAST_AREA];
948 /* Clear. */
949 *row = null_row;
951 /* Restore pointers. */
952 row->glyphs[LEFT_MARGIN_AREA] = p[LEFT_MARGIN_AREA];
953 row->glyphs[TEXT_AREA] = p[TEXT_AREA];
954 row->glyphs[RIGHT_MARGIN_AREA] = p[RIGHT_MARGIN_AREA];
955 row->glyphs[LAST_AREA] = p[LAST_AREA];
957 #if 0 /* At some point, some bit-fields of struct glyph were not set,
958 which made glyphs unequal when compared with GLYPH_EQUAL_P.
959 Redisplay outputs such glyphs, and flickering effects were
960 the result. This also depended on the contents of memory
961 returned by xmalloc. If flickering happens again, activate
962 the code below. If the flickering is gone with that, chances
963 are that the flickering has the same reason as here. */
964 memset (p[0], 0, (char *) p[LAST_AREA] - (char *) p[0]);
965 #endif
969 /* Make ROW an empty, enabled row of canonical character height,
970 in window W starting at y-position Y. */
972 void
973 blank_row (struct window *w, struct glyph_row *row, int y)
975 int min_y, max_y;
977 min_y = WINDOW_HEADER_LINE_HEIGHT (w);
978 max_y = WINDOW_BOX_HEIGHT_NO_MODE_LINE (w);
980 clear_glyph_row (row);
981 row->y = y;
982 row->ascent = row->phys_ascent = 0;
983 row->height = row->phys_height = FRAME_LINE_HEIGHT (XFRAME (w->frame));
984 row->visible_height = row->height;
986 if (row->y < min_y)
987 row->visible_height -= min_y - row->y;
988 if (row->y + row->height > max_y)
989 row->visible_height -= row->y + row->height - max_y;
991 row->enabled_p = 1;
995 /* Increment buffer positions in glyph row ROW. DELTA and DELTA_BYTES
996 are the amounts by which to change positions. Note that the first
997 glyph of the text area of a row can have a buffer position even if
998 the used count of the text area is zero. Such rows display line
999 ends. */
1001 static void
1002 increment_row_positions (struct glyph_row *row,
1003 EMACS_INT delta, EMACS_INT delta_bytes)
1005 int area, i;
1007 /* Increment start and end positions. */
1008 MATRIX_ROW_START_CHARPOS (row) += delta;
1009 MATRIX_ROW_START_BYTEPOS (row) += delta_bytes;
1010 MATRIX_ROW_END_CHARPOS (row) += delta;
1011 MATRIX_ROW_END_BYTEPOS (row) += delta_bytes;
1012 CHARPOS (row->start.pos) += delta;
1013 BYTEPOS (row->start.pos) += delta_bytes;
1014 CHARPOS (row->end.pos) += delta;
1015 BYTEPOS (row->end.pos) += delta_bytes;
1017 if (!row->enabled_p)
1018 return;
1020 /* Increment positions in glyphs. */
1021 for (area = 0; area < LAST_AREA; ++area)
1022 for (i = 0; i < row->used[area]; ++i)
1023 if (BUFFERP (row->glyphs[area][i].object)
1024 && row->glyphs[area][i].charpos > 0)
1025 row->glyphs[area][i].charpos += delta;
1027 /* Capture the case of rows displaying a line end. */
1028 if (row->used[TEXT_AREA] == 0
1029 && MATRIX_ROW_DISPLAYS_TEXT_P (row))
1030 row->glyphs[TEXT_AREA]->charpos += delta;
1034 #if 0
1035 /* Swap glyphs between two glyph rows A and B. This exchanges glyph
1036 contents, i.e. glyph structure contents are exchanged between A and
1037 B without changing glyph pointers in A and B. */
1039 static void
1040 swap_glyphs_in_rows (struct glyph_row *a, struct glyph_row *b)
1042 int area;
1044 for (area = 0; area < LAST_AREA; ++area)
1046 /* Number of glyphs to swap. */
1047 int max_used = max (a->used[area], b->used[area]);
1049 /* Start of glyphs in area of row A. */
1050 struct glyph *glyph_a = a->glyphs[area];
1052 /* End + 1 of glyphs in area of row A. */
1053 struct glyph *glyph_a_end = a->glyphs[max_used];
1055 /* Start of glyphs in area of row B. */
1056 struct glyph *glyph_b = b->glyphs[area];
1058 while (glyph_a < glyph_a_end)
1060 /* Non-ISO HP/UX compiler doesn't like auto struct
1061 initialization. */
1062 struct glyph temp;
1063 temp = *glyph_a;
1064 *glyph_a = *glyph_b;
1065 *glyph_b = temp;
1066 ++glyph_a;
1067 ++glyph_b;
1072 #endif /* 0 */
1074 /* Exchange pointers to glyph memory between glyph rows A and B. Also
1075 exchange the used[] array and the hash values of the rows, because
1076 these should all go together for the row's hash value to be
1077 correct. */
1079 static inline void
1080 swap_glyph_pointers (struct glyph_row *a, struct glyph_row *b)
1082 int i;
1083 unsigned hash_tem = a->hash;
1085 for (i = 0; i < LAST_AREA + 1; ++i)
1087 struct glyph *temp = a->glyphs[i];
1089 a->glyphs[i] = b->glyphs[i];
1090 b->glyphs[i] = temp;
1091 if (i < LAST_AREA)
1093 short used_tem = a->used[i];
1095 a->used[i] = b->used[i];
1096 b->used[i] = used_tem;
1099 a->hash = b->hash;
1100 b->hash = hash_tem;
1104 /* Copy glyph row structure FROM to glyph row structure TO, except
1105 that glyph pointers, the `used' counts, and the hash values in the
1106 structures are left unchanged. */
1108 static inline void
1109 copy_row_except_pointers (struct glyph_row *to, struct glyph_row *from)
1111 struct glyph *pointers[1 + LAST_AREA];
1112 short used[LAST_AREA];
1113 unsigned hashval;
1115 /* Save glyph pointers of TO. */
1116 memcpy (pointers, to->glyphs, sizeof to->glyphs);
1117 memcpy (used, to->used, sizeof to->used);
1118 hashval = to->hash;
1120 /* Do a structure assignment. */
1121 *to = *from;
1123 /* Restore original pointers of TO. */
1124 memcpy (to->glyphs, pointers, sizeof to->glyphs);
1125 memcpy (to->used, used, sizeof to->used);
1126 to->hash = hashval;
1130 /* Assign glyph row FROM to glyph row TO. This works like a structure
1131 assignment TO = FROM, except that glyph pointers are not copied but
1132 exchanged between TO and FROM. Pointers must be exchanged to avoid
1133 a memory leak. */
1135 static inline void
1136 assign_row (struct glyph_row *to, struct glyph_row *from)
1138 swap_glyph_pointers (to, from);
1139 copy_row_except_pointers (to, from);
1143 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1144 a row in a window matrix, is a slice of the glyph memory of the
1145 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1146 is non-zero if the glyph memory of WINDOW_ROW is part of the glyph
1147 memory of FRAME_ROW. */
1149 #if GLYPH_DEBUG
1151 static int
1152 glyph_row_slice_p (struct glyph_row *window_row, struct glyph_row *frame_row)
1154 struct glyph *window_glyph_start = window_row->glyphs[0];
1155 struct glyph *frame_glyph_start = frame_row->glyphs[0];
1156 struct glyph *frame_glyph_end = frame_row->glyphs[LAST_AREA];
1158 return (frame_glyph_start <= window_glyph_start
1159 && window_glyph_start < frame_glyph_end);
1162 #endif /* GLYPH_DEBUG */
1164 #if 0
1166 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1167 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1168 in WINDOW_MATRIX is found satisfying the condition. */
1170 static struct glyph_row *
1171 find_glyph_row_slice (struct glyph_matrix *window_matrix,
1172 struct glyph_matrix *frame_matrix, int row)
1174 int i;
1176 xassert (row >= 0 && row < frame_matrix->nrows);
1178 for (i = 0; i < window_matrix->nrows; ++i)
1179 if (glyph_row_slice_p (window_matrix->rows + i,
1180 frame_matrix->rows + row))
1181 break;
1183 return i < window_matrix->nrows ? window_matrix->rows + i : 0;
1186 #endif /* 0 */
1188 /* Prepare ROW for display. Desired rows are cleared lazily,
1189 i.e. they are only marked as to be cleared by setting their
1190 enabled_p flag to zero. When a row is to be displayed, a prior
1191 call to this function really clears it. */
1193 void
1194 prepare_desired_row (struct glyph_row *row)
1196 if (!row->enabled_p)
1198 int rp = row->reversed_p;
1200 clear_glyph_row (row);
1201 row->enabled_p = 1;
1202 row->reversed_p = rp;
1207 /* Return a hash code for glyph row ROW. */
1209 static int
1210 line_hash_code (struct glyph_row *row)
1212 int hash = 0;
1214 if (row->enabled_p)
1216 struct glyph *glyph = row->glyphs[TEXT_AREA];
1217 struct glyph *end = glyph + row->used[TEXT_AREA];
1219 while (glyph < end)
1221 int c = glyph->u.ch;
1222 int face_id = glyph->face_id;
1223 if (FRAME_MUST_WRITE_SPACES (SELECTED_FRAME ())) /* XXX Is SELECTED_FRAME OK here? */
1224 c -= SPACEGLYPH;
1225 hash = (((hash << 4) + (hash >> 24)) & 0x0fffffff) + c;
1226 hash = (((hash << 4) + (hash >> 24)) & 0x0fffffff) + face_id;
1227 ++glyph;
1230 if (hash == 0)
1231 hash = 1;
1234 return hash;
1238 /* Return the cost of drawing line VPOS in MATRIX. The cost equals
1239 the number of characters in the line. If must_write_spaces is
1240 zero, leading and trailing spaces are ignored. */
1242 static int
1243 line_draw_cost (struct glyph_matrix *matrix, int vpos)
1245 struct glyph_row *row = matrix->rows + vpos;
1246 struct glyph *beg = row->glyphs[TEXT_AREA];
1247 struct glyph *end = beg + row->used[TEXT_AREA];
1248 int len;
1249 Lisp_Object *glyph_table_base = GLYPH_TABLE_BASE;
1250 ptrdiff_t glyph_table_len = GLYPH_TABLE_LENGTH;
1252 /* Ignore trailing and leading spaces if we can. */
1253 if (!FRAME_MUST_WRITE_SPACES (SELECTED_FRAME ())) /* XXX Is SELECTED_FRAME OK here? */
1255 /* Skip from the end over trailing spaces. */
1256 while (end > beg && CHAR_GLYPH_SPACE_P (*(end - 1)))
1257 --end;
1259 /* All blank line. */
1260 if (end == beg)
1261 return 0;
1263 /* Skip over leading spaces. */
1264 while (CHAR_GLYPH_SPACE_P (*beg))
1265 ++beg;
1268 /* If we don't have a glyph-table, each glyph is one character,
1269 so return the number of glyphs. */
1270 if (glyph_table_base == 0)
1271 len = end - beg;
1272 else
1274 /* Otherwise, scan the glyphs and accumulate their total length
1275 in LEN. */
1276 len = 0;
1277 while (beg < end)
1279 GLYPH g;
1281 SET_GLYPH_FROM_CHAR_GLYPH (g, *beg);
1283 if (GLYPH_INVALID_P (g)
1284 || GLYPH_SIMPLE_P (glyph_table_base, glyph_table_len, g))
1285 len += 1;
1286 else
1287 len += GLYPH_LENGTH (glyph_table_base, g);
1289 ++beg;
1293 return len;
1297 /* Test two glyph rows A and B for equality. Value is non-zero if A
1298 and B have equal contents. MOUSE_FACE_P non-zero means compare the
1299 mouse_face_p flags of A and B, too. */
1301 static inline int
1302 row_equal_p (struct glyph_row *a, struct glyph_row *b, int mouse_face_p)
1304 xassert (verify_row_hash (a));
1305 xassert (verify_row_hash (b));
1307 if (a == b)
1308 return 1;
1309 else if (a->hash != b->hash)
1310 return 0;
1311 else
1313 struct glyph *a_glyph, *b_glyph, *a_end;
1314 int area;
1316 if (mouse_face_p && a->mouse_face_p != b->mouse_face_p)
1317 return 0;
1319 /* Compare glyphs. */
1320 for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
1322 if (a->used[area] != b->used[area])
1323 return 0;
1325 a_glyph = a->glyphs[area];
1326 a_end = a_glyph + a->used[area];
1327 b_glyph = b->glyphs[area];
1329 while (a_glyph < a_end
1330 && GLYPH_EQUAL_P (a_glyph, b_glyph))
1331 ++a_glyph, ++b_glyph;
1333 if (a_glyph != a_end)
1334 return 0;
1337 if (a->fill_line_p != b->fill_line_p
1338 || a->cursor_in_fringe_p != b->cursor_in_fringe_p
1339 || a->left_fringe_bitmap != b->left_fringe_bitmap
1340 || a->left_fringe_face_id != b->left_fringe_face_id
1341 || a->left_fringe_offset != b->left_fringe_offset
1342 || a->right_fringe_bitmap != b->right_fringe_bitmap
1343 || a->right_fringe_face_id != b->right_fringe_face_id
1344 || a->right_fringe_offset != b->right_fringe_offset
1345 || a->fringe_bitmap_periodic_p != b->fringe_bitmap_periodic_p
1346 || a->overlay_arrow_bitmap != b->overlay_arrow_bitmap
1347 || a->exact_window_width_line_p != b->exact_window_width_line_p
1348 || a->overlapped_p != b->overlapped_p
1349 || (MATRIX_ROW_CONTINUATION_LINE_P (a)
1350 != MATRIX_ROW_CONTINUATION_LINE_P (b))
1351 || a->reversed_p != b->reversed_p
1352 /* Different partially visible characters on left margin. */
1353 || a->x != b->x
1354 /* Different height. */
1355 || a->ascent != b->ascent
1356 || a->phys_ascent != b->phys_ascent
1357 || a->phys_height != b->phys_height
1358 || a->visible_height != b->visible_height)
1359 return 0;
1362 return 1;
1367 /***********************************************************************
1368 Glyph Pool
1370 See dispextern.h for an overall explanation of glyph pools.
1371 ***********************************************************************/
1373 /* Allocate a glyph_pool structure. The structure returned is
1374 initialized with zeros. The global variable glyph_pool_count is
1375 incremented for each pool allocated. */
1377 static struct glyph_pool *
1378 new_glyph_pool (void)
1380 struct glyph_pool *result;
1382 /* Allocate a new glyph_pool and clear it. */
1383 result = (struct glyph_pool *) xmalloc (sizeof *result);
1384 memset (result, 0, sizeof *result);
1386 /* For memory leak and double deletion checking. */
1387 ++glyph_pool_count;
1389 return result;
1393 /* Free a glyph_pool structure POOL. The function may be called with
1394 a null POOL pointer. The global variable glyph_pool_count is
1395 decremented with every pool structure freed. If this count gets
1396 negative, more structures were freed than allocated, i.e. one
1397 structure must have been freed more than once or a bogus pointer
1398 was passed to free_glyph_pool. */
1400 static void
1401 free_glyph_pool (struct glyph_pool *pool)
1403 if (pool)
1405 /* More freed than allocated? */
1406 --glyph_pool_count;
1407 xassert (glyph_pool_count >= 0);
1409 xfree (pool->glyphs);
1410 xfree (pool);
1415 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1416 columns we need. This function never shrinks a pool. The only
1417 case in which this would make sense, would be when a frame's size
1418 is changed from a large value to a smaller one. But, if someone
1419 does it once, we can expect that he will do it again.
1421 Value is non-zero if the pool changed in a way which makes
1422 re-adjusting window glyph matrices necessary. */
1424 static int
1425 realloc_glyph_pool (struct glyph_pool *pool, struct dim matrix_dim)
1427 ptrdiff_t needed;
1428 int changed_p;
1430 changed_p = (pool->glyphs == 0
1431 || matrix_dim.height != pool->nrows
1432 || matrix_dim.width != pool->ncolumns);
1434 /* Enlarge the glyph pool. */
1435 needed = matrix_dim.width;
1436 if (INT_MULTIPLY_OVERFLOW (needed, matrix_dim.height))
1437 memory_full (SIZE_MAX);
1438 needed *= matrix_dim.height;
1439 if (needed > pool->nglyphs)
1441 ptrdiff_t old_nglyphs = pool->nglyphs;
1442 pool->glyphs = xpalloc (pool->glyphs, &pool->nglyphs,
1443 needed - old_nglyphs, -1, sizeof *pool->glyphs);
1444 memset (pool->glyphs + old_nglyphs, 0,
1445 (pool->nglyphs - old_nglyphs) * sizeof *pool->glyphs);
1448 /* Remember the number of rows and columns because (a) we use them
1449 to do sanity checks, and (b) the number of columns determines
1450 where rows in the frame matrix start---this must be available to
1451 determine pointers to rows of window sub-matrices. */
1452 pool->nrows = matrix_dim.height;
1453 pool->ncolumns = matrix_dim.width;
1455 return changed_p;
1460 /***********************************************************************
1461 Debug Code
1462 ***********************************************************************/
1464 #if GLYPH_DEBUG
1467 /* Flush standard output. This is sometimes useful to call from the debugger.
1468 XXX Maybe this should be changed to flush the current terminal instead of
1469 stdout.
1472 void flush_stdout (void) EXTERNALLY_VISIBLE;
1474 void
1475 flush_stdout (void)
1477 fflush (stdout);
1481 /* Check that no glyph pointers have been lost in MATRIX. If a
1482 pointer has been lost, e.g. by using a structure assignment between
1483 rows, at least one pointer must occur more than once in the rows of
1484 MATRIX. */
1486 void
1487 check_matrix_pointer_lossage (struct glyph_matrix *matrix)
1489 int i, j;
1491 for (i = 0; i < matrix->nrows; ++i)
1492 for (j = 0; j < matrix->nrows; ++j)
1493 xassert (i == j
1494 || (matrix->rows[i].glyphs[TEXT_AREA]
1495 != matrix->rows[j].glyphs[TEXT_AREA]));
1499 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1501 struct glyph_row *
1502 matrix_row (struct glyph_matrix *matrix, int row)
1504 xassert (matrix && matrix->rows);
1505 xassert (row >= 0 && row < matrix->nrows);
1507 /* That's really too slow for normal testing because this function
1508 is called almost everywhere. Although---it's still astonishingly
1509 fast, so it is valuable to have for debugging purposes. */
1510 #if 0
1511 check_matrix_pointer_lossage (matrix);
1512 #endif
1514 return matrix->rows + row;
1518 #if 0 /* This function makes invalid assumptions when text is
1519 partially invisible. But it might come handy for debugging
1520 nevertheless. */
1522 /* Check invariants that must hold for an up to date current matrix of
1523 window W. */
1525 static void
1526 check_matrix_invariants (struct window *w)
1528 struct glyph_matrix *matrix = w->current_matrix;
1529 int yb = window_text_bottom_y (w);
1530 struct glyph_row *row = matrix->rows;
1531 struct glyph_row *last_text_row = NULL;
1532 struct buffer *saved = current_buffer;
1533 struct buffer *buffer = XBUFFER (w->buffer);
1534 int c;
1536 /* This can sometimes happen for a fresh window. */
1537 if (matrix->nrows < 2)
1538 return;
1540 set_buffer_temp (buffer);
1542 /* Note: last row is always reserved for the mode line. */
1543 while (MATRIX_ROW_DISPLAYS_TEXT_P (row)
1544 && MATRIX_ROW_BOTTOM_Y (row) < yb)
1546 struct glyph_row *next = row + 1;
1548 if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
1549 last_text_row = row;
1551 /* Check that character and byte positions are in sync. */
1552 xassert (MATRIX_ROW_START_BYTEPOS (row)
1553 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row)));
1554 xassert (BYTEPOS (row->start.pos)
1555 == CHAR_TO_BYTE (CHARPOS (row->start.pos)));
1557 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1558 have such a position temporarily in case of a minibuffer
1559 displaying something like `[Sole completion]' at its end. */
1560 if (MATRIX_ROW_END_CHARPOS (row) < BUF_ZV (current_buffer))
1562 xassert (MATRIX_ROW_END_BYTEPOS (row)
1563 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row)));
1564 xassert (BYTEPOS (row->end.pos)
1565 == CHAR_TO_BYTE (CHARPOS (row->end.pos)));
1568 /* Check that end position of `row' is equal to start position
1569 of next row. */
1570 if (next->enabled_p && MATRIX_ROW_DISPLAYS_TEXT_P (next))
1572 xassert (MATRIX_ROW_END_CHARPOS (row)
1573 == MATRIX_ROW_START_CHARPOS (next));
1574 xassert (MATRIX_ROW_END_BYTEPOS (row)
1575 == MATRIX_ROW_START_BYTEPOS (next));
1576 xassert (CHARPOS (row->end.pos) == CHARPOS (next->start.pos));
1577 xassert (BYTEPOS (row->end.pos) == BYTEPOS (next->start.pos));
1579 row = next;
1582 xassert (w->current_matrix->nrows == w->desired_matrix->nrows);
1583 xassert (w->desired_matrix->rows != NULL);
1584 set_buffer_temp (saved);
1587 #endif /* 0 */
1589 #endif /* GLYPH_DEBUG != 0 */
1593 /**********************************************************************
1594 Allocating/ Adjusting Glyph Matrices
1595 **********************************************************************/
1597 /* Allocate glyph matrices over a window tree for a frame-based
1598 redisplay
1600 X and Y are column/row within the frame glyph matrix where
1601 sub-matrices for the window tree rooted at WINDOW must be
1602 allocated. DIM_ONLY_P non-zero means that the caller of this
1603 function is only interested in the result matrix dimension, and
1604 matrix adjustments should not be performed.
1606 The function returns the total width/height of the sub-matrices of
1607 the window tree. If called on a frame root window, the computation
1608 will take the mini-buffer window into account.
1610 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1612 NEW_LEAF_MATRIX set if any window in the tree did not have a
1613 glyph matrices yet, and
1615 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1616 any window in the tree will be changed or have been changed (see
1617 DIM_ONLY_P)
1619 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1620 function.
1622 Windows are arranged into chains of windows on the same level
1623 through the next fields of window structures. Such a level can be
1624 either a sequence of horizontally adjacent windows from left to
1625 right, or a sequence of vertically adjacent windows from top to
1626 bottom. Each window in a horizontal sequence can be either a leaf
1627 window or a vertical sequence; a window in a vertical sequence can
1628 be either a leaf or a horizontal sequence. All windows in a
1629 horizontal sequence have the same height, and all windows in a
1630 vertical sequence have the same width.
1632 This function uses, for historical reasons, a more general
1633 algorithm to determine glyph matrix dimensions that would be
1634 necessary.
1636 The matrix height of a horizontal sequence is determined by the
1637 maximum height of any matrix in the sequence. The matrix width of
1638 a horizontal sequence is computed by adding up matrix widths of
1639 windows in the sequence.
1641 |<------- result width ------->|
1642 +---------+----------+---------+ ---
1643 | | | | |
1644 | | | |
1645 +---------+ | | result height
1646 | +---------+
1647 | | |
1648 +----------+ ---
1650 The matrix width of a vertical sequence is the maximum matrix width
1651 of any window in the sequence. Its height is computed by adding up
1652 matrix heights of windows in the sequence.
1654 |<---- result width -->|
1655 +---------+ ---
1656 | | |
1657 | | |
1658 +---------+--+ |
1659 | | |
1660 | | result height
1662 +------------+---------+ |
1663 | | |
1664 | | |
1665 +------------+---------+ --- */
1667 /* Bit indicating that a new matrix will be allocated or has been
1668 allocated. */
1670 #define NEW_LEAF_MATRIX (1 << 0)
1672 /* Bit indicating that a matrix will or has changed its location or
1673 size. */
1675 #define CHANGED_LEAF_MATRIX (1 << 1)
1677 static struct dim
1678 allocate_matrices_for_frame_redisplay (Lisp_Object window, int x, int y,
1679 int dim_only_p, int *window_change_flags)
1681 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (window)));
1682 int x0 = x, y0 = y;
1683 int wmax = 0, hmax = 0;
1684 struct dim total;
1685 struct dim dim;
1686 struct window *w;
1687 int in_horz_combination_p;
1689 /* What combination is WINDOW part of? Compute this once since the
1690 result is the same for all windows in the `next' chain. The
1691 special case of a root window (parent equal to nil) is treated
1692 like a vertical combination because a root window's `next'
1693 points to the mini-buffer window, if any, which is arranged
1694 vertically below other windows. */
1695 in_horz_combination_p
1696 = (!NILP (XWINDOW (window)->parent)
1697 && !NILP (XWINDOW (XWINDOW (window)->parent)->hchild));
1699 /* For WINDOW and all windows on the same level. */
1702 w = XWINDOW (window);
1704 /* Get the dimension of the window sub-matrix for W, depending
1705 on whether this is a combination or a leaf window. */
1706 if (!NILP (w->hchild))
1707 dim = allocate_matrices_for_frame_redisplay (w->hchild, x, y,
1708 dim_only_p,
1709 window_change_flags);
1710 else if (!NILP (w->vchild))
1711 dim = allocate_matrices_for_frame_redisplay (w->vchild, x, y,
1712 dim_only_p,
1713 window_change_flags);
1714 else
1716 /* If not already done, allocate sub-matrix structures. */
1717 if (w->desired_matrix == NULL)
1719 w->desired_matrix = new_glyph_matrix (f->desired_pool);
1720 w->current_matrix = new_glyph_matrix (f->current_pool);
1721 *window_change_flags |= NEW_LEAF_MATRIX;
1724 /* Width and height MUST be chosen so that there are no
1725 holes in the frame matrix. */
1726 dim.width = required_matrix_width (w);
1727 dim.height = required_matrix_height (w);
1729 /* Will matrix be re-allocated? */
1730 if (x != w->desired_matrix->matrix_x
1731 || y != w->desired_matrix->matrix_y
1732 || dim.width != w->desired_matrix->matrix_w
1733 || dim.height != w->desired_matrix->matrix_h
1734 || (margin_glyphs_to_reserve (w, dim.width,
1735 w->left_margin_cols)
1736 != w->desired_matrix->left_margin_glyphs)
1737 || (margin_glyphs_to_reserve (w, dim.width,
1738 w->right_margin_cols)
1739 != w->desired_matrix->right_margin_glyphs))
1740 *window_change_flags |= CHANGED_LEAF_MATRIX;
1742 /* Actually change matrices, if allowed. Do not consider
1743 CHANGED_LEAF_MATRIX computed above here because the pool
1744 may have been changed which we don't now here. We trust
1745 that we only will be called with DIM_ONLY_P != 0 when
1746 necessary. */
1747 if (!dim_only_p)
1749 adjust_glyph_matrix (w, w->desired_matrix, x, y, dim);
1750 adjust_glyph_matrix (w, w->current_matrix, x, y, dim);
1754 /* If we are part of a horizontal combination, advance x for
1755 windows to the right of W; otherwise advance y for windows
1756 below W. */
1757 if (in_horz_combination_p)
1758 x += dim.width;
1759 else
1760 y += dim.height;
1762 /* Remember maximum glyph matrix dimensions. */
1763 wmax = max (wmax, dim.width);
1764 hmax = max (hmax, dim.height);
1766 /* Next window on same level. */
1767 window = w->next;
1769 while (!NILP (window));
1771 /* Set `total' to the total glyph matrix dimension of this window
1772 level. In a vertical combination, the width is the width of the
1773 widest window; the height is the y we finally reached, corrected
1774 by the y we started with. In a horizontal combination, the total
1775 height is the height of the tallest window, and the width is the
1776 x we finally reached, corrected by the x we started with. */
1777 if (in_horz_combination_p)
1779 total.width = x - x0;
1780 total.height = hmax;
1782 else
1784 total.width = wmax;
1785 total.height = y - y0;
1788 return total;
1792 /* Return the required height of glyph matrices for window W. */
1794 static int
1795 required_matrix_height (struct window *w)
1797 #ifdef HAVE_WINDOW_SYSTEM
1798 struct frame *f = XFRAME (w->frame);
1800 if (FRAME_WINDOW_P (f))
1802 int ch_height = FRAME_SMALLEST_FONT_HEIGHT (f);
1803 int window_pixel_height = window_box_height (w) + eabs (w->vscroll);
1804 return (((window_pixel_height + ch_height - 1)
1805 / ch_height) * w->nrows_scale_factor
1806 /* One partially visible line at the top and
1807 bottom of the window. */
1809 /* 2 for header and mode line. */
1810 + 2);
1812 #endif /* HAVE_WINDOW_SYSTEM */
1814 return WINDOW_TOTAL_LINES (w);
1818 /* Return the required width of glyph matrices for window W. */
1820 static int
1821 required_matrix_width (struct window *w)
1823 #ifdef HAVE_WINDOW_SYSTEM
1824 struct frame *f = XFRAME (w->frame);
1825 if (FRAME_WINDOW_P (f))
1827 int ch_width = FRAME_SMALLEST_CHAR_WIDTH (f);
1828 int window_pixel_width = WINDOW_TOTAL_WIDTH (w);
1830 /* Compute number of glyphs needed in a glyph row. */
1831 return (((window_pixel_width + ch_width - 1)
1832 / ch_width) * w->ncols_scale_factor
1833 /* 2 partially visible columns in the text area. */
1835 /* One partially visible column at the right
1836 edge of each marginal area. */
1837 + 1 + 1);
1839 #endif /* HAVE_WINDOW_SYSTEM */
1841 return XINT (w->total_cols);
1845 /* Allocate window matrices for window-based redisplay. W is the
1846 window whose matrices must be allocated/reallocated. */
1848 static void
1849 allocate_matrices_for_window_redisplay (struct window *w)
1851 while (w)
1853 if (!NILP (w->vchild))
1854 allocate_matrices_for_window_redisplay (XWINDOW (w->vchild));
1855 else if (!NILP (w->hchild))
1856 allocate_matrices_for_window_redisplay (XWINDOW (w->hchild));
1857 else
1859 /* W is a leaf window. */
1860 struct dim dim;
1862 /* If matrices are not yet allocated, allocate them now. */
1863 if (w->desired_matrix == NULL)
1865 w->desired_matrix = new_glyph_matrix (NULL);
1866 w->current_matrix = new_glyph_matrix (NULL);
1869 dim.width = required_matrix_width (w);
1870 dim.height = required_matrix_height (w);
1871 adjust_glyph_matrix (w, w->desired_matrix, 0, 0, dim);
1872 adjust_glyph_matrix (w, w->current_matrix, 0, 0, dim);
1875 w = NILP (w->next) ? NULL : XWINDOW (w->next);
1880 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
1881 do it for all frames; otherwise do it just for the given frame.
1882 This function must be called when a new frame is created, its size
1883 changes, or its window configuration changes. */
1885 void
1886 adjust_glyphs (struct frame *f)
1888 /* Block input so that expose events and other events that access
1889 glyph matrices are not processed while we are changing them. */
1890 BLOCK_INPUT;
1892 if (f)
1893 adjust_frame_glyphs (f);
1894 else
1896 Lisp_Object tail, lisp_frame;
1898 FOR_EACH_FRAME (tail, lisp_frame)
1899 adjust_frame_glyphs (XFRAME (lisp_frame));
1902 UNBLOCK_INPUT;
1906 /* Adjust frame glyphs when Emacs is initialized.
1908 To be called from init_display.
1910 We need a glyph matrix because redraw will happen soon.
1911 Unfortunately, window sizes on selected_frame are not yet set to
1912 meaningful values. I believe we can assume that there are only two
1913 windows on the frame---the mini-buffer and the root window. Frame
1914 height and width seem to be correct so far. So, set the sizes of
1915 windows to estimated values. */
1917 static void
1918 adjust_frame_glyphs_initially (void)
1920 struct frame *sf = SELECTED_FRAME ();
1921 struct window *root = XWINDOW (sf->root_window);
1922 struct window *mini = XWINDOW (root->next);
1923 int frame_lines = FRAME_LINES (sf);
1924 int frame_cols = FRAME_COLS (sf);
1925 int top_margin = FRAME_TOP_MARGIN (sf);
1927 /* Do it for the root window. */
1928 XSETFASTINT (root->top_line, top_margin);
1929 XSETFASTINT (root->total_lines, frame_lines - 1 - top_margin);
1930 XSETFASTINT (root->total_cols, frame_cols);
1932 /* Do it for the mini-buffer window. */
1933 XSETFASTINT (mini->top_line, frame_lines - 1);
1934 XSETFASTINT (mini->total_lines, 1);
1935 XSETFASTINT (mini->total_cols, frame_cols);
1937 adjust_frame_glyphs (sf);
1938 glyphs_initialized_initially_p = 1;
1942 /* Allocate/reallocate glyph matrices of a single frame F. */
1944 static void
1945 adjust_frame_glyphs (struct frame *f)
1947 if (FRAME_WINDOW_P (f))
1948 adjust_frame_glyphs_for_window_redisplay (f);
1949 else
1950 adjust_frame_glyphs_for_frame_redisplay (f);
1952 /* Don't forget the message buffer and the buffer for
1953 decode_mode_spec. */
1954 adjust_frame_message_buffer (f);
1955 adjust_decode_mode_spec_buffer (f);
1957 f->glyphs_initialized_p = 1;
1960 /* Return 1 if any window in the tree has nonzero window margins. See
1961 the hack at the end of adjust_frame_glyphs_for_frame_redisplay. */
1962 static int
1963 showing_window_margins_p (struct window *w)
1965 while (w)
1967 if (!NILP (w->hchild))
1969 if (showing_window_margins_p (XWINDOW (w->hchild)))
1970 return 1;
1972 else if (!NILP (w->vchild))
1974 if (showing_window_margins_p (XWINDOW (w->vchild)))
1975 return 1;
1977 else if (!NILP (w->left_margin_cols)
1978 || !NILP (w->right_margin_cols))
1979 return 1;
1981 w = NILP (w->next) ? 0 : XWINDOW (w->next);
1983 return 0;
1987 /* In the window tree with root W, build current matrices of leaf
1988 windows from the frame's current matrix. */
1990 static void
1991 fake_current_matrices (Lisp_Object window)
1993 struct window *w;
1995 for (; !NILP (window); window = w->next)
1997 w = XWINDOW (window);
1999 if (!NILP (w->hchild))
2000 fake_current_matrices (w->hchild);
2001 else if (!NILP (w->vchild))
2002 fake_current_matrices (w->vchild);
2003 else
2005 int i;
2006 struct frame *f = XFRAME (w->frame);
2007 struct glyph_matrix *m = w->current_matrix;
2008 struct glyph_matrix *fm = f->current_matrix;
2010 xassert (m->matrix_h == WINDOW_TOTAL_LINES (w));
2011 xassert (m->matrix_w == WINDOW_TOTAL_COLS (w));
2013 for (i = 0; i < m->matrix_h; ++i)
2015 struct glyph_row *r = m->rows + i;
2016 struct glyph_row *fr = fm->rows + i + WINDOW_TOP_EDGE_LINE (w);
2018 xassert (r->glyphs[TEXT_AREA] >= fr->glyphs[TEXT_AREA]
2019 && r->glyphs[LAST_AREA] <= fr->glyphs[LAST_AREA]);
2021 r->enabled_p = fr->enabled_p;
2022 if (r->enabled_p)
2024 r->used[LEFT_MARGIN_AREA] = m->left_margin_glyphs;
2025 r->used[RIGHT_MARGIN_AREA] = m->right_margin_glyphs;
2026 r->used[TEXT_AREA] = (m->matrix_w
2027 - r->used[LEFT_MARGIN_AREA]
2028 - r->used[RIGHT_MARGIN_AREA]);
2029 r->mode_line_p = 0;
2037 /* Save away the contents of frame F's current frame matrix. Value is
2038 a glyph matrix holding the contents of F's current frame matrix. */
2040 static struct glyph_matrix *
2041 save_current_matrix (struct frame *f)
2043 int i;
2044 struct glyph_matrix *saved;
2046 saved = (struct glyph_matrix *) xmalloc (sizeof *saved);
2047 memset (saved, 0, sizeof *saved);
2048 saved->nrows = f->current_matrix->nrows;
2049 saved->rows = (struct glyph_row *) xmalloc (saved->nrows
2050 * sizeof *saved->rows);
2051 memset (saved->rows, 0, saved->nrows * sizeof *saved->rows);
2053 for (i = 0; i < saved->nrows; ++i)
2055 struct glyph_row *from = f->current_matrix->rows + i;
2056 struct glyph_row *to = saved->rows + i;
2057 ptrdiff_t nbytes = from->used[TEXT_AREA] * sizeof (struct glyph);
2058 to->glyphs[TEXT_AREA] = (struct glyph *) xmalloc (nbytes);
2059 memcpy (to->glyphs[TEXT_AREA], from->glyphs[TEXT_AREA], nbytes);
2060 to->used[TEXT_AREA] = from->used[TEXT_AREA];
2063 return saved;
2067 /* Restore the contents of frame F's current frame matrix from SAVED,
2068 and free memory associated with SAVED. */
2070 static void
2071 restore_current_matrix (struct frame *f, struct glyph_matrix *saved)
2073 int i;
2075 for (i = 0; i < saved->nrows; ++i)
2077 struct glyph_row *from = saved->rows + i;
2078 struct glyph_row *to = f->current_matrix->rows + i;
2079 ptrdiff_t nbytes = from->used[TEXT_AREA] * sizeof (struct glyph);
2080 memcpy (to->glyphs[TEXT_AREA], from->glyphs[TEXT_AREA], nbytes);
2081 to->used[TEXT_AREA] = from->used[TEXT_AREA];
2082 xfree (from->glyphs[TEXT_AREA]);
2085 xfree (saved->rows);
2086 xfree (saved);
2091 /* Allocate/reallocate glyph matrices of a single frame F for
2092 frame-based redisplay. */
2094 static void
2095 adjust_frame_glyphs_for_frame_redisplay (struct frame *f)
2097 struct dim matrix_dim;
2098 int pool_changed_p;
2099 int window_change_flags;
2100 int top_window_y;
2102 if (!FRAME_LIVE_P (f))
2103 return;
2105 top_window_y = FRAME_TOP_MARGIN (f);
2107 /* Allocate glyph pool structures if not already done. */
2108 if (f->desired_pool == NULL)
2110 f->desired_pool = new_glyph_pool ();
2111 f->current_pool = new_glyph_pool ();
2114 /* Allocate frames matrix structures if needed. */
2115 if (f->desired_matrix == NULL)
2117 f->desired_matrix = new_glyph_matrix (f->desired_pool);
2118 f->current_matrix = new_glyph_matrix (f->current_pool);
2121 /* Compute window glyph matrices. (This takes the mini-buffer
2122 window into account). The result is the size of the frame glyph
2123 matrix needed. The variable window_change_flags is set to a bit
2124 mask indicating whether new matrices will be allocated or
2125 existing matrices change their size or location within the frame
2126 matrix. */
2127 window_change_flags = 0;
2128 matrix_dim
2129 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f),
2130 0, top_window_y,
2132 &window_change_flags);
2134 /* Add in menu bar lines, if any. */
2135 matrix_dim.height += top_window_y;
2137 /* Enlarge pools as necessary. */
2138 pool_changed_p = realloc_glyph_pool (f->desired_pool, matrix_dim);
2139 realloc_glyph_pool (f->current_pool, matrix_dim);
2141 /* Set up glyph pointers within window matrices. Do this only if
2142 absolutely necessary since it requires a frame redraw. */
2143 if (pool_changed_p || window_change_flags)
2145 /* Do it for window matrices. */
2146 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f),
2147 0, top_window_y, 0,
2148 &window_change_flags);
2150 /* Size of frame matrices must equal size of frame. Note
2151 that we are called for X frames with window widths NOT equal
2152 to the frame width (from CHANGE_FRAME_SIZE_1). */
2153 xassert (matrix_dim.width == FRAME_COLS (f)
2154 && matrix_dim.height == FRAME_LINES (f));
2156 /* Pointers to glyph memory in glyph rows are exchanged during
2157 the update phase of redisplay, which means in general that a
2158 frame's current matrix consists of pointers into both the
2159 desired and current glyph pool of the frame. Adjusting a
2160 matrix sets the frame matrix up so that pointers are all into
2161 the same pool. If we want to preserve glyph contents of the
2162 current matrix over a call to adjust_glyph_matrix, we must
2163 make a copy of the current glyphs, and restore the current
2164 matrix' contents from that copy. */
2165 if (display_completed
2166 && !FRAME_GARBAGED_P (f)
2167 && matrix_dim.width == f->current_matrix->matrix_w
2168 && matrix_dim.height == f->current_matrix->matrix_h
2169 /* For some reason, the frame glyph matrix gets corrupted if
2170 any of the windows contain margins. I haven't been able
2171 to hunt down the reason, but for the moment this prevents
2172 the problem from manifesting. -- cyd */
2173 && !showing_window_margins_p (XWINDOW (FRAME_ROOT_WINDOW (f))))
2175 struct glyph_matrix *copy = save_current_matrix (f);
2176 adjust_glyph_matrix (NULL, f->desired_matrix, 0, 0, matrix_dim);
2177 adjust_glyph_matrix (NULL, f->current_matrix, 0, 0, matrix_dim);
2178 restore_current_matrix (f, copy);
2179 fake_current_matrices (FRAME_ROOT_WINDOW (f));
2181 else
2183 adjust_glyph_matrix (NULL, f->desired_matrix, 0, 0, matrix_dim);
2184 adjust_glyph_matrix (NULL, f->current_matrix, 0, 0, matrix_dim);
2185 SET_FRAME_GARBAGED (f);
2191 /* Allocate/reallocate glyph matrices of a single frame F for
2192 window-based redisplay. */
2194 static void
2195 adjust_frame_glyphs_for_window_redisplay (struct frame *f)
2197 xassert (FRAME_WINDOW_P (f) && FRAME_LIVE_P (f));
2199 /* Allocate/reallocate window matrices. */
2200 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f)));
2202 #ifdef HAVE_X_WINDOWS
2203 /* Allocate/ reallocate matrices of the dummy window used to display
2204 the menu bar under X when no X toolkit support is available. */
2205 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
2207 /* Allocate a dummy window if not already done. */
2208 struct window *w;
2209 if (NILP (f->menu_bar_window))
2211 f->menu_bar_window = make_window ();
2212 w = XWINDOW (f->menu_bar_window);
2213 XSETFRAME (w->frame, f);
2214 w->pseudo_window_p = 1;
2216 else
2217 w = XWINDOW (f->menu_bar_window);
2219 /* Set window dimensions to frame dimensions and allocate or
2220 adjust glyph matrices of W. */
2221 XSETFASTINT (w->top_line, 0);
2222 XSETFASTINT (w->left_col, 0);
2223 XSETFASTINT (w->total_lines, FRAME_MENU_BAR_LINES (f));
2224 XSETFASTINT (w->total_cols, FRAME_TOTAL_COLS (f));
2225 allocate_matrices_for_window_redisplay (w);
2227 #endif /* not USE_X_TOOLKIT && not USE_GTK */
2228 #endif /* HAVE_X_WINDOWS */
2230 #ifndef USE_GTK
2232 /* Allocate/ reallocate matrices of the tool bar window. If we
2233 don't have a tool bar window yet, make one. */
2234 struct window *w;
2235 if (NILP (f->tool_bar_window))
2237 f->tool_bar_window = make_window ();
2238 w = XWINDOW (f->tool_bar_window);
2239 XSETFRAME (w->frame, f);
2240 w->pseudo_window_p = 1;
2242 else
2243 w = XWINDOW (f->tool_bar_window);
2245 XSETFASTINT (w->top_line, FRAME_MENU_BAR_LINES (f));
2246 XSETFASTINT (w->left_col, 0);
2247 XSETFASTINT (w->total_lines, FRAME_TOOL_BAR_LINES (f));
2248 XSETFASTINT (w->total_cols, FRAME_TOTAL_COLS (f));
2249 allocate_matrices_for_window_redisplay (w);
2251 #endif
2255 /* Adjust/ allocate message buffer of frame F.
2257 Note that the message buffer is never freed. Since I could not
2258 find a free in 19.34, I assume that freeing it would be
2259 problematic in some way and don't do it either.
2261 (Implementation note: It should be checked if we can free it
2262 eventually without causing trouble). */
2264 static void
2265 adjust_frame_message_buffer (struct frame *f)
2267 ptrdiff_t size = FRAME_MESSAGE_BUF_SIZE (f) + 1;
2269 if (FRAME_MESSAGE_BUF (f))
2271 char *buffer = FRAME_MESSAGE_BUF (f);
2272 char *new_buffer = (char *) xrealloc (buffer, size);
2273 FRAME_MESSAGE_BUF (f) = new_buffer;
2275 else
2276 FRAME_MESSAGE_BUF (f) = (char *) xmalloc (size);
2280 /* Re-allocate buffer for decode_mode_spec on frame F. */
2282 static void
2283 adjust_decode_mode_spec_buffer (struct frame *f)
2285 f->decode_mode_spec_buffer
2286 = (char *) xrealloc (f->decode_mode_spec_buffer,
2287 FRAME_MESSAGE_BUF_SIZE (f) + 1);
2292 /**********************************************************************
2293 Freeing Glyph Matrices
2294 **********************************************************************/
2296 /* Free glyph memory for a frame F. F may be null. This function can
2297 be called for the same frame more than once. The root window of
2298 F may be nil when this function is called. This is the case when
2299 the function is called when F is destroyed. */
2301 void
2302 free_glyphs (struct frame *f)
2304 if (f && f->glyphs_initialized_p)
2306 /* Block interrupt input so that we don't get surprised by an X
2307 event while we're in an inconsistent state. */
2308 BLOCK_INPUT;
2309 f->glyphs_initialized_p = 0;
2311 /* Release window sub-matrices. */
2312 if (!NILP (f->root_window))
2313 free_window_matrices (XWINDOW (f->root_window));
2315 /* Free the dummy window for menu bars without X toolkit and its
2316 glyph matrices. */
2317 if (!NILP (f->menu_bar_window))
2319 struct window *w = XWINDOW (f->menu_bar_window);
2320 free_glyph_matrix (w->desired_matrix);
2321 free_glyph_matrix (w->current_matrix);
2322 w->desired_matrix = w->current_matrix = NULL;
2323 f->menu_bar_window = Qnil;
2326 /* Free the tool bar window and its glyph matrices. */
2327 if (!NILP (f->tool_bar_window))
2329 struct window *w = XWINDOW (f->tool_bar_window);
2330 free_glyph_matrix (w->desired_matrix);
2331 free_glyph_matrix (w->current_matrix);
2332 w->desired_matrix = w->current_matrix = NULL;
2333 f->tool_bar_window = Qnil;
2336 /* Release frame glyph matrices. Reset fields to zero in
2337 case we are called a second time. */
2338 if (f->desired_matrix)
2340 free_glyph_matrix (f->desired_matrix);
2341 free_glyph_matrix (f->current_matrix);
2342 f->desired_matrix = f->current_matrix = NULL;
2345 /* Release glyph pools. */
2346 if (f->desired_pool)
2348 free_glyph_pool (f->desired_pool);
2349 free_glyph_pool (f->current_pool);
2350 f->desired_pool = f->current_pool = NULL;
2353 UNBLOCK_INPUT;
2358 /* Free glyph sub-matrices in the window tree rooted at W. This
2359 function may be called with a null pointer, and it may be called on
2360 the same tree more than once. */
2362 void
2363 free_window_matrices (struct window *w)
2365 while (w)
2367 if (!NILP (w->hchild))
2368 free_window_matrices (XWINDOW (w->hchild));
2369 else if (!NILP (w->vchild))
2370 free_window_matrices (XWINDOW (w->vchild));
2371 else
2373 /* This is a leaf window. Free its memory and reset fields
2374 to zero in case this function is called a second time for
2375 W. */
2376 free_glyph_matrix (w->current_matrix);
2377 free_glyph_matrix (w->desired_matrix);
2378 w->current_matrix = w->desired_matrix = NULL;
2381 /* Next window on same level. */
2382 w = NILP (w->next) ? 0 : XWINDOW (w->next);
2387 /* Check glyph memory leaks. This function is called from
2388 shut_down_emacs. Note that frames are not destroyed when Emacs
2389 exits. We therefore free all glyph memory for all active frames
2390 explicitly and check that nothing is left allocated. */
2392 void
2393 check_glyph_memory (void)
2395 Lisp_Object tail, frame;
2397 /* Free glyph memory for all frames. */
2398 FOR_EACH_FRAME (tail, frame)
2399 free_glyphs (XFRAME (frame));
2401 /* Check that nothing is left allocated. */
2402 if (glyph_matrix_count)
2403 abort ();
2404 if (glyph_pool_count)
2405 abort ();
2410 /**********************************************************************
2411 Building a Frame Matrix
2412 **********************************************************************/
2414 /* Most of the redisplay code works on glyph matrices attached to
2415 windows. This is a good solution most of the time, but it is not
2416 suitable for terminal code. Terminal output functions cannot rely
2417 on being able to set an arbitrary terminal window. Instead they
2418 must be provided with a view of the whole frame, i.e. the whole
2419 screen. We build such a view by constructing a frame matrix from
2420 window matrices in this section.
2422 Windows that must be updated have their must_be_update_p flag set.
2423 For all such windows, their desired matrix is made part of the
2424 desired frame matrix. For other windows, their current matrix is
2425 made part of the desired frame matrix.
2427 +-----------------+----------------+
2428 | desired | desired |
2429 | | |
2430 +-----------------+----------------+
2431 | current |
2433 +----------------------------------+
2435 Desired window matrices can be made part of the frame matrix in a
2436 cheap way: We exploit the fact that the desired frame matrix and
2437 desired window matrices share their glyph memory. This is not
2438 possible for current window matrices. Their glyphs are copied to
2439 the desired frame matrix. The latter is equivalent to
2440 preserve_other_columns in the old redisplay.
2442 Used glyphs counters for frame matrix rows are the result of adding
2443 up glyph lengths of the window matrices. A line in the frame
2444 matrix is enabled, if a corresponding line in a window matrix is
2445 enabled.
2447 After building the desired frame matrix, it will be passed to
2448 terminal code, which will manipulate both the desired and current
2449 frame matrix. Changes applied to the frame's current matrix have
2450 to be visible in current window matrices afterwards, of course.
2452 This problem is solved like this:
2454 1. Window and frame matrices share glyphs. Window matrices are
2455 constructed in a way that their glyph contents ARE the glyph
2456 contents needed in a frame matrix. Thus, any modification of
2457 glyphs done in terminal code will be reflected in window matrices
2458 automatically.
2460 2. Exchanges of rows in a frame matrix done by terminal code are
2461 intercepted by hook functions so that corresponding row operations
2462 on window matrices can be performed. This is necessary because we
2463 use pointers to glyphs in glyph row structures. To satisfy the
2464 assumption of point 1 above that glyphs are updated implicitly in
2465 window matrices when they are manipulated via the frame matrix,
2466 window and frame matrix must of course agree where to find the
2467 glyphs for their rows. Possible manipulations that must be
2468 mirrored are assignments of rows of the desired frame matrix to the
2469 current frame matrix and scrolling the current frame matrix. */
2471 /* Build frame F's desired matrix from window matrices. Only windows
2472 which have the flag must_be_updated_p set have to be updated. Menu
2473 bar lines of a frame are not covered by window matrices, so make
2474 sure not to touch them in this function. */
2476 static void
2477 build_frame_matrix (struct frame *f)
2479 int i;
2481 /* F must have a frame matrix when this function is called. */
2482 xassert (!FRAME_WINDOW_P (f));
2484 /* Clear all rows in the frame matrix covered by window matrices.
2485 Menu bar lines are not covered by windows. */
2486 for (i = FRAME_TOP_MARGIN (f); i < f->desired_matrix->nrows; ++i)
2487 clear_glyph_row (MATRIX_ROW (f->desired_matrix, i));
2489 /* Build the matrix by walking the window tree. */
2490 build_frame_matrix_from_window_tree (f->desired_matrix,
2491 XWINDOW (FRAME_ROOT_WINDOW (f)));
2495 /* Walk a window tree, building a frame matrix MATRIX from window
2496 matrices. W is the root of a window tree. */
2498 static void
2499 build_frame_matrix_from_window_tree (struct glyph_matrix *matrix, struct window *w)
2501 while (w)
2503 if (!NILP (w->hchild))
2504 build_frame_matrix_from_window_tree (matrix, XWINDOW (w->hchild));
2505 else if (!NILP (w->vchild))
2506 build_frame_matrix_from_window_tree (matrix, XWINDOW (w->vchild));
2507 else
2508 build_frame_matrix_from_leaf_window (matrix, w);
2510 w = NILP (w->next) ? 0 : XWINDOW (w->next);
2515 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2516 desired frame matrix built. W is a leaf window whose desired or
2517 current matrix is to be added to FRAME_MATRIX. W's flag
2518 must_be_updated_p determines which matrix it contributes to
2519 FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix
2520 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2521 Adding a desired matrix means setting up used counters and such in
2522 frame rows, while adding a current window matrix to FRAME_MATRIX
2523 means copying glyphs. The latter case corresponds to
2524 preserve_other_columns in the old redisplay. */
2526 static void
2527 build_frame_matrix_from_leaf_window (struct glyph_matrix *frame_matrix, struct window *w)
2529 struct glyph_matrix *window_matrix;
2530 int window_y, frame_y;
2531 /* If non-zero, a glyph to insert at the right border of W. */
2532 GLYPH right_border_glyph;
2534 SET_GLYPH_FROM_CHAR (right_border_glyph, 0);
2536 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2537 if (w->must_be_updated_p)
2539 window_matrix = w->desired_matrix;
2541 /* Decide whether we want to add a vertical border glyph. */
2542 if (!WINDOW_RIGHTMOST_P (w))
2544 struct Lisp_Char_Table *dp = window_display_table (w);
2545 Lisp_Object gc;
2547 SET_GLYPH_FROM_CHAR (right_border_glyph, '|');
2548 if (dp
2549 && (gc = DISP_BORDER_GLYPH (dp), GLYPH_CODE_P (gc))
2550 && GLYPH_CODE_CHAR_VALID_P (gc))
2552 SET_GLYPH_FROM_GLYPH_CODE (right_border_glyph, gc);
2553 spec_glyph_lookup_face (w, &right_border_glyph);
2556 if (GLYPH_FACE (right_border_glyph) <= 0)
2557 SET_GLYPH_FACE (right_border_glyph, VERTICAL_BORDER_FACE_ID);
2560 else
2561 window_matrix = w->current_matrix;
2563 /* For all rows in the window matrix and corresponding rows in the
2564 frame matrix. */
2565 window_y = 0;
2566 frame_y = window_matrix->matrix_y;
2567 while (window_y < window_matrix->nrows)
2569 struct glyph_row *frame_row = frame_matrix->rows + frame_y;
2570 struct glyph_row *window_row = window_matrix->rows + window_y;
2571 int current_row_p = window_matrix == w->current_matrix;
2573 /* Fill up the frame row with spaces up to the left margin of the
2574 window row. */
2575 fill_up_frame_row_with_spaces (frame_row, window_matrix->matrix_x);
2577 /* Fill up areas in the window matrix row with spaces. */
2578 fill_up_glyph_row_with_spaces (window_row);
2580 /* If only part of W's desired matrix has been built, and
2581 window_row wasn't displayed, use the corresponding current
2582 row instead. */
2583 if (window_matrix == w->desired_matrix
2584 && !window_row->enabled_p)
2586 window_row = w->current_matrix->rows + window_y;
2587 current_row_p = 1;
2590 if (current_row_p)
2592 /* Copy window row to frame row. */
2593 memcpy (frame_row->glyphs[TEXT_AREA] + window_matrix->matrix_x,
2594 window_row->glyphs[0],
2595 window_matrix->matrix_w * sizeof (struct glyph));
2597 else
2599 xassert (window_row->enabled_p);
2601 /* Only when a desired row has been displayed, we want
2602 the corresponding frame row to be updated. */
2603 frame_row->enabled_p = 1;
2605 /* Maybe insert a vertical border between horizontally adjacent
2606 windows. */
2607 if (GLYPH_CHAR (right_border_glyph) != 0)
2609 struct glyph *border = window_row->glyphs[LAST_AREA] - 1;
2610 SET_CHAR_GLYPH_FROM_GLYPH (*border, right_border_glyph);
2613 #if GLYPH_DEBUG
2614 /* Window row window_y must be a slice of frame row
2615 frame_y. */
2616 xassert (glyph_row_slice_p (window_row, frame_row));
2618 /* If rows are in sync, we don't have to copy glyphs because
2619 frame and window share glyphs. */
2621 strcpy (w->current_matrix->method, w->desired_matrix->method);
2622 add_window_display_history (w, w->current_matrix->method, 0);
2623 #endif
2626 /* Set number of used glyphs in the frame matrix. Since we fill
2627 up with spaces, and visit leaf windows from left to right it
2628 can be done simply. */
2629 frame_row->used[TEXT_AREA]
2630 = window_matrix->matrix_x + window_matrix->matrix_w;
2632 /* Next row. */
2633 ++window_y;
2634 ++frame_y;
2638 /* Given a user-specified glyph, possibly including a Lisp-level face
2639 ID, return a glyph that has a realized face ID.
2640 This is used for glyphs displayed specially and not part of the text;
2641 for instance, vertical separators, truncation markers, etc. */
2643 void
2644 spec_glyph_lookup_face (struct window *w, GLYPH *glyph)
2646 int lface_id = GLYPH_FACE (*glyph);
2647 /* Convert the glyph's specified face to a realized (cache) face. */
2648 if (lface_id > 0)
2650 int face_id = merge_faces (XFRAME (w->frame),
2651 Qt, lface_id, DEFAULT_FACE_ID);
2652 SET_GLYPH_FACE (*glyph, face_id);
2656 /* Add spaces to a glyph row ROW in a window matrix.
2658 Each row has the form:
2660 +---------+-----------------------------+------------+
2661 | left | text | right |
2662 +---------+-----------------------------+------------+
2664 Left and right marginal areas are optional. This function adds
2665 spaces to areas so that there are no empty holes between areas.
2666 In other words: If the right area is not empty, the text area
2667 is filled up with spaces up to the right area. If the text area
2668 is not empty, the left area is filled up.
2670 To be called for frame-based redisplay, only. */
2672 static void
2673 fill_up_glyph_row_with_spaces (struct glyph_row *row)
2675 fill_up_glyph_row_area_with_spaces (row, LEFT_MARGIN_AREA);
2676 fill_up_glyph_row_area_with_spaces (row, TEXT_AREA);
2677 fill_up_glyph_row_area_with_spaces (row, RIGHT_MARGIN_AREA);
2681 /* Fill area AREA of glyph row ROW with spaces. To be called for
2682 frame-based redisplay only. */
2684 static void
2685 fill_up_glyph_row_area_with_spaces (struct glyph_row *row, int area)
2687 if (row->glyphs[area] < row->glyphs[area + 1])
2689 struct glyph *end = row->glyphs[area + 1];
2690 struct glyph *text = row->glyphs[area] + row->used[area];
2692 while (text < end)
2693 *text++ = space_glyph;
2694 row->used[area] = text - row->glyphs[area];
2699 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2700 reached. In frame matrices only one area, TEXT_AREA, is used. */
2702 static void
2703 fill_up_frame_row_with_spaces (struct glyph_row *row, int upto)
2705 int i = row->used[TEXT_AREA];
2706 struct glyph *glyph = row->glyphs[TEXT_AREA];
2708 while (i < upto)
2709 glyph[i++] = space_glyph;
2711 row->used[TEXT_AREA] = i;
2716 /**********************************************************************
2717 Mirroring operations on frame matrices in window matrices
2718 **********************************************************************/
2720 /* Set frame being updated via frame-based redisplay to F. This
2721 function must be called before updates to make explicit that we are
2722 working on frame matrices or not. */
2724 static inline void
2725 set_frame_matrix_frame (struct frame *f)
2727 frame_matrix_frame = f;
2731 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2732 DESIRED_MATRIX is the desired matrix corresponding to
2733 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2734 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2735 frame_matrix_frame is non-null, this indicates that the exchange is
2736 done in frame matrices, and that we have to perform analogous
2737 operations in window matrices of frame_matrix_frame. */
2739 static inline void
2740 make_current (struct glyph_matrix *desired_matrix, struct glyph_matrix *current_matrix, int row)
2742 struct glyph_row *current_row = MATRIX_ROW (current_matrix, row);
2743 struct glyph_row *desired_row = MATRIX_ROW (desired_matrix, row);
2744 int mouse_face_p = current_row->mouse_face_p;
2746 /* Do current_row = desired_row. This exchanges glyph pointers
2747 between both rows, and does a structure assignment otherwise. */
2748 assign_row (current_row, desired_row);
2750 /* Enable current_row to mark it as valid. */
2751 current_row->enabled_p = 1;
2752 current_row->mouse_face_p = mouse_face_p;
2754 /* If we are called on frame matrices, perform analogous operations
2755 for window matrices. */
2756 if (frame_matrix_frame)
2757 mirror_make_current (XWINDOW (frame_matrix_frame->root_window), row);
2761 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2762 W's frame which has been made current (by swapping pointers between
2763 current and desired matrix). Perform analogous operations in the
2764 matrices of leaf windows in the window tree rooted at W. */
2766 static void
2767 mirror_make_current (struct window *w, int frame_row)
2769 while (w)
2771 if (!NILP (w->hchild))
2772 mirror_make_current (XWINDOW (w->hchild), frame_row);
2773 else if (!NILP (w->vchild))
2774 mirror_make_current (XWINDOW (w->vchild), frame_row);
2775 else
2777 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2778 here because the checks performed in debug mode there
2779 will not allow the conversion. */
2780 int row = frame_row - w->desired_matrix->matrix_y;
2782 /* If FRAME_ROW is within W, assign the desired row to the
2783 current row (exchanging glyph pointers). */
2784 if (row >= 0 && row < w->desired_matrix->matrix_h)
2786 struct glyph_row *current_row
2787 = MATRIX_ROW (w->current_matrix, row);
2788 struct glyph_row *desired_row
2789 = MATRIX_ROW (w->desired_matrix, row);
2791 if (desired_row->enabled_p)
2792 assign_row (current_row, desired_row);
2793 else
2794 swap_glyph_pointers (desired_row, current_row);
2795 current_row->enabled_p = 1;
2797 /* Set the Y coordinate of the mode/header line's row.
2798 It is needed in draw_row_with_mouse_face to find the
2799 screen coordinates. (Window-based redisplay sets
2800 this in update_window, but no one seems to do that
2801 for frame-based redisplay.) */
2802 if (current_row->mode_line_p)
2803 current_row->y = row;
2807 w = NILP (w->next) ? 0 : XWINDOW (w->next);
2812 /* Perform row dance after scrolling. We are working on the range of
2813 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2814 including) in MATRIX. COPY_FROM is a vector containing, for each
2815 row I in the range 0 <= I < NLINES, the index of the original line
2816 to move to I. This index is relative to the row range, i.e. 0 <=
2817 index < NLINES. RETAINED_P is a vector containing zero for each
2818 row 0 <= I < NLINES which is empty.
2820 This function is called from do_scrolling and do_direct_scrolling. */
2822 void
2823 mirrored_line_dance (struct glyph_matrix *matrix, int unchanged_at_top, int nlines,
2824 int *copy_from, char *retained_p)
2826 /* A copy of original rows. */
2827 struct glyph_row *old_rows;
2829 /* Rows to assign to. */
2830 struct glyph_row *new_rows = MATRIX_ROW (matrix, unchanged_at_top);
2832 int i;
2834 /* Make a copy of the original rows. */
2835 old_rows = (struct glyph_row *) alloca (nlines * sizeof *old_rows);
2836 memcpy (old_rows, new_rows, nlines * sizeof *old_rows);
2838 /* Assign new rows, maybe clear lines. */
2839 for (i = 0; i < nlines; ++i)
2841 int enabled_before_p = new_rows[i].enabled_p;
2843 xassert (i + unchanged_at_top < matrix->nrows);
2844 xassert (unchanged_at_top + copy_from[i] < matrix->nrows);
2845 new_rows[i] = old_rows[copy_from[i]];
2846 new_rows[i].enabled_p = enabled_before_p;
2848 /* RETAINED_P is zero for empty lines. */
2849 if (!retained_p[copy_from[i]])
2850 new_rows[i].enabled_p = 0;
2853 /* Do the same for window matrices, if MATRIX is a frame matrix. */
2854 if (frame_matrix_frame)
2855 mirror_line_dance (XWINDOW (frame_matrix_frame->root_window),
2856 unchanged_at_top, nlines, copy_from, retained_p);
2860 /* Synchronize glyph pointers in the current matrix of window W with
2861 the current frame matrix. */
2863 static void
2864 sync_window_with_frame_matrix_rows (struct window *w)
2866 struct frame *f = XFRAME (w->frame);
2867 struct glyph_row *window_row, *window_row_end, *frame_row;
2868 int left, right, x, width;
2870 /* Preconditions: W must be a leaf window on a tty frame. */
2871 xassert (NILP (w->hchild) && NILP (w->vchild));
2872 xassert (!FRAME_WINDOW_P (f));
2874 left = margin_glyphs_to_reserve (w, 1, w->left_margin_cols);
2875 right = margin_glyphs_to_reserve (w, 1, w->right_margin_cols);
2876 x = w->current_matrix->matrix_x;
2877 width = w->current_matrix->matrix_w;
2879 window_row = w->current_matrix->rows;
2880 window_row_end = window_row + w->current_matrix->nrows;
2881 frame_row = f->current_matrix->rows + WINDOW_TOP_EDGE_LINE (w);
2883 for (; window_row < window_row_end; ++window_row, ++frame_row)
2885 window_row->glyphs[LEFT_MARGIN_AREA]
2886 = frame_row->glyphs[0] + x;
2887 window_row->glyphs[TEXT_AREA]
2888 = window_row->glyphs[LEFT_MARGIN_AREA] + left;
2889 window_row->glyphs[LAST_AREA]
2890 = window_row->glyphs[LEFT_MARGIN_AREA] + width;
2891 window_row->glyphs[RIGHT_MARGIN_AREA]
2892 = window_row->glyphs[LAST_AREA] - right;
2897 /* Return the window in the window tree rooted in W containing frame
2898 row ROW. Value is null if none is found. */
2900 static struct window *
2901 frame_row_to_window (struct window *w, int row)
2903 struct window *found = NULL;
2905 while (w && !found)
2907 if (!NILP (w->hchild))
2908 found = frame_row_to_window (XWINDOW (w->hchild), row);
2909 else if (!NILP (w->vchild))
2910 found = frame_row_to_window (XWINDOW (w->vchild), row);
2911 else if (row >= WINDOW_TOP_EDGE_LINE (w)
2912 && row < WINDOW_BOTTOM_EDGE_LINE (w))
2913 found = w;
2915 w = NILP (w->next) ? 0 : XWINDOW (w->next);
2918 return found;
2922 /* Perform a line dance in the window tree rooted at W, after
2923 scrolling a frame matrix in mirrored_line_dance.
2925 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
2926 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
2927 COPY_FROM is a vector containing, for each row I in the range 0 <=
2928 I < NLINES, the index of the original line to move to I. This
2929 index is relative to the row range, i.e. 0 <= index < NLINES.
2930 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
2931 which is empty. */
2933 static void
2934 mirror_line_dance (struct window *w, int unchanged_at_top, int nlines, int *copy_from, char *retained_p)
2936 while (w)
2938 if (!NILP (w->hchild))
2939 mirror_line_dance (XWINDOW (w->hchild), unchanged_at_top,
2940 nlines, copy_from, retained_p);
2941 else if (!NILP (w->vchild))
2942 mirror_line_dance (XWINDOW (w->vchild), unchanged_at_top,
2943 nlines, copy_from, retained_p);
2944 else
2946 /* W is a leaf window, and we are working on its current
2947 matrix m. */
2948 struct glyph_matrix *m = w->current_matrix;
2949 int i, sync_p = 0;
2950 struct glyph_row *old_rows;
2952 /* Make a copy of the original rows of matrix m. */
2953 old_rows = (struct glyph_row *) alloca (m->nrows * sizeof *old_rows);
2954 memcpy (old_rows, m->rows, m->nrows * sizeof *old_rows);
2956 for (i = 0; i < nlines; ++i)
2958 /* Frame relative line assigned to. */
2959 int frame_to = i + unchanged_at_top;
2961 /* Frame relative line assigned. */
2962 int frame_from = copy_from[i] + unchanged_at_top;
2964 /* Window relative line assigned to. */
2965 int window_to = frame_to - m->matrix_y;
2967 /* Window relative line assigned. */
2968 int window_from = frame_from - m->matrix_y;
2970 /* Is assigned line inside window? */
2971 int from_inside_window_p
2972 = window_from >= 0 && window_from < m->matrix_h;
2974 /* Is assigned to line inside window? */
2975 int to_inside_window_p
2976 = window_to >= 0 && window_to < m->matrix_h;
2978 if (from_inside_window_p && to_inside_window_p)
2980 /* Enabled setting before assignment. */
2981 int enabled_before_p;
2983 /* Do the assignment. The enabled_p flag is saved
2984 over the assignment because the old redisplay did
2985 that. */
2986 enabled_before_p = m->rows[window_to].enabled_p;
2987 m->rows[window_to] = old_rows[window_from];
2988 m->rows[window_to].enabled_p = enabled_before_p;
2990 /* If frame line is empty, window line is empty, too. */
2991 if (!retained_p[copy_from[i]])
2992 m->rows[window_to].enabled_p = 0;
2994 else if (to_inside_window_p)
2996 /* A copy between windows. This is an infrequent
2997 case not worth optimizing. */
2998 struct frame *f = XFRAME (w->frame);
2999 struct window *root = XWINDOW (FRAME_ROOT_WINDOW (f));
3000 struct window *w2;
3001 struct glyph_matrix *m2;
3002 int m2_from;
3004 w2 = frame_row_to_window (root, frame_from);
3005 /* ttn@surf.glug.org: when enabling menu bar using `emacs
3006 -nw', FROM_FRAME sometimes has no associated window.
3007 This check avoids a segfault if W2 is null. */
3008 if (w2)
3010 m2 = w2->current_matrix;
3011 m2_from = frame_from - m2->matrix_y;
3012 copy_row_except_pointers (m->rows + window_to,
3013 m2->rows + m2_from);
3015 /* If frame line is empty, window line is empty, too. */
3016 if (!retained_p[copy_from[i]])
3017 m->rows[window_to].enabled_p = 0;
3019 sync_p = 1;
3021 else if (from_inside_window_p)
3022 sync_p = 1;
3025 /* If there was a copy between windows, make sure glyph
3026 pointers are in sync with the frame matrix. */
3027 if (sync_p)
3028 sync_window_with_frame_matrix_rows (w);
3030 /* Check that no pointers are lost. */
3031 CHECK_MATRIX (m);
3034 /* Next window on same level. */
3035 w = NILP (w->next) ? 0 : XWINDOW (w->next);
3040 #if GLYPH_DEBUG
3042 /* Check that window and frame matrices agree about their
3043 understanding where glyphs of the rows are to find. For each
3044 window in the window tree rooted at W, check that rows in the
3045 matrices of leaf window agree with their frame matrices about
3046 glyph pointers. */
3048 static void
3049 check_window_matrix_pointers (struct window *w)
3051 while (w)
3053 if (!NILP (w->hchild))
3054 check_window_matrix_pointers (XWINDOW (w->hchild));
3055 else if (!NILP (w->vchild))
3056 check_window_matrix_pointers (XWINDOW (w->vchild));
3057 else
3059 struct frame *f = XFRAME (w->frame);
3060 check_matrix_pointers (w->desired_matrix, f->desired_matrix);
3061 check_matrix_pointers (w->current_matrix, f->current_matrix);
3064 w = NILP (w->next) ? 0 : XWINDOW (w->next);
3069 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
3070 a window and FRAME_MATRIX is the corresponding frame matrix. For
3071 each row in WINDOW_MATRIX check that it's a slice of the
3072 corresponding frame row. If it isn't, abort. */
3074 static void
3075 check_matrix_pointers (struct glyph_matrix *window_matrix,
3076 struct glyph_matrix *frame_matrix)
3078 /* Row number in WINDOW_MATRIX. */
3079 int i = 0;
3081 /* Row number corresponding to I in FRAME_MATRIX. */
3082 int j = window_matrix->matrix_y;
3084 /* For all rows check that the row in the window matrix is a
3085 slice of the row in the frame matrix. If it isn't we didn't
3086 mirror an operation on the frame matrix correctly. */
3087 while (i < window_matrix->nrows)
3089 if (!glyph_row_slice_p (window_matrix->rows + i,
3090 frame_matrix->rows + j))
3091 abort ();
3092 ++i, ++j;
3096 #endif /* GLYPH_DEBUG != 0 */
3100 /**********************************************************************
3101 VPOS and HPOS translations
3102 **********************************************************************/
3104 #if GLYPH_DEBUG
3106 /* Translate vertical position VPOS which is relative to window W to a
3107 vertical position relative to W's frame. */
3109 static int
3110 window_to_frame_vpos (struct window *w, int vpos)
3112 xassert (!FRAME_WINDOW_P (XFRAME (w->frame)));
3113 xassert (vpos >= 0 && vpos <= w->desired_matrix->nrows);
3114 vpos += WINDOW_TOP_EDGE_LINE (w);
3115 xassert (vpos >= 0 && vpos <= FRAME_LINES (XFRAME (w->frame)));
3116 return vpos;
3120 /* Translate horizontal position HPOS which is relative to window W to
3121 a horizontal position relative to W's frame. */
3123 static int
3124 window_to_frame_hpos (struct window *w, int hpos)
3126 xassert (!FRAME_WINDOW_P (XFRAME (w->frame)));
3127 hpos += WINDOW_LEFT_EDGE_COL (w);
3128 return hpos;
3131 #endif /* GLYPH_DEBUG */
3135 /**********************************************************************
3136 Redrawing Frames
3137 **********************************************************************/
3139 DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 1, 1, 0,
3140 doc: /* Clear frame FRAME and output again what is supposed to appear on it. */)
3141 (Lisp_Object frame)
3143 struct frame *f;
3145 CHECK_LIVE_FRAME (frame);
3146 f = XFRAME (frame);
3148 /* Ignore redraw requests, if frame has no glyphs yet.
3149 (Implementation note: It still has to be checked why we are
3150 called so early here). */
3151 if (!glyphs_initialized_initially_p)
3152 return Qnil;
3154 update_begin (f);
3155 #ifdef MSDOS
3156 if (FRAME_MSDOS_P (f))
3157 FRAME_TERMINAL (f)->set_terminal_modes_hook (FRAME_TERMINAL (f));
3158 #endif
3159 clear_frame (f);
3160 clear_current_matrices (f);
3161 update_end (f);
3162 if (FRAME_TERMCAP_P (f))
3163 fflush (FRAME_TTY (f)->output);
3164 windows_or_buffers_changed++;
3165 /* Mark all windows as inaccurate, so that every window will have
3166 its redisplay done. */
3167 mark_window_display_accurate (FRAME_ROOT_WINDOW (f), 0);
3168 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f)), 1);
3169 f->garbaged = 0;
3170 return Qnil;
3174 /* Redraw frame F. This is nothing more than a call to the Lisp
3175 function redraw-frame. */
3177 void
3178 redraw_frame (struct frame *f)
3180 Lisp_Object frame;
3181 XSETFRAME (frame, f);
3182 Fredraw_frame (frame);
3186 DEFUN ("redraw-display", Fredraw_display, Sredraw_display, 0, 0, "",
3187 doc: /* Clear and redisplay all visible frames. */)
3188 (void)
3190 Lisp_Object tail, frame;
3192 FOR_EACH_FRAME (tail, frame)
3193 if (FRAME_VISIBLE_P (XFRAME (frame)))
3194 Fredraw_frame (frame);
3196 return Qnil;
3201 /***********************************************************************
3202 Frame Update
3203 ***********************************************************************/
3205 /* Update frame F based on the data in desired matrices.
3207 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3208 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3209 scrolling.
3211 Value is non-zero if redisplay was stopped due to pending input. */
3214 update_frame (struct frame *f, int force_p, int inhibit_hairy_id_p)
3216 /* 1 means display has been paused because of pending input. */
3217 int paused_p;
3218 struct window *root_window = XWINDOW (f->root_window);
3220 if (redisplay_dont_pause)
3221 force_p = 1;
3222 #if PERIODIC_PREEMPTION_CHECKING
3223 else if (NILP (Vredisplay_preemption_period))
3224 force_p = 1;
3225 else if (!force_p && NUMBERP (Vredisplay_preemption_period))
3227 EMACS_TIME tm;
3228 double p = XFLOATINT (Vredisplay_preemption_period);
3229 int sec, usec;
3231 if (detect_input_pending_ignore_squeezables ())
3233 paused_p = 1;
3234 goto do_pause;
3237 sec = (int) p;
3238 usec = (p - sec) * 1000000;
3240 EMACS_GET_TIME (tm);
3241 EMACS_SET_SECS_USECS (preemption_period, sec, usec);
3242 EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
3244 #endif
3246 if (FRAME_WINDOW_P (f))
3248 /* We are working on window matrix basis. All windows whose
3249 flag must_be_updated_p is set have to be updated. */
3251 /* Record that we are not working on frame matrices. */
3252 set_frame_matrix_frame (NULL);
3254 /* Update all windows in the window tree of F, maybe stopping
3255 when pending input is detected. */
3256 update_begin (f);
3258 /* Update the menu bar on X frames that don't have toolkit
3259 support. */
3260 if (WINDOWP (f->menu_bar_window))
3261 update_window (XWINDOW (f->menu_bar_window), 1);
3263 /* Update the tool-bar window, if present. */
3264 if (WINDOWP (f->tool_bar_window))
3266 struct window *w = XWINDOW (f->tool_bar_window);
3268 /* Update tool-bar window. */
3269 if (w->must_be_updated_p)
3271 Lisp_Object tem;
3273 update_window (w, 1);
3274 w->must_be_updated_p = 0;
3276 /* Swap tool-bar strings. We swap because we want to
3277 reuse strings. */
3278 tem = f->current_tool_bar_string;
3279 f->current_tool_bar_string = f->desired_tool_bar_string;
3280 f->desired_tool_bar_string = tem;
3285 /* Update windows. */
3286 paused_p = update_window_tree (root_window, force_p);
3287 update_end (f);
3289 /* This flush is a performance bottleneck under X,
3290 and it doesn't seem to be necessary anyway (in general).
3291 It is necessary when resizing the window with the mouse, or
3292 at least the fringes are not redrawn in a timely manner. ++kfs */
3293 if (f->force_flush_display_p)
3295 FRAME_RIF (f)->flush_display (f);
3296 f->force_flush_display_p = 0;
3299 else
3301 /* We are working on frame matrix basis. Set the frame on whose
3302 frame matrix we operate. */
3303 set_frame_matrix_frame (f);
3305 /* Build F's desired matrix from window matrices. */
3306 build_frame_matrix (f);
3308 /* Update the display */
3309 update_begin (f);
3310 paused_p = update_frame_1 (f, force_p, inhibit_hairy_id_p);
3311 update_end (f);
3313 if (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))
3315 if (FRAME_TTY (f)->termscript)
3316 fflush (FRAME_TTY (f)->termscript);
3317 if (FRAME_TERMCAP_P (f))
3318 fflush (FRAME_TTY (f)->output);
3321 /* Check window matrices for lost pointers. */
3322 #if GLYPH_DEBUG
3323 check_window_matrix_pointers (root_window);
3324 add_frame_display_history (f, paused_p);
3325 #endif
3328 #if PERIODIC_PREEMPTION_CHECKING
3329 do_pause:
3330 #endif
3331 /* Reset flags indicating that a window should be updated. */
3332 set_window_update_flags (root_window, 0);
3334 display_completed = !paused_p;
3335 return paused_p;
3340 /************************************************************************
3341 Window-based updates
3342 ************************************************************************/
3344 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3345 don't stop updating when input is pending. */
3347 static int
3348 update_window_tree (struct window *w, int force_p)
3350 int paused_p = 0;
3352 while (w && !paused_p)
3354 if (!NILP (w->hchild))
3355 paused_p |= update_window_tree (XWINDOW (w->hchild), force_p);
3356 else if (!NILP (w->vchild))
3357 paused_p |= update_window_tree (XWINDOW (w->vchild), force_p);
3358 else if (w->must_be_updated_p)
3359 paused_p |= update_window (w, force_p);
3361 w = NILP (w->next) ? 0 : XWINDOW (w->next);
3364 return paused_p;
3368 /* Update window W if its flag must_be_updated_p is non-zero. If
3369 FORCE_P is non-zero, don't stop updating if input is pending. */
3371 void
3372 update_single_window (struct window *w, int force_p)
3374 if (w->must_be_updated_p)
3376 struct frame *f = XFRAME (WINDOW_FRAME (w));
3378 /* Record that this is not a frame-based redisplay. */
3379 set_frame_matrix_frame (NULL);
3381 if (redisplay_dont_pause)
3382 force_p = 1;
3383 #if PERIODIC_PREEMPTION_CHECKING
3384 else if (NILP (Vredisplay_preemption_period))
3385 force_p = 1;
3386 else if (!force_p && NUMBERP (Vredisplay_preemption_period))
3388 EMACS_TIME tm;
3389 double p = XFLOATINT (Vredisplay_preemption_period);
3390 int sec, usec;
3392 sec = (int) p;
3393 usec = (p - sec) * 1000000;
3395 EMACS_GET_TIME (tm);
3396 EMACS_SET_SECS_USECS (preemption_period, sec, usec);
3397 EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
3399 #endif
3401 /* Update W. */
3402 update_begin (f);
3403 update_window (w, force_p);
3404 update_end (f);
3406 /* Reset flag in W. */
3407 w->must_be_updated_p = 0;
3411 #ifdef HAVE_WINDOW_SYSTEM
3413 /* Redraw lines from the current matrix of window W that are
3414 overlapped by other rows. YB is bottom-most y-position in W. */
3416 static void
3417 redraw_overlapped_rows (struct window *w, int yb)
3419 int i;
3420 struct frame *f = XFRAME (WINDOW_FRAME (w));
3422 /* If rows overlapping others have been changed, the rows being
3423 overlapped have to be redrawn. This won't draw lines that have
3424 already been drawn in update_window_line because overlapped_p in
3425 desired rows is 0, so after row assignment overlapped_p in
3426 current rows is 0. */
3427 for (i = 0; i < w->current_matrix->nrows; ++i)
3429 struct glyph_row *row = w->current_matrix->rows + i;
3431 if (!row->enabled_p)
3432 break;
3433 else if (row->mode_line_p)
3434 continue;
3436 if (row->overlapped_p)
3438 enum glyph_row_area area;
3440 for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
3442 updated_row = row;
3443 updated_area = area;
3444 FRAME_RIF (f)->cursor_to (i, 0, row->y,
3445 area == TEXT_AREA ? row->x : 0);
3446 if (row->used[area])
3447 FRAME_RIF (f)->write_glyphs (row->glyphs[area],
3448 row->used[area]);
3449 FRAME_RIF (f)->clear_end_of_line (-1);
3452 row->overlapped_p = 0;
3455 if (MATRIX_ROW_BOTTOM_Y (row) >= yb)
3456 break;
3461 /* Redraw lines from the current matrix of window W that overlap
3462 others. YB is bottom-most y-position in W. */
3464 static void
3465 redraw_overlapping_rows (struct window *w, int yb)
3467 int i, bottom_y;
3468 struct glyph_row *row;
3469 struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
3471 for (i = 0; i < w->current_matrix->nrows; ++i)
3473 row = w->current_matrix->rows + i;
3475 if (!row->enabled_p)
3476 break;
3477 else if (row->mode_line_p)
3478 continue;
3480 bottom_y = MATRIX_ROW_BOTTOM_Y (row);
3482 if (row->overlapping_p)
3484 int overlaps = 0;
3486 if (MATRIX_ROW_OVERLAPS_PRED_P (row) && i > 0
3487 && !MATRIX_ROW (w->current_matrix, i - 1)->overlapped_p)
3488 overlaps |= OVERLAPS_PRED;
3489 if (MATRIX_ROW_OVERLAPS_SUCC_P (row) && bottom_y < yb
3490 && !MATRIX_ROW (w->current_matrix, i + 1)->overlapped_p)
3491 overlaps |= OVERLAPS_SUCC;
3493 if (overlaps)
3495 if (row->used[LEFT_MARGIN_AREA])
3496 rif->fix_overlapping_area (w, row, LEFT_MARGIN_AREA, overlaps);
3498 if (row->used[TEXT_AREA])
3499 rif->fix_overlapping_area (w, row, TEXT_AREA, overlaps);
3501 if (row->used[RIGHT_MARGIN_AREA])
3502 rif->fix_overlapping_area (w, row, RIGHT_MARGIN_AREA, overlaps);
3504 /* Record in neighbor rows that ROW overwrites part of
3505 their display. */
3506 if (overlaps & OVERLAPS_PRED)
3507 MATRIX_ROW (w->current_matrix, i - 1)->overlapped_p = 1;
3508 if (overlaps & OVERLAPS_SUCC)
3509 MATRIX_ROW (w->current_matrix, i + 1)->overlapped_p = 1;
3513 if (bottom_y >= yb)
3514 break;
3518 #endif /* HAVE_WINDOW_SYSTEM */
3521 #if defined GLYPH_DEBUG && 0
3523 /* Check that no row in the current matrix of window W is enabled
3524 which is below what's displayed in the window. */
3526 static void
3527 check_current_matrix_flags (struct window *w)
3529 int last_seen_p = 0;
3530 int i, yb = window_text_bottom_y (w);
3532 for (i = 0; i < w->current_matrix->nrows - 1; ++i)
3534 struct glyph_row *row = MATRIX_ROW (w->current_matrix, i);
3535 if (!last_seen_p && MATRIX_ROW_BOTTOM_Y (row) >= yb)
3536 last_seen_p = 1;
3537 else if (last_seen_p && row->enabled_p)
3538 abort ();
3542 #endif /* GLYPH_DEBUG */
3545 /* Update display of window W. FORCE_P non-zero means that we should
3546 not stop when detecting pending input. */
3548 static int
3549 update_window (struct window *w, int force_p)
3551 struct glyph_matrix *desired_matrix = w->desired_matrix;
3552 int paused_p;
3553 #if !PERIODIC_PREEMPTION_CHECKING
3554 int preempt_count = baud_rate / 2400 + 1;
3555 #endif
3556 struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
3557 #if GLYPH_DEBUG
3558 /* Check that W's frame doesn't have glyph matrices. */
3559 xassert (FRAME_WINDOW_P (XFRAME (WINDOW_FRAME (w))));
3560 #endif
3562 /* Check pending input the first time so that we can quickly return. */
3563 #if !PERIODIC_PREEMPTION_CHECKING
3564 if (!force_p)
3565 detect_input_pending_ignore_squeezables ();
3566 #endif
3568 /* If forced to complete the update, or if no input is pending, do
3569 the update. */
3570 if (force_p || !input_pending || !NILP (do_mouse_tracking))
3572 struct glyph_row *row, *end;
3573 struct glyph_row *mode_line_row;
3574 struct glyph_row *header_line_row;
3575 int yb, changed_p = 0, mouse_face_overwritten_p = 0;
3576 #if ! PERIODIC_PREEMPTION_CHECKING
3577 int n_updated = 0;
3578 #endif
3580 rif->update_window_begin_hook (w);
3581 yb = window_text_bottom_y (w);
3582 row = desired_matrix->rows;
3583 end = row + desired_matrix->nrows - 1;
3585 /* Take note of the header line, if there is one. We will
3586 update it below, after updating all of the window's lines. */
3587 if (row->mode_line_p)
3589 header_line_row = row;
3590 ++row;
3592 else
3593 header_line_row = NULL;
3595 /* Update the mode line, if necessary. */
3596 mode_line_row = MATRIX_MODE_LINE_ROW (desired_matrix);
3597 if (mode_line_row->mode_line_p && mode_line_row->enabled_p)
3599 mode_line_row->y = yb;
3600 update_window_line (w, MATRIX_ROW_VPOS (mode_line_row,
3601 desired_matrix),
3602 &mouse_face_overwritten_p);
3605 /* Find first enabled row. Optimizations in redisplay_internal
3606 may lead to an update with only one row enabled. There may
3607 be also completely empty matrices. */
3608 while (row < end && !row->enabled_p)
3609 ++row;
3611 /* Try reusing part of the display by copying. */
3612 if (row < end && !desired_matrix->no_scrolling_p)
3614 int rc = scrolling_window (w, header_line_row != NULL);
3615 if (rc < 0)
3617 /* All rows were found to be equal. */
3618 paused_p = 0;
3619 goto set_cursor;
3621 else if (rc > 0)
3623 /* We've scrolled the display. */
3624 force_p = 1;
3625 changed_p = 1;
3629 /* Update the rest of the lines. */
3630 for (; row < end && (force_p || !input_pending); ++row)
3631 /* scrolling_window resets the enabled_p flag of the rows it
3632 reuses from current_matrix. */
3633 if (row->enabled_p)
3635 int vpos = MATRIX_ROW_VPOS (row, desired_matrix);
3636 int i;
3638 /* We'll have to play a little bit with when to
3639 detect_input_pending. If it's done too often,
3640 scrolling large windows with repeated scroll-up
3641 commands will too quickly pause redisplay. */
3642 #if PERIODIC_PREEMPTION_CHECKING
3643 if (!force_p)
3645 EMACS_TIME tm, dif;
3646 EMACS_GET_TIME (tm);
3647 EMACS_SUB_TIME (dif, preemption_next_check, tm);
3648 if (EMACS_TIME_NEG_P (dif))
3650 EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
3651 if (detect_input_pending_ignore_squeezables ())
3652 break;
3655 #else
3656 if (!force_p && ++n_updated % preempt_count == 0)
3657 detect_input_pending_ignore_squeezables ();
3658 #endif
3659 changed_p |= update_window_line (w, vpos,
3660 &mouse_face_overwritten_p);
3662 /* Mark all rows below the last visible one in the current
3663 matrix as invalid. This is necessary because of
3664 variable line heights. Consider the case of three
3665 successive redisplays, where the first displays 5
3666 lines, the second 3 lines, and the third 5 lines again.
3667 If the second redisplay wouldn't mark rows in the
3668 current matrix invalid, the third redisplay might be
3669 tempted to optimize redisplay based on lines displayed
3670 in the first redisplay. */
3671 if (MATRIX_ROW_BOTTOM_Y (row) >= yb)
3672 for (i = vpos + 1; i < w->current_matrix->nrows - 1; ++i)
3673 MATRIX_ROW (w->current_matrix, i)->enabled_p = 0;
3676 /* Was display preempted? */
3677 paused_p = row < end;
3679 set_cursor:
3681 /* Update the header line after scrolling because a new header
3682 line would otherwise overwrite lines at the top of the window
3683 that can be scrolled. */
3684 if (header_line_row && header_line_row->enabled_p)
3686 header_line_row->y = 0;
3687 update_window_line (w, 0, &mouse_face_overwritten_p);
3690 /* Fix the appearance of overlapping/overlapped rows. */
3691 if (!paused_p && !w->pseudo_window_p)
3693 #ifdef HAVE_WINDOW_SYSTEM
3694 if (changed_p && rif->fix_overlapping_area)
3696 redraw_overlapped_rows (w, yb);
3697 redraw_overlapping_rows (w, yb);
3699 #endif
3701 /* Make cursor visible at cursor position of W. */
3702 set_window_cursor_after_update (w);
3704 #if 0 /* Check that current matrix invariants are satisfied. This is
3705 for debugging only. See the comment of check_matrix_invariants. */
3706 IF_DEBUG (check_matrix_invariants (w));
3707 #endif
3710 #if GLYPH_DEBUG
3711 /* Remember the redisplay method used to display the matrix. */
3712 strcpy (w->current_matrix->method, w->desired_matrix->method);
3713 #endif
3715 #ifdef HAVE_WINDOW_SYSTEM
3716 update_window_fringes (w, 0);
3717 #endif
3719 /* End the update of window W. Don't set the cursor if we
3720 paused updating the display because in this case,
3721 set_window_cursor_after_update hasn't been called, and
3722 output_cursor doesn't contain the cursor location. */
3723 rif->update_window_end_hook (w, !paused_p, mouse_face_overwritten_p);
3725 else
3726 paused_p = 1;
3728 #if GLYPH_DEBUG
3729 /* check_current_matrix_flags (w); */
3730 add_window_display_history (w, w->current_matrix->method, paused_p);
3731 #endif
3733 clear_glyph_matrix (desired_matrix);
3735 return paused_p;
3739 /* Update the display of area AREA in window W, row number VPOS.
3740 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3742 static void
3743 update_marginal_area (struct window *w, int area, int vpos)
3745 struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
3746 struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
3748 /* Let functions in xterm.c know what area subsequent X positions
3749 will be relative to. */
3750 updated_area = area;
3752 /* Set cursor to start of glyphs, write them, and clear to the end
3753 of the area. I don't think that something more sophisticated is
3754 necessary here, since marginal areas will not be the default. */
3755 rif->cursor_to (vpos, 0, desired_row->y, 0);
3756 if (desired_row->used[area])
3757 rif->write_glyphs (desired_row->glyphs[area], desired_row->used[area]);
3758 rif->clear_end_of_line (-1);
3762 /* Update the display of the text area of row VPOS in window W.
3763 Value is non-zero if display has changed. */
3765 static int
3766 update_text_area (struct window *w, int vpos)
3768 struct glyph_row *current_row = MATRIX_ROW (w->current_matrix, vpos);
3769 struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
3770 struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
3771 int changed_p = 0;
3773 /* Let functions in xterm.c know what area subsequent X positions
3774 will be relative to. */
3775 updated_area = TEXT_AREA;
3777 /* If rows are at different X or Y, or rows have different height,
3778 or the current row is marked invalid, write the entire line. */
3779 if (!current_row->enabled_p
3780 || desired_row->y != current_row->y
3781 || desired_row->ascent != current_row->ascent
3782 || desired_row->phys_ascent != current_row->phys_ascent
3783 || desired_row->phys_height != current_row->phys_height
3784 || desired_row->visible_height != current_row->visible_height
3785 || current_row->overlapped_p
3786 /* This next line is necessary for correctly redrawing
3787 mouse-face areas after scrolling and other operations.
3788 However, it causes excessive flickering when mouse is moved
3789 across the mode line. Luckily, turning it off for the mode
3790 line doesn't seem to hurt anything. -- cyd.
3791 But it is still needed for the header line. -- kfs. */
3792 || (current_row->mouse_face_p
3793 && !(current_row->mode_line_p && vpos > 0))
3794 || current_row->x != desired_row->x)
3796 rif->cursor_to (vpos, 0, desired_row->y, desired_row->x);
3798 if (desired_row->used[TEXT_AREA])
3799 rif->write_glyphs (desired_row->glyphs[TEXT_AREA],
3800 desired_row->used[TEXT_AREA]);
3802 /* Clear to end of window. */
3803 rif->clear_end_of_line (-1);
3804 changed_p = 1;
3806 /* This erases the cursor. We do this here because
3807 notice_overwritten_cursor cannot easily check this, which
3808 might indicate that the whole functionality of
3809 notice_overwritten_cursor would better be implemented here.
3810 On the other hand, we need notice_overwritten_cursor as long
3811 as mouse highlighting is done asynchronously outside of
3812 redisplay. */
3813 if (vpos == w->phys_cursor.vpos)
3814 w->phys_cursor_on_p = 0;
3816 else
3818 int stop, i, x;
3819 struct glyph *current_glyph = current_row->glyphs[TEXT_AREA];
3820 struct glyph *desired_glyph = desired_row->glyphs[TEXT_AREA];
3821 int overlapping_glyphs_p = current_row->contains_overlapping_glyphs_p;
3822 int desired_stop_pos = desired_row->used[TEXT_AREA];
3823 int abort_skipping = 0;
3825 /* If the desired row extends its face to the text area end, and
3826 unless the current row also does so at the same position,
3827 make sure we write at least one glyph, so that the face
3828 extension actually takes place. */
3829 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row)
3830 && (desired_stop_pos < current_row->used[TEXT_AREA]
3831 || (desired_stop_pos == current_row->used[TEXT_AREA]
3832 && !MATRIX_ROW_EXTENDS_FACE_P (current_row))))
3833 --desired_stop_pos;
3835 stop = min (current_row->used[TEXT_AREA], desired_stop_pos);
3836 i = 0;
3837 x = desired_row->x;
3839 /* Loop over glyphs that current and desired row may have
3840 in common. */
3841 while (i < stop)
3843 int can_skip_p = !abort_skipping;
3845 /* Skip over glyphs that both rows have in common. These
3846 don't have to be written. We can't skip if the last
3847 current glyph overlaps the glyph to its right. For
3848 example, consider a current row of `if ' with the `f' in
3849 Courier bold so that it overlaps the ` ' to its right.
3850 If the desired row is ` ', we would skip over the space
3851 after the `if' and there would remain a pixel from the
3852 `f' on the screen. */
3853 if (overlapping_glyphs_p && i > 0)
3855 struct glyph *glyph = &current_row->glyphs[TEXT_AREA][i - 1];
3856 int left, right;
3858 rif->get_glyph_overhangs (glyph, XFRAME (w->frame),
3859 &left, &right);
3860 can_skip_p = (right == 0 && !abort_skipping);
3863 if (can_skip_p)
3865 int start_hpos = i;
3867 while (i < stop
3868 && GLYPH_EQUAL_P (desired_glyph, current_glyph))
3870 x += desired_glyph->pixel_width;
3871 ++desired_glyph, ++current_glyph, ++i;
3874 /* Consider the case that the current row contains "xxx
3875 ppp ggg" in italic Courier font, and the desired row
3876 is "xxx ggg". The character `p' has lbearing, `g'
3877 has not. The loop above will stop in front of the
3878 first `p' in the current row. If we would start
3879 writing glyphs there, we wouldn't erase the lbearing
3880 of the `p'. The rest of the lbearing problem is then
3881 taken care of by draw_glyphs. */
3882 if (overlapping_glyphs_p
3883 && i > 0
3884 && i < current_row->used[TEXT_AREA]
3885 && (current_row->used[TEXT_AREA]
3886 != desired_row->used[TEXT_AREA]))
3888 int left, right;
3890 rif->get_glyph_overhangs (current_glyph, XFRAME (w->frame),
3891 &left, &right);
3892 while (left > 0 && i > 0)
3894 --i, --desired_glyph, --current_glyph;
3895 x -= desired_glyph->pixel_width;
3896 left -= desired_glyph->pixel_width;
3899 /* Abort the skipping algorithm if we end up before
3900 our starting point, to avoid looping (bug#1070).
3901 This can happen when the lbearing is larger than
3902 the pixel width. */
3903 abort_skipping = (i < start_hpos);
3907 /* Try to avoid writing the entire rest of the desired row
3908 by looking for a resync point. This mainly prevents
3909 mode line flickering in the case the mode line is in
3910 fixed-pitch font, which it usually will be. */
3911 if (i < desired_row->used[TEXT_AREA])
3913 int start_x = x, start_hpos = i;
3914 struct glyph *start = desired_glyph;
3915 int current_x = x;
3916 int skip_first_p = !can_skip_p;
3918 /* Find the next glyph that's equal again. */
3919 while (i < stop
3920 && (skip_first_p
3921 || !GLYPH_EQUAL_P (desired_glyph, current_glyph))
3922 && x == current_x)
3924 x += desired_glyph->pixel_width;
3925 current_x += current_glyph->pixel_width;
3926 ++desired_glyph, ++current_glyph, ++i;
3927 skip_first_p = 0;
3930 if (i == start_hpos || x != current_x)
3932 i = start_hpos;
3933 x = start_x;
3934 desired_glyph = start;
3935 break;
3938 rif->cursor_to (vpos, start_hpos, desired_row->y, start_x);
3939 rif->write_glyphs (start, i - start_hpos);
3940 changed_p = 1;
3944 /* Write the rest. */
3945 if (i < desired_row->used[TEXT_AREA])
3947 rif->cursor_to (vpos, i, desired_row->y, x);
3948 rif->write_glyphs (desired_glyph, desired_row->used[TEXT_AREA] - i);
3949 changed_p = 1;
3952 /* Maybe clear to end of line. */
3953 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row))
3955 /* If new row extends to the end of the text area, nothing
3956 has to be cleared, if and only if we did a write_glyphs
3957 above. This is made sure by setting desired_stop_pos
3958 appropriately above. */
3959 xassert (i < desired_row->used[TEXT_AREA]
3960 || ((desired_row->used[TEXT_AREA]
3961 == current_row->used[TEXT_AREA])
3962 && MATRIX_ROW_EXTENDS_FACE_P (current_row)));
3964 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row))
3966 /* If old row extends to the end of the text area, clear. */
3967 if (i >= desired_row->used[TEXT_AREA])
3968 rif->cursor_to (vpos, i, desired_row->y,
3969 desired_row->pixel_width);
3970 rif->clear_end_of_line (-1);
3971 changed_p = 1;
3973 else if (desired_row->pixel_width < current_row->pixel_width)
3975 /* Otherwise clear to the end of the old row. Everything
3976 after that position should be clear already. */
3977 int xlim;
3979 if (i >= desired_row->used[TEXT_AREA])
3980 rif->cursor_to (vpos, i, desired_row->y,
3981 desired_row->pixel_width);
3983 /* If cursor is displayed at the end of the line, make sure
3984 it's cleared. Nowadays we don't have a phys_cursor_glyph
3985 with which to erase the cursor (because this method
3986 doesn't work with lbearing/rbearing), so we must do it
3987 this way. */
3988 if (vpos == w->phys_cursor.vpos
3989 && (desired_row->reversed_p
3990 ? (w->phys_cursor.hpos < 0)
3991 : (w->phys_cursor.hpos >= desired_row->used[TEXT_AREA])))
3993 w->phys_cursor_on_p = 0;
3994 xlim = -1;
3996 else
3997 xlim = current_row->pixel_width;
3998 rif->clear_end_of_line (xlim);
3999 changed_p = 1;
4003 return changed_p;
4007 /* Update row VPOS in window W. Value is non-zero if display has been
4008 changed. */
4010 static int
4011 update_window_line (struct window *w, int vpos, int *mouse_face_overwritten_p)
4013 struct glyph_row *current_row = MATRIX_ROW (w->current_matrix, vpos);
4014 struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
4015 struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
4016 int changed_p = 0;
4018 /* Set the row being updated. This is important to let xterm.c
4019 know what line height values are in effect. */
4020 updated_row = desired_row;
4022 /* A row can be completely invisible in case a desired matrix was
4023 built with a vscroll and then make_cursor_line_fully_visible shifts
4024 the matrix. Make sure to make such rows current anyway, since
4025 we need the correct y-position, for example, in the current matrix. */
4026 if (desired_row->mode_line_p
4027 || desired_row->visible_height > 0)
4029 xassert (desired_row->enabled_p);
4031 /* Update display of the left margin area, if there is one. */
4032 if (!desired_row->full_width_p
4033 && !NILP (w->left_margin_cols))
4035 changed_p = 1;
4036 update_marginal_area (w, LEFT_MARGIN_AREA, vpos);
4039 /* Update the display of the text area. */
4040 if (update_text_area (w, vpos))
4042 changed_p = 1;
4043 if (current_row->mouse_face_p)
4044 *mouse_face_overwritten_p = 1;
4047 /* Update display of the right margin area, if there is one. */
4048 if (!desired_row->full_width_p
4049 && !NILP (w->right_margin_cols))
4051 changed_p = 1;
4052 update_marginal_area (w, RIGHT_MARGIN_AREA, vpos);
4055 /* Draw truncation marks etc. */
4056 if (!current_row->enabled_p
4057 || desired_row->y != current_row->y
4058 || desired_row->visible_height != current_row->visible_height
4059 || desired_row->cursor_in_fringe_p != current_row->cursor_in_fringe_p
4060 || desired_row->overlay_arrow_bitmap != current_row->overlay_arrow_bitmap
4061 || current_row->redraw_fringe_bitmaps_p
4062 || desired_row->mode_line_p != current_row->mode_line_p
4063 || desired_row->exact_window_width_line_p != current_row->exact_window_width_line_p
4064 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row)
4065 != MATRIX_ROW_CONTINUATION_LINE_P (current_row)))
4066 rif->after_update_window_line_hook (desired_row);
4069 /* Update current_row from desired_row. */
4070 make_current (w->desired_matrix, w->current_matrix, vpos);
4071 updated_row = NULL;
4072 return changed_p;
4076 /* Set the cursor after an update of window W. This function may only
4077 be called from update_window. */
4079 static void
4080 set_window_cursor_after_update (struct window *w)
4082 struct frame *f = XFRAME (w->frame);
4083 struct redisplay_interface *rif = FRAME_RIF (f);
4084 int cx, cy, vpos, hpos;
4086 /* Not intended for frame matrix updates. */
4087 xassert (FRAME_WINDOW_P (f));
4089 if (cursor_in_echo_area
4090 && !NILP (echo_area_buffer[0])
4091 /* If we are showing a message instead of the mini-buffer,
4092 show the cursor for the message instead. */
4093 && XWINDOW (minibuf_window) == w
4094 && EQ (minibuf_window, echo_area_window)
4095 /* These cases apply only to the frame that contains
4096 the active mini-buffer window. */
4097 && FRAME_HAS_MINIBUF_P (f)
4098 && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
4100 cx = cy = vpos = hpos = 0;
4102 if (cursor_in_echo_area >= 0)
4104 /* If the mini-buffer is several lines high, find the last
4105 line that has any text on it. Note: either all lines
4106 are enabled or none. Otherwise we wouldn't be able to
4107 determine Y. */
4108 struct glyph_row *row, *last_row;
4109 struct glyph *glyph;
4110 int yb = window_text_bottom_y (w);
4112 last_row = NULL;
4113 row = w->current_matrix->rows;
4114 while (row->enabled_p
4115 && (last_row == NULL
4116 || MATRIX_ROW_BOTTOM_Y (row) <= yb))
4118 if (row->used[TEXT_AREA]
4119 && row->glyphs[TEXT_AREA][0].charpos >= 0)
4120 last_row = row;
4121 ++row;
4124 if (last_row)
4126 struct glyph *start = last_row->glyphs[TEXT_AREA];
4127 struct glyph *last = start + last_row->used[TEXT_AREA] - 1;
4129 while (last > start && last->charpos < 0)
4130 --last;
4132 for (glyph = start; glyph < last; ++glyph)
4134 cx += glyph->pixel_width;
4135 ++hpos;
4138 cy = last_row->y;
4139 vpos = MATRIX_ROW_VPOS (last_row, w->current_matrix);
4143 else
4145 cx = w->cursor.x;
4146 cy = w->cursor.y;
4147 hpos = w->cursor.hpos;
4148 vpos = w->cursor.vpos;
4151 /* Window cursor can be out of sync for horizontally split windows. */
4152 hpos = max (-1, hpos); /* -1 is for when cursor is on the left fringe */
4153 hpos = min (w->current_matrix->matrix_w - 1, hpos);
4154 vpos = max (0, vpos);
4155 vpos = min (w->current_matrix->nrows - 1, vpos);
4156 rif->cursor_to (vpos, hpos, cy, cx);
4160 /* Set WINDOW->must_be_updated_p to ON_P for all windows in the window
4161 tree rooted at W. */
4163 void
4164 set_window_update_flags (struct window *w, int on_p)
4166 while (w)
4168 if (!NILP (w->hchild))
4169 set_window_update_flags (XWINDOW (w->hchild), on_p);
4170 else if (!NILP (w->vchild))
4171 set_window_update_flags (XWINDOW (w->vchild), on_p);
4172 else
4173 w->must_be_updated_p = on_p;
4175 w = NILP (w->next) ? 0 : XWINDOW (w->next);
4181 /***********************************************************************
4182 Window-Based Scrolling
4183 ***********************************************************************/
4185 /* Structure describing rows in scrolling_window. */
4187 struct row_entry
4189 /* Number of occurrences of this row in desired and current matrix. */
4190 int old_uses, new_uses;
4192 /* Vpos of row in new matrix. */
4193 int new_line_number;
4195 /* Bucket index of this row_entry in the hash table row_table. */
4196 ptrdiff_t bucket;
4198 /* The row described by this entry. */
4199 struct glyph_row *row;
4201 /* Hash collision chain. */
4202 struct row_entry *next;
4205 /* A pool to allocate row_entry structures from, and the size of the
4206 pool. The pool is reallocated in scrolling_window when we find
4207 that we need a larger one. */
4209 static struct row_entry *row_entry_pool;
4210 static ptrdiff_t row_entry_pool_size;
4212 /* Index of next free entry in row_entry_pool. */
4214 static ptrdiff_t row_entry_idx;
4216 /* The hash table used during scrolling, and the table's size. This
4217 table is used to quickly identify equal rows in the desired and
4218 current matrix. */
4220 static struct row_entry **row_table;
4221 static ptrdiff_t row_table_size;
4223 /* Vectors of pointers to row_entry structures belonging to the
4224 current and desired matrix, and the size of the vectors. */
4226 static struct row_entry **old_lines, **new_lines;
4227 static ptrdiff_t old_lines_size, new_lines_size;
4229 /* A pool to allocate run structures from, and its size. */
4231 static struct run *run_pool;
4232 static ptrdiff_t runs_size;
4234 /* A vector of runs of lines found during scrolling. */
4236 static struct run **runs;
4238 /* Add glyph row ROW to the scrolling hash table. */
4240 static inline struct row_entry *
4241 add_row_entry (struct glyph_row *row)
4243 struct row_entry *entry;
4244 ptrdiff_t i = row->hash % row_table_size;
4246 entry = row_table[i];
4247 xassert (entry || verify_row_hash (row));
4248 while (entry && !row_equal_p (entry->row, row, 1))
4249 entry = entry->next;
4251 if (entry == NULL)
4253 entry = row_entry_pool + row_entry_idx++;
4254 entry->row = row;
4255 entry->old_uses = entry->new_uses = 0;
4256 entry->new_line_number = 0;
4257 entry->bucket = i;
4258 entry->next = row_table[i];
4259 row_table[i] = entry;
4262 return entry;
4266 /* Try to reuse part of the current display of W by scrolling lines.
4267 HEADER_LINE_P non-zero means W has a header line.
4269 The algorithm is taken from Communications of the ACM, Apr78 "A
4270 Technique for Isolating Differences Between Files." It should take
4271 O(N) time.
4273 A short outline of the steps of the algorithm
4275 1. Skip lines equal at the start and end of both matrices.
4277 2. Enter rows in the current and desired matrix into a symbol
4278 table, counting how often they appear in both matrices.
4280 3. Rows that appear exactly once in both matrices serve as anchors,
4281 i.e. we assume that such lines are likely to have been moved.
4283 4. Starting from anchor lines, extend regions to be scrolled both
4284 forward and backward.
4286 Value is
4288 -1 if all rows were found to be equal.
4289 0 to indicate that we did not scroll the display, or
4290 1 if we did scroll. */
4292 static int
4293 scrolling_window (struct window *w, int header_line_p)
4295 struct glyph_matrix *desired_matrix = w->desired_matrix;
4296 struct glyph_matrix *current_matrix = w->current_matrix;
4297 int yb = window_text_bottom_y (w);
4298 ptrdiff_t i;
4299 int j, first_old, first_new, last_old, last_new;
4300 int nruns, run_idx;
4301 ptrdiff_t n;
4302 struct row_entry *entry;
4303 struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
4305 /* Skip over rows equal at the start. */
4306 for (i = header_line_p ? 1 : 0; i < current_matrix->nrows - 1; ++i)
4308 struct glyph_row *d = MATRIX_ROW (desired_matrix, i);
4309 struct glyph_row *c = MATRIX_ROW (current_matrix, i);
4311 if (c->enabled_p
4312 && d->enabled_p
4313 && !d->redraw_fringe_bitmaps_p
4314 && c->y == d->y
4315 && MATRIX_ROW_BOTTOM_Y (c) <= yb
4316 && MATRIX_ROW_BOTTOM_Y (d) <= yb
4317 && row_equal_p (c, d, 1))
4319 assign_row (c, d);
4320 d->enabled_p = 0;
4322 else
4323 break;
4326 /* Give up if some rows in the desired matrix are not enabled. */
4327 if (!MATRIX_ROW (desired_matrix, i)->enabled_p)
4328 return -1;
4330 first_old = first_new = i;
4332 /* Set last_new to the index + 1 of the row that reaches the
4333 bottom boundary in the desired matrix. Give up if we find a
4334 disabled row before we reach the bottom boundary. */
4335 i = first_new + 1;
4336 while (i < desired_matrix->nrows - 1)
4338 int bottom;
4340 if (!MATRIX_ROW (desired_matrix, i)->enabled_p)
4341 return 0;
4342 bottom = MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix, i));
4343 if (bottom <= yb)
4344 ++i;
4345 if (bottom >= yb)
4346 break;
4349 last_new = i;
4351 /* Set last_old to the index + 1 of the row that reaches the bottom
4352 boundary in the current matrix. We don't look at the enabled
4353 flag here because we plan to reuse part of the display even if
4354 other parts are disabled. */
4355 i = first_old + 1;
4356 while (i < current_matrix->nrows - 1)
4358 int bottom = MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix, i));
4359 if (bottom <= yb)
4360 ++i;
4361 if (bottom >= yb)
4362 break;
4365 last_old = i;
4367 /* Skip over rows equal at the bottom. */
4368 i = last_new;
4369 j = last_old;
4370 while (i - 1 > first_new
4371 && j - 1 > first_old
4372 && MATRIX_ROW (current_matrix, j - 1)->enabled_p
4373 && (MATRIX_ROW (current_matrix, j - 1)->y
4374 == MATRIX_ROW (desired_matrix, i - 1)->y)
4375 && !MATRIX_ROW (desired_matrix, i - 1)->redraw_fringe_bitmaps_p
4376 && row_equal_p (MATRIX_ROW (desired_matrix, i - 1),
4377 MATRIX_ROW (current_matrix, j - 1), 1))
4378 --i, --j;
4379 last_new = i;
4380 last_old = j;
4382 /* Nothing to do if all rows are equal. */
4383 if (last_new == first_new)
4384 return 0;
4386 /* Check for integer overflow in size calculation.
4388 If next_almost_prime checks (N) for divisibility by 2..10, then
4389 it can return at most N + 10, e.g., next_almost_prime (1) == 11.
4390 So, set next_almost_prime_increment_max to 10.
4392 It's just a coincidence that next_almost_prime_increment_max ==
4393 NEXT_ALMOST_PRIME_LIMIT - 1. If NEXT_ALMOST_PRIME_LIMIT were
4394 13, then next_almost_prime_increment_max would be 14, e.g.,
4395 because next_almost_prime (113) would be 127. */
4397 verify (NEXT_ALMOST_PRIME_LIMIT == 11);
4398 enum { next_almost_prime_increment_max = 10 };
4399 ptrdiff_t row_table_max =
4400 (min (PTRDIFF_MAX, SIZE_MAX) / (3 * sizeof *row_table)
4401 - next_almost_prime_increment_max);
4402 ptrdiff_t current_nrows_max = row_table_max - desired_matrix->nrows;
4403 if (current_nrows_max < current_matrix->nrows)
4404 memory_full (SIZE_MAX);
4407 /* Reallocate vectors, tables etc. if necessary. */
4409 if (current_matrix->nrows > old_lines_size)
4410 old_lines = xpalloc (old_lines, &old_lines_size,
4411 current_matrix->nrows - old_lines_size,
4412 INT_MAX, sizeof *old_lines);
4414 if (desired_matrix->nrows > new_lines_size)
4415 new_lines = xpalloc (new_lines, &new_lines_size,
4416 desired_matrix->nrows - new_lines_size,
4417 INT_MAX, sizeof *new_lines);
4419 n = desired_matrix->nrows;
4420 n += current_matrix->nrows;
4421 if (row_table_size < 3 * n)
4423 ptrdiff_t size = next_almost_prime (3 * n);
4424 row_table = xnrealloc (row_table, size, sizeof *row_table);
4425 row_table_size = size;
4426 memset (row_table, 0, size * sizeof *row_table);
4429 if (n > row_entry_pool_size)
4430 row_entry_pool = xpalloc (row_entry_pool, &row_entry_pool_size,
4431 n - row_entry_pool_size,
4432 -1, sizeof *row_entry_pool);
4434 if (desired_matrix->nrows > runs_size)
4436 runs = xnrealloc (runs, desired_matrix->nrows, sizeof *runs);
4437 run_pool = xnrealloc (run_pool, desired_matrix->nrows, sizeof *run_pool);
4438 runs_size = desired_matrix->nrows;
4441 nruns = run_idx = 0;
4442 row_entry_idx = 0;
4444 /* Add rows from the current and desired matrix to the hash table
4445 row_hash_table to be able to find equal ones quickly. */
4447 for (i = first_old; i < last_old; ++i)
4449 if (MATRIX_ROW (current_matrix, i)->enabled_p)
4451 entry = add_row_entry (MATRIX_ROW (current_matrix, i));
4452 old_lines[i] = entry;
4453 ++entry->old_uses;
4455 else
4456 old_lines[i] = NULL;
4459 for (i = first_new; i < last_new; ++i)
4461 xassert (MATRIX_ROW_ENABLED_P (desired_matrix, i));
4462 entry = add_row_entry (MATRIX_ROW (desired_matrix, i));
4463 ++entry->new_uses;
4464 entry->new_line_number = i;
4465 new_lines[i] = entry;
4468 /* Identify moves based on lines that are unique and equal
4469 in both matrices. */
4470 for (i = first_old; i < last_old;)
4471 if (old_lines[i]
4472 && old_lines[i]->old_uses == 1
4473 && old_lines[i]->new_uses == 1)
4475 int p, q;
4476 int new_line = old_lines[i]->new_line_number;
4477 struct run *run = run_pool + run_idx++;
4479 /* Record move. */
4480 run->current_vpos = i;
4481 run->current_y = MATRIX_ROW (current_matrix, i)->y;
4482 run->desired_vpos = new_line;
4483 run->desired_y = MATRIX_ROW (desired_matrix, new_line)->y;
4484 run->nrows = 1;
4485 run->height = MATRIX_ROW (current_matrix, i)->height;
4487 /* Extend backward. */
4488 p = i - 1;
4489 q = new_line - 1;
4490 while (p > first_old
4491 && q > first_new
4492 && old_lines[p] == new_lines[q])
4494 int h = MATRIX_ROW (current_matrix, p)->height;
4495 --run->current_vpos;
4496 --run->desired_vpos;
4497 ++run->nrows;
4498 run->height += h;
4499 run->desired_y -= h;
4500 run->current_y -= h;
4501 --p, --q;
4504 /* Extend forward. */
4505 p = i + 1;
4506 q = new_line + 1;
4507 while (p < last_old
4508 && q < last_new
4509 && old_lines[p] == new_lines[q])
4511 int h = MATRIX_ROW (current_matrix, p)->height;
4512 ++run->nrows;
4513 run->height += h;
4514 ++p, ++q;
4517 /* Insert run into list of all runs. Order runs by copied
4518 pixel lines. Note that we record runs that don't have to
4519 be copied because they are already in place. This is done
4520 because we can avoid calling update_window_line in this
4521 case. */
4522 for (p = 0; p < nruns && runs[p]->height > run->height; ++p)
4524 for (q = nruns; q > p; --q)
4525 runs[q] = runs[q - 1];
4526 runs[p] = run;
4527 ++nruns;
4529 i += run->nrows;
4531 else
4532 ++i;
4534 /* Do the moves. Do it in a way that we don't overwrite something
4535 we want to copy later on. This is not solvable in general
4536 because there is only one display and we don't have a way to
4537 exchange areas on this display. Example:
4539 +-----------+ +-----------+
4540 | A | | B |
4541 +-----------+ --> +-----------+
4542 | B | | A |
4543 +-----------+ +-----------+
4545 Instead, prefer bigger moves, and invalidate moves that would
4546 copy from where we copied to. */
4548 for (i = 0; i < nruns; ++i)
4549 if (runs[i]->nrows > 0)
4551 struct run *r = runs[i];
4553 /* Copy on the display. */
4554 if (r->current_y != r->desired_y)
4556 rif->clear_window_mouse_face (w);
4557 rif->scroll_run_hook (w, r);
4560 /* Truncate runs that copy to where we copied to, and
4561 invalidate runs that copy from where we copied to. */
4562 for (j = nruns - 1; j > i; --j)
4564 struct run *p = runs[j];
4565 int truncated_p = 0;
4567 if (p->nrows > 0
4568 && p->desired_y < r->desired_y + r->height
4569 && p->desired_y + p->height > r->desired_y)
4571 if (p->desired_y < r->desired_y)
4573 p->nrows = r->desired_vpos - p->desired_vpos;
4574 p->height = r->desired_y - p->desired_y;
4575 truncated_p = 1;
4577 else
4579 int nrows_copied = (r->desired_vpos + r->nrows
4580 - p->desired_vpos);
4582 if (p->nrows <= nrows_copied)
4583 p->nrows = 0;
4584 else
4586 int height_copied = (r->desired_y + r->height
4587 - p->desired_y);
4589 p->current_vpos += nrows_copied;
4590 p->desired_vpos += nrows_copied;
4591 p->nrows -= nrows_copied;
4592 p->current_y += height_copied;
4593 p->desired_y += height_copied;
4594 p->height -= height_copied;
4595 truncated_p = 1;
4600 if (r->current_y != r->desired_y
4601 /* The condition below is equivalent to
4602 ((p->current_y >= r->desired_y
4603 && p->current_y < r->desired_y + r->height)
4604 || (p->current_y + p->height > r->desired_y
4605 && (p->current_y + p->height
4606 <= r->desired_y + r->height)))
4607 because we have 0 < p->height <= r->height. */
4608 && p->current_y < r->desired_y + r->height
4609 && p->current_y + p->height > r->desired_y)
4610 p->nrows = 0;
4612 /* Reorder runs by copied pixel lines if truncated. */
4613 if (truncated_p && p->nrows > 0)
4615 int k = nruns - 1;
4617 while (runs[k]->nrows == 0 || runs[k]->height < p->height)
4618 k--;
4619 memmove (runs + j, runs + j + 1, (k - j) * sizeof (*runs));
4620 runs[k] = p;
4624 /* Assign matrix rows. */
4625 for (j = 0; j < r->nrows; ++j)
4627 struct glyph_row *from, *to;
4628 int to_overlapped_p;
4630 to = MATRIX_ROW (current_matrix, r->desired_vpos + j);
4631 from = MATRIX_ROW (desired_matrix, r->desired_vpos + j);
4632 to_overlapped_p = to->overlapped_p;
4633 from->redraw_fringe_bitmaps_p = from->fringe_bitmap_periodic_p;
4634 assign_row (to, from);
4635 /* The above `assign_row' actually does swap, so if we had
4636 an overlap in the copy destination of two runs, then
4637 the second run would assign a previously disabled bogus
4638 row. But thanks to the truncation code in the
4639 preceding for-loop, we no longer have such an overlap,
4640 and thus the assigned row should always be enabled. */
4641 xassert (to->enabled_p);
4642 from->enabled_p = 0;
4643 to->overlapped_p = to_overlapped_p;
4647 /* Clear the hash table, for the next time. */
4648 for (i = 0; i < row_entry_idx; ++i)
4649 row_table[row_entry_pool[i].bucket] = NULL;
4651 /* Value is 1 to indicate that we scrolled the display. */
4652 return 0 < nruns;
4657 /************************************************************************
4658 Frame-Based Updates
4659 ************************************************************************/
4661 /* Update the desired frame matrix of frame F.
4663 FORCE_P non-zero means that the update should not be stopped by
4664 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
4665 should not be tried.
4667 Value is non-zero if update was stopped due to pending input. */
4669 static int
4670 update_frame_1 (struct frame *f, int force_p, int inhibit_id_p)
4672 /* Frame matrices to work on. */
4673 struct glyph_matrix *current_matrix = f->current_matrix;
4674 struct glyph_matrix *desired_matrix = f->desired_matrix;
4675 int i;
4676 int pause_p;
4677 int preempt_count = baud_rate / 2400 + 1;
4679 xassert (current_matrix && desired_matrix);
4681 if (baud_rate != FRAME_COST_BAUD_RATE (f))
4682 calculate_costs (f);
4684 if (preempt_count <= 0)
4685 preempt_count = 1;
4687 #if !PERIODIC_PREEMPTION_CHECKING
4688 if (!force_p && detect_input_pending_ignore_squeezables ())
4690 pause_p = 1;
4691 goto do_pause;
4693 #endif
4695 /* If we cannot insert/delete lines, it's no use trying it. */
4696 if (!FRAME_LINE_INS_DEL_OK (f))
4697 inhibit_id_p = 1;
4699 /* See if any of the desired lines are enabled; don't compute for
4700 i/d line if just want cursor motion. */
4701 for (i = 0; i < desired_matrix->nrows; i++)
4702 if (MATRIX_ROW_ENABLED_P (desired_matrix, i))
4703 break;
4705 /* Try doing i/d line, if not yet inhibited. */
4706 if (!inhibit_id_p && i < desired_matrix->nrows)
4707 force_p |= scrolling (f);
4709 /* Update the individual lines as needed. Do bottom line first. */
4710 if (MATRIX_ROW_ENABLED_P (desired_matrix, desired_matrix->nrows - 1))
4711 update_frame_line (f, desired_matrix->nrows - 1);
4713 /* Now update the rest of the lines. */
4714 for (i = 0; i < desired_matrix->nrows - 1 && (force_p || !input_pending); i++)
4716 if (MATRIX_ROW_ENABLED_P (desired_matrix, i))
4718 if (FRAME_TERMCAP_P (f))
4720 /* Flush out every so many lines.
4721 Also flush out if likely to have more than 1k buffered
4722 otherwise. I'm told that some telnet connections get
4723 really screwed by more than 1k output at once. */
4724 FILE *display_output = FRAME_TTY (f)->output;
4725 if (display_output)
4727 int outq = PENDING_OUTPUT_COUNT (display_output);
4728 if (outq > 900
4729 || (outq > 20 && ((i - 1) % preempt_count == 0)))
4731 fflush (display_output);
4732 if (preempt_count == 1)
4734 #ifdef EMACS_OUTQSIZE
4735 if (EMACS_OUTQSIZE (0, &outq) < 0)
4736 /* Probably not a tty. Ignore the error and reset
4737 the outq count. */
4738 outq = PENDING_OUTPUT_COUNT (FRAME_TTY (f->output));
4739 #endif
4740 outq *= 10;
4741 if (baud_rate <= outq && baud_rate > 0)
4742 sleep (outq / baud_rate);
4748 #if PERIODIC_PREEMPTION_CHECKING
4749 if (!force_p)
4751 EMACS_TIME tm, dif;
4752 EMACS_GET_TIME (tm);
4753 EMACS_SUB_TIME (dif, preemption_next_check, tm);
4754 if (EMACS_TIME_NEG_P (dif))
4756 EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
4757 if (detect_input_pending_ignore_squeezables ())
4758 break;
4761 #else
4762 if (!force_p && (i - 1) % preempt_count == 0)
4763 detect_input_pending_ignore_squeezables ();
4764 #endif
4766 update_frame_line (f, i);
4770 pause_p = (i < FRAME_LINES (f) - 1) ? i : 0;
4772 /* Now just clean up termcap drivers and set cursor, etc. */
4773 if (!pause_p)
4775 if ((cursor_in_echo_area
4776 /* If we are showing a message instead of the mini-buffer,
4777 show the cursor for the message instead of for the
4778 (now hidden) mini-buffer contents. */
4779 || (EQ (minibuf_window, selected_window)
4780 && EQ (minibuf_window, echo_area_window)
4781 && !NILP (echo_area_buffer[0])))
4782 /* These cases apply only to the frame that contains
4783 the active mini-buffer window. */
4784 && FRAME_HAS_MINIBUF_P (f)
4785 && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
4787 int top = WINDOW_TOP_EDGE_LINE (XWINDOW (FRAME_MINIBUF_WINDOW (f)));
4788 int row, col;
4790 if (cursor_in_echo_area < 0)
4792 /* Negative value of cursor_in_echo_area means put
4793 cursor at beginning of line. */
4794 row = top;
4795 col = 0;
4797 else
4799 /* Positive value of cursor_in_echo_area means put
4800 cursor at the end of the prompt. If the mini-buffer
4801 is several lines high, find the last line that has
4802 any text on it. */
4803 row = FRAME_LINES (f);
4806 --row;
4807 col = 0;
4809 if (MATRIX_ROW_ENABLED_P (current_matrix, row))
4811 /* Frame rows are filled up with spaces that
4812 must be ignored here. */
4813 struct glyph_row *r = MATRIX_ROW (current_matrix,
4814 row);
4815 struct glyph *start = r->glyphs[TEXT_AREA];
4816 struct glyph *last = start + r->used[TEXT_AREA];
4818 while (last > start
4819 && (last - 1)->charpos < 0)
4820 --last;
4822 col = last - start;
4825 while (row > top && col == 0);
4827 /* Make sure COL is not out of range. */
4828 if (col >= FRAME_CURSOR_X_LIMIT (f))
4830 /* If we have another row, advance cursor into it. */
4831 if (row < FRAME_LINES (f) - 1)
4833 col = FRAME_LEFT_SCROLL_BAR_COLS (f);
4834 row++;
4836 /* Otherwise move it back in range. */
4837 else
4838 col = FRAME_CURSOR_X_LIMIT (f) - 1;
4842 cursor_to (f, row, col);
4844 else
4846 /* We have only one cursor on terminal frames. Use it to
4847 display the cursor of the selected window. */
4848 struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
4849 if (w->cursor.vpos >= 0
4850 /* The cursor vpos may be temporarily out of bounds
4851 in the following situation: There is one window,
4852 with the cursor in the lower half of it. The window
4853 is split, and a message causes a redisplay before
4854 a new cursor position has been computed. */
4855 && w->cursor.vpos < WINDOW_TOTAL_LINES (w))
4857 int x = WINDOW_TO_FRAME_HPOS (w, w->cursor.hpos);
4858 int y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
4860 if (INTEGERP (w->left_margin_cols))
4861 x += XFASTINT (w->left_margin_cols);
4863 /* x = max (min (x, FRAME_TOTAL_COLS (f) - 1), 0); */
4864 cursor_to (f, y, x);
4869 #if !PERIODIC_PREEMPTION_CHECKING
4870 do_pause:
4871 #endif
4873 clear_desired_matrices (f);
4874 return pause_p;
4878 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4880 static int
4881 scrolling (struct frame *frame)
4883 int unchanged_at_top, unchanged_at_bottom;
4884 int window_size;
4885 int changed_lines;
4886 int *old_hash = (int *) alloca (FRAME_LINES (frame) * sizeof (int));
4887 int *new_hash = (int *) alloca (FRAME_LINES (frame) * sizeof (int));
4888 int *draw_cost = (int *) alloca (FRAME_LINES (frame) * sizeof (int));
4889 int *old_draw_cost = (int *) alloca (FRAME_LINES (frame) * sizeof (int));
4890 register int i;
4891 int free_at_end_vpos = FRAME_LINES (frame);
4892 struct glyph_matrix *current_matrix = frame->current_matrix;
4893 struct glyph_matrix *desired_matrix = frame->desired_matrix;
4895 if (!current_matrix)
4896 abort ();
4898 /* Compute hash codes of all the lines. Also calculate number of
4899 changed lines, number of unchanged lines at the beginning, and
4900 number of unchanged lines at the end. */
4901 changed_lines = 0;
4902 unchanged_at_top = 0;
4903 unchanged_at_bottom = FRAME_LINES (frame);
4904 for (i = 0; i < FRAME_LINES (frame); i++)
4906 /* Give up on this scrolling if some old lines are not enabled. */
4907 if (!MATRIX_ROW_ENABLED_P (current_matrix, i))
4908 return 0;
4909 old_hash[i] = line_hash_code (MATRIX_ROW (current_matrix, i));
4910 if (! MATRIX_ROW_ENABLED_P (desired_matrix, i))
4912 /* This line cannot be redrawn, so don't let scrolling mess it. */
4913 new_hash[i] = old_hash[i];
4914 #define INFINITY 1000000 /* Taken from scroll.c */
4915 draw_cost[i] = INFINITY;
4917 else
4919 new_hash[i] = line_hash_code (MATRIX_ROW (desired_matrix, i));
4920 draw_cost[i] = line_draw_cost (desired_matrix, i);
4923 if (old_hash[i] != new_hash[i])
4925 changed_lines++;
4926 unchanged_at_bottom = FRAME_LINES (frame) - i - 1;
4928 else if (i == unchanged_at_top)
4929 unchanged_at_top++;
4930 old_draw_cost[i] = line_draw_cost (current_matrix, i);
4933 /* If changed lines are few, don't allow preemption, don't scroll. */
4934 if ((!FRAME_SCROLL_REGION_OK (frame)
4935 && changed_lines < baud_rate / 2400)
4936 || unchanged_at_bottom == FRAME_LINES (frame))
4937 return 1;
4939 window_size = (FRAME_LINES (frame) - unchanged_at_top
4940 - unchanged_at_bottom);
4942 if (FRAME_SCROLL_REGION_OK (frame))
4943 free_at_end_vpos -= unchanged_at_bottom;
4944 else if (FRAME_MEMORY_BELOW_FRAME (frame))
4945 free_at_end_vpos = -1;
4947 /* If large window, fast terminal and few lines in common between
4948 current frame and desired frame, don't bother with i/d calc. */
4949 if (!FRAME_SCROLL_REGION_OK (frame)
4950 && window_size >= 18 && baud_rate > 2400
4951 && (window_size >=
4952 10 * scrolling_max_lines_saved (unchanged_at_top,
4953 FRAME_LINES (frame) - unchanged_at_bottom,
4954 old_hash, new_hash, draw_cost)))
4955 return 0;
4957 if (window_size < 2)
4958 return 0;
4960 scrolling_1 (frame, window_size, unchanged_at_top, unchanged_at_bottom,
4961 draw_cost + unchanged_at_top - 1,
4962 old_draw_cost + unchanged_at_top - 1,
4963 old_hash + unchanged_at_top - 1,
4964 new_hash + unchanged_at_top - 1,
4965 free_at_end_vpos - unchanged_at_top);
4967 return 0;
4971 /* Count the number of blanks at the start of the vector of glyphs R
4972 which is LEN glyphs long. */
4974 static int
4975 count_blanks (struct glyph *r, int len)
4977 int i;
4979 for (i = 0; i < len; ++i)
4980 if (!CHAR_GLYPH_SPACE_P (r[i]))
4981 break;
4983 return i;
4987 /* Count the number of glyphs in common at the start of the glyph
4988 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
4989 of STR2. Value is the number of equal glyphs equal at the start. */
4991 static int
4992 count_match (struct glyph *str1, struct glyph *end1, struct glyph *str2, struct glyph *end2)
4994 struct glyph *p1 = str1;
4995 struct glyph *p2 = str2;
4997 while (p1 < end1
4998 && p2 < end2
4999 && GLYPH_CHAR_AND_FACE_EQUAL_P (p1, p2))
5000 ++p1, ++p2;
5002 return p1 - str1;
5006 /* Char insertion/deletion cost vector, from term.c */
5008 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_TOTAL_COLS ((f))])
5011 /* Perform a frame-based update on line VPOS in frame FRAME. */
5013 static void
5014 update_frame_line (struct frame *f, int vpos)
5016 struct glyph *obody, *nbody, *op1, *op2, *np1, *nend;
5017 int tem;
5018 int osp, nsp, begmatch, endmatch, olen, nlen;
5019 struct glyph_matrix *current_matrix = f->current_matrix;
5020 struct glyph_matrix *desired_matrix = f->desired_matrix;
5021 struct glyph_row *current_row = MATRIX_ROW (current_matrix, vpos);
5022 struct glyph_row *desired_row = MATRIX_ROW (desired_matrix, vpos);
5023 int must_write_whole_line_p;
5024 int write_spaces_p = FRAME_MUST_WRITE_SPACES (f);
5025 int colored_spaces_p = (FACE_FROM_ID (f, DEFAULT_FACE_ID)->background
5026 != FACE_TTY_DEFAULT_BG_COLOR);
5028 if (colored_spaces_p)
5029 write_spaces_p = 1;
5031 /* Current row not enabled means it has unknown contents. We must
5032 write the whole desired line in that case. */
5033 must_write_whole_line_p = !current_row->enabled_p;
5034 if (must_write_whole_line_p)
5036 obody = 0;
5037 olen = 0;
5039 else
5041 obody = MATRIX_ROW_GLYPH_START (current_matrix, vpos);
5042 olen = current_row->used[TEXT_AREA];
5044 /* Ignore trailing spaces, if we can. */
5045 if (!write_spaces_p)
5046 while (olen > 0 && CHAR_GLYPH_SPACE_P (obody[olen-1]))
5047 olen--;
5050 current_row->enabled_p = 1;
5051 current_row->used[TEXT_AREA] = desired_row->used[TEXT_AREA];
5053 /* If desired line is empty, just clear the line. */
5054 if (!desired_row->enabled_p)
5056 nlen = 0;
5057 goto just_erase;
5060 nbody = desired_row->glyphs[TEXT_AREA];
5061 nlen = desired_row->used[TEXT_AREA];
5062 nend = nbody + nlen;
5064 /* If display line has unknown contents, write the whole line. */
5065 if (must_write_whole_line_p)
5067 /* Ignore spaces at the end, if we can. */
5068 if (!write_spaces_p)
5069 while (nlen > 0 && CHAR_GLYPH_SPACE_P (nbody[nlen - 1]))
5070 --nlen;
5072 /* Write the contents of the desired line. */
5073 if (nlen)
5075 cursor_to (f, vpos, 0);
5076 write_glyphs (f, nbody, nlen);
5079 /* Don't call clear_end_of_line if we already wrote the whole
5080 line. The cursor will not be at the right margin in that
5081 case but in the line below. */
5082 if (nlen < FRAME_TOTAL_COLS (f))
5084 cursor_to (f, vpos, nlen);
5085 clear_end_of_line (f, FRAME_TOTAL_COLS (f));
5087 else
5088 /* Make sure we are in the right row, otherwise cursor movement
5089 with cmgoto might use `ch' in the wrong row. */
5090 cursor_to (f, vpos, 0);
5092 make_current (desired_matrix, current_matrix, vpos);
5093 return;
5096 /* Pretend trailing spaces are not there at all,
5097 unless for one reason or another we must write all spaces. */
5098 if (!write_spaces_p)
5099 while (nlen > 0 && CHAR_GLYPH_SPACE_P (nbody[nlen - 1]))
5100 nlen--;
5102 /* If there's no i/d char, quickly do the best we can without it. */
5103 if (!FRAME_CHAR_INS_DEL_OK (f))
5105 int i, j;
5107 /* Find the first glyph in desired row that doesn't agree with
5108 a glyph in the current row, and write the rest from there on. */
5109 for (i = 0; i < nlen; i++)
5111 if (i >= olen || !GLYPH_EQUAL_P (nbody + i, obody + i))
5113 /* Find the end of the run of different glyphs. */
5114 j = i + 1;
5115 while (j < nlen
5116 && (j >= olen
5117 || !GLYPH_EQUAL_P (nbody + j, obody + j)
5118 || CHAR_GLYPH_PADDING_P (nbody[j])))
5119 ++j;
5121 /* Output this run of non-matching chars. */
5122 cursor_to (f, vpos, i);
5123 write_glyphs (f, nbody + i, j - i);
5124 i = j - 1;
5126 /* Now find the next non-match. */
5130 /* Clear the rest of the line, or the non-clear part of it. */
5131 if (olen > nlen)
5133 cursor_to (f, vpos, nlen);
5134 clear_end_of_line (f, olen);
5137 /* Make current row = desired row. */
5138 make_current (desired_matrix, current_matrix, vpos);
5139 return;
5142 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
5143 characters in a row. */
5145 if (!olen)
5147 /* If current line is blank, skip over initial spaces, if
5148 possible, and write the rest. */
5149 if (write_spaces_p)
5150 nsp = 0;
5151 else
5152 nsp = count_blanks (nbody, nlen);
5154 if (nlen > nsp)
5156 cursor_to (f, vpos, nsp);
5157 write_glyphs (f, nbody + nsp, nlen - nsp);
5160 /* Exchange contents between current_frame and new_frame. */
5161 make_current (desired_matrix, current_matrix, vpos);
5162 return;
5165 /* Compute number of leading blanks in old and new contents. */
5166 osp = count_blanks (obody, olen);
5167 nsp = (colored_spaces_p ? 0 : count_blanks (nbody, nlen));
5169 /* Compute number of matching chars starting with first non-blank. */
5170 begmatch = count_match (obody + osp, obody + olen,
5171 nbody + nsp, nbody + nlen);
5173 /* Spaces in new match implicit space past the end of old. */
5174 /* A bug causing this to be a no-op was fixed in 18.29. */
5175 if (!write_spaces_p && osp + begmatch == olen)
5177 np1 = nbody + nsp;
5178 while (np1 + begmatch < nend && CHAR_GLYPH_SPACE_P (np1[begmatch]))
5179 ++begmatch;
5182 /* Avoid doing insert/delete char
5183 just cause number of leading spaces differs
5184 when the following text does not match. */
5185 if (begmatch == 0 && osp != nsp)
5186 osp = nsp = min (osp, nsp);
5188 /* Find matching characters at end of line */
5189 op1 = obody + olen;
5190 np1 = nbody + nlen;
5191 op2 = op1 + begmatch - min (olen - osp, nlen - nsp);
5192 while (op1 > op2
5193 && GLYPH_EQUAL_P (op1 - 1, np1 - 1))
5195 op1--;
5196 np1--;
5198 endmatch = obody + olen - op1;
5200 /* tem gets the distance to insert or delete.
5201 endmatch is how many characters we save by doing so.
5202 Is it worth it? */
5204 tem = (nlen - nsp) - (olen - osp);
5205 if (endmatch && tem
5206 && (!FRAME_CHAR_INS_DEL_OK (f)
5207 || endmatch <= char_ins_del_cost (f)[tem]))
5208 endmatch = 0;
5210 /* nsp - osp is the distance to insert or delete.
5211 If that is nonzero, begmatch is known to be nonzero also.
5212 begmatch + endmatch is how much we save by doing the ins/del.
5213 Is it worth it? */
5215 if (nsp != osp
5216 && (!FRAME_CHAR_INS_DEL_OK (f)
5217 || begmatch + endmatch <= char_ins_del_cost (f)[nsp - osp]))
5219 begmatch = 0;
5220 endmatch = 0;
5221 osp = nsp = min (osp, nsp);
5224 /* Now go through the line, inserting, writing and
5225 deleting as appropriate. */
5227 if (osp > nsp)
5229 cursor_to (f, vpos, nsp);
5230 delete_glyphs (f, osp - nsp);
5232 else if (nsp > osp)
5234 /* If going to delete chars later in line
5235 and insert earlier in the line,
5236 must delete first to avoid losing data in the insert */
5237 if (endmatch && nlen < olen + nsp - osp)
5239 cursor_to (f, vpos, nlen - endmatch + osp - nsp);
5240 delete_glyphs (f, olen + nsp - osp - nlen);
5241 olen = nlen - (nsp - osp);
5243 cursor_to (f, vpos, osp);
5244 insert_glyphs (f, 0, nsp - osp);
5246 olen += nsp - osp;
5248 tem = nsp + begmatch + endmatch;
5249 if (nlen != tem || olen != tem)
5251 if (!endmatch || nlen == olen)
5253 /* If new text being written reaches right margin, there is
5254 no need to do clear-to-eol at the end of this function
5255 (and it would not be safe, since cursor is not going to
5256 be "at the margin" after the text is done). */
5257 if (nlen == FRAME_TOTAL_COLS (f))
5258 olen = 0;
5260 /* Function write_glyphs is prepared to do nothing
5261 if passed a length <= 0. Check it here to avoid
5262 unnecessary cursor movement. */
5263 if (nlen - tem > 0)
5265 cursor_to (f, vpos, nsp + begmatch);
5266 write_glyphs (f, nbody + nsp + begmatch, nlen - tem);
5269 else if (nlen > olen)
5271 /* Here, we used to have the following simple code:
5272 ----------------------------------------
5273 write_glyphs (nbody + nsp + begmatch, olen - tem);
5274 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5275 ----------------------------------------
5276 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5277 is a padding glyph. */
5278 int out = olen - tem; /* Columns to be overwritten originally. */
5279 int del;
5281 cursor_to (f, vpos, nsp + begmatch);
5283 /* Calculate columns we can actually overwrite. */
5284 while (CHAR_GLYPH_PADDING_P (nbody[nsp + begmatch + out]))
5285 out--;
5286 write_glyphs (f, nbody + nsp + begmatch, out);
5288 /* If we left columns to be overwritten, we must delete them. */
5289 del = olen - tem - out;
5290 if (del > 0)
5291 delete_glyphs (f, del);
5293 /* At last, we insert columns not yet written out. */
5294 insert_glyphs (f, nbody + nsp + begmatch + out, nlen - olen + del);
5295 olen = nlen;
5297 else if (olen > nlen)
5299 cursor_to (f, vpos, nsp + begmatch);
5300 write_glyphs (f, nbody + nsp + begmatch, nlen - tem);
5301 delete_glyphs (f, olen - nlen);
5302 olen = nlen;
5306 just_erase:
5307 /* If any unerased characters remain after the new line, erase them. */
5308 if (olen > nlen)
5310 cursor_to (f, vpos, nlen);
5311 clear_end_of_line (f, olen);
5314 /* Exchange contents between current_frame and new_frame. */
5315 make_current (desired_matrix, current_matrix, vpos);
5320 /***********************************************************************
5321 X/Y Position -> Buffer Position
5322 ***********************************************************************/
5324 /* Determine what's under window-relative pixel position (*X, *Y).
5325 Return the OBJECT (string or buffer) that's there.
5326 Return in *POS the position in that object.
5327 Adjust *X and *Y to character positions.
5328 Return in *DX and *DY the pixel coordinates of the click,
5329 relative to the top left corner of OBJECT, or relative to
5330 the top left corner of the character glyph at (*X, *Y)
5331 if OBJECT is nil.
5332 Return WIDTH and HEIGHT of the object at (*X, *Y), or zero
5333 if the coordinates point to an empty area of the display. */
5335 Lisp_Object
5336 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)
5338 struct it it;
5339 Lisp_Object old_current_buffer = Fcurrent_buffer ();
5340 struct text_pos startp;
5341 Lisp_Object string;
5342 struct glyph_row *row;
5343 #ifdef HAVE_WINDOW_SYSTEM
5344 struct image *img = 0;
5345 #endif
5346 int x0, x1, to_x;
5347 void *itdata = NULL;
5349 /* We used to set current_buffer directly here, but that does the
5350 wrong thing with `face-remapping-alist' (bug#2044). */
5351 Fset_buffer (w->buffer);
5352 itdata = bidi_shelve_cache ();
5353 SET_TEXT_POS_FROM_MARKER (startp, w->start);
5354 CHARPOS (startp) = min (ZV, max (BEGV, CHARPOS (startp)));
5355 BYTEPOS (startp) = min (ZV_BYTE, max (BEGV_BYTE, BYTEPOS (startp)));
5356 start_display (&it, w, startp);
5357 /* start_display takes into account the header-line row, but IT's
5358 vpos still counts from the glyph row that includes the window's
5359 start position. Adjust for a possible header-line row. */
5360 it.vpos += WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0;
5362 x0 = *x;
5364 /* First, move to the beginning of the row corresponding to *Y. We
5365 need to be in that row to get the correct value of base paragraph
5366 direction for the text at (*X, *Y). */
5367 move_it_to (&it, -1, 0, *y, -1, MOVE_TO_X | MOVE_TO_Y);
5369 /* TO_X is the pixel position that the iterator will compute for the
5370 glyph at *X. We add it.first_visible_x because iterator
5371 positions include the hscroll. */
5372 to_x = x0 + it.first_visible_x;
5373 if (it.bidi_it.paragraph_dir == R2L)
5374 /* For lines in an R2L paragraph, we need to mirror TO_X wrt the
5375 text area. This is because the iterator, even in R2L
5376 paragraphs, delivers glyphs as if they started at the left
5377 margin of the window. (When we actually produce glyphs for
5378 display, we reverse their order in PRODUCE_GLYPHS, but the
5379 iterator doesn't know about that.) The following line adjusts
5380 the pixel position to the iterator geometry, which is what
5381 move_it_* routines use. (The -1 is because in a window whose
5382 text-area width is W, the rightmost pixel position is W-1, and
5383 it should be mirrored into zero pixel position.) */
5384 to_x = window_box_width (w, TEXT_AREA) - to_x - 1;
5386 /* Now move horizontally in the row to the glyph under *X. Second
5387 argument is ZV to prevent move_it_in_display_line from matching
5388 based on buffer positions. */
5389 move_it_in_display_line (&it, ZV, to_x, MOVE_TO_X);
5390 bidi_unshelve_cache (itdata, 0);
5392 Fset_buffer (old_current_buffer);
5394 *dx = x0 + it.first_visible_x - it.current_x;
5395 *dy = *y - it.current_y;
5397 string = w->buffer;
5398 if (STRINGP (it.string))
5399 string = it.string;
5400 *pos = it.current;
5401 if (it.what == IT_COMPOSITION
5402 && it.cmp_it.nchars > 1
5403 && it.cmp_it.reversed_p)
5405 /* The current display element is a grapheme cluster in a
5406 composition. In that case, we need the position of the first
5407 character of the cluster. But, as it.cmp_it.reversed_p is 1,
5408 it.current points to the last character of the cluster, thus
5409 we must move back to the first character of the same
5410 cluster. */
5411 CHARPOS (pos->pos) -= it.cmp_it.nchars - 1;
5412 if (STRINGP (it.string))
5413 BYTEPOS (pos->pos) = string_char_to_byte (string, CHARPOS (pos->pos));
5414 else
5415 BYTEPOS (pos->pos) = buf_charpos_to_bytepos (XBUFFER (w->buffer),
5416 CHARPOS (pos->pos));
5419 #ifdef HAVE_WINDOW_SYSTEM
5420 if (it.what == IT_IMAGE)
5422 if ((img = IMAGE_FROM_ID (it.f, it.image_id)) != NULL
5423 && !NILP (img->spec))
5424 *object = img->spec;
5426 #endif
5428 if (it.vpos < w->current_matrix->nrows
5429 && (row = MATRIX_ROW (w->current_matrix, it.vpos),
5430 row->enabled_p))
5432 if (it.hpos < row->used[TEXT_AREA])
5434 struct glyph *glyph = row->glyphs[TEXT_AREA] + it.hpos;
5435 #ifdef HAVE_WINDOW_SYSTEM
5436 if (img)
5438 *dy -= row->ascent - glyph->ascent;
5439 *dx += glyph->slice.img.x;
5440 *dy += glyph->slice.img.y;
5441 /* Image slices positions are still relative to the entire image */
5442 *width = img->width;
5443 *height = img->height;
5445 else
5446 #endif
5448 *width = glyph->pixel_width;
5449 *height = glyph->ascent + glyph->descent;
5452 else
5454 *width = 0;
5455 *height = row->height;
5458 else
5460 *width = *height = 0;
5463 /* Add extra (default width) columns if clicked after EOL. */
5464 x1 = max (0, it.current_x + it.pixel_width - it.first_visible_x);
5465 if (x0 > x1)
5466 it.hpos += (x0 - x1) / WINDOW_FRAME_COLUMN_WIDTH (w);
5468 *x = it.hpos;
5469 *y = it.vpos;
5471 return string;
5475 /* Value is the string under window-relative coordinates X/Y in the
5476 mode line or header line (PART says which) of window W, or nil if none.
5477 *CHARPOS is set to the position in the string returned. */
5479 Lisp_Object
5480 mode_line_string (struct window *w, enum window_part part,
5481 int *x, int *y, EMACS_INT *charpos, Lisp_Object *object,
5482 int *dx, int *dy, int *width, int *height)
5484 struct glyph_row *row;
5485 struct glyph *glyph, *end;
5486 int x0, y0;
5487 Lisp_Object string = Qnil;
5489 if (part == ON_MODE_LINE)
5490 row = MATRIX_MODE_LINE_ROW (w->current_matrix);
5491 else
5492 row = MATRIX_HEADER_LINE_ROW (w->current_matrix);
5493 y0 = *y - row->y;
5494 *y = row - MATRIX_FIRST_TEXT_ROW (w->current_matrix);
5496 if (row->mode_line_p && row->enabled_p)
5498 /* Find the glyph under X. If we find one with a string object,
5499 it's the one we were looking for. */
5500 glyph = row->glyphs[TEXT_AREA];
5501 end = glyph + row->used[TEXT_AREA];
5502 for (x0 = *x; glyph < end && x0 >= glyph->pixel_width; ++glyph)
5503 x0 -= glyph->pixel_width;
5504 *x = glyph - row->glyphs[TEXT_AREA];
5505 if (glyph < end)
5507 string = glyph->object;
5508 *charpos = glyph->charpos;
5509 *width = glyph->pixel_width;
5510 *height = glyph->ascent + glyph->descent;
5511 #ifdef HAVE_WINDOW_SYSTEM
5512 if (glyph->type == IMAGE_GLYPH)
5514 struct image *img;
5515 img = IMAGE_FROM_ID (WINDOW_XFRAME (w), glyph->u.img_id);
5516 if (img != NULL)
5517 *object = img->spec;
5518 y0 -= row->ascent - glyph->ascent;
5520 #endif
5522 else
5524 /* Add extra (default width) columns if clicked after EOL. */
5525 *x += x0 / WINDOW_FRAME_COLUMN_WIDTH (w);
5526 *width = 0;
5527 *height = row->height;
5530 else
5532 *x = 0;
5533 x0 = 0;
5534 *width = *height = 0;
5537 *dx = x0;
5538 *dy = y0;
5540 return string;
5544 /* Value is the string under window-relative coordinates X/Y in either
5545 marginal area, or nil if none. *CHARPOS is set to the position in
5546 the string returned. */
5548 Lisp_Object
5549 marginal_area_string (struct window *w, enum window_part part,
5550 int *x, int *y, EMACS_INT *charpos, Lisp_Object *object,
5551 int *dx, int *dy, int *width, int *height)
5553 struct glyph_row *row = w->current_matrix->rows;
5554 struct glyph *glyph, *end;
5555 int x0, y0, i, wy = *y;
5556 int area;
5557 Lisp_Object string = Qnil;
5559 if (part == ON_LEFT_MARGIN)
5560 area = LEFT_MARGIN_AREA;
5561 else if (part == ON_RIGHT_MARGIN)
5562 area = RIGHT_MARGIN_AREA;
5563 else
5564 abort ();
5566 for (i = 0; row->enabled_p && i < w->current_matrix->nrows; ++i, ++row)
5567 if (wy >= row->y && wy < MATRIX_ROW_BOTTOM_Y (row))
5568 break;
5569 y0 = *y - row->y;
5570 *y = row - MATRIX_FIRST_TEXT_ROW (w->current_matrix);
5572 if (row->enabled_p)
5574 /* Find the glyph under X. If we find one with a string object,
5575 it's the one we were looking for. */
5576 if (area == RIGHT_MARGIN_AREA)
5577 x0 = ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
5578 ? WINDOW_LEFT_FRINGE_WIDTH (w)
5579 : WINDOW_TOTAL_FRINGE_WIDTH (w))
5580 + window_box_width (w, LEFT_MARGIN_AREA)
5581 + window_box_width (w, TEXT_AREA));
5582 else
5583 x0 = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
5584 ? WINDOW_LEFT_FRINGE_WIDTH (w)
5585 : 0);
5587 glyph = row->glyphs[area];
5588 end = glyph + row->used[area];
5589 for (x0 = *x - x0; glyph < end && x0 >= glyph->pixel_width; ++glyph)
5590 x0 -= glyph->pixel_width;
5591 *x = glyph - row->glyphs[area];
5592 if (glyph < end)
5594 string = glyph->object;
5595 *charpos = glyph->charpos;
5596 *width = glyph->pixel_width;
5597 *height = glyph->ascent + glyph->descent;
5598 #ifdef HAVE_WINDOW_SYSTEM
5599 if (glyph->type == IMAGE_GLYPH)
5601 struct image *img;
5602 img = IMAGE_FROM_ID (WINDOW_XFRAME (w), glyph->u.img_id);
5603 if (img != NULL)
5604 *object = img->spec;
5605 y0 -= row->ascent - glyph->ascent;
5606 x0 += glyph->slice.img.x;
5607 y0 += glyph->slice.img.y;
5609 #endif
5611 else
5613 /* Add extra (default width) columns if clicked after EOL. */
5614 *x += x0 / WINDOW_FRAME_COLUMN_WIDTH (w);
5615 *width = 0;
5616 *height = row->height;
5619 else
5621 x0 = 0;
5622 *x = 0;
5623 *width = *height = 0;
5626 *dx = x0;
5627 *dy = y0;
5629 return string;
5633 /***********************************************************************
5634 Changing Frame Sizes
5635 ***********************************************************************/
5637 #ifdef SIGWINCH
5639 static void
5640 window_change_signal (int signalnum) /* If we don't have an argument, */
5641 /* some compilers complain in signal calls. */
5643 int width, height;
5644 int old_errno = errno;
5646 struct tty_display_info *tty;
5648 signal (SIGWINCH, window_change_signal);
5649 SIGNAL_THREAD_CHECK (signalnum);
5651 /* The frame size change obviously applies to a single
5652 termcap-controlled terminal, but we can't decide which.
5653 Therefore, we resize the frames corresponding to each tty.
5655 for (tty = tty_list; tty; tty = tty->next) {
5657 if (! tty->term_initted)
5658 continue;
5660 /* Suspended tty frames have tty->input == NULL avoid trying to
5661 use it. */
5662 if (!tty->input)
5663 continue;
5665 get_tty_size (fileno (tty->input), &width, &height);
5667 if (width > 5 && height > 2) {
5668 Lisp_Object tail, frame;
5670 FOR_EACH_FRAME (tail, frame)
5671 if (FRAME_TERMCAP_P (XFRAME (frame)) && FRAME_TTY (XFRAME (frame)) == tty)
5672 /* Record the new sizes, but don't reallocate the data
5673 structures now. Let that be done later outside of the
5674 signal handler. */
5675 change_frame_size (XFRAME (frame), height, width, 0, 1, 0);
5679 errno = old_errno;
5681 #endif /* SIGWINCH */
5684 /* Do any change in frame size that was requested by a signal. SAFE
5685 non-zero means this function is called from a place where it is
5686 safe to change frame sizes while a redisplay is in progress. */
5688 void
5689 do_pending_window_change (int safe)
5691 /* If window_change_signal should have run before, run it now. */
5692 if (redisplaying_p && !safe)
5693 return;
5695 while (delayed_size_change)
5697 Lisp_Object tail, frame;
5699 delayed_size_change = 0;
5701 FOR_EACH_FRAME (tail, frame)
5703 struct frame *f = XFRAME (frame);
5705 if (f->new_text_lines != 0 || f->new_text_cols != 0)
5706 change_frame_size (f, f->new_text_lines, f->new_text_cols,
5707 0, 0, safe);
5713 /* Change the frame height and/or width. Values may be given as zero to
5714 indicate no change is to take place.
5716 If DELAY is non-zero, then assume we're being called from a signal
5717 handler, and queue the change for later - perhaps the next
5718 redisplay. Since this tries to resize windows, we can't call it
5719 from a signal handler.
5721 SAFE non-zero means this function is called from a place where it's
5722 safe to change frame sizes while a redisplay is in progress. */
5724 void
5725 change_frame_size (register struct frame *f, int newheight, int newwidth, int pretend, int delay, int safe)
5727 Lisp_Object tail, frame;
5729 if (FRAME_MSDOS_P (f))
5731 /* On MS-DOS, all frames use the same screen, so a change in
5732 size affects all frames. Termcap now supports multiple
5733 ttys. */
5734 FOR_EACH_FRAME (tail, frame)
5735 if (! FRAME_WINDOW_P (XFRAME (frame)))
5736 change_frame_size_1 (XFRAME (frame), newheight, newwidth,
5737 pretend, delay, safe);
5739 else
5740 change_frame_size_1 (f, newheight, newwidth, pretend, delay, safe);
5743 static void
5744 change_frame_size_1 (register struct frame *f, int newheight, int newwidth, int pretend, int delay, int safe)
5746 int new_frame_total_cols;
5747 int count = SPECPDL_INDEX ();
5749 /* If we can't deal with the change now, queue it for later. */
5750 if (delay || (redisplaying_p && !safe))
5752 f->new_text_lines = newheight;
5753 f->new_text_cols = newwidth;
5754 delayed_size_change = 1;
5755 return;
5758 /* This size-change overrides any pending one for this frame. */
5759 f->new_text_lines = 0;
5760 f->new_text_cols = 0;
5762 /* If an argument is zero, set it to the current value. */
5763 if (newheight == 0)
5764 newheight = FRAME_LINES (f);
5765 if (newwidth == 0)
5766 newwidth = FRAME_COLS (f);
5768 /* Compute width of windows in F. */
5769 /* Round up to the smallest acceptable size. */
5770 check_frame_size (f, &newheight, &newwidth);
5772 /* This is the width of the frame with vertical scroll bars and fringe
5773 columns. Do this after rounding - see discussion of bug#9723. */
5774 new_frame_total_cols = FRAME_TOTAL_COLS_ARG (f, newwidth);
5776 /* If we're not changing the frame size, quit now. */
5777 /* Frame width may be unchanged but the text portion may change, for
5778 example, fullscreen and remove/add scroll bar. */
5779 if (newheight == FRAME_LINES (f)
5780 /* Text portion unchanged? */
5781 && newwidth == FRAME_COLS (f)
5782 /* Frame width unchanged? */
5783 && new_frame_total_cols == FRAME_TOTAL_COLS (f))
5784 return;
5786 BLOCK_INPUT;
5788 #ifdef MSDOS
5789 /* We only can set screen dimensions to certain values supported
5790 by our video hardware. Try to find the smallest size greater
5791 or equal to the requested dimensions. */
5792 dos_set_window_size (&newheight, &newwidth);
5793 #endif
5795 if (newheight != FRAME_LINES (f))
5797 resize_frame_windows (f, newheight, 0);
5799 /* MSDOS frames cannot PRETEND, as they change frame size by
5800 manipulating video hardware. */
5801 if ((FRAME_TERMCAP_P (f) && !pretend) || FRAME_MSDOS_P (f))
5802 FrameRows (FRAME_TTY (f)) = newheight;
5805 if (new_frame_total_cols != FRAME_TOTAL_COLS (f))
5807 resize_frame_windows (f, new_frame_total_cols, 1);
5809 /* MSDOS frames cannot PRETEND, as they change frame size by
5810 manipulating video hardware. */
5811 if ((FRAME_TERMCAP_P (f) && !pretend) || FRAME_MSDOS_P (f))
5812 FrameCols (FRAME_TTY (f)) = newwidth;
5814 if (WINDOWP (f->tool_bar_window))
5815 XSETFASTINT (XWINDOW (f->tool_bar_window)->total_cols, newwidth);
5818 FRAME_LINES (f) = newheight;
5819 SET_FRAME_COLS (f, newwidth);
5822 struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
5823 int text_area_x, text_area_y, text_area_width, text_area_height;
5825 window_box (w, TEXT_AREA, &text_area_x, &text_area_y, &text_area_width,
5826 &text_area_height);
5827 if (w->cursor.x >= text_area_x + text_area_width)
5828 w->cursor.hpos = w->cursor.x = 0;
5829 if (w->cursor.y >= text_area_y + text_area_height)
5830 w->cursor.vpos = w->cursor.y = 0;
5833 adjust_glyphs (f);
5834 calculate_costs (f);
5835 SET_FRAME_GARBAGED (f);
5836 f->resized_p = 1;
5838 UNBLOCK_INPUT;
5840 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
5842 run_window_configuration_change_hook (f);
5844 unbind_to (count, Qnil);
5849 /***********************************************************************
5850 Terminal Related Lisp Functions
5851 ***********************************************************************/
5853 DEFUN ("open-termscript", Fopen_termscript, Sopen_termscript,
5854 1, 1, "FOpen termscript file: ",
5855 doc: /* Start writing all terminal output to FILE as well as the terminal.
5856 FILE = nil means just close any termscript file currently open. */)
5857 (Lisp_Object file)
5859 struct tty_display_info *tty;
5861 if (! FRAME_TERMCAP_P (SELECTED_FRAME ())
5862 && ! FRAME_MSDOS_P (SELECTED_FRAME ()))
5863 error ("Current frame is not on a tty device");
5865 tty = CURTTY ();
5867 if (tty->termscript != 0)
5869 BLOCK_INPUT;
5870 fclose (tty->termscript);
5871 UNBLOCK_INPUT;
5873 tty->termscript = 0;
5875 if (! NILP (file))
5877 file = Fexpand_file_name (file, Qnil);
5878 tty->termscript = fopen (SSDATA (file), "w");
5879 if (tty->termscript == 0)
5880 report_file_error ("Opening termscript", Fcons (file, Qnil));
5882 return Qnil;
5886 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal,
5887 Ssend_string_to_terminal, 1, 2, 0,
5888 doc: /* Send STRING to the terminal without alteration.
5889 Control characters in STRING will have terminal-dependent effects.
5891 Optional parameter TERMINAL specifies the tty terminal device to use.
5892 It may be a terminal object, a frame, or nil for the terminal used by
5893 the currently selected frame. In batch mode, STRING is sent to stdout
5894 when TERMINAL is nil. */)
5895 (Lisp_Object string, Lisp_Object terminal)
5897 struct terminal *t = get_terminal (terminal, 1);
5898 FILE *out;
5900 /* ??? Perhaps we should do something special for multibyte strings here. */
5901 CHECK_STRING (string);
5902 BLOCK_INPUT;
5904 if (!t)
5905 error ("Unknown terminal device");
5907 if (t->type == output_initial)
5908 out = stdout;
5909 else if (t->type != output_termcap && t->type != output_msdos_raw)
5910 error ("Device %d is not a termcap terminal device", t->id);
5911 else
5913 struct tty_display_info *tty = t->display_info.tty;
5915 if (! tty->output)
5916 error ("Terminal is currently suspended");
5918 if (tty->termscript)
5920 fwrite (SDATA (string), 1, SBYTES (string), tty->termscript);
5921 fflush (tty->termscript);
5923 out = tty->output;
5925 fwrite (SDATA (string), 1, SBYTES (string), out);
5926 fflush (out);
5927 UNBLOCK_INPUT;
5928 return Qnil;
5932 DEFUN ("ding", Fding, Sding, 0, 1, 0,
5933 doc: /* Beep, or flash the screen.
5934 Also, unless an argument is given,
5935 terminate any keyboard macro currently executing. */)
5936 (Lisp_Object arg)
5938 if (!NILP (arg))
5940 if (noninteractive)
5941 putchar (07);
5942 else
5943 ring_bell (XFRAME (selected_frame));
5945 else
5946 bitch_at_user ();
5948 return Qnil;
5951 void
5952 bitch_at_user (void)
5954 if (noninteractive)
5955 putchar (07);
5956 else if (!INTERACTIVE) /* Stop executing a keyboard macro. */
5957 error ("Keyboard macro terminated by a command ringing the bell");
5958 else
5959 ring_bell (XFRAME (selected_frame));
5964 /***********************************************************************
5965 Sleeping, Waiting
5966 ***********************************************************************/
5968 DEFUN ("sleep-for", Fsleep_for, Ssleep_for, 1, 2, 0,
5969 doc: /* Pause, without updating display, for SECONDS seconds.
5970 SECONDS may be a floating-point value, meaning that you can wait for a
5971 fraction of a second. Optional second arg MILLISECONDS specifies an
5972 additional wait period, in milliseconds; this may be useful if your
5973 Emacs was built without floating point support.
5974 \(Not all operating systems support waiting for a fraction of a second.) */)
5975 (Lisp_Object seconds, Lisp_Object milliseconds)
5977 int sec, usec;
5979 if (NILP (milliseconds))
5980 XSETINT (milliseconds, 0);
5981 else
5982 CHECK_NUMBER (milliseconds);
5983 usec = XINT (milliseconds) * 1000;
5986 double duration = extract_float (seconds);
5987 sec = (int) duration;
5988 usec += (duration - sec) * 1000000;
5991 #ifndef EMACS_HAS_USECS
5992 if (sec == 0 && usec != 0)
5993 error ("Millisecond `sleep-for' not supported on %s", SYSTEM_TYPE);
5994 #endif
5996 /* Assure that 0 <= usec < 1000000. */
5997 if (usec < 0)
5999 /* We can't rely on the rounding being correct if usec is negative. */
6000 if (-1000000 < usec)
6001 sec--, usec += 1000000;
6002 else
6003 sec -= -usec / 1000000, usec = 1000000 - (-usec % 1000000);
6005 else
6006 sec += usec / 1000000, usec %= 1000000;
6008 if (sec < 0 || (sec == 0 && usec == 0))
6009 return Qnil;
6011 wait_reading_process_output (sec, usec, 0, 0, Qnil, NULL, 0);
6013 return Qnil;
6017 /* This is just like wait_reading_process_output, except that
6018 it does redisplay.
6020 TIMEOUT is number of seconds to wait (float or integer),
6021 or t to wait forever.
6022 READING is 1 if reading input.
6023 If DO_DISPLAY is >0 display process output while waiting.
6024 If DO_DISPLAY is >1 perform an initial redisplay before waiting.
6027 Lisp_Object
6028 sit_for (Lisp_Object timeout, int reading, int do_display)
6030 int sec, usec;
6032 swallow_events (do_display);
6034 if ((detect_input_pending_run_timers (do_display))
6035 || !NILP (Vexecuting_kbd_macro))
6036 return Qnil;
6038 if (do_display >= 2)
6039 redisplay_preserve_echo_area (2);
6041 if (INTEGERP (timeout))
6043 sec = XINT (timeout);
6044 usec = 0;
6046 else if (FLOATP (timeout))
6048 double seconds = XFLOAT_DATA (timeout);
6049 sec = (int) seconds;
6050 usec = (int) ((seconds - sec) * 1000000);
6052 else if (EQ (timeout, Qt))
6054 sec = 0;
6055 usec = 0;
6057 else
6058 wrong_type_argument (Qnumberp, timeout);
6060 if (sec == 0 && usec == 0 && !EQ (timeout, Qt))
6061 return Qt;
6063 #ifdef SIGIO
6064 gobble_input (0);
6065 #endif
6067 wait_reading_process_output (sec, usec, reading ? -1 : 1, do_display,
6068 Qnil, NULL, 0);
6070 return detect_input_pending () ? Qnil : Qt;
6074 DEFUN ("redisplay", Fredisplay, Sredisplay, 0, 1, 0,
6075 doc: /* Perform redisplay.
6076 Optional arg FORCE, if non-nil, prevents redisplay from being
6077 preempted by arriving input, even if `redisplay-dont-pause' is nil.
6078 If `redisplay-dont-pause' is non-nil (the default), redisplay is never
6079 preempted by arriving input, so FORCE does nothing.
6081 Return t if redisplay was performed, nil if redisplay was preempted
6082 immediately by pending input. */)
6083 (Lisp_Object force)
6085 int count;
6087 swallow_events (1);
6088 if ((detect_input_pending_run_timers (1)
6089 && NILP (force) && !redisplay_dont_pause)
6090 || !NILP (Vexecuting_kbd_macro))
6091 return Qnil;
6093 count = SPECPDL_INDEX ();
6094 if (!NILP (force) && !redisplay_dont_pause)
6095 specbind (Qredisplay_dont_pause, Qt);
6096 redisplay_preserve_echo_area (2);
6097 unbind_to (count, Qnil);
6098 return Qt;
6103 /***********************************************************************
6104 Other Lisp Functions
6105 ***********************************************************************/
6107 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
6108 session's frames, frame names, buffers, buffer-read-only flags, and
6109 buffer-modified-flags. */
6111 static Lisp_Object frame_and_buffer_state;
6114 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p,
6115 Sframe_or_buffer_changed_p, 0, 1, 0,
6116 doc: /* Return non-nil if the frame and buffer state appears to have changed.
6117 VARIABLE is a variable name whose value is either nil or a state vector
6118 that will be updated to contain all frames and buffers,
6119 aside from buffers whose names start with space,
6120 along with the buffers' read-only and modified flags. This allows a fast
6121 check to see whether buffer menus might need to be recomputed.
6122 If this function returns non-nil, it updates the internal vector to reflect
6123 the current state.
6125 If VARIABLE is nil, an internal variable is used. Users should not
6126 pass nil for VARIABLE. */)
6127 (Lisp_Object variable)
6129 Lisp_Object state, tail, frame, buf;
6130 Lisp_Object *vecp, *end;
6131 int n;
6133 if (! NILP (variable))
6135 CHECK_SYMBOL (variable);
6136 state = Fsymbol_value (variable);
6137 if (! VECTORP (state))
6138 goto changed;
6140 else
6141 state = frame_and_buffer_state;
6143 vecp = XVECTOR (state)->contents;
6144 end = vecp + ASIZE (state);
6146 FOR_EACH_FRAME (tail, frame)
6148 if (vecp == end)
6149 goto changed;
6150 if (!EQ (*vecp++, frame))
6151 goto changed;
6152 if (vecp == end)
6153 goto changed;
6154 if (!EQ (*vecp++, XFRAME (frame)->name))
6155 goto changed;
6157 /* Check that the buffer info matches. */
6158 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
6160 buf = XCDR (XCAR (tail));
6161 /* Ignore buffers that aren't included in buffer lists. */
6162 if (SREF (BVAR (XBUFFER (buf), name), 0) == ' ')
6163 continue;
6164 if (vecp == end)
6165 goto changed;
6166 if (!EQ (*vecp++, buf))
6167 goto changed;
6168 if (vecp == end)
6169 goto changed;
6170 if (!EQ (*vecp++, BVAR (XBUFFER (buf), read_only)))
6171 goto changed;
6172 if (vecp == end)
6173 goto changed;
6174 if (!EQ (*vecp++, Fbuffer_modified_p (buf)))
6175 goto changed;
6177 if (vecp == end)
6178 goto changed;
6179 /* Detect deletion of a buffer at the end of the list. */
6180 if (EQ (*vecp, Qlambda))
6181 return Qnil;
6183 /* Come here if we decide the data has changed. */
6184 changed:
6185 /* Count the size we will need.
6186 Start with 1 so there is room for at least one lambda at the end. */
6187 n = 1;
6188 FOR_EACH_FRAME (tail, frame)
6189 n += 2;
6190 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
6191 n += 3;
6192 /* Reallocate the vector if data has grown to need it,
6193 or if it has shrunk a lot. */
6194 if (! VECTORP (state)
6195 || n > ASIZE (state)
6196 || n + 20 < ASIZE (state) / 2)
6197 /* Add 20 extra so we grow it less often. */
6199 state = Fmake_vector (make_number (n + 20), Qlambda);
6200 if (! NILP (variable))
6201 Fset (variable, state);
6202 else
6203 frame_and_buffer_state = state;
6206 /* Record the new data in the (possibly reallocated) vector. */
6207 vecp = XVECTOR (state)->contents;
6208 FOR_EACH_FRAME (tail, frame)
6210 *vecp++ = frame;
6211 *vecp++ = XFRAME (frame)->name;
6213 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
6215 buf = XCDR (XCAR (tail));
6216 /* Ignore buffers that aren't included in buffer lists. */
6217 if (SREF (BVAR (XBUFFER (buf), name), 0) == ' ')
6218 continue;
6219 *vecp++ = buf;
6220 *vecp++ = BVAR (XBUFFER (buf), read_only);
6221 *vecp++ = Fbuffer_modified_p (buf);
6223 /* Fill up the vector with lambdas (always at least one). */
6224 *vecp++ = Qlambda;
6225 while (vecp - XVECTOR (state)->contents
6226 < ASIZE (state))
6227 *vecp++ = Qlambda;
6228 /* Make sure we didn't overflow the vector. */
6229 if (vecp - XVECTOR (state)->contents
6230 > ASIZE (state))
6231 abort ();
6232 return Qt;
6237 /***********************************************************************
6238 Initialization
6239 ***********************************************************************/
6241 /* Initialization done when Emacs fork is started, before doing stty.
6242 Determine terminal type and set terminal_driver. Then invoke its
6243 decoding routine to set up variables in the terminal package. */
6245 void
6246 init_display (void)
6248 char *terminal_type;
6250 /* Construct the space glyph. */
6251 space_glyph.type = CHAR_GLYPH;
6252 SET_CHAR_GLYPH (space_glyph, ' ', DEFAULT_FACE_ID, 0);
6253 space_glyph.charpos = -1;
6255 inverse_video = 0;
6256 cursor_in_echo_area = 0;
6257 terminal_type = (char *) 0;
6259 /* Now is the time to initialize this; it's used by init_sys_modes
6260 during startup. */
6261 Vinitial_window_system = Qnil;
6263 /* SIGWINCH needs to be handled no matter what display we start
6264 with. Otherwise newly opened tty frames will not resize
6265 automatically. */
6266 #ifdef SIGWINCH
6267 #ifndef CANNOT_DUMP
6268 if (initialized)
6269 #endif /* CANNOT_DUMP */
6270 signal (SIGWINCH, window_change_signal);
6271 #endif /* SIGWINCH */
6273 /* If running as a daemon, no need to initialize any frames/terminal. */
6274 if (IS_DAEMON)
6275 return;
6277 /* If the user wants to use a window system, we shouldn't bother
6278 initializing the terminal. This is especially important when the
6279 terminal is so dumb that emacs gives up before and doesn't bother
6280 using the window system.
6282 If the DISPLAY environment variable is set and nonempty,
6283 try to use X, and die with an error message if that doesn't work. */
6285 #ifdef HAVE_X_WINDOWS
6286 if (! inhibit_window_system && ! display_arg)
6288 char *display;
6289 display = getenv ("DISPLAY");
6290 display_arg = (display != 0 && *display != 0);
6292 if (display_arg && !x_display_ok (display))
6294 fprintf (stderr, "Display %s unavailable, simulating -nw\n",
6295 display);
6296 inhibit_window_system = 1;
6300 if (!inhibit_window_system && display_arg)
6302 Vinitial_window_system = Qx;
6303 #ifdef HAVE_X11
6304 Vwindow_system_version = make_number (11);
6305 #endif
6306 #if defined (GNU_LINUX) && defined (HAVE_LIBNCURSES)
6307 /* In some versions of ncurses,
6308 tputs crashes if we have not called tgetent.
6309 So call tgetent. */
6310 { char b[2044]; tgetent (b, "xterm");}
6311 #endif
6312 adjust_frame_glyphs_initially ();
6313 return;
6315 #endif /* HAVE_X_WINDOWS */
6317 #ifdef HAVE_NTGUI
6318 if (!inhibit_window_system)
6320 Vinitial_window_system = Qw32;
6321 Vwindow_system_version = make_number (1);
6322 adjust_frame_glyphs_initially ();
6323 return;
6325 #endif /* HAVE_NTGUI */
6327 #ifdef HAVE_NS
6328 if (!inhibit_window_system
6329 #ifndef CANNOT_DUMP
6330 && initialized
6331 #endif
6334 Vinitial_window_system = Qns;
6335 Vwindow_system_version = make_number (10);
6336 adjust_frame_glyphs_initially ();
6337 return;
6339 #endif
6341 /* If no window system has been specified, try to use the terminal. */
6342 if (! isatty (0))
6344 fatal ("standard input is not a tty");
6345 exit (1);
6348 #ifdef WINDOWSNT
6349 terminal_type = "w32console";
6350 #else
6351 /* Look at the TERM variable. */
6352 terminal_type = (char *) getenv ("TERM");
6353 #endif
6354 if (!terminal_type)
6356 #ifdef HAVE_WINDOW_SYSTEM
6357 if (! inhibit_window_system)
6358 fprintf (stderr, "Please set the environment variable DISPLAY or TERM (see `tset').\n");
6359 else
6360 #endif /* HAVE_WINDOW_SYSTEM */
6361 fprintf (stderr, "Please set the environment variable TERM; see `tset'.\n");
6362 exit (1);
6366 struct terminal *t;
6367 struct frame *f = XFRAME (selected_frame);
6369 /* Open a display on the controlling tty. */
6370 t = init_tty (0, terminal_type, 1); /* Errors are fatal. */
6372 /* Convert the initial frame to use the new display. */
6373 if (f->output_method != output_initial)
6374 abort ();
6375 f->output_method = t->type;
6376 f->terminal = t;
6378 t->reference_count++;
6379 #ifdef MSDOS
6380 f->output_data.tty->display_info = &the_only_display_info;
6381 #else
6382 if (f->output_method == output_termcap)
6383 create_tty_output (f);
6384 #endif
6385 t->display_info.tty->top_frame = selected_frame;
6386 change_frame_size (XFRAME (selected_frame),
6387 FrameRows (t->display_info.tty),
6388 FrameCols (t->display_info.tty), 0, 0, 1);
6390 /* Delete the initial terminal. */
6391 if (--initial_terminal->reference_count == 0
6392 && initial_terminal->delete_terminal_hook)
6393 (*initial_terminal->delete_terminal_hook) (initial_terminal);
6395 /* Update frame parameters to reflect the new type. */
6396 Fmodify_frame_parameters
6397 (selected_frame, Fcons (Fcons (Qtty_type,
6398 Ftty_type (selected_frame)), Qnil));
6399 if (t->display_info.tty->name)
6400 Fmodify_frame_parameters (selected_frame,
6401 Fcons (Fcons (Qtty, build_string (t->display_info.tty->name)),
6402 Qnil));
6403 else
6404 Fmodify_frame_parameters (selected_frame, Fcons (Fcons (Qtty, Qnil),
6405 Qnil));
6409 struct frame *sf = SELECTED_FRAME ();
6410 int width = FRAME_TOTAL_COLS (sf);
6411 int height = FRAME_LINES (sf);
6413 /* If these sizes are so big they cause overflow, just ignore the
6414 change. It's not clear what better we could do. The rest of
6415 the code assumes that (width + 2) * height * sizeof (struct glyph)
6416 does not overflow and does not exceed PTRDIFF_MAX or SIZE_MAX. */
6417 if (INT_ADD_RANGE_OVERFLOW (width, 2, INT_MIN, INT_MAX)
6418 || INT_MULTIPLY_RANGE_OVERFLOW (width + 2, height, INT_MIN, INT_MAX)
6419 || (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (struct glyph)
6420 < (width + 2) * height))
6421 fatal ("screen size %dx%d too big", width, height);
6424 adjust_frame_glyphs_initially ();
6425 calculate_costs (XFRAME (selected_frame));
6427 /* Set up faces of the initial terminal frame of a dumped Emacs. */
6428 if (initialized
6429 && !noninteractive
6430 && NILP (Vinitial_window_system))
6432 /* For the initial frame, we don't have any way of knowing what
6433 are the foreground and background colors of the terminal. */
6434 struct frame *sf = SELECTED_FRAME ();
6436 FRAME_FOREGROUND_PIXEL (sf) = FACE_TTY_DEFAULT_FG_COLOR;
6437 FRAME_BACKGROUND_PIXEL (sf) = FACE_TTY_DEFAULT_BG_COLOR;
6438 call0 (intern ("tty-set-up-initial-frame-faces"));
6444 /***********************************************************************
6445 Blinking cursor
6446 ***********************************************************************/
6448 DEFUN ("internal-show-cursor", Finternal_show_cursor,
6449 Sinternal_show_cursor, 2, 2, 0,
6450 doc: /* Set the cursor-visibility flag of WINDOW to SHOW.
6451 WINDOW nil means use the selected window. SHOW non-nil means
6452 show a cursor in WINDOW in the next redisplay. SHOW nil means
6453 don't show a cursor. */)
6454 (Lisp_Object window, Lisp_Object show)
6456 /* Don't change cursor state while redisplaying. This could confuse
6457 output routines. */
6458 if (!redisplaying_p)
6460 if (NILP (window))
6461 window = selected_window;
6462 else
6463 CHECK_WINDOW (window);
6465 XWINDOW (window)->cursor_off_p = NILP (show);
6468 return Qnil;
6472 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p,
6473 Sinternal_show_cursor_p, 0, 1, 0,
6474 doc: /* Value is non-nil if next redisplay will display a cursor in WINDOW.
6475 WINDOW nil or omitted means report on the selected window. */)
6476 (Lisp_Object window)
6478 struct window *w;
6480 if (NILP (window))
6481 window = selected_window;
6482 else
6483 CHECK_WINDOW (window);
6485 w = XWINDOW (window);
6486 return w->cursor_off_p ? Qnil : Qt;
6489 DEFUN ("last-nonminibuffer-frame", Flast_nonminibuf_frame,
6490 Slast_nonminibuf_frame, 0, 0, 0,
6491 doc: /* Value is last nonminibuffer frame. */)
6492 (void)
6494 Lisp_Object frame = Qnil;
6496 if (last_nonminibuf_frame)
6497 XSETFRAME (frame, last_nonminibuf_frame);
6499 return frame;
6502 /***********************************************************************
6503 Initialization
6504 ***********************************************************************/
6506 void
6507 syms_of_display (void)
6509 defsubr (&Sredraw_frame);
6510 defsubr (&Sredraw_display);
6511 defsubr (&Sframe_or_buffer_changed_p);
6512 defsubr (&Sopen_termscript);
6513 defsubr (&Sding);
6514 defsubr (&Sredisplay);
6515 defsubr (&Ssleep_for);
6516 defsubr (&Ssend_string_to_terminal);
6517 defsubr (&Sinternal_show_cursor);
6518 defsubr (&Sinternal_show_cursor_p);
6519 defsubr (&Slast_nonminibuf_frame);
6521 #if GLYPH_DEBUG
6522 defsubr (&Sdump_redisplay_history);
6523 #endif
6525 frame_and_buffer_state = Fmake_vector (make_number (20), Qlambda);
6526 staticpro (&frame_and_buffer_state);
6528 DEFSYM (Qdisplay_table, "display-table");
6529 DEFSYM (Qredisplay_dont_pause, "redisplay-dont-pause");
6531 DEFVAR_INT ("baud-rate", baud_rate,
6532 doc: /* The output baud rate of the terminal.
6533 On most systems, changing this value will affect the amount of padding
6534 and the other strategic decisions made during redisplay. */);
6536 DEFVAR_BOOL ("inverse-video", inverse_video,
6537 doc: /* Non-nil means invert the entire frame display.
6538 This means everything is in inverse video which otherwise would not be. */);
6540 DEFVAR_BOOL ("visible-bell", visible_bell,
6541 doc: /* Non-nil means try to flash the frame to represent a bell.
6543 See also `ring-bell-function'. */);
6545 DEFVAR_BOOL ("no-redraw-on-reenter", no_redraw_on_reenter,
6546 doc: /* Non-nil means no need to redraw entire frame after suspending.
6547 A non-nil value is useful if the terminal can automatically preserve
6548 Emacs's frame display when you reenter Emacs.
6549 It is up to you to set this variable if your terminal can do that. */);
6551 DEFVAR_LISP ("initial-window-system", Vinitial_window_system,
6552 doc: /* Name of the window system that Emacs uses for the first frame.
6553 The value is a symbol:
6554 nil for a termcap frame (a character-only terminal),
6555 'x' for an Emacs frame that is really an X window,
6556 'w32' for an Emacs frame that is a window on MS-Windows display,
6557 'ns' for an Emacs frame on a GNUstep or Macintosh Cocoa display,
6558 'pc' for a direct-write MS-DOS frame.
6560 Use of this variable as a boolean is deprecated. Instead,
6561 use `display-graphic-p' or any of the other `display-*-p'
6562 predicates which report frame's specific UI-related capabilities. */);
6564 DEFVAR_KBOARD ("window-system", Vwindow_system,
6565 doc: /* Name of window system through which the selected frame is displayed.
6566 The value is a symbol:
6567 nil for a termcap frame (a character-only terminal),
6568 'x' for an Emacs frame that is really an X window,
6569 'w32' for an Emacs frame that is a window on MS-Windows display,
6570 'ns' for an Emacs frame on a GNUstep or Macintosh Cocoa display,
6571 'pc' for a direct-write MS-DOS frame.
6573 Use of this variable as a boolean is deprecated. Instead,
6574 use `display-graphic-p' or any of the other `display-*-p'
6575 predicates which report frame's specific UI-related capabilities. */);
6577 DEFVAR_LISP ("window-system-version", Vwindow_system_version,
6578 doc: /* The version number of the window system in use.
6579 For X windows, this is 11. */);
6581 DEFVAR_BOOL ("cursor-in-echo-area", cursor_in_echo_area,
6582 doc: /* Non-nil means put cursor in minibuffer, at end of any message there. */);
6584 DEFVAR_LISP ("glyph-table", Vglyph_table,
6585 doc: /* Table defining how to output a glyph code to the frame.
6586 If not nil, this is a vector indexed by glyph code to define the glyph.
6587 Each element can be:
6588 integer: a glyph code which this glyph is an alias for.
6589 string: output this glyph using that string (not impl. in X windows).
6590 nil: this glyph mod 524288 is the code of a character to output,
6591 and this glyph / 524288 is the face number (see `face-id') to use
6592 while outputting it. */);
6593 Vglyph_table = Qnil;
6595 DEFVAR_LISP ("standard-display-table", Vstandard_display_table,
6596 doc: /* Display table to use for buffers that specify none.
6597 See `buffer-display-table' for more information. */);
6598 Vstandard_display_table = Qnil;
6600 DEFVAR_BOOL ("redisplay-dont-pause", redisplay_dont_pause,
6601 doc: /* Non-nil means display update isn't paused when input is detected. */);
6602 redisplay_dont_pause = 1;
6604 #if PERIODIC_PREEMPTION_CHECKING
6605 DEFVAR_LISP ("redisplay-preemption-period", Vredisplay_preemption_period,
6606 doc: /* Period in seconds between checking for input during redisplay.
6607 This has an effect only if `redisplay-dont-pause' is nil; in that
6608 case, arriving input preempts redisplay until the input is processed.
6609 If the value is nil, redisplay is never preempted. */);
6610 Vredisplay_preemption_period = make_float (0.10);
6611 #endif
6613 #ifdef CANNOT_DUMP
6614 if (noninteractive)
6615 #endif
6617 Vinitial_window_system = Qnil;
6618 Vwindow_system_version = Qnil;