(dired-listing-switches): apparently, "ls -b" is actually supposed to work
[emacs.git] / src / dispnew.c
blob02d6de53bbf4568acdae50a443f4948cf2101cd5
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];
1088 short used_tem = a->used[i];
1090 a->glyphs[i] = b->glyphs[i];
1091 b->glyphs[i] = temp;
1092 a->used[i] = b->used[i];
1093 b->used[i] = used_tem;
1095 a->hash = b->hash;
1096 b->hash = hash_tem;
1100 /* Copy glyph row structure FROM to glyph row structure TO, except
1101 that glyph pointers, the `used' counts, and the hash values in the
1102 structures are left unchanged. */
1104 static inline void
1105 copy_row_except_pointers (struct glyph_row *to, struct glyph_row *from)
1107 struct glyph *pointers[1 + LAST_AREA];
1108 short used[1 + LAST_AREA];
1109 unsigned hashval;
1111 /* Save glyph pointers of TO. */
1112 memcpy (pointers, to->glyphs, sizeof to->glyphs);
1113 memcpy (used, to->used, sizeof to->used);
1114 hashval = to->hash;
1116 /* Do a structure assignment. */
1117 *to = *from;
1119 /* Restore original pointers of TO. */
1120 memcpy (to->glyphs, pointers, sizeof to->glyphs);
1121 memcpy (to->used, used, sizeof to->used);
1122 to->hash = hashval;
1126 /* Assign glyph row FROM to glyph row TO. This works like a structure
1127 assignment TO = FROM, except that glyph pointers are not copied but
1128 exchanged between TO and FROM. Pointers must be exchanged to avoid
1129 a memory leak. */
1131 static inline void
1132 assign_row (struct glyph_row *to, struct glyph_row *from)
1134 swap_glyph_pointers (to, from);
1135 copy_row_except_pointers (to, from);
1139 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1140 a row in a window matrix, is a slice of the glyph memory of the
1141 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1142 is non-zero if the glyph memory of WINDOW_ROW is part of the glyph
1143 memory of FRAME_ROW. */
1145 #if GLYPH_DEBUG
1147 static int
1148 glyph_row_slice_p (struct glyph_row *window_row, struct glyph_row *frame_row)
1150 struct glyph *window_glyph_start = window_row->glyphs[0];
1151 struct glyph *frame_glyph_start = frame_row->glyphs[0];
1152 struct glyph *frame_glyph_end = frame_row->glyphs[LAST_AREA];
1154 return (frame_glyph_start <= window_glyph_start
1155 && window_glyph_start < frame_glyph_end);
1158 #endif /* GLYPH_DEBUG */
1160 #if 0
1162 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1163 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1164 in WINDOW_MATRIX is found satisfying the condition. */
1166 static struct glyph_row *
1167 find_glyph_row_slice (struct glyph_matrix *window_matrix,
1168 struct glyph_matrix *frame_matrix, int row)
1170 int i;
1172 xassert (row >= 0 && row < frame_matrix->nrows);
1174 for (i = 0; i < window_matrix->nrows; ++i)
1175 if (glyph_row_slice_p (window_matrix->rows + i,
1176 frame_matrix->rows + row))
1177 break;
1179 return i < window_matrix->nrows ? window_matrix->rows + i : 0;
1182 #endif /* 0 */
1184 /* Prepare ROW for display. Desired rows are cleared lazily,
1185 i.e. they are only marked as to be cleared by setting their
1186 enabled_p flag to zero. When a row is to be displayed, a prior
1187 call to this function really clears it. */
1189 void
1190 prepare_desired_row (struct glyph_row *row)
1192 if (!row->enabled_p)
1194 int rp = row->reversed_p;
1196 clear_glyph_row (row);
1197 row->enabled_p = 1;
1198 row->reversed_p = rp;
1203 /* Return a hash code for glyph row ROW. */
1205 static int
1206 line_hash_code (struct glyph_row *row)
1208 int hash = 0;
1210 if (row->enabled_p)
1212 struct glyph *glyph = row->glyphs[TEXT_AREA];
1213 struct glyph *end = glyph + row->used[TEXT_AREA];
1215 while (glyph < end)
1217 int c = glyph->u.ch;
1218 int face_id = glyph->face_id;
1219 if (FRAME_MUST_WRITE_SPACES (SELECTED_FRAME ())) /* XXX Is SELECTED_FRAME OK here? */
1220 c -= SPACEGLYPH;
1221 hash = (((hash << 4) + (hash >> 24)) & 0x0fffffff) + c;
1222 hash = (((hash << 4) + (hash >> 24)) & 0x0fffffff) + face_id;
1223 ++glyph;
1226 if (hash == 0)
1227 hash = 1;
1230 return hash;
1234 /* Return the cost of drawing line VPOS in MATRIX. The cost equals
1235 the number of characters in the line. If must_write_spaces is
1236 zero, leading and trailing spaces are ignored. */
1238 static int
1239 line_draw_cost (struct glyph_matrix *matrix, int vpos)
1241 struct glyph_row *row = matrix->rows + vpos;
1242 struct glyph *beg = row->glyphs[TEXT_AREA];
1243 struct glyph *end = beg + row->used[TEXT_AREA];
1244 int len;
1245 Lisp_Object *glyph_table_base = GLYPH_TABLE_BASE;
1246 ptrdiff_t glyph_table_len = GLYPH_TABLE_LENGTH;
1248 /* Ignore trailing and leading spaces if we can. */
1249 if (!FRAME_MUST_WRITE_SPACES (SELECTED_FRAME ())) /* XXX Is SELECTED_FRAME OK here? */
1251 /* Skip from the end over trailing spaces. */
1252 while (end > beg && CHAR_GLYPH_SPACE_P (*(end - 1)))
1253 --end;
1255 /* All blank line. */
1256 if (end == beg)
1257 return 0;
1259 /* Skip over leading spaces. */
1260 while (CHAR_GLYPH_SPACE_P (*beg))
1261 ++beg;
1264 /* If we don't have a glyph-table, each glyph is one character,
1265 so return the number of glyphs. */
1266 if (glyph_table_base == 0)
1267 len = end - beg;
1268 else
1270 /* Otherwise, scan the glyphs and accumulate their total length
1271 in LEN. */
1272 len = 0;
1273 while (beg < end)
1275 GLYPH g;
1277 SET_GLYPH_FROM_CHAR_GLYPH (g, *beg);
1279 if (GLYPH_INVALID_P (g)
1280 || GLYPH_SIMPLE_P (glyph_table_base, glyph_table_len, g))
1281 len += 1;
1282 else
1283 len += GLYPH_LENGTH (glyph_table_base, g);
1285 ++beg;
1289 return len;
1293 /* Test two glyph rows A and B for equality. Value is non-zero if A
1294 and B have equal contents. MOUSE_FACE_P non-zero means compare the
1295 mouse_face_p flags of A and B, too. */
1297 static inline int
1298 row_equal_p (struct glyph_row *a, struct glyph_row *b, int mouse_face_p)
1300 xassert (verify_row_hash (a));
1301 xassert (verify_row_hash (b));
1303 if (a == b)
1304 return 1;
1305 else if (a->hash != b->hash)
1306 return 0;
1307 else
1309 struct glyph *a_glyph, *b_glyph, *a_end;
1310 int area;
1312 if (mouse_face_p && a->mouse_face_p != b->mouse_face_p)
1313 return 0;
1315 /* Compare glyphs. */
1316 for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
1318 if (a->used[area] != b->used[area])
1319 return 0;
1321 a_glyph = a->glyphs[area];
1322 a_end = a_glyph + a->used[area];
1323 b_glyph = b->glyphs[area];
1325 while (a_glyph < a_end
1326 && GLYPH_EQUAL_P (a_glyph, b_glyph))
1327 ++a_glyph, ++b_glyph;
1329 if (a_glyph != a_end)
1330 return 0;
1333 if (a->fill_line_p != b->fill_line_p
1334 || a->cursor_in_fringe_p != b->cursor_in_fringe_p
1335 || a->left_fringe_bitmap != b->left_fringe_bitmap
1336 || a->left_fringe_face_id != b->left_fringe_face_id
1337 || a->left_fringe_offset != b->left_fringe_offset
1338 || a->right_fringe_bitmap != b->right_fringe_bitmap
1339 || a->right_fringe_face_id != b->right_fringe_face_id
1340 || a->right_fringe_offset != b->right_fringe_offset
1341 || a->fringe_bitmap_periodic_p != b->fringe_bitmap_periodic_p
1342 || a->overlay_arrow_bitmap != b->overlay_arrow_bitmap
1343 || a->exact_window_width_line_p != b->exact_window_width_line_p
1344 || a->overlapped_p != b->overlapped_p
1345 || (MATRIX_ROW_CONTINUATION_LINE_P (a)
1346 != MATRIX_ROW_CONTINUATION_LINE_P (b))
1347 || a->reversed_p != b->reversed_p
1348 /* Different partially visible characters on left margin. */
1349 || a->x != b->x
1350 /* Different height. */
1351 || a->ascent != b->ascent
1352 || a->phys_ascent != b->phys_ascent
1353 || a->phys_height != b->phys_height
1354 || a->visible_height != b->visible_height)
1355 return 0;
1358 return 1;
1363 /***********************************************************************
1364 Glyph Pool
1366 See dispextern.h for an overall explanation of glyph pools.
1367 ***********************************************************************/
1369 /* Allocate a glyph_pool structure. The structure returned is
1370 initialized with zeros. The global variable glyph_pool_count is
1371 incremented for each pool allocated. */
1373 static struct glyph_pool *
1374 new_glyph_pool (void)
1376 struct glyph_pool *result;
1378 /* Allocate a new glyph_pool and clear it. */
1379 result = (struct glyph_pool *) xmalloc (sizeof *result);
1380 memset (result, 0, sizeof *result);
1382 /* For memory leak and double deletion checking. */
1383 ++glyph_pool_count;
1385 return result;
1389 /* Free a glyph_pool structure POOL. The function may be called with
1390 a null POOL pointer. The global variable glyph_pool_count is
1391 decremented with every pool structure freed. If this count gets
1392 negative, more structures were freed than allocated, i.e. one
1393 structure must have been freed more than once or a bogus pointer
1394 was passed to free_glyph_pool. */
1396 static void
1397 free_glyph_pool (struct glyph_pool *pool)
1399 if (pool)
1401 /* More freed than allocated? */
1402 --glyph_pool_count;
1403 xassert (glyph_pool_count >= 0);
1405 xfree (pool->glyphs);
1406 xfree (pool);
1411 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1412 columns we need. This function never shrinks a pool. The only
1413 case in which this would make sense, would be when a frame's size
1414 is changed from a large value to a smaller one. But, if someone
1415 does it once, we can expect that he will do it again.
1417 Value is non-zero if the pool changed in a way which makes
1418 re-adjusting window glyph matrices necessary. */
1420 static int
1421 realloc_glyph_pool (struct glyph_pool *pool, struct dim matrix_dim)
1423 ptrdiff_t needed;
1424 int changed_p;
1426 changed_p = (pool->glyphs == 0
1427 || matrix_dim.height != pool->nrows
1428 || matrix_dim.width != pool->ncolumns);
1430 /* Enlarge the glyph pool. */
1431 needed = matrix_dim.width;
1432 if (INT_MULTIPLY_OVERFLOW (needed, matrix_dim.height))
1433 memory_full (SIZE_MAX);
1434 needed *= matrix_dim.height;
1435 if (needed > pool->nglyphs)
1437 ptrdiff_t old_nglyphs = pool->nglyphs;
1438 pool->glyphs = xpalloc (pool->glyphs, &pool->nglyphs,
1439 needed - old_nglyphs, -1, sizeof *pool->glyphs);
1440 memset (pool->glyphs + old_nglyphs, 0,
1441 (pool->nglyphs - old_nglyphs) * sizeof *pool->glyphs);
1444 /* Remember the number of rows and columns because (a) we use them
1445 to do sanity checks, and (b) the number of columns determines
1446 where rows in the frame matrix start---this must be available to
1447 determine pointers to rows of window sub-matrices. */
1448 pool->nrows = matrix_dim.height;
1449 pool->ncolumns = matrix_dim.width;
1451 return changed_p;
1456 /***********************************************************************
1457 Debug Code
1458 ***********************************************************************/
1460 #if GLYPH_DEBUG
1463 /* Flush standard output. This is sometimes useful to call from the debugger.
1464 XXX Maybe this should be changed to flush the current terminal instead of
1465 stdout.
1468 void flush_stdout (void) EXTERNALLY_VISIBLE;
1470 void
1471 flush_stdout (void)
1473 fflush (stdout);
1477 /* Check that no glyph pointers have been lost in MATRIX. If a
1478 pointer has been lost, e.g. by using a structure assignment between
1479 rows, at least one pointer must occur more than once in the rows of
1480 MATRIX. */
1482 void
1483 check_matrix_pointer_lossage (struct glyph_matrix *matrix)
1485 int i, j;
1487 for (i = 0; i < matrix->nrows; ++i)
1488 for (j = 0; j < matrix->nrows; ++j)
1489 xassert (i == j
1490 || (matrix->rows[i].glyphs[TEXT_AREA]
1491 != matrix->rows[j].glyphs[TEXT_AREA]));
1495 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1497 struct glyph_row *
1498 matrix_row (struct glyph_matrix *matrix, int row)
1500 xassert (matrix && matrix->rows);
1501 xassert (row >= 0 && row < matrix->nrows);
1503 /* That's really too slow for normal testing because this function
1504 is called almost everywhere. Although---it's still astonishingly
1505 fast, so it is valuable to have for debugging purposes. */
1506 #if 0
1507 check_matrix_pointer_lossage (matrix);
1508 #endif
1510 return matrix->rows + row;
1514 #if 0 /* This function makes invalid assumptions when text is
1515 partially invisible. But it might come handy for debugging
1516 nevertheless. */
1518 /* Check invariants that must hold for an up to date current matrix of
1519 window W. */
1521 static void
1522 check_matrix_invariants (struct window *w)
1524 struct glyph_matrix *matrix = w->current_matrix;
1525 int yb = window_text_bottom_y (w);
1526 struct glyph_row *row = matrix->rows;
1527 struct glyph_row *last_text_row = NULL;
1528 struct buffer *saved = current_buffer;
1529 struct buffer *buffer = XBUFFER (w->buffer);
1530 int c;
1532 /* This can sometimes happen for a fresh window. */
1533 if (matrix->nrows < 2)
1534 return;
1536 set_buffer_temp (buffer);
1538 /* Note: last row is always reserved for the mode line. */
1539 while (MATRIX_ROW_DISPLAYS_TEXT_P (row)
1540 && MATRIX_ROW_BOTTOM_Y (row) < yb)
1542 struct glyph_row *next = row + 1;
1544 if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
1545 last_text_row = row;
1547 /* Check that character and byte positions are in sync. */
1548 xassert (MATRIX_ROW_START_BYTEPOS (row)
1549 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row)));
1550 xassert (BYTEPOS (row->start.pos)
1551 == CHAR_TO_BYTE (CHARPOS (row->start.pos)));
1553 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1554 have such a position temporarily in case of a minibuffer
1555 displaying something like `[Sole completion]' at its end. */
1556 if (MATRIX_ROW_END_CHARPOS (row) < BUF_ZV (current_buffer))
1558 xassert (MATRIX_ROW_END_BYTEPOS (row)
1559 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row)));
1560 xassert (BYTEPOS (row->end.pos)
1561 == CHAR_TO_BYTE (CHARPOS (row->end.pos)));
1564 /* Check that end position of `row' is equal to start position
1565 of next row. */
1566 if (next->enabled_p && MATRIX_ROW_DISPLAYS_TEXT_P (next))
1568 xassert (MATRIX_ROW_END_CHARPOS (row)
1569 == MATRIX_ROW_START_CHARPOS (next));
1570 xassert (MATRIX_ROW_END_BYTEPOS (row)
1571 == MATRIX_ROW_START_BYTEPOS (next));
1572 xassert (CHARPOS (row->end.pos) == CHARPOS (next->start.pos));
1573 xassert (BYTEPOS (row->end.pos) == BYTEPOS (next->start.pos));
1575 row = next;
1578 xassert (w->current_matrix->nrows == w->desired_matrix->nrows);
1579 xassert (w->desired_matrix->rows != NULL);
1580 set_buffer_temp (saved);
1583 #endif /* 0 */
1585 #endif /* GLYPH_DEBUG != 0 */
1589 /**********************************************************************
1590 Allocating/ Adjusting Glyph Matrices
1591 **********************************************************************/
1593 /* Allocate glyph matrices over a window tree for a frame-based
1594 redisplay
1596 X and Y are column/row within the frame glyph matrix where
1597 sub-matrices for the window tree rooted at WINDOW must be
1598 allocated. DIM_ONLY_P non-zero means that the caller of this
1599 function is only interested in the result matrix dimension, and
1600 matrix adjustments should not be performed.
1602 The function returns the total width/height of the sub-matrices of
1603 the window tree. If called on a frame root window, the computation
1604 will take the mini-buffer window into account.
1606 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1608 NEW_LEAF_MATRIX set if any window in the tree did not have a
1609 glyph matrices yet, and
1611 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1612 any window in the tree will be changed or have been changed (see
1613 DIM_ONLY_P)
1615 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1616 function.
1618 Windows are arranged into chains of windows on the same level
1619 through the next fields of window structures. Such a level can be
1620 either a sequence of horizontally adjacent windows from left to
1621 right, or a sequence of vertically adjacent windows from top to
1622 bottom. Each window in a horizontal sequence can be either a leaf
1623 window or a vertical sequence; a window in a vertical sequence can
1624 be either a leaf or a horizontal sequence. All windows in a
1625 horizontal sequence have the same height, and all windows in a
1626 vertical sequence have the same width.
1628 This function uses, for historical reasons, a more general
1629 algorithm to determine glyph matrix dimensions that would be
1630 necessary.
1632 The matrix height of a horizontal sequence is determined by the
1633 maximum height of any matrix in the sequence. The matrix width of
1634 a horizontal sequence is computed by adding up matrix widths of
1635 windows in the sequence.
1637 |<------- result width ------->|
1638 +---------+----------+---------+ ---
1639 | | | | |
1640 | | | |
1641 +---------+ | | result height
1642 | +---------+
1643 | | |
1644 +----------+ ---
1646 The matrix width of a vertical sequence is the maximum matrix width
1647 of any window in the sequence. Its height is computed by adding up
1648 matrix heights of windows in the sequence.
1650 |<---- result width -->|
1651 +---------+ ---
1652 | | |
1653 | | |
1654 +---------+--+ |
1655 | | |
1656 | | result height
1658 +------------+---------+ |
1659 | | |
1660 | | |
1661 +------------+---------+ --- */
1663 /* Bit indicating that a new matrix will be allocated or has been
1664 allocated. */
1666 #define NEW_LEAF_MATRIX (1 << 0)
1668 /* Bit indicating that a matrix will or has changed its location or
1669 size. */
1671 #define CHANGED_LEAF_MATRIX (1 << 1)
1673 static struct dim
1674 allocate_matrices_for_frame_redisplay (Lisp_Object window, int x, int y,
1675 int dim_only_p, int *window_change_flags)
1677 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (window)));
1678 int x0 = x, y0 = y;
1679 int wmax = 0, hmax = 0;
1680 struct dim total;
1681 struct dim dim;
1682 struct window *w;
1683 int in_horz_combination_p;
1685 /* What combination is WINDOW part of? Compute this once since the
1686 result is the same for all windows in the `next' chain. The
1687 special case of a root window (parent equal to nil) is treated
1688 like a vertical combination because a root window's `next'
1689 points to the mini-buffer window, if any, which is arranged
1690 vertically below other windows. */
1691 in_horz_combination_p
1692 = (!NILP (XWINDOW (window)->parent)
1693 && !NILP (XWINDOW (XWINDOW (window)->parent)->hchild));
1695 /* For WINDOW and all windows on the same level. */
1698 w = XWINDOW (window);
1700 /* Get the dimension of the window sub-matrix for W, depending
1701 on whether this is a combination or a leaf window. */
1702 if (!NILP (w->hchild))
1703 dim = allocate_matrices_for_frame_redisplay (w->hchild, x, y,
1704 dim_only_p,
1705 window_change_flags);
1706 else if (!NILP (w->vchild))
1707 dim = allocate_matrices_for_frame_redisplay (w->vchild, x, y,
1708 dim_only_p,
1709 window_change_flags);
1710 else
1712 /* If not already done, allocate sub-matrix structures. */
1713 if (w->desired_matrix == NULL)
1715 w->desired_matrix = new_glyph_matrix (f->desired_pool);
1716 w->current_matrix = new_glyph_matrix (f->current_pool);
1717 *window_change_flags |= NEW_LEAF_MATRIX;
1720 /* Width and height MUST be chosen so that there are no
1721 holes in the frame matrix. */
1722 dim.width = required_matrix_width (w);
1723 dim.height = required_matrix_height (w);
1725 /* Will matrix be re-allocated? */
1726 if (x != w->desired_matrix->matrix_x
1727 || y != w->desired_matrix->matrix_y
1728 || dim.width != w->desired_matrix->matrix_w
1729 || dim.height != w->desired_matrix->matrix_h
1730 || (margin_glyphs_to_reserve (w, dim.width,
1731 w->left_margin_cols)
1732 != w->desired_matrix->left_margin_glyphs)
1733 || (margin_glyphs_to_reserve (w, dim.width,
1734 w->right_margin_cols)
1735 != w->desired_matrix->right_margin_glyphs))
1736 *window_change_flags |= CHANGED_LEAF_MATRIX;
1738 /* Actually change matrices, if allowed. Do not consider
1739 CHANGED_LEAF_MATRIX computed above here because the pool
1740 may have been changed which we don't now here. We trust
1741 that we only will be called with DIM_ONLY_P != 0 when
1742 necessary. */
1743 if (!dim_only_p)
1745 adjust_glyph_matrix (w, w->desired_matrix, x, y, dim);
1746 adjust_glyph_matrix (w, w->current_matrix, x, y, dim);
1750 /* If we are part of a horizontal combination, advance x for
1751 windows to the right of W; otherwise advance y for windows
1752 below W. */
1753 if (in_horz_combination_p)
1754 x += dim.width;
1755 else
1756 y += dim.height;
1758 /* Remember maximum glyph matrix dimensions. */
1759 wmax = max (wmax, dim.width);
1760 hmax = max (hmax, dim.height);
1762 /* Next window on same level. */
1763 window = w->next;
1765 while (!NILP (window));
1767 /* Set `total' to the total glyph matrix dimension of this window
1768 level. In a vertical combination, the width is the width of the
1769 widest window; the height is the y we finally reached, corrected
1770 by the y we started with. In a horizontal combination, the total
1771 height is the height of the tallest window, and the width is the
1772 x we finally reached, corrected by the x we started with. */
1773 if (in_horz_combination_p)
1775 total.width = x - x0;
1776 total.height = hmax;
1778 else
1780 total.width = wmax;
1781 total.height = y - y0;
1784 return total;
1788 /* Return the required height of glyph matrices for window W. */
1790 static int
1791 required_matrix_height (struct window *w)
1793 #ifdef HAVE_WINDOW_SYSTEM
1794 struct frame *f = XFRAME (w->frame);
1796 if (FRAME_WINDOW_P (f))
1798 int ch_height = FRAME_SMALLEST_FONT_HEIGHT (f);
1799 int window_pixel_height = window_box_height (w) + eabs (w->vscroll);
1800 return (((window_pixel_height + ch_height - 1)
1801 / ch_height) * w->nrows_scale_factor
1802 /* One partially visible line at the top and
1803 bottom of the window. */
1805 /* 2 for header and mode line. */
1806 + 2);
1808 #endif /* HAVE_WINDOW_SYSTEM */
1810 return WINDOW_TOTAL_LINES (w);
1814 /* Return the required width of glyph matrices for window W. */
1816 static int
1817 required_matrix_width (struct window *w)
1819 #ifdef HAVE_WINDOW_SYSTEM
1820 struct frame *f = XFRAME (w->frame);
1821 if (FRAME_WINDOW_P (f))
1823 int ch_width = FRAME_SMALLEST_CHAR_WIDTH (f);
1824 int window_pixel_width = WINDOW_TOTAL_WIDTH (w);
1826 /* Compute number of glyphs needed in a glyph row. */
1827 return (((window_pixel_width + ch_width - 1)
1828 / ch_width) * w->ncols_scale_factor
1829 /* 2 partially visible columns in the text area. */
1831 /* One partially visible column at the right
1832 edge of each marginal area. */
1833 + 1 + 1);
1835 #endif /* HAVE_WINDOW_SYSTEM */
1837 return XINT (w->total_cols);
1841 /* Allocate window matrices for window-based redisplay. W is the
1842 window whose matrices must be allocated/reallocated. */
1844 static void
1845 allocate_matrices_for_window_redisplay (struct window *w)
1847 while (w)
1849 if (!NILP (w->vchild))
1850 allocate_matrices_for_window_redisplay (XWINDOW (w->vchild));
1851 else if (!NILP (w->hchild))
1852 allocate_matrices_for_window_redisplay (XWINDOW (w->hchild));
1853 else
1855 /* W is a leaf window. */
1856 struct dim dim;
1858 /* If matrices are not yet allocated, allocate them now. */
1859 if (w->desired_matrix == NULL)
1861 w->desired_matrix = new_glyph_matrix (NULL);
1862 w->current_matrix = new_glyph_matrix (NULL);
1865 dim.width = required_matrix_width (w);
1866 dim.height = required_matrix_height (w);
1867 adjust_glyph_matrix (w, w->desired_matrix, 0, 0, dim);
1868 adjust_glyph_matrix (w, w->current_matrix, 0, 0, dim);
1871 w = NILP (w->next) ? NULL : XWINDOW (w->next);
1876 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
1877 do it for all frames; otherwise do it just for the given frame.
1878 This function must be called when a new frame is created, its size
1879 changes, or its window configuration changes. */
1881 void
1882 adjust_glyphs (struct frame *f)
1884 /* Block input so that expose events and other events that access
1885 glyph matrices are not processed while we are changing them. */
1886 BLOCK_INPUT;
1888 if (f)
1889 adjust_frame_glyphs (f);
1890 else
1892 Lisp_Object tail, lisp_frame;
1894 FOR_EACH_FRAME (tail, lisp_frame)
1895 adjust_frame_glyphs (XFRAME (lisp_frame));
1898 UNBLOCK_INPUT;
1902 /* Adjust frame glyphs when Emacs is initialized.
1904 To be called from init_display.
1906 We need a glyph matrix because redraw will happen soon.
1907 Unfortunately, window sizes on selected_frame are not yet set to
1908 meaningful values. I believe we can assume that there are only two
1909 windows on the frame---the mini-buffer and the root window. Frame
1910 height and width seem to be correct so far. So, set the sizes of
1911 windows to estimated values. */
1913 static void
1914 adjust_frame_glyphs_initially (void)
1916 struct frame *sf = SELECTED_FRAME ();
1917 struct window *root = XWINDOW (sf->root_window);
1918 struct window *mini = XWINDOW (root->next);
1919 int frame_lines = FRAME_LINES (sf);
1920 int frame_cols = FRAME_COLS (sf);
1921 int top_margin = FRAME_TOP_MARGIN (sf);
1923 /* Do it for the root window. */
1924 XSETFASTINT (root->top_line, top_margin);
1925 XSETFASTINT (root->total_lines, frame_lines - 1 - top_margin);
1926 XSETFASTINT (root->total_cols, frame_cols);
1928 /* Do it for the mini-buffer window. */
1929 XSETFASTINT (mini->top_line, frame_lines - 1);
1930 XSETFASTINT (mini->total_lines, 1);
1931 XSETFASTINT (mini->total_cols, frame_cols);
1933 adjust_frame_glyphs (sf);
1934 glyphs_initialized_initially_p = 1;
1938 /* Allocate/reallocate glyph matrices of a single frame F. */
1940 static void
1941 adjust_frame_glyphs (struct frame *f)
1943 if (FRAME_WINDOW_P (f))
1944 adjust_frame_glyphs_for_window_redisplay (f);
1945 else
1946 adjust_frame_glyphs_for_frame_redisplay (f);
1948 /* Don't forget the message buffer and the buffer for
1949 decode_mode_spec. */
1950 adjust_frame_message_buffer (f);
1951 adjust_decode_mode_spec_buffer (f);
1953 f->glyphs_initialized_p = 1;
1956 /* Return 1 if any window in the tree has nonzero window margins. See
1957 the hack at the end of adjust_frame_glyphs_for_frame_redisplay. */
1958 static int
1959 showing_window_margins_p (struct window *w)
1961 while (w)
1963 if (!NILP (w->hchild))
1965 if (showing_window_margins_p (XWINDOW (w->hchild)))
1966 return 1;
1968 else if (!NILP (w->vchild))
1970 if (showing_window_margins_p (XWINDOW (w->vchild)))
1971 return 1;
1973 else if (!NILP (w->left_margin_cols)
1974 || !NILP (w->right_margin_cols))
1975 return 1;
1977 w = NILP (w->next) ? 0 : XWINDOW (w->next);
1979 return 0;
1983 /* In the window tree with root W, build current matrices of leaf
1984 windows from the frame's current matrix. */
1986 static void
1987 fake_current_matrices (Lisp_Object window)
1989 struct window *w;
1991 for (; !NILP (window); window = w->next)
1993 w = XWINDOW (window);
1995 if (!NILP (w->hchild))
1996 fake_current_matrices (w->hchild);
1997 else if (!NILP (w->vchild))
1998 fake_current_matrices (w->vchild);
1999 else
2001 int i;
2002 struct frame *f = XFRAME (w->frame);
2003 struct glyph_matrix *m = w->current_matrix;
2004 struct glyph_matrix *fm = f->current_matrix;
2006 xassert (m->matrix_h == WINDOW_TOTAL_LINES (w));
2007 xassert (m->matrix_w == WINDOW_TOTAL_COLS (w));
2009 for (i = 0; i < m->matrix_h; ++i)
2011 struct glyph_row *r = m->rows + i;
2012 struct glyph_row *fr = fm->rows + i + WINDOW_TOP_EDGE_LINE (w);
2014 xassert (r->glyphs[TEXT_AREA] >= fr->glyphs[TEXT_AREA]
2015 && r->glyphs[LAST_AREA] <= fr->glyphs[LAST_AREA]);
2017 r->enabled_p = fr->enabled_p;
2018 if (r->enabled_p)
2020 r->used[LEFT_MARGIN_AREA] = m->left_margin_glyphs;
2021 r->used[RIGHT_MARGIN_AREA] = m->right_margin_glyphs;
2022 r->used[TEXT_AREA] = (m->matrix_w
2023 - r->used[LEFT_MARGIN_AREA]
2024 - r->used[RIGHT_MARGIN_AREA]);
2025 r->mode_line_p = 0;
2033 /* Save away the contents of frame F's current frame matrix. Value is
2034 a glyph matrix holding the contents of F's current frame matrix. */
2036 static struct glyph_matrix *
2037 save_current_matrix (struct frame *f)
2039 int i;
2040 struct glyph_matrix *saved;
2042 saved = (struct glyph_matrix *) xmalloc (sizeof *saved);
2043 memset (saved, 0, sizeof *saved);
2044 saved->nrows = f->current_matrix->nrows;
2045 saved->rows = (struct glyph_row *) xmalloc (saved->nrows
2046 * sizeof *saved->rows);
2047 memset (saved->rows, 0, saved->nrows * sizeof *saved->rows);
2049 for (i = 0; i < saved->nrows; ++i)
2051 struct glyph_row *from = f->current_matrix->rows + i;
2052 struct glyph_row *to = saved->rows + i;
2053 ptrdiff_t nbytes = from->used[TEXT_AREA] * sizeof (struct glyph);
2054 to->glyphs[TEXT_AREA] = (struct glyph *) xmalloc (nbytes);
2055 memcpy (to->glyphs[TEXT_AREA], from->glyphs[TEXT_AREA], nbytes);
2056 to->used[TEXT_AREA] = from->used[TEXT_AREA];
2059 return saved;
2063 /* Restore the contents of frame F's current frame matrix from SAVED,
2064 and free memory associated with SAVED. */
2066 static void
2067 restore_current_matrix (struct frame *f, struct glyph_matrix *saved)
2069 int i;
2071 for (i = 0; i < saved->nrows; ++i)
2073 struct glyph_row *from = saved->rows + i;
2074 struct glyph_row *to = f->current_matrix->rows + i;
2075 ptrdiff_t nbytes = from->used[TEXT_AREA] * sizeof (struct glyph);
2076 memcpy (to->glyphs[TEXT_AREA], from->glyphs[TEXT_AREA], nbytes);
2077 to->used[TEXT_AREA] = from->used[TEXT_AREA];
2078 xfree (from->glyphs[TEXT_AREA]);
2081 xfree (saved->rows);
2082 xfree (saved);
2087 /* Allocate/reallocate glyph matrices of a single frame F for
2088 frame-based redisplay. */
2090 static void
2091 adjust_frame_glyphs_for_frame_redisplay (struct frame *f)
2093 struct dim matrix_dim;
2094 int pool_changed_p;
2095 int window_change_flags;
2096 int top_window_y;
2098 if (!FRAME_LIVE_P (f))
2099 return;
2101 top_window_y = FRAME_TOP_MARGIN (f);
2103 /* Allocate glyph pool structures if not already done. */
2104 if (f->desired_pool == NULL)
2106 f->desired_pool = new_glyph_pool ();
2107 f->current_pool = new_glyph_pool ();
2110 /* Allocate frames matrix structures if needed. */
2111 if (f->desired_matrix == NULL)
2113 f->desired_matrix = new_glyph_matrix (f->desired_pool);
2114 f->current_matrix = new_glyph_matrix (f->current_pool);
2117 /* Compute window glyph matrices. (This takes the mini-buffer
2118 window into account). The result is the size of the frame glyph
2119 matrix needed. The variable window_change_flags is set to a bit
2120 mask indicating whether new matrices will be allocated or
2121 existing matrices change their size or location within the frame
2122 matrix. */
2123 window_change_flags = 0;
2124 matrix_dim
2125 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f),
2126 0, top_window_y,
2128 &window_change_flags);
2130 /* Add in menu bar lines, if any. */
2131 matrix_dim.height += top_window_y;
2133 /* Enlarge pools as necessary. */
2134 pool_changed_p = realloc_glyph_pool (f->desired_pool, matrix_dim);
2135 realloc_glyph_pool (f->current_pool, matrix_dim);
2137 /* Set up glyph pointers within window matrices. Do this only if
2138 absolutely necessary since it requires a frame redraw. */
2139 if (pool_changed_p || window_change_flags)
2141 /* Do it for window matrices. */
2142 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f),
2143 0, top_window_y, 0,
2144 &window_change_flags);
2146 /* Size of frame matrices must equal size of frame. Note
2147 that we are called for X frames with window widths NOT equal
2148 to the frame width (from CHANGE_FRAME_SIZE_1). */
2149 xassert (matrix_dim.width == FRAME_COLS (f)
2150 && matrix_dim.height == FRAME_LINES (f));
2152 /* Pointers to glyph memory in glyph rows are exchanged during
2153 the update phase of redisplay, which means in general that a
2154 frame's current matrix consists of pointers into both the
2155 desired and current glyph pool of the frame. Adjusting a
2156 matrix sets the frame matrix up so that pointers are all into
2157 the same pool. If we want to preserve glyph contents of the
2158 current matrix over a call to adjust_glyph_matrix, we must
2159 make a copy of the current glyphs, and restore the current
2160 matrix' contents from that copy. */
2161 if (display_completed
2162 && !FRAME_GARBAGED_P (f)
2163 && matrix_dim.width == f->current_matrix->matrix_w
2164 && matrix_dim.height == f->current_matrix->matrix_h
2165 /* For some reason, the frame glyph matrix gets corrupted if
2166 any of the windows contain margins. I haven't been able
2167 to hunt down the reason, but for the moment this prevents
2168 the problem from manifesting. -- cyd */
2169 && !showing_window_margins_p (XWINDOW (FRAME_ROOT_WINDOW (f))))
2171 struct glyph_matrix *copy = save_current_matrix (f);
2172 adjust_glyph_matrix (NULL, f->desired_matrix, 0, 0, matrix_dim);
2173 adjust_glyph_matrix (NULL, f->current_matrix, 0, 0, matrix_dim);
2174 restore_current_matrix (f, copy);
2175 fake_current_matrices (FRAME_ROOT_WINDOW (f));
2177 else
2179 adjust_glyph_matrix (NULL, f->desired_matrix, 0, 0, matrix_dim);
2180 adjust_glyph_matrix (NULL, f->current_matrix, 0, 0, matrix_dim);
2181 SET_FRAME_GARBAGED (f);
2187 /* Allocate/reallocate glyph matrices of a single frame F for
2188 window-based redisplay. */
2190 static void
2191 adjust_frame_glyphs_for_window_redisplay (struct frame *f)
2193 xassert (FRAME_WINDOW_P (f) && FRAME_LIVE_P (f));
2195 /* Allocate/reallocate window matrices. */
2196 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f)));
2198 #ifdef HAVE_X_WINDOWS
2199 /* Allocate/ reallocate matrices of the dummy window used to display
2200 the menu bar under X when no X toolkit support is available. */
2201 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
2203 /* Allocate a dummy window if not already done. */
2204 struct window *w;
2205 if (NILP (f->menu_bar_window))
2207 f->menu_bar_window = make_window ();
2208 w = XWINDOW (f->menu_bar_window);
2209 XSETFRAME (w->frame, f);
2210 w->pseudo_window_p = 1;
2212 else
2213 w = XWINDOW (f->menu_bar_window);
2215 /* Set window dimensions to frame dimensions and allocate or
2216 adjust glyph matrices of W. */
2217 XSETFASTINT (w->top_line, 0);
2218 XSETFASTINT (w->left_col, 0);
2219 XSETFASTINT (w->total_lines, FRAME_MENU_BAR_LINES (f));
2220 XSETFASTINT (w->total_cols, FRAME_TOTAL_COLS (f));
2221 allocate_matrices_for_window_redisplay (w);
2223 #endif /* not USE_X_TOOLKIT && not USE_GTK */
2224 #endif /* HAVE_X_WINDOWS */
2226 #ifndef USE_GTK
2228 /* Allocate/ reallocate matrices of the tool bar window. If we
2229 don't have a tool bar window yet, make one. */
2230 struct window *w;
2231 if (NILP (f->tool_bar_window))
2233 f->tool_bar_window = make_window ();
2234 w = XWINDOW (f->tool_bar_window);
2235 XSETFRAME (w->frame, f);
2236 w->pseudo_window_p = 1;
2238 else
2239 w = XWINDOW (f->tool_bar_window);
2241 XSETFASTINT (w->top_line, FRAME_MENU_BAR_LINES (f));
2242 XSETFASTINT (w->left_col, 0);
2243 XSETFASTINT (w->total_lines, FRAME_TOOL_BAR_LINES (f));
2244 XSETFASTINT (w->total_cols, FRAME_TOTAL_COLS (f));
2245 allocate_matrices_for_window_redisplay (w);
2247 #endif
2251 /* Adjust/ allocate message buffer of frame F.
2253 Note that the message buffer is never freed. Since I could not
2254 find a free in 19.34, I assume that freeing it would be
2255 problematic in some way and don't do it either.
2257 (Implementation note: It should be checked if we can free it
2258 eventually without causing trouble). */
2260 static void
2261 adjust_frame_message_buffer (struct frame *f)
2263 ptrdiff_t size = FRAME_MESSAGE_BUF_SIZE (f) + 1;
2265 if (FRAME_MESSAGE_BUF (f))
2267 char *buffer = FRAME_MESSAGE_BUF (f);
2268 char *new_buffer = (char *) xrealloc (buffer, size);
2269 FRAME_MESSAGE_BUF (f) = new_buffer;
2271 else
2272 FRAME_MESSAGE_BUF (f) = (char *) xmalloc (size);
2276 /* Re-allocate buffer for decode_mode_spec on frame F. */
2278 static void
2279 adjust_decode_mode_spec_buffer (struct frame *f)
2281 f->decode_mode_spec_buffer
2282 = (char *) xrealloc (f->decode_mode_spec_buffer,
2283 FRAME_MESSAGE_BUF_SIZE (f) + 1);
2288 /**********************************************************************
2289 Freeing Glyph Matrices
2290 **********************************************************************/
2292 /* Free glyph memory for a frame F. F may be null. This function can
2293 be called for the same frame more than once. The root window of
2294 F may be nil when this function is called. This is the case when
2295 the function is called when F is destroyed. */
2297 void
2298 free_glyphs (struct frame *f)
2300 if (f && f->glyphs_initialized_p)
2302 /* Block interrupt input so that we don't get surprised by an X
2303 event while we're in an inconsistent state. */
2304 BLOCK_INPUT;
2305 f->glyphs_initialized_p = 0;
2307 /* Release window sub-matrices. */
2308 if (!NILP (f->root_window))
2309 free_window_matrices (XWINDOW (f->root_window));
2311 /* Free the dummy window for menu bars without X toolkit and its
2312 glyph matrices. */
2313 if (!NILP (f->menu_bar_window))
2315 struct window *w = XWINDOW (f->menu_bar_window);
2316 free_glyph_matrix (w->desired_matrix);
2317 free_glyph_matrix (w->current_matrix);
2318 w->desired_matrix = w->current_matrix = NULL;
2319 f->menu_bar_window = Qnil;
2322 /* Free the tool bar window and its glyph matrices. */
2323 if (!NILP (f->tool_bar_window))
2325 struct window *w = XWINDOW (f->tool_bar_window);
2326 free_glyph_matrix (w->desired_matrix);
2327 free_glyph_matrix (w->current_matrix);
2328 w->desired_matrix = w->current_matrix = NULL;
2329 f->tool_bar_window = Qnil;
2332 /* Release frame glyph matrices. Reset fields to zero in
2333 case we are called a second time. */
2334 if (f->desired_matrix)
2336 free_glyph_matrix (f->desired_matrix);
2337 free_glyph_matrix (f->current_matrix);
2338 f->desired_matrix = f->current_matrix = NULL;
2341 /* Release glyph pools. */
2342 if (f->desired_pool)
2344 free_glyph_pool (f->desired_pool);
2345 free_glyph_pool (f->current_pool);
2346 f->desired_pool = f->current_pool = NULL;
2349 UNBLOCK_INPUT;
2354 /* Free glyph sub-matrices in the window tree rooted at W. This
2355 function may be called with a null pointer, and it may be called on
2356 the same tree more than once. */
2358 void
2359 free_window_matrices (struct window *w)
2361 while (w)
2363 if (!NILP (w->hchild))
2364 free_window_matrices (XWINDOW (w->hchild));
2365 else if (!NILP (w->vchild))
2366 free_window_matrices (XWINDOW (w->vchild));
2367 else
2369 /* This is a leaf window. Free its memory and reset fields
2370 to zero in case this function is called a second time for
2371 W. */
2372 free_glyph_matrix (w->current_matrix);
2373 free_glyph_matrix (w->desired_matrix);
2374 w->current_matrix = w->desired_matrix = NULL;
2377 /* Next window on same level. */
2378 w = NILP (w->next) ? 0 : XWINDOW (w->next);
2383 /* Check glyph memory leaks. This function is called from
2384 shut_down_emacs. Note that frames are not destroyed when Emacs
2385 exits. We therefore free all glyph memory for all active frames
2386 explicitly and check that nothing is left allocated. */
2388 void
2389 check_glyph_memory (void)
2391 Lisp_Object tail, frame;
2393 /* Free glyph memory for all frames. */
2394 FOR_EACH_FRAME (tail, frame)
2395 free_glyphs (XFRAME (frame));
2397 /* Check that nothing is left allocated. */
2398 if (glyph_matrix_count)
2399 abort ();
2400 if (glyph_pool_count)
2401 abort ();
2406 /**********************************************************************
2407 Building a Frame Matrix
2408 **********************************************************************/
2410 /* Most of the redisplay code works on glyph matrices attached to
2411 windows. This is a good solution most of the time, but it is not
2412 suitable for terminal code. Terminal output functions cannot rely
2413 on being able to set an arbitrary terminal window. Instead they
2414 must be provided with a view of the whole frame, i.e. the whole
2415 screen. We build such a view by constructing a frame matrix from
2416 window matrices in this section.
2418 Windows that must be updated have their must_be_update_p flag set.
2419 For all such windows, their desired matrix is made part of the
2420 desired frame matrix. For other windows, their current matrix is
2421 made part of the desired frame matrix.
2423 +-----------------+----------------+
2424 | desired | desired |
2425 | | |
2426 +-----------------+----------------+
2427 | current |
2429 +----------------------------------+
2431 Desired window matrices can be made part of the frame matrix in a
2432 cheap way: We exploit the fact that the desired frame matrix and
2433 desired window matrices share their glyph memory. This is not
2434 possible for current window matrices. Their glyphs are copied to
2435 the desired frame matrix. The latter is equivalent to
2436 preserve_other_columns in the old redisplay.
2438 Used glyphs counters for frame matrix rows are the result of adding
2439 up glyph lengths of the window matrices. A line in the frame
2440 matrix is enabled, if a corresponding line in a window matrix is
2441 enabled.
2443 After building the desired frame matrix, it will be passed to
2444 terminal code, which will manipulate both the desired and current
2445 frame matrix. Changes applied to the frame's current matrix have
2446 to be visible in current window matrices afterwards, of course.
2448 This problem is solved like this:
2450 1. Window and frame matrices share glyphs. Window matrices are
2451 constructed in a way that their glyph contents ARE the glyph
2452 contents needed in a frame matrix. Thus, any modification of
2453 glyphs done in terminal code will be reflected in window matrices
2454 automatically.
2456 2. Exchanges of rows in a frame matrix done by terminal code are
2457 intercepted by hook functions so that corresponding row operations
2458 on window matrices can be performed. This is necessary because we
2459 use pointers to glyphs in glyph row structures. To satisfy the
2460 assumption of point 1 above that glyphs are updated implicitly in
2461 window matrices when they are manipulated via the frame matrix,
2462 window and frame matrix must of course agree where to find the
2463 glyphs for their rows. Possible manipulations that must be
2464 mirrored are assignments of rows of the desired frame matrix to the
2465 current frame matrix and scrolling the current frame matrix. */
2467 /* Build frame F's desired matrix from window matrices. Only windows
2468 which have the flag must_be_updated_p set have to be updated. Menu
2469 bar lines of a frame are not covered by window matrices, so make
2470 sure not to touch them in this function. */
2472 static void
2473 build_frame_matrix (struct frame *f)
2475 int i;
2477 /* F must have a frame matrix when this function is called. */
2478 xassert (!FRAME_WINDOW_P (f));
2480 /* Clear all rows in the frame matrix covered by window matrices.
2481 Menu bar lines are not covered by windows. */
2482 for (i = FRAME_TOP_MARGIN (f); i < f->desired_matrix->nrows; ++i)
2483 clear_glyph_row (MATRIX_ROW (f->desired_matrix, i));
2485 /* Build the matrix by walking the window tree. */
2486 build_frame_matrix_from_window_tree (f->desired_matrix,
2487 XWINDOW (FRAME_ROOT_WINDOW (f)));
2491 /* Walk a window tree, building a frame matrix MATRIX from window
2492 matrices. W is the root of a window tree. */
2494 static void
2495 build_frame_matrix_from_window_tree (struct glyph_matrix *matrix, struct window *w)
2497 while (w)
2499 if (!NILP (w->hchild))
2500 build_frame_matrix_from_window_tree (matrix, XWINDOW (w->hchild));
2501 else if (!NILP (w->vchild))
2502 build_frame_matrix_from_window_tree (matrix, XWINDOW (w->vchild));
2503 else
2504 build_frame_matrix_from_leaf_window (matrix, w);
2506 w = NILP (w->next) ? 0 : XWINDOW (w->next);
2511 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2512 desired frame matrix built. W is a leaf window whose desired or
2513 current matrix is to be added to FRAME_MATRIX. W's flag
2514 must_be_updated_p determines which matrix it contributes to
2515 FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix
2516 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2517 Adding a desired matrix means setting up used counters and such in
2518 frame rows, while adding a current window matrix to FRAME_MATRIX
2519 means copying glyphs. The latter case corresponds to
2520 preserve_other_columns in the old redisplay. */
2522 static void
2523 build_frame_matrix_from_leaf_window (struct glyph_matrix *frame_matrix, struct window *w)
2525 struct glyph_matrix *window_matrix;
2526 int window_y, frame_y;
2527 /* If non-zero, a glyph to insert at the right border of W. */
2528 GLYPH right_border_glyph;
2530 SET_GLYPH_FROM_CHAR (right_border_glyph, 0);
2532 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2533 if (w->must_be_updated_p)
2535 window_matrix = w->desired_matrix;
2537 /* Decide whether we want to add a vertical border glyph. */
2538 if (!WINDOW_RIGHTMOST_P (w))
2540 struct Lisp_Char_Table *dp = window_display_table (w);
2541 Lisp_Object gc;
2543 SET_GLYPH_FROM_CHAR (right_border_glyph, '|');
2544 if (dp
2545 && (gc = DISP_BORDER_GLYPH (dp), GLYPH_CODE_P (gc))
2546 && GLYPH_CODE_CHAR_VALID_P (gc))
2548 SET_GLYPH_FROM_GLYPH_CODE (right_border_glyph, gc);
2549 spec_glyph_lookup_face (w, &right_border_glyph);
2552 if (GLYPH_FACE (right_border_glyph) <= 0)
2553 SET_GLYPH_FACE (right_border_glyph, VERTICAL_BORDER_FACE_ID);
2556 else
2557 window_matrix = w->current_matrix;
2559 /* For all rows in the window matrix and corresponding rows in the
2560 frame matrix. */
2561 window_y = 0;
2562 frame_y = window_matrix->matrix_y;
2563 while (window_y < window_matrix->nrows)
2565 struct glyph_row *frame_row = frame_matrix->rows + frame_y;
2566 struct glyph_row *window_row = window_matrix->rows + window_y;
2567 int current_row_p = window_matrix == w->current_matrix;
2569 /* Fill up the frame row with spaces up to the left margin of the
2570 window row. */
2571 fill_up_frame_row_with_spaces (frame_row, window_matrix->matrix_x);
2573 /* Fill up areas in the window matrix row with spaces. */
2574 fill_up_glyph_row_with_spaces (window_row);
2576 /* If only part of W's desired matrix has been built, and
2577 window_row wasn't displayed, use the corresponding current
2578 row instead. */
2579 if (window_matrix == w->desired_matrix
2580 && !window_row->enabled_p)
2582 window_row = w->current_matrix->rows + window_y;
2583 current_row_p = 1;
2586 if (current_row_p)
2588 /* Copy window row to frame row. */
2589 memcpy (frame_row->glyphs[TEXT_AREA] + window_matrix->matrix_x,
2590 window_row->glyphs[0],
2591 window_matrix->matrix_w * sizeof (struct glyph));
2593 else
2595 xassert (window_row->enabled_p);
2597 /* Only when a desired row has been displayed, we want
2598 the corresponding frame row to be updated. */
2599 frame_row->enabled_p = 1;
2601 /* Maybe insert a vertical border between horizontally adjacent
2602 windows. */
2603 if (GLYPH_CHAR (right_border_glyph) != 0)
2605 struct glyph *border = window_row->glyphs[LAST_AREA] - 1;
2606 SET_CHAR_GLYPH_FROM_GLYPH (*border, right_border_glyph);
2609 #if GLYPH_DEBUG
2610 /* Window row window_y must be a slice of frame row
2611 frame_y. */
2612 xassert (glyph_row_slice_p (window_row, frame_row));
2614 /* If rows are in sync, we don't have to copy glyphs because
2615 frame and window share glyphs. */
2617 strcpy (w->current_matrix->method, w->desired_matrix->method);
2618 add_window_display_history (w, w->current_matrix->method, 0);
2619 #endif
2622 /* Set number of used glyphs in the frame matrix. Since we fill
2623 up with spaces, and visit leaf windows from left to right it
2624 can be done simply. */
2625 frame_row->used[TEXT_AREA]
2626 = window_matrix->matrix_x + window_matrix->matrix_w;
2628 /* Next row. */
2629 ++window_y;
2630 ++frame_y;
2634 /* Given a user-specified glyph, possibly including a Lisp-level face
2635 ID, return a glyph that has a realized face ID.
2636 This is used for glyphs displayed specially and not part of the text;
2637 for instance, vertical separators, truncation markers, etc. */
2639 void
2640 spec_glyph_lookup_face (struct window *w, GLYPH *glyph)
2642 int lface_id = GLYPH_FACE (*glyph);
2643 /* Convert the glyph's specified face to a realized (cache) face. */
2644 if (lface_id > 0)
2646 int face_id = merge_faces (XFRAME (w->frame),
2647 Qt, lface_id, DEFAULT_FACE_ID);
2648 SET_GLYPH_FACE (*glyph, face_id);
2652 /* Add spaces to a glyph row ROW in a window matrix.
2654 Each row has the form:
2656 +---------+-----------------------------+------------+
2657 | left | text | right |
2658 +---------+-----------------------------+------------+
2660 Left and right marginal areas are optional. This function adds
2661 spaces to areas so that there are no empty holes between areas.
2662 In other words: If the right area is not empty, the text area
2663 is filled up with spaces up to the right area. If the text area
2664 is not empty, the left area is filled up.
2666 To be called for frame-based redisplay, only. */
2668 static void
2669 fill_up_glyph_row_with_spaces (struct glyph_row *row)
2671 fill_up_glyph_row_area_with_spaces (row, LEFT_MARGIN_AREA);
2672 fill_up_glyph_row_area_with_spaces (row, TEXT_AREA);
2673 fill_up_glyph_row_area_with_spaces (row, RIGHT_MARGIN_AREA);
2677 /* Fill area AREA of glyph row ROW with spaces. To be called for
2678 frame-based redisplay only. */
2680 static void
2681 fill_up_glyph_row_area_with_spaces (struct glyph_row *row, int area)
2683 if (row->glyphs[area] < row->glyphs[area + 1])
2685 struct glyph *end = row->glyphs[area + 1];
2686 struct glyph *text = row->glyphs[area] + row->used[area];
2688 while (text < end)
2689 *text++ = space_glyph;
2690 row->used[area] = text - row->glyphs[area];
2695 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2696 reached. In frame matrices only one area, TEXT_AREA, is used. */
2698 static void
2699 fill_up_frame_row_with_spaces (struct glyph_row *row, int upto)
2701 int i = row->used[TEXT_AREA];
2702 struct glyph *glyph = row->glyphs[TEXT_AREA];
2704 while (i < upto)
2705 glyph[i++] = space_glyph;
2707 row->used[TEXT_AREA] = i;
2712 /**********************************************************************
2713 Mirroring operations on frame matrices in window matrices
2714 **********************************************************************/
2716 /* Set frame being updated via frame-based redisplay to F. This
2717 function must be called before updates to make explicit that we are
2718 working on frame matrices or not. */
2720 static inline void
2721 set_frame_matrix_frame (struct frame *f)
2723 frame_matrix_frame = f;
2727 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2728 DESIRED_MATRIX is the desired matrix corresponding to
2729 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2730 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2731 frame_matrix_frame is non-null, this indicates that the exchange is
2732 done in frame matrices, and that we have to perform analogous
2733 operations in window matrices of frame_matrix_frame. */
2735 static inline void
2736 make_current (struct glyph_matrix *desired_matrix, struct glyph_matrix *current_matrix, int row)
2738 struct glyph_row *current_row = MATRIX_ROW (current_matrix, row);
2739 struct glyph_row *desired_row = MATRIX_ROW (desired_matrix, row);
2740 int mouse_face_p = current_row->mouse_face_p;
2742 /* Do current_row = desired_row. This exchanges glyph pointers
2743 between both rows, and does a structure assignment otherwise. */
2744 assign_row (current_row, desired_row);
2746 /* Enable current_row to mark it as valid. */
2747 current_row->enabled_p = 1;
2748 current_row->mouse_face_p = mouse_face_p;
2750 /* If we are called on frame matrices, perform analogous operations
2751 for window matrices. */
2752 if (frame_matrix_frame)
2753 mirror_make_current (XWINDOW (frame_matrix_frame->root_window), row);
2757 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2758 W's frame which has been made current (by swapping pointers between
2759 current and desired matrix). Perform analogous operations in the
2760 matrices of leaf windows in the window tree rooted at W. */
2762 static void
2763 mirror_make_current (struct window *w, int frame_row)
2765 while (w)
2767 if (!NILP (w->hchild))
2768 mirror_make_current (XWINDOW (w->hchild), frame_row);
2769 else if (!NILP (w->vchild))
2770 mirror_make_current (XWINDOW (w->vchild), frame_row);
2771 else
2773 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2774 here because the checks performed in debug mode there
2775 will not allow the conversion. */
2776 int row = frame_row - w->desired_matrix->matrix_y;
2778 /* If FRAME_ROW is within W, assign the desired row to the
2779 current row (exchanging glyph pointers). */
2780 if (row >= 0 && row < w->desired_matrix->matrix_h)
2782 struct glyph_row *current_row
2783 = MATRIX_ROW (w->current_matrix, row);
2784 struct glyph_row *desired_row
2785 = MATRIX_ROW (w->desired_matrix, row);
2787 if (desired_row->enabled_p)
2788 assign_row (current_row, desired_row);
2789 else
2790 swap_glyph_pointers (desired_row, current_row);
2791 current_row->enabled_p = 1;
2793 /* Set the Y coordinate of the mode/header line's row.
2794 It is needed in draw_row_with_mouse_face to find the
2795 screen coordinates. (Window-based redisplay sets
2796 this in update_window, but no one seems to do that
2797 for frame-based redisplay.) */
2798 if (current_row->mode_line_p)
2799 current_row->y = row;
2803 w = NILP (w->next) ? 0 : XWINDOW (w->next);
2808 /* Perform row dance after scrolling. We are working on the range of
2809 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2810 including) in MATRIX. COPY_FROM is a vector containing, for each
2811 row I in the range 0 <= I < NLINES, the index of the original line
2812 to move to I. This index is relative to the row range, i.e. 0 <=
2813 index < NLINES. RETAINED_P is a vector containing zero for each
2814 row 0 <= I < NLINES which is empty.
2816 This function is called from do_scrolling and do_direct_scrolling. */
2818 void
2819 mirrored_line_dance (struct glyph_matrix *matrix, int unchanged_at_top, int nlines,
2820 int *copy_from, char *retained_p)
2822 /* A copy of original rows. */
2823 struct glyph_row *old_rows;
2825 /* Rows to assign to. */
2826 struct glyph_row *new_rows = MATRIX_ROW (matrix, unchanged_at_top);
2828 int i;
2830 /* Make a copy of the original rows. */
2831 old_rows = (struct glyph_row *) alloca (nlines * sizeof *old_rows);
2832 memcpy (old_rows, new_rows, nlines * sizeof *old_rows);
2834 /* Assign new rows, maybe clear lines. */
2835 for (i = 0; i < nlines; ++i)
2837 int enabled_before_p = new_rows[i].enabled_p;
2839 xassert (i + unchanged_at_top < matrix->nrows);
2840 xassert (unchanged_at_top + copy_from[i] < matrix->nrows);
2841 new_rows[i] = old_rows[copy_from[i]];
2842 new_rows[i].enabled_p = enabled_before_p;
2844 /* RETAINED_P is zero for empty lines. */
2845 if (!retained_p[copy_from[i]])
2846 new_rows[i].enabled_p = 0;
2849 /* Do the same for window matrices, if MATRIX is a frame matrix. */
2850 if (frame_matrix_frame)
2851 mirror_line_dance (XWINDOW (frame_matrix_frame->root_window),
2852 unchanged_at_top, nlines, copy_from, retained_p);
2856 /* Synchronize glyph pointers in the current matrix of window W with
2857 the current frame matrix. */
2859 static void
2860 sync_window_with_frame_matrix_rows (struct window *w)
2862 struct frame *f = XFRAME (w->frame);
2863 struct glyph_row *window_row, *window_row_end, *frame_row;
2864 int left, right, x, width;
2866 /* Preconditions: W must be a leaf window on a tty frame. */
2867 xassert (NILP (w->hchild) && NILP (w->vchild));
2868 xassert (!FRAME_WINDOW_P (f));
2870 left = margin_glyphs_to_reserve (w, 1, w->left_margin_cols);
2871 right = margin_glyphs_to_reserve (w, 1, w->right_margin_cols);
2872 x = w->current_matrix->matrix_x;
2873 width = w->current_matrix->matrix_w;
2875 window_row = w->current_matrix->rows;
2876 window_row_end = window_row + w->current_matrix->nrows;
2877 frame_row = f->current_matrix->rows + WINDOW_TOP_EDGE_LINE (w);
2879 for (; window_row < window_row_end; ++window_row, ++frame_row)
2881 window_row->glyphs[LEFT_MARGIN_AREA]
2882 = frame_row->glyphs[0] + x;
2883 window_row->glyphs[TEXT_AREA]
2884 = window_row->glyphs[LEFT_MARGIN_AREA] + left;
2885 window_row->glyphs[LAST_AREA]
2886 = window_row->glyphs[LEFT_MARGIN_AREA] + width;
2887 window_row->glyphs[RIGHT_MARGIN_AREA]
2888 = window_row->glyphs[LAST_AREA] - right;
2893 /* Return the window in the window tree rooted in W containing frame
2894 row ROW. Value is null if none is found. */
2896 static struct window *
2897 frame_row_to_window (struct window *w, int row)
2899 struct window *found = NULL;
2901 while (w && !found)
2903 if (!NILP (w->hchild))
2904 found = frame_row_to_window (XWINDOW (w->hchild), row);
2905 else if (!NILP (w->vchild))
2906 found = frame_row_to_window (XWINDOW (w->vchild), row);
2907 else if (row >= WINDOW_TOP_EDGE_LINE (w)
2908 && row < WINDOW_BOTTOM_EDGE_LINE (w))
2909 found = w;
2911 w = NILP (w->next) ? 0 : XWINDOW (w->next);
2914 return found;
2918 /* Perform a line dance in the window tree rooted at W, after
2919 scrolling a frame matrix in mirrored_line_dance.
2921 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
2922 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
2923 COPY_FROM is a vector containing, for each row I in the range 0 <=
2924 I < NLINES, the index of the original line to move to I. This
2925 index is relative to the row range, i.e. 0 <= index < NLINES.
2926 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
2927 which is empty. */
2929 static void
2930 mirror_line_dance (struct window *w, int unchanged_at_top, int nlines, int *copy_from, char *retained_p)
2932 while (w)
2934 if (!NILP (w->hchild))
2935 mirror_line_dance (XWINDOW (w->hchild), unchanged_at_top,
2936 nlines, copy_from, retained_p);
2937 else if (!NILP (w->vchild))
2938 mirror_line_dance (XWINDOW (w->vchild), unchanged_at_top,
2939 nlines, copy_from, retained_p);
2940 else
2942 /* W is a leaf window, and we are working on its current
2943 matrix m. */
2944 struct glyph_matrix *m = w->current_matrix;
2945 int i, sync_p = 0;
2946 struct glyph_row *old_rows;
2948 /* Make a copy of the original rows of matrix m. */
2949 old_rows = (struct glyph_row *) alloca (m->nrows * sizeof *old_rows);
2950 memcpy (old_rows, m->rows, m->nrows * sizeof *old_rows);
2952 for (i = 0; i < nlines; ++i)
2954 /* Frame relative line assigned to. */
2955 int frame_to = i + unchanged_at_top;
2957 /* Frame relative line assigned. */
2958 int frame_from = copy_from[i] + unchanged_at_top;
2960 /* Window relative line assigned to. */
2961 int window_to = frame_to - m->matrix_y;
2963 /* Window relative line assigned. */
2964 int window_from = frame_from - m->matrix_y;
2966 /* Is assigned line inside window? */
2967 int from_inside_window_p
2968 = window_from >= 0 && window_from < m->matrix_h;
2970 /* Is assigned to line inside window? */
2971 int to_inside_window_p
2972 = window_to >= 0 && window_to < m->matrix_h;
2974 if (from_inside_window_p && to_inside_window_p)
2976 /* Enabled setting before assignment. */
2977 int enabled_before_p;
2979 /* Do the assignment. The enabled_p flag is saved
2980 over the assignment because the old redisplay did
2981 that. */
2982 enabled_before_p = m->rows[window_to].enabled_p;
2983 m->rows[window_to] = old_rows[window_from];
2984 m->rows[window_to].enabled_p = enabled_before_p;
2986 /* If frame line is empty, window line is empty, too. */
2987 if (!retained_p[copy_from[i]])
2988 m->rows[window_to].enabled_p = 0;
2990 else if (to_inside_window_p)
2992 /* A copy between windows. This is an infrequent
2993 case not worth optimizing. */
2994 struct frame *f = XFRAME (w->frame);
2995 struct window *root = XWINDOW (FRAME_ROOT_WINDOW (f));
2996 struct window *w2;
2997 struct glyph_matrix *m2;
2998 int m2_from;
3000 w2 = frame_row_to_window (root, frame_from);
3001 /* ttn@surf.glug.org: when enabling menu bar using `emacs
3002 -nw', FROM_FRAME sometimes has no associated window.
3003 This check avoids a segfault if W2 is null. */
3004 if (w2)
3006 m2 = w2->current_matrix;
3007 m2_from = frame_from - m2->matrix_y;
3008 copy_row_except_pointers (m->rows + window_to,
3009 m2->rows + m2_from);
3011 /* If frame line is empty, window line is empty, too. */
3012 if (!retained_p[copy_from[i]])
3013 m->rows[window_to].enabled_p = 0;
3015 sync_p = 1;
3017 else if (from_inside_window_p)
3018 sync_p = 1;
3021 /* If there was a copy between windows, make sure glyph
3022 pointers are in sync with the frame matrix. */
3023 if (sync_p)
3024 sync_window_with_frame_matrix_rows (w);
3026 /* Check that no pointers are lost. */
3027 CHECK_MATRIX (m);
3030 /* Next window on same level. */
3031 w = NILP (w->next) ? 0 : XWINDOW (w->next);
3036 #if GLYPH_DEBUG
3038 /* Check that window and frame matrices agree about their
3039 understanding where glyphs of the rows are to find. For each
3040 window in the window tree rooted at W, check that rows in the
3041 matrices of leaf window agree with their frame matrices about
3042 glyph pointers. */
3044 static void
3045 check_window_matrix_pointers (struct window *w)
3047 while (w)
3049 if (!NILP (w->hchild))
3050 check_window_matrix_pointers (XWINDOW (w->hchild));
3051 else if (!NILP (w->vchild))
3052 check_window_matrix_pointers (XWINDOW (w->vchild));
3053 else
3055 struct frame *f = XFRAME (w->frame);
3056 check_matrix_pointers (w->desired_matrix, f->desired_matrix);
3057 check_matrix_pointers (w->current_matrix, f->current_matrix);
3060 w = NILP (w->next) ? 0 : XWINDOW (w->next);
3065 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
3066 a window and FRAME_MATRIX is the corresponding frame matrix. For
3067 each row in WINDOW_MATRIX check that it's a slice of the
3068 corresponding frame row. If it isn't, abort. */
3070 static void
3071 check_matrix_pointers (struct glyph_matrix *window_matrix,
3072 struct glyph_matrix *frame_matrix)
3074 /* Row number in WINDOW_MATRIX. */
3075 int i = 0;
3077 /* Row number corresponding to I in FRAME_MATRIX. */
3078 int j = window_matrix->matrix_y;
3080 /* For all rows check that the row in the window matrix is a
3081 slice of the row in the frame matrix. If it isn't we didn't
3082 mirror an operation on the frame matrix correctly. */
3083 while (i < window_matrix->nrows)
3085 if (!glyph_row_slice_p (window_matrix->rows + i,
3086 frame_matrix->rows + j))
3087 abort ();
3088 ++i, ++j;
3092 #endif /* GLYPH_DEBUG != 0 */
3096 /**********************************************************************
3097 VPOS and HPOS translations
3098 **********************************************************************/
3100 #if GLYPH_DEBUG
3102 /* Translate vertical position VPOS which is relative to window W to a
3103 vertical position relative to W's frame. */
3105 static int
3106 window_to_frame_vpos (struct window *w, int vpos)
3108 xassert (!FRAME_WINDOW_P (XFRAME (w->frame)));
3109 xassert (vpos >= 0 && vpos <= w->desired_matrix->nrows);
3110 vpos += WINDOW_TOP_EDGE_LINE (w);
3111 xassert (vpos >= 0 && vpos <= FRAME_LINES (XFRAME (w->frame)));
3112 return vpos;
3116 /* Translate horizontal position HPOS which is relative to window W to
3117 a horizontal position relative to W's frame. */
3119 static int
3120 window_to_frame_hpos (struct window *w, int hpos)
3122 xassert (!FRAME_WINDOW_P (XFRAME (w->frame)));
3123 hpos += WINDOW_LEFT_EDGE_COL (w);
3124 return hpos;
3127 #endif /* GLYPH_DEBUG */
3131 /**********************************************************************
3132 Redrawing Frames
3133 **********************************************************************/
3135 DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 1, 1, 0,
3136 doc: /* Clear frame FRAME and output again what is supposed to appear on it. */)
3137 (Lisp_Object frame)
3139 struct frame *f;
3141 CHECK_LIVE_FRAME (frame);
3142 f = XFRAME (frame);
3144 /* Ignore redraw requests, if frame has no glyphs yet.
3145 (Implementation note: It still has to be checked why we are
3146 called so early here). */
3147 if (!glyphs_initialized_initially_p)
3148 return Qnil;
3150 update_begin (f);
3151 #ifdef MSDOS
3152 if (FRAME_MSDOS_P (f))
3153 FRAME_TERMINAL (f)->set_terminal_modes_hook (FRAME_TERMINAL (f));
3154 #endif
3155 clear_frame (f);
3156 clear_current_matrices (f);
3157 update_end (f);
3158 if (FRAME_TERMCAP_P (f))
3159 fflush (FRAME_TTY (f)->output);
3160 windows_or_buffers_changed++;
3161 /* Mark all windows as inaccurate, so that every window will have
3162 its redisplay done. */
3163 mark_window_display_accurate (FRAME_ROOT_WINDOW (f), 0);
3164 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f)), 1);
3165 f->garbaged = 0;
3166 return Qnil;
3170 /* Redraw frame F. This is nothing more than a call to the Lisp
3171 function redraw-frame. */
3173 void
3174 redraw_frame (struct frame *f)
3176 Lisp_Object frame;
3177 XSETFRAME (frame, f);
3178 Fredraw_frame (frame);
3182 DEFUN ("redraw-display", Fredraw_display, Sredraw_display, 0, 0, "",
3183 doc: /* Clear and redisplay all visible frames. */)
3184 (void)
3186 Lisp_Object tail, frame;
3188 FOR_EACH_FRAME (tail, frame)
3189 if (FRAME_VISIBLE_P (XFRAME (frame)))
3190 Fredraw_frame (frame);
3192 return Qnil;
3197 /***********************************************************************
3198 Frame Update
3199 ***********************************************************************/
3201 /* Update frame F based on the data in desired matrices.
3203 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3204 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3205 scrolling.
3207 Value is non-zero if redisplay was stopped due to pending input. */
3210 update_frame (struct frame *f, int force_p, int inhibit_hairy_id_p)
3212 /* 1 means display has been paused because of pending input. */
3213 int paused_p;
3214 struct window *root_window = XWINDOW (f->root_window);
3216 if (redisplay_dont_pause)
3217 force_p = 1;
3218 #if PERIODIC_PREEMPTION_CHECKING
3219 else if (NILP (Vredisplay_preemption_period))
3220 force_p = 1;
3221 else if (!force_p && NUMBERP (Vredisplay_preemption_period))
3223 EMACS_TIME tm;
3224 double p = XFLOATINT (Vredisplay_preemption_period);
3225 int sec, usec;
3227 if (detect_input_pending_ignore_squeezables ())
3229 paused_p = 1;
3230 goto do_pause;
3233 sec = (int) p;
3234 usec = (p - sec) * 1000000;
3236 EMACS_GET_TIME (tm);
3237 EMACS_SET_SECS_USECS (preemption_period, sec, usec);
3238 EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
3240 #endif
3242 if (FRAME_WINDOW_P (f))
3244 /* We are working on window matrix basis. All windows whose
3245 flag must_be_updated_p is set have to be updated. */
3247 /* Record that we are not working on frame matrices. */
3248 set_frame_matrix_frame (NULL);
3250 /* Update all windows in the window tree of F, maybe stopping
3251 when pending input is detected. */
3252 update_begin (f);
3254 /* Update the menu bar on X frames that don't have toolkit
3255 support. */
3256 if (WINDOWP (f->menu_bar_window))
3257 update_window (XWINDOW (f->menu_bar_window), 1);
3259 /* Update the tool-bar window, if present. */
3260 if (WINDOWP (f->tool_bar_window))
3262 struct window *w = XWINDOW (f->tool_bar_window);
3264 /* Update tool-bar window. */
3265 if (w->must_be_updated_p)
3267 Lisp_Object tem;
3269 update_window (w, 1);
3270 w->must_be_updated_p = 0;
3272 /* Swap tool-bar strings. We swap because we want to
3273 reuse strings. */
3274 tem = f->current_tool_bar_string;
3275 f->current_tool_bar_string = f->desired_tool_bar_string;
3276 f->desired_tool_bar_string = tem;
3281 /* Update windows. */
3282 paused_p = update_window_tree (root_window, force_p);
3283 update_end (f);
3285 /* This flush is a performance bottleneck under X,
3286 and it doesn't seem to be necessary anyway (in general).
3287 It is necessary when resizing the window with the mouse, or
3288 at least the fringes are not redrawn in a timely manner. ++kfs */
3289 if (f->force_flush_display_p)
3291 FRAME_RIF (f)->flush_display (f);
3292 f->force_flush_display_p = 0;
3295 else
3297 /* We are working on frame matrix basis. Set the frame on whose
3298 frame matrix we operate. */
3299 set_frame_matrix_frame (f);
3301 /* Build F's desired matrix from window matrices. */
3302 build_frame_matrix (f);
3304 /* Update the display */
3305 update_begin (f);
3306 paused_p = update_frame_1 (f, force_p, inhibit_hairy_id_p);
3307 update_end (f);
3309 if (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))
3311 if (FRAME_TTY (f)->termscript)
3312 fflush (FRAME_TTY (f)->termscript);
3313 if (FRAME_TERMCAP_P (f))
3314 fflush (FRAME_TTY (f)->output);
3317 /* Check window matrices for lost pointers. */
3318 #if GLYPH_DEBUG
3319 check_window_matrix_pointers (root_window);
3320 add_frame_display_history (f, paused_p);
3321 #endif
3324 #if PERIODIC_PREEMPTION_CHECKING
3325 do_pause:
3326 #endif
3327 /* Reset flags indicating that a window should be updated. */
3328 set_window_update_flags (root_window, 0);
3330 display_completed = !paused_p;
3331 return paused_p;
3336 /************************************************************************
3337 Window-based updates
3338 ************************************************************************/
3340 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3341 don't stop updating when input is pending. */
3343 static int
3344 update_window_tree (struct window *w, int force_p)
3346 int paused_p = 0;
3348 while (w && !paused_p)
3350 if (!NILP (w->hchild))
3351 paused_p |= update_window_tree (XWINDOW (w->hchild), force_p);
3352 else if (!NILP (w->vchild))
3353 paused_p |= update_window_tree (XWINDOW (w->vchild), force_p);
3354 else if (w->must_be_updated_p)
3355 paused_p |= update_window (w, force_p);
3357 w = NILP (w->next) ? 0 : XWINDOW (w->next);
3360 return paused_p;
3364 /* Update window W if its flag must_be_updated_p is non-zero. If
3365 FORCE_P is non-zero, don't stop updating if input is pending. */
3367 void
3368 update_single_window (struct window *w, int force_p)
3370 if (w->must_be_updated_p)
3372 struct frame *f = XFRAME (WINDOW_FRAME (w));
3374 /* Record that this is not a frame-based redisplay. */
3375 set_frame_matrix_frame (NULL);
3377 if (redisplay_dont_pause)
3378 force_p = 1;
3379 #if PERIODIC_PREEMPTION_CHECKING
3380 else if (NILP (Vredisplay_preemption_period))
3381 force_p = 1;
3382 else if (!force_p && NUMBERP (Vredisplay_preemption_period))
3384 EMACS_TIME tm;
3385 double p = XFLOATINT (Vredisplay_preemption_period);
3386 int sec, usec;
3388 sec = (int) p;
3389 usec = (p - sec) * 1000000;
3391 EMACS_GET_TIME (tm);
3392 EMACS_SET_SECS_USECS (preemption_period, sec, usec);
3393 EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
3395 #endif
3397 /* Update W. */
3398 update_begin (f);
3399 update_window (w, force_p);
3400 update_end (f);
3402 /* Reset flag in W. */
3403 w->must_be_updated_p = 0;
3407 #ifdef HAVE_WINDOW_SYSTEM
3409 /* Redraw lines from the current matrix of window W that are
3410 overlapped by other rows. YB is bottom-most y-position in W. */
3412 static void
3413 redraw_overlapped_rows (struct window *w, int yb)
3415 int i;
3416 struct frame *f = XFRAME (WINDOW_FRAME (w));
3418 /* If rows overlapping others have been changed, the rows being
3419 overlapped have to be redrawn. This won't draw lines that have
3420 already been drawn in update_window_line because overlapped_p in
3421 desired rows is 0, so after row assignment overlapped_p in
3422 current rows is 0. */
3423 for (i = 0; i < w->current_matrix->nrows; ++i)
3425 struct glyph_row *row = w->current_matrix->rows + i;
3427 if (!row->enabled_p)
3428 break;
3429 else if (row->mode_line_p)
3430 continue;
3432 if (row->overlapped_p)
3434 enum glyph_row_area area;
3436 for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
3438 updated_row = row;
3439 updated_area = area;
3440 FRAME_RIF (f)->cursor_to (i, 0, row->y,
3441 area == TEXT_AREA ? row->x : 0);
3442 if (row->used[area])
3443 FRAME_RIF (f)->write_glyphs (row->glyphs[area],
3444 row->used[area]);
3445 FRAME_RIF (f)->clear_end_of_line (-1);
3448 row->overlapped_p = 0;
3451 if (MATRIX_ROW_BOTTOM_Y (row) >= yb)
3452 break;
3457 /* Redraw lines from the current matrix of window W that overlap
3458 others. YB is bottom-most y-position in W. */
3460 static void
3461 redraw_overlapping_rows (struct window *w, int yb)
3463 int i, bottom_y;
3464 struct glyph_row *row;
3465 struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
3467 for (i = 0; i < w->current_matrix->nrows; ++i)
3469 row = w->current_matrix->rows + i;
3471 if (!row->enabled_p)
3472 break;
3473 else if (row->mode_line_p)
3474 continue;
3476 bottom_y = MATRIX_ROW_BOTTOM_Y (row);
3478 if (row->overlapping_p)
3480 int overlaps = 0;
3482 if (MATRIX_ROW_OVERLAPS_PRED_P (row) && i > 0
3483 && !MATRIX_ROW (w->current_matrix, i - 1)->overlapped_p)
3484 overlaps |= OVERLAPS_PRED;
3485 if (MATRIX_ROW_OVERLAPS_SUCC_P (row) && bottom_y < yb
3486 && !MATRIX_ROW (w->current_matrix, i + 1)->overlapped_p)
3487 overlaps |= OVERLAPS_SUCC;
3489 if (overlaps)
3491 if (row->used[LEFT_MARGIN_AREA])
3492 rif->fix_overlapping_area (w, row, LEFT_MARGIN_AREA, overlaps);
3494 if (row->used[TEXT_AREA])
3495 rif->fix_overlapping_area (w, row, TEXT_AREA, overlaps);
3497 if (row->used[RIGHT_MARGIN_AREA])
3498 rif->fix_overlapping_area (w, row, RIGHT_MARGIN_AREA, overlaps);
3500 /* Record in neighbor rows that ROW overwrites part of
3501 their display. */
3502 if (overlaps & OVERLAPS_PRED)
3503 MATRIX_ROW (w->current_matrix, i - 1)->overlapped_p = 1;
3504 if (overlaps & OVERLAPS_SUCC)
3505 MATRIX_ROW (w->current_matrix, i + 1)->overlapped_p = 1;
3509 if (bottom_y >= yb)
3510 break;
3514 #endif /* HAVE_WINDOW_SYSTEM */
3517 #if defined GLYPH_DEBUG && 0
3519 /* Check that no row in the current matrix of window W is enabled
3520 which is below what's displayed in the window. */
3522 static void
3523 check_current_matrix_flags (struct window *w)
3525 int last_seen_p = 0;
3526 int i, yb = window_text_bottom_y (w);
3528 for (i = 0; i < w->current_matrix->nrows - 1; ++i)
3530 struct glyph_row *row = MATRIX_ROW (w->current_matrix, i);
3531 if (!last_seen_p && MATRIX_ROW_BOTTOM_Y (row) >= yb)
3532 last_seen_p = 1;
3533 else if (last_seen_p && row->enabled_p)
3534 abort ();
3538 #endif /* GLYPH_DEBUG */
3541 /* Update display of window W. FORCE_P non-zero means that we should
3542 not stop when detecting pending input. */
3544 static int
3545 update_window (struct window *w, int force_p)
3547 struct glyph_matrix *desired_matrix = w->desired_matrix;
3548 int paused_p;
3549 #if !PERIODIC_PREEMPTION_CHECKING
3550 int preempt_count = baud_rate / 2400 + 1;
3551 #endif
3552 struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
3553 #if GLYPH_DEBUG
3554 /* Check that W's frame doesn't have glyph matrices. */
3555 xassert (FRAME_WINDOW_P (XFRAME (WINDOW_FRAME (w))));
3556 #endif
3558 /* Check pending input the first time so that we can quickly return. */
3559 #if !PERIODIC_PREEMPTION_CHECKING
3560 if (!force_p)
3561 detect_input_pending_ignore_squeezables ();
3562 #endif
3564 /* If forced to complete the update, or if no input is pending, do
3565 the update. */
3566 if (force_p || !input_pending || !NILP (do_mouse_tracking))
3568 struct glyph_row *row, *end;
3569 struct glyph_row *mode_line_row;
3570 struct glyph_row *header_line_row;
3571 int yb, changed_p = 0, mouse_face_overwritten_p = 0;
3572 #if ! PERIODIC_PREEMPTION_CHECKING
3573 int n_updated = 0;
3574 #endif
3576 rif->update_window_begin_hook (w);
3577 yb = window_text_bottom_y (w);
3578 row = desired_matrix->rows;
3579 end = row + desired_matrix->nrows - 1;
3581 /* Take note of the header line, if there is one. We will
3582 update it below, after updating all of the window's lines. */
3583 if (row->mode_line_p)
3585 header_line_row = row;
3586 ++row;
3588 else
3589 header_line_row = NULL;
3591 /* Update the mode line, if necessary. */
3592 mode_line_row = MATRIX_MODE_LINE_ROW (desired_matrix);
3593 if (mode_line_row->mode_line_p && mode_line_row->enabled_p)
3595 mode_line_row->y = yb;
3596 update_window_line (w, MATRIX_ROW_VPOS (mode_line_row,
3597 desired_matrix),
3598 &mouse_face_overwritten_p);
3601 /* Find first enabled row. Optimizations in redisplay_internal
3602 may lead to an update with only one row enabled. There may
3603 be also completely empty matrices. */
3604 while (row < end && !row->enabled_p)
3605 ++row;
3607 /* Try reusing part of the display by copying. */
3608 if (row < end && !desired_matrix->no_scrolling_p)
3610 int rc = scrolling_window (w, header_line_row != NULL);
3611 if (rc < 0)
3613 /* All rows were found to be equal. */
3614 paused_p = 0;
3615 goto set_cursor;
3617 else if (rc > 0)
3619 /* We've scrolled the display. */
3620 force_p = 1;
3621 changed_p = 1;
3625 /* Update the rest of the lines. */
3626 for (; row < end && (force_p || !input_pending); ++row)
3627 /* scrolling_window resets the enabled_p flag of the rows it
3628 reuses from current_matrix. */
3629 if (row->enabled_p)
3631 int vpos = MATRIX_ROW_VPOS (row, desired_matrix);
3632 int i;
3634 /* We'll have to play a little bit with when to
3635 detect_input_pending. If it's done too often,
3636 scrolling large windows with repeated scroll-up
3637 commands will too quickly pause redisplay. */
3638 #if PERIODIC_PREEMPTION_CHECKING
3639 if (!force_p)
3641 EMACS_TIME tm, dif;
3642 EMACS_GET_TIME (tm);
3643 EMACS_SUB_TIME (dif, preemption_next_check, tm);
3644 if (EMACS_TIME_NEG_P (dif))
3646 EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
3647 if (detect_input_pending_ignore_squeezables ())
3648 break;
3651 #else
3652 if (!force_p && ++n_updated % preempt_count == 0)
3653 detect_input_pending_ignore_squeezables ();
3654 #endif
3655 changed_p |= update_window_line (w, vpos,
3656 &mouse_face_overwritten_p);
3658 /* Mark all rows below the last visible one in the current
3659 matrix as invalid. This is necessary because of
3660 variable line heights. Consider the case of three
3661 successive redisplays, where the first displays 5
3662 lines, the second 3 lines, and the third 5 lines again.
3663 If the second redisplay wouldn't mark rows in the
3664 current matrix invalid, the third redisplay might be
3665 tempted to optimize redisplay based on lines displayed
3666 in the first redisplay. */
3667 if (MATRIX_ROW_BOTTOM_Y (row) >= yb)
3668 for (i = vpos + 1; i < w->current_matrix->nrows - 1; ++i)
3669 MATRIX_ROW (w->current_matrix, i)->enabled_p = 0;
3672 /* Was display preempted? */
3673 paused_p = row < end;
3675 set_cursor:
3677 /* Update the header line after scrolling because a new header
3678 line would otherwise overwrite lines at the top of the window
3679 that can be scrolled. */
3680 if (header_line_row && header_line_row->enabled_p)
3682 header_line_row->y = 0;
3683 update_window_line (w, 0, &mouse_face_overwritten_p);
3686 /* Fix the appearance of overlapping/overlapped rows. */
3687 if (!paused_p && !w->pseudo_window_p)
3689 #ifdef HAVE_WINDOW_SYSTEM
3690 if (changed_p && rif->fix_overlapping_area)
3692 redraw_overlapped_rows (w, yb);
3693 redraw_overlapping_rows (w, yb);
3695 #endif
3697 /* Make cursor visible at cursor position of W. */
3698 set_window_cursor_after_update (w);
3700 #if 0 /* Check that current matrix invariants are satisfied. This is
3701 for debugging only. See the comment of check_matrix_invariants. */
3702 IF_DEBUG (check_matrix_invariants (w));
3703 #endif
3706 #if GLYPH_DEBUG
3707 /* Remember the redisplay method used to display the matrix. */
3708 strcpy (w->current_matrix->method, w->desired_matrix->method);
3709 #endif
3711 #ifdef HAVE_WINDOW_SYSTEM
3712 update_window_fringes (w, 0);
3713 #endif
3715 /* End the update of window W. Don't set the cursor if we
3716 paused updating the display because in this case,
3717 set_window_cursor_after_update hasn't been called, and
3718 output_cursor doesn't contain the cursor location. */
3719 rif->update_window_end_hook (w, !paused_p, mouse_face_overwritten_p);
3721 else
3722 paused_p = 1;
3724 #if GLYPH_DEBUG
3725 /* check_current_matrix_flags (w); */
3726 add_window_display_history (w, w->current_matrix->method, paused_p);
3727 #endif
3729 clear_glyph_matrix (desired_matrix);
3731 return paused_p;
3735 /* Update the display of area AREA in window W, row number VPOS.
3736 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3738 static void
3739 update_marginal_area (struct window *w, int area, int vpos)
3741 struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
3742 struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
3744 /* Let functions in xterm.c know what area subsequent X positions
3745 will be relative to. */
3746 updated_area = area;
3748 /* Set cursor to start of glyphs, write them, and clear to the end
3749 of the area. I don't think that something more sophisticated is
3750 necessary here, since marginal areas will not be the default. */
3751 rif->cursor_to (vpos, 0, desired_row->y, 0);
3752 if (desired_row->used[area])
3753 rif->write_glyphs (desired_row->glyphs[area], desired_row->used[area]);
3754 rif->clear_end_of_line (-1);
3758 /* Update the display of the text area of row VPOS in window W.
3759 Value is non-zero if display has changed. */
3761 static int
3762 update_text_area (struct window *w, int vpos)
3764 struct glyph_row *current_row = MATRIX_ROW (w->current_matrix, vpos);
3765 struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
3766 struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
3767 int changed_p = 0;
3769 /* Let functions in xterm.c know what area subsequent X positions
3770 will be relative to. */
3771 updated_area = TEXT_AREA;
3773 /* If rows are at different X or Y, or rows have different height,
3774 or the current row is marked invalid, write the entire line. */
3775 if (!current_row->enabled_p
3776 || desired_row->y != current_row->y
3777 || desired_row->ascent != current_row->ascent
3778 || desired_row->phys_ascent != current_row->phys_ascent
3779 || desired_row->phys_height != current_row->phys_height
3780 || desired_row->visible_height != current_row->visible_height
3781 || current_row->overlapped_p
3782 /* This next line is necessary for correctly redrawing
3783 mouse-face areas after scrolling and other operations.
3784 However, it causes excessive flickering when mouse is moved
3785 across the mode line. Luckily, turning it off for the mode
3786 line doesn't seem to hurt anything. -- cyd.
3787 But it is still needed for the header line. -- kfs. */
3788 || (current_row->mouse_face_p
3789 && !(current_row->mode_line_p && vpos > 0))
3790 || current_row->x != desired_row->x)
3792 rif->cursor_to (vpos, 0, desired_row->y, desired_row->x);
3794 if (desired_row->used[TEXT_AREA])
3795 rif->write_glyphs (desired_row->glyphs[TEXT_AREA],
3796 desired_row->used[TEXT_AREA]);
3798 /* Clear to end of window. */
3799 rif->clear_end_of_line (-1);
3800 changed_p = 1;
3802 /* This erases the cursor. We do this here because
3803 notice_overwritten_cursor cannot easily check this, which
3804 might indicate that the whole functionality of
3805 notice_overwritten_cursor would better be implemented here.
3806 On the other hand, we need notice_overwritten_cursor as long
3807 as mouse highlighting is done asynchronously outside of
3808 redisplay. */
3809 if (vpos == w->phys_cursor.vpos)
3810 w->phys_cursor_on_p = 0;
3812 else
3814 int stop, i, x;
3815 struct glyph *current_glyph = current_row->glyphs[TEXT_AREA];
3816 struct glyph *desired_glyph = desired_row->glyphs[TEXT_AREA];
3817 int overlapping_glyphs_p = current_row->contains_overlapping_glyphs_p;
3818 int desired_stop_pos = desired_row->used[TEXT_AREA];
3819 int abort_skipping = 0;
3821 /* If the desired row extends its face to the text area end, and
3822 unless the current row also does so at the same position,
3823 make sure we write at least one glyph, so that the face
3824 extension actually takes place. */
3825 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row)
3826 && (desired_stop_pos < current_row->used[TEXT_AREA]
3827 || (desired_stop_pos == current_row->used[TEXT_AREA]
3828 && !MATRIX_ROW_EXTENDS_FACE_P (current_row))))
3829 --desired_stop_pos;
3831 stop = min (current_row->used[TEXT_AREA], desired_stop_pos);
3832 i = 0;
3833 x = desired_row->x;
3835 /* Loop over glyphs that current and desired row may have
3836 in common. */
3837 while (i < stop)
3839 int can_skip_p = !abort_skipping;
3841 /* Skip over glyphs that both rows have in common. These
3842 don't have to be written. We can't skip if the last
3843 current glyph overlaps the glyph to its right. For
3844 example, consider a current row of `if ' with the `f' in
3845 Courier bold so that it overlaps the ` ' to its right.
3846 If the desired row is ` ', we would skip over the space
3847 after the `if' and there would remain a pixel from the
3848 `f' on the screen. */
3849 if (overlapping_glyphs_p && i > 0)
3851 struct glyph *glyph = &current_row->glyphs[TEXT_AREA][i - 1];
3852 int left, right;
3854 rif->get_glyph_overhangs (glyph, XFRAME (w->frame),
3855 &left, &right);
3856 can_skip_p = (right == 0 && !abort_skipping);
3859 if (can_skip_p)
3861 int start_hpos = i;
3863 while (i < stop
3864 && GLYPH_EQUAL_P (desired_glyph, current_glyph))
3866 x += desired_glyph->pixel_width;
3867 ++desired_glyph, ++current_glyph, ++i;
3870 /* Consider the case that the current row contains "xxx
3871 ppp ggg" in italic Courier font, and the desired row
3872 is "xxx ggg". The character `p' has lbearing, `g'
3873 has not. The loop above will stop in front of the
3874 first `p' in the current row. If we would start
3875 writing glyphs there, we wouldn't erase the lbearing
3876 of the `p'. The rest of the lbearing problem is then
3877 taken care of by draw_glyphs. */
3878 if (overlapping_glyphs_p
3879 && i > 0
3880 && i < current_row->used[TEXT_AREA]
3881 && (current_row->used[TEXT_AREA]
3882 != desired_row->used[TEXT_AREA]))
3884 int left, right;
3886 rif->get_glyph_overhangs (current_glyph, XFRAME (w->frame),
3887 &left, &right);
3888 while (left > 0 && i > 0)
3890 --i, --desired_glyph, --current_glyph;
3891 x -= desired_glyph->pixel_width;
3892 left -= desired_glyph->pixel_width;
3895 /* Abort the skipping algorithm if we end up before
3896 our starting point, to avoid looping (bug#1070).
3897 This can happen when the lbearing is larger than
3898 the pixel width. */
3899 abort_skipping = (i < start_hpos);
3903 /* Try to avoid writing the entire rest of the desired row
3904 by looking for a resync point. This mainly prevents
3905 mode line flickering in the case the mode line is in
3906 fixed-pitch font, which it usually will be. */
3907 if (i < desired_row->used[TEXT_AREA])
3909 int start_x = x, start_hpos = i;
3910 struct glyph *start = desired_glyph;
3911 int current_x = x;
3912 int skip_first_p = !can_skip_p;
3914 /* Find the next glyph that's equal again. */
3915 while (i < stop
3916 && (skip_first_p
3917 || !GLYPH_EQUAL_P (desired_glyph, current_glyph))
3918 && x == current_x)
3920 x += desired_glyph->pixel_width;
3921 current_x += current_glyph->pixel_width;
3922 ++desired_glyph, ++current_glyph, ++i;
3923 skip_first_p = 0;
3926 if (i == start_hpos || x != current_x)
3928 i = start_hpos;
3929 x = start_x;
3930 desired_glyph = start;
3931 break;
3934 rif->cursor_to (vpos, start_hpos, desired_row->y, start_x);
3935 rif->write_glyphs (start, i - start_hpos);
3936 changed_p = 1;
3940 /* Write the rest. */
3941 if (i < desired_row->used[TEXT_AREA])
3943 rif->cursor_to (vpos, i, desired_row->y, x);
3944 rif->write_glyphs (desired_glyph, desired_row->used[TEXT_AREA] - i);
3945 changed_p = 1;
3948 /* Maybe clear to end of line. */
3949 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row))
3951 /* If new row extends to the end of the text area, nothing
3952 has to be cleared, if and only if we did a write_glyphs
3953 above. This is made sure by setting desired_stop_pos
3954 appropriately above. */
3955 xassert (i < desired_row->used[TEXT_AREA]
3956 || ((desired_row->used[TEXT_AREA]
3957 == current_row->used[TEXT_AREA])
3958 && MATRIX_ROW_EXTENDS_FACE_P (current_row)));
3960 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row))
3962 /* If old row extends to the end of the text area, clear. */
3963 if (i >= desired_row->used[TEXT_AREA])
3964 rif->cursor_to (vpos, i, desired_row->y,
3965 desired_row->pixel_width);
3966 rif->clear_end_of_line (-1);
3967 changed_p = 1;
3969 else if (desired_row->pixel_width < current_row->pixel_width)
3971 /* Otherwise clear to the end of the old row. Everything
3972 after that position should be clear already. */
3973 int xlim;
3975 if (i >= desired_row->used[TEXT_AREA])
3976 rif->cursor_to (vpos, i, desired_row->y,
3977 desired_row->pixel_width);
3979 /* If cursor is displayed at the end of the line, make sure
3980 it's cleared. Nowadays we don't have a phys_cursor_glyph
3981 with which to erase the cursor (because this method
3982 doesn't work with lbearing/rbearing), so we must do it
3983 this way. */
3984 if (vpos == w->phys_cursor.vpos
3985 && (desired_row->reversed_p
3986 ? (w->phys_cursor.hpos < 0)
3987 : (w->phys_cursor.hpos >= desired_row->used[TEXT_AREA])))
3989 w->phys_cursor_on_p = 0;
3990 xlim = -1;
3992 else
3993 xlim = current_row->pixel_width;
3994 rif->clear_end_of_line (xlim);
3995 changed_p = 1;
3999 return changed_p;
4003 /* Update row VPOS in window W. Value is non-zero if display has been
4004 changed. */
4006 static int
4007 update_window_line (struct window *w, int vpos, int *mouse_face_overwritten_p)
4009 struct glyph_row *current_row = MATRIX_ROW (w->current_matrix, vpos);
4010 struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
4011 struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
4012 int changed_p = 0;
4014 /* Set the row being updated. This is important to let xterm.c
4015 know what line height values are in effect. */
4016 updated_row = desired_row;
4018 /* A row can be completely invisible in case a desired matrix was
4019 built with a vscroll and then make_cursor_line_fully_visible shifts
4020 the matrix. Make sure to make such rows current anyway, since
4021 we need the correct y-position, for example, in the current matrix. */
4022 if (desired_row->mode_line_p
4023 || desired_row->visible_height > 0)
4025 xassert (desired_row->enabled_p);
4027 /* Update display of the left margin area, if there is one. */
4028 if (!desired_row->full_width_p
4029 && !NILP (w->left_margin_cols))
4031 changed_p = 1;
4032 update_marginal_area (w, LEFT_MARGIN_AREA, vpos);
4035 /* Update the display of the text area. */
4036 if (update_text_area (w, vpos))
4038 changed_p = 1;
4039 if (current_row->mouse_face_p)
4040 *mouse_face_overwritten_p = 1;
4043 /* Update display of the right margin area, if there is one. */
4044 if (!desired_row->full_width_p
4045 && !NILP (w->right_margin_cols))
4047 changed_p = 1;
4048 update_marginal_area (w, RIGHT_MARGIN_AREA, vpos);
4051 /* Draw truncation marks etc. */
4052 if (!current_row->enabled_p
4053 || desired_row->y != current_row->y
4054 || desired_row->visible_height != current_row->visible_height
4055 || desired_row->cursor_in_fringe_p != current_row->cursor_in_fringe_p
4056 || desired_row->overlay_arrow_bitmap != current_row->overlay_arrow_bitmap
4057 || current_row->redraw_fringe_bitmaps_p
4058 || desired_row->mode_line_p != current_row->mode_line_p
4059 || desired_row->exact_window_width_line_p != current_row->exact_window_width_line_p
4060 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row)
4061 != MATRIX_ROW_CONTINUATION_LINE_P (current_row)))
4062 rif->after_update_window_line_hook (desired_row);
4065 /* Update current_row from desired_row. */
4066 make_current (w->desired_matrix, w->current_matrix, vpos);
4067 updated_row = NULL;
4068 return changed_p;
4072 /* Set the cursor after an update of window W. This function may only
4073 be called from update_window. */
4075 static void
4076 set_window_cursor_after_update (struct window *w)
4078 struct frame *f = XFRAME (w->frame);
4079 struct redisplay_interface *rif = FRAME_RIF (f);
4080 int cx, cy, vpos, hpos;
4082 /* Not intended for frame matrix updates. */
4083 xassert (FRAME_WINDOW_P (f));
4085 if (cursor_in_echo_area
4086 && !NILP (echo_area_buffer[0])
4087 /* If we are showing a message instead of the mini-buffer,
4088 show the cursor for the message instead. */
4089 && XWINDOW (minibuf_window) == w
4090 && EQ (minibuf_window, echo_area_window)
4091 /* These cases apply only to the frame that contains
4092 the active mini-buffer window. */
4093 && FRAME_HAS_MINIBUF_P (f)
4094 && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
4096 cx = cy = vpos = hpos = 0;
4098 if (cursor_in_echo_area >= 0)
4100 /* If the mini-buffer is several lines high, find the last
4101 line that has any text on it. Note: either all lines
4102 are enabled or none. Otherwise we wouldn't be able to
4103 determine Y. */
4104 struct glyph_row *row, *last_row;
4105 struct glyph *glyph;
4106 int yb = window_text_bottom_y (w);
4108 last_row = NULL;
4109 row = w->current_matrix->rows;
4110 while (row->enabled_p
4111 && (last_row == NULL
4112 || MATRIX_ROW_BOTTOM_Y (row) <= yb))
4114 if (row->used[TEXT_AREA]
4115 && row->glyphs[TEXT_AREA][0].charpos >= 0)
4116 last_row = row;
4117 ++row;
4120 if (last_row)
4122 struct glyph *start = last_row->glyphs[TEXT_AREA];
4123 struct glyph *last = start + last_row->used[TEXT_AREA] - 1;
4125 while (last > start && last->charpos < 0)
4126 --last;
4128 for (glyph = start; glyph < last; ++glyph)
4130 cx += glyph->pixel_width;
4131 ++hpos;
4134 cy = last_row->y;
4135 vpos = MATRIX_ROW_VPOS (last_row, w->current_matrix);
4139 else
4141 cx = w->cursor.x;
4142 cy = w->cursor.y;
4143 hpos = w->cursor.hpos;
4144 vpos = w->cursor.vpos;
4147 /* Window cursor can be out of sync for horizontally split windows. */
4148 hpos = max (-1, hpos); /* -1 is for when cursor is on the left fringe */
4149 hpos = min (w->current_matrix->matrix_w - 1, hpos);
4150 vpos = max (0, vpos);
4151 vpos = min (w->current_matrix->nrows - 1, vpos);
4152 rif->cursor_to (vpos, hpos, cy, cx);
4156 /* Set WINDOW->must_be_updated_p to ON_P for all windows in the window
4157 tree rooted at W. */
4159 void
4160 set_window_update_flags (struct window *w, int on_p)
4162 while (w)
4164 if (!NILP (w->hchild))
4165 set_window_update_flags (XWINDOW (w->hchild), on_p);
4166 else if (!NILP (w->vchild))
4167 set_window_update_flags (XWINDOW (w->vchild), on_p);
4168 else
4169 w->must_be_updated_p = on_p;
4171 w = NILP (w->next) ? 0 : XWINDOW (w->next);
4177 /***********************************************************************
4178 Window-Based Scrolling
4179 ***********************************************************************/
4181 /* Structure describing rows in scrolling_window. */
4183 struct row_entry
4185 /* Number of occurrences of this row in desired and current matrix. */
4186 int old_uses, new_uses;
4188 /* Vpos of row in new matrix. */
4189 int new_line_number;
4191 /* Bucket index of this row_entry in the hash table row_table. */
4192 ptrdiff_t bucket;
4194 /* The row described by this entry. */
4195 struct glyph_row *row;
4197 /* Hash collision chain. */
4198 struct row_entry *next;
4201 /* A pool to allocate row_entry structures from, and the size of the
4202 pool. The pool is reallocated in scrolling_window when we find
4203 that we need a larger one. */
4205 static struct row_entry *row_entry_pool;
4206 static ptrdiff_t row_entry_pool_size;
4208 /* Index of next free entry in row_entry_pool. */
4210 static ptrdiff_t row_entry_idx;
4212 /* The hash table used during scrolling, and the table's size. This
4213 table is used to quickly identify equal rows in the desired and
4214 current matrix. */
4216 static struct row_entry **row_table;
4217 static ptrdiff_t row_table_size;
4219 /* Vectors of pointers to row_entry structures belonging to the
4220 current and desired matrix, and the size of the vectors. */
4222 static struct row_entry **old_lines, **new_lines;
4223 static ptrdiff_t old_lines_size, new_lines_size;
4225 /* A pool to allocate run structures from, and its size. */
4227 static struct run *run_pool;
4228 static ptrdiff_t runs_size;
4230 /* A vector of runs of lines found during scrolling. */
4232 static struct run **runs;
4234 /* Add glyph row ROW to the scrolling hash table. */
4236 static inline struct row_entry *
4237 add_row_entry (struct glyph_row *row)
4239 struct row_entry *entry;
4240 ptrdiff_t i = row->hash % row_table_size;
4242 entry = row_table[i];
4243 xassert (entry || verify_row_hash (row));
4244 while (entry && !row_equal_p (entry->row, row, 1))
4245 entry = entry->next;
4247 if (entry == NULL)
4249 entry = row_entry_pool + row_entry_idx++;
4250 entry->row = row;
4251 entry->old_uses = entry->new_uses = 0;
4252 entry->new_line_number = 0;
4253 entry->bucket = i;
4254 entry->next = row_table[i];
4255 row_table[i] = entry;
4258 return entry;
4262 /* Try to reuse part of the current display of W by scrolling lines.
4263 HEADER_LINE_P non-zero means W has a header line.
4265 The algorithm is taken from Communications of the ACM, Apr78 "A
4266 Technique for Isolating Differences Between Files." It should take
4267 O(N) time.
4269 A short outline of the steps of the algorithm
4271 1. Skip lines equal at the start and end of both matrices.
4273 2. Enter rows in the current and desired matrix into a symbol
4274 table, counting how often they appear in both matrices.
4276 3. Rows that appear exactly once in both matrices serve as anchors,
4277 i.e. we assume that such lines are likely to have been moved.
4279 4. Starting from anchor lines, extend regions to be scrolled both
4280 forward and backward.
4282 Value is
4284 -1 if all rows were found to be equal.
4285 0 to indicate that we did not scroll the display, or
4286 1 if we did scroll. */
4288 static int
4289 scrolling_window (struct window *w, int header_line_p)
4291 struct glyph_matrix *desired_matrix = w->desired_matrix;
4292 struct glyph_matrix *current_matrix = w->current_matrix;
4293 int yb = window_text_bottom_y (w);
4294 ptrdiff_t i;
4295 int j, first_old, first_new, last_old, last_new;
4296 int nruns, run_idx;
4297 ptrdiff_t n;
4298 struct row_entry *entry;
4299 struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
4301 /* Skip over rows equal at the start. */
4302 for (i = header_line_p ? 1 : 0; i < current_matrix->nrows - 1; ++i)
4304 struct glyph_row *d = MATRIX_ROW (desired_matrix, i);
4305 struct glyph_row *c = MATRIX_ROW (current_matrix, i);
4307 if (c->enabled_p
4308 && d->enabled_p
4309 && !d->redraw_fringe_bitmaps_p
4310 && c->y == d->y
4311 && MATRIX_ROW_BOTTOM_Y (c) <= yb
4312 && MATRIX_ROW_BOTTOM_Y (d) <= yb
4313 && row_equal_p (c, d, 1))
4315 assign_row (c, d);
4316 d->enabled_p = 0;
4318 else
4319 break;
4322 /* Give up if some rows in the desired matrix are not enabled. */
4323 if (!MATRIX_ROW (desired_matrix, i)->enabled_p)
4324 return -1;
4326 first_old = first_new = i;
4328 /* Set last_new to the index + 1 of the row that reaches the
4329 bottom boundary in the desired matrix. Give up if we find a
4330 disabled row before we reach the bottom boundary. */
4331 i = first_new + 1;
4332 while (i < desired_matrix->nrows - 1)
4334 int bottom;
4336 if (!MATRIX_ROW (desired_matrix, i)->enabled_p)
4337 return 0;
4338 bottom = MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix, i));
4339 if (bottom <= yb)
4340 ++i;
4341 if (bottom >= yb)
4342 break;
4345 last_new = i;
4347 /* Set last_old to the index + 1 of the row that reaches the bottom
4348 boundary in the current matrix. We don't look at the enabled
4349 flag here because we plan to reuse part of the display even if
4350 other parts are disabled. */
4351 i = first_old + 1;
4352 while (i < current_matrix->nrows - 1)
4354 int bottom = MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix, i));
4355 if (bottom <= yb)
4356 ++i;
4357 if (bottom >= yb)
4358 break;
4361 last_old = i;
4363 /* Skip over rows equal at the bottom. */
4364 i = last_new;
4365 j = last_old;
4366 while (i - 1 > first_new
4367 && j - 1 > first_old
4368 && MATRIX_ROW (current_matrix, j - 1)->enabled_p
4369 && (MATRIX_ROW (current_matrix, j - 1)->y
4370 == MATRIX_ROW (desired_matrix, i - 1)->y)
4371 && !MATRIX_ROW (desired_matrix, i - 1)->redraw_fringe_bitmaps_p
4372 && row_equal_p (MATRIX_ROW (desired_matrix, i - 1),
4373 MATRIX_ROW (current_matrix, j - 1), 1))
4374 --i, --j;
4375 last_new = i;
4376 last_old = j;
4378 /* Nothing to do if all rows are equal. */
4379 if (last_new == first_new)
4380 return 0;
4382 /* Check for integer overflow in size calculation.
4384 If next_almost_prime checks (N) for divisibility by 2..10, then
4385 it can return at most N + 10, e.g., next_almost_prime (1) == 11.
4386 So, set next_almost_prime_increment_max to 10.
4388 It's just a coincidence that next_almost_prime_increment_max ==
4389 NEXT_ALMOST_PRIME_LIMIT - 1. If NEXT_ALMOST_PRIME_LIMIT were
4390 13, then next_almost_prime_increment_max would be 14, e.g.,
4391 because next_almost_prime (113) would be 127. */
4393 verify (NEXT_ALMOST_PRIME_LIMIT == 11);
4394 enum { next_almost_prime_increment_max = 10 };
4395 ptrdiff_t row_table_max =
4396 (min (PTRDIFF_MAX, SIZE_MAX) / (3 * sizeof *row_table)
4397 - next_almost_prime_increment_max);
4398 ptrdiff_t current_nrows_max = row_table_max - desired_matrix->nrows;
4399 if (current_nrows_max < current_matrix->nrows)
4400 memory_full (SIZE_MAX);
4403 /* Reallocate vectors, tables etc. if necessary. */
4405 if (current_matrix->nrows > old_lines_size)
4406 old_lines = xpalloc (old_lines, &old_lines_size,
4407 current_matrix->nrows - old_lines_size,
4408 INT_MAX, sizeof *old_lines);
4410 if (desired_matrix->nrows > new_lines_size)
4411 new_lines = xpalloc (new_lines, &new_lines_size,
4412 desired_matrix->nrows - new_lines_size,
4413 INT_MAX, sizeof *new_lines);
4415 n = desired_matrix->nrows;
4416 n += current_matrix->nrows;
4417 if (row_table_size < 3 * n)
4419 ptrdiff_t size = next_almost_prime (3 * n);
4420 row_table = xnrealloc (row_table, size, sizeof *row_table);
4421 row_table_size = size;
4422 memset (row_table, 0, size * sizeof *row_table);
4425 if (n > row_entry_pool_size)
4426 row_entry_pool = xpalloc (row_entry_pool, &row_entry_pool_size,
4427 n - row_entry_pool_size,
4428 -1, sizeof *row_entry_pool);
4430 if (desired_matrix->nrows > runs_size)
4432 runs = xnrealloc (runs, desired_matrix->nrows, sizeof *runs);
4433 run_pool = xnrealloc (run_pool, desired_matrix->nrows, sizeof *run_pool);
4434 runs_size = desired_matrix->nrows;
4437 nruns = run_idx = 0;
4438 row_entry_idx = 0;
4440 /* Add rows from the current and desired matrix to the hash table
4441 row_hash_table to be able to find equal ones quickly. */
4443 for (i = first_old; i < last_old; ++i)
4445 if (MATRIX_ROW (current_matrix, i)->enabled_p)
4447 entry = add_row_entry (MATRIX_ROW (current_matrix, i));
4448 old_lines[i] = entry;
4449 ++entry->old_uses;
4451 else
4452 old_lines[i] = NULL;
4455 for (i = first_new; i < last_new; ++i)
4457 xassert (MATRIX_ROW_ENABLED_P (desired_matrix, i));
4458 entry = add_row_entry (MATRIX_ROW (desired_matrix, i));
4459 ++entry->new_uses;
4460 entry->new_line_number = i;
4461 new_lines[i] = entry;
4464 /* Identify moves based on lines that are unique and equal
4465 in both matrices. */
4466 for (i = first_old; i < last_old;)
4467 if (old_lines[i]
4468 && old_lines[i]->old_uses == 1
4469 && old_lines[i]->new_uses == 1)
4471 int p, q;
4472 int new_line = old_lines[i]->new_line_number;
4473 struct run *run = run_pool + run_idx++;
4475 /* Record move. */
4476 run->current_vpos = i;
4477 run->current_y = MATRIX_ROW (current_matrix, i)->y;
4478 run->desired_vpos = new_line;
4479 run->desired_y = MATRIX_ROW (desired_matrix, new_line)->y;
4480 run->nrows = 1;
4481 run->height = MATRIX_ROW (current_matrix, i)->height;
4483 /* Extend backward. */
4484 p = i - 1;
4485 q = new_line - 1;
4486 while (p > first_old
4487 && q > first_new
4488 && old_lines[p] == new_lines[q])
4490 int h = MATRIX_ROW (current_matrix, p)->height;
4491 --run->current_vpos;
4492 --run->desired_vpos;
4493 ++run->nrows;
4494 run->height += h;
4495 run->desired_y -= h;
4496 run->current_y -= h;
4497 --p, --q;
4500 /* Extend forward. */
4501 p = i + 1;
4502 q = new_line + 1;
4503 while (p < last_old
4504 && q < last_new
4505 && old_lines[p] == new_lines[q])
4507 int h = MATRIX_ROW (current_matrix, p)->height;
4508 ++run->nrows;
4509 run->height += h;
4510 ++p, ++q;
4513 /* Insert run into list of all runs. Order runs by copied
4514 pixel lines. Note that we record runs that don't have to
4515 be copied because they are already in place. This is done
4516 because we can avoid calling update_window_line in this
4517 case. */
4518 for (p = 0; p < nruns && runs[p]->height > run->height; ++p)
4520 for (q = nruns; q > p; --q)
4521 runs[q] = runs[q - 1];
4522 runs[p] = run;
4523 ++nruns;
4525 i += run->nrows;
4527 else
4528 ++i;
4530 /* Do the moves. Do it in a way that we don't overwrite something
4531 we want to copy later on. This is not solvable in general
4532 because there is only one display and we don't have a way to
4533 exchange areas on this display. Example:
4535 +-----------+ +-----------+
4536 | A | | B |
4537 +-----------+ --> +-----------+
4538 | B | | A |
4539 +-----------+ +-----------+
4541 Instead, prefer bigger moves, and invalidate moves that would
4542 copy from where we copied to. */
4544 for (i = 0; i < nruns; ++i)
4545 if (runs[i]->nrows > 0)
4547 struct run *r = runs[i];
4549 /* Copy on the display. */
4550 if (r->current_y != r->desired_y)
4552 rif->clear_window_mouse_face (w);
4553 rif->scroll_run_hook (w, r);
4556 /* Truncate runs that copy to where we copied to, and
4557 invalidate runs that copy from where we copied to. */
4558 for (j = nruns - 1; j > i; --j)
4560 struct run *p = runs[j];
4561 int truncated_p = 0;
4563 if (p->nrows > 0
4564 && p->desired_y < r->desired_y + r->height
4565 && p->desired_y + p->height > r->desired_y)
4567 if (p->desired_y < r->desired_y)
4569 p->nrows = r->desired_vpos - p->desired_vpos;
4570 p->height = r->desired_y - p->desired_y;
4571 truncated_p = 1;
4573 else
4575 int nrows_copied = (r->desired_vpos + r->nrows
4576 - p->desired_vpos);
4578 if (p->nrows <= nrows_copied)
4579 p->nrows = 0;
4580 else
4582 int height_copied = (r->desired_y + r->height
4583 - p->desired_y);
4585 p->current_vpos += nrows_copied;
4586 p->desired_vpos += nrows_copied;
4587 p->nrows -= nrows_copied;
4588 p->current_y += height_copied;
4589 p->desired_y += height_copied;
4590 p->height -= height_copied;
4591 truncated_p = 1;
4596 if (r->current_y != r->desired_y
4597 /* The condition below is equivalent to
4598 ((p->current_y >= r->desired_y
4599 && p->current_y < r->desired_y + r->height)
4600 || (p->current_y + p->height > r->desired_y
4601 && (p->current_y + p->height
4602 <= r->desired_y + r->height)))
4603 because we have 0 < p->height <= r->height. */
4604 && p->current_y < r->desired_y + r->height
4605 && p->current_y + p->height > r->desired_y)
4606 p->nrows = 0;
4608 /* Reorder runs by copied pixel lines if truncated. */
4609 if (truncated_p && p->nrows > 0)
4611 int k = nruns - 1;
4613 while (runs[k]->nrows == 0 || runs[k]->height < p->height)
4614 k--;
4615 memmove (runs + j, runs + j + 1, (k - j) * sizeof (*runs));
4616 runs[k] = p;
4620 /* Assign matrix rows. */
4621 for (j = 0; j < r->nrows; ++j)
4623 struct glyph_row *from, *to;
4624 int to_overlapped_p;
4626 to = MATRIX_ROW (current_matrix, r->desired_vpos + j);
4627 from = MATRIX_ROW (desired_matrix, r->desired_vpos + j);
4628 to_overlapped_p = to->overlapped_p;
4629 from->redraw_fringe_bitmaps_p = from->fringe_bitmap_periodic_p;
4630 assign_row (to, from);
4631 /* The above `assign_row' actually does swap, so if we had
4632 an overlap in the copy destination of two runs, then
4633 the second run would assign a previously disabled bogus
4634 row. But thanks to the truncation code in the
4635 preceding for-loop, we no longer have such an overlap,
4636 and thus the assigned row should always be enabled. */
4637 xassert (to->enabled_p);
4638 from->enabled_p = 0;
4639 to->overlapped_p = to_overlapped_p;
4643 /* Clear the hash table, for the next time. */
4644 for (i = 0; i < row_entry_idx; ++i)
4645 row_table[row_entry_pool[i].bucket] = NULL;
4647 /* Value is 1 to indicate that we scrolled the display. */
4648 return 0 < nruns;
4653 /************************************************************************
4654 Frame-Based Updates
4655 ************************************************************************/
4657 /* Update the desired frame matrix of frame F.
4659 FORCE_P non-zero means that the update should not be stopped by
4660 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
4661 should not be tried.
4663 Value is non-zero if update was stopped due to pending input. */
4665 static int
4666 update_frame_1 (struct frame *f, int force_p, int inhibit_id_p)
4668 /* Frame matrices to work on. */
4669 struct glyph_matrix *current_matrix = f->current_matrix;
4670 struct glyph_matrix *desired_matrix = f->desired_matrix;
4671 int i;
4672 int pause_p;
4673 int preempt_count = baud_rate / 2400 + 1;
4675 xassert (current_matrix && desired_matrix);
4677 if (baud_rate != FRAME_COST_BAUD_RATE (f))
4678 calculate_costs (f);
4680 if (preempt_count <= 0)
4681 preempt_count = 1;
4683 #if !PERIODIC_PREEMPTION_CHECKING
4684 if (!force_p && detect_input_pending_ignore_squeezables ())
4686 pause_p = 1;
4687 goto do_pause;
4689 #endif
4691 /* If we cannot insert/delete lines, it's no use trying it. */
4692 if (!FRAME_LINE_INS_DEL_OK (f))
4693 inhibit_id_p = 1;
4695 /* See if any of the desired lines are enabled; don't compute for
4696 i/d line if just want cursor motion. */
4697 for (i = 0; i < desired_matrix->nrows; i++)
4698 if (MATRIX_ROW_ENABLED_P (desired_matrix, i))
4699 break;
4701 /* Try doing i/d line, if not yet inhibited. */
4702 if (!inhibit_id_p && i < desired_matrix->nrows)
4703 force_p |= scrolling (f);
4705 /* Update the individual lines as needed. Do bottom line first. */
4706 if (MATRIX_ROW_ENABLED_P (desired_matrix, desired_matrix->nrows - 1))
4707 update_frame_line (f, desired_matrix->nrows - 1);
4709 /* Now update the rest of the lines. */
4710 for (i = 0; i < desired_matrix->nrows - 1 && (force_p || !input_pending); i++)
4712 if (MATRIX_ROW_ENABLED_P (desired_matrix, i))
4714 if (FRAME_TERMCAP_P (f))
4716 /* Flush out every so many lines.
4717 Also flush out if likely to have more than 1k buffered
4718 otherwise. I'm told that some telnet connections get
4719 really screwed by more than 1k output at once. */
4720 FILE *display_output = FRAME_TTY (f)->output;
4721 if (display_output)
4723 int outq = PENDING_OUTPUT_COUNT (display_output);
4724 if (outq > 900
4725 || (outq > 20 && ((i - 1) % preempt_count == 0)))
4727 fflush (display_output);
4728 if (preempt_count == 1)
4730 #ifdef EMACS_OUTQSIZE
4731 if (EMACS_OUTQSIZE (0, &outq) < 0)
4732 /* Probably not a tty. Ignore the error and reset
4733 the outq count. */
4734 outq = PENDING_OUTPUT_COUNT (FRAME_TTY (f->output));
4735 #endif
4736 outq *= 10;
4737 if (baud_rate <= outq && baud_rate > 0)
4738 sleep (outq / baud_rate);
4744 #if PERIODIC_PREEMPTION_CHECKING
4745 if (!force_p)
4747 EMACS_TIME tm, dif;
4748 EMACS_GET_TIME (tm);
4749 EMACS_SUB_TIME (dif, preemption_next_check, tm);
4750 if (EMACS_TIME_NEG_P (dif))
4752 EMACS_ADD_TIME (preemption_next_check, tm, preemption_period);
4753 if (detect_input_pending_ignore_squeezables ())
4754 break;
4757 #else
4758 if (!force_p && (i - 1) % preempt_count == 0)
4759 detect_input_pending_ignore_squeezables ();
4760 #endif
4762 update_frame_line (f, i);
4766 pause_p = (i < FRAME_LINES (f) - 1) ? i : 0;
4768 /* Now just clean up termcap drivers and set cursor, etc. */
4769 if (!pause_p)
4771 if ((cursor_in_echo_area
4772 /* If we are showing a message instead of the mini-buffer,
4773 show the cursor for the message instead of for the
4774 (now hidden) mini-buffer contents. */
4775 || (EQ (minibuf_window, selected_window)
4776 && EQ (minibuf_window, echo_area_window)
4777 && !NILP (echo_area_buffer[0])))
4778 /* These cases apply only to the frame that contains
4779 the active mini-buffer window. */
4780 && FRAME_HAS_MINIBUF_P (f)
4781 && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
4783 int top = WINDOW_TOP_EDGE_LINE (XWINDOW (FRAME_MINIBUF_WINDOW (f)));
4784 int row, col;
4786 if (cursor_in_echo_area < 0)
4788 /* Negative value of cursor_in_echo_area means put
4789 cursor at beginning of line. */
4790 row = top;
4791 col = 0;
4793 else
4795 /* Positive value of cursor_in_echo_area means put
4796 cursor at the end of the prompt. If the mini-buffer
4797 is several lines high, find the last line that has
4798 any text on it. */
4799 row = FRAME_LINES (f);
4802 --row;
4803 col = 0;
4805 if (MATRIX_ROW_ENABLED_P (current_matrix, row))
4807 /* Frame rows are filled up with spaces that
4808 must be ignored here. */
4809 struct glyph_row *r = MATRIX_ROW (current_matrix,
4810 row);
4811 struct glyph *start = r->glyphs[TEXT_AREA];
4812 struct glyph *last = start + r->used[TEXT_AREA];
4814 while (last > start
4815 && (last - 1)->charpos < 0)
4816 --last;
4818 col = last - start;
4821 while (row > top && col == 0);
4823 /* Make sure COL is not out of range. */
4824 if (col >= FRAME_CURSOR_X_LIMIT (f))
4826 /* If we have another row, advance cursor into it. */
4827 if (row < FRAME_LINES (f) - 1)
4829 col = FRAME_LEFT_SCROLL_BAR_COLS (f);
4830 row++;
4832 /* Otherwise move it back in range. */
4833 else
4834 col = FRAME_CURSOR_X_LIMIT (f) - 1;
4838 cursor_to (f, row, col);
4840 else
4842 /* We have only one cursor on terminal frames. Use it to
4843 display the cursor of the selected window. */
4844 struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
4845 if (w->cursor.vpos >= 0
4846 /* The cursor vpos may be temporarily out of bounds
4847 in the following situation: There is one window,
4848 with the cursor in the lower half of it. The window
4849 is split, and a message causes a redisplay before
4850 a new cursor position has been computed. */
4851 && w->cursor.vpos < WINDOW_TOTAL_LINES (w))
4853 int x = WINDOW_TO_FRAME_HPOS (w, w->cursor.hpos);
4854 int y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
4856 if (INTEGERP (w->left_margin_cols))
4857 x += XFASTINT (w->left_margin_cols);
4859 /* x = max (min (x, FRAME_TOTAL_COLS (f) - 1), 0); */
4860 cursor_to (f, y, x);
4865 #if !PERIODIC_PREEMPTION_CHECKING
4866 do_pause:
4867 #endif
4869 clear_desired_matrices (f);
4870 return pause_p;
4874 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4876 static int
4877 scrolling (struct frame *frame)
4879 int unchanged_at_top, unchanged_at_bottom;
4880 int window_size;
4881 int changed_lines;
4882 int *old_hash = (int *) alloca (FRAME_LINES (frame) * sizeof (int));
4883 int *new_hash = (int *) alloca (FRAME_LINES (frame) * sizeof (int));
4884 int *draw_cost = (int *) alloca (FRAME_LINES (frame) * sizeof (int));
4885 int *old_draw_cost = (int *) alloca (FRAME_LINES (frame) * sizeof (int));
4886 register int i;
4887 int free_at_end_vpos = FRAME_LINES (frame);
4888 struct glyph_matrix *current_matrix = frame->current_matrix;
4889 struct glyph_matrix *desired_matrix = frame->desired_matrix;
4891 if (!current_matrix)
4892 abort ();
4894 /* Compute hash codes of all the lines. Also calculate number of
4895 changed lines, number of unchanged lines at the beginning, and
4896 number of unchanged lines at the end. */
4897 changed_lines = 0;
4898 unchanged_at_top = 0;
4899 unchanged_at_bottom = FRAME_LINES (frame);
4900 for (i = 0; i < FRAME_LINES (frame); i++)
4902 /* Give up on this scrolling if some old lines are not enabled. */
4903 if (!MATRIX_ROW_ENABLED_P (current_matrix, i))
4904 return 0;
4905 old_hash[i] = line_hash_code (MATRIX_ROW (current_matrix, i));
4906 if (! MATRIX_ROW_ENABLED_P (desired_matrix, i))
4908 /* This line cannot be redrawn, so don't let scrolling mess it. */
4909 new_hash[i] = old_hash[i];
4910 #define INFINITY 1000000 /* Taken from scroll.c */
4911 draw_cost[i] = INFINITY;
4913 else
4915 new_hash[i] = line_hash_code (MATRIX_ROW (desired_matrix, i));
4916 draw_cost[i] = line_draw_cost (desired_matrix, i);
4919 if (old_hash[i] != new_hash[i])
4921 changed_lines++;
4922 unchanged_at_bottom = FRAME_LINES (frame) - i - 1;
4924 else if (i == unchanged_at_top)
4925 unchanged_at_top++;
4926 old_draw_cost[i] = line_draw_cost (current_matrix, i);
4929 /* If changed lines are few, don't allow preemption, don't scroll. */
4930 if ((!FRAME_SCROLL_REGION_OK (frame)
4931 && changed_lines < baud_rate / 2400)
4932 || unchanged_at_bottom == FRAME_LINES (frame))
4933 return 1;
4935 window_size = (FRAME_LINES (frame) - unchanged_at_top
4936 - unchanged_at_bottom);
4938 if (FRAME_SCROLL_REGION_OK (frame))
4939 free_at_end_vpos -= unchanged_at_bottom;
4940 else if (FRAME_MEMORY_BELOW_FRAME (frame))
4941 free_at_end_vpos = -1;
4943 /* If large window, fast terminal and few lines in common between
4944 current frame and desired frame, don't bother with i/d calc. */
4945 if (!FRAME_SCROLL_REGION_OK (frame)
4946 && window_size >= 18 && baud_rate > 2400
4947 && (window_size >=
4948 10 * scrolling_max_lines_saved (unchanged_at_top,
4949 FRAME_LINES (frame) - unchanged_at_bottom,
4950 old_hash, new_hash, draw_cost)))
4951 return 0;
4953 if (window_size < 2)
4954 return 0;
4956 scrolling_1 (frame, window_size, unchanged_at_top, unchanged_at_bottom,
4957 draw_cost + unchanged_at_top - 1,
4958 old_draw_cost + unchanged_at_top - 1,
4959 old_hash + unchanged_at_top - 1,
4960 new_hash + unchanged_at_top - 1,
4961 free_at_end_vpos - unchanged_at_top);
4963 return 0;
4967 /* Count the number of blanks at the start of the vector of glyphs R
4968 which is LEN glyphs long. */
4970 static int
4971 count_blanks (struct glyph *r, int len)
4973 int i;
4975 for (i = 0; i < len; ++i)
4976 if (!CHAR_GLYPH_SPACE_P (r[i]))
4977 break;
4979 return i;
4983 /* Count the number of glyphs in common at the start of the glyph
4984 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
4985 of STR2. Value is the number of equal glyphs equal at the start. */
4987 static int
4988 count_match (struct glyph *str1, struct glyph *end1, struct glyph *str2, struct glyph *end2)
4990 struct glyph *p1 = str1;
4991 struct glyph *p2 = str2;
4993 while (p1 < end1
4994 && p2 < end2
4995 && GLYPH_CHAR_AND_FACE_EQUAL_P (p1, p2))
4996 ++p1, ++p2;
4998 return p1 - str1;
5002 /* Char insertion/deletion cost vector, from term.c */
5004 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_TOTAL_COLS ((f))])
5007 /* Perform a frame-based update on line VPOS in frame FRAME. */
5009 static void
5010 update_frame_line (struct frame *f, int vpos)
5012 struct glyph *obody, *nbody, *op1, *op2, *np1, *nend;
5013 int tem;
5014 int osp, nsp, begmatch, endmatch, olen, nlen;
5015 struct glyph_matrix *current_matrix = f->current_matrix;
5016 struct glyph_matrix *desired_matrix = f->desired_matrix;
5017 struct glyph_row *current_row = MATRIX_ROW (current_matrix, vpos);
5018 struct glyph_row *desired_row = MATRIX_ROW (desired_matrix, vpos);
5019 int must_write_whole_line_p;
5020 int write_spaces_p = FRAME_MUST_WRITE_SPACES (f);
5021 int colored_spaces_p = (FACE_FROM_ID (f, DEFAULT_FACE_ID)->background
5022 != FACE_TTY_DEFAULT_BG_COLOR);
5024 if (colored_spaces_p)
5025 write_spaces_p = 1;
5027 /* Current row not enabled means it has unknown contents. We must
5028 write the whole desired line in that case. */
5029 must_write_whole_line_p = !current_row->enabled_p;
5030 if (must_write_whole_line_p)
5032 obody = 0;
5033 olen = 0;
5035 else
5037 obody = MATRIX_ROW_GLYPH_START (current_matrix, vpos);
5038 olen = current_row->used[TEXT_AREA];
5040 /* Ignore trailing spaces, if we can. */
5041 if (!write_spaces_p)
5042 while (olen > 0 && CHAR_GLYPH_SPACE_P (obody[olen-1]))
5043 olen--;
5046 current_row->enabled_p = 1;
5047 current_row->used[TEXT_AREA] = desired_row->used[TEXT_AREA];
5049 /* If desired line is empty, just clear the line. */
5050 if (!desired_row->enabled_p)
5052 nlen = 0;
5053 goto just_erase;
5056 nbody = desired_row->glyphs[TEXT_AREA];
5057 nlen = desired_row->used[TEXT_AREA];
5058 nend = nbody + nlen;
5060 /* If display line has unknown contents, write the whole line. */
5061 if (must_write_whole_line_p)
5063 /* Ignore spaces at the end, if we can. */
5064 if (!write_spaces_p)
5065 while (nlen > 0 && CHAR_GLYPH_SPACE_P (nbody[nlen - 1]))
5066 --nlen;
5068 /* Write the contents of the desired line. */
5069 if (nlen)
5071 cursor_to (f, vpos, 0);
5072 write_glyphs (f, nbody, nlen);
5075 /* Don't call clear_end_of_line if we already wrote the whole
5076 line. The cursor will not be at the right margin in that
5077 case but in the line below. */
5078 if (nlen < FRAME_TOTAL_COLS (f))
5080 cursor_to (f, vpos, nlen);
5081 clear_end_of_line (f, FRAME_TOTAL_COLS (f));
5083 else
5084 /* Make sure we are in the right row, otherwise cursor movement
5085 with cmgoto might use `ch' in the wrong row. */
5086 cursor_to (f, vpos, 0);
5088 make_current (desired_matrix, current_matrix, vpos);
5089 return;
5092 /* Pretend trailing spaces are not there at all,
5093 unless for one reason or another we must write all spaces. */
5094 if (!write_spaces_p)
5095 while (nlen > 0 && CHAR_GLYPH_SPACE_P (nbody[nlen - 1]))
5096 nlen--;
5098 /* If there's no i/d char, quickly do the best we can without it. */
5099 if (!FRAME_CHAR_INS_DEL_OK (f))
5101 int i, j;
5103 /* Find the first glyph in desired row that doesn't agree with
5104 a glyph in the current row, and write the rest from there on. */
5105 for (i = 0; i < nlen; i++)
5107 if (i >= olen || !GLYPH_EQUAL_P (nbody + i, obody + i))
5109 /* Find the end of the run of different glyphs. */
5110 j = i + 1;
5111 while (j < nlen
5112 && (j >= olen
5113 || !GLYPH_EQUAL_P (nbody + j, obody + j)
5114 || CHAR_GLYPH_PADDING_P (nbody[j])))
5115 ++j;
5117 /* Output this run of non-matching chars. */
5118 cursor_to (f, vpos, i);
5119 write_glyphs (f, nbody + i, j - i);
5120 i = j - 1;
5122 /* Now find the next non-match. */
5126 /* Clear the rest of the line, or the non-clear part of it. */
5127 if (olen > nlen)
5129 cursor_to (f, vpos, nlen);
5130 clear_end_of_line (f, olen);
5133 /* Make current row = desired row. */
5134 make_current (desired_matrix, current_matrix, vpos);
5135 return;
5138 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
5139 characters in a row. */
5141 if (!olen)
5143 /* If current line is blank, skip over initial spaces, if
5144 possible, and write the rest. */
5145 if (write_spaces_p)
5146 nsp = 0;
5147 else
5148 nsp = count_blanks (nbody, nlen);
5150 if (nlen > nsp)
5152 cursor_to (f, vpos, nsp);
5153 write_glyphs (f, nbody + nsp, nlen - nsp);
5156 /* Exchange contents between current_frame and new_frame. */
5157 make_current (desired_matrix, current_matrix, vpos);
5158 return;
5161 /* Compute number of leading blanks in old and new contents. */
5162 osp = count_blanks (obody, olen);
5163 nsp = (colored_spaces_p ? 0 : count_blanks (nbody, nlen));
5165 /* Compute number of matching chars starting with first non-blank. */
5166 begmatch = count_match (obody + osp, obody + olen,
5167 nbody + nsp, nbody + nlen);
5169 /* Spaces in new match implicit space past the end of old. */
5170 /* A bug causing this to be a no-op was fixed in 18.29. */
5171 if (!write_spaces_p && osp + begmatch == olen)
5173 np1 = nbody + nsp;
5174 while (np1 + begmatch < nend && CHAR_GLYPH_SPACE_P (np1[begmatch]))
5175 ++begmatch;
5178 /* Avoid doing insert/delete char
5179 just cause number of leading spaces differs
5180 when the following text does not match. */
5181 if (begmatch == 0 && osp != nsp)
5182 osp = nsp = min (osp, nsp);
5184 /* Find matching characters at end of line */
5185 op1 = obody + olen;
5186 np1 = nbody + nlen;
5187 op2 = op1 + begmatch - min (olen - osp, nlen - nsp);
5188 while (op1 > op2
5189 && GLYPH_EQUAL_P (op1 - 1, np1 - 1))
5191 op1--;
5192 np1--;
5194 endmatch = obody + olen - op1;
5196 /* tem gets the distance to insert or delete.
5197 endmatch is how many characters we save by doing so.
5198 Is it worth it? */
5200 tem = (nlen - nsp) - (olen - osp);
5201 if (endmatch && tem
5202 && (!FRAME_CHAR_INS_DEL_OK (f)
5203 || endmatch <= char_ins_del_cost (f)[tem]))
5204 endmatch = 0;
5206 /* nsp - osp is the distance to insert or delete.
5207 If that is nonzero, begmatch is known to be nonzero also.
5208 begmatch + endmatch is how much we save by doing the ins/del.
5209 Is it worth it? */
5211 if (nsp != osp
5212 && (!FRAME_CHAR_INS_DEL_OK (f)
5213 || begmatch + endmatch <= char_ins_del_cost (f)[nsp - osp]))
5215 begmatch = 0;
5216 endmatch = 0;
5217 osp = nsp = min (osp, nsp);
5220 /* Now go through the line, inserting, writing and
5221 deleting as appropriate. */
5223 if (osp > nsp)
5225 cursor_to (f, vpos, nsp);
5226 delete_glyphs (f, osp - nsp);
5228 else if (nsp > osp)
5230 /* If going to delete chars later in line
5231 and insert earlier in the line,
5232 must delete first to avoid losing data in the insert */
5233 if (endmatch && nlen < olen + nsp - osp)
5235 cursor_to (f, vpos, nlen - endmatch + osp - nsp);
5236 delete_glyphs (f, olen + nsp - osp - nlen);
5237 olen = nlen - (nsp - osp);
5239 cursor_to (f, vpos, osp);
5240 insert_glyphs (f, 0, nsp - osp);
5242 olen += nsp - osp;
5244 tem = nsp + begmatch + endmatch;
5245 if (nlen != tem || olen != tem)
5247 if (!endmatch || nlen == olen)
5249 /* If new text being written reaches right margin, there is
5250 no need to do clear-to-eol at the end of this function
5251 (and it would not be safe, since cursor is not going to
5252 be "at the margin" after the text is done). */
5253 if (nlen == FRAME_TOTAL_COLS (f))
5254 olen = 0;
5256 /* Function write_glyphs is prepared to do nothing
5257 if passed a length <= 0. Check it here to avoid
5258 unnecessary cursor movement. */
5259 if (nlen - tem > 0)
5261 cursor_to (f, vpos, nsp + begmatch);
5262 write_glyphs (f, nbody + nsp + begmatch, nlen - tem);
5265 else if (nlen > olen)
5267 /* Here, we used to have the following simple code:
5268 ----------------------------------------
5269 write_glyphs (nbody + nsp + begmatch, olen - tem);
5270 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5271 ----------------------------------------
5272 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5273 is a padding glyph. */
5274 int out = olen - tem; /* Columns to be overwritten originally. */
5275 int del;
5277 cursor_to (f, vpos, nsp + begmatch);
5279 /* Calculate columns we can actually overwrite. */
5280 while (CHAR_GLYPH_PADDING_P (nbody[nsp + begmatch + out]))
5281 out--;
5282 write_glyphs (f, nbody + nsp + begmatch, out);
5284 /* If we left columns to be overwritten, we must delete them. */
5285 del = olen - tem - out;
5286 if (del > 0)
5287 delete_glyphs (f, del);
5289 /* At last, we insert columns not yet written out. */
5290 insert_glyphs (f, nbody + nsp + begmatch + out, nlen - olen + del);
5291 olen = nlen;
5293 else if (olen > nlen)
5295 cursor_to (f, vpos, nsp + begmatch);
5296 write_glyphs (f, nbody + nsp + begmatch, nlen - tem);
5297 delete_glyphs (f, olen - nlen);
5298 olen = nlen;
5302 just_erase:
5303 /* If any unerased characters remain after the new line, erase them. */
5304 if (olen > nlen)
5306 cursor_to (f, vpos, nlen);
5307 clear_end_of_line (f, olen);
5310 /* Exchange contents between current_frame and new_frame. */
5311 make_current (desired_matrix, current_matrix, vpos);
5316 /***********************************************************************
5317 X/Y Position -> Buffer Position
5318 ***********************************************************************/
5320 /* Determine what's under window-relative pixel position (*X, *Y).
5321 Return the OBJECT (string or buffer) that's there.
5322 Return in *POS the position in that object.
5323 Adjust *X and *Y to character positions.
5324 Return in *DX and *DY the pixel coordinates of the click,
5325 relative to the top left corner of OBJECT, or relative to
5326 the top left corner of the character glyph at (*X, *Y)
5327 if OBJECT is nil.
5328 Return WIDTH and HEIGHT of the object at (*X, *Y), or zero
5329 if the coordinates point to an empty area of the display. */
5331 Lisp_Object
5332 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)
5334 struct it it;
5335 Lisp_Object old_current_buffer = Fcurrent_buffer ();
5336 struct text_pos startp;
5337 Lisp_Object string;
5338 struct glyph_row *row;
5339 #ifdef HAVE_WINDOW_SYSTEM
5340 struct image *img = 0;
5341 #endif
5342 int x0, x1, to_x;
5343 void *itdata = NULL;
5345 /* We used to set current_buffer directly here, but that does the
5346 wrong thing with `face-remapping-alist' (bug#2044). */
5347 Fset_buffer (w->buffer);
5348 itdata = bidi_shelve_cache ();
5349 SET_TEXT_POS_FROM_MARKER (startp, w->start);
5350 CHARPOS (startp) = min (ZV, max (BEGV, CHARPOS (startp)));
5351 BYTEPOS (startp) = min (ZV_BYTE, max (BEGV_BYTE, BYTEPOS (startp)));
5352 start_display (&it, w, startp);
5353 /* start_display takes into account the header-line row, but IT's
5354 vpos still counts from the glyph row that includes the window's
5355 start position. Adjust for a possible header-line row. */
5356 it.vpos += WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0;
5358 x0 = *x;
5360 /* First, move to the beginning of the row corresponding to *Y. We
5361 need to be in that row to get the correct value of base paragraph
5362 direction for the text at (*X, *Y). */
5363 move_it_to (&it, -1, 0, *y, -1, MOVE_TO_X | MOVE_TO_Y);
5365 /* TO_X is the pixel position that the iterator will compute for the
5366 glyph at *X. We add it.first_visible_x because iterator
5367 positions include the hscroll. */
5368 to_x = x0 + it.first_visible_x;
5369 if (it.bidi_it.paragraph_dir == R2L)
5370 /* For lines in an R2L paragraph, we need to mirror TO_X wrt the
5371 text area. This is because the iterator, even in R2L
5372 paragraphs, delivers glyphs as if they started at the left
5373 margin of the window. (When we actually produce glyphs for
5374 display, we reverse their order in PRODUCE_GLYPHS, but the
5375 iterator doesn't know about that.) The following line adjusts
5376 the pixel position to the iterator geometry, which is what
5377 move_it_* routines use. (The -1 is because in a window whose
5378 text-area width is W, the rightmost pixel position is W-1, and
5379 it should be mirrored into zero pixel position.) */
5380 to_x = window_box_width (w, TEXT_AREA) - to_x - 1;
5382 /* Now move horizontally in the row to the glyph under *X. Second
5383 argument is ZV to prevent move_it_in_display_line from matching
5384 based on buffer positions. */
5385 move_it_in_display_line (&it, ZV, to_x, MOVE_TO_X);
5386 bidi_unshelve_cache (itdata, 0);
5388 Fset_buffer (old_current_buffer);
5390 *dx = x0 + it.first_visible_x - it.current_x;
5391 *dy = *y - it.current_y;
5393 string = w->buffer;
5394 if (STRINGP (it.string))
5395 string = it.string;
5396 *pos = it.current;
5397 if (it.what == IT_COMPOSITION
5398 && it.cmp_it.nchars > 1
5399 && it.cmp_it.reversed_p)
5401 /* The current display element is a grapheme cluster in a
5402 composition. In that case, we need the position of the first
5403 character of the cluster. But, as it.cmp_it.reversed_p is 1,
5404 it.current points to the last character of the cluster, thus
5405 we must move back to the first character of the same
5406 cluster. */
5407 CHARPOS (pos->pos) -= it.cmp_it.nchars - 1;
5408 if (STRINGP (it.string))
5409 BYTEPOS (pos->pos) = string_char_to_byte (string, CHARPOS (pos->pos));
5410 else
5411 BYTEPOS (pos->pos) = buf_charpos_to_bytepos (XBUFFER (w->buffer),
5412 CHARPOS (pos->pos));
5415 #ifdef HAVE_WINDOW_SYSTEM
5416 if (it.what == IT_IMAGE)
5418 if ((img = IMAGE_FROM_ID (it.f, it.image_id)) != NULL
5419 && !NILP (img->spec))
5420 *object = img->spec;
5422 #endif
5424 if (it.vpos < w->current_matrix->nrows
5425 && (row = MATRIX_ROW (w->current_matrix, it.vpos),
5426 row->enabled_p))
5428 if (it.hpos < row->used[TEXT_AREA])
5430 struct glyph *glyph = row->glyphs[TEXT_AREA] + it.hpos;
5431 #ifdef HAVE_WINDOW_SYSTEM
5432 if (img)
5434 *dy -= row->ascent - glyph->ascent;
5435 *dx += glyph->slice.img.x;
5436 *dy += glyph->slice.img.y;
5437 /* Image slices positions are still relative to the entire image */
5438 *width = img->width;
5439 *height = img->height;
5441 else
5442 #endif
5444 *width = glyph->pixel_width;
5445 *height = glyph->ascent + glyph->descent;
5448 else
5450 *width = 0;
5451 *height = row->height;
5454 else
5456 *width = *height = 0;
5459 /* Add extra (default width) columns if clicked after EOL. */
5460 x1 = max (0, it.current_x + it.pixel_width - it.first_visible_x);
5461 if (x0 > x1)
5462 it.hpos += (x0 - x1) / WINDOW_FRAME_COLUMN_WIDTH (w);
5464 *x = it.hpos;
5465 *y = it.vpos;
5467 return string;
5471 /* Value is the string under window-relative coordinates X/Y in the
5472 mode line or header line (PART says which) of window W, or nil if none.
5473 *CHARPOS is set to the position in the string returned. */
5475 Lisp_Object
5476 mode_line_string (struct window *w, enum window_part part,
5477 int *x, int *y, EMACS_INT *charpos, Lisp_Object *object,
5478 int *dx, int *dy, int *width, int *height)
5480 struct glyph_row *row;
5481 struct glyph *glyph, *end;
5482 int x0, y0;
5483 Lisp_Object string = Qnil;
5485 if (part == ON_MODE_LINE)
5486 row = MATRIX_MODE_LINE_ROW (w->current_matrix);
5487 else
5488 row = MATRIX_HEADER_LINE_ROW (w->current_matrix);
5489 y0 = *y - row->y;
5490 *y = row - MATRIX_FIRST_TEXT_ROW (w->current_matrix);
5492 if (row->mode_line_p && row->enabled_p)
5494 /* Find the glyph under X. If we find one with a string object,
5495 it's the one we were looking for. */
5496 glyph = row->glyphs[TEXT_AREA];
5497 end = glyph + row->used[TEXT_AREA];
5498 for (x0 = *x; glyph < end && x0 >= glyph->pixel_width; ++glyph)
5499 x0 -= glyph->pixel_width;
5500 *x = glyph - row->glyphs[TEXT_AREA];
5501 if (glyph < end)
5503 string = glyph->object;
5504 *charpos = glyph->charpos;
5505 *width = glyph->pixel_width;
5506 *height = glyph->ascent + glyph->descent;
5507 #ifdef HAVE_WINDOW_SYSTEM
5508 if (glyph->type == IMAGE_GLYPH)
5510 struct image *img;
5511 img = IMAGE_FROM_ID (WINDOW_XFRAME (w), glyph->u.img_id);
5512 if (img != NULL)
5513 *object = img->spec;
5514 y0 -= row->ascent - glyph->ascent;
5516 #endif
5518 else
5520 /* Add extra (default width) columns if clicked after EOL. */
5521 *x += x0 / WINDOW_FRAME_COLUMN_WIDTH (w);
5522 *width = 0;
5523 *height = row->height;
5526 else
5528 *x = 0;
5529 x0 = 0;
5530 *width = *height = 0;
5533 *dx = x0;
5534 *dy = y0;
5536 return string;
5540 /* Value is the string under window-relative coordinates X/Y in either
5541 marginal area, or nil if none. *CHARPOS is set to the position in
5542 the string returned. */
5544 Lisp_Object
5545 marginal_area_string (struct window *w, enum window_part part,
5546 int *x, int *y, EMACS_INT *charpos, Lisp_Object *object,
5547 int *dx, int *dy, int *width, int *height)
5549 struct glyph_row *row = w->current_matrix->rows;
5550 struct glyph *glyph, *end;
5551 int x0, y0, i, wy = *y;
5552 int area;
5553 Lisp_Object string = Qnil;
5555 if (part == ON_LEFT_MARGIN)
5556 area = LEFT_MARGIN_AREA;
5557 else if (part == ON_RIGHT_MARGIN)
5558 area = RIGHT_MARGIN_AREA;
5559 else
5560 abort ();
5562 for (i = 0; row->enabled_p && i < w->current_matrix->nrows; ++i, ++row)
5563 if (wy >= row->y && wy < MATRIX_ROW_BOTTOM_Y (row))
5564 break;
5565 y0 = *y - row->y;
5566 *y = row - MATRIX_FIRST_TEXT_ROW (w->current_matrix);
5568 if (row->enabled_p)
5570 /* Find the glyph under X. If we find one with a string object,
5571 it's the one we were looking for. */
5572 if (area == RIGHT_MARGIN_AREA)
5573 x0 = ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
5574 ? WINDOW_LEFT_FRINGE_WIDTH (w)
5575 : WINDOW_TOTAL_FRINGE_WIDTH (w))
5576 + window_box_width (w, LEFT_MARGIN_AREA)
5577 + window_box_width (w, TEXT_AREA));
5578 else
5579 x0 = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
5580 ? WINDOW_LEFT_FRINGE_WIDTH (w)
5581 : 0);
5583 glyph = row->glyphs[area];
5584 end = glyph + row->used[area];
5585 for (x0 = *x - x0; glyph < end && x0 >= glyph->pixel_width; ++glyph)
5586 x0 -= glyph->pixel_width;
5587 *x = glyph - row->glyphs[area];
5588 if (glyph < end)
5590 string = glyph->object;
5591 *charpos = glyph->charpos;
5592 *width = glyph->pixel_width;
5593 *height = glyph->ascent + glyph->descent;
5594 #ifdef HAVE_WINDOW_SYSTEM
5595 if (glyph->type == IMAGE_GLYPH)
5597 struct image *img;
5598 img = IMAGE_FROM_ID (WINDOW_XFRAME (w), glyph->u.img_id);
5599 if (img != NULL)
5600 *object = img->spec;
5601 y0 -= row->ascent - glyph->ascent;
5602 x0 += glyph->slice.img.x;
5603 y0 += glyph->slice.img.y;
5605 #endif
5607 else
5609 /* Add extra (default width) columns if clicked after EOL. */
5610 *x += x0 / WINDOW_FRAME_COLUMN_WIDTH (w);
5611 *width = 0;
5612 *height = row->height;
5615 else
5617 x0 = 0;
5618 *x = 0;
5619 *width = *height = 0;
5622 *dx = x0;
5623 *dy = y0;
5625 return string;
5629 /***********************************************************************
5630 Changing Frame Sizes
5631 ***********************************************************************/
5633 #ifdef SIGWINCH
5635 static void
5636 window_change_signal (int signalnum) /* If we don't have an argument, */
5637 /* some compilers complain in signal calls. */
5639 int width, height;
5640 int old_errno = errno;
5642 struct tty_display_info *tty;
5644 signal (SIGWINCH, window_change_signal);
5645 SIGNAL_THREAD_CHECK (signalnum);
5647 /* The frame size change obviously applies to a single
5648 termcap-controlled terminal, but we can't decide which.
5649 Therefore, we resize the frames corresponding to each tty.
5651 for (tty = tty_list; tty; tty = tty->next) {
5653 if (! tty->term_initted)
5654 continue;
5656 /* Suspended tty frames have tty->input == NULL avoid trying to
5657 use it. */
5658 if (!tty->input)
5659 continue;
5661 get_tty_size (fileno (tty->input), &width, &height);
5663 if (width > 5 && height > 2) {
5664 Lisp_Object tail, frame;
5666 FOR_EACH_FRAME (tail, frame)
5667 if (FRAME_TERMCAP_P (XFRAME (frame)) && FRAME_TTY (XFRAME (frame)) == tty)
5668 /* Record the new sizes, but don't reallocate the data
5669 structures now. Let that be done later outside of the
5670 signal handler. */
5671 change_frame_size (XFRAME (frame), height, width, 0, 1, 0);
5675 errno = old_errno;
5677 #endif /* SIGWINCH */
5680 /* Do any change in frame size that was requested by a signal. SAFE
5681 non-zero means this function is called from a place where it is
5682 safe to change frame sizes while a redisplay is in progress. */
5684 void
5685 do_pending_window_change (int safe)
5687 /* If window_change_signal should have run before, run it now. */
5688 if (redisplaying_p && !safe)
5689 return;
5691 while (delayed_size_change)
5693 Lisp_Object tail, frame;
5695 delayed_size_change = 0;
5697 FOR_EACH_FRAME (tail, frame)
5699 struct frame *f = XFRAME (frame);
5701 if (f->new_text_lines != 0 || f->new_text_cols != 0)
5702 change_frame_size (f, f->new_text_lines, f->new_text_cols,
5703 0, 0, safe);
5709 /* Change the frame height and/or width. Values may be given as zero to
5710 indicate no change is to take place.
5712 If DELAY is non-zero, then assume we're being called from a signal
5713 handler, and queue the change for later - perhaps the next
5714 redisplay. Since this tries to resize windows, we can't call it
5715 from a signal handler.
5717 SAFE non-zero means this function is called from a place where it's
5718 safe to change frame sizes while a redisplay is in progress. */
5720 void
5721 change_frame_size (register struct frame *f, int newheight, int newwidth, int pretend, int delay, int safe)
5723 Lisp_Object tail, frame;
5725 if (FRAME_MSDOS_P (f))
5727 /* On MS-DOS, all frames use the same screen, so a change in
5728 size affects all frames. Termcap now supports multiple
5729 ttys. */
5730 FOR_EACH_FRAME (tail, frame)
5731 if (! FRAME_WINDOW_P (XFRAME (frame)))
5732 change_frame_size_1 (XFRAME (frame), newheight, newwidth,
5733 pretend, delay, safe);
5735 else
5736 change_frame_size_1 (f, newheight, newwidth, pretend, delay, safe);
5739 static void
5740 change_frame_size_1 (register struct frame *f, int newheight, int newwidth, int pretend, int delay, int safe)
5742 int new_frame_total_cols;
5743 int count = SPECPDL_INDEX ();
5745 /* If we can't deal with the change now, queue it for later. */
5746 if (delay || (redisplaying_p && !safe))
5748 f->new_text_lines = newheight;
5749 f->new_text_cols = newwidth;
5750 delayed_size_change = 1;
5751 return;
5754 /* This size-change overrides any pending one for this frame. */
5755 f->new_text_lines = 0;
5756 f->new_text_cols = 0;
5758 /* If an argument is zero, set it to the current value. */
5759 if (newheight == 0)
5760 newheight = FRAME_LINES (f);
5761 if (newwidth == 0)
5762 newwidth = FRAME_COLS (f);
5764 /* Compute width of windows in F. */
5765 /* Round up to the smallest acceptable size. */
5766 check_frame_size (f, &newheight, &newwidth);
5768 /* This is the width of the frame with vertical scroll bars and fringe
5769 columns. Do this after rounding - see discussion of bug#9723. */
5770 new_frame_total_cols = FRAME_TOTAL_COLS_ARG (f, newwidth);
5772 /* If we're not changing the frame size, quit now. */
5773 /* Frame width may be unchanged but the text portion may change, for
5774 example, fullscreen and remove/add scroll bar. */
5775 if (newheight == FRAME_LINES (f)
5776 /* Text portion unchanged? */
5777 && newwidth == FRAME_COLS (f)
5778 /* Frame width unchanged? */
5779 && new_frame_total_cols == FRAME_TOTAL_COLS (f))
5780 return;
5782 BLOCK_INPUT;
5784 #ifdef MSDOS
5785 /* We only can set screen dimensions to certain values supported
5786 by our video hardware. Try to find the smallest size greater
5787 or equal to the requested dimensions. */
5788 dos_set_window_size (&newheight, &newwidth);
5789 #endif
5791 if (newheight != FRAME_LINES (f))
5793 resize_frame_windows (f, newheight, 0);
5795 /* MSDOS frames cannot PRETEND, as they change frame size by
5796 manipulating video hardware. */
5797 if ((FRAME_TERMCAP_P (f) && !pretend) || FRAME_MSDOS_P (f))
5798 FrameRows (FRAME_TTY (f)) = newheight;
5801 if (new_frame_total_cols != FRAME_TOTAL_COLS (f))
5803 resize_frame_windows (f, new_frame_total_cols, 1);
5805 /* MSDOS frames cannot PRETEND, as they change frame size by
5806 manipulating video hardware. */
5807 if ((FRAME_TERMCAP_P (f) && !pretend) || FRAME_MSDOS_P (f))
5808 FrameCols (FRAME_TTY (f)) = newwidth;
5810 if (WINDOWP (f->tool_bar_window))
5811 XSETFASTINT (XWINDOW (f->tool_bar_window)->total_cols, newwidth);
5814 FRAME_LINES (f) = newheight;
5815 SET_FRAME_COLS (f, newwidth);
5818 struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
5819 int text_area_x, text_area_y, text_area_width, text_area_height;
5821 window_box (w, TEXT_AREA, &text_area_x, &text_area_y, &text_area_width,
5822 &text_area_height);
5823 if (w->cursor.x >= text_area_x + text_area_width)
5824 w->cursor.hpos = w->cursor.x = 0;
5825 if (w->cursor.y >= text_area_y + text_area_height)
5826 w->cursor.vpos = w->cursor.y = 0;
5829 adjust_glyphs (f);
5830 calculate_costs (f);
5831 SET_FRAME_GARBAGED (f);
5832 f->resized_p = 1;
5834 UNBLOCK_INPUT;
5836 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
5838 run_window_configuration_change_hook (f);
5840 unbind_to (count, Qnil);
5845 /***********************************************************************
5846 Terminal Related Lisp Functions
5847 ***********************************************************************/
5849 DEFUN ("open-termscript", Fopen_termscript, Sopen_termscript,
5850 1, 1, "FOpen termscript file: ",
5851 doc: /* Start writing all terminal output to FILE as well as the terminal.
5852 FILE = nil means just close any termscript file currently open. */)
5853 (Lisp_Object file)
5855 struct tty_display_info *tty;
5857 if (! FRAME_TERMCAP_P (SELECTED_FRAME ())
5858 && ! FRAME_MSDOS_P (SELECTED_FRAME ()))
5859 error ("Current frame is not on a tty device");
5861 tty = CURTTY ();
5863 if (tty->termscript != 0)
5865 BLOCK_INPUT;
5866 fclose (tty->termscript);
5867 UNBLOCK_INPUT;
5869 tty->termscript = 0;
5871 if (! NILP (file))
5873 file = Fexpand_file_name (file, Qnil);
5874 tty->termscript = fopen (SSDATA (file), "w");
5875 if (tty->termscript == 0)
5876 report_file_error ("Opening termscript", Fcons (file, Qnil));
5878 return Qnil;
5882 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal,
5883 Ssend_string_to_terminal, 1, 2, 0,
5884 doc: /* Send STRING to the terminal without alteration.
5885 Control characters in STRING will have terminal-dependent effects.
5887 Optional parameter TERMINAL specifies the tty terminal device to use.
5888 It may be a terminal object, a frame, or nil for the terminal used by
5889 the currently selected frame. In batch mode, STRING is sent to stdout
5890 when TERMINAL is nil. */)
5891 (Lisp_Object string, Lisp_Object terminal)
5893 struct terminal *t = get_terminal (terminal, 1);
5894 FILE *out;
5896 /* ??? Perhaps we should do something special for multibyte strings here. */
5897 CHECK_STRING (string);
5898 BLOCK_INPUT;
5900 if (!t)
5901 error ("Unknown terminal device");
5903 if (t->type == output_initial)
5904 out = stdout;
5905 else if (t->type != output_termcap && t->type != output_msdos_raw)
5906 error ("Device %d is not a termcap terminal device", t->id);
5907 else
5909 struct tty_display_info *tty = t->display_info.tty;
5911 if (! tty->output)
5912 error ("Terminal is currently suspended");
5914 if (tty->termscript)
5916 fwrite (SDATA (string), 1, SBYTES (string), tty->termscript);
5917 fflush (tty->termscript);
5919 out = tty->output;
5921 fwrite (SDATA (string), 1, SBYTES (string), out);
5922 fflush (out);
5923 UNBLOCK_INPUT;
5924 return Qnil;
5928 DEFUN ("ding", Fding, Sding, 0, 1, 0,
5929 doc: /* Beep, or flash the screen.
5930 Also, unless an argument is given,
5931 terminate any keyboard macro currently executing. */)
5932 (Lisp_Object arg)
5934 if (!NILP (arg))
5936 if (noninteractive)
5937 putchar (07);
5938 else
5939 ring_bell (XFRAME (selected_frame));
5941 else
5942 bitch_at_user ();
5944 return Qnil;
5947 void
5948 bitch_at_user (void)
5950 if (noninteractive)
5951 putchar (07);
5952 else if (!INTERACTIVE) /* Stop executing a keyboard macro. */
5953 error ("Keyboard macro terminated by a command ringing the bell");
5954 else
5955 ring_bell (XFRAME (selected_frame));
5960 /***********************************************************************
5961 Sleeping, Waiting
5962 ***********************************************************************/
5964 DEFUN ("sleep-for", Fsleep_for, Ssleep_for, 1, 2, 0,
5965 doc: /* Pause, without updating display, for SECONDS seconds.
5966 SECONDS may be a floating-point value, meaning that you can wait for a
5967 fraction of a second. Optional second arg MILLISECONDS specifies an
5968 additional wait period, in milliseconds; this may be useful if your
5969 Emacs was built without floating point support.
5970 \(Not all operating systems support waiting for a fraction of a second.) */)
5971 (Lisp_Object seconds, Lisp_Object milliseconds)
5973 int sec, usec;
5975 if (NILP (milliseconds))
5976 XSETINT (milliseconds, 0);
5977 else
5978 CHECK_NUMBER (milliseconds);
5979 usec = XINT (milliseconds) * 1000;
5982 double duration = extract_float (seconds);
5983 sec = (int) duration;
5984 usec += (duration - sec) * 1000000;
5987 #ifndef EMACS_HAS_USECS
5988 if (sec == 0 && usec != 0)
5989 error ("Millisecond `sleep-for' not supported on %s", SYSTEM_TYPE);
5990 #endif
5992 /* Assure that 0 <= usec < 1000000. */
5993 if (usec < 0)
5995 /* We can't rely on the rounding being correct if usec is negative. */
5996 if (-1000000 < usec)
5997 sec--, usec += 1000000;
5998 else
5999 sec -= -usec / 1000000, usec = 1000000 - (-usec % 1000000);
6001 else
6002 sec += usec / 1000000, usec %= 1000000;
6004 if (sec < 0 || (sec == 0 && usec == 0))
6005 return Qnil;
6007 wait_reading_process_output (sec, usec, 0, 0, Qnil, NULL, 0);
6009 return Qnil;
6013 /* This is just like wait_reading_process_output, except that
6014 it does redisplay.
6016 TIMEOUT is number of seconds to wait (float or integer),
6017 or t to wait forever.
6018 READING is 1 if reading input.
6019 If DO_DISPLAY is >0 display process output while waiting.
6020 If DO_DISPLAY is >1 perform an initial redisplay before waiting.
6023 Lisp_Object
6024 sit_for (Lisp_Object timeout, int reading, int do_display)
6026 int sec, usec;
6028 swallow_events (do_display);
6030 if ((detect_input_pending_run_timers (do_display))
6031 || !NILP (Vexecuting_kbd_macro))
6032 return Qnil;
6034 if (do_display >= 2)
6035 redisplay_preserve_echo_area (2);
6037 if (INTEGERP (timeout))
6039 sec = XINT (timeout);
6040 usec = 0;
6042 else if (FLOATP (timeout))
6044 double seconds = XFLOAT_DATA (timeout);
6045 sec = (int) seconds;
6046 usec = (int) ((seconds - sec) * 1000000);
6048 else if (EQ (timeout, Qt))
6050 sec = 0;
6051 usec = 0;
6053 else
6054 wrong_type_argument (Qnumberp, timeout);
6056 if (sec == 0 && usec == 0 && !EQ (timeout, Qt))
6057 return Qt;
6059 #ifdef SIGIO
6060 gobble_input (0);
6061 #endif
6063 wait_reading_process_output (sec, usec, reading ? -1 : 1, do_display,
6064 Qnil, NULL, 0);
6066 return detect_input_pending () ? Qnil : Qt;
6070 DEFUN ("redisplay", Fredisplay, Sredisplay, 0, 1, 0,
6071 doc: /* Perform redisplay.
6072 Optional arg FORCE, if non-nil, prevents redisplay from being
6073 preempted by arriving input, even if `redisplay-dont-pause' is nil.
6074 If `redisplay-dont-pause' is non-nil (the default), redisplay is never
6075 preempted by arriving input, so FORCE does nothing.
6077 Return t if redisplay was performed, nil if redisplay was preempted
6078 immediately by pending input. */)
6079 (Lisp_Object force)
6081 int count;
6083 swallow_events (1);
6084 if ((detect_input_pending_run_timers (1)
6085 && NILP (force) && !redisplay_dont_pause)
6086 || !NILP (Vexecuting_kbd_macro))
6087 return Qnil;
6089 count = SPECPDL_INDEX ();
6090 if (!NILP (force) && !redisplay_dont_pause)
6091 specbind (Qredisplay_dont_pause, Qt);
6092 redisplay_preserve_echo_area (2);
6093 unbind_to (count, Qnil);
6094 return Qt;
6099 /***********************************************************************
6100 Other Lisp Functions
6101 ***********************************************************************/
6103 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
6104 session's frames, frame names, buffers, buffer-read-only flags, and
6105 buffer-modified-flags. */
6107 static Lisp_Object frame_and_buffer_state;
6110 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p,
6111 Sframe_or_buffer_changed_p, 0, 1, 0,
6112 doc: /* Return non-nil if the frame and buffer state appears to have changed.
6113 VARIABLE is a variable name whose value is either nil or a state vector
6114 that will be updated to contain all frames and buffers,
6115 aside from buffers whose names start with space,
6116 along with the buffers' read-only and modified flags. This allows a fast
6117 check to see whether buffer menus might need to be recomputed.
6118 If this function returns non-nil, it updates the internal vector to reflect
6119 the current state.
6121 If VARIABLE is nil, an internal variable is used. Users should not
6122 pass nil for VARIABLE. */)
6123 (Lisp_Object variable)
6125 Lisp_Object state, tail, frame, buf;
6126 Lisp_Object *vecp, *end;
6127 int n;
6129 if (! NILP (variable))
6131 CHECK_SYMBOL (variable);
6132 state = Fsymbol_value (variable);
6133 if (! VECTORP (state))
6134 goto changed;
6136 else
6137 state = frame_and_buffer_state;
6139 vecp = XVECTOR (state)->contents;
6140 end = vecp + ASIZE (state);
6142 FOR_EACH_FRAME (tail, frame)
6144 if (vecp == end)
6145 goto changed;
6146 if (!EQ (*vecp++, frame))
6147 goto changed;
6148 if (vecp == end)
6149 goto changed;
6150 if (!EQ (*vecp++, XFRAME (frame)->name))
6151 goto changed;
6153 /* Check that the buffer info matches. */
6154 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
6156 buf = XCDR (XCAR (tail));
6157 /* Ignore buffers that aren't included in buffer lists. */
6158 if (SREF (BVAR (XBUFFER (buf), name), 0) == ' ')
6159 continue;
6160 if (vecp == end)
6161 goto changed;
6162 if (!EQ (*vecp++, buf))
6163 goto changed;
6164 if (vecp == end)
6165 goto changed;
6166 if (!EQ (*vecp++, BVAR (XBUFFER (buf), read_only)))
6167 goto changed;
6168 if (vecp == end)
6169 goto changed;
6170 if (!EQ (*vecp++, Fbuffer_modified_p (buf)))
6171 goto changed;
6173 if (vecp == end)
6174 goto changed;
6175 /* Detect deletion of a buffer at the end of the list. */
6176 if (EQ (*vecp, Qlambda))
6177 return Qnil;
6179 /* Come here if we decide the data has changed. */
6180 changed:
6181 /* Count the size we will need.
6182 Start with 1 so there is room for at least one lambda at the end. */
6183 n = 1;
6184 FOR_EACH_FRAME (tail, frame)
6185 n += 2;
6186 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
6187 n += 3;
6188 /* Reallocate the vector if data has grown to need it,
6189 or if it has shrunk a lot. */
6190 if (! VECTORP (state)
6191 || n > ASIZE (state)
6192 || n + 20 < ASIZE (state) / 2)
6193 /* Add 20 extra so we grow it less often. */
6195 state = Fmake_vector (make_number (n + 20), Qlambda);
6196 if (! NILP (variable))
6197 Fset (variable, state);
6198 else
6199 frame_and_buffer_state = state;
6202 /* Record the new data in the (possibly reallocated) vector. */
6203 vecp = XVECTOR (state)->contents;
6204 FOR_EACH_FRAME (tail, frame)
6206 *vecp++ = frame;
6207 *vecp++ = XFRAME (frame)->name;
6209 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
6211 buf = XCDR (XCAR (tail));
6212 /* Ignore buffers that aren't included in buffer lists. */
6213 if (SREF (BVAR (XBUFFER (buf), name), 0) == ' ')
6214 continue;
6215 *vecp++ = buf;
6216 *vecp++ = BVAR (XBUFFER (buf), read_only);
6217 *vecp++ = Fbuffer_modified_p (buf);
6219 /* Fill up the vector with lambdas (always at least one). */
6220 *vecp++ = Qlambda;
6221 while (vecp - XVECTOR (state)->contents
6222 < ASIZE (state))
6223 *vecp++ = Qlambda;
6224 /* Make sure we didn't overflow the vector. */
6225 if (vecp - XVECTOR (state)->contents
6226 > ASIZE (state))
6227 abort ();
6228 return Qt;
6233 /***********************************************************************
6234 Initialization
6235 ***********************************************************************/
6237 /* Initialization done when Emacs fork is started, before doing stty.
6238 Determine terminal type and set terminal_driver. Then invoke its
6239 decoding routine to set up variables in the terminal package. */
6241 void
6242 init_display (void)
6244 char *terminal_type;
6246 /* Construct the space glyph. */
6247 space_glyph.type = CHAR_GLYPH;
6248 SET_CHAR_GLYPH (space_glyph, ' ', DEFAULT_FACE_ID, 0);
6249 space_glyph.charpos = -1;
6251 inverse_video = 0;
6252 cursor_in_echo_area = 0;
6253 terminal_type = (char *) 0;
6255 /* Now is the time to initialize this; it's used by init_sys_modes
6256 during startup. */
6257 Vinitial_window_system = Qnil;
6259 /* SIGWINCH needs to be handled no matter what display we start
6260 with. Otherwise newly opened tty frames will not resize
6261 automatically. */
6262 #ifdef SIGWINCH
6263 #ifndef CANNOT_DUMP
6264 if (initialized)
6265 #endif /* CANNOT_DUMP */
6266 signal (SIGWINCH, window_change_signal);
6267 #endif /* SIGWINCH */
6269 /* If running as a daemon, no need to initialize any frames/terminal. */
6270 if (IS_DAEMON)
6271 return;
6273 /* If the user wants to use a window system, we shouldn't bother
6274 initializing the terminal. This is especially important when the
6275 terminal is so dumb that emacs gives up before and doesn't bother
6276 using the window system.
6278 If the DISPLAY environment variable is set and nonempty,
6279 try to use X, and die with an error message if that doesn't work. */
6281 #ifdef HAVE_X_WINDOWS
6282 if (! inhibit_window_system && ! display_arg)
6284 char *display;
6285 display = getenv ("DISPLAY");
6286 display_arg = (display != 0 && *display != 0);
6288 if (display_arg && !x_display_ok (display))
6290 fprintf (stderr, "Display %s unavailable, simulating -nw\n",
6291 display);
6292 inhibit_window_system = 1;
6296 if (!inhibit_window_system && display_arg)
6298 Vinitial_window_system = Qx;
6299 #ifdef HAVE_X11
6300 Vwindow_system_version = make_number (11);
6301 #endif
6302 #if defined (GNU_LINUX) && defined (HAVE_LIBNCURSES)
6303 /* In some versions of ncurses,
6304 tputs crashes if we have not called tgetent.
6305 So call tgetent. */
6306 { char b[2044]; tgetent (b, "xterm");}
6307 #endif
6308 adjust_frame_glyphs_initially ();
6309 return;
6311 #endif /* HAVE_X_WINDOWS */
6313 #ifdef HAVE_NTGUI
6314 if (!inhibit_window_system)
6316 Vinitial_window_system = Qw32;
6317 Vwindow_system_version = make_number (1);
6318 adjust_frame_glyphs_initially ();
6319 return;
6321 #endif /* HAVE_NTGUI */
6323 #ifdef HAVE_NS
6324 if (!inhibit_window_system
6325 #ifndef CANNOT_DUMP
6326 && initialized
6327 #endif
6330 Vinitial_window_system = Qns;
6331 Vwindow_system_version = make_number (10);
6332 adjust_frame_glyphs_initially ();
6333 return;
6335 #endif
6337 /* If no window system has been specified, try to use the terminal. */
6338 if (! isatty (0))
6340 fatal ("standard input is not a tty");
6341 exit (1);
6344 #ifdef WINDOWSNT
6345 terminal_type = "w32console";
6346 #else
6347 /* Look at the TERM variable. */
6348 terminal_type = (char *) getenv ("TERM");
6349 #endif
6350 if (!terminal_type)
6352 #ifdef HAVE_WINDOW_SYSTEM
6353 if (! inhibit_window_system)
6354 fprintf (stderr, "Please set the environment variable DISPLAY or TERM (see `tset').\n");
6355 else
6356 #endif /* HAVE_WINDOW_SYSTEM */
6357 fprintf (stderr, "Please set the environment variable TERM; see `tset'.\n");
6358 exit (1);
6362 struct terminal *t;
6363 struct frame *f = XFRAME (selected_frame);
6365 /* Open a display on the controlling tty. */
6366 t = init_tty (0, terminal_type, 1); /* Errors are fatal. */
6368 /* Convert the initial frame to use the new display. */
6369 if (f->output_method != output_initial)
6370 abort ();
6371 f->output_method = t->type;
6372 f->terminal = t;
6374 t->reference_count++;
6375 #ifdef MSDOS
6376 f->output_data.tty->display_info = &the_only_display_info;
6377 #else
6378 if (f->output_method == output_termcap)
6379 create_tty_output (f);
6380 #endif
6381 t->display_info.tty->top_frame = selected_frame;
6382 change_frame_size (XFRAME (selected_frame),
6383 FrameRows (t->display_info.tty),
6384 FrameCols (t->display_info.tty), 0, 0, 1);
6386 /* Delete the initial terminal. */
6387 if (--initial_terminal->reference_count == 0
6388 && initial_terminal->delete_terminal_hook)
6389 (*initial_terminal->delete_terminal_hook) (initial_terminal);
6391 /* Update frame parameters to reflect the new type. */
6392 Fmodify_frame_parameters
6393 (selected_frame, Fcons (Fcons (Qtty_type,
6394 Ftty_type (selected_frame)), Qnil));
6395 if (t->display_info.tty->name)
6396 Fmodify_frame_parameters (selected_frame,
6397 Fcons (Fcons (Qtty, build_string (t->display_info.tty->name)),
6398 Qnil));
6399 else
6400 Fmodify_frame_parameters (selected_frame, Fcons (Fcons (Qtty, Qnil),
6401 Qnil));
6405 struct frame *sf = SELECTED_FRAME ();
6406 int width = FRAME_TOTAL_COLS (sf);
6407 int height = FRAME_LINES (sf);
6409 /* If these sizes are so big they cause overflow, just ignore the
6410 change. It's not clear what better we could do. The rest of
6411 the code assumes that (width + 2) * height * sizeof (struct glyph)
6412 does not overflow and does not exceed PTRDIFF_MAX or SIZE_MAX. */
6413 if (INT_ADD_RANGE_OVERFLOW (width, 2, INT_MIN, INT_MAX)
6414 || INT_MULTIPLY_RANGE_OVERFLOW (width + 2, height, INT_MIN, INT_MAX)
6415 || (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (struct glyph)
6416 < (width + 2) * height))
6417 fatal ("screen size %dx%d too big", width, height);
6420 adjust_frame_glyphs_initially ();
6421 calculate_costs (XFRAME (selected_frame));
6423 /* Set up faces of the initial terminal frame of a dumped Emacs. */
6424 if (initialized
6425 && !noninteractive
6426 && NILP (Vinitial_window_system))
6428 /* For the initial frame, we don't have any way of knowing what
6429 are the foreground and background colors of the terminal. */
6430 struct frame *sf = SELECTED_FRAME ();
6432 FRAME_FOREGROUND_PIXEL (sf) = FACE_TTY_DEFAULT_FG_COLOR;
6433 FRAME_BACKGROUND_PIXEL (sf) = FACE_TTY_DEFAULT_BG_COLOR;
6434 call0 (intern ("tty-set-up-initial-frame-faces"));
6440 /***********************************************************************
6441 Blinking cursor
6442 ***********************************************************************/
6444 DEFUN ("internal-show-cursor", Finternal_show_cursor,
6445 Sinternal_show_cursor, 2, 2, 0,
6446 doc: /* Set the cursor-visibility flag of WINDOW to SHOW.
6447 WINDOW nil means use the selected window. SHOW non-nil means
6448 show a cursor in WINDOW in the next redisplay. SHOW nil means
6449 don't show a cursor. */)
6450 (Lisp_Object window, Lisp_Object show)
6452 /* Don't change cursor state while redisplaying. This could confuse
6453 output routines. */
6454 if (!redisplaying_p)
6456 if (NILP (window))
6457 window = selected_window;
6458 else
6459 CHECK_WINDOW (window);
6461 XWINDOW (window)->cursor_off_p = NILP (show);
6464 return Qnil;
6468 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p,
6469 Sinternal_show_cursor_p, 0, 1, 0,
6470 doc: /* Value is non-nil if next redisplay will display a cursor in WINDOW.
6471 WINDOW nil or omitted means report on the selected window. */)
6472 (Lisp_Object window)
6474 struct window *w;
6476 if (NILP (window))
6477 window = selected_window;
6478 else
6479 CHECK_WINDOW (window);
6481 w = XWINDOW (window);
6482 return w->cursor_off_p ? Qnil : Qt;
6485 DEFUN ("last-nonminibuffer-frame", Flast_nonminibuf_frame,
6486 Slast_nonminibuf_frame, 0, 0, 0,
6487 doc: /* Value is last nonminibuffer frame. */)
6488 (void)
6490 Lisp_Object frame = Qnil;
6492 if (last_nonminibuf_frame)
6493 XSETFRAME (frame, last_nonminibuf_frame);
6495 return frame;
6498 /***********************************************************************
6499 Initialization
6500 ***********************************************************************/
6502 void
6503 syms_of_display (void)
6505 defsubr (&Sredraw_frame);
6506 defsubr (&Sredraw_display);
6507 defsubr (&Sframe_or_buffer_changed_p);
6508 defsubr (&Sopen_termscript);
6509 defsubr (&Sding);
6510 defsubr (&Sredisplay);
6511 defsubr (&Ssleep_for);
6512 defsubr (&Ssend_string_to_terminal);
6513 defsubr (&Sinternal_show_cursor);
6514 defsubr (&Sinternal_show_cursor_p);
6515 defsubr (&Slast_nonminibuf_frame);
6517 #if GLYPH_DEBUG
6518 defsubr (&Sdump_redisplay_history);
6519 #endif
6521 frame_and_buffer_state = Fmake_vector (make_number (20), Qlambda);
6522 staticpro (&frame_and_buffer_state);
6524 DEFSYM (Qdisplay_table, "display-table");
6525 DEFSYM (Qredisplay_dont_pause, "redisplay-dont-pause");
6527 DEFVAR_INT ("baud-rate", baud_rate,
6528 doc: /* The output baud rate of the terminal.
6529 On most systems, changing this value will affect the amount of padding
6530 and the other strategic decisions made during redisplay. */);
6532 DEFVAR_BOOL ("inverse-video", inverse_video,
6533 doc: /* Non-nil means invert the entire frame display.
6534 This means everything is in inverse video which otherwise would not be. */);
6536 DEFVAR_BOOL ("visible-bell", visible_bell,
6537 doc: /* Non-nil means try to flash the frame to represent a bell.
6539 See also `ring-bell-function'. */);
6541 DEFVAR_BOOL ("no-redraw-on-reenter", no_redraw_on_reenter,
6542 doc: /* Non-nil means no need to redraw entire frame after suspending.
6543 A non-nil value is useful if the terminal can automatically preserve
6544 Emacs's frame display when you reenter Emacs.
6545 It is up to you to set this variable if your terminal can do that. */);
6547 DEFVAR_LISP ("initial-window-system", Vinitial_window_system,
6548 doc: /* Name of the window system that Emacs uses for the first frame.
6549 The value is a symbol:
6550 nil for a termcap frame (a character-only terminal),
6551 'x' for an Emacs frame that is really an X window,
6552 'w32' for an Emacs frame that is a window on MS-Windows display,
6553 'ns' for an Emacs frame on a GNUstep or Macintosh Cocoa display,
6554 'pc' for a direct-write MS-DOS frame.
6556 Use of this variable as a boolean is deprecated. Instead,
6557 use `display-graphic-p' or any of the other `display-*-p'
6558 predicates which report frame's specific UI-related capabilities. */);
6560 DEFVAR_KBOARD ("window-system", Vwindow_system,
6561 doc: /* Name of window system through which the selected frame is displayed.
6562 The value is a symbol:
6563 nil for a termcap frame (a character-only terminal),
6564 'x' for an Emacs frame that is really an X window,
6565 'w32' for an Emacs frame that is a window on MS-Windows display,
6566 'ns' for an Emacs frame on a GNUstep or Macintosh Cocoa display,
6567 'pc' for a direct-write MS-DOS frame.
6569 Use of this variable as a boolean is deprecated. Instead,
6570 use `display-graphic-p' or any of the other `display-*-p'
6571 predicates which report frame's specific UI-related capabilities. */);
6573 DEFVAR_LISP ("window-system-version", Vwindow_system_version,
6574 doc: /* The version number of the window system in use.
6575 For X windows, this is 11. */);
6577 DEFVAR_BOOL ("cursor-in-echo-area", cursor_in_echo_area,
6578 doc: /* Non-nil means put cursor in minibuffer, at end of any message there. */);
6580 DEFVAR_LISP ("glyph-table", Vglyph_table,
6581 doc: /* Table defining how to output a glyph code to the frame.
6582 If not nil, this is a vector indexed by glyph code to define the glyph.
6583 Each element can be:
6584 integer: a glyph code which this glyph is an alias for.
6585 string: output this glyph using that string (not impl. in X windows).
6586 nil: this glyph mod 524288 is the code of a character to output,
6587 and this glyph / 524288 is the face number (see `face-id') to use
6588 while outputting it. */);
6589 Vglyph_table = Qnil;
6591 DEFVAR_LISP ("standard-display-table", Vstandard_display_table,
6592 doc: /* Display table to use for buffers that specify none.
6593 See `buffer-display-table' for more information. */);
6594 Vstandard_display_table = Qnil;
6596 DEFVAR_BOOL ("redisplay-dont-pause", redisplay_dont_pause,
6597 doc: /* Non-nil means display update isn't paused when input is detected. */);
6598 redisplay_dont_pause = 1;
6600 #if PERIODIC_PREEMPTION_CHECKING
6601 DEFVAR_LISP ("redisplay-preemption-period", Vredisplay_preemption_period,
6602 doc: /* Period in seconds between checking for input during redisplay.
6603 This has an effect only if `redisplay-dont-pause' is nil; in that
6604 case, arriving input preempts redisplay until the input is processed.
6605 If the value is nil, redisplay is never preempted. */);
6606 Vredisplay_preemption_period = make_float (0.10);
6607 #endif
6609 #ifdef CANNOT_DUMP
6610 if (noninteractive)
6611 #endif
6613 Vinitial_window_system = Qnil;
6614 Vwindow_system_version = Qnil;