1 /* Updating of data structures for redisplay.
3 Copyright (C) 1985-1988, 1993-1995, 1997-2012 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
30 /* cm.h must come after dispextern.h on Windows. */
31 #include "dispextern.h"
34 #include "character.h"
37 #include "termhooks.h"
42 #include "intervals.h"
43 #include "blockinput.h"
46 #include "syssignal.h"
50 #endif /* HAVE_X_WINDOWS */
54 #endif /* HAVE_NTGUI */
60 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
65 /* Get number of chars of output now in the buffer of a stdio stream.
66 This ought to be built in stdio, but it isn't. Some s- files
67 override this because their stdio internals differ. */
69 #ifdef __GNU_LIBRARY__
71 /* The s- file might have overridden the definition with one that
72 works for the system's C library. But we are using the GNU C
73 library, so this is the right definition for every system. */
75 #ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT
76 #define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT
78 #undef PENDING_OUTPUT_COUNT
79 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
81 #else /* not __GNU_LIBRARY__ */
82 #if !defined (PENDING_OUTPUT_COUNT) && HAVE_STDIO_EXT_H && HAVE___FPENDING
83 #include <stdio_ext.h>
84 #define PENDING_OUTPUT_COUNT(FILE) __fpending (FILE)
86 #ifndef PENDING_OUTPUT_COUNT
87 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
89 #endif /* not __GNU_LIBRARY__ */
91 #if defined (HAVE_TERM_H) && defined (GNU_LINUX)
92 #include <term.h> /* for tgetent */
95 /* Structure to pass dimensions around. Used for character bounding
96 boxes, glyph matrix dimensions and alike. */
105 /* Function prototypes. */
107 static void update_frame_line (struct frame
*, int);
108 static int required_matrix_height (struct window
*);
109 static int required_matrix_width (struct window
*);
110 static void adjust_frame_glyphs (struct frame
*);
111 static void change_frame_size_1 (struct frame
*, int, int, int, int, int);
112 static void increment_row_positions (struct glyph_row
*, ptrdiff_t, ptrdiff_t);
113 static void fill_up_frame_row_with_spaces (struct glyph_row
*, int);
114 static void build_frame_matrix_from_window_tree (struct glyph_matrix
*,
116 static void build_frame_matrix_from_leaf_window (struct glyph_matrix
*,
118 static void adjust_frame_message_buffer (struct frame
*);
119 static void adjust_decode_mode_spec_buffer (struct frame
*);
120 static void fill_up_glyph_row_with_spaces (struct glyph_row
*);
121 static void clear_window_matrices (struct window
*, int);
122 static void fill_up_glyph_row_area_with_spaces (struct glyph_row
*, int);
123 static int scrolling_window (struct window
*, int);
124 static int update_window_line (struct window
*, int, int *);
125 static void mirror_make_current (struct window
*, int);
127 static void check_matrix_pointers (struct glyph_matrix
*,
128 struct glyph_matrix
*);
130 static void mirror_line_dance (struct window
*, int, int, int *, char *);
131 static int update_window_tree (struct window
*, int);
132 static int update_window (struct window
*, int);
133 static int update_frame_1 (struct frame
*, int, int);
134 static int scrolling (struct frame
*);
135 static void set_window_cursor_after_update (struct window
*);
136 static void adjust_frame_glyphs_for_window_redisplay (struct frame
*);
137 static void adjust_frame_glyphs_for_frame_redisplay (struct frame
*);
140 /* Define PERIODIC_PREEMPTION_CHECKING to 1, if micro-second timers
141 are supported, so we can check for input during redisplay at
142 regular intervals. */
143 #ifdef EMACS_HAS_USECS
144 #define PERIODIC_PREEMPTION_CHECKING 1
146 #define PERIODIC_PREEMPTION_CHECKING 0
149 #if PERIODIC_PREEMPTION_CHECKING
151 /* Redisplay preemption timers. */
153 static EMACS_TIME preemption_period
;
154 static EMACS_TIME preemption_next_check
;
158 /* Nonzero upon entry to redisplay means do not assume anything about
159 current contents of actual terminal frame; clear and redraw it. */
163 /* Nonzero means last display completed. Zero means it was preempted. */
165 int display_completed
;
167 Lisp_Object Qdisplay_table
, Qredisplay_dont_pause
;
170 /* The currently selected frame. In a single-frame version, this
171 variable always equals the_only_frame. */
173 Lisp_Object selected_frame
;
175 /* A frame which is not just a mini-buffer, or 0 if there are no such
176 frames. This is usually the most recent such frame that was
177 selected. In a single-frame version, this variable always holds
178 the address of the_only_frame. */
180 struct frame
*last_nonminibuf_frame
;
182 /* 1 means SIGWINCH happened when not safe. */
184 static int delayed_size_change
;
186 /* 1 means glyph initialization has been completed at startup. */
188 static int glyphs_initialized_initially_p
;
190 /* Updated window if != 0. Set by update_window. */
192 struct window
*updated_window
;
194 /* Glyph row updated in update_window_line, and area that is updated. */
196 struct glyph_row
*updated_row
;
199 /* A glyph for a space. */
201 struct glyph space_glyph
;
203 /* Counts of allocated structures. These counts serve to diagnose
204 memory leaks and double frees. */
206 static int glyph_matrix_count
;
207 static int glyph_pool_count
;
209 /* If non-null, the frame whose frame matrices are manipulated. If
210 null, window matrices are worked on. */
212 static struct frame
*frame_matrix_frame
;
214 /* Non-zero means that fonts have been loaded since the last glyph
215 matrix adjustments. Redisplay must stop, and glyph matrices must
216 be adjusted when this flag becomes non-zero during display. The
217 reason fonts can be loaded so late is that fonts of fontsets are
218 loaded on demand. Another reason is that a line contains many
219 characters displayed by zero width or very narrow glyphs of
220 variable-width fonts. */
224 /* Convert vpos and hpos from frame to window and vice versa.
225 This may only be used for terminal frames. */
229 static int window_to_frame_vpos (struct window
*, int);
230 static int window_to_frame_hpos (struct window
*, int);
231 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
232 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
234 /* One element of the ring buffer containing redisplay history
237 struct redisplay_history
239 char trace
[512 + 100];
242 /* The size of the history buffer. */
244 #define REDISPLAY_HISTORY_SIZE 30
246 /* The redisplay history buffer. */
248 static struct redisplay_history redisplay_history
[REDISPLAY_HISTORY_SIZE
];
250 /* Next free entry in redisplay_history. */
252 static int history_idx
;
254 /* A tick that's incremented each time something is added to the
257 static uprintmax_t history_tick
;
259 static void add_frame_display_history (struct frame
*, int);
261 /* Add to the redisplay history how window W has been displayed.
262 MSG is a trace containing the information how W's glyph matrix
263 has been constructed. PAUSED_P non-zero means that the update
264 has been interrupted for pending input. */
267 add_window_display_history (struct window
*w
, const char *msg
, int paused_p
)
271 if (history_idx
>= REDISPLAY_HISTORY_SIZE
)
273 buf
= redisplay_history
[history_idx
].trace
;
276 snprintf (buf
, sizeof redisplay_history
[0].trace
,
277 "%"pMu
": window %p (`%s')%s\n%s",
280 ((BUFFERP (w
->buffer
)
281 && STRINGP (BVAR (XBUFFER (w
->buffer
), name
)))
282 ? SSDATA (BVAR (XBUFFER (w
->buffer
), name
))
284 paused_p
? " ***paused***" : "",
289 /* Add to the redisplay history that frame F has been displayed.
290 PAUSED_P non-zero means that the update has been interrupted for
294 add_frame_display_history (struct frame
*f
, int paused_p
)
298 if (history_idx
>= REDISPLAY_HISTORY_SIZE
)
300 buf
= redisplay_history
[history_idx
].trace
;
303 sprintf (buf
, "%"pMu
": update frame %p%s",
305 f
, paused_p
? " ***paused***" : "");
309 DEFUN ("dump-redisplay-history", Fdump_redisplay_history
,
310 Sdump_redisplay_history
, 0, 0, "",
311 doc
: /* Dump redisplay history to stderr. */)
316 for (i
= history_idx
- 1; i
!= history_idx
; --i
)
319 i
= REDISPLAY_HISTORY_SIZE
- 1;
320 fprintf (stderr
, "%s\n", redisplay_history
[i
].trace
);
327 #else /* GLYPH_DEBUG == 0 */
329 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + WINDOW_TOP_EDGE_LINE (W))
330 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + WINDOW_LEFT_EDGE_COL (W))
332 #endif /* GLYPH_DEBUG == 0 */
335 #if defined PROFILING && !HAVE___EXECUTABLE_START
336 /* FIXME: only used to find text start for profiling. */
339 safe_bcopy (const char *from
, char *to
, int size
)
345 /***********************************************************************
347 ***********************************************************************/
349 /* Allocate and return a glyph_matrix structure. POOL is the glyph
350 pool from which memory for the matrix should be allocated, or null
351 for window-based redisplay where no glyph pools are used. The
352 member `pool' of the glyph matrix structure returned is set to
353 POOL, the structure is otherwise zeroed. */
355 static struct glyph_matrix
*
356 new_glyph_matrix (struct glyph_pool
*pool
)
358 struct glyph_matrix
*result
;
360 /* Allocate and clear. */
361 result
= (struct glyph_matrix
*) xmalloc (sizeof *result
);
362 memset (result
, 0, sizeof *result
);
364 /* Increment number of allocated matrices. This count is used
365 to detect memory leaks. */
366 ++glyph_matrix_count
;
368 /* Set pool and return. */
374 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
376 The global counter glyph_matrix_count is decremented when a matrix
377 is freed. If the count gets negative, more structures were freed
378 than allocated, i.e. one matrix was freed more than once or a bogus
379 pointer was passed to this function.
381 If MATRIX->pool is null, this means that the matrix manages its own
382 glyph memory---this is done for matrices on X frames. Freeing the
383 matrix also frees the glyph memory in this case. */
386 free_glyph_matrix (struct glyph_matrix
*matrix
)
392 /* Detect the case that more matrices are freed than were
394 if (--glyph_matrix_count
< 0)
397 /* Free glyph memory if MATRIX owns it. */
398 if (matrix
->pool
== NULL
)
399 for (i
= 0; i
< matrix
->rows_allocated
; ++i
)
400 xfree (matrix
->rows
[i
].glyphs
[LEFT_MARGIN_AREA
]);
402 /* Free row structures and the matrix itself. */
403 xfree (matrix
->rows
);
409 /* Return the number of glyphs to reserve for a marginal area of
410 window W. TOTAL_GLYPHS is the number of glyphs in a complete
411 display line of window W. MARGIN gives the width of the marginal
412 area in canonical character units. MARGIN should be an integer
416 margin_glyphs_to_reserve (struct window
*w
, int total_glyphs
, Lisp_Object margin
)
420 if (NUMBERP (margin
))
422 int width
= XFASTINT (w
->total_cols
);
423 double d
= max (0, XFLOATINT (margin
));
424 d
= min (width
/ 2 - 1, d
);
425 n
= (int) ((double) total_glyphs
/ width
* d
);
434 /* Return non-zero if ROW's hash value is correct, zero if not. */
436 verify_row_hash (struct glyph_row
*row
)
438 return row
->hash
== row_hash (row
);
442 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
445 W is null if the function is called for a frame glyph matrix.
446 Otherwise it is the window MATRIX is a member of. X and Y are the
447 indices of the first column and row of MATRIX within the frame
448 matrix, if such a matrix exists. They are zero for purely
449 window-based redisplay. DIM is the needed size of the matrix.
451 In window-based redisplay, where no frame matrices exist, glyph
452 matrices manage their own glyph storage. Otherwise, they allocate
453 storage from a common frame glyph pool which can be found in
456 The reason for this memory management strategy is to avoid complete
457 frame redraws if possible. When we allocate from a common pool, a
458 change of the location or size of a sub-matrix within the pool
459 requires a complete redisplay of the frame because we cannot easily
460 make sure that the current matrices of all windows still agree with
461 what is displayed on the screen. While this is usually fast, it
462 leads to screen flickering. */
465 adjust_glyph_matrix (struct window
*w
, struct glyph_matrix
*matrix
, int x
, int y
, struct dim dim
)
469 int marginal_areas_changed_p
= 0;
470 int header_line_changed_p
= 0;
471 int header_line_p
= 0;
472 int left
= -1, right
= -1;
473 int window_width
= -1, window_height
= -1;
475 /* See if W had a header line that has disappeared now, or vice versa.
479 window_box (w
, -1, 0, 0, &window_width
, &window_height
);
481 header_line_p
= WINDOW_WANTS_HEADER_LINE_P (w
);
482 header_line_changed_p
= header_line_p
!= matrix
->header_line_p
;
484 matrix
->header_line_p
= header_line_p
;
486 /* If POOL is null, MATRIX is a window matrix for window-based redisplay.
487 Do nothing if MATRIX' size, position, vscroll, and marginal areas
488 haven't changed. This optimization is important because preserving
489 the matrix means preventing redisplay. */
490 if (matrix
->pool
== NULL
)
492 left
= margin_glyphs_to_reserve (w
, dim
.width
, w
->left_margin_cols
);
493 right
= margin_glyphs_to_reserve (w
, dim
.width
, w
->right_margin_cols
);
494 xassert (left
>= 0 && right
>= 0);
495 marginal_areas_changed_p
= (left
!= matrix
->left_margin_glyphs
496 || right
!= matrix
->right_margin_glyphs
);
498 if (!marginal_areas_changed_p
500 && !header_line_changed_p
501 && matrix
->window_left_col
== WINDOW_LEFT_EDGE_COL (w
)
502 && matrix
->window_top_line
== WINDOW_TOP_EDGE_LINE (w
)
503 && matrix
->window_height
== window_height
504 && matrix
->window_vscroll
== w
->vscroll
505 && matrix
->window_width
== window_width
)
509 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
510 if (matrix
->rows_allocated
< dim
.height
)
512 int old_alloc
= matrix
->rows_allocated
;
513 new_rows
= dim
.height
- matrix
->rows_allocated
;
514 matrix
->rows
= xpalloc (matrix
->rows
, &matrix
->rows_allocated
,
515 new_rows
, INT_MAX
, sizeof *matrix
->rows
);
516 memset (matrix
->rows
+ old_alloc
, 0,
517 (matrix
->rows_allocated
- old_alloc
) * sizeof *matrix
->rows
);
522 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
523 on a frame not using window-based redisplay. Set up pointers for
524 each row into the glyph pool. */
527 xassert (matrix
->pool
->glyphs
);
531 left
= margin_glyphs_to_reserve (w
, dim
.width
,
532 w
->left_margin_cols
);
533 right
= margin_glyphs_to_reserve (w
, dim
.width
,
534 w
->right_margin_cols
);
539 for (i
= 0; i
< dim
.height
; ++i
)
541 struct glyph_row
*row
= &matrix
->rows
[i
];
543 row
->glyphs
[LEFT_MARGIN_AREA
]
544 = (matrix
->pool
->glyphs
545 + (y
+ i
) * matrix
->pool
->ncolumns
549 || row
== matrix
->rows
+ dim
.height
- 1
550 || (row
== matrix
->rows
&& matrix
->header_line_p
))
552 row
->glyphs
[TEXT_AREA
]
553 = row
->glyphs
[LEFT_MARGIN_AREA
];
554 row
->glyphs
[RIGHT_MARGIN_AREA
]
555 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
556 row
->glyphs
[LAST_AREA
]
557 = row
->glyphs
[RIGHT_MARGIN_AREA
];
561 row
->glyphs
[TEXT_AREA
]
562 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
563 row
->glyphs
[RIGHT_MARGIN_AREA
]
564 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
565 row
->glyphs
[LAST_AREA
]
566 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
570 matrix
->left_margin_glyphs
= left
;
571 matrix
->right_margin_glyphs
= right
;
575 /* If MATRIX->pool is null, MATRIX is responsible for managing
576 its own memory. It is a window matrix for window-based redisplay.
577 Allocate glyph memory from the heap. */
578 if (dim
.width
> matrix
->matrix_w
580 || header_line_changed_p
581 || marginal_areas_changed_p
)
583 struct glyph_row
*row
= matrix
->rows
;
584 struct glyph_row
*end
= row
+ matrix
->rows_allocated
;
588 row
->glyphs
[LEFT_MARGIN_AREA
]
589 = xnrealloc (row
->glyphs
[LEFT_MARGIN_AREA
],
590 dim
.width
, sizeof (struct glyph
));
592 /* The mode line never has marginal areas. */
593 if (row
== matrix
->rows
+ dim
.height
- 1
594 || (row
== matrix
->rows
&& matrix
->header_line_p
))
596 row
->glyphs
[TEXT_AREA
]
597 = row
->glyphs
[LEFT_MARGIN_AREA
];
598 row
->glyphs
[RIGHT_MARGIN_AREA
]
599 = row
->glyphs
[TEXT_AREA
] + dim
.width
;
600 row
->glyphs
[LAST_AREA
]
601 = row
->glyphs
[RIGHT_MARGIN_AREA
];
605 row
->glyphs
[TEXT_AREA
]
606 = row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
607 row
->glyphs
[RIGHT_MARGIN_AREA
]
608 = row
->glyphs
[TEXT_AREA
] + dim
.width
- left
- right
;
609 row
->glyphs
[LAST_AREA
]
610 = row
->glyphs
[LEFT_MARGIN_AREA
] + dim
.width
;
616 xassert (left
>= 0 && right
>= 0);
617 matrix
->left_margin_glyphs
= left
;
618 matrix
->right_margin_glyphs
= right
;
621 /* Number of rows to be used by MATRIX. */
622 matrix
->nrows
= dim
.height
;
623 xassert (matrix
->nrows
>= 0);
627 if (matrix
== w
->current_matrix
)
629 /* Mark rows in a current matrix of a window as not having
630 valid contents. It's important to not do this for
631 desired matrices. When Emacs starts, it may already be
632 building desired matrices when this function runs. */
633 if (window_width
< 0)
634 window_width
= window_box_width (w
, -1);
636 /* Optimize the case that only the height has changed (C-x 2,
637 upper window). Invalidate all rows that are no longer part
639 if (!marginal_areas_changed_p
640 && !header_line_changed_p
642 && dim
.width
== matrix
->matrix_w
643 && matrix
->window_left_col
== WINDOW_LEFT_EDGE_COL (w
)
644 && matrix
->window_top_line
== WINDOW_TOP_EDGE_LINE (w
)
645 && matrix
->window_width
== window_width
)
647 /* Find the last row in the window. */
648 for (i
= 0; i
< matrix
->nrows
&& matrix
->rows
[i
].enabled_p
; ++i
)
649 if (MATRIX_ROW_BOTTOM_Y (matrix
->rows
+ i
) >= window_height
)
655 /* Window end is invalid, if inside of the rows that
656 are invalidated below. */
657 if (INTEGERP (w
->window_end_vpos
)
658 && XFASTINT (w
->window_end_vpos
) >= i
)
659 w
->window_end_valid
= Qnil
;
661 while (i
< matrix
->nrows
)
662 matrix
->rows
[i
++].enabled_p
= 0;
666 for (i
= 0; i
< matrix
->nrows
; ++i
)
667 matrix
->rows
[i
].enabled_p
= 0;
670 else if (matrix
== w
->desired_matrix
)
672 /* Rows in desired matrices always have to be cleared;
673 redisplay expects this is the case when it runs, so it
674 had better be the case when we adjust matrices between
676 for (i
= 0; i
< matrix
->nrows
; ++i
)
677 matrix
->rows
[i
].enabled_p
= 0;
682 /* Remember last values to be able to optimize frame redraws. */
683 matrix
->matrix_x
= x
;
684 matrix
->matrix_y
= y
;
685 matrix
->matrix_w
= dim
.width
;
686 matrix
->matrix_h
= dim
.height
;
688 /* Record the top y location and height of W at the time the matrix
689 was last adjusted. This is used to optimize redisplay above. */
692 matrix
->window_left_col
= WINDOW_LEFT_EDGE_COL (w
);
693 matrix
->window_top_line
= WINDOW_TOP_EDGE_LINE (w
);
694 matrix
->window_height
= window_height
;
695 matrix
->window_width
= window_width
;
696 matrix
->window_vscroll
= w
->vscroll
;
701 /* Reverse the contents of rows in MATRIX between START and END. The
702 contents of the row at END - 1 end up at START, END - 2 at START +
703 1 etc. This is part of the implementation of rotate_matrix (see
707 reverse_rows (struct glyph_matrix
*matrix
, int start
, int end
)
711 for (i
= start
, j
= end
- 1; i
< j
; ++i
, --j
)
713 /* Non-ISO HP/UX compiler doesn't like auto struct
715 struct glyph_row temp
;
716 temp
= matrix
->rows
[i
];
717 matrix
->rows
[i
] = matrix
->rows
[j
];
718 matrix
->rows
[j
] = temp
;
723 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
724 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
725 indices. (Note: this does not copy glyphs, only glyph pointers in
726 row structures are moved around).
728 The algorithm used for rotating the vector was, I believe, first
729 described by Kernighan. See the vector R as consisting of two
730 sub-vectors AB, where A has length BY for BY >= 0. The result
731 after rotating is then BA. Reverse both sub-vectors to get ArBr
732 and reverse the result to get (ArBr)r which is BA. Similar for
736 rotate_matrix (struct glyph_matrix
*matrix
, int first
, int last
, int by
)
740 /* Up (rotate left, i.e. towards lower indices). */
742 reverse_rows (matrix
, first
, first
+ by
);
743 reverse_rows (matrix
, first
+ by
, last
);
744 reverse_rows (matrix
, first
, last
);
748 /* Down (rotate right, i.e. towards higher indices). */
749 reverse_rows (matrix
, last
- by
, last
);
750 reverse_rows (matrix
, first
, last
- by
);
751 reverse_rows (matrix
, first
, last
);
756 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
757 with indices START <= index < END. Increment positions by DELTA/
761 increment_matrix_positions (struct glyph_matrix
*matrix
, int start
, int end
,
762 ptrdiff_t delta
, ptrdiff_t delta_bytes
)
764 /* Check that START and END are reasonable values. */
765 xassert (start
>= 0 && start
<= matrix
->nrows
);
766 xassert (end
>= 0 && end
<= matrix
->nrows
);
767 xassert (start
<= end
);
769 for (; start
< end
; ++start
)
770 increment_row_positions (matrix
->rows
+ start
, delta
, delta_bytes
);
774 /* Enable a range of rows in glyph matrix MATRIX. START and END are
775 the row indices of the first and last + 1 row to enable. If
776 ENABLED_P is non-zero, enabled_p flags in rows will be set to 1. */
779 enable_glyph_matrix_rows (struct glyph_matrix
*matrix
, int start
, int end
, int enabled_p
)
781 xassert (start
<= end
);
782 xassert (start
>= 0 && start
< matrix
->nrows
);
783 xassert (end
>= 0 && end
<= matrix
->nrows
);
785 for (; start
< end
; ++start
)
786 matrix
->rows
[start
].enabled_p
= enabled_p
!= 0;
792 This empties all rows in MATRIX by setting the enabled_p flag for
793 all rows of the matrix to zero. The function prepare_desired_row
794 will eventually really clear a row when it sees one with a zero
797 Resets update hints to defaults value. The only update hint
798 currently present is the flag MATRIX->no_scrolling_p. */
801 clear_glyph_matrix (struct glyph_matrix
*matrix
)
805 enable_glyph_matrix_rows (matrix
, 0, matrix
->nrows
, 0);
806 matrix
->no_scrolling_p
= 0;
811 /* Shift part of the glyph matrix MATRIX of window W up or down.
812 Increment y-positions in glyph rows between START and END by DY,
813 and recompute their visible height. */
816 shift_glyph_matrix (struct window
*w
, struct glyph_matrix
*matrix
, int start
, int end
, int dy
)
820 xassert (start
<= end
);
821 xassert (start
>= 0 && start
< matrix
->nrows
);
822 xassert (end
>= 0 && end
<= matrix
->nrows
);
824 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
825 max_y
= WINDOW_BOX_HEIGHT_NO_MODE_LINE (w
);
827 for (; start
< end
; ++start
)
829 struct glyph_row
*row
= &matrix
->rows
[start
];
832 row
->visible_height
= row
->height
;
835 row
->visible_height
-= min_y
- row
->y
;
836 if (row
->y
+ row
->height
> max_y
)
837 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
838 if (row
->fringe_bitmap_periodic_p
)
839 row
->redraw_fringe_bitmaps_p
= 1;
844 /* Mark all rows in current matrices of frame F as invalid. Marking
845 invalid is done by setting enabled_p to zero for all rows in a
849 clear_current_matrices (register struct frame
*f
)
851 /* Clear frame current matrix, if we have one. */
852 if (f
->current_matrix
)
853 clear_glyph_matrix (f
->current_matrix
);
855 /* Clear the matrix of the menu bar window, if such a window exists.
856 The menu bar window is currently used to display menus on X when
857 no toolkit support is compiled in. */
858 if (WINDOWP (f
->menu_bar_window
))
859 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->current_matrix
);
861 /* Clear the matrix of the tool-bar window, if any. */
862 if (WINDOWP (f
->tool_bar_window
))
863 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
865 /* Clear current window matrices. */
866 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
867 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 0);
871 /* Clear out all display lines of F for a coming redisplay. */
874 clear_desired_matrices (register struct frame
*f
)
876 if (f
->desired_matrix
)
877 clear_glyph_matrix (f
->desired_matrix
);
879 if (WINDOWP (f
->menu_bar_window
))
880 clear_glyph_matrix (XWINDOW (f
->menu_bar_window
)->desired_matrix
);
882 if (WINDOWP (f
->tool_bar_window
))
883 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->desired_matrix
);
885 /* Do it for window matrices. */
886 xassert (WINDOWP (FRAME_ROOT_WINDOW (f
)));
887 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
891 /* Clear matrices in window tree rooted in W. If DESIRED_P is
892 non-zero clear desired matrices, otherwise clear current matrices. */
895 clear_window_matrices (struct window
*w
, int desired_p
)
899 if (!NILP (w
->hchild
))
901 xassert (WINDOWP (w
->hchild
));
902 clear_window_matrices (XWINDOW (w
->hchild
), desired_p
);
904 else if (!NILP (w
->vchild
))
906 xassert (WINDOWP (w
->vchild
));
907 clear_window_matrices (XWINDOW (w
->vchild
), desired_p
);
912 clear_glyph_matrix (w
->desired_matrix
);
915 clear_glyph_matrix (w
->current_matrix
);
916 w
->window_end_valid
= Qnil
;
920 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
926 /***********************************************************************
929 See dispextern.h for an overall explanation of glyph rows.
930 ***********************************************************************/
932 /* Clear glyph row ROW. Do it in a way that makes it robust against
933 changes in the glyph_row structure, i.e. addition or removal of
934 structure members. */
936 static struct glyph_row null_row
;
939 clear_glyph_row (struct glyph_row
*row
)
941 struct glyph
*p
[1 + LAST_AREA
];
944 p
[LEFT_MARGIN_AREA
] = row
->glyphs
[LEFT_MARGIN_AREA
];
945 p
[TEXT_AREA
] = row
->glyphs
[TEXT_AREA
];
946 p
[RIGHT_MARGIN_AREA
] = row
->glyphs
[RIGHT_MARGIN_AREA
];
947 p
[LAST_AREA
] = row
->glyphs
[LAST_AREA
];
952 /* Restore pointers. */
953 row
->glyphs
[LEFT_MARGIN_AREA
] = p
[LEFT_MARGIN_AREA
];
954 row
->glyphs
[TEXT_AREA
] = p
[TEXT_AREA
];
955 row
->glyphs
[RIGHT_MARGIN_AREA
] = p
[RIGHT_MARGIN_AREA
];
956 row
->glyphs
[LAST_AREA
] = p
[LAST_AREA
];
958 #if 0 /* At some point, some bit-fields of struct glyph were not set,
959 which made glyphs unequal when compared with GLYPH_EQUAL_P.
960 Redisplay outputs such glyphs, and flickering effects were
961 the result. This also depended on the contents of memory
962 returned by xmalloc. If flickering happens again, activate
963 the code below. If the flickering is gone with that, chances
964 are that the flickering has the same reason as here. */
965 memset (p
[0], 0, (char *) p
[LAST_AREA
] - (char *) p
[0]);
970 /* Make ROW an empty, enabled row of canonical character height,
971 in window W starting at y-position Y. */
974 blank_row (struct window
*w
, struct glyph_row
*row
, int y
)
978 min_y
= WINDOW_HEADER_LINE_HEIGHT (w
);
979 max_y
= WINDOW_BOX_HEIGHT_NO_MODE_LINE (w
);
981 clear_glyph_row (row
);
983 row
->ascent
= row
->phys_ascent
= 0;
984 row
->height
= row
->phys_height
= FRAME_LINE_HEIGHT (XFRAME (w
->frame
));
985 row
->visible_height
= row
->height
;
988 row
->visible_height
-= min_y
- row
->y
;
989 if (row
->y
+ row
->height
> max_y
)
990 row
->visible_height
-= row
->y
+ row
->height
- max_y
;
996 /* Increment buffer positions in glyph row ROW. DELTA and DELTA_BYTES
997 are the amounts by which to change positions. Note that the first
998 glyph of the text area of a row can have a buffer position even if
999 the used count of the text area is zero. Such rows display line
1003 increment_row_positions (struct glyph_row
*row
,
1004 ptrdiff_t delta
, ptrdiff_t delta_bytes
)
1008 /* Increment start and end positions. */
1009 MATRIX_ROW_START_CHARPOS (row
) += delta
;
1010 MATRIX_ROW_START_BYTEPOS (row
) += delta_bytes
;
1011 MATRIX_ROW_END_CHARPOS (row
) += delta
;
1012 MATRIX_ROW_END_BYTEPOS (row
) += delta_bytes
;
1013 CHARPOS (row
->start
.pos
) += delta
;
1014 BYTEPOS (row
->start
.pos
) += delta_bytes
;
1015 CHARPOS (row
->end
.pos
) += delta
;
1016 BYTEPOS (row
->end
.pos
) += delta_bytes
;
1018 if (!row
->enabled_p
)
1021 /* Increment positions in glyphs. */
1022 for (area
= 0; area
< LAST_AREA
; ++area
)
1023 for (i
= 0; i
< row
->used
[area
]; ++i
)
1024 if (BUFFERP (row
->glyphs
[area
][i
].object
)
1025 && row
->glyphs
[area
][i
].charpos
> 0)
1026 row
->glyphs
[area
][i
].charpos
+= delta
;
1028 /* Capture the case of rows displaying a line end. */
1029 if (row
->used
[TEXT_AREA
] == 0
1030 && MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1031 row
->glyphs
[TEXT_AREA
]->charpos
+= delta
;
1036 /* Swap glyphs between two glyph rows A and B. This exchanges glyph
1037 contents, i.e. glyph structure contents are exchanged between A and
1038 B without changing glyph pointers in A and B. */
1041 swap_glyphs_in_rows (struct glyph_row
*a
, struct glyph_row
*b
)
1045 for (area
= 0; area
< LAST_AREA
; ++area
)
1047 /* Number of glyphs to swap. */
1048 int max_used
= max (a
->used
[area
], b
->used
[area
]);
1050 /* Start of glyphs in area of row A. */
1051 struct glyph
*glyph_a
= a
->glyphs
[area
];
1053 /* End + 1 of glyphs in area of row A. */
1054 struct glyph
*glyph_a_end
= a
->glyphs
[max_used
];
1056 /* Start of glyphs in area of row B. */
1057 struct glyph
*glyph_b
= b
->glyphs
[area
];
1059 while (glyph_a
< glyph_a_end
)
1061 /* Non-ISO HP/UX compiler doesn't like auto struct
1065 *glyph_a
= *glyph_b
;
1075 /* Exchange pointers to glyph memory between glyph rows A and B. Also
1076 exchange the used[] array and the hash values of the rows, because
1077 these should all go together for the row's hash value to be
1081 swap_glyph_pointers (struct glyph_row
*a
, struct glyph_row
*b
)
1084 unsigned hash_tem
= a
->hash
;
1086 for (i
= 0; i
< LAST_AREA
+ 1; ++i
)
1088 struct glyph
*temp
= a
->glyphs
[i
];
1090 a
->glyphs
[i
] = b
->glyphs
[i
];
1091 b
->glyphs
[i
] = temp
;
1094 short used_tem
= a
->used
[i
];
1096 a
->used
[i
] = b
->used
[i
];
1097 b
->used
[i
] = used_tem
;
1105 /* Copy glyph row structure FROM to glyph row structure TO, except
1106 that glyph pointers, the `used' counts, and the hash values in the
1107 structures are left unchanged. */
1110 copy_row_except_pointers (struct glyph_row
*to
, struct glyph_row
*from
)
1112 struct glyph
*pointers
[1 + LAST_AREA
];
1113 short used
[LAST_AREA
];
1116 /* Save glyph pointers of TO. */
1117 memcpy (pointers
, to
->glyphs
, sizeof to
->glyphs
);
1118 memcpy (used
, to
->used
, sizeof to
->used
);
1121 /* Do a structure assignment. */
1124 /* Restore original pointers of TO. */
1125 memcpy (to
->glyphs
, pointers
, sizeof to
->glyphs
);
1126 memcpy (to
->used
, used
, sizeof to
->used
);
1131 /* Assign glyph row FROM to glyph row TO. This works like a structure
1132 assignment TO = FROM, except that glyph pointers are not copied but
1133 exchanged between TO and FROM. Pointers must be exchanged to avoid
1137 assign_row (struct glyph_row
*to
, struct glyph_row
*from
)
1139 swap_glyph_pointers (to
, from
);
1140 copy_row_except_pointers (to
, from
);
1144 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1145 a row in a window matrix, is a slice of the glyph memory of the
1146 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1147 is non-zero if the glyph memory of WINDOW_ROW is part of the glyph
1148 memory of FRAME_ROW. */
1153 glyph_row_slice_p (struct glyph_row
*window_row
, struct glyph_row
*frame_row
)
1155 struct glyph
*window_glyph_start
= window_row
->glyphs
[0];
1156 struct glyph
*frame_glyph_start
= frame_row
->glyphs
[0];
1157 struct glyph
*frame_glyph_end
= frame_row
->glyphs
[LAST_AREA
];
1159 return (frame_glyph_start
<= window_glyph_start
1160 && window_glyph_start
< frame_glyph_end
);
1163 #endif /* GLYPH_DEBUG */
1167 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1168 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1169 in WINDOW_MATRIX is found satisfying the condition. */
1171 static struct glyph_row
*
1172 find_glyph_row_slice (struct glyph_matrix
*window_matrix
,
1173 struct glyph_matrix
*frame_matrix
, int row
)
1177 xassert (row
>= 0 && row
< frame_matrix
->nrows
);
1179 for (i
= 0; i
< window_matrix
->nrows
; ++i
)
1180 if (glyph_row_slice_p (window_matrix
->rows
+ i
,
1181 frame_matrix
->rows
+ row
))
1184 return i
< window_matrix
->nrows
? window_matrix
->rows
+ i
: 0;
1189 /* Prepare ROW for display. Desired rows are cleared lazily,
1190 i.e. they are only marked as to be cleared by setting their
1191 enabled_p flag to zero. When a row is to be displayed, a prior
1192 call to this function really clears it. */
1195 prepare_desired_row (struct glyph_row
*row
)
1197 if (!row
->enabled_p
)
1199 int rp
= row
->reversed_p
;
1201 clear_glyph_row (row
);
1203 row
->reversed_p
= rp
;
1208 /* Return a hash code for glyph row ROW. */
1211 line_hash_code (struct glyph_row
*row
)
1217 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
1218 struct glyph
*end
= glyph
+ row
->used
[TEXT_AREA
];
1222 int c
= glyph
->u
.ch
;
1223 int face_id
= glyph
->face_id
;
1224 if (FRAME_MUST_WRITE_SPACES (SELECTED_FRAME ())) /* XXX Is SELECTED_FRAME OK here? */
1226 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + c
;
1227 hash
= (((hash
<< 4) + (hash
>> 24)) & 0x0fffffff) + face_id
;
1239 /* Return the cost of drawing line VPOS in MATRIX. The cost equals
1240 the number of characters in the line. If must_write_spaces is
1241 zero, leading and trailing spaces are ignored. */
1244 line_draw_cost (struct glyph_matrix
*matrix
, int vpos
)
1246 struct glyph_row
*row
= matrix
->rows
+ vpos
;
1247 struct glyph
*beg
= row
->glyphs
[TEXT_AREA
];
1248 struct glyph
*end
= beg
+ row
->used
[TEXT_AREA
];
1250 Lisp_Object
*glyph_table_base
= GLYPH_TABLE_BASE
;
1251 ptrdiff_t glyph_table_len
= GLYPH_TABLE_LENGTH
;
1253 /* Ignore trailing and leading spaces if we can. */
1254 if (!FRAME_MUST_WRITE_SPACES (SELECTED_FRAME ())) /* XXX Is SELECTED_FRAME OK here? */
1256 /* Skip from the end over trailing spaces. */
1257 while (end
> beg
&& CHAR_GLYPH_SPACE_P (*(end
- 1)))
1260 /* All blank line. */
1264 /* Skip over leading spaces. */
1265 while (CHAR_GLYPH_SPACE_P (*beg
))
1269 /* If we don't have a glyph-table, each glyph is one character,
1270 so return the number of glyphs. */
1271 if (glyph_table_base
== 0)
1275 /* Otherwise, scan the glyphs and accumulate their total length
1282 SET_GLYPH_FROM_CHAR_GLYPH (g
, *beg
);
1284 if (GLYPH_INVALID_P (g
)
1285 || GLYPH_SIMPLE_P (glyph_table_base
, glyph_table_len
, g
))
1288 len
+= GLYPH_LENGTH (glyph_table_base
, g
);
1298 /* Test two glyph rows A and B for equality. Value is non-zero if A
1299 and B have equal contents. MOUSE_FACE_P non-zero means compare the
1300 mouse_face_p flags of A and B, too. */
1303 row_equal_p (struct glyph_row
*a
, struct glyph_row
*b
, int mouse_face_p
)
1305 xassert (verify_row_hash (a
));
1306 xassert (verify_row_hash (b
));
1310 else if (a
->hash
!= b
->hash
)
1314 struct glyph
*a_glyph
, *b_glyph
, *a_end
;
1317 if (mouse_face_p
&& a
->mouse_face_p
!= b
->mouse_face_p
)
1320 /* Compare glyphs. */
1321 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
1323 if (a
->used
[area
] != b
->used
[area
])
1326 a_glyph
= a
->glyphs
[area
];
1327 a_end
= a_glyph
+ a
->used
[area
];
1328 b_glyph
= b
->glyphs
[area
];
1330 while (a_glyph
< a_end
1331 && GLYPH_EQUAL_P (a_glyph
, b_glyph
))
1332 ++a_glyph
, ++b_glyph
;
1334 if (a_glyph
!= a_end
)
1338 if (a
->fill_line_p
!= b
->fill_line_p
1339 || a
->cursor_in_fringe_p
!= b
->cursor_in_fringe_p
1340 || a
->left_fringe_bitmap
!= b
->left_fringe_bitmap
1341 || a
->left_fringe_face_id
!= b
->left_fringe_face_id
1342 || a
->left_fringe_offset
!= b
->left_fringe_offset
1343 || a
->right_fringe_bitmap
!= b
->right_fringe_bitmap
1344 || a
->right_fringe_face_id
!= b
->right_fringe_face_id
1345 || a
->right_fringe_offset
!= b
->right_fringe_offset
1346 || a
->fringe_bitmap_periodic_p
!= b
->fringe_bitmap_periodic_p
1347 || a
->overlay_arrow_bitmap
!= b
->overlay_arrow_bitmap
1348 || a
->exact_window_width_line_p
!= b
->exact_window_width_line_p
1349 || a
->overlapped_p
!= b
->overlapped_p
1350 || (MATRIX_ROW_CONTINUATION_LINE_P (a
)
1351 != MATRIX_ROW_CONTINUATION_LINE_P (b
))
1352 || a
->reversed_p
!= b
->reversed_p
1353 /* Different partially visible characters on left margin. */
1355 /* Different height. */
1356 || a
->ascent
!= b
->ascent
1357 || a
->phys_ascent
!= b
->phys_ascent
1358 || a
->phys_height
!= b
->phys_height
1359 || a
->visible_height
!= b
->visible_height
)
1368 /***********************************************************************
1371 See dispextern.h for an overall explanation of glyph pools.
1372 ***********************************************************************/
1374 /* Allocate a glyph_pool structure. The structure returned is
1375 initialized with zeros. The global variable glyph_pool_count is
1376 incremented for each pool allocated. */
1378 static struct glyph_pool
*
1379 new_glyph_pool (void)
1381 struct glyph_pool
*result
;
1383 /* Allocate a new glyph_pool and clear it. */
1384 result
= (struct glyph_pool
*) xmalloc (sizeof *result
);
1385 memset (result
, 0, sizeof *result
);
1387 /* For memory leak and double deletion checking. */
1394 /* Free a glyph_pool structure POOL. The function may be called with
1395 a null POOL pointer. The global variable glyph_pool_count is
1396 decremented with every pool structure freed. If this count gets
1397 negative, more structures were freed than allocated, i.e. one
1398 structure must have been freed more than once or a bogus pointer
1399 was passed to free_glyph_pool. */
1402 free_glyph_pool (struct glyph_pool
*pool
)
1406 /* More freed than allocated? */
1408 xassert (glyph_pool_count
>= 0);
1410 xfree (pool
->glyphs
);
1416 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1417 columns we need. This function never shrinks a pool. The only
1418 case in which this would make sense, would be when a frame's size
1419 is changed from a large value to a smaller one. But, if someone
1420 does it once, we can expect that he will do it again.
1422 Value is non-zero if the pool changed in a way which makes
1423 re-adjusting window glyph matrices necessary. */
1426 realloc_glyph_pool (struct glyph_pool
*pool
, struct dim matrix_dim
)
1431 changed_p
= (pool
->glyphs
== 0
1432 || matrix_dim
.height
!= pool
->nrows
1433 || matrix_dim
.width
!= pool
->ncolumns
);
1435 /* Enlarge the glyph pool. */
1436 needed
= matrix_dim
.width
;
1437 if (INT_MULTIPLY_OVERFLOW (needed
, matrix_dim
.height
))
1438 memory_full (SIZE_MAX
);
1439 needed
*= matrix_dim
.height
;
1440 if (needed
> pool
->nglyphs
)
1442 ptrdiff_t old_nglyphs
= pool
->nglyphs
;
1443 pool
->glyphs
= xpalloc (pool
->glyphs
, &pool
->nglyphs
,
1444 needed
- old_nglyphs
, -1, sizeof *pool
->glyphs
);
1445 memset (pool
->glyphs
+ old_nglyphs
, 0,
1446 (pool
->nglyphs
- old_nglyphs
) * sizeof *pool
->glyphs
);
1449 /* Remember the number of rows and columns because (a) we use them
1450 to do sanity checks, and (b) the number of columns determines
1451 where rows in the frame matrix start---this must be available to
1452 determine pointers to rows of window sub-matrices. */
1453 pool
->nrows
= matrix_dim
.height
;
1454 pool
->ncolumns
= matrix_dim
.width
;
1461 /***********************************************************************
1463 ***********************************************************************/
1468 /* Flush standard output. This is sometimes useful to call from the debugger.
1469 XXX Maybe this should be changed to flush the current terminal instead of
1473 void flush_stdout (void) EXTERNALLY_VISIBLE
;
1482 /* Check that no glyph pointers have been lost in MATRIX. If a
1483 pointer has been lost, e.g. by using a structure assignment between
1484 rows, at least one pointer must occur more than once in the rows of
1488 check_matrix_pointer_lossage (struct glyph_matrix
*matrix
)
1492 for (i
= 0; i
< matrix
->nrows
; ++i
)
1493 for (j
= 0; j
< matrix
->nrows
; ++j
)
1495 || (matrix
->rows
[i
].glyphs
[TEXT_AREA
]
1496 != matrix
->rows
[j
].glyphs
[TEXT_AREA
]));
1500 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1503 matrix_row (struct glyph_matrix
*matrix
, int row
)
1505 xassert (matrix
&& matrix
->rows
);
1506 xassert (row
>= 0 && row
< matrix
->nrows
);
1508 /* That's really too slow for normal testing because this function
1509 is called almost everywhere. Although---it's still astonishingly
1510 fast, so it is valuable to have for debugging purposes. */
1512 check_matrix_pointer_lossage (matrix
);
1515 return matrix
->rows
+ row
;
1519 #if 0 /* This function makes invalid assumptions when text is
1520 partially invisible. But it might come handy for debugging
1523 /* Check invariants that must hold for an up to date current matrix of
1527 check_matrix_invariants (struct window
*w
)
1529 struct glyph_matrix
*matrix
= w
->current_matrix
;
1530 int yb
= window_text_bottom_y (w
);
1531 struct glyph_row
*row
= matrix
->rows
;
1532 struct glyph_row
*last_text_row
= NULL
;
1533 struct buffer
*saved
= current_buffer
;
1534 struct buffer
*buffer
= XBUFFER (w
->buffer
);
1537 /* This can sometimes happen for a fresh window. */
1538 if (matrix
->nrows
< 2)
1541 set_buffer_temp (buffer
);
1543 /* Note: last row is always reserved for the mode line. */
1544 while (MATRIX_ROW_DISPLAYS_TEXT_P (row
)
1545 && MATRIX_ROW_BOTTOM_Y (row
) < yb
)
1547 struct glyph_row
*next
= row
+ 1;
1549 if (MATRIX_ROW_DISPLAYS_TEXT_P (row
))
1550 last_text_row
= row
;
1552 /* Check that character and byte positions are in sync. */
1553 xassert (MATRIX_ROW_START_BYTEPOS (row
)
1554 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row
)));
1555 xassert (BYTEPOS (row
->start
.pos
)
1556 == CHAR_TO_BYTE (CHARPOS (row
->start
.pos
)));
1558 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1559 have such a position temporarily in case of a minibuffer
1560 displaying something like `[Sole completion]' at its end. */
1561 if (MATRIX_ROW_END_CHARPOS (row
) < BUF_ZV (current_buffer
))
1563 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1564 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row
)));
1565 xassert (BYTEPOS (row
->end
.pos
)
1566 == CHAR_TO_BYTE (CHARPOS (row
->end
.pos
)));
1569 /* Check that end position of `row' is equal to start position
1571 if (next
->enabled_p
&& MATRIX_ROW_DISPLAYS_TEXT_P (next
))
1573 xassert (MATRIX_ROW_END_CHARPOS (row
)
1574 == MATRIX_ROW_START_CHARPOS (next
));
1575 xassert (MATRIX_ROW_END_BYTEPOS (row
)
1576 == MATRIX_ROW_START_BYTEPOS (next
));
1577 xassert (CHARPOS (row
->end
.pos
) == CHARPOS (next
->start
.pos
));
1578 xassert (BYTEPOS (row
->end
.pos
) == BYTEPOS (next
->start
.pos
));
1583 xassert (w
->current_matrix
->nrows
== w
->desired_matrix
->nrows
);
1584 xassert (w
->desired_matrix
->rows
!= NULL
);
1585 set_buffer_temp (saved
);
1590 #endif /* GLYPH_DEBUG != 0 */
1594 /**********************************************************************
1595 Allocating/ Adjusting Glyph Matrices
1596 **********************************************************************/
1598 /* Allocate glyph matrices over a window tree for a frame-based
1601 X and Y are column/row within the frame glyph matrix where
1602 sub-matrices for the window tree rooted at WINDOW must be
1603 allocated. DIM_ONLY_P non-zero means that the caller of this
1604 function is only interested in the result matrix dimension, and
1605 matrix adjustments should not be performed.
1607 The function returns the total width/height of the sub-matrices of
1608 the window tree. If called on a frame root window, the computation
1609 will take the mini-buffer window into account.
1611 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1613 NEW_LEAF_MATRIX set if any window in the tree did not have a
1614 glyph matrices yet, and
1616 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1617 any window in the tree will be changed or have been changed (see
1620 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1623 Windows are arranged into chains of windows on the same level
1624 through the next fields of window structures. Such a level can be
1625 either a sequence of horizontally adjacent windows from left to
1626 right, or a sequence of vertically adjacent windows from top to
1627 bottom. Each window in a horizontal sequence can be either a leaf
1628 window or a vertical sequence; a window in a vertical sequence can
1629 be either a leaf or a horizontal sequence. All windows in a
1630 horizontal sequence have the same height, and all windows in a
1631 vertical sequence have the same width.
1633 This function uses, for historical reasons, a more general
1634 algorithm to determine glyph matrix dimensions that would be
1637 The matrix height of a horizontal sequence is determined by the
1638 maximum height of any matrix in the sequence. The matrix width of
1639 a horizontal sequence is computed by adding up matrix widths of
1640 windows in the sequence.
1642 |<------- result width ------->|
1643 +---------+----------+---------+ ---
1646 +---------+ | | result height
1651 The matrix width of a vertical sequence is the maximum matrix width
1652 of any window in the sequence. Its height is computed by adding up
1653 matrix heights of windows in the sequence.
1655 |<---- result width -->|
1663 +------------+---------+ |
1666 +------------+---------+ --- */
1668 /* Bit indicating that a new matrix will be allocated or has been
1671 #define NEW_LEAF_MATRIX (1 << 0)
1673 /* Bit indicating that a matrix will or has changed its location or
1676 #define CHANGED_LEAF_MATRIX (1 << 1)
1679 allocate_matrices_for_frame_redisplay (Lisp_Object window
, int x
, int y
,
1680 int dim_only_p
, int *window_change_flags
)
1682 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1684 int wmax
= 0, hmax
= 0;
1688 int in_horz_combination_p
;
1690 /* What combination is WINDOW part of? Compute this once since the
1691 result is the same for all windows in the `next' chain. The
1692 special case of a root window (parent equal to nil) is treated
1693 like a vertical combination because a root window's `next'
1694 points to the mini-buffer window, if any, which is arranged
1695 vertically below other windows. */
1696 in_horz_combination_p
1697 = (!NILP (XWINDOW (window
)->parent
)
1698 && !NILP (XWINDOW (XWINDOW (window
)->parent
)->hchild
));
1700 /* For WINDOW and all windows on the same level. */
1703 w
= XWINDOW (window
);
1705 /* Get the dimension of the window sub-matrix for W, depending
1706 on whether this is a combination or a leaf window. */
1707 if (!NILP (w
->hchild
))
1708 dim
= allocate_matrices_for_frame_redisplay (w
->hchild
, x
, y
,
1710 window_change_flags
);
1711 else if (!NILP (w
->vchild
))
1712 dim
= allocate_matrices_for_frame_redisplay (w
->vchild
, x
, y
,
1714 window_change_flags
);
1717 /* If not already done, allocate sub-matrix structures. */
1718 if (w
->desired_matrix
== NULL
)
1720 w
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
1721 w
->current_matrix
= new_glyph_matrix (f
->current_pool
);
1722 *window_change_flags
|= NEW_LEAF_MATRIX
;
1725 /* Width and height MUST be chosen so that there are no
1726 holes in the frame matrix. */
1727 dim
.width
= required_matrix_width (w
);
1728 dim
.height
= required_matrix_height (w
);
1730 /* Will matrix be re-allocated? */
1731 if (x
!= w
->desired_matrix
->matrix_x
1732 || y
!= w
->desired_matrix
->matrix_y
1733 || dim
.width
!= w
->desired_matrix
->matrix_w
1734 || dim
.height
!= w
->desired_matrix
->matrix_h
1735 || (margin_glyphs_to_reserve (w
, dim
.width
,
1736 w
->left_margin_cols
)
1737 != w
->desired_matrix
->left_margin_glyphs
)
1738 || (margin_glyphs_to_reserve (w
, dim
.width
,
1739 w
->right_margin_cols
)
1740 != w
->desired_matrix
->right_margin_glyphs
))
1741 *window_change_flags
|= CHANGED_LEAF_MATRIX
;
1743 /* Actually change matrices, if allowed. Do not consider
1744 CHANGED_LEAF_MATRIX computed above here because the pool
1745 may have been changed which we don't now here. We trust
1746 that we only will be called with DIM_ONLY_P != 0 when
1750 adjust_glyph_matrix (w
, w
->desired_matrix
, x
, y
, dim
);
1751 adjust_glyph_matrix (w
, w
->current_matrix
, x
, y
, dim
);
1755 /* If we are part of a horizontal combination, advance x for
1756 windows to the right of W; otherwise advance y for windows
1758 if (in_horz_combination_p
)
1763 /* Remember maximum glyph matrix dimensions. */
1764 wmax
= max (wmax
, dim
.width
);
1765 hmax
= max (hmax
, dim
.height
);
1767 /* Next window on same level. */
1770 while (!NILP (window
));
1772 /* Set `total' to the total glyph matrix dimension of this window
1773 level. In a vertical combination, the width is the width of the
1774 widest window; the height is the y we finally reached, corrected
1775 by the y we started with. In a horizontal combination, the total
1776 height is the height of the tallest window, and the width is the
1777 x we finally reached, corrected by the x we started with. */
1778 if (in_horz_combination_p
)
1780 total
.width
= x
- x0
;
1781 total
.height
= hmax
;
1786 total
.height
= y
- y0
;
1793 /* Return the required height of glyph matrices for window W. */
1796 required_matrix_height (struct window
*w
)
1798 #ifdef HAVE_WINDOW_SYSTEM
1799 struct frame
*f
= XFRAME (w
->frame
);
1801 if (FRAME_WINDOW_P (f
))
1803 int ch_height
= FRAME_SMALLEST_FONT_HEIGHT (f
);
1804 int window_pixel_height
= window_box_height (w
) + eabs (w
->vscroll
);
1805 return (((window_pixel_height
+ ch_height
- 1)
1806 / ch_height
) * w
->nrows_scale_factor
1807 /* One partially visible line at the top and
1808 bottom of the window. */
1810 /* 2 for header and mode line. */
1813 #endif /* HAVE_WINDOW_SYSTEM */
1815 return WINDOW_TOTAL_LINES (w
);
1819 /* Return the required width of glyph matrices for window W. */
1822 required_matrix_width (struct window
*w
)
1824 #ifdef HAVE_WINDOW_SYSTEM
1825 struct frame
*f
= XFRAME (w
->frame
);
1826 if (FRAME_WINDOW_P (f
))
1828 int ch_width
= FRAME_SMALLEST_CHAR_WIDTH (f
);
1829 int window_pixel_width
= WINDOW_TOTAL_WIDTH (w
);
1831 /* Compute number of glyphs needed in a glyph row. */
1832 return (((window_pixel_width
+ ch_width
- 1)
1833 / ch_width
) * w
->ncols_scale_factor
1834 /* 2 partially visible columns in the text area. */
1836 /* One partially visible column at the right
1837 edge of each marginal area. */
1840 #endif /* HAVE_WINDOW_SYSTEM */
1842 return XINT (w
->total_cols
);
1846 /* Allocate window matrices for window-based redisplay. W is the
1847 window whose matrices must be allocated/reallocated. */
1850 allocate_matrices_for_window_redisplay (struct window
*w
)
1854 if (!NILP (w
->vchild
))
1855 allocate_matrices_for_window_redisplay (XWINDOW (w
->vchild
));
1856 else if (!NILP (w
->hchild
))
1857 allocate_matrices_for_window_redisplay (XWINDOW (w
->hchild
));
1860 /* W is a leaf window. */
1863 /* If matrices are not yet allocated, allocate them now. */
1864 if (w
->desired_matrix
== NULL
)
1866 w
->desired_matrix
= new_glyph_matrix (NULL
);
1867 w
->current_matrix
= new_glyph_matrix (NULL
);
1870 dim
.width
= required_matrix_width (w
);
1871 dim
.height
= required_matrix_height (w
);
1872 adjust_glyph_matrix (w
, w
->desired_matrix
, 0, 0, dim
);
1873 adjust_glyph_matrix (w
, w
->current_matrix
, 0, 0, dim
);
1876 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
1881 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
1882 do it for all frames; otherwise do it just for the given frame.
1883 This function must be called when a new frame is created, its size
1884 changes, or its window configuration changes. */
1887 adjust_glyphs (struct frame
*f
)
1889 /* Block input so that expose events and other events that access
1890 glyph matrices are not processed while we are changing them. */
1894 adjust_frame_glyphs (f
);
1897 Lisp_Object tail
, lisp_frame
;
1899 FOR_EACH_FRAME (tail
, lisp_frame
)
1900 adjust_frame_glyphs (XFRAME (lisp_frame
));
1907 /* Adjust frame glyphs when Emacs is initialized.
1909 To be called from init_display.
1911 We need a glyph matrix because redraw will happen soon.
1912 Unfortunately, window sizes on selected_frame are not yet set to
1913 meaningful values. I believe we can assume that there are only two
1914 windows on the frame---the mini-buffer and the root window. Frame
1915 height and width seem to be correct so far. So, set the sizes of
1916 windows to estimated values. */
1919 adjust_frame_glyphs_initially (void)
1921 struct frame
*sf
= SELECTED_FRAME ();
1922 struct window
*root
= XWINDOW (sf
->root_window
);
1923 struct window
*mini
= XWINDOW (root
->next
);
1924 int frame_lines
= FRAME_LINES (sf
);
1925 int frame_cols
= FRAME_COLS (sf
);
1926 int top_margin
= FRAME_TOP_MARGIN (sf
);
1928 /* Do it for the root window. */
1929 XSETFASTINT (root
->top_line
, top_margin
);
1930 XSETFASTINT (root
->total_lines
, frame_lines
- 1 - top_margin
);
1931 XSETFASTINT (root
->total_cols
, frame_cols
);
1933 /* Do it for the mini-buffer window. */
1934 XSETFASTINT (mini
->top_line
, frame_lines
- 1);
1935 XSETFASTINT (mini
->total_lines
, 1);
1936 XSETFASTINT (mini
->total_cols
, frame_cols
);
1938 adjust_frame_glyphs (sf
);
1939 glyphs_initialized_initially_p
= 1;
1943 /* Allocate/reallocate glyph matrices of a single frame F. */
1946 adjust_frame_glyphs (struct frame
*f
)
1948 if (FRAME_WINDOW_P (f
))
1949 adjust_frame_glyphs_for_window_redisplay (f
);
1951 adjust_frame_glyphs_for_frame_redisplay (f
);
1953 /* Don't forget the message buffer and the buffer for
1954 decode_mode_spec. */
1955 adjust_frame_message_buffer (f
);
1956 adjust_decode_mode_spec_buffer (f
);
1958 f
->glyphs_initialized_p
= 1;
1961 /* Return 1 if any window in the tree has nonzero window margins. See
1962 the hack at the end of adjust_frame_glyphs_for_frame_redisplay. */
1964 showing_window_margins_p (struct window
*w
)
1968 if (!NILP (w
->hchild
))
1970 if (showing_window_margins_p (XWINDOW (w
->hchild
)))
1973 else if (!NILP (w
->vchild
))
1975 if (showing_window_margins_p (XWINDOW (w
->vchild
)))
1978 else if (!NILP (w
->left_margin_cols
)
1979 || !NILP (w
->right_margin_cols
))
1982 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
1988 /* In the window tree with root W, build current matrices of leaf
1989 windows from the frame's current matrix. */
1992 fake_current_matrices (Lisp_Object window
)
1996 for (; !NILP (window
); window
= w
->next
)
1998 w
= XWINDOW (window
);
2000 if (!NILP (w
->hchild
))
2001 fake_current_matrices (w
->hchild
);
2002 else if (!NILP (w
->vchild
))
2003 fake_current_matrices (w
->vchild
);
2007 struct frame
*f
= XFRAME (w
->frame
);
2008 struct glyph_matrix
*m
= w
->current_matrix
;
2009 struct glyph_matrix
*fm
= f
->current_matrix
;
2011 xassert (m
->matrix_h
== WINDOW_TOTAL_LINES (w
));
2012 xassert (m
->matrix_w
== WINDOW_TOTAL_COLS (w
));
2014 for (i
= 0; i
< m
->matrix_h
; ++i
)
2016 struct glyph_row
*r
= m
->rows
+ i
;
2017 struct glyph_row
*fr
= fm
->rows
+ i
+ WINDOW_TOP_EDGE_LINE (w
);
2019 xassert (r
->glyphs
[TEXT_AREA
] >= fr
->glyphs
[TEXT_AREA
]
2020 && r
->glyphs
[LAST_AREA
] <= fr
->glyphs
[LAST_AREA
]);
2022 r
->enabled_p
= fr
->enabled_p
;
2025 r
->used
[LEFT_MARGIN_AREA
] = m
->left_margin_glyphs
;
2026 r
->used
[RIGHT_MARGIN_AREA
] = m
->right_margin_glyphs
;
2027 r
->used
[TEXT_AREA
] = (m
->matrix_w
2028 - r
->used
[LEFT_MARGIN_AREA
]
2029 - r
->used
[RIGHT_MARGIN_AREA
]);
2038 /* Save away the contents of frame F's current frame matrix. Value is
2039 a glyph matrix holding the contents of F's current frame matrix. */
2041 static struct glyph_matrix
*
2042 save_current_matrix (struct frame
*f
)
2045 struct glyph_matrix
*saved
;
2047 saved
= (struct glyph_matrix
*) xmalloc (sizeof *saved
);
2048 memset (saved
, 0, sizeof *saved
);
2049 saved
->nrows
= f
->current_matrix
->nrows
;
2050 saved
->rows
= (struct glyph_row
*) xmalloc (saved
->nrows
2051 * sizeof *saved
->rows
);
2052 memset (saved
->rows
, 0, saved
->nrows
* sizeof *saved
->rows
);
2054 for (i
= 0; i
< saved
->nrows
; ++i
)
2056 struct glyph_row
*from
= f
->current_matrix
->rows
+ i
;
2057 struct glyph_row
*to
= saved
->rows
+ i
;
2058 ptrdiff_t nbytes
= from
->used
[TEXT_AREA
] * sizeof (struct glyph
);
2059 to
->glyphs
[TEXT_AREA
] = (struct glyph
*) xmalloc (nbytes
);
2060 memcpy (to
->glyphs
[TEXT_AREA
], from
->glyphs
[TEXT_AREA
], nbytes
);
2061 to
->used
[TEXT_AREA
] = from
->used
[TEXT_AREA
];
2068 /* Restore the contents of frame F's current frame matrix from SAVED,
2069 and free memory associated with SAVED. */
2072 restore_current_matrix (struct frame
*f
, struct glyph_matrix
*saved
)
2076 for (i
= 0; i
< saved
->nrows
; ++i
)
2078 struct glyph_row
*from
= saved
->rows
+ i
;
2079 struct glyph_row
*to
= f
->current_matrix
->rows
+ i
;
2080 ptrdiff_t nbytes
= from
->used
[TEXT_AREA
] * sizeof (struct glyph
);
2081 memcpy (to
->glyphs
[TEXT_AREA
], from
->glyphs
[TEXT_AREA
], nbytes
);
2082 to
->used
[TEXT_AREA
] = from
->used
[TEXT_AREA
];
2083 xfree (from
->glyphs
[TEXT_AREA
]);
2086 xfree (saved
->rows
);
2092 /* Allocate/reallocate glyph matrices of a single frame F for
2093 frame-based redisplay. */
2096 adjust_frame_glyphs_for_frame_redisplay (struct frame
*f
)
2098 struct dim matrix_dim
;
2100 int window_change_flags
;
2103 if (!FRAME_LIVE_P (f
))
2106 top_window_y
= FRAME_TOP_MARGIN (f
);
2108 /* Allocate glyph pool structures if not already done. */
2109 if (f
->desired_pool
== NULL
)
2111 f
->desired_pool
= new_glyph_pool ();
2112 f
->current_pool
= new_glyph_pool ();
2115 /* Allocate frames matrix structures if needed. */
2116 if (f
->desired_matrix
== NULL
)
2118 f
->desired_matrix
= new_glyph_matrix (f
->desired_pool
);
2119 f
->current_matrix
= new_glyph_matrix (f
->current_pool
);
2122 /* Compute window glyph matrices. (This takes the mini-buffer
2123 window into account). The result is the size of the frame glyph
2124 matrix needed. The variable window_change_flags is set to a bit
2125 mask indicating whether new matrices will be allocated or
2126 existing matrices change their size or location within the frame
2128 window_change_flags
= 0;
2130 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2133 &window_change_flags
);
2135 /* Add in menu bar lines, if any. */
2136 matrix_dim
.height
+= top_window_y
;
2138 /* Enlarge pools as necessary. */
2139 pool_changed_p
= realloc_glyph_pool (f
->desired_pool
, matrix_dim
);
2140 realloc_glyph_pool (f
->current_pool
, matrix_dim
);
2142 /* Set up glyph pointers within window matrices. Do this only if
2143 absolutely necessary since it requires a frame redraw. */
2144 if (pool_changed_p
|| window_change_flags
)
2146 /* Do it for window matrices. */
2147 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f
),
2149 &window_change_flags
);
2151 /* Size of frame matrices must equal size of frame. Note
2152 that we are called for X frames with window widths NOT equal
2153 to the frame width (from CHANGE_FRAME_SIZE_1). */
2154 xassert (matrix_dim
.width
== FRAME_COLS (f
)
2155 && matrix_dim
.height
== FRAME_LINES (f
));
2157 /* Pointers to glyph memory in glyph rows are exchanged during
2158 the update phase of redisplay, which means in general that a
2159 frame's current matrix consists of pointers into both the
2160 desired and current glyph pool of the frame. Adjusting a
2161 matrix sets the frame matrix up so that pointers are all into
2162 the same pool. If we want to preserve glyph contents of the
2163 current matrix over a call to adjust_glyph_matrix, we must
2164 make a copy of the current glyphs, and restore the current
2165 matrix' contents from that copy. */
2166 if (display_completed
2167 && !FRAME_GARBAGED_P (f
)
2168 && matrix_dim
.width
== f
->current_matrix
->matrix_w
2169 && matrix_dim
.height
== f
->current_matrix
->matrix_h
2170 /* For some reason, the frame glyph matrix gets corrupted if
2171 any of the windows contain margins. I haven't been able
2172 to hunt down the reason, but for the moment this prevents
2173 the problem from manifesting. -- cyd */
2174 && !showing_window_margins_p (XWINDOW (FRAME_ROOT_WINDOW (f
))))
2176 struct glyph_matrix
*copy
= save_current_matrix (f
);
2177 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2178 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2179 restore_current_matrix (f
, copy
);
2180 fake_current_matrices (FRAME_ROOT_WINDOW (f
));
2184 adjust_glyph_matrix (NULL
, f
->desired_matrix
, 0, 0, matrix_dim
);
2185 adjust_glyph_matrix (NULL
, f
->current_matrix
, 0, 0, matrix_dim
);
2186 SET_FRAME_GARBAGED (f
);
2192 /* Allocate/reallocate glyph matrices of a single frame F for
2193 window-based redisplay. */
2196 adjust_frame_glyphs_for_window_redisplay (struct frame
*f
)
2198 xassert (FRAME_WINDOW_P (f
) && FRAME_LIVE_P (f
));
2200 /* Allocate/reallocate window matrices. */
2201 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2203 #ifdef HAVE_X_WINDOWS
2204 /* Allocate/ reallocate matrices of the dummy window used to display
2205 the menu bar under X when no X toolkit support is available. */
2206 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
2208 /* Allocate a dummy window if not already done. */
2210 if (NILP (f
->menu_bar_window
))
2212 f
->menu_bar_window
= make_window ();
2213 w
= XWINDOW (f
->menu_bar_window
);
2214 XSETFRAME (w
->frame
, f
);
2215 w
->pseudo_window_p
= 1;
2218 w
= XWINDOW (f
->menu_bar_window
);
2220 /* Set window dimensions to frame dimensions and allocate or
2221 adjust glyph matrices of W. */
2222 XSETFASTINT (w
->top_line
, 0);
2223 XSETFASTINT (w
->left_col
, 0);
2224 XSETFASTINT (w
->total_lines
, FRAME_MENU_BAR_LINES (f
));
2225 XSETFASTINT (w
->total_cols
, FRAME_TOTAL_COLS (f
));
2226 allocate_matrices_for_window_redisplay (w
);
2228 #endif /* not USE_X_TOOLKIT && not USE_GTK */
2229 #endif /* HAVE_X_WINDOWS */
2233 /* Allocate/ reallocate matrices of the tool bar window. If we
2234 don't have a tool bar window yet, make one. */
2236 if (NILP (f
->tool_bar_window
))
2238 f
->tool_bar_window
= make_window ();
2239 w
= XWINDOW (f
->tool_bar_window
);
2240 XSETFRAME (w
->frame
, f
);
2241 w
->pseudo_window_p
= 1;
2244 w
= XWINDOW (f
->tool_bar_window
);
2246 XSETFASTINT (w
->top_line
, FRAME_MENU_BAR_LINES (f
));
2247 XSETFASTINT (w
->left_col
, 0);
2248 XSETFASTINT (w
->total_lines
, FRAME_TOOL_BAR_LINES (f
));
2249 XSETFASTINT (w
->total_cols
, FRAME_TOTAL_COLS (f
));
2250 allocate_matrices_for_window_redisplay (w
);
2256 /* Adjust/ allocate message buffer of frame F.
2258 Note that the message buffer is never freed. Since I could not
2259 find a free in 19.34, I assume that freeing it would be
2260 problematic in some way and don't do it either.
2262 (Implementation note: It should be checked if we can free it
2263 eventually without causing trouble). */
2266 adjust_frame_message_buffer (struct frame
*f
)
2268 ptrdiff_t size
= FRAME_MESSAGE_BUF_SIZE (f
) + 1;
2270 if (FRAME_MESSAGE_BUF (f
))
2272 char *buffer
= FRAME_MESSAGE_BUF (f
);
2273 char *new_buffer
= (char *) xrealloc (buffer
, size
);
2274 FRAME_MESSAGE_BUF (f
) = new_buffer
;
2277 FRAME_MESSAGE_BUF (f
) = (char *) xmalloc (size
);
2281 /* Re-allocate buffer for decode_mode_spec on frame F. */
2284 adjust_decode_mode_spec_buffer (struct frame
*f
)
2286 f
->decode_mode_spec_buffer
2287 = (char *) xrealloc (f
->decode_mode_spec_buffer
,
2288 FRAME_MESSAGE_BUF_SIZE (f
) + 1);
2293 /**********************************************************************
2294 Freeing Glyph Matrices
2295 **********************************************************************/
2297 /* Free glyph memory for a frame F. F may be null. This function can
2298 be called for the same frame more than once. The root window of
2299 F may be nil when this function is called. This is the case when
2300 the function is called when F is destroyed. */
2303 free_glyphs (struct frame
*f
)
2305 if (f
&& f
->glyphs_initialized_p
)
2307 /* Block interrupt input so that we don't get surprised by an X
2308 event while we're in an inconsistent state. */
2310 f
->glyphs_initialized_p
= 0;
2312 /* Release window sub-matrices. */
2313 if (!NILP (f
->root_window
))
2314 free_window_matrices (XWINDOW (f
->root_window
));
2316 /* Free the dummy window for menu bars without X toolkit and its
2318 if (!NILP (f
->menu_bar_window
))
2320 struct window
*w
= XWINDOW (f
->menu_bar_window
);
2321 free_glyph_matrix (w
->desired_matrix
);
2322 free_glyph_matrix (w
->current_matrix
);
2323 w
->desired_matrix
= w
->current_matrix
= NULL
;
2324 f
->menu_bar_window
= Qnil
;
2327 /* Free the tool bar window and its glyph matrices. */
2328 if (!NILP (f
->tool_bar_window
))
2330 struct window
*w
= XWINDOW (f
->tool_bar_window
);
2331 free_glyph_matrix (w
->desired_matrix
);
2332 free_glyph_matrix (w
->current_matrix
);
2333 w
->desired_matrix
= w
->current_matrix
= NULL
;
2334 f
->tool_bar_window
= Qnil
;
2337 /* Release frame glyph matrices. Reset fields to zero in
2338 case we are called a second time. */
2339 if (f
->desired_matrix
)
2341 free_glyph_matrix (f
->desired_matrix
);
2342 free_glyph_matrix (f
->current_matrix
);
2343 f
->desired_matrix
= f
->current_matrix
= NULL
;
2346 /* Release glyph pools. */
2347 if (f
->desired_pool
)
2349 free_glyph_pool (f
->desired_pool
);
2350 free_glyph_pool (f
->current_pool
);
2351 f
->desired_pool
= f
->current_pool
= NULL
;
2359 /* Free glyph sub-matrices in the window tree rooted at W. This
2360 function may be called with a null pointer, and it may be called on
2361 the same tree more than once. */
2364 free_window_matrices (struct window
*w
)
2368 if (!NILP (w
->hchild
))
2369 free_window_matrices (XWINDOW (w
->hchild
));
2370 else if (!NILP (w
->vchild
))
2371 free_window_matrices (XWINDOW (w
->vchild
));
2374 /* This is a leaf window. Free its memory and reset fields
2375 to zero in case this function is called a second time for
2377 free_glyph_matrix (w
->current_matrix
);
2378 free_glyph_matrix (w
->desired_matrix
);
2379 w
->current_matrix
= w
->desired_matrix
= NULL
;
2382 /* Next window on same level. */
2383 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2388 /* Check glyph memory leaks. This function is called from
2389 shut_down_emacs. Note that frames are not destroyed when Emacs
2390 exits. We therefore free all glyph memory for all active frames
2391 explicitly and check that nothing is left allocated. */
2394 check_glyph_memory (void)
2396 Lisp_Object tail
, frame
;
2398 /* Free glyph memory for all frames. */
2399 FOR_EACH_FRAME (tail
, frame
)
2400 free_glyphs (XFRAME (frame
));
2402 /* Check that nothing is left allocated. */
2403 if (glyph_matrix_count
)
2405 if (glyph_pool_count
)
2411 /**********************************************************************
2412 Building a Frame Matrix
2413 **********************************************************************/
2415 /* Most of the redisplay code works on glyph matrices attached to
2416 windows. This is a good solution most of the time, but it is not
2417 suitable for terminal code. Terminal output functions cannot rely
2418 on being able to set an arbitrary terminal window. Instead they
2419 must be provided with a view of the whole frame, i.e. the whole
2420 screen. We build such a view by constructing a frame matrix from
2421 window matrices in this section.
2423 Windows that must be updated have their must_be_update_p flag set.
2424 For all such windows, their desired matrix is made part of the
2425 desired frame matrix. For other windows, their current matrix is
2426 made part of the desired frame matrix.
2428 +-----------------+----------------+
2429 | desired | desired |
2431 +-----------------+----------------+
2434 +----------------------------------+
2436 Desired window matrices can be made part of the frame matrix in a
2437 cheap way: We exploit the fact that the desired frame matrix and
2438 desired window matrices share their glyph memory. This is not
2439 possible for current window matrices. Their glyphs are copied to
2440 the desired frame matrix. The latter is equivalent to
2441 preserve_other_columns in the old redisplay.
2443 Used glyphs counters for frame matrix rows are the result of adding
2444 up glyph lengths of the window matrices. A line in the frame
2445 matrix is enabled, if a corresponding line in a window matrix is
2448 After building the desired frame matrix, it will be passed to
2449 terminal code, which will manipulate both the desired and current
2450 frame matrix. Changes applied to the frame's current matrix have
2451 to be visible in current window matrices afterwards, of course.
2453 This problem is solved like this:
2455 1. Window and frame matrices share glyphs. Window matrices are
2456 constructed in a way that their glyph contents ARE the glyph
2457 contents needed in a frame matrix. Thus, any modification of
2458 glyphs done in terminal code will be reflected in window matrices
2461 2. Exchanges of rows in a frame matrix done by terminal code are
2462 intercepted by hook functions so that corresponding row operations
2463 on window matrices can be performed. This is necessary because we
2464 use pointers to glyphs in glyph row structures. To satisfy the
2465 assumption of point 1 above that glyphs are updated implicitly in
2466 window matrices when they are manipulated via the frame matrix,
2467 window and frame matrix must of course agree where to find the
2468 glyphs for their rows. Possible manipulations that must be
2469 mirrored are assignments of rows of the desired frame matrix to the
2470 current frame matrix and scrolling the current frame matrix. */
2472 /* Build frame F's desired matrix from window matrices. Only windows
2473 which have the flag must_be_updated_p set have to be updated. Menu
2474 bar lines of a frame are not covered by window matrices, so make
2475 sure not to touch them in this function. */
2478 build_frame_matrix (struct frame
*f
)
2482 /* F must have a frame matrix when this function is called. */
2483 xassert (!FRAME_WINDOW_P (f
));
2485 /* Clear all rows in the frame matrix covered by window matrices.
2486 Menu bar lines are not covered by windows. */
2487 for (i
= FRAME_TOP_MARGIN (f
); i
< f
->desired_matrix
->nrows
; ++i
)
2488 clear_glyph_row (MATRIX_ROW (f
->desired_matrix
, i
));
2490 /* Build the matrix by walking the window tree. */
2491 build_frame_matrix_from_window_tree (f
->desired_matrix
,
2492 XWINDOW (FRAME_ROOT_WINDOW (f
)));
2496 /* Walk a window tree, building a frame matrix MATRIX from window
2497 matrices. W is the root of a window tree. */
2500 build_frame_matrix_from_window_tree (struct glyph_matrix
*matrix
, struct window
*w
)
2504 if (!NILP (w
->hchild
))
2505 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->hchild
));
2506 else if (!NILP (w
->vchild
))
2507 build_frame_matrix_from_window_tree (matrix
, XWINDOW (w
->vchild
));
2509 build_frame_matrix_from_leaf_window (matrix
, w
);
2511 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2516 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2517 desired frame matrix built. W is a leaf window whose desired or
2518 current matrix is to be added to FRAME_MATRIX. W's flag
2519 must_be_updated_p determines which matrix it contributes to
2520 FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix
2521 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2522 Adding a desired matrix means setting up used counters and such in
2523 frame rows, while adding a current window matrix to FRAME_MATRIX
2524 means copying glyphs. The latter case corresponds to
2525 preserve_other_columns in the old redisplay. */
2528 build_frame_matrix_from_leaf_window (struct glyph_matrix
*frame_matrix
, struct window
*w
)
2530 struct glyph_matrix
*window_matrix
;
2531 int window_y
, frame_y
;
2532 /* If non-zero, a glyph to insert at the right border of W. */
2533 GLYPH right_border_glyph
;
2535 SET_GLYPH_FROM_CHAR (right_border_glyph
, 0);
2537 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2538 if (w
->must_be_updated_p
)
2540 window_matrix
= w
->desired_matrix
;
2542 /* Decide whether we want to add a vertical border glyph. */
2543 if (!WINDOW_RIGHTMOST_P (w
))
2545 struct Lisp_Char_Table
*dp
= window_display_table (w
);
2548 SET_GLYPH_FROM_CHAR (right_border_glyph
, '|');
2550 && (gc
= DISP_BORDER_GLYPH (dp
), GLYPH_CODE_P (gc
)))
2552 SET_GLYPH_FROM_GLYPH_CODE (right_border_glyph
, gc
);
2553 spec_glyph_lookup_face (w
, &right_border_glyph
);
2556 if (GLYPH_FACE (right_border_glyph
) <= 0)
2557 SET_GLYPH_FACE (right_border_glyph
, VERTICAL_BORDER_FACE_ID
);
2561 window_matrix
= w
->current_matrix
;
2563 /* For all rows in the window matrix and corresponding rows in the
2566 frame_y
= window_matrix
->matrix_y
;
2567 while (window_y
< window_matrix
->nrows
)
2569 struct glyph_row
*frame_row
= frame_matrix
->rows
+ frame_y
;
2570 struct glyph_row
*window_row
= window_matrix
->rows
+ window_y
;
2571 int current_row_p
= window_matrix
== w
->current_matrix
;
2573 /* Fill up the frame row with spaces up to the left margin of the
2575 fill_up_frame_row_with_spaces (frame_row
, window_matrix
->matrix_x
);
2577 /* Fill up areas in the window matrix row with spaces. */
2578 fill_up_glyph_row_with_spaces (window_row
);
2580 /* If only part of W's desired matrix has been built, and
2581 window_row wasn't displayed, use the corresponding current
2583 if (window_matrix
== w
->desired_matrix
2584 && !window_row
->enabled_p
)
2586 window_row
= w
->current_matrix
->rows
+ window_y
;
2592 /* Copy window row to frame row. */
2593 memcpy (frame_row
->glyphs
[TEXT_AREA
] + window_matrix
->matrix_x
,
2594 window_row
->glyphs
[0],
2595 window_matrix
->matrix_w
* sizeof (struct glyph
));
2599 xassert (window_row
->enabled_p
);
2601 /* Only when a desired row has been displayed, we want
2602 the corresponding frame row to be updated. */
2603 frame_row
->enabled_p
= 1;
2605 /* Maybe insert a vertical border between horizontally adjacent
2607 if (GLYPH_CHAR (right_border_glyph
) != 0)
2609 struct glyph
*border
= window_row
->glyphs
[LAST_AREA
] - 1;
2610 SET_CHAR_GLYPH_FROM_GLYPH (*border
, right_border_glyph
);
2614 /* Window row window_y must be a slice of frame row
2616 xassert (glyph_row_slice_p (window_row
, frame_row
));
2618 /* If rows are in sync, we don't have to copy glyphs because
2619 frame and window share glyphs. */
2621 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
2622 add_window_display_history (w
, w
->current_matrix
->method
, 0);
2626 /* Set number of used glyphs in the frame matrix. Since we fill
2627 up with spaces, and visit leaf windows from left to right it
2628 can be done simply. */
2629 frame_row
->used
[TEXT_AREA
]
2630 = window_matrix
->matrix_x
+ window_matrix
->matrix_w
;
2638 /* Given a user-specified glyph, possibly including a Lisp-level face
2639 ID, return a glyph that has a realized face ID.
2640 This is used for glyphs displayed specially and not part of the text;
2641 for instance, vertical separators, truncation markers, etc. */
2644 spec_glyph_lookup_face (struct window
*w
, GLYPH
*glyph
)
2646 int lface_id
= GLYPH_FACE (*glyph
);
2647 /* Convert the glyph's specified face to a realized (cache) face. */
2650 int face_id
= merge_faces (XFRAME (w
->frame
),
2651 Qt
, lface_id
, DEFAULT_FACE_ID
);
2652 SET_GLYPH_FACE (*glyph
, face_id
);
2656 /* Add spaces to a glyph row ROW in a window matrix.
2658 Each row has the form:
2660 +---------+-----------------------------+------------+
2661 | left | text | right |
2662 +---------+-----------------------------+------------+
2664 Left and right marginal areas are optional. This function adds
2665 spaces to areas so that there are no empty holes between areas.
2666 In other words: If the right area is not empty, the text area
2667 is filled up with spaces up to the right area. If the text area
2668 is not empty, the left area is filled up.
2670 To be called for frame-based redisplay, only. */
2673 fill_up_glyph_row_with_spaces (struct glyph_row
*row
)
2675 fill_up_glyph_row_area_with_spaces (row
, LEFT_MARGIN_AREA
);
2676 fill_up_glyph_row_area_with_spaces (row
, TEXT_AREA
);
2677 fill_up_glyph_row_area_with_spaces (row
, RIGHT_MARGIN_AREA
);
2681 /* Fill area AREA of glyph row ROW with spaces. To be called for
2682 frame-based redisplay only. */
2685 fill_up_glyph_row_area_with_spaces (struct glyph_row
*row
, int area
)
2687 if (row
->glyphs
[area
] < row
->glyphs
[area
+ 1])
2689 struct glyph
*end
= row
->glyphs
[area
+ 1];
2690 struct glyph
*text
= row
->glyphs
[area
] + row
->used
[area
];
2693 *text
++ = space_glyph
;
2694 row
->used
[area
] = text
- row
->glyphs
[area
];
2699 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2700 reached. In frame matrices only one area, TEXT_AREA, is used. */
2703 fill_up_frame_row_with_spaces (struct glyph_row
*row
, int upto
)
2705 int i
= row
->used
[TEXT_AREA
];
2706 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
2709 glyph
[i
++] = space_glyph
;
2711 row
->used
[TEXT_AREA
] = i
;
2716 /**********************************************************************
2717 Mirroring operations on frame matrices in window matrices
2718 **********************************************************************/
2720 /* Set frame being updated via frame-based redisplay to F. This
2721 function must be called before updates to make explicit that we are
2722 working on frame matrices or not. */
2725 set_frame_matrix_frame (struct frame
*f
)
2727 frame_matrix_frame
= f
;
2731 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2732 DESIRED_MATRIX is the desired matrix corresponding to
2733 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2734 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2735 frame_matrix_frame is non-null, this indicates that the exchange is
2736 done in frame matrices, and that we have to perform analogous
2737 operations in window matrices of frame_matrix_frame. */
2740 make_current (struct glyph_matrix
*desired_matrix
, struct glyph_matrix
*current_matrix
, int row
)
2742 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, row
);
2743 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, row
);
2744 int mouse_face_p
= current_row
->mouse_face_p
;
2746 /* Do current_row = desired_row. This exchanges glyph pointers
2747 between both rows, and does a structure assignment otherwise. */
2748 assign_row (current_row
, desired_row
);
2750 /* Enable current_row to mark it as valid. */
2751 current_row
->enabled_p
= 1;
2752 current_row
->mouse_face_p
= mouse_face_p
;
2754 /* If we are called on frame matrices, perform analogous operations
2755 for window matrices. */
2756 if (frame_matrix_frame
)
2757 mirror_make_current (XWINDOW (frame_matrix_frame
->root_window
), row
);
2761 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2762 W's frame which has been made current (by swapping pointers between
2763 current and desired matrix). Perform analogous operations in the
2764 matrices of leaf windows in the window tree rooted at W. */
2767 mirror_make_current (struct window
*w
, int frame_row
)
2771 if (!NILP (w
->hchild
))
2772 mirror_make_current (XWINDOW (w
->hchild
), frame_row
);
2773 else if (!NILP (w
->vchild
))
2774 mirror_make_current (XWINDOW (w
->vchild
), frame_row
);
2777 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2778 here because the checks performed in debug mode there
2779 will not allow the conversion. */
2780 int row
= frame_row
- w
->desired_matrix
->matrix_y
;
2782 /* If FRAME_ROW is within W, assign the desired row to the
2783 current row (exchanging glyph pointers). */
2784 if (row
>= 0 && row
< w
->desired_matrix
->matrix_h
)
2786 struct glyph_row
*current_row
2787 = MATRIX_ROW (w
->current_matrix
, row
);
2788 struct glyph_row
*desired_row
2789 = MATRIX_ROW (w
->desired_matrix
, row
);
2791 if (desired_row
->enabled_p
)
2792 assign_row (current_row
, desired_row
);
2794 swap_glyph_pointers (desired_row
, current_row
);
2795 current_row
->enabled_p
= 1;
2797 /* Set the Y coordinate of the mode/header line's row.
2798 It is needed in draw_row_with_mouse_face to find the
2799 screen coordinates. (Window-based redisplay sets
2800 this in update_window, but no one seems to do that
2801 for frame-based redisplay.) */
2802 if (current_row
->mode_line_p
)
2803 current_row
->y
= row
;
2807 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2812 /* Perform row dance after scrolling. We are working on the range of
2813 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2814 including) in MATRIX. COPY_FROM is a vector containing, for each
2815 row I in the range 0 <= I < NLINES, the index of the original line
2816 to move to I. This index is relative to the row range, i.e. 0 <=
2817 index < NLINES. RETAINED_P is a vector containing zero for each
2818 row 0 <= I < NLINES which is empty.
2820 This function is called from do_scrolling and do_direct_scrolling. */
2823 mirrored_line_dance (struct glyph_matrix
*matrix
, int unchanged_at_top
, int nlines
,
2824 int *copy_from
, char *retained_p
)
2826 /* A copy of original rows. */
2827 struct glyph_row
*old_rows
;
2829 /* Rows to assign to. */
2830 struct glyph_row
*new_rows
= MATRIX_ROW (matrix
, unchanged_at_top
);
2834 /* Make a copy of the original rows. */
2835 old_rows
= (struct glyph_row
*) alloca (nlines
* sizeof *old_rows
);
2836 memcpy (old_rows
, new_rows
, nlines
* sizeof *old_rows
);
2838 /* Assign new rows, maybe clear lines. */
2839 for (i
= 0; i
< nlines
; ++i
)
2841 int enabled_before_p
= new_rows
[i
].enabled_p
;
2843 xassert (i
+ unchanged_at_top
< matrix
->nrows
);
2844 xassert (unchanged_at_top
+ copy_from
[i
] < matrix
->nrows
);
2845 new_rows
[i
] = old_rows
[copy_from
[i
]];
2846 new_rows
[i
].enabled_p
= enabled_before_p
;
2848 /* RETAINED_P is zero for empty lines. */
2849 if (!retained_p
[copy_from
[i
]])
2850 new_rows
[i
].enabled_p
= 0;
2853 /* Do the same for window matrices, if MATRIX is a frame matrix. */
2854 if (frame_matrix_frame
)
2855 mirror_line_dance (XWINDOW (frame_matrix_frame
->root_window
),
2856 unchanged_at_top
, nlines
, copy_from
, retained_p
);
2860 /* Synchronize glyph pointers in the current matrix of window W with
2861 the current frame matrix. */
2864 sync_window_with_frame_matrix_rows (struct window
*w
)
2866 struct frame
*f
= XFRAME (w
->frame
);
2867 struct glyph_row
*window_row
, *window_row_end
, *frame_row
;
2868 int left
, right
, x
, width
;
2870 /* Preconditions: W must be a leaf window on a tty frame. */
2871 xassert (NILP (w
->hchild
) && NILP (w
->vchild
));
2872 xassert (!FRAME_WINDOW_P (f
));
2874 left
= margin_glyphs_to_reserve (w
, 1, w
->left_margin_cols
);
2875 right
= margin_glyphs_to_reserve (w
, 1, w
->right_margin_cols
);
2876 x
= w
->current_matrix
->matrix_x
;
2877 width
= w
->current_matrix
->matrix_w
;
2879 window_row
= w
->current_matrix
->rows
;
2880 window_row_end
= window_row
+ w
->current_matrix
->nrows
;
2881 frame_row
= f
->current_matrix
->rows
+ WINDOW_TOP_EDGE_LINE (w
);
2883 for (; window_row
< window_row_end
; ++window_row
, ++frame_row
)
2885 window_row
->glyphs
[LEFT_MARGIN_AREA
]
2886 = frame_row
->glyphs
[0] + x
;
2887 window_row
->glyphs
[TEXT_AREA
]
2888 = window_row
->glyphs
[LEFT_MARGIN_AREA
] + left
;
2889 window_row
->glyphs
[LAST_AREA
]
2890 = window_row
->glyphs
[LEFT_MARGIN_AREA
] + width
;
2891 window_row
->glyphs
[RIGHT_MARGIN_AREA
]
2892 = window_row
->glyphs
[LAST_AREA
] - right
;
2897 /* Return the window in the window tree rooted in W containing frame
2898 row ROW. Value is null if none is found. */
2900 static struct window
*
2901 frame_row_to_window (struct window
*w
, int row
)
2903 struct window
*found
= NULL
;
2907 if (!NILP (w
->hchild
))
2908 found
= frame_row_to_window (XWINDOW (w
->hchild
), row
);
2909 else if (!NILP (w
->vchild
))
2910 found
= frame_row_to_window (XWINDOW (w
->vchild
), row
);
2911 else if (row
>= WINDOW_TOP_EDGE_LINE (w
)
2912 && row
< WINDOW_BOTTOM_EDGE_LINE (w
))
2915 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
2922 /* Perform a line dance in the window tree rooted at W, after
2923 scrolling a frame matrix in mirrored_line_dance.
2925 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
2926 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
2927 COPY_FROM is a vector containing, for each row I in the range 0 <=
2928 I < NLINES, the index of the original line to move to I. This
2929 index is relative to the row range, i.e. 0 <= index < NLINES.
2930 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
2934 mirror_line_dance (struct window
*w
, int unchanged_at_top
, int nlines
, int *copy_from
, char *retained_p
)
2938 if (!NILP (w
->hchild
))
2939 mirror_line_dance (XWINDOW (w
->hchild
), unchanged_at_top
,
2940 nlines
, copy_from
, retained_p
);
2941 else if (!NILP (w
->vchild
))
2942 mirror_line_dance (XWINDOW (w
->vchild
), unchanged_at_top
,
2943 nlines
, copy_from
, retained_p
);
2946 /* W is a leaf window, and we are working on its current
2948 struct glyph_matrix
*m
= w
->current_matrix
;
2950 struct glyph_row
*old_rows
;
2952 /* Make a copy of the original rows of matrix m. */
2953 old_rows
= (struct glyph_row
*) alloca (m
->nrows
* sizeof *old_rows
);
2954 memcpy (old_rows
, m
->rows
, m
->nrows
* sizeof *old_rows
);
2956 for (i
= 0; i
< nlines
; ++i
)
2958 /* Frame relative line assigned to. */
2959 int frame_to
= i
+ unchanged_at_top
;
2961 /* Frame relative line assigned. */
2962 int frame_from
= copy_from
[i
] + unchanged_at_top
;
2964 /* Window relative line assigned to. */
2965 int window_to
= frame_to
- m
->matrix_y
;
2967 /* Window relative line assigned. */
2968 int window_from
= frame_from
- m
->matrix_y
;
2970 /* Is assigned line inside window? */
2971 int from_inside_window_p
2972 = window_from
>= 0 && window_from
< m
->matrix_h
;
2974 /* Is assigned to line inside window? */
2975 int to_inside_window_p
2976 = window_to
>= 0 && window_to
< m
->matrix_h
;
2978 if (from_inside_window_p
&& to_inside_window_p
)
2980 /* Enabled setting before assignment. */
2981 int enabled_before_p
;
2983 /* Do the assignment. The enabled_p flag is saved
2984 over the assignment because the old redisplay did
2986 enabled_before_p
= m
->rows
[window_to
].enabled_p
;
2987 m
->rows
[window_to
] = old_rows
[window_from
];
2988 m
->rows
[window_to
].enabled_p
= enabled_before_p
;
2990 /* If frame line is empty, window line is empty, too. */
2991 if (!retained_p
[copy_from
[i
]])
2992 m
->rows
[window_to
].enabled_p
= 0;
2994 else if (to_inside_window_p
)
2996 /* A copy between windows. This is an infrequent
2997 case not worth optimizing. */
2998 struct frame
*f
= XFRAME (w
->frame
);
2999 struct window
*root
= XWINDOW (FRAME_ROOT_WINDOW (f
));
3001 struct glyph_matrix
*m2
;
3004 w2
= frame_row_to_window (root
, frame_from
);
3005 /* ttn@surf.glug.org: when enabling menu bar using `emacs
3006 -nw', FROM_FRAME sometimes has no associated window.
3007 This check avoids a segfault if W2 is null. */
3010 m2
= w2
->current_matrix
;
3011 m2_from
= frame_from
- m2
->matrix_y
;
3012 copy_row_except_pointers (m
->rows
+ window_to
,
3013 m2
->rows
+ m2_from
);
3015 /* If frame line is empty, window line is empty, too. */
3016 if (!retained_p
[copy_from
[i
]])
3017 m
->rows
[window_to
].enabled_p
= 0;
3021 else if (from_inside_window_p
)
3025 /* If there was a copy between windows, make sure glyph
3026 pointers are in sync with the frame matrix. */
3028 sync_window_with_frame_matrix_rows (w
);
3030 /* Check that no pointers are lost. */
3034 /* Next window on same level. */
3035 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3042 /* Check that window and frame matrices agree about their
3043 understanding where glyphs of the rows are to find. For each
3044 window in the window tree rooted at W, check that rows in the
3045 matrices of leaf window agree with their frame matrices about
3049 check_window_matrix_pointers (struct window
*w
)
3053 if (!NILP (w
->hchild
))
3054 check_window_matrix_pointers (XWINDOW (w
->hchild
));
3055 else if (!NILP (w
->vchild
))
3056 check_window_matrix_pointers (XWINDOW (w
->vchild
));
3059 struct frame
*f
= XFRAME (w
->frame
);
3060 check_matrix_pointers (w
->desired_matrix
, f
->desired_matrix
);
3061 check_matrix_pointers (w
->current_matrix
, f
->current_matrix
);
3064 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3069 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
3070 a window and FRAME_MATRIX is the corresponding frame matrix. For
3071 each row in WINDOW_MATRIX check that it's a slice of the
3072 corresponding frame row. If it isn't, abort. */
3075 check_matrix_pointers (struct glyph_matrix
*window_matrix
,
3076 struct glyph_matrix
*frame_matrix
)
3078 /* Row number in WINDOW_MATRIX. */
3081 /* Row number corresponding to I in FRAME_MATRIX. */
3082 int j
= window_matrix
->matrix_y
;
3084 /* For all rows check that the row in the window matrix is a
3085 slice of the row in the frame matrix. If it isn't we didn't
3086 mirror an operation on the frame matrix correctly. */
3087 while (i
< window_matrix
->nrows
)
3089 if (!glyph_row_slice_p (window_matrix
->rows
+ i
,
3090 frame_matrix
->rows
+ j
))
3096 #endif /* GLYPH_DEBUG != 0 */
3100 /**********************************************************************
3101 VPOS and HPOS translations
3102 **********************************************************************/
3106 /* Translate vertical position VPOS which is relative to window W to a
3107 vertical position relative to W's frame. */
3110 window_to_frame_vpos (struct window
*w
, int vpos
)
3112 xassert (!FRAME_WINDOW_P (XFRAME (w
->frame
)));
3113 xassert (vpos
>= 0 && vpos
<= w
->desired_matrix
->nrows
);
3114 vpos
+= WINDOW_TOP_EDGE_LINE (w
);
3115 xassert (vpos
>= 0 && vpos
<= FRAME_LINES (XFRAME (w
->frame
)));
3120 /* Translate horizontal position HPOS which is relative to window W to
3121 a horizontal position relative to W's frame. */
3124 window_to_frame_hpos (struct window
*w
, int hpos
)
3126 xassert (!FRAME_WINDOW_P (XFRAME (w
->frame
)));
3127 hpos
+= WINDOW_LEFT_EDGE_COL (w
);
3131 #endif /* GLYPH_DEBUG */
3135 /**********************************************************************
3137 **********************************************************************/
3139 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
3140 doc
: /* Clear frame FRAME and output again what is supposed to appear on it. */)
3145 CHECK_LIVE_FRAME (frame
);
3148 /* Ignore redraw requests, if frame has no glyphs yet.
3149 (Implementation note: It still has to be checked why we are
3150 called so early here). */
3151 if (!glyphs_initialized_initially_p
)
3156 if (FRAME_MSDOS_P (f
))
3157 FRAME_TERMINAL (f
)->set_terminal_modes_hook (FRAME_TERMINAL (f
));
3160 clear_current_matrices (f
);
3162 if (FRAME_TERMCAP_P (f
))
3163 fflush (FRAME_TTY (f
)->output
);
3164 windows_or_buffers_changed
++;
3165 /* Mark all windows as inaccurate, so that every window will have
3166 its redisplay done. */
3167 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
3168 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f
)), 1);
3174 /* Redraw frame F. This is nothing more than a call to the Lisp
3175 function redraw-frame. */
3178 redraw_frame (struct frame
*f
)
3181 XSETFRAME (frame
, f
);
3182 Fredraw_frame (frame
);
3186 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
3187 doc
: /* Clear and redisplay all visible frames. */)
3190 Lisp_Object tail
, frame
;
3192 FOR_EACH_FRAME (tail
, frame
)
3193 if (FRAME_VISIBLE_P (XFRAME (frame
)))
3194 Fredraw_frame (frame
);
3201 /***********************************************************************
3203 ***********************************************************************/
3205 /* Update frame F based on the data in desired matrices.
3207 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3208 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3211 Value is non-zero if redisplay was stopped due to pending input. */
3214 update_frame (struct frame
*f
, int force_p
, int inhibit_hairy_id_p
)
3216 /* 1 means display has been paused because of pending input. */
3218 struct window
*root_window
= XWINDOW (f
->root_window
);
3220 if (redisplay_dont_pause
)
3222 #if PERIODIC_PREEMPTION_CHECKING
3223 else if (NILP (Vredisplay_preemption_period
))
3225 else if (!force_p
&& NUMBERP (Vredisplay_preemption_period
))
3228 double p
= XFLOATINT (Vredisplay_preemption_period
);
3231 if (detect_input_pending_ignore_squeezables ())
3238 usec
= (p
- sec
) * 1000000;
3240 EMACS_GET_TIME (tm
);
3241 EMACS_SET_SECS_USECS (preemption_period
, sec
, usec
);
3242 EMACS_ADD_TIME (preemption_next_check
, tm
, preemption_period
);
3246 if (FRAME_WINDOW_P (f
))
3248 /* We are working on window matrix basis. All windows whose
3249 flag must_be_updated_p is set have to be updated. */
3251 /* Record that we are not working on frame matrices. */
3252 set_frame_matrix_frame (NULL
);
3254 /* Update all windows in the window tree of F, maybe stopping
3255 when pending input is detected. */
3258 /* Update the menu bar on X frames that don't have toolkit
3260 if (WINDOWP (f
->menu_bar_window
))
3261 update_window (XWINDOW (f
->menu_bar_window
), 1);
3263 /* Update the tool-bar window, if present. */
3264 if (WINDOWP (f
->tool_bar_window
))
3266 struct window
*w
= XWINDOW (f
->tool_bar_window
);
3268 /* Update tool-bar window. */
3269 if (w
->must_be_updated_p
)
3273 update_window (w
, 1);
3274 w
->must_be_updated_p
= 0;
3276 /* Swap tool-bar strings. We swap because we want to
3278 tem
= f
->current_tool_bar_string
;
3279 f
->current_tool_bar_string
= f
->desired_tool_bar_string
;
3280 f
->desired_tool_bar_string
= tem
;
3285 /* Update windows. */
3286 paused_p
= update_window_tree (root_window
, force_p
);
3289 /* This flush is a performance bottleneck under X,
3290 and it doesn't seem to be necessary anyway (in general).
3291 It is necessary when resizing the window with the mouse, or
3292 at least the fringes are not redrawn in a timely manner. ++kfs */
3293 if (f
->force_flush_display_p
)
3295 FRAME_RIF (f
)->flush_display (f
);
3296 f
->force_flush_display_p
= 0;
3301 /* We are working on frame matrix basis. Set the frame on whose
3302 frame matrix we operate. */
3303 set_frame_matrix_frame (f
);
3305 /* Build F's desired matrix from window matrices. */
3306 build_frame_matrix (f
);
3308 /* Update the display */
3310 paused_p
= update_frame_1 (f
, force_p
, inhibit_hairy_id_p
);
3313 if (FRAME_TERMCAP_P (f
) || FRAME_MSDOS_P (f
))
3315 if (FRAME_TTY (f
)->termscript
)
3316 fflush (FRAME_TTY (f
)->termscript
);
3317 if (FRAME_TERMCAP_P (f
))
3318 fflush (FRAME_TTY (f
)->output
);
3321 /* Check window matrices for lost pointers. */
3323 check_window_matrix_pointers (root_window
);
3324 add_frame_display_history (f
, paused_p
);
3328 #if PERIODIC_PREEMPTION_CHECKING
3331 /* Reset flags indicating that a window should be updated. */
3332 set_window_update_flags (root_window
, 0);
3334 display_completed
= !paused_p
;
3340 /************************************************************************
3341 Window-based updates
3342 ************************************************************************/
3344 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3345 don't stop updating when input is pending. */
3348 update_window_tree (struct window
*w
, int force_p
)
3352 while (w
&& !paused_p
)
3354 if (!NILP (w
->hchild
))
3355 paused_p
|= update_window_tree (XWINDOW (w
->hchild
), force_p
);
3356 else if (!NILP (w
->vchild
))
3357 paused_p
|= update_window_tree (XWINDOW (w
->vchild
), force_p
);
3358 else if (w
->must_be_updated_p
)
3359 paused_p
|= update_window (w
, force_p
);
3361 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
3368 /* Update window W if its flag must_be_updated_p is non-zero. If
3369 FORCE_P is non-zero, don't stop updating if input is pending. */
3372 update_single_window (struct window
*w
, int force_p
)
3374 if (w
->must_be_updated_p
)
3376 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3378 /* Record that this is not a frame-based redisplay. */
3379 set_frame_matrix_frame (NULL
);
3381 if (redisplay_dont_pause
)
3383 #if PERIODIC_PREEMPTION_CHECKING
3384 else if (NILP (Vredisplay_preemption_period
))
3386 else if (!force_p
&& NUMBERP (Vredisplay_preemption_period
))
3389 double p
= XFLOATINT (Vredisplay_preemption_period
);
3393 usec
= (p
- sec
) * 1000000;
3395 EMACS_GET_TIME (tm
);
3396 EMACS_SET_SECS_USECS (preemption_period
, sec
, usec
);
3397 EMACS_ADD_TIME (preemption_next_check
, tm
, preemption_period
);
3403 update_window (w
, force_p
);
3406 /* Reset flag in W. */
3407 w
->must_be_updated_p
= 0;
3411 #ifdef HAVE_WINDOW_SYSTEM
3413 /* Redraw lines from the current matrix of window W that are
3414 overlapped by other rows. YB is bottom-most y-position in W. */
3417 redraw_overlapped_rows (struct window
*w
, int yb
)
3420 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3422 /* If rows overlapping others have been changed, the rows being
3423 overlapped have to be redrawn. This won't draw lines that have
3424 already been drawn in update_window_line because overlapped_p in
3425 desired rows is 0, so after row assignment overlapped_p in
3426 current rows is 0. */
3427 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3429 struct glyph_row
*row
= w
->current_matrix
->rows
+ i
;
3431 if (!row
->enabled_p
)
3433 else if (row
->mode_line_p
)
3436 if (row
->overlapped_p
)
3438 enum glyph_row_area area
;
3440 for (area
= LEFT_MARGIN_AREA
; area
< LAST_AREA
; ++area
)
3443 updated_area
= area
;
3444 FRAME_RIF (f
)->cursor_to (i
, 0, row
->y
,
3445 area
== TEXT_AREA
? row
->x
: 0);
3446 if (row
->used
[area
])
3447 FRAME_RIF (f
)->write_glyphs (row
->glyphs
[area
],
3449 FRAME_RIF (f
)->clear_end_of_line (-1);
3452 row
->overlapped_p
= 0;
3455 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3461 /* Redraw lines from the current matrix of window W that overlap
3462 others. YB is bottom-most y-position in W. */
3465 redraw_overlapping_rows (struct window
*w
, int yb
)
3468 struct glyph_row
*row
;
3469 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
3471 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
3473 row
= w
->current_matrix
->rows
+ i
;
3475 if (!row
->enabled_p
)
3477 else if (row
->mode_line_p
)
3480 bottom_y
= MATRIX_ROW_BOTTOM_Y (row
);
3482 if (row
->overlapping_p
)
3486 if (MATRIX_ROW_OVERLAPS_PRED_P (row
) && i
> 0
3487 && !MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
)
3488 overlaps
|= OVERLAPS_PRED
;
3489 if (MATRIX_ROW_OVERLAPS_SUCC_P (row
) && bottom_y
< yb
3490 && !MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
)
3491 overlaps
|= OVERLAPS_SUCC
;
3495 if (row
->used
[LEFT_MARGIN_AREA
])
3496 rif
->fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
, overlaps
);
3498 if (row
->used
[TEXT_AREA
])
3499 rif
->fix_overlapping_area (w
, row
, TEXT_AREA
, overlaps
);
3501 if (row
->used
[RIGHT_MARGIN_AREA
])
3502 rif
->fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
, overlaps
);
3504 /* Record in neighbor rows that ROW overwrites part of
3506 if (overlaps
& OVERLAPS_PRED
)
3507 MATRIX_ROW (w
->current_matrix
, i
- 1)->overlapped_p
= 1;
3508 if (overlaps
& OVERLAPS_SUCC
)
3509 MATRIX_ROW (w
->current_matrix
, i
+ 1)->overlapped_p
= 1;
3518 #endif /* HAVE_WINDOW_SYSTEM */
3521 #if defined GLYPH_DEBUG && 0
3523 /* Check that no row in the current matrix of window W is enabled
3524 which is below what's displayed in the window. */
3527 check_current_matrix_flags (struct window
*w
)
3529 int last_seen_p
= 0;
3530 int i
, yb
= window_text_bottom_y (w
);
3532 for (i
= 0; i
< w
->current_matrix
->nrows
- 1; ++i
)
3534 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
3535 if (!last_seen_p
&& MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3537 else if (last_seen_p
&& row
->enabled_p
)
3542 #endif /* GLYPH_DEBUG */
3545 /* Update display of window W. FORCE_P non-zero means that we should
3546 not stop when detecting pending input. */
3549 update_window (struct window
*w
, int force_p
)
3551 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
3553 #if !PERIODIC_PREEMPTION_CHECKING
3554 int preempt_count
= baud_rate
/ 2400 + 1;
3556 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
3558 /* Check that W's frame doesn't have glyph matrices. */
3559 xassert (FRAME_WINDOW_P (XFRAME (WINDOW_FRAME (w
))));
3562 /* Check pending input the first time so that we can quickly return. */
3563 #if !PERIODIC_PREEMPTION_CHECKING
3565 detect_input_pending_ignore_squeezables ();
3568 /* If forced to complete the update, or if no input is pending, do
3570 if (force_p
|| !input_pending
|| !NILP (do_mouse_tracking
))
3572 struct glyph_row
*row
, *end
;
3573 struct glyph_row
*mode_line_row
;
3574 struct glyph_row
*header_line_row
;
3575 int yb
, changed_p
= 0, mouse_face_overwritten_p
= 0;
3576 #if ! PERIODIC_PREEMPTION_CHECKING
3580 rif
->update_window_begin_hook (w
);
3581 yb
= window_text_bottom_y (w
);
3582 row
= desired_matrix
->rows
;
3583 end
= row
+ desired_matrix
->nrows
- 1;
3585 /* Take note of the header line, if there is one. We will
3586 update it below, after updating all of the window's lines. */
3587 if (row
->mode_line_p
)
3589 header_line_row
= row
;
3593 header_line_row
= NULL
;
3595 /* Update the mode line, if necessary. */
3596 mode_line_row
= MATRIX_MODE_LINE_ROW (desired_matrix
);
3597 if (mode_line_row
->mode_line_p
&& mode_line_row
->enabled_p
)
3599 mode_line_row
->y
= yb
;
3600 update_window_line (w
, MATRIX_ROW_VPOS (mode_line_row
,
3602 &mouse_face_overwritten_p
);
3605 /* Find first enabled row. Optimizations in redisplay_internal
3606 may lead to an update with only one row enabled. There may
3607 be also completely empty matrices. */
3608 while (row
< end
&& !row
->enabled_p
)
3611 /* Try reusing part of the display by copying. */
3612 if (row
< end
&& !desired_matrix
->no_scrolling_p
)
3614 int rc
= scrolling_window (w
, header_line_row
!= NULL
);
3617 /* All rows were found to be equal. */
3623 /* We've scrolled the display. */
3629 /* Update the rest of the lines. */
3630 for (; row
< end
&& (force_p
|| !input_pending
); ++row
)
3631 /* scrolling_window resets the enabled_p flag of the rows it
3632 reuses from current_matrix. */
3635 int vpos
= MATRIX_ROW_VPOS (row
, desired_matrix
);
3638 /* We'll have to play a little bit with when to
3639 detect_input_pending. If it's done too often,
3640 scrolling large windows with repeated scroll-up
3641 commands will too quickly pause redisplay. */
3642 #if PERIODIC_PREEMPTION_CHECKING
3646 EMACS_GET_TIME (tm
);
3647 EMACS_SUB_TIME (dif
, preemption_next_check
, tm
);
3648 if (EMACS_TIME_NEG_P (dif
))
3650 EMACS_ADD_TIME (preemption_next_check
, tm
, preemption_period
);
3651 if (detect_input_pending_ignore_squeezables ())
3656 if (!force_p
&& ++n_updated
% preempt_count
== 0)
3657 detect_input_pending_ignore_squeezables ();
3659 changed_p
|= update_window_line (w
, vpos
,
3660 &mouse_face_overwritten_p
);
3662 /* Mark all rows below the last visible one in the current
3663 matrix as invalid. This is necessary because of
3664 variable line heights. Consider the case of three
3665 successive redisplays, where the first displays 5
3666 lines, the second 3 lines, and the third 5 lines again.
3667 If the second redisplay wouldn't mark rows in the
3668 current matrix invalid, the third redisplay might be
3669 tempted to optimize redisplay based on lines displayed
3670 in the first redisplay. */
3671 if (MATRIX_ROW_BOTTOM_Y (row
) >= yb
)
3672 for (i
= vpos
+ 1; i
< w
->current_matrix
->nrows
- 1; ++i
)
3673 MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
= 0;
3676 /* Was display preempted? */
3677 paused_p
= row
< end
;
3681 /* Update the header line after scrolling because a new header
3682 line would otherwise overwrite lines at the top of the window
3683 that can be scrolled. */
3684 if (header_line_row
&& header_line_row
->enabled_p
)
3686 header_line_row
->y
= 0;
3687 update_window_line (w
, 0, &mouse_face_overwritten_p
);
3690 /* Fix the appearance of overlapping/overlapped rows. */
3691 if (!paused_p
&& !w
->pseudo_window_p
)
3693 #ifdef HAVE_WINDOW_SYSTEM
3694 if (changed_p
&& rif
->fix_overlapping_area
)
3696 redraw_overlapped_rows (w
, yb
);
3697 redraw_overlapping_rows (w
, yb
);
3701 /* Make cursor visible at cursor position of W. */
3702 set_window_cursor_after_update (w
);
3704 #if 0 /* Check that current matrix invariants are satisfied. This is
3705 for debugging only. See the comment of check_matrix_invariants. */
3706 IF_DEBUG (check_matrix_invariants (w
));
3711 /* Remember the redisplay method used to display the matrix. */
3712 strcpy (w
->current_matrix
->method
, w
->desired_matrix
->method
);
3715 #ifdef HAVE_WINDOW_SYSTEM
3716 update_window_fringes (w
, 0);
3719 /* End the update of window W. Don't set the cursor if we
3720 paused updating the display because in this case,
3721 set_window_cursor_after_update hasn't been called, and
3722 output_cursor doesn't contain the cursor location. */
3723 rif
->update_window_end_hook (w
, !paused_p
, mouse_face_overwritten_p
);
3729 /* check_current_matrix_flags (w); */
3730 add_window_display_history (w
, w
->current_matrix
->method
, paused_p
);
3733 clear_glyph_matrix (desired_matrix
);
3739 /* Update the display of area AREA in window W, row number VPOS.
3740 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
3743 update_marginal_area (struct window
*w
, int area
, int vpos
)
3745 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3746 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
3748 /* Let functions in xterm.c know what area subsequent X positions
3749 will be relative to. */
3750 updated_area
= area
;
3752 /* Set cursor to start of glyphs, write them, and clear to the end
3753 of the area. I don't think that something more sophisticated is
3754 necessary here, since marginal areas will not be the default. */
3755 rif
->cursor_to (vpos
, 0, desired_row
->y
, 0);
3756 if (desired_row
->used
[area
])
3757 rif
->write_glyphs (desired_row
->glyphs
[area
], desired_row
->used
[area
]);
3758 rif
->clear_end_of_line (-1);
3762 /* Update the display of the text area of row VPOS in window W.
3763 Value is non-zero if display has changed. */
3766 update_text_area (struct window
*w
, int vpos
)
3768 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
3769 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
3770 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
3773 /* Let functions in xterm.c know what area subsequent X positions
3774 will be relative to. */
3775 updated_area
= TEXT_AREA
;
3777 /* If rows are at different X or Y, or rows have different height,
3778 or the current row is marked invalid, write the entire line. */
3779 if (!current_row
->enabled_p
3780 || desired_row
->y
!= current_row
->y
3781 || desired_row
->ascent
!= current_row
->ascent
3782 || desired_row
->phys_ascent
!= current_row
->phys_ascent
3783 || desired_row
->phys_height
!= current_row
->phys_height
3784 || desired_row
->visible_height
!= current_row
->visible_height
3785 || current_row
->overlapped_p
3786 /* This next line is necessary for correctly redrawing
3787 mouse-face areas after scrolling and other operations.
3788 However, it causes excessive flickering when mouse is moved
3789 across the mode line. Luckily, turning it off for the mode
3790 line doesn't seem to hurt anything. -- cyd.
3791 But it is still needed for the header line. -- kfs. */
3792 || (current_row
->mouse_face_p
3793 && !(current_row
->mode_line_p
&& vpos
> 0))
3794 || current_row
->x
!= desired_row
->x
)
3796 rif
->cursor_to (vpos
, 0, desired_row
->y
, desired_row
->x
);
3798 if (desired_row
->used
[TEXT_AREA
])
3799 rif
->write_glyphs (desired_row
->glyphs
[TEXT_AREA
],
3800 desired_row
->used
[TEXT_AREA
]);
3802 /* Clear to end of window. */
3803 rif
->clear_end_of_line (-1);
3806 /* This erases the cursor. We do this here because
3807 notice_overwritten_cursor cannot easily check this, which
3808 might indicate that the whole functionality of
3809 notice_overwritten_cursor would better be implemented here.
3810 On the other hand, we need notice_overwritten_cursor as long
3811 as mouse highlighting is done asynchronously outside of
3813 if (vpos
== w
->phys_cursor
.vpos
)
3814 w
->phys_cursor_on_p
= 0;
3819 struct glyph
*current_glyph
= current_row
->glyphs
[TEXT_AREA
];
3820 struct glyph
*desired_glyph
= desired_row
->glyphs
[TEXT_AREA
];
3821 int overlapping_glyphs_p
= current_row
->contains_overlapping_glyphs_p
;
3822 int desired_stop_pos
= desired_row
->used
[TEXT_AREA
];
3823 int abort_skipping
= 0;
3825 /* If the desired row extends its face to the text area end, and
3826 unless the current row also does so at the same position,
3827 make sure we write at least one glyph, so that the face
3828 extension actually takes place. */
3829 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
)
3830 && (desired_stop_pos
< current_row
->used
[TEXT_AREA
]
3831 || (desired_stop_pos
== current_row
->used
[TEXT_AREA
]
3832 && !MATRIX_ROW_EXTENDS_FACE_P (current_row
))))
3835 stop
= min (current_row
->used
[TEXT_AREA
], desired_stop_pos
);
3839 /* Loop over glyphs that current and desired row may have
3843 int can_skip_p
= !abort_skipping
;
3845 /* Skip over glyphs that both rows have in common. These
3846 don't have to be written. We can't skip if the last
3847 current glyph overlaps the glyph to its right. For
3848 example, consider a current row of `if ' with the `f' in
3849 Courier bold so that it overlaps the ` ' to its right.
3850 If the desired row is ` ', we would skip over the space
3851 after the `if' and there would remain a pixel from the
3852 `f' on the screen. */
3853 if (overlapping_glyphs_p
&& i
> 0)
3855 struct glyph
*glyph
= ¤t_row
->glyphs
[TEXT_AREA
][i
- 1];
3858 rif
->get_glyph_overhangs (glyph
, XFRAME (w
->frame
),
3860 can_skip_p
= (right
== 0 && !abort_skipping
);
3868 && GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3870 x
+= desired_glyph
->pixel_width
;
3871 ++desired_glyph
, ++current_glyph
, ++i
;
3874 /* Consider the case that the current row contains "xxx
3875 ppp ggg" in italic Courier font, and the desired row
3876 is "xxx ggg". The character `p' has lbearing, `g'
3877 has not. The loop above will stop in front of the
3878 first `p' in the current row. If we would start
3879 writing glyphs there, we wouldn't erase the lbearing
3880 of the `p'. The rest of the lbearing problem is then
3881 taken care of by draw_glyphs. */
3882 if (overlapping_glyphs_p
3884 && i
< current_row
->used
[TEXT_AREA
]
3885 && (current_row
->used
[TEXT_AREA
]
3886 != desired_row
->used
[TEXT_AREA
]))
3890 rif
->get_glyph_overhangs (current_glyph
, XFRAME (w
->frame
),
3892 while (left
> 0 && i
> 0)
3894 --i
, --desired_glyph
, --current_glyph
;
3895 x
-= desired_glyph
->pixel_width
;
3896 left
-= desired_glyph
->pixel_width
;
3899 /* Abort the skipping algorithm if we end up before
3900 our starting point, to avoid looping (bug#1070).
3901 This can happen when the lbearing is larger than
3903 abort_skipping
= (i
< start_hpos
);
3907 /* Try to avoid writing the entire rest of the desired row
3908 by looking for a resync point. This mainly prevents
3909 mode line flickering in the case the mode line is in
3910 fixed-pitch font, which it usually will be. */
3911 if (i
< desired_row
->used
[TEXT_AREA
])
3913 int start_x
= x
, start_hpos
= i
;
3914 struct glyph
*start
= desired_glyph
;
3916 int skip_first_p
= !can_skip_p
;
3918 /* Find the next glyph that's equal again. */
3921 || !GLYPH_EQUAL_P (desired_glyph
, current_glyph
))
3924 x
+= desired_glyph
->pixel_width
;
3925 current_x
+= current_glyph
->pixel_width
;
3926 ++desired_glyph
, ++current_glyph
, ++i
;
3930 if (i
== start_hpos
|| x
!= current_x
)
3934 desired_glyph
= start
;
3938 rif
->cursor_to (vpos
, start_hpos
, desired_row
->y
, start_x
);
3939 rif
->write_glyphs (start
, i
- start_hpos
);
3944 /* Write the rest. */
3945 if (i
< desired_row
->used
[TEXT_AREA
])
3947 rif
->cursor_to (vpos
, i
, desired_row
->y
, x
);
3948 rif
->write_glyphs (desired_glyph
, desired_row
->used
[TEXT_AREA
] - i
);
3952 /* Maybe clear to end of line. */
3953 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row
))
3955 /* If new row extends to the end of the text area, nothing
3956 has to be cleared, if and only if we did a write_glyphs
3957 above. This is made sure by setting desired_stop_pos
3958 appropriately above. */
3959 xassert (i
< desired_row
->used
[TEXT_AREA
]
3960 || ((desired_row
->used
[TEXT_AREA
]
3961 == current_row
->used
[TEXT_AREA
])
3962 && MATRIX_ROW_EXTENDS_FACE_P (current_row
)));
3964 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row
))
3966 /* If old row extends to the end of the text area, clear. */
3967 if (i
>= desired_row
->used
[TEXT_AREA
])
3968 rif
->cursor_to (vpos
, i
, desired_row
->y
,
3969 desired_row
->pixel_width
);
3970 rif
->clear_end_of_line (-1);
3973 else if (desired_row
->pixel_width
< current_row
->pixel_width
)
3975 /* Otherwise clear to the end of the old row. Everything
3976 after that position should be clear already. */
3979 if (i
>= desired_row
->used
[TEXT_AREA
])
3980 rif
->cursor_to (vpos
, i
, desired_row
->y
,
3981 desired_row
->pixel_width
);
3983 /* If cursor is displayed at the end of the line, make sure
3984 it's cleared. Nowadays we don't have a phys_cursor_glyph
3985 with which to erase the cursor (because this method
3986 doesn't work with lbearing/rbearing), so we must do it
3988 if (vpos
== w
->phys_cursor
.vpos
3989 && (desired_row
->reversed_p
3990 ? (w
->phys_cursor
.hpos
< 0)
3991 : (w
->phys_cursor
.hpos
>= desired_row
->used
[TEXT_AREA
])))
3993 w
->phys_cursor_on_p
= 0;
3997 xlim
= current_row
->pixel_width
;
3998 rif
->clear_end_of_line (xlim
);
4007 /* Update row VPOS in window W. Value is non-zero if display has been
4011 update_window_line (struct window
*w
, int vpos
, int *mouse_face_overwritten_p
)
4013 struct glyph_row
*current_row
= MATRIX_ROW (w
->current_matrix
, vpos
);
4014 struct glyph_row
*desired_row
= MATRIX_ROW (w
->desired_matrix
, vpos
);
4015 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
4018 /* Set the row being updated. This is important to let xterm.c
4019 know what line height values are in effect. */
4020 updated_row
= desired_row
;
4022 /* A row can be completely invisible in case a desired matrix was
4023 built with a vscroll and then make_cursor_line_fully_visible shifts
4024 the matrix. Make sure to make such rows current anyway, since
4025 we need the correct y-position, for example, in the current matrix. */
4026 if (desired_row
->mode_line_p
4027 || desired_row
->visible_height
> 0)
4029 xassert (desired_row
->enabled_p
);
4031 /* Update display of the left margin area, if there is one. */
4032 if (!desired_row
->full_width_p
4033 && !NILP (w
->left_margin_cols
))
4036 update_marginal_area (w
, LEFT_MARGIN_AREA
, vpos
);
4039 /* Update the display of the text area. */
4040 if (update_text_area (w
, vpos
))
4043 if (current_row
->mouse_face_p
)
4044 *mouse_face_overwritten_p
= 1;
4047 /* Update display of the right margin area, if there is one. */
4048 if (!desired_row
->full_width_p
4049 && !NILP (w
->right_margin_cols
))
4052 update_marginal_area (w
, RIGHT_MARGIN_AREA
, vpos
);
4055 /* Draw truncation marks etc. */
4056 if (!current_row
->enabled_p
4057 || desired_row
->y
!= current_row
->y
4058 || desired_row
->visible_height
!= current_row
->visible_height
4059 || desired_row
->cursor_in_fringe_p
!= current_row
->cursor_in_fringe_p
4060 || desired_row
->overlay_arrow_bitmap
!= current_row
->overlay_arrow_bitmap
4061 || current_row
->redraw_fringe_bitmaps_p
4062 || desired_row
->mode_line_p
!= current_row
->mode_line_p
4063 || desired_row
->exact_window_width_line_p
!= current_row
->exact_window_width_line_p
4064 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row
)
4065 != MATRIX_ROW_CONTINUATION_LINE_P (current_row
)))
4066 rif
->after_update_window_line_hook (desired_row
);
4069 /* Update current_row from desired_row. */
4070 make_current (w
->desired_matrix
, w
->current_matrix
, vpos
);
4076 /* Set the cursor after an update of window W. This function may only
4077 be called from update_window. */
4080 set_window_cursor_after_update (struct window
*w
)
4082 struct frame
*f
= XFRAME (w
->frame
);
4083 struct redisplay_interface
*rif
= FRAME_RIF (f
);
4084 int cx
, cy
, vpos
, hpos
;
4086 /* Not intended for frame matrix updates. */
4087 xassert (FRAME_WINDOW_P (f
));
4089 if (cursor_in_echo_area
4090 && !NILP (echo_area_buffer
[0])
4091 /* If we are showing a message instead of the mini-buffer,
4092 show the cursor for the message instead. */
4093 && XWINDOW (minibuf_window
) == w
4094 && EQ (minibuf_window
, echo_area_window
)
4095 /* These cases apply only to the frame that contains
4096 the active mini-buffer window. */
4097 && FRAME_HAS_MINIBUF_P (f
)
4098 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4100 cx
= cy
= vpos
= hpos
= 0;
4102 if (cursor_in_echo_area
>= 0)
4104 /* If the mini-buffer is several lines high, find the last
4105 line that has any text on it. Note: either all lines
4106 are enabled or none. Otherwise we wouldn't be able to
4108 struct glyph_row
*row
, *last_row
;
4109 struct glyph
*glyph
;
4110 int yb
= window_text_bottom_y (w
);
4113 row
= w
->current_matrix
->rows
;
4114 while (row
->enabled_p
4115 && (last_row
== NULL
4116 || MATRIX_ROW_BOTTOM_Y (row
) <= yb
))
4118 if (row
->used
[TEXT_AREA
]
4119 && row
->glyphs
[TEXT_AREA
][0].charpos
>= 0)
4126 struct glyph
*start
= last_row
->glyphs
[TEXT_AREA
];
4127 struct glyph
*last
= start
+ last_row
->used
[TEXT_AREA
] - 1;
4129 while (last
> start
&& last
->charpos
< 0)
4132 for (glyph
= start
; glyph
< last
; ++glyph
)
4134 cx
+= glyph
->pixel_width
;
4139 vpos
= MATRIX_ROW_VPOS (last_row
, w
->current_matrix
);
4147 hpos
= w
->cursor
.hpos
;
4148 vpos
= w
->cursor
.vpos
;
4151 /* Window cursor can be out of sync for horizontally split windows. */
4152 hpos
= max (-1, hpos
); /* -1 is for when cursor is on the left fringe */
4153 hpos
= min (w
->current_matrix
->matrix_w
- 1, hpos
);
4154 vpos
= max (0, vpos
);
4155 vpos
= min (w
->current_matrix
->nrows
- 1, vpos
);
4156 rif
->cursor_to (vpos
, hpos
, cy
, cx
);
4160 /* Set WINDOW->must_be_updated_p to ON_P for all windows in the window
4161 tree rooted at W. */
4164 set_window_update_flags (struct window
*w
, int on_p
)
4168 if (!NILP (w
->hchild
))
4169 set_window_update_flags (XWINDOW (w
->hchild
), on_p
);
4170 else if (!NILP (w
->vchild
))
4171 set_window_update_flags (XWINDOW (w
->vchild
), on_p
);
4173 w
->must_be_updated_p
= on_p
;
4175 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
4181 /***********************************************************************
4182 Window-Based Scrolling
4183 ***********************************************************************/
4185 /* Structure describing rows in scrolling_window. */
4189 /* Number of occurrences of this row in desired and current matrix. */
4190 int old_uses
, new_uses
;
4192 /* Vpos of row in new matrix. */
4193 int new_line_number
;
4195 /* Bucket index of this row_entry in the hash table row_table. */
4198 /* The row described by this entry. */
4199 struct glyph_row
*row
;
4201 /* Hash collision chain. */
4202 struct row_entry
*next
;
4205 /* A pool to allocate row_entry structures from, and the size of the
4206 pool. The pool is reallocated in scrolling_window when we find
4207 that we need a larger one. */
4209 static struct row_entry
*row_entry_pool
;
4210 static ptrdiff_t row_entry_pool_size
;
4212 /* Index of next free entry in row_entry_pool. */
4214 static ptrdiff_t row_entry_idx
;
4216 /* The hash table used during scrolling, and the table's size. This
4217 table is used to quickly identify equal rows in the desired and
4220 static struct row_entry
**row_table
;
4221 static ptrdiff_t row_table_size
;
4223 /* Vectors of pointers to row_entry structures belonging to the
4224 current and desired matrix, and the size of the vectors. */
4226 static struct row_entry
**old_lines
, **new_lines
;
4227 static ptrdiff_t old_lines_size
, new_lines_size
;
4229 /* A pool to allocate run structures from, and its size. */
4231 static struct run
*run_pool
;
4232 static ptrdiff_t runs_size
;
4234 /* A vector of runs of lines found during scrolling. */
4236 static struct run
**runs
;
4238 /* Add glyph row ROW to the scrolling hash table. */
4240 static inline struct row_entry
*
4241 add_row_entry (struct glyph_row
*row
)
4243 struct row_entry
*entry
;
4244 ptrdiff_t i
= row
->hash
% row_table_size
;
4246 entry
= row_table
[i
];
4247 xassert (entry
|| verify_row_hash (row
));
4248 while (entry
&& !row_equal_p (entry
->row
, row
, 1))
4249 entry
= entry
->next
;
4253 entry
= row_entry_pool
+ row_entry_idx
++;
4255 entry
->old_uses
= entry
->new_uses
= 0;
4256 entry
->new_line_number
= 0;
4258 entry
->next
= row_table
[i
];
4259 row_table
[i
] = entry
;
4266 /* Try to reuse part of the current display of W by scrolling lines.
4267 HEADER_LINE_P non-zero means W has a header line.
4269 The algorithm is taken from Communications of the ACM, Apr78 "A
4270 Technique for Isolating Differences Between Files." It should take
4273 A short outline of the steps of the algorithm
4275 1. Skip lines equal at the start and end of both matrices.
4277 2. Enter rows in the current and desired matrix into a symbol
4278 table, counting how often they appear in both matrices.
4280 3. Rows that appear exactly once in both matrices serve as anchors,
4281 i.e. we assume that such lines are likely to have been moved.
4283 4. Starting from anchor lines, extend regions to be scrolled both
4284 forward and backward.
4288 -1 if all rows were found to be equal.
4289 0 to indicate that we did not scroll the display, or
4290 1 if we did scroll. */
4293 scrolling_window (struct window
*w
, int header_line_p
)
4295 struct glyph_matrix
*desired_matrix
= w
->desired_matrix
;
4296 struct glyph_matrix
*current_matrix
= w
->current_matrix
;
4297 int yb
= window_text_bottom_y (w
);
4299 int j
, first_old
, first_new
, last_old
, last_new
;
4302 struct row_entry
*entry
;
4303 struct redisplay_interface
*rif
= FRAME_RIF (XFRAME (WINDOW_FRAME (w
)));
4305 /* Skip over rows equal at the start. */
4306 for (i
= header_line_p
? 1 : 0; i
< current_matrix
->nrows
- 1; ++i
)
4308 struct glyph_row
*d
= MATRIX_ROW (desired_matrix
, i
);
4309 struct glyph_row
*c
= MATRIX_ROW (current_matrix
, i
);
4313 && !d
->redraw_fringe_bitmaps_p
4315 && MATRIX_ROW_BOTTOM_Y (c
) <= yb
4316 && MATRIX_ROW_BOTTOM_Y (d
) <= yb
4317 && row_equal_p (c
, d
, 1))
4326 /* Give up if some rows in the desired matrix are not enabled. */
4327 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4330 first_old
= first_new
= i
;
4332 /* Set last_new to the index + 1 of the row that reaches the
4333 bottom boundary in the desired matrix. Give up if we find a
4334 disabled row before we reach the bottom boundary. */
4336 while (i
< desired_matrix
->nrows
- 1)
4340 if (!MATRIX_ROW (desired_matrix
, i
)->enabled_p
)
4342 bottom
= MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix
, i
));
4351 /* Set last_old to the index + 1 of the row that reaches the bottom
4352 boundary in the current matrix. We don't look at the enabled
4353 flag here because we plan to reuse part of the display even if
4354 other parts are disabled. */
4356 while (i
< current_matrix
->nrows
- 1)
4358 int bottom
= MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix
, i
));
4367 /* Skip over rows equal at the bottom. */
4370 while (i
- 1 > first_new
4371 && j
- 1 > first_old
4372 && MATRIX_ROW (current_matrix
, j
- 1)->enabled_p
4373 && (MATRIX_ROW (current_matrix
, j
- 1)->y
4374 == MATRIX_ROW (desired_matrix
, i
- 1)->y
)
4375 && !MATRIX_ROW (desired_matrix
, i
- 1)->redraw_fringe_bitmaps_p
4376 && row_equal_p (MATRIX_ROW (desired_matrix
, i
- 1),
4377 MATRIX_ROW (current_matrix
, j
- 1), 1))
4382 /* Nothing to do if all rows are equal. */
4383 if (last_new
== first_new
)
4386 /* Check for integer overflow in size calculation.
4388 If next_almost_prime checks (N) for divisibility by 2..10, then
4389 it can return at most N + 10, e.g., next_almost_prime (1) == 11.
4390 So, set next_almost_prime_increment_max to 10.
4392 It's just a coincidence that next_almost_prime_increment_max ==
4393 NEXT_ALMOST_PRIME_LIMIT - 1. If NEXT_ALMOST_PRIME_LIMIT were
4394 13, then next_almost_prime_increment_max would be 14, e.g.,
4395 because next_almost_prime (113) would be 127. */
4397 verify (NEXT_ALMOST_PRIME_LIMIT
== 11);
4398 enum { next_almost_prime_increment_max
= 10 };
4399 ptrdiff_t row_table_max
=
4400 (min (PTRDIFF_MAX
, SIZE_MAX
) / (3 * sizeof *row_table
)
4401 - next_almost_prime_increment_max
);
4402 ptrdiff_t current_nrows_max
= row_table_max
- desired_matrix
->nrows
;
4403 if (current_nrows_max
< current_matrix
->nrows
)
4404 memory_full (SIZE_MAX
);
4407 /* Reallocate vectors, tables etc. if necessary. */
4409 if (current_matrix
->nrows
> old_lines_size
)
4410 old_lines
= xpalloc (old_lines
, &old_lines_size
,
4411 current_matrix
->nrows
- old_lines_size
,
4412 INT_MAX
, sizeof *old_lines
);
4414 if (desired_matrix
->nrows
> new_lines_size
)
4415 new_lines
= xpalloc (new_lines
, &new_lines_size
,
4416 desired_matrix
->nrows
- new_lines_size
,
4417 INT_MAX
, sizeof *new_lines
);
4419 n
= desired_matrix
->nrows
;
4420 n
+= current_matrix
->nrows
;
4421 if (row_table_size
< 3 * n
)
4423 ptrdiff_t size
= next_almost_prime (3 * n
);
4424 row_table
= xnrealloc (row_table
, size
, sizeof *row_table
);
4425 row_table_size
= size
;
4426 memset (row_table
, 0, size
* sizeof *row_table
);
4429 if (n
> row_entry_pool_size
)
4430 row_entry_pool
= xpalloc (row_entry_pool
, &row_entry_pool_size
,
4431 n
- row_entry_pool_size
,
4432 -1, sizeof *row_entry_pool
);
4434 if (desired_matrix
->nrows
> runs_size
)
4436 runs
= xnrealloc (runs
, desired_matrix
->nrows
, sizeof *runs
);
4437 run_pool
= xnrealloc (run_pool
, desired_matrix
->nrows
, sizeof *run_pool
);
4438 runs_size
= desired_matrix
->nrows
;
4441 nruns
= run_idx
= 0;
4444 /* Add rows from the current and desired matrix to the hash table
4445 row_hash_table to be able to find equal ones quickly. */
4447 for (i
= first_old
; i
< last_old
; ++i
)
4449 if (MATRIX_ROW (current_matrix
, i
)->enabled_p
)
4451 entry
= add_row_entry (MATRIX_ROW (current_matrix
, i
));
4452 old_lines
[i
] = entry
;
4456 old_lines
[i
] = NULL
;
4459 for (i
= first_new
; i
< last_new
; ++i
)
4461 xassert (MATRIX_ROW_ENABLED_P (desired_matrix
, i
));
4462 entry
= add_row_entry (MATRIX_ROW (desired_matrix
, i
));
4464 entry
->new_line_number
= i
;
4465 new_lines
[i
] = entry
;
4468 /* Identify moves based on lines that are unique and equal
4469 in both matrices. */
4470 for (i
= first_old
; i
< last_old
;)
4472 && old_lines
[i
]->old_uses
== 1
4473 && old_lines
[i
]->new_uses
== 1)
4476 int new_line
= old_lines
[i
]->new_line_number
;
4477 struct run
*run
= run_pool
+ run_idx
++;
4480 run
->current_vpos
= i
;
4481 run
->current_y
= MATRIX_ROW (current_matrix
, i
)->y
;
4482 run
->desired_vpos
= new_line
;
4483 run
->desired_y
= MATRIX_ROW (desired_matrix
, new_line
)->y
;
4485 run
->height
= MATRIX_ROW (current_matrix
, i
)->height
;
4487 /* Extend backward. */
4490 while (p
> first_old
4492 && old_lines
[p
] == new_lines
[q
])
4494 int h
= MATRIX_ROW (current_matrix
, p
)->height
;
4495 --run
->current_vpos
;
4496 --run
->desired_vpos
;
4499 run
->desired_y
-= h
;
4500 run
->current_y
-= h
;
4504 /* Extend forward. */
4509 && old_lines
[p
] == new_lines
[q
])
4511 int h
= MATRIX_ROW (current_matrix
, p
)->height
;
4517 /* Insert run into list of all runs. Order runs by copied
4518 pixel lines. Note that we record runs that don't have to
4519 be copied because they are already in place. This is done
4520 because we can avoid calling update_window_line in this
4522 for (p
= 0; p
< nruns
&& runs
[p
]->height
> run
->height
; ++p
)
4524 for (q
= nruns
; q
> p
; --q
)
4525 runs
[q
] = runs
[q
- 1];
4534 /* Do the moves. Do it in a way that we don't overwrite something
4535 we want to copy later on. This is not solvable in general
4536 because there is only one display and we don't have a way to
4537 exchange areas on this display. Example:
4539 +-----------+ +-----------+
4541 +-----------+ --> +-----------+
4543 +-----------+ +-----------+
4545 Instead, prefer bigger moves, and invalidate moves that would
4546 copy from where we copied to. */
4548 for (i
= 0; i
< nruns
; ++i
)
4549 if (runs
[i
]->nrows
> 0)
4551 struct run
*r
= runs
[i
];
4553 /* Copy on the display. */
4554 if (r
->current_y
!= r
->desired_y
)
4556 rif
->clear_window_mouse_face (w
);
4557 rif
->scroll_run_hook (w
, r
);
4560 /* Truncate runs that copy to where we copied to, and
4561 invalidate runs that copy from where we copied to. */
4562 for (j
= nruns
- 1; j
> i
; --j
)
4564 struct run
*p
= runs
[j
];
4565 int truncated_p
= 0;
4568 && p
->desired_y
< r
->desired_y
+ r
->height
4569 && p
->desired_y
+ p
->height
> r
->desired_y
)
4571 if (p
->desired_y
< r
->desired_y
)
4573 p
->nrows
= r
->desired_vpos
- p
->desired_vpos
;
4574 p
->height
= r
->desired_y
- p
->desired_y
;
4579 int nrows_copied
= (r
->desired_vpos
+ r
->nrows
4582 if (p
->nrows
<= nrows_copied
)
4586 int height_copied
= (r
->desired_y
+ r
->height
4589 p
->current_vpos
+= nrows_copied
;
4590 p
->desired_vpos
+= nrows_copied
;
4591 p
->nrows
-= nrows_copied
;
4592 p
->current_y
+= height_copied
;
4593 p
->desired_y
+= height_copied
;
4594 p
->height
-= height_copied
;
4600 if (r
->current_y
!= r
->desired_y
4601 /* The condition below is equivalent to
4602 ((p->current_y >= r->desired_y
4603 && p->current_y < r->desired_y + r->height)
4604 || (p->current_y + p->height > r->desired_y
4605 && (p->current_y + p->height
4606 <= r->desired_y + r->height)))
4607 because we have 0 < p->height <= r->height. */
4608 && p
->current_y
< r
->desired_y
+ r
->height
4609 && p
->current_y
+ p
->height
> r
->desired_y
)
4612 /* Reorder runs by copied pixel lines if truncated. */
4613 if (truncated_p
&& p
->nrows
> 0)
4617 while (runs
[k
]->nrows
== 0 || runs
[k
]->height
< p
->height
)
4619 memmove (runs
+ j
, runs
+ j
+ 1, (k
- j
) * sizeof (*runs
));
4624 /* Assign matrix rows. */
4625 for (j
= 0; j
< r
->nrows
; ++j
)
4627 struct glyph_row
*from
, *to
;
4628 int to_overlapped_p
;
4630 to
= MATRIX_ROW (current_matrix
, r
->desired_vpos
+ j
);
4631 from
= MATRIX_ROW (desired_matrix
, r
->desired_vpos
+ j
);
4632 to_overlapped_p
= to
->overlapped_p
;
4633 from
->redraw_fringe_bitmaps_p
= from
->fringe_bitmap_periodic_p
;
4634 assign_row (to
, from
);
4635 /* The above `assign_row' actually does swap, so if we had
4636 an overlap in the copy destination of two runs, then
4637 the second run would assign a previously disabled bogus
4638 row. But thanks to the truncation code in the
4639 preceding for-loop, we no longer have such an overlap,
4640 and thus the assigned row should always be enabled. */
4641 xassert (to
->enabled_p
);
4642 from
->enabled_p
= 0;
4643 to
->overlapped_p
= to_overlapped_p
;
4647 /* Clear the hash table, for the next time. */
4648 for (i
= 0; i
< row_entry_idx
; ++i
)
4649 row_table
[row_entry_pool
[i
].bucket
] = NULL
;
4651 /* Value is 1 to indicate that we scrolled the display. */
4657 /************************************************************************
4659 ************************************************************************/
4661 /* Update the desired frame matrix of frame F.
4663 FORCE_P non-zero means that the update should not be stopped by
4664 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
4665 should not be tried.
4667 Value is non-zero if update was stopped due to pending input. */
4670 update_frame_1 (struct frame
*f
, int force_p
, int inhibit_id_p
)
4672 /* Frame matrices to work on. */
4673 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
4674 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
4677 int preempt_count
= baud_rate
/ 2400 + 1;
4679 xassert (current_matrix
&& desired_matrix
);
4681 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
4682 calculate_costs (f
);
4684 if (preempt_count
<= 0)
4687 #if !PERIODIC_PREEMPTION_CHECKING
4688 if (!force_p
&& detect_input_pending_ignore_squeezables ())
4695 /* If we cannot insert/delete lines, it's no use trying it. */
4696 if (!FRAME_LINE_INS_DEL_OK (f
))
4699 /* See if any of the desired lines are enabled; don't compute for
4700 i/d line if just want cursor motion. */
4701 for (i
= 0; i
< desired_matrix
->nrows
; i
++)
4702 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4705 /* Try doing i/d line, if not yet inhibited. */
4706 if (!inhibit_id_p
&& i
< desired_matrix
->nrows
)
4707 force_p
|= scrolling (f
);
4709 /* Update the individual lines as needed. Do bottom line first. */
4710 if (MATRIX_ROW_ENABLED_P (desired_matrix
, desired_matrix
->nrows
- 1))
4711 update_frame_line (f
, desired_matrix
->nrows
- 1);
4713 /* Now update the rest of the lines. */
4714 for (i
= 0; i
< desired_matrix
->nrows
- 1 && (force_p
|| !input_pending
); i
++)
4716 if (MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4718 if (FRAME_TERMCAP_P (f
))
4720 /* Flush out every so many lines.
4721 Also flush out if likely to have more than 1k buffered
4722 otherwise. I'm told that some telnet connections get
4723 really screwed by more than 1k output at once. */
4724 FILE *display_output
= FRAME_TTY (f
)->output
;
4727 int outq
= PENDING_OUTPUT_COUNT (display_output
);
4729 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
4731 fflush (display_output
);
4732 if (preempt_count
== 1)
4734 #ifdef EMACS_OUTQSIZE
4735 if (EMACS_OUTQSIZE (0, &outq
) < 0)
4736 /* Probably not a tty. Ignore the error and reset
4738 outq
= PENDING_OUTPUT_COUNT (FRAME_TTY (f
->output
));
4741 if (baud_rate
<= outq
&& baud_rate
> 0)
4742 sleep (outq
/ baud_rate
);
4748 #if PERIODIC_PREEMPTION_CHECKING
4752 EMACS_GET_TIME (tm
);
4753 EMACS_SUB_TIME (dif
, preemption_next_check
, tm
);
4754 if (EMACS_TIME_NEG_P (dif
))
4756 EMACS_ADD_TIME (preemption_next_check
, tm
, preemption_period
);
4757 if (detect_input_pending_ignore_squeezables ())
4762 if (!force_p
&& (i
- 1) % preempt_count
== 0)
4763 detect_input_pending_ignore_squeezables ();
4766 update_frame_line (f
, i
);
4770 pause_p
= (i
< FRAME_LINES (f
) - 1) ? i
: 0;
4772 /* Now just clean up termcap drivers and set cursor, etc. */
4775 if ((cursor_in_echo_area
4776 /* If we are showing a message instead of the mini-buffer,
4777 show the cursor for the message instead of for the
4778 (now hidden) mini-buffer contents. */
4779 || (EQ (minibuf_window
, selected_window
)
4780 && EQ (minibuf_window
, echo_area_window
)
4781 && !NILP (echo_area_buffer
[0])))
4782 /* These cases apply only to the frame that contains
4783 the active mini-buffer window. */
4784 && FRAME_HAS_MINIBUF_P (f
)
4785 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
4787 int top
= WINDOW_TOP_EDGE_LINE (XWINDOW (FRAME_MINIBUF_WINDOW (f
)));
4790 if (cursor_in_echo_area
< 0)
4792 /* Negative value of cursor_in_echo_area means put
4793 cursor at beginning of line. */
4799 /* Positive value of cursor_in_echo_area means put
4800 cursor at the end of the prompt. If the mini-buffer
4801 is several lines high, find the last line that has
4803 row
= FRAME_LINES (f
);
4809 if (MATRIX_ROW_ENABLED_P (current_matrix
, row
))
4811 /* Frame rows are filled up with spaces that
4812 must be ignored here. */
4813 struct glyph_row
*r
= MATRIX_ROW (current_matrix
,
4815 struct glyph
*start
= r
->glyphs
[TEXT_AREA
];
4816 struct glyph
*last
= start
+ r
->used
[TEXT_AREA
];
4819 && (last
- 1)->charpos
< 0)
4825 while (row
> top
&& col
== 0);
4827 /* Make sure COL is not out of range. */
4828 if (col
>= FRAME_CURSOR_X_LIMIT (f
))
4830 /* If we have another row, advance cursor into it. */
4831 if (row
< FRAME_LINES (f
) - 1)
4833 col
= FRAME_LEFT_SCROLL_BAR_COLS (f
);
4836 /* Otherwise move it back in range. */
4838 col
= FRAME_CURSOR_X_LIMIT (f
) - 1;
4842 cursor_to (f
, row
, col
);
4846 /* We have only one cursor on terminal frames. Use it to
4847 display the cursor of the selected window. */
4848 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
4849 if (w
->cursor
.vpos
>= 0
4850 /* The cursor vpos may be temporarily out of bounds
4851 in the following situation: There is one window,
4852 with the cursor in the lower half of it. The window
4853 is split, and a message causes a redisplay before
4854 a new cursor position has been computed. */
4855 && w
->cursor
.vpos
< WINDOW_TOTAL_LINES (w
))
4857 int x
= WINDOW_TO_FRAME_HPOS (w
, w
->cursor
.hpos
);
4858 int y
= WINDOW_TO_FRAME_VPOS (w
, w
->cursor
.vpos
);
4860 if (INTEGERP (w
->left_margin_cols
))
4861 x
+= XFASTINT (w
->left_margin_cols
);
4863 /* x = max (min (x, FRAME_TOTAL_COLS (f) - 1), 0); */
4864 cursor_to (f
, y
, x
);
4869 #if !PERIODIC_PREEMPTION_CHECKING
4873 clear_desired_matrices (f
);
4878 /* Do line insertions/deletions on frame F for frame-based redisplay. */
4881 scrolling (struct frame
*frame
)
4883 int unchanged_at_top
, unchanged_at_bottom
;
4886 int *old_hash
= (int *) alloca (FRAME_LINES (frame
) * sizeof (int));
4887 int *new_hash
= (int *) alloca (FRAME_LINES (frame
) * sizeof (int));
4888 int *draw_cost
= (int *) alloca (FRAME_LINES (frame
) * sizeof (int));
4889 int *old_draw_cost
= (int *) alloca (FRAME_LINES (frame
) * sizeof (int));
4891 int free_at_end_vpos
= FRAME_LINES (frame
);
4892 struct glyph_matrix
*current_matrix
= frame
->current_matrix
;
4893 struct glyph_matrix
*desired_matrix
= frame
->desired_matrix
;
4895 if (!current_matrix
)
4898 /* Compute hash codes of all the lines. Also calculate number of
4899 changed lines, number of unchanged lines at the beginning, and
4900 number of unchanged lines at the end. */
4902 unchanged_at_top
= 0;
4903 unchanged_at_bottom
= FRAME_LINES (frame
);
4904 for (i
= 0; i
< FRAME_LINES (frame
); i
++)
4906 /* Give up on this scrolling if some old lines are not enabled. */
4907 if (!MATRIX_ROW_ENABLED_P (current_matrix
, i
))
4909 old_hash
[i
] = line_hash_code (MATRIX_ROW (current_matrix
, i
));
4910 if (! MATRIX_ROW_ENABLED_P (desired_matrix
, i
))
4912 /* This line cannot be redrawn, so don't let scrolling mess it. */
4913 new_hash
[i
] = old_hash
[i
];
4914 #define INFINITY 1000000 /* Taken from scroll.c */
4915 draw_cost
[i
] = INFINITY
;
4919 new_hash
[i
] = line_hash_code (MATRIX_ROW (desired_matrix
, i
));
4920 draw_cost
[i
] = line_draw_cost (desired_matrix
, i
);
4923 if (old_hash
[i
] != new_hash
[i
])
4926 unchanged_at_bottom
= FRAME_LINES (frame
) - i
- 1;
4928 else if (i
== unchanged_at_top
)
4930 old_draw_cost
[i
] = line_draw_cost (current_matrix
, i
);
4933 /* If changed lines are few, don't allow preemption, don't scroll. */
4934 if ((!FRAME_SCROLL_REGION_OK (frame
)
4935 && changed_lines
< baud_rate
/ 2400)
4936 || unchanged_at_bottom
== FRAME_LINES (frame
))
4939 window_size
= (FRAME_LINES (frame
) - unchanged_at_top
4940 - unchanged_at_bottom
);
4942 if (FRAME_SCROLL_REGION_OK (frame
))
4943 free_at_end_vpos
-= unchanged_at_bottom
;
4944 else if (FRAME_MEMORY_BELOW_FRAME (frame
))
4945 free_at_end_vpos
= -1;
4947 /* If large window, fast terminal and few lines in common between
4948 current frame and desired frame, don't bother with i/d calc. */
4949 if (!FRAME_SCROLL_REGION_OK (frame
)
4950 && window_size
>= 18 && baud_rate
> 2400
4952 10 * scrolling_max_lines_saved (unchanged_at_top
,
4953 FRAME_LINES (frame
) - unchanged_at_bottom
,
4954 old_hash
, new_hash
, draw_cost
)))
4957 if (window_size
< 2)
4960 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
4961 draw_cost
+ unchanged_at_top
- 1,
4962 old_draw_cost
+ unchanged_at_top
- 1,
4963 old_hash
+ unchanged_at_top
- 1,
4964 new_hash
+ unchanged_at_top
- 1,
4965 free_at_end_vpos
- unchanged_at_top
);
4971 /* Count the number of blanks at the start of the vector of glyphs R
4972 which is LEN glyphs long. */
4975 count_blanks (struct glyph
*r
, int len
)
4979 for (i
= 0; i
< len
; ++i
)
4980 if (!CHAR_GLYPH_SPACE_P (r
[i
]))
4987 /* Count the number of glyphs in common at the start of the glyph
4988 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
4989 of STR2. Value is the number of equal glyphs equal at the start. */
4992 count_match (struct glyph
*str1
, struct glyph
*end1
, struct glyph
*str2
, struct glyph
*end2
)
4994 struct glyph
*p1
= str1
;
4995 struct glyph
*p2
= str2
;
4999 && GLYPH_CHAR_AND_FACE_EQUAL_P (p1
, p2
))
5006 /* Char insertion/deletion cost vector, from term.c */
5008 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_TOTAL_COLS ((f))])
5011 /* Perform a frame-based update on line VPOS in frame FRAME. */
5014 update_frame_line (struct frame
*f
, int vpos
)
5016 struct glyph
*obody
, *nbody
, *op1
, *op2
, *np1
, *nend
;
5018 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
5019 struct glyph_matrix
*current_matrix
= f
->current_matrix
;
5020 struct glyph_matrix
*desired_matrix
= f
->desired_matrix
;
5021 struct glyph_row
*current_row
= MATRIX_ROW (current_matrix
, vpos
);
5022 struct glyph_row
*desired_row
= MATRIX_ROW (desired_matrix
, vpos
);
5023 int must_write_whole_line_p
;
5024 int write_spaces_p
= FRAME_MUST_WRITE_SPACES (f
);
5025 int colored_spaces_p
= (FACE_FROM_ID (f
, DEFAULT_FACE_ID
)->background
5026 != FACE_TTY_DEFAULT_BG_COLOR
);
5028 if (colored_spaces_p
)
5031 /* Current row not enabled means it has unknown contents. We must
5032 write the whole desired line in that case. */
5033 must_write_whole_line_p
= !current_row
->enabled_p
;
5034 if (must_write_whole_line_p
)
5041 obody
= MATRIX_ROW_GLYPH_START (current_matrix
, vpos
);
5042 olen
= current_row
->used
[TEXT_AREA
];
5044 /* Ignore trailing spaces, if we can. */
5045 if (!write_spaces_p
)
5046 while (olen
> 0 && CHAR_GLYPH_SPACE_P (obody
[olen
-1]))
5050 current_row
->enabled_p
= 1;
5051 current_row
->used
[TEXT_AREA
] = desired_row
->used
[TEXT_AREA
];
5053 /* If desired line is empty, just clear the line. */
5054 if (!desired_row
->enabled_p
)
5060 nbody
= desired_row
->glyphs
[TEXT_AREA
];
5061 nlen
= desired_row
->used
[TEXT_AREA
];
5062 nend
= nbody
+ nlen
;
5064 /* If display line has unknown contents, write the whole line. */
5065 if (must_write_whole_line_p
)
5067 /* Ignore spaces at the end, if we can. */
5068 if (!write_spaces_p
)
5069 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5072 /* Write the contents of the desired line. */
5075 cursor_to (f
, vpos
, 0);
5076 write_glyphs (f
, nbody
, nlen
);
5079 /* Don't call clear_end_of_line if we already wrote the whole
5080 line. The cursor will not be at the right margin in that
5081 case but in the line below. */
5082 if (nlen
< FRAME_TOTAL_COLS (f
))
5084 cursor_to (f
, vpos
, nlen
);
5085 clear_end_of_line (f
, FRAME_TOTAL_COLS (f
));
5088 /* Make sure we are in the right row, otherwise cursor movement
5089 with cmgoto might use `ch' in the wrong row. */
5090 cursor_to (f
, vpos
, 0);
5092 make_current (desired_matrix
, current_matrix
, vpos
);
5096 /* Pretend trailing spaces are not there at all,
5097 unless for one reason or another we must write all spaces. */
5098 if (!write_spaces_p
)
5099 while (nlen
> 0 && CHAR_GLYPH_SPACE_P (nbody
[nlen
- 1]))
5102 /* If there's no i/d char, quickly do the best we can without it. */
5103 if (!FRAME_CHAR_INS_DEL_OK (f
))
5107 /* Find the first glyph in desired row that doesn't agree with
5108 a glyph in the current row, and write the rest from there on. */
5109 for (i
= 0; i
< nlen
; i
++)
5111 if (i
>= olen
|| !GLYPH_EQUAL_P (nbody
+ i
, obody
+ i
))
5113 /* Find the end of the run of different glyphs. */
5117 || !GLYPH_EQUAL_P (nbody
+ j
, obody
+ j
)
5118 || CHAR_GLYPH_PADDING_P (nbody
[j
])))
5121 /* Output this run of non-matching chars. */
5122 cursor_to (f
, vpos
, i
);
5123 write_glyphs (f
, nbody
+ i
, j
- i
);
5126 /* Now find the next non-match. */
5130 /* Clear the rest of the line, or the non-clear part of it. */
5133 cursor_to (f
, vpos
, nlen
);
5134 clear_end_of_line (f
, olen
);
5137 /* Make current row = desired row. */
5138 make_current (desired_matrix
, current_matrix
, vpos
);
5142 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
5143 characters in a row. */
5147 /* If current line is blank, skip over initial spaces, if
5148 possible, and write the rest. */
5152 nsp
= count_blanks (nbody
, nlen
);
5156 cursor_to (f
, vpos
, nsp
);
5157 write_glyphs (f
, nbody
+ nsp
, nlen
- nsp
);
5160 /* Exchange contents between current_frame and new_frame. */
5161 make_current (desired_matrix
, current_matrix
, vpos
);
5165 /* Compute number of leading blanks in old and new contents. */
5166 osp
= count_blanks (obody
, olen
);
5167 nsp
= (colored_spaces_p
? 0 : count_blanks (nbody
, nlen
));
5169 /* Compute number of matching chars starting with first non-blank. */
5170 begmatch
= count_match (obody
+ osp
, obody
+ olen
,
5171 nbody
+ nsp
, nbody
+ nlen
);
5173 /* Spaces in new match implicit space past the end of old. */
5174 /* A bug causing this to be a no-op was fixed in 18.29. */
5175 if (!write_spaces_p
&& osp
+ begmatch
== olen
)
5178 while (np1
+ begmatch
< nend
&& CHAR_GLYPH_SPACE_P (np1
[begmatch
]))
5182 /* Avoid doing insert/delete char
5183 just cause number of leading spaces differs
5184 when the following text does not match. */
5185 if (begmatch
== 0 && osp
!= nsp
)
5186 osp
= nsp
= min (osp
, nsp
);
5188 /* Find matching characters at end of line */
5191 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
5193 && GLYPH_EQUAL_P (op1
- 1, np1
- 1))
5198 endmatch
= obody
+ olen
- op1
;
5200 /* tem gets the distance to insert or delete.
5201 endmatch is how many characters we save by doing so.
5204 tem
= (nlen
- nsp
) - (olen
- osp
);
5206 && (!FRAME_CHAR_INS_DEL_OK (f
)
5207 || endmatch
<= char_ins_del_cost (f
)[tem
]))
5210 /* nsp - osp is the distance to insert or delete.
5211 If that is nonzero, begmatch is known to be nonzero also.
5212 begmatch + endmatch is how much we save by doing the ins/del.
5216 && (!FRAME_CHAR_INS_DEL_OK (f
)
5217 || begmatch
+ endmatch
<= char_ins_del_cost (f
)[nsp
- osp
]))
5221 osp
= nsp
= min (osp
, nsp
);
5224 /* Now go through the line, inserting, writing and
5225 deleting as appropriate. */
5229 cursor_to (f
, vpos
, nsp
);
5230 delete_glyphs (f
, osp
- nsp
);
5234 /* If going to delete chars later in line
5235 and insert earlier in the line,
5236 must delete first to avoid losing data in the insert */
5237 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
5239 cursor_to (f
, vpos
, nlen
- endmatch
+ osp
- nsp
);
5240 delete_glyphs (f
, olen
+ nsp
- osp
- nlen
);
5241 olen
= nlen
- (nsp
- osp
);
5243 cursor_to (f
, vpos
, osp
);
5244 insert_glyphs (f
, 0, nsp
- osp
);
5248 tem
= nsp
+ begmatch
+ endmatch
;
5249 if (nlen
!= tem
|| olen
!= tem
)
5251 if (!endmatch
|| nlen
== olen
)
5253 /* If new text being written reaches right margin, there is
5254 no need to do clear-to-eol at the end of this function
5255 (and it would not be safe, since cursor is not going to
5256 be "at the margin" after the text is done). */
5257 if (nlen
== FRAME_TOTAL_COLS (f
))
5260 /* Function write_glyphs is prepared to do nothing
5261 if passed a length <= 0. Check it here to avoid
5262 unnecessary cursor movement. */
5265 cursor_to (f
, vpos
, nsp
+ begmatch
);
5266 write_glyphs (f
, nbody
+ nsp
+ begmatch
, nlen
- tem
);
5269 else if (nlen
> olen
)
5271 /* Here, we used to have the following simple code:
5272 ----------------------------------------
5273 write_glyphs (nbody + nsp + begmatch, olen - tem);
5274 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5275 ----------------------------------------
5276 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5277 is a padding glyph. */
5278 int out
= olen
- tem
; /* Columns to be overwritten originally. */
5281 cursor_to (f
, vpos
, nsp
+ begmatch
);
5283 /* Calculate columns we can actually overwrite. */
5284 while (CHAR_GLYPH_PADDING_P (nbody
[nsp
+ begmatch
+ out
]))
5286 write_glyphs (f
, nbody
+ nsp
+ begmatch
, out
);
5288 /* If we left columns to be overwritten, we must delete them. */
5289 del
= olen
- tem
- out
;
5291 delete_glyphs (f
, del
);
5293 /* At last, we insert columns not yet written out. */
5294 insert_glyphs (f
, nbody
+ nsp
+ begmatch
+ out
, nlen
- olen
+ del
);
5297 else if (olen
> nlen
)
5299 cursor_to (f
, vpos
, nsp
+ begmatch
);
5300 write_glyphs (f
, nbody
+ nsp
+ begmatch
, nlen
- tem
);
5301 delete_glyphs (f
, olen
- nlen
);
5307 /* If any unerased characters remain after the new line, erase them. */
5310 cursor_to (f
, vpos
, nlen
);
5311 clear_end_of_line (f
, olen
);
5314 /* Exchange contents between current_frame and new_frame. */
5315 make_current (desired_matrix
, current_matrix
, vpos
);
5320 /***********************************************************************
5321 X/Y Position -> Buffer Position
5322 ***********************************************************************/
5324 /* Determine what's under window-relative pixel position (*X, *Y).
5325 Return the OBJECT (string or buffer) that's there.
5326 Return in *POS the position in that object.
5327 Adjust *X and *Y to character positions.
5328 Return in *DX and *DY the pixel coordinates of the click,
5329 relative to the top left corner of OBJECT, or relative to
5330 the top left corner of the character glyph at (*X, *Y)
5332 Return WIDTH and HEIGHT of the object at (*X, *Y), or zero
5333 if the coordinates point to an empty area of the display. */
5336 buffer_posn_from_coords (struct window
*w
, int *x
, int *y
, struct display_pos
*pos
, Lisp_Object
*object
, int *dx
, int *dy
, int *width
, int *height
)
5339 Lisp_Object old_current_buffer
= Fcurrent_buffer ();
5340 struct text_pos startp
;
5342 struct glyph_row
*row
;
5343 #ifdef HAVE_WINDOW_SYSTEM
5344 struct image
*img
= 0;
5347 void *itdata
= NULL
;
5349 /* We used to set current_buffer directly here, but that does the
5350 wrong thing with `face-remapping-alist' (bug#2044). */
5351 Fset_buffer (w
->buffer
);
5352 itdata
= bidi_shelve_cache ();
5353 SET_TEXT_POS_FROM_MARKER (startp
, w
->start
);
5354 CHARPOS (startp
) = min (ZV
, max (BEGV
, CHARPOS (startp
)));
5355 BYTEPOS (startp
) = min (ZV_BYTE
, max (BEGV_BYTE
, BYTEPOS (startp
)));
5356 start_display (&it
, w
, startp
);
5357 /* start_display takes into account the header-line row, but IT's
5358 vpos still counts from the glyph row that includes the window's
5359 start position. Adjust for a possible header-line row. */
5360 it
.vpos
+= WINDOW_WANTS_HEADER_LINE_P (w
) ? 1 : 0;
5364 /* First, move to the beginning of the row corresponding to *Y. We
5365 need to be in that row to get the correct value of base paragraph
5366 direction for the text at (*X, *Y). */
5367 move_it_to (&it
, -1, 0, *y
, -1, MOVE_TO_X
| MOVE_TO_Y
);
5369 /* TO_X is the pixel position that the iterator will compute for the
5370 glyph at *X. We add it.first_visible_x because iterator
5371 positions include the hscroll. */
5372 to_x
= x0
+ it
.first_visible_x
;
5373 if (it
.bidi_it
.paragraph_dir
== R2L
)
5374 /* For lines in an R2L paragraph, we need to mirror TO_X wrt the
5375 text area. This is because the iterator, even in R2L
5376 paragraphs, delivers glyphs as if they started at the left
5377 margin of the window. (When we actually produce glyphs for
5378 display, we reverse their order in PRODUCE_GLYPHS, but the
5379 iterator doesn't know about that.) The following line adjusts
5380 the pixel position to the iterator geometry, which is what
5381 move_it_* routines use. (The -1 is because in a window whose
5382 text-area width is W, the rightmost pixel position is W-1, and
5383 it should be mirrored into zero pixel position.) */
5384 to_x
= window_box_width (w
, TEXT_AREA
) - to_x
- 1;
5386 /* Now move horizontally in the row to the glyph under *X. Second
5387 argument is ZV to prevent move_it_in_display_line from matching
5388 based on buffer positions. */
5389 move_it_in_display_line (&it
, ZV
, to_x
, MOVE_TO_X
);
5390 bidi_unshelve_cache (itdata
, 0);
5392 Fset_buffer (old_current_buffer
);
5394 *dx
= x0
+ it
.first_visible_x
- it
.current_x
;
5395 *dy
= *y
- it
.current_y
;
5398 if (STRINGP (it
.string
))
5401 if (it
.what
== IT_COMPOSITION
5402 && it
.cmp_it
.nchars
> 1
5403 && it
.cmp_it
.reversed_p
)
5405 /* The current display element is a grapheme cluster in a
5406 composition. In that case, we need the position of the first
5407 character of the cluster. But, as it.cmp_it.reversed_p is 1,
5408 it.current points to the last character of the cluster, thus
5409 we must move back to the first character of the same
5411 CHARPOS (pos
->pos
) -= it
.cmp_it
.nchars
- 1;
5412 if (STRINGP (it
.string
))
5413 BYTEPOS (pos
->pos
) = string_char_to_byte (string
, CHARPOS (pos
->pos
));
5415 BYTEPOS (pos
->pos
) = buf_charpos_to_bytepos (XBUFFER (w
->buffer
),
5416 CHARPOS (pos
->pos
));
5419 #ifdef HAVE_WINDOW_SYSTEM
5420 if (it
.what
== IT_IMAGE
)
5422 if ((img
= IMAGE_FROM_ID (it
.f
, it
.image_id
)) != NULL
5423 && !NILP (img
->spec
))
5424 *object
= img
->spec
;
5428 if (it
.vpos
< w
->current_matrix
->nrows
5429 && (row
= MATRIX_ROW (w
->current_matrix
, it
.vpos
),
5432 if (it
.hpos
< row
->used
[TEXT_AREA
])
5434 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + it
.hpos
;
5435 #ifdef HAVE_WINDOW_SYSTEM
5438 *dy
-= row
->ascent
- glyph
->ascent
;
5439 *dx
+= glyph
->slice
.img
.x
;
5440 *dy
+= glyph
->slice
.img
.y
;
5441 /* Image slices positions are still relative to the entire image */
5442 *width
= img
->width
;
5443 *height
= img
->height
;
5448 *width
= glyph
->pixel_width
;
5449 *height
= glyph
->ascent
+ glyph
->descent
;
5455 *height
= row
->height
;
5460 *width
= *height
= 0;
5463 /* Add extra (default width) columns if clicked after EOL. */
5464 x1
= max (0, it
.current_x
+ it
.pixel_width
- it
.first_visible_x
);
5466 it
.hpos
+= (x0
- x1
) / WINDOW_FRAME_COLUMN_WIDTH (w
);
5475 /* Value is the string under window-relative coordinates X/Y in the
5476 mode line or header line (PART says which) of window W, or nil if none.
5477 *CHARPOS is set to the position in the string returned. */
5480 mode_line_string (struct window
*w
, enum window_part part
,
5481 int *x
, int *y
, ptrdiff_t *charpos
, Lisp_Object
*object
,
5482 int *dx
, int *dy
, int *width
, int *height
)
5484 struct glyph_row
*row
;
5485 struct glyph
*glyph
, *end
;
5487 Lisp_Object string
= Qnil
;
5489 if (part
== ON_MODE_LINE
)
5490 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
5492 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
5494 *y
= row
- MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
5496 if (row
->mode_line_p
&& row
->enabled_p
)
5498 /* Find the glyph under X. If we find one with a string object,
5499 it's the one we were looking for. */
5500 glyph
= row
->glyphs
[TEXT_AREA
];
5501 end
= glyph
+ row
->used
[TEXT_AREA
];
5502 for (x0
= *x
; glyph
< end
&& x0
>= glyph
->pixel_width
; ++glyph
)
5503 x0
-= glyph
->pixel_width
;
5504 *x
= glyph
- row
->glyphs
[TEXT_AREA
];
5507 string
= glyph
->object
;
5508 *charpos
= glyph
->charpos
;
5509 *width
= glyph
->pixel_width
;
5510 *height
= glyph
->ascent
+ glyph
->descent
;
5511 #ifdef HAVE_WINDOW_SYSTEM
5512 if (glyph
->type
== IMAGE_GLYPH
)
5515 img
= IMAGE_FROM_ID (WINDOW_XFRAME (w
), glyph
->u
.img_id
);
5517 *object
= img
->spec
;
5518 y0
-= row
->ascent
- glyph
->ascent
;
5524 /* Add extra (default width) columns if clicked after EOL. */
5525 *x
+= x0
/ WINDOW_FRAME_COLUMN_WIDTH (w
);
5527 *height
= row
->height
;
5534 *width
= *height
= 0;
5544 /* Value is the string under window-relative coordinates X/Y in either
5545 marginal area, or nil if none. *CHARPOS is set to the position in
5546 the string returned. */
5549 marginal_area_string (struct window
*w
, enum window_part part
,
5550 int *x
, int *y
, ptrdiff_t *charpos
, Lisp_Object
*object
,
5551 int *dx
, int *dy
, int *width
, int *height
)
5553 struct glyph_row
*row
= w
->current_matrix
->rows
;
5554 struct glyph
*glyph
, *end
;
5555 int x0
, y0
, i
, wy
= *y
;
5557 Lisp_Object string
= Qnil
;
5559 if (part
== ON_LEFT_MARGIN
)
5560 area
= LEFT_MARGIN_AREA
;
5561 else if (part
== ON_RIGHT_MARGIN
)
5562 area
= RIGHT_MARGIN_AREA
;
5566 for (i
= 0; row
->enabled_p
&& i
< w
->current_matrix
->nrows
; ++i
, ++row
)
5567 if (wy
>= row
->y
&& wy
< MATRIX_ROW_BOTTOM_Y (row
))
5570 *y
= row
- MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
5574 /* Find the glyph under X. If we find one with a string object,
5575 it's the one we were looking for. */
5576 if (area
== RIGHT_MARGIN_AREA
)
5577 x0
= ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5578 ? WINDOW_LEFT_FRINGE_WIDTH (w
)
5579 : WINDOW_TOTAL_FRINGE_WIDTH (w
))
5580 + window_box_width (w
, LEFT_MARGIN_AREA
)
5581 + window_box_width (w
, TEXT_AREA
));
5583 x0
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5584 ? WINDOW_LEFT_FRINGE_WIDTH (w
)
5587 glyph
= row
->glyphs
[area
];
5588 end
= glyph
+ row
->used
[area
];
5589 for (x0
= *x
- x0
; glyph
< end
&& x0
>= glyph
->pixel_width
; ++glyph
)
5590 x0
-= glyph
->pixel_width
;
5591 *x
= glyph
- row
->glyphs
[area
];
5594 string
= glyph
->object
;
5595 *charpos
= glyph
->charpos
;
5596 *width
= glyph
->pixel_width
;
5597 *height
= glyph
->ascent
+ glyph
->descent
;
5598 #ifdef HAVE_WINDOW_SYSTEM
5599 if (glyph
->type
== IMAGE_GLYPH
)
5602 img
= IMAGE_FROM_ID (WINDOW_XFRAME (w
), glyph
->u
.img_id
);
5604 *object
= img
->spec
;
5605 y0
-= row
->ascent
- glyph
->ascent
;
5606 x0
+= glyph
->slice
.img
.x
;
5607 y0
+= glyph
->slice
.img
.y
;
5613 /* Add extra (default width) columns if clicked after EOL. */
5614 *x
+= x0
/ WINDOW_FRAME_COLUMN_WIDTH (w
);
5616 *height
= row
->height
;
5623 *width
= *height
= 0;
5633 /***********************************************************************
5634 Changing Frame Sizes
5635 ***********************************************************************/
5640 window_change_signal (int signalnum
) /* If we don't have an argument, */
5641 /* some compilers complain in signal calls. */
5644 int old_errno
= errno
;
5646 struct tty_display_info
*tty
;
5648 signal (SIGWINCH
, window_change_signal
);
5649 SIGNAL_THREAD_CHECK (signalnum
);
5651 /* The frame size change obviously applies to a single
5652 termcap-controlled terminal, but we can't decide which.
5653 Therefore, we resize the frames corresponding to each tty.
5655 for (tty
= tty_list
; tty
; tty
= tty
->next
) {
5657 if (! tty
->term_initted
)
5660 /* Suspended tty frames have tty->input == NULL avoid trying to
5665 get_tty_size (fileno (tty
->input
), &width
, &height
);
5667 if (width
> 5 && height
> 2) {
5668 Lisp_Object tail
, frame
;
5670 FOR_EACH_FRAME (tail
, frame
)
5671 if (FRAME_TERMCAP_P (XFRAME (frame
)) && FRAME_TTY (XFRAME (frame
)) == tty
)
5672 /* Record the new sizes, but don't reallocate the data
5673 structures now. Let that be done later outside of the
5675 change_frame_size (XFRAME (frame
), height
, width
, 0, 1, 0);
5681 #endif /* SIGWINCH */
5684 /* Do any change in frame size that was requested by a signal. SAFE
5685 non-zero means this function is called from a place where it is
5686 safe to change frame sizes while a redisplay is in progress. */
5689 do_pending_window_change (int safe
)
5691 /* If window_change_signal should have run before, run it now. */
5692 if (redisplaying_p
&& !safe
)
5695 while (delayed_size_change
)
5697 Lisp_Object tail
, frame
;
5699 delayed_size_change
= 0;
5701 FOR_EACH_FRAME (tail
, frame
)
5703 struct frame
*f
= XFRAME (frame
);
5705 if (f
->new_text_lines
!= 0 || f
->new_text_cols
!= 0)
5706 change_frame_size (f
, f
->new_text_lines
, f
->new_text_cols
,
5713 /* Change the frame height and/or width. Values may be given as zero to
5714 indicate no change is to take place.
5716 If DELAY is non-zero, then assume we're being called from a signal
5717 handler, and queue the change for later - perhaps the next
5718 redisplay. Since this tries to resize windows, we can't call it
5719 from a signal handler.
5721 SAFE non-zero means this function is called from a place where it's
5722 safe to change frame sizes while a redisplay is in progress. */
5725 change_frame_size (register struct frame
*f
, int newheight
, int newwidth
, int pretend
, int delay
, int safe
)
5727 Lisp_Object tail
, frame
;
5729 if (FRAME_MSDOS_P (f
))
5731 /* On MS-DOS, all frames use the same screen, so a change in
5732 size affects all frames. Termcap now supports multiple
5734 FOR_EACH_FRAME (tail
, frame
)
5735 if (! FRAME_WINDOW_P (XFRAME (frame
)))
5736 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
5737 pretend
, delay
, safe
);
5740 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
, safe
);
5744 change_frame_size_1 (register struct frame
*f
, int newheight
, int newwidth
, int pretend
, int delay
, int safe
)
5746 int new_frame_total_cols
;
5747 ptrdiff_t count
= SPECPDL_INDEX ();
5749 /* If we can't deal with the change now, queue it for later. */
5750 if (delay
|| (redisplaying_p
&& !safe
))
5752 f
->new_text_lines
= newheight
;
5753 f
->new_text_cols
= newwidth
;
5754 delayed_size_change
= 1;
5758 /* This size-change overrides any pending one for this frame. */
5759 f
->new_text_lines
= 0;
5760 f
->new_text_cols
= 0;
5762 /* If an argument is zero, set it to the current value. */
5764 newheight
= FRAME_LINES (f
);
5766 newwidth
= FRAME_COLS (f
);
5768 /* Compute width of windows in F. */
5769 /* Round up to the smallest acceptable size. */
5770 check_frame_size (f
, &newheight
, &newwidth
);
5772 /* This is the width of the frame with vertical scroll bars and fringe
5773 columns. Do this after rounding - see discussion of bug#9723. */
5774 new_frame_total_cols
= FRAME_TOTAL_COLS_ARG (f
, newwidth
);
5776 /* If we're not changing the frame size, quit now. */
5777 /* Frame width may be unchanged but the text portion may change, for
5778 example, fullscreen and remove/add scroll bar. */
5779 if (newheight
== FRAME_LINES (f
)
5780 /* Text portion unchanged? */
5781 && newwidth
== FRAME_COLS (f
)
5782 /* Frame width unchanged? */
5783 && new_frame_total_cols
== FRAME_TOTAL_COLS (f
))
5789 /* We only can set screen dimensions to certain values supported
5790 by our video hardware. Try to find the smallest size greater
5791 or equal to the requested dimensions. */
5792 dos_set_window_size (&newheight
, &newwidth
);
5795 if (newheight
!= FRAME_LINES (f
))
5797 resize_frame_windows (f
, newheight
, 0);
5799 /* MSDOS frames cannot PRETEND, as they change frame size by
5800 manipulating video hardware. */
5801 if ((FRAME_TERMCAP_P (f
) && !pretend
) || FRAME_MSDOS_P (f
))
5802 FrameRows (FRAME_TTY (f
)) = newheight
;
5805 if (new_frame_total_cols
!= FRAME_TOTAL_COLS (f
))
5807 resize_frame_windows (f
, new_frame_total_cols
, 1);
5809 /* MSDOS frames cannot PRETEND, as they change frame size by
5810 manipulating video hardware. */
5811 if ((FRAME_TERMCAP_P (f
) && !pretend
) || FRAME_MSDOS_P (f
))
5812 FrameCols (FRAME_TTY (f
)) = newwidth
;
5814 if (WINDOWP (f
->tool_bar_window
))
5815 XSETFASTINT (XWINDOW (f
->tool_bar_window
)->total_cols
, newwidth
);
5818 FRAME_LINES (f
) = newheight
;
5819 SET_FRAME_COLS (f
, newwidth
);
5822 struct window
*w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
5823 int text_area_x
, text_area_y
, text_area_width
, text_area_height
;
5825 window_box (w
, TEXT_AREA
, &text_area_x
, &text_area_y
, &text_area_width
,
5827 if (w
->cursor
.x
>= text_area_x
+ text_area_width
)
5828 w
->cursor
.hpos
= w
->cursor
.x
= 0;
5829 if (w
->cursor
.y
>= text_area_y
+ text_area_height
)
5830 w
->cursor
.vpos
= w
->cursor
.y
= 0;
5834 calculate_costs (f
);
5835 SET_FRAME_GARBAGED (f
);
5840 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
5842 run_window_configuration_change_hook (f
);
5844 unbind_to (count
, Qnil
);
5849 /***********************************************************************
5850 Terminal Related Lisp Functions
5851 ***********************************************************************/
5853 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
5854 1, 1, "FOpen termscript file: ",
5855 doc
: /* Start writing all terminal output to FILE as well as the terminal.
5856 FILE = nil means just close any termscript file currently open. */)
5859 struct tty_display_info
*tty
;
5861 if (! FRAME_TERMCAP_P (SELECTED_FRAME ())
5862 && ! FRAME_MSDOS_P (SELECTED_FRAME ()))
5863 error ("Current frame is not on a tty device");
5867 if (tty
->termscript
!= 0)
5870 fclose (tty
->termscript
);
5873 tty
->termscript
= 0;
5877 file
= Fexpand_file_name (file
, Qnil
);
5878 tty
->termscript
= fopen (SSDATA (file
), "w");
5879 if (tty
->termscript
== 0)
5880 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
5886 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
5887 Ssend_string_to_terminal
, 1, 2, 0,
5888 doc
: /* Send STRING to the terminal without alteration.
5889 Control characters in STRING will have terminal-dependent effects.
5891 Optional parameter TERMINAL specifies the tty terminal device to use.
5892 It may be a terminal object, a frame, or nil for the terminal used by
5893 the currently selected frame. In batch mode, STRING is sent to stdout
5894 when TERMINAL is nil. */)
5895 (Lisp_Object string
, Lisp_Object terminal
)
5897 struct terminal
*t
= get_terminal (terminal
, 1);
5900 /* ??? Perhaps we should do something special for multibyte strings here. */
5901 CHECK_STRING (string
);
5905 error ("Unknown terminal device");
5907 if (t
->type
== output_initial
)
5909 else if (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
)
5910 error ("Device %d is not a termcap terminal device", t
->id
);
5913 struct tty_display_info
*tty
= t
->display_info
.tty
;
5916 error ("Terminal is currently suspended");
5918 if (tty
->termscript
)
5920 fwrite (SDATA (string
), 1, SBYTES (string
), tty
->termscript
);
5921 fflush (tty
->termscript
);
5925 fwrite (SDATA (string
), 1, SBYTES (string
), out
);
5932 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
5933 doc
: /* Beep, or flash the screen.
5934 Also, unless an argument is given,
5935 terminate any keyboard macro currently executing. */)
5943 ring_bell (XFRAME (selected_frame
));
5952 bitch_at_user (void)
5956 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
5957 error ("Keyboard macro terminated by a command ringing the bell");
5959 ring_bell (XFRAME (selected_frame
));
5964 /***********************************************************************
5966 ***********************************************************************/
5968 /* Convert a positive value DURATION to a seconds count *PSEC plus a
5969 microseconds count *PUSEC, rounding up. On overflow return the
5972 duration_to_sec_usec (double duration
, int *psec
, int *pusec
)
5974 int MILLION
= 1000000;
5975 int sec
= INT_MAX
, usec
= MILLION
- 1;
5977 if (duration
< INT_MAX
+ 1.0)
5980 double usdouble
= (duration
- s
) * MILLION
;
5981 int usfloor
= usdouble
;
5982 int usceil
= usfloor
+ (usfloor
< usdouble
);
5984 if (usceil
< MILLION
)
5989 else if (sec
< INT_MAX
)
6000 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
6001 doc
: /* Pause, without updating display, for SECONDS seconds.
6002 SECONDS may be a floating-point value, meaning that you can wait for a
6003 fraction of a second. Optional second arg MILLISECONDS specifies an
6004 additional wait period, in milliseconds; this may be useful if your
6005 Emacs was built without floating point support.
6006 \(Not all operating systems support waiting for a fraction of a second.) */)
6007 (Lisp_Object seconds
, Lisp_Object milliseconds
)
6010 double duration
= extract_float (seconds
);
6012 if (!NILP (milliseconds
))
6014 CHECK_NUMBER (milliseconds
);
6015 duration
+= XINT (milliseconds
) / 1000.0;
6018 if (! (0 < duration
))
6021 duration_to_sec_usec (duration
, &sec
, &usec
);
6023 #ifndef EMACS_HAS_USECS
6024 if (sec
== 0 && usec
!= 0)
6025 error ("Millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
6028 wait_reading_process_output (sec
, usec
, 0, 0, Qnil
, NULL
, 0);
6034 /* This is just like wait_reading_process_output, except that
6037 TIMEOUT is number of seconds to wait (float or integer),
6038 or t to wait forever.
6039 READING is 1 if reading input.
6040 If DO_DISPLAY is >0 display process output while waiting.
6041 If DO_DISPLAY is >1 perform an initial redisplay before waiting.
6045 sit_for (Lisp_Object timeout
, int reading
, int do_display
)
6049 swallow_events (do_display
);
6051 if ((detect_input_pending_run_timers (do_display
))
6052 || !NILP (Vexecuting_kbd_macro
))
6055 if (do_display
>= 2)
6056 redisplay_preserve_echo_area (2);
6058 if (EQ (timeout
, Qt
))
6065 double duration
= extract_float (timeout
);
6067 if (! (0 < duration
))
6070 duration_to_sec_usec (duration
, &sec
, &usec
);
6077 wait_reading_process_output (sec
, usec
, reading
? -1 : 1, do_display
,
6080 return detect_input_pending () ? Qnil
: Qt
;
6084 DEFUN ("redisplay", Fredisplay
, Sredisplay
, 0, 1, 0,
6085 doc
: /* Perform redisplay.
6086 Optional arg FORCE, if non-nil, prevents redisplay from being
6087 preempted by arriving input, even if `redisplay-dont-pause' is nil.
6088 If `redisplay-dont-pause' is non-nil (the default), redisplay is never
6089 preempted by arriving input, so FORCE does nothing.
6091 Return t if redisplay was performed, nil if redisplay was preempted
6092 immediately by pending input. */)
6098 if ((detect_input_pending_run_timers (1)
6099 && NILP (force
) && !redisplay_dont_pause
)
6100 || !NILP (Vexecuting_kbd_macro
))
6103 count
= SPECPDL_INDEX ();
6104 if (!NILP (force
) && !redisplay_dont_pause
)
6105 specbind (Qredisplay_dont_pause
, Qt
);
6106 redisplay_preserve_echo_area (2);
6107 unbind_to (count
, Qnil
);
6113 /***********************************************************************
6114 Other Lisp Functions
6115 ***********************************************************************/
6117 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
6118 session's frames, frame names, buffers, buffer-read-only flags, and
6119 buffer-modified-flags. */
6121 static Lisp_Object frame_and_buffer_state
;
6124 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
6125 Sframe_or_buffer_changed_p
, 0, 1, 0,
6126 doc
: /* Return non-nil if the frame and buffer state appears to have changed.
6127 VARIABLE is a variable name whose value is either nil or a state vector
6128 that will be updated to contain all frames and buffers,
6129 aside from buffers whose names start with space,
6130 along with the buffers' read-only and modified flags. This allows a fast
6131 check to see whether buffer menus might need to be recomputed.
6132 If this function returns non-nil, it updates the internal vector to reflect
6135 If VARIABLE is nil, an internal variable is used. Users should not
6136 pass nil for VARIABLE. */)
6137 (Lisp_Object variable
)
6139 Lisp_Object state
, tail
, frame
, buf
;
6140 Lisp_Object
*vecp
, *end
;
6143 if (! NILP (variable
))
6145 CHECK_SYMBOL (variable
);
6146 state
= Fsymbol_value (variable
);
6147 if (! VECTORP (state
))
6151 state
= frame_and_buffer_state
;
6153 vecp
= XVECTOR (state
)->contents
;
6154 end
= vecp
+ ASIZE (state
);
6156 FOR_EACH_FRAME (tail
, frame
)
6160 if (!EQ (*vecp
++, frame
))
6164 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
6167 /* Check that the buffer info matches. */
6168 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
6170 buf
= XCDR (XCAR (tail
));
6171 /* Ignore buffers that aren't included in buffer lists. */
6172 if (SREF (BVAR (XBUFFER (buf
), name
), 0) == ' ')
6176 if (!EQ (*vecp
++, buf
))
6180 if (!EQ (*vecp
++, BVAR (XBUFFER (buf
), read_only
)))
6184 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
6189 /* Detect deletion of a buffer at the end of the list. */
6190 if (EQ (*vecp
, Qlambda
))
6193 /* Come here if we decide the data has changed. */
6195 /* Count the size we will need.
6196 Start with 1 so there is room for at least one lambda at the end. */
6198 FOR_EACH_FRAME (tail
, frame
)
6200 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
6202 /* Reallocate the vector if data has grown to need it,
6203 or if it has shrunk a lot. */
6204 if (! VECTORP (state
)
6205 || n
> ASIZE (state
)
6206 || n
+ 20 < ASIZE (state
) / 2)
6207 /* Add 20 extra so we grow it less often. */
6209 state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
6210 if (! NILP (variable
))
6211 Fset (variable
, state
);
6213 frame_and_buffer_state
= state
;
6216 /* Record the new data in the (possibly reallocated) vector. */
6217 vecp
= XVECTOR (state
)->contents
;
6218 FOR_EACH_FRAME (tail
, frame
)
6221 *vecp
++ = XFRAME (frame
)->name
;
6223 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
6225 buf
= XCDR (XCAR (tail
));
6226 /* Ignore buffers that aren't included in buffer lists. */
6227 if (SREF (BVAR (XBUFFER (buf
), name
), 0) == ' ')
6230 *vecp
++ = BVAR (XBUFFER (buf
), read_only
);
6231 *vecp
++ = Fbuffer_modified_p (buf
);
6233 /* Fill up the vector with lambdas (always at least one). */
6235 while (vecp
- XVECTOR (state
)->contents
6238 /* Make sure we didn't overflow the vector. */
6239 if (vecp
- XVECTOR (state
)->contents
6247 /***********************************************************************
6249 ***********************************************************************/
6251 /* Initialization done when Emacs fork is started, before doing stty.
6252 Determine terminal type and set terminal_driver. Then invoke its
6253 decoding routine to set up variables in the terminal package. */
6258 char *terminal_type
;
6260 /* Construct the space glyph. */
6261 space_glyph
.type
= CHAR_GLYPH
;
6262 SET_CHAR_GLYPH (space_glyph
, ' ', DEFAULT_FACE_ID
, 0);
6263 space_glyph
.charpos
= -1;
6266 cursor_in_echo_area
= 0;
6267 terminal_type
= (char *) 0;
6269 /* Now is the time to initialize this; it's used by init_sys_modes
6271 Vinitial_window_system
= Qnil
;
6273 /* SIGWINCH needs to be handled no matter what display we start
6274 with. Otherwise newly opened tty frames will not resize
6279 #endif /* CANNOT_DUMP */
6280 signal (SIGWINCH
, window_change_signal
);
6281 #endif /* SIGWINCH */
6283 /* If running as a daemon, no need to initialize any frames/terminal. */
6287 /* If the user wants to use a window system, we shouldn't bother
6288 initializing the terminal. This is especially important when the
6289 terminal is so dumb that emacs gives up before and doesn't bother
6290 using the window system.
6292 If the DISPLAY environment variable is set and nonempty,
6293 try to use X, and die with an error message if that doesn't work. */
6295 #ifdef HAVE_X_WINDOWS
6296 if (! inhibit_window_system
&& ! display_arg
)
6299 display
= getenv ("DISPLAY");
6300 display_arg
= (display
!= 0 && *display
!= 0);
6302 if (display_arg
&& !x_display_ok (display
))
6304 fprintf (stderr
, "Display %s unavailable, simulating -nw\n",
6306 inhibit_window_system
= 1;
6310 if (!inhibit_window_system
&& display_arg
)
6312 Vinitial_window_system
= Qx
;
6314 Vwindow_system_version
= make_number (11);
6317 /* In some versions of ncurses,
6318 tputs crashes if we have not called tgetent.
6320 { char b
[2044]; tgetent (b
, "xterm");}
6322 adjust_frame_glyphs_initially ();
6325 #endif /* HAVE_X_WINDOWS */
6328 if (!inhibit_window_system
)
6330 Vinitial_window_system
= Qw32
;
6331 Vwindow_system_version
= make_number (1);
6332 adjust_frame_glyphs_initially ();
6335 #endif /* HAVE_NTGUI */
6338 if (!inhibit_window_system
6344 Vinitial_window_system
= Qns
;
6345 Vwindow_system_version
= make_number (10);
6346 adjust_frame_glyphs_initially ();
6351 /* If no window system has been specified, try to use the terminal. */
6354 fatal ("standard input is not a tty");
6359 terminal_type
= "w32console";
6361 /* Look at the TERM variable. */
6362 terminal_type
= (char *) getenv ("TERM");
6366 #ifdef HAVE_WINDOW_SYSTEM
6367 if (! inhibit_window_system
)
6368 fprintf (stderr
, "Please set the environment variable DISPLAY or TERM (see `tset').\n");
6370 #endif /* HAVE_WINDOW_SYSTEM */
6371 fprintf (stderr
, "Please set the environment variable TERM; see `tset'.\n");
6377 struct frame
*f
= XFRAME (selected_frame
);
6379 /* Open a display on the controlling tty. */
6380 t
= init_tty (0, terminal_type
, 1); /* Errors are fatal. */
6382 /* Convert the initial frame to use the new display. */
6383 if (f
->output_method
!= output_initial
)
6385 f
->output_method
= t
->type
;
6388 t
->reference_count
++;
6390 f
->output_data
.tty
->display_info
= &the_only_display_info
;
6392 if (f
->output_method
== output_termcap
)
6393 create_tty_output (f
);
6395 t
->display_info
.tty
->top_frame
= selected_frame
;
6396 change_frame_size (XFRAME (selected_frame
),
6397 FrameRows (t
->display_info
.tty
),
6398 FrameCols (t
->display_info
.tty
), 0, 0, 1);
6400 /* Delete the initial terminal. */
6401 if (--initial_terminal
->reference_count
== 0
6402 && initial_terminal
->delete_terminal_hook
)
6403 (*initial_terminal
->delete_terminal_hook
) (initial_terminal
);
6405 /* Update frame parameters to reflect the new type. */
6406 Fmodify_frame_parameters
6407 (selected_frame
, Fcons (Fcons (Qtty_type
,
6408 Ftty_type (selected_frame
)), Qnil
));
6409 if (t
->display_info
.tty
->name
)
6410 Fmodify_frame_parameters (selected_frame
,
6411 Fcons (Fcons (Qtty
, build_string (t
->display_info
.tty
->name
)),
6414 Fmodify_frame_parameters (selected_frame
, Fcons (Fcons (Qtty
, Qnil
),
6419 struct frame
*sf
= SELECTED_FRAME ();
6420 int width
= FRAME_TOTAL_COLS (sf
);
6421 int height
= FRAME_LINES (sf
);
6423 /* If these sizes are so big they cause overflow, just ignore the
6424 change. It's not clear what better we could do. The rest of
6425 the code assumes that (width + 2) * height * sizeof (struct glyph)
6426 does not overflow and does not exceed PTRDIFF_MAX or SIZE_MAX. */
6427 if (INT_ADD_RANGE_OVERFLOW (width
, 2, INT_MIN
, INT_MAX
)
6428 || INT_MULTIPLY_RANGE_OVERFLOW (width
+ 2, height
, INT_MIN
, INT_MAX
)
6429 || (min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof (struct glyph
)
6430 < (width
+ 2) * height
))
6431 fatal ("screen size %dx%d too big", width
, height
);
6434 adjust_frame_glyphs_initially ();
6435 calculate_costs (XFRAME (selected_frame
));
6437 /* Set up faces of the initial terminal frame of a dumped Emacs. */
6440 && NILP (Vinitial_window_system
))
6442 /* For the initial frame, we don't have any way of knowing what
6443 are the foreground and background colors of the terminal. */
6444 struct frame
*sf
= SELECTED_FRAME ();
6446 FRAME_FOREGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_FG_COLOR
;
6447 FRAME_BACKGROUND_PIXEL (sf
) = FACE_TTY_DEFAULT_BG_COLOR
;
6448 call0 (intern ("tty-set-up-initial-frame-faces"));
6454 /***********************************************************************
6456 ***********************************************************************/
6458 DEFUN ("internal-show-cursor", Finternal_show_cursor
,
6459 Sinternal_show_cursor
, 2, 2, 0,
6460 doc
: /* Set the cursor-visibility flag of WINDOW to SHOW.
6461 WINDOW nil means use the selected window. SHOW non-nil means
6462 show a cursor in WINDOW in the next redisplay. SHOW nil means
6463 don't show a cursor. */)
6464 (Lisp_Object window
, Lisp_Object show
)
6466 /* Don't change cursor state while redisplaying. This could confuse
6468 if (!redisplaying_p
)
6471 window
= selected_window
;
6473 CHECK_WINDOW (window
);
6475 XWINDOW (window
)->cursor_off_p
= NILP (show
);
6482 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p
,
6483 Sinternal_show_cursor_p
, 0, 1, 0,
6484 doc
: /* Value is non-nil if next redisplay will display a cursor in WINDOW.
6485 WINDOW nil or omitted means report on the selected window. */)
6486 (Lisp_Object window
)
6491 window
= selected_window
;
6493 CHECK_WINDOW (window
);
6495 w
= XWINDOW (window
);
6496 return w
->cursor_off_p
? Qnil
: Qt
;
6499 DEFUN ("last-nonminibuffer-frame", Flast_nonminibuf_frame
,
6500 Slast_nonminibuf_frame
, 0, 0, 0,
6501 doc
: /* Value is last nonminibuffer frame. */)
6504 Lisp_Object frame
= Qnil
;
6506 if (last_nonminibuf_frame
)
6507 XSETFRAME (frame
, last_nonminibuf_frame
);
6512 /***********************************************************************
6514 ***********************************************************************/
6517 syms_of_display (void)
6519 defsubr (&Sredraw_frame
);
6520 defsubr (&Sredraw_display
);
6521 defsubr (&Sframe_or_buffer_changed_p
);
6522 defsubr (&Sopen_termscript
);
6524 defsubr (&Sredisplay
);
6525 defsubr (&Ssleep_for
);
6526 defsubr (&Ssend_string_to_terminal
);
6527 defsubr (&Sinternal_show_cursor
);
6528 defsubr (&Sinternal_show_cursor_p
);
6529 defsubr (&Slast_nonminibuf_frame
);
6532 defsubr (&Sdump_redisplay_history
);
6535 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
6536 staticpro (&frame_and_buffer_state
);
6538 DEFSYM (Qdisplay_table
, "display-table");
6539 DEFSYM (Qredisplay_dont_pause
, "redisplay-dont-pause");
6541 DEFVAR_INT ("baud-rate", baud_rate
,
6542 doc
: /* The output baud rate of the terminal.
6543 On most systems, changing this value will affect the amount of padding
6544 and the other strategic decisions made during redisplay. */);
6546 DEFVAR_BOOL ("inverse-video", inverse_video
,
6547 doc
: /* Non-nil means invert the entire frame display.
6548 This means everything is in inverse video which otherwise would not be. */);
6550 DEFVAR_BOOL ("visible-bell", visible_bell
,
6551 doc
: /* Non-nil means try to flash the frame to represent a bell.
6553 See also `ring-bell-function'. */);
6555 DEFVAR_BOOL ("no-redraw-on-reenter", no_redraw_on_reenter
,
6556 doc
: /* Non-nil means no need to redraw entire frame after suspending.
6557 A non-nil value is useful if the terminal can automatically preserve
6558 Emacs's frame display when you reenter Emacs.
6559 It is up to you to set this variable if your terminal can do that. */);
6561 DEFVAR_LISP ("initial-window-system", Vinitial_window_system
,
6562 doc
: /* Name of the window system that Emacs uses for the first frame.
6563 The value is a symbol:
6564 nil for a termcap frame (a character-only terminal),
6565 'x' for an Emacs frame that is really an X window,
6566 'w32' for an Emacs frame that is a window on MS-Windows display,
6567 'ns' for an Emacs frame on a GNUstep or Macintosh Cocoa display,
6568 'pc' for a direct-write MS-DOS frame.
6570 Use of this variable as a boolean is deprecated. Instead,
6571 use `display-graphic-p' or any of the other `display-*-p'
6572 predicates which report frame's specific UI-related capabilities. */);
6574 DEFVAR_KBOARD ("window-system", Vwindow_system
,
6575 doc
: /* Name of window system through which the selected frame is displayed.
6576 The value is a symbol:
6577 nil for a termcap frame (a character-only terminal),
6578 'x' for an Emacs frame that is really an X window,
6579 'w32' for an Emacs frame that is a window on MS-Windows display,
6580 'ns' for an Emacs frame on a GNUstep or Macintosh Cocoa display,
6581 'pc' for a direct-write MS-DOS frame.
6583 Use of this variable as a boolean is deprecated. Instead,
6584 use `display-graphic-p' or any of the other `display-*-p'
6585 predicates which report frame's specific UI-related capabilities. */);
6587 DEFVAR_LISP ("window-system-version", Vwindow_system_version
,
6588 doc
: /* The version number of the window system in use.
6589 For X windows, this is 11. */);
6591 DEFVAR_BOOL ("cursor-in-echo-area", cursor_in_echo_area
,
6592 doc
: /* Non-nil means put cursor in minibuffer, at end of any message there. */);
6594 DEFVAR_LISP ("glyph-table", Vglyph_table
,
6595 doc
: /* Table defining how to output a glyph code to the frame.
6596 If not nil, this is a vector indexed by glyph code to define the glyph.
6597 Each element can be:
6598 integer: a glyph code which this glyph is an alias for.
6599 string: output this glyph using that string (not impl. in X windows).
6600 nil: this glyph mod 524288 is the code of a character to output,
6601 and this glyph / 524288 is the face number (see `face-id') to use
6602 while outputting it. */);
6603 Vglyph_table
= Qnil
;
6605 DEFVAR_LISP ("standard-display-table", Vstandard_display_table
,
6606 doc
: /* Display table to use for buffers that specify none.
6607 See `buffer-display-table' for more information. */);
6608 Vstandard_display_table
= Qnil
;
6610 DEFVAR_BOOL ("redisplay-dont-pause", redisplay_dont_pause
,
6611 doc
: /* Non-nil means display update isn't paused when input is detected. */);
6612 redisplay_dont_pause
= 1;
6614 #if PERIODIC_PREEMPTION_CHECKING
6615 DEFVAR_LISP ("redisplay-preemption-period", Vredisplay_preemption_period
,
6616 doc
: /* Period in seconds between checking for input during redisplay.
6617 This has an effect only if `redisplay-dont-pause' is nil; in that
6618 case, arriving input preempts redisplay until the input is processed.
6619 If the value is nil, redisplay is never preempted. */);
6620 Vredisplay_preemption_period
= make_float (0.10);
6627 Vinitial_window_system
= Qnil
;
6628 Vwindow_system_version
= Qnil
;