(safe_bcopy): Source pointer now points to const.
[bpt/emacs.git] / src / dispnew.c
1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 97, 98, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
4
5 This file is part of GNU Emacs.
6
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 2, or (at your option)
10 any later version.
11
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.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22 #include <config.h>
23 #include <signal.h>
24 #include <stdio.h>
25 #include <ctype.h>
26
27 #ifdef HAVE_UNISTD_H
28 #include <unistd.h>
29 #endif
30
31 #include "lisp.h"
32 #include "termchar.h"
33 #include "termopts.h"
34 #include "termhooks.h"
35 /* cm.h must come after dispextern.h on Windows. */
36 #include "dispextern.h"
37 #include "cm.h"
38 #include "buffer.h"
39 #include "charset.h"
40 #include "keyboard.h"
41 #include "frame.h"
42 #include "window.h"
43 #include "commands.h"
44 #include "disptab.h"
45 #include "indent.h"
46 #include "intervals.h"
47 #include "blockinput.h"
48 #include "process.h"
49
50 /* I don't know why DEC Alpha OSF1 fail to compile this file if we
51 include the following file. */
52 /* #include "systty.h" */
53 #include "syssignal.h"
54
55 #ifdef HAVE_X_WINDOWS
56 #include "xterm.h"
57 #endif /* HAVE_X_WINDOWS */
58
59 #ifdef HAVE_NTGUI
60 #include "w32term.h"
61 #endif /* HAVE_NTGUI */
62
63 #ifdef MAC_OS
64 #include "macterm.h"
65 #endif /* MAC_OS */
66
67 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
68
69 #include "systime.h"
70 #include <errno.h>
71
72 /* To get the prototype for `sleep'. */
73
74 #ifdef HAVE_UNISTD_H
75 #include <unistd.h>
76 #endif
77
78 /* Get number of chars of output now in the buffer of a stdio stream.
79 This ought to be built in in stdio, but it isn't. Some s- files
80 override this because their stdio internals differ. */
81
82 #ifdef __GNU_LIBRARY__
83
84 /* The s- file might have overridden the definition with one that
85 works for the system's C library. But we are using the GNU C
86 library, so this is the right definition for every system. */
87
88 #ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT
89 #define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT
90 #else
91 #undef PENDING_OUTPUT_COUNT
92 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
93 #endif
94 #else /* not __GNU_LIBRARY__ */
95 #if !defined (PENDING_OUTPUT_COUNT) && HAVE_STDIO_EXT_H && HAVE___FPENDING
96 #include <stdio_ext.h>
97 #define PENDING_OUTPUT_COUNT(FILE) __fpending (FILE)
98 #endif
99 #ifndef PENDING_OUTPUT_COUNT
100 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
101 #endif
102 #endif /* not __GNU_LIBRARY__ */
103
104 #if defined(HAVE_TERM_H) && defined (GNU_LINUX) && defined (HAVE_LIBNCURSES)
105 #include <term.h> /* for tgetent */
106 #endif
107 \f
108 /* Structure to pass dimensions around. Used for character bounding
109 boxes, glyph matrix dimensions and alike. */
110
111 struct dim
112 {
113 int width;
114 int height;
115 };
116
117 \f
118 /* Function prototypes. */
119
120 static struct glyph_matrix *save_current_matrix P_ ((struct frame *));
121 static void restore_current_matrix P_ ((struct frame *, struct glyph_matrix *));
122 static void fake_current_matrices P_ ((Lisp_Object));
123 static void redraw_overlapping_rows P_ ((struct window *, int));
124 static void redraw_overlapped_rows P_ ((struct window *, int));
125 static int count_blanks P_ ((struct glyph *, int));
126 static int count_match P_ ((struct glyph *, struct glyph *,
127 struct glyph *, struct glyph *));
128 static unsigned line_draw_cost P_ ((struct glyph_matrix *, int));
129 static void update_frame_line P_ ((struct frame *, int));
130 static struct dim allocate_matrices_for_frame_redisplay
131 P_ ((Lisp_Object, int, int, int, int *));
132 static void allocate_matrices_for_window_redisplay P_ ((struct window *));
133 static int realloc_glyph_pool P_ ((struct glyph_pool *, struct dim));
134 static void adjust_frame_glyphs P_ ((struct frame *));
135 struct glyph_matrix *new_glyph_matrix P_ ((struct glyph_pool *));
136 static void free_glyph_matrix P_ ((struct glyph_matrix *));
137 static void adjust_glyph_matrix P_ ((struct window *, struct glyph_matrix *,
138 int, int, struct dim));
139 static void change_frame_size_1 P_ ((struct frame *, int, int, int, int, int));
140 static void swap_glyph_pointers P_ ((struct glyph_row *, struct glyph_row *));
141 #if GLYPH_DEBUG
142 static int glyph_row_slice_p P_ ((struct glyph_row *, struct glyph_row *));
143 #endif
144 static void fill_up_frame_row_with_spaces P_ ((struct glyph_row *, int));
145 static void build_frame_matrix_from_window_tree P_ ((struct glyph_matrix *,
146 struct window *));
147 static void build_frame_matrix_from_leaf_window P_ ((struct glyph_matrix *,
148 struct window *));
149 static struct glyph_pool *new_glyph_pool P_ ((void));
150 static void free_glyph_pool P_ ((struct glyph_pool *));
151 static void adjust_frame_glyphs_initially P_ ((void));
152 static void adjust_frame_message_buffer P_ ((struct frame *));
153 static void adjust_decode_mode_spec_buffer P_ ((struct frame *));
154 static void fill_up_glyph_row_with_spaces P_ ((struct glyph_row *));
155 static void build_frame_matrix P_ ((struct frame *));
156 void clear_current_matrices P_ ((struct frame *));
157 void scroll_glyph_matrix_range P_ ((struct glyph_matrix *, int, int,
158 int, int));
159 static void clear_window_matrices P_ ((struct window *, int));
160 static void fill_up_glyph_row_area_with_spaces P_ ((struct glyph_row *, int));
161 static int scrolling_window P_ ((struct window *, int));
162 static int update_window_line P_ ((struct window *, int, int *));
163 static void update_marginal_area P_ ((struct window *, int, int));
164 static int update_text_area P_ ((struct window *, int));
165 static void make_current P_ ((struct glyph_matrix *, struct glyph_matrix *,
166 int));
167 static void mirror_make_current P_ ((struct window *, int));
168 void check_window_matrix_pointers P_ ((struct window *));
169 #if GLYPH_DEBUG
170 static void check_matrix_pointers P_ ((struct glyph_matrix *,
171 struct glyph_matrix *));
172 #endif
173 static void mirror_line_dance P_ ((struct window *, int, int, int *, char *));
174 static int update_window_tree P_ ((struct window *, int));
175 static int update_window P_ ((struct window *, int));
176 static int update_frame_1 P_ ((struct frame *, int, int));
177 static void set_window_cursor_after_update P_ ((struct window *));
178 static int row_equal_p P_ ((struct window *, struct glyph_row *,
179 struct glyph_row *, int));
180 static void adjust_frame_glyphs_for_window_redisplay P_ ((struct frame *));
181 static void adjust_frame_glyphs_for_frame_redisplay P_ ((struct frame *));
182 static void reverse_rows P_ ((struct glyph_matrix *, int, int));
183 static int margin_glyphs_to_reserve P_ ((struct window *, int, Lisp_Object));
184 static void sync_window_with_frame_matrix_rows P_ ((struct window *));
185 struct window *frame_row_to_window P_ ((struct window *, int));
186
187 \f
188 /* Non-zero means don't pause redisplay for pending input. (This is
189 for debugging and for a future implementation of EDT-like
190 scrolling. */
191
192 int redisplay_dont_pause;
193
194 /* Nonzero upon entry to redisplay means do not assume anything about
195 current contents of actual terminal frame; clear and redraw it. */
196
197 int frame_garbaged;
198
199 /* Nonzero means last display completed. Zero means it was preempted. */
200
201 int display_completed;
202
203 /* Lisp variable visible-bell; enables use of screen-flash instead of
204 audible bell. */
205
206 int visible_bell;
207
208 /* Invert the color of the whole frame, at a low level. */
209
210 int inverse_video;
211
212 /* Line speed of the terminal. */
213
214 EMACS_INT baud_rate;
215
216 /* Either nil or a symbol naming the window system under which Emacs
217 is running. */
218
219 Lisp_Object Vwindow_system;
220
221 /* Version number of X windows: 10, 11 or nil. */
222
223 Lisp_Object Vwindow_system_version;
224
225 /* Vector of glyph definitions. Indexed by glyph number, the contents
226 are a string which is how to output the glyph.
227
228 If Vglyph_table is nil, a glyph is output by using its low 8 bits
229 as a character code.
230
231 This is an obsolete feature that is no longer used. The variable
232 is retained for compatibility. */
233
234 Lisp_Object Vglyph_table;
235
236 /* Display table to use for vectors that don't specify their own. */
237
238 Lisp_Object Vstandard_display_table;
239
240 /* Nonzero means reading single-character input with prompt so put
241 cursor on mini-buffer after the prompt. Positive means at end of
242 text in echo area; negative means at beginning of line. */
243
244 int cursor_in_echo_area;
245
246 Lisp_Object Qdisplay_table, Qredisplay_dont_pause;
247
248 \f
249 /* The currently selected frame. In a single-frame version, this
250 variable always equals the_only_frame. */
251
252 Lisp_Object selected_frame;
253
254 /* A frame which is not just a mini-buffer, or 0 if there are no such
255 frames. This is usually the most recent such frame that was
256 selected. In a single-frame version, this variable always holds
257 the address of the_only_frame. */
258
259 struct frame *last_nonminibuf_frame;
260
261 /* Stdio stream being used for copy of all output. */
262
263 FILE *termscript;
264
265 /* Structure for info on cursor positioning. */
266
267 struct cm Wcm;
268
269 /* 1 means SIGWINCH happened when not safe. */
270
271 int delayed_size_change;
272
273 /* 1 means glyph initialization has been completed at startup. */
274
275 static int glyphs_initialized_initially_p;
276
277 /* Updated window if != 0. Set by update_window. */
278
279 struct window *updated_window;
280
281 /* Glyph row updated in update_window_line, and area that is updated. */
282
283 struct glyph_row *updated_row;
284 int updated_area;
285
286 /* A glyph for a space. */
287
288 struct glyph space_glyph;
289
290 /* Non-zero means update has been performed directly, so that there's
291 no need for redisplay_internal to do much work. Set by
292 direct_output_for_insert. */
293
294 int redisplay_performed_directly_p;
295
296 /* Counts of allocated structures. These counts serve to diagnose
297 memory leaks and double frees. */
298
299 int glyph_matrix_count;
300 int glyph_pool_count;
301
302 /* If non-null, the frame whose frame matrices are manipulated. If
303 null, window matrices are worked on. */
304
305 static struct frame *frame_matrix_frame;
306
307 /* Current interface for window-based redisplay. Set from init_xterm.
308 A null value means we are not using window-based redisplay. */
309
310 struct redisplay_interface *rif;
311
312 /* Non-zero means that fonts have been loaded since the last glyph
313 matrix adjustments. Redisplay must stop, and glyph matrices must
314 be adjusted when this flag becomes non-zero during display. The
315 reason fonts can be loaded so late is that fonts of fontsets are
316 loaded on demand. */
317
318 int fonts_changed_p;
319
320 /* Convert vpos and hpos from frame to window and vice versa.
321 This may only be used for terminal frames. */
322
323 #if GLYPH_DEBUG
324
325 static int window_to_frame_vpos P_ ((struct window *, int));
326 static int window_to_frame_hpos P_ ((struct window *, int));
327 #define WINDOW_TO_FRAME_VPOS(W, VPOS) window_to_frame_vpos ((W), (VPOS))
328 #define WINDOW_TO_FRAME_HPOS(W, HPOS) window_to_frame_hpos ((W), (HPOS))
329
330 /* One element of the ring buffer containing redisplay history
331 information. */
332
333 struct redisplay_history
334 {
335 char trace[512 + 100];
336 };
337
338 /* The size of the history buffer. */
339
340 #define REDISPLAY_HISTORY_SIZE 30
341
342 /* The redisplay history buffer. */
343
344 static struct redisplay_history redisplay_history[REDISPLAY_HISTORY_SIZE];
345
346 /* Next free entry in redisplay_history. */
347
348 static int history_idx;
349
350 /* A tick that's incremented each time something is added to the
351 history. */
352
353 static unsigned history_tick;
354
355 static void add_frame_display_history P_ ((struct frame *, int));
356 static void add_window_display_history P_ ((struct window *, char *, int));
357
358
359 /* Add to the redisplay history how window W has been displayed.
360 MSG is a trace containing the information how W's glyph matrix
361 has been constructed. PAUSED_P non-zero means that the update
362 has been interrupted for pending input. */
363
364 static void
365 add_window_display_history (w, msg, paused_p)
366 struct window *w;
367 char *msg;
368 int paused_p;
369 {
370 char *buf;
371
372 if (history_idx >= REDISPLAY_HISTORY_SIZE)
373 history_idx = 0;
374 buf = redisplay_history[history_idx].trace;
375 ++history_idx;
376
377 sprintf (buf, "%d: window %p (`%s')%s\n",
378 history_tick++,
379 w,
380 ((BUFFERP (w->buffer)
381 && STRINGP (XBUFFER (w->buffer)->name))
382 ? (char *) SDATA (XBUFFER (w->buffer)->name)
383 : "???"),
384 paused_p ? " ***paused***" : "");
385 strcat (buf, msg);
386 }
387
388
389 /* Add to the redisplay history that frame F has been displayed.
390 PAUSED_P non-zero means that the update has been interrupted for
391 pending input. */
392
393 static void
394 add_frame_display_history (f, paused_p)
395 struct frame *f;
396 int paused_p;
397 {
398 char *buf;
399
400 if (history_idx >= REDISPLAY_HISTORY_SIZE)
401 history_idx = 0;
402 buf = redisplay_history[history_idx].trace;
403 ++history_idx;
404
405 sprintf (buf, "%d: update frame %p%s",
406 history_tick++,
407 f, paused_p ? " ***paused***" : "");
408 }
409
410
411 DEFUN ("dump-redisplay-history", Fdump_redisplay_history,
412 Sdump_redisplay_history, 0, 0, "",
413 doc: /* Dump redisplay history to stderr. */)
414 ()
415 {
416 int i;
417
418 for (i = history_idx - 1; i != history_idx; --i)
419 {
420 if (i < 0)
421 i = REDISPLAY_HISTORY_SIZE - 1;
422 fprintf (stderr, "%s\n", redisplay_history[i].trace);
423 }
424
425 return Qnil;
426 }
427
428
429 #else /* GLYPH_DEBUG == 0 */
430
431 #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + XFASTINT ((W)->top))
432 #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + XFASTINT ((W)->left))
433
434 #endif /* GLYPH_DEBUG == 0 */
435
436
437 /* Like bcopy except never gets confused by overlap. Let this be the
438 first function defined in this file, or change emacs.c where the
439 address of this function is used. */
440
441 void
442 safe_bcopy (from, to, size)
443 const char *from;
444 char *to;
445 int size;
446 {
447 if (size <= 0 || from == to)
448 return;
449
450 /* If the source and destination don't overlap, then bcopy can
451 handle it. If they do overlap, but the destination is lower in
452 memory than the source, we'll assume bcopy can handle that. */
453 if (to < from || from + size <= to)
454 bcopy (from, to, size);
455
456 /* Otherwise, we'll copy from the end. */
457 else
458 {
459 register const char *endf = from + size;
460 register char *endt = to + size;
461
462 /* If TO - FROM is large, then we should break the copy into
463 nonoverlapping chunks of TO - FROM bytes each. However, if
464 TO - FROM is small, then the bcopy function call overhead
465 makes this not worth it. The crossover point could be about
466 anywhere. Since I don't think the obvious copy loop is too
467 bad, I'm trying to err in its favor. */
468 if (to - from < 64)
469 {
470 do
471 *--endt = *--endf;
472 while (endf != from);
473 }
474 else
475 {
476 for (;;)
477 {
478 endt -= (to - from);
479 endf -= (to - from);
480
481 if (endt < to)
482 break;
483
484 bcopy (endf, endt, to - from);
485 }
486
487 /* If SIZE wasn't a multiple of TO - FROM, there will be a
488 little left over. The amount left over is (endt + (to -
489 from)) - to, which is endt - from. */
490 bcopy (from, to, endt - from);
491 }
492 }
493 }
494
495
496 \f
497 /***********************************************************************
498 Glyph Matrices
499 ***********************************************************************/
500
501 /* Allocate and return a glyph_matrix structure. POOL is the glyph
502 pool from which memory for the matrix should be allocated, or null
503 for window-based redisplay where no glyph pools are used. The
504 member `pool' of the glyph matrix structure returned is set to
505 POOL, the structure is otherwise zeroed. */
506
507 struct glyph_matrix *
508 new_glyph_matrix (pool)
509 struct glyph_pool *pool;
510 {
511 struct glyph_matrix *result;
512
513 /* Allocate and clear. */
514 result = (struct glyph_matrix *) xmalloc (sizeof *result);
515 bzero (result, sizeof *result);
516
517 /* Increment number of allocated matrices. This count is used
518 to detect memory leaks. */
519 ++glyph_matrix_count;
520
521 /* Set pool and return. */
522 result->pool = pool;
523 return result;
524 }
525
526
527 /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed.
528
529 The global counter glyph_matrix_count is decremented when a matrix
530 is freed. If the count gets negative, more structures were freed
531 than allocated, i.e. one matrix was freed more than once or a bogus
532 pointer was passed to this function.
533
534 If MATRIX->pool is null, this means that the matrix manages its own
535 glyph memory---this is done for matrices on X frames. Freeing the
536 matrix also frees the glyph memory in this case. */
537
538 static void
539 free_glyph_matrix (matrix)
540 struct glyph_matrix *matrix;
541 {
542 if (matrix)
543 {
544 int i;
545
546 /* Detect the case that more matrices are freed than were
547 allocated. */
548 if (--glyph_matrix_count < 0)
549 abort ();
550
551 /* Free glyph memory if MATRIX owns it. */
552 if (matrix->pool == NULL)
553 for (i = 0; i < matrix->rows_allocated; ++i)
554 xfree (matrix->rows[i].glyphs[LEFT_MARGIN_AREA]);
555
556 /* Free row structures and the matrix itself. */
557 xfree (matrix->rows);
558 xfree (matrix);
559 }
560 }
561
562
563 /* Return the number of glyphs to reserve for a marginal area of
564 window W. TOTAL_GLYPHS is the number of glyphs in a complete
565 display line of window W. MARGIN gives the width of the marginal
566 area in canonical character units. MARGIN should be an integer
567 or a float. */
568
569 static int
570 margin_glyphs_to_reserve (w, total_glyphs, margin)
571 struct window *w;
572 int total_glyphs;
573 Lisp_Object margin;
574 {
575 int n;
576
577 if (NUMBERP (margin))
578 {
579 int width = XFASTINT (w->width);
580 double d = max (0, XFLOATINT (margin));
581 d = min (width / 2 - 1, d);
582 n = (int) ((double) total_glyphs / width * d);
583 }
584 else
585 n = 0;
586
587 return n;
588 }
589
590
591 /* Adjust glyph matrix MATRIX on window W or on a frame to changed
592 window sizes.
593
594 W is null if the function is called for a frame glyph matrix.
595 Otherwise it is the window MATRIX is a member of. X and Y are the
596 indices of the first column and row of MATRIX within the frame
597 matrix, if such a matrix exists. They are zero for purely
598 window-based redisplay. DIM is the needed size of the matrix.
599
600 In window-based redisplay, where no frame matrices exist, glyph
601 matrices manage their own glyph storage. Otherwise, they allocate
602 storage from a common frame glyph pool which can be found in
603 MATRIX->pool.
604
605 The reason for this memory management strategy is to avoid complete
606 frame redraws if possible. When we allocate from a common pool, a
607 change of the location or size of a sub-matrix within the pool
608 requires a complete redisplay of the frame because we cannot easily
609 make sure that the current matrices of all windows still agree with
610 what is displayed on the screen. While this is usually fast, it
611 leads to screen flickering. */
612
613 static void
614 adjust_glyph_matrix (w, matrix, x, y, dim)
615 struct window *w;
616 struct glyph_matrix *matrix;
617 int x, y;
618 struct dim dim;
619 {
620 int i;
621 int new_rows;
622 int marginal_areas_changed_p = 0;
623 int header_line_changed_p = 0;
624 int header_line_p = 0;
625 int left = -1, right = -1;
626 int window_x, window_y, window_width = -1, window_height;
627
628 /* See if W had a header line that has disappeared now, or vice versa. */
629 if (w)
630 {
631 header_line_p = WINDOW_WANTS_HEADER_LINE_P (w);
632 header_line_changed_p = header_line_p != matrix->header_line_p;
633 }
634 matrix->header_line_p = header_line_p;
635
636 /* Do nothing if MATRIX' size, position, vscroll, and marginal areas
637 haven't changed. This optimization is important because preserving
638 the matrix means preventing redisplay. */
639 if (matrix->pool == NULL)
640 {
641 window_box (w, -1, &window_x, &window_y, &window_width, &window_height);
642 left = margin_glyphs_to_reserve (w, dim.width, w->left_margin_width);
643 right = margin_glyphs_to_reserve (w, dim.width, w->right_margin_width);
644 xassert (left >= 0 && right >= 0);
645 marginal_areas_changed_p = (left != matrix->left_margin_glyphs
646 || right != matrix->right_margin_glyphs);
647
648 if (!marginal_areas_changed_p
649 && !fonts_changed_p
650 && !header_line_changed_p
651 && matrix->window_left_x == XFASTINT (w->left)
652 && matrix->window_top_y == XFASTINT (w->top)
653 && matrix->window_height == window_height
654 && matrix->window_vscroll == w->vscroll
655 && matrix->window_width == window_width)
656 return;
657 }
658
659 /* Enlarge MATRIX->rows if necessary. New rows are cleared. */
660 if (matrix->rows_allocated < dim.height)
661 {
662 int size = dim.height * sizeof (struct glyph_row);
663 new_rows = dim.height - matrix->rows_allocated;
664 matrix->rows = (struct glyph_row *) xrealloc (matrix->rows, size);
665 bzero (matrix->rows + matrix->rows_allocated,
666 new_rows * sizeof *matrix->rows);
667 matrix->rows_allocated = dim.height;
668 }
669 else
670 new_rows = 0;
671
672 /* If POOL is not null, MATRIX is a frame matrix or a window matrix
673 on a frame not using window-based redisplay. Set up pointers for
674 each row into the glyph pool. */
675 if (matrix->pool)
676 {
677 xassert (matrix->pool->glyphs);
678
679 if (w)
680 {
681 left = margin_glyphs_to_reserve (w, dim.width,
682 w->left_margin_width);
683 right = margin_glyphs_to_reserve (w, dim.width,
684 w->right_margin_width);
685 }
686 else
687 left = right = 0;
688
689 for (i = 0; i < dim.height; ++i)
690 {
691 struct glyph_row *row = &matrix->rows[i];
692
693 row->glyphs[LEFT_MARGIN_AREA]
694 = (matrix->pool->glyphs
695 + (y + i) * matrix->pool->ncolumns
696 + x);
697
698 if (w == NULL
699 || row == matrix->rows + dim.height - 1
700 || (row == matrix->rows && matrix->header_line_p))
701 {
702 row->glyphs[TEXT_AREA]
703 = row->glyphs[LEFT_MARGIN_AREA];
704 row->glyphs[RIGHT_MARGIN_AREA]
705 = row->glyphs[TEXT_AREA] + dim.width;
706 row->glyphs[LAST_AREA]
707 = row->glyphs[RIGHT_MARGIN_AREA];
708 }
709 else
710 {
711 row->glyphs[TEXT_AREA]
712 = row->glyphs[LEFT_MARGIN_AREA] + left;
713 row->glyphs[RIGHT_MARGIN_AREA]
714 = row->glyphs[TEXT_AREA] + dim.width - left - right;
715 row->glyphs[LAST_AREA]
716 = row->glyphs[LEFT_MARGIN_AREA] + dim.width;
717 }
718 }
719
720 matrix->left_margin_glyphs = left;
721 matrix->right_margin_glyphs = right;
722 }
723 else
724 {
725 /* If MATRIX->pool is null, MATRIX is responsible for managing
726 its own memory. Allocate glyph memory from the heap. */
727 if (dim.width > matrix->matrix_w
728 || new_rows
729 || header_line_changed_p
730 || marginal_areas_changed_p)
731 {
732 struct glyph_row *row = matrix->rows;
733 struct glyph_row *end = row + matrix->rows_allocated;
734
735 while (row < end)
736 {
737 row->glyphs[LEFT_MARGIN_AREA]
738 = (struct glyph *) xrealloc (row->glyphs[LEFT_MARGIN_AREA],
739 (dim.width
740 * sizeof (struct glyph)));
741
742 /* The mode line never has marginal areas. */
743 if (row == matrix->rows + dim.height - 1
744 || (row == matrix->rows && matrix->header_line_p))
745 {
746 row->glyphs[TEXT_AREA]
747 = row->glyphs[LEFT_MARGIN_AREA];
748 row->glyphs[RIGHT_MARGIN_AREA]
749 = row->glyphs[TEXT_AREA] + dim.width;
750 row->glyphs[LAST_AREA]
751 = row->glyphs[RIGHT_MARGIN_AREA];
752 }
753 else
754 {
755 row->glyphs[TEXT_AREA]
756 = row->glyphs[LEFT_MARGIN_AREA] + left;
757 row->glyphs[RIGHT_MARGIN_AREA]
758 = row->glyphs[TEXT_AREA] + dim.width - left - right;
759 row->glyphs[LAST_AREA]
760 = row->glyphs[LEFT_MARGIN_AREA] + dim.width;
761 }
762 ++row;
763 }
764 }
765
766 xassert (left >= 0 && right >= 0);
767 matrix->left_margin_glyphs = left;
768 matrix->right_margin_glyphs = right;
769 }
770
771 /* Number of rows to be used by MATRIX. */
772 matrix->nrows = dim.height;
773 xassert (matrix->nrows >= 0);
774
775 if (w)
776 {
777 if (matrix == w->current_matrix)
778 {
779 /* Mark rows in a current matrix of a window as not having
780 valid contents. It's important to not do this for
781 desired matrices. When Emacs starts, it may already be
782 building desired matrices when this function runs. */
783 if (window_width < 0)
784 window_width = window_box_width (w, -1);
785
786 /* Optimize the case that only the height has changed (C-x 2,
787 upper window). Invalidate all rows that are no longer part
788 of the window. */
789 if (!marginal_areas_changed_p
790 && !header_line_changed_p
791 && new_rows == 0
792 && dim.width == matrix->matrix_w
793 && matrix->window_left_x == XFASTINT (w->left)
794 && matrix->window_top_y == XFASTINT (w->top)
795 && matrix->window_width == window_width)
796 {
797 /* Find the last row in the window. */
798 for (i = 0; i < matrix->nrows && matrix->rows[i].enabled_p; ++i)
799 if (MATRIX_ROW_BOTTOM_Y (matrix->rows + i) >= window_height)
800 {
801 ++i;
802 break;
803 }
804
805 /* Window end is invalid, if inside of the rows that
806 are invalidated below. */
807 if (INTEGERP (w->window_end_vpos)
808 && XFASTINT (w->window_end_vpos) >= i)
809 w->window_end_valid = Qnil;
810
811 while (i < matrix->nrows)
812 matrix->rows[i++].enabled_p = 0;
813 }
814 else
815 {
816 for (i = 0; i < matrix->nrows; ++i)
817 matrix->rows[i].enabled_p = 0;
818 }
819 }
820 else if (matrix == w->desired_matrix)
821 {
822 /* Rows in desired matrices always have to be cleared;
823 redisplay expects this is the case when it runs, so it
824 had better be the case when we adjust matrices between
825 redisplays. */
826 for (i = 0; i < matrix->nrows; ++i)
827 matrix->rows[i].enabled_p = 0;
828 }
829 }
830
831
832 /* Remember last values to be able to optimize frame redraws. */
833 matrix->matrix_x = x;
834 matrix->matrix_y = y;
835 matrix->matrix_w = dim.width;
836 matrix->matrix_h = dim.height;
837
838 /* Record the top y location and height of W at the time the matrix
839 was last adjusted. This is used to optimize redisplay above. */
840 if (w)
841 {
842 matrix->window_left_x = XFASTINT (w->left);
843 matrix->window_top_y = XFASTINT (w->top);
844 matrix->window_height = window_height;
845 matrix->window_width = window_width;
846 matrix->window_vscroll = w->vscroll;
847 }
848 }
849
850
851 /* Reverse the contents of rows in MATRIX between START and END. The
852 contents of the row at END - 1 end up at START, END - 2 at START +
853 1 etc. This is part of the implementation of rotate_matrix (see
854 below). */
855
856 static void
857 reverse_rows (matrix, start, end)
858 struct glyph_matrix *matrix;
859 int start, end;
860 {
861 int i, j;
862
863 for (i = start, j = end - 1; i < j; ++i, --j)
864 {
865 /* Non-ISO HP/UX compiler doesn't like auto struct
866 initialization. */
867 struct glyph_row temp;
868 temp = matrix->rows[i];
869 matrix->rows[i] = matrix->rows[j];
870 matrix->rows[j] = temp;
871 }
872 }
873
874
875 /* Rotate the contents of rows in MATRIX in the range FIRST .. LAST -
876 1 by BY positions. BY < 0 means rotate left, i.e. towards lower
877 indices. (Note: this does not copy glyphs, only glyph pointers in
878 row structures are moved around).
879
880 The algorithm used for rotating the vector was, I believe, first
881 described by Kernighan. See the vector R as consisting of two
882 sub-vectors AB, where A has length BY for BY >= 0. The result
883 after rotating is then BA. Reverse both sub-vectors to get ArBr
884 and reverse the result to get (ArBr)r which is BA. Similar for
885 rotating right. */
886
887 void
888 rotate_matrix (matrix, first, last, by)
889 struct glyph_matrix *matrix;
890 int first, last, by;
891 {
892 if (by < 0)
893 {
894 /* Up (rotate left, i.e. towards lower indices). */
895 by = -by;
896 reverse_rows (matrix, first, first + by);
897 reverse_rows (matrix, first + by, last);
898 reverse_rows (matrix, first, last);
899 }
900 else if (by > 0)
901 {
902 /* Down (rotate right, i.e. towards higher indices). */
903 reverse_rows (matrix, last - by, last);
904 reverse_rows (matrix, first, last - by);
905 reverse_rows (matrix, first, last);
906 }
907 }
908
909
910 /* Increment buffer positions in glyph rows of MATRIX. Do it for rows
911 with indices START <= index < END. Increment positions by DELTA/
912 DELTA_BYTES. */
913
914 void
915 increment_matrix_positions (matrix, start, end, delta, delta_bytes)
916 struct glyph_matrix *matrix;
917 int start, end, delta, delta_bytes;
918 {
919 /* Check that START and END are reasonable values. */
920 xassert (start >= 0 && start <= matrix->nrows);
921 xassert (end >= 0 && end <= matrix->nrows);
922 xassert (start <= end);
923
924 for (; start < end; ++start)
925 increment_row_positions (matrix->rows + start, delta, delta_bytes);
926 }
927
928
929 /* Enable a range of rows in glyph matrix MATRIX. START and END are
930 the row indices of the first and last + 1 row to enable. If
931 ENABLED_P is non-zero, enabled_p flags in rows will be set to 1. */
932
933 void
934 enable_glyph_matrix_rows (matrix, start, end, enabled_p)
935 struct glyph_matrix *matrix;
936 int start, end;
937 int enabled_p;
938 {
939 xassert (start <= end);
940 xassert (start >= 0 && start < matrix->nrows);
941 xassert (end >= 0 && end <= matrix->nrows);
942
943 for (; start < end; ++start)
944 matrix->rows[start].enabled_p = enabled_p != 0;
945 }
946
947
948 /* Clear MATRIX.
949
950 This empties all rows in MATRIX by setting the enabled_p flag for
951 all rows of the matrix to zero. The function prepare_desired_row
952 will eventually really clear a row when it sees one with a zero
953 enabled_p flag.
954
955 Resets update hints to defaults value. The only update hint
956 currently present is the flag MATRIX->no_scrolling_p. */
957
958 void
959 clear_glyph_matrix (matrix)
960 struct glyph_matrix *matrix;
961 {
962 if (matrix)
963 {
964 enable_glyph_matrix_rows (matrix, 0, matrix->nrows, 0);
965 matrix->no_scrolling_p = 0;
966 }
967 }
968
969
970 /* Shift part of the glyph matrix MATRIX of window W up or down.
971 Increment y-positions in glyph rows between START and END by DY,
972 and recompute their visible height. */
973
974 void
975 shift_glyph_matrix (w, matrix, start, end, dy)
976 struct window *w;
977 struct glyph_matrix *matrix;
978 int start, end, dy;
979 {
980 int min_y, max_y;
981
982 xassert (start <= end);
983 xassert (start >= 0 && start < matrix->nrows);
984 xassert (end >= 0 && end <= matrix->nrows);
985
986 min_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
987 max_y = WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w);
988
989 for (; start < end; ++start)
990 {
991 struct glyph_row *row = &matrix->rows[start];
992
993 row->y += dy;
994 row->visible_height = row->height;
995
996 if (row->y < min_y)
997 row->visible_height -= min_y - row->y;
998 if (row->y + row->height > max_y)
999 row->visible_height -= row->y + row->height - max_y;
1000 }
1001 }
1002
1003
1004 /* Mark all rows in current matrices of frame F as invalid. Marking
1005 invalid is done by setting enabled_p to zero for all rows in a
1006 current matrix. */
1007
1008 void
1009 clear_current_matrices (f)
1010 register struct frame *f;
1011 {
1012 /* Clear frame current matrix, if we have one. */
1013 if (f->current_matrix)
1014 clear_glyph_matrix (f->current_matrix);
1015
1016 /* Clear the matrix of the menu bar window, if such a window exists.
1017 The menu bar window is currently used to display menus on X when
1018 no toolkit support is compiled in. */
1019 if (WINDOWP (f->menu_bar_window))
1020 clear_glyph_matrix (XWINDOW (f->menu_bar_window)->current_matrix);
1021
1022 /* Clear the matrix of the tool-bar window, if any. */
1023 if (WINDOWP (f->tool_bar_window))
1024 clear_glyph_matrix (XWINDOW (f->tool_bar_window)->current_matrix);
1025
1026 /* Clear current window matrices. */
1027 xassert (WINDOWP (FRAME_ROOT_WINDOW (f)));
1028 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f)), 0);
1029 }
1030
1031
1032 /* Clear out all display lines of F for a coming redisplay. */
1033
1034 void
1035 clear_desired_matrices (f)
1036 register struct frame *f;
1037 {
1038 if (f->desired_matrix)
1039 clear_glyph_matrix (f->desired_matrix);
1040
1041 if (WINDOWP (f->menu_bar_window))
1042 clear_glyph_matrix (XWINDOW (f->menu_bar_window)->desired_matrix);
1043
1044 if (WINDOWP (f->tool_bar_window))
1045 clear_glyph_matrix (XWINDOW (f->tool_bar_window)->desired_matrix);
1046
1047 /* Do it for window matrices. */
1048 xassert (WINDOWP (FRAME_ROOT_WINDOW (f)));
1049 clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f)), 1);
1050 }
1051
1052
1053 /* Clear matrices in window tree rooted in W. If DESIRED_P is
1054 non-zero clear desired matrices, otherwise clear current matrices. */
1055
1056 static void
1057 clear_window_matrices (w, desired_p)
1058 struct window *w;
1059 int desired_p;
1060 {
1061 while (w)
1062 {
1063 if (!NILP (w->hchild))
1064 {
1065 xassert (WINDOWP (w->hchild));
1066 clear_window_matrices (XWINDOW (w->hchild), desired_p);
1067 }
1068 else if (!NILP (w->vchild))
1069 {
1070 xassert (WINDOWP (w->vchild));
1071 clear_window_matrices (XWINDOW (w->vchild), desired_p);
1072 }
1073 else
1074 {
1075 if (desired_p)
1076 clear_glyph_matrix (w->desired_matrix);
1077 else
1078 {
1079 clear_glyph_matrix (w->current_matrix);
1080 w->window_end_valid = Qnil;
1081 }
1082 }
1083
1084 w = NILP (w->next) ? 0 : XWINDOW (w->next);
1085 }
1086 }
1087
1088
1089 \f
1090 /***********************************************************************
1091 Glyph Rows
1092
1093 See dispextern.h for an overall explanation of glyph rows.
1094 ***********************************************************************/
1095
1096 /* Clear glyph row ROW. Do it in a way that makes it robust against
1097 changes in the glyph_row structure, i.e. addition or removal of
1098 structure members. */
1099
1100 static struct glyph_row null_row;
1101
1102 void
1103 clear_glyph_row (row)
1104 struct glyph_row *row;
1105 {
1106 struct glyph *p[1 + LAST_AREA];
1107
1108 /* Save pointers. */
1109 p[LEFT_MARGIN_AREA] = row->glyphs[LEFT_MARGIN_AREA];
1110 p[TEXT_AREA] = row->glyphs[TEXT_AREA];
1111 p[RIGHT_MARGIN_AREA] = row->glyphs[RIGHT_MARGIN_AREA];
1112 p[LAST_AREA] = row->glyphs[LAST_AREA];
1113
1114 /* Clear. */
1115 *row = null_row;
1116
1117 /* Restore pointers. */
1118 row->glyphs[LEFT_MARGIN_AREA] = p[LEFT_MARGIN_AREA];
1119 row->glyphs[TEXT_AREA] = p[TEXT_AREA];
1120 row->glyphs[RIGHT_MARGIN_AREA] = p[RIGHT_MARGIN_AREA];
1121 row->glyphs[LAST_AREA] = p[LAST_AREA];
1122
1123 #if 0 /* At some point, some bit-fields of struct glyph were not set,
1124 which made glyphs unequal when compared with GLYPH_EQUAL_P.
1125 Redisplay outputs such glyphs, and flickering effects were
1126 the result. This also depended on the contents of memory
1127 returned by xmalloc. If flickering happens again, activate
1128 the code below. If the flickering is gone with that, chances
1129 are that the flickering has the same reason as here. */
1130 bzero (p[0], (char *) p[LAST_AREA] - (char *) p[0]);
1131 #endif
1132 }
1133
1134
1135 /* Make ROW an empty, enabled row of canonical character height,
1136 in window W starting at y-position Y. */
1137
1138 void
1139 blank_row (w, row, y)
1140 struct window *w;
1141 struct glyph_row *row;
1142 int y;
1143 {
1144 int min_y, max_y;
1145
1146 min_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
1147 max_y = WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE (w);
1148
1149 clear_glyph_row (row);
1150 row->y = y;
1151 row->ascent = row->phys_ascent = 0;
1152 row->height = row->phys_height = CANON_Y_UNIT (XFRAME (w->frame));
1153 row->visible_height = row->height;
1154
1155 if (row->y < min_y)
1156 row->visible_height -= min_y - row->y;
1157 if (row->y + row->height > max_y)
1158 row->visible_height -= row->y + row->height - max_y;
1159
1160 row->enabled_p = 1;
1161 }
1162
1163
1164 /* Increment buffer positions in glyph row ROW. DELTA and DELTA_BYTES
1165 are the amounts by which to change positions. Note that the first
1166 glyph of the text area of a row can have a buffer position even if
1167 the used count of the text area is zero. Such rows display line
1168 ends. */
1169
1170 void
1171 increment_row_positions (row, delta, delta_bytes)
1172 struct glyph_row *row;
1173 int delta, delta_bytes;
1174 {
1175 int area, i;
1176
1177 /* Increment start and end positions. */
1178 MATRIX_ROW_START_CHARPOS (row) += delta;
1179 MATRIX_ROW_START_BYTEPOS (row) += delta_bytes;
1180 MATRIX_ROW_END_CHARPOS (row) += delta;
1181 MATRIX_ROW_END_BYTEPOS (row) += delta_bytes;
1182
1183 /* Increment positions in glyphs. */
1184 for (area = 0; area < LAST_AREA; ++area)
1185 for (i = 0; i < row->used[area]; ++i)
1186 if (BUFFERP (row->glyphs[area][i].object)
1187 && row->glyphs[area][i].charpos > 0)
1188 row->glyphs[area][i].charpos += delta;
1189
1190 /* Capture the case of rows displaying a line end. */
1191 if (row->used[TEXT_AREA] == 0
1192 && MATRIX_ROW_DISPLAYS_TEXT_P (row))
1193 row->glyphs[TEXT_AREA]->charpos += delta;
1194 }
1195
1196
1197 #if 0
1198 /* Swap glyphs between two glyph rows A and B. This exchanges glyph
1199 contents, i.e. glyph structure contents are exchanged between A and
1200 B without changing glyph pointers in A and B. */
1201
1202 static void
1203 swap_glyphs_in_rows (a, b)
1204 struct glyph_row *a, *b;
1205 {
1206 int area;
1207
1208 for (area = 0; area < LAST_AREA; ++area)
1209 {
1210 /* Number of glyphs to swap. */
1211 int max_used = max (a->used[area], b->used[area]);
1212
1213 /* Start of glyphs in area of row A. */
1214 struct glyph *glyph_a = a->glyphs[area];
1215
1216 /* End + 1 of glyphs in area of row A. */
1217 struct glyph *glyph_a_end = a->glyphs[max_used];
1218
1219 /* Start of glyphs in area of row B. */
1220 struct glyph *glyph_b = b->glyphs[area];
1221
1222 while (glyph_a < glyph_a_end)
1223 {
1224 /* Non-ISO HP/UX compiler doesn't like auto struct
1225 initialization. */
1226 struct glyph temp;
1227 temp = *glyph_a;
1228 *glyph_a = *glyph_b;
1229 *glyph_b = temp;
1230 ++glyph_a;
1231 ++glyph_b;
1232 }
1233 }
1234 }
1235
1236 #endif /* 0 */
1237
1238 /* Exchange pointers to glyph memory between glyph rows A and B. */
1239
1240 static INLINE void
1241 swap_glyph_pointers (a, b)
1242 struct glyph_row *a, *b;
1243 {
1244 int i;
1245 for (i = 0; i < LAST_AREA + 1; ++i)
1246 {
1247 struct glyph *temp = a->glyphs[i];
1248 a->glyphs[i] = b->glyphs[i];
1249 b->glyphs[i] = temp;
1250 }
1251 }
1252
1253
1254 /* Copy glyph row structure FROM to glyph row structure TO, except
1255 that glyph pointers in the structures are left unchanged. */
1256
1257 INLINE void
1258 copy_row_except_pointers (to, from)
1259 struct glyph_row *to, *from;
1260 {
1261 struct glyph *pointers[1 + LAST_AREA];
1262
1263 /* Save glyph pointers of TO. */
1264 bcopy (to->glyphs, pointers, sizeof to->glyphs);
1265
1266 /* Do a structure assignment. */
1267 *to = *from;
1268
1269 /* Restore original pointers of TO. */
1270 bcopy (pointers, to->glyphs, sizeof to->glyphs);
1271 }
1272
1273
1274 /* Copy contents of glyph row FROM to glyph row TO. Glyph pointers in
1275 TO and FROM are left unchanged. Glyph contents are copied from the
1276 glyph memory of FROM to the glyph memory of TO. Increment buffer
1277 positions in row TO by DELTA/ DELTA_BYTES. */
1278
1279 void
1280 copy_glyph_row_contents (to, from, delta, delta_bytes)
1281 struct glyph_row *to, *from;
1282 int delta, delta_bytes;
1283 {
1284 int area;
1285
1286 /* This is like a structure assignment TO = FROM, except that
1287 glyph pointers in the rows are left unchanged. */
1288 copy_row_except_pointers (to, from);
1289
1290 /* Copy glyphs from FROM to TO. */
1291 for (area = 0; area < LAST_AREA; ++area)
1292 if (from->used[area])
1293 bcopy (from->glyphs[area], to->glyphs[area],
1294 from->used[area] * sizeof (struct glyph));
1295
1296 /* Increment buffer positions in TO by DELTA. */
1297 increment_row_positions (to, delta, delta_bytes);
1298 }
1299
1300
1301 /* Assign glyph row FROM to glyph row TO. This works like a structure
1302 assignment TO = FROM, except that glyph pointers are not copied but
1303 exchanged between TO and FROM. Pointers must be exchanged to avoid
1304 a memory leak. */
1305
1306 static INLINE void
1307 assign_row (to, from)
1308 struct glyph_row *to, *from;
1309 {
1310 swap_glyph_pointers (to, from);
1311 copy_row_except_pointers (to, from);
1312 }
1313
1314
1315 /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is
1316 a row in a window matrix, is a slice of the glyph memory of the
1317 glyph row FRAME_ROW which is a row in a frame glyph matrix. Value
1318 is non-zero if the glyph memory of WINDOW_ROW is part of the glyph
1319 memory of FRAME_ROW. */
1320
1321 #if GLYPH_DEBUG
1322
1323 static int
1324 glyph_row_slice_p (window_row, frame_row)
1325 struct glyph_row *window_row, *frame_row;
1326 {
1327 struct glyph *window_glyph_start = window_row->glyphs[0];
1328 struct glyph *frame_glyph_start = frame_row->glyphs[0];
1329 struct glyph *frame_glyph_end = frame_row->glyphs[LAST_AREA];
1330
1331 return (frame_glyph_start <= window_glyph_start
1332 && window_glyph_start < frame_glyph_end);
1333 }
1334
1335 #endif /* GLYPH_DEBUG */
1336
1337 #if 0
1338
1339 /* Find the row in the window glyph matrix WINDOW_MATRIX being a slice
1340 of ROW in the frame matrix FRAME_MATRIX. Value is null if no row
1341 in WINDOW_MATRIX is found satisfying the condition. */
1342
1343 static struct glyph_row *
1344 find_glyph_row_slice (window_matrix, frame_matrix, row)
1345 struct glyph_matrix *window_matrix, *frame_matrix;
1346 int row;
1347 {
1348 int i;
1349
1350 xassert (row >= 0 && row < frame_matrix->nrows);
1351
1352 for (i = 0; i < window_matrix->nrows; ++i)
1353 if (glyph_row_slice_p (window_matrix->rows + i,
1354 frame_matrix->rows + row))
1355 break;
1356
1357 return i < window_matrix->nrows ? window_matrix->rows + i : 0;
1358 }
1359
1360 #endif /* 0 */
1361
1362 /* Prepare ROW for display. Desired rows are cleared lazily,
1363 i.e. they are only marked as to be cleared by setting their
1364 enabled_p flag to zero. When a row is to be displayed, a prior
1365 call to this function really clears it. */
1366
1367 void
1368 prepare_desired_row (row)
1369 struct glyph_row *row;
1370 {
1371 if (!row->enabled_p)
1372 {
1373 clear_glyph_row (row);
1374 row->enabled_p = 1;
1375 }
1376 }
1377
1378
1379 /* Return a hash code for glyph row ROW. */
1380
1381 int
1382 line_hash_code (row)
1383 struct glyph_row *row;
1384 {
1385 int hash = 0;
1386
1387 if (row->enabled_p)
1388 {
1389 struct glyph *glyph = row->glyphs[TEXT_AREA];
1390 struct glyph *end = glyph + row->used[TEXT_AREA];
1391
1392 while (glyph < end)
1393 {
1394 int c = glyph->u.ch;
1395 int face_id = glyph->face_id;
1396 if (must_write_spaces)
1397 c -= SPACEGLYPH;
1398 hash = (((hash << 4) + (hash >> 24)) & 0x0fffffff) + c;
1399 hash = (((hash << 4) + (hash >> 24)) & 0x0fffffff) + face_id;
1400 ++glyph;
1401 }
1402
1403 if (hash == 0)
1404 hash = 1;
1405 }
1406
1407 return hash;
1408 }
1409
1410
1411 /* Return the cost of drawing line VPOS in MATRIX. The cost equals
1412 the number of characters in the line. If must_write_spaces is
1413 zero, leading and trailing spaces are ignored. */
1414
1415 static unsigned int
1416 line_draw_cost (matrix, vpos)
1417 struct glyph_matrix *matrix;
1418 int vpos;
1419 {
1420 struct glyph_row *row = matrix->rows + vpos;
1421 struct glyph *beg = row->glyphs[TEXT_AREA];
1422 struct glyph *end = beg + row->used[TEXT_AREA];
1423 int len;
1424 Lisp_Object *glyph_table_base = GLYPH_TABLE_BASE;
1425 int glyph_table_len = GLYPH_TABLE_LENGTH;
1426
1427 /* Ignore trailing and leading spaces if we can. */
1428 if (!must_write_spaces)
1429 {
1430 /* Skip from the end over trailing spaces. */
1431 while (end > beg && CHAR_GLYPH_SPACE_P (*(end - 1)))
1432 --end;
1433
1434 /* All blank line. */
1435 if (end == beg)
1436 return 0;
1437
1438 /* Skip over leading spaces. */
1439 while (CHAR_GLYPH_SPACE_P (*beg))
1440 ++beg;
1441 }
1442
1443 /* If we don't have a glyph-table, each glyph is one character,
1444 so return the number of glyphs. */
1445 if (glyph_table_base == 0)
1446 len = end - beg;
1447 else
1448 {
1449 /* Otherwise, scan the glyphs and accumulate their total length
1450 in LEN. */
1451 len = 0;
1452 while (beg < end)
1453 {
1454 GLYPH g = GLYPH_FROM_CHAR_GLYPH (*beg);
1455
1456 if (g < 0
1457 || GLYPH_SIMPLE_P (glyph_table_base, glyph_table_len, g))
1458 len += 1;
1459 else
1460 len += GLYPH_LENGTH (glyph_table_base, g);
1461
1462 ++beg;
1463 }
1464 }
1465
1466 return len;
1467 }
1468
1469
1470 /* Test two glyph rows A and B for equality. Value is non-zero if A
1471 and B have equal contents. W is the window to which the glyphs
1472 rows A and B belong. It is needed here to test for partial row
1473 visibility. MOUSE_FACE_P non-zero means compare the mouse_face_p
1474 flags of A and B, too. */
1475
1476 static INLINE int
1477 row_equal_p (w, a, b, mouse_face_p)
1478 struct window *w;
1479 struct glyph_row *a, *b;
1480 int mouse_face_p;
1481 {
1482 if (a == b)
1483 return 1;
1484 else if (a->hash != b->hash)
1485 return 0;
1486 else
1487 {
1488 struct glyph *a_glyph, *b_glyph, *a_end;
1489 int area;
1490
1491 if (mouse_face_p && a->mouse_face_p != b->mouse_face_p)
1492 return 0;
1493
1494 /* Compare glyphs. */
1495 for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
1496 {
1497 if (a->used[area] != b->used[area])
1498 return 0;
1499
1500 a_glyph = a->glyphs[area];
1501 a_end = a_glyph + a->used[area];
1502 b_glyph = b->glyphs[area];
1503
1504 while (a_glyph < a_end
1505 && GLYPH_EQUAL_P (a_glyph, b_glyph))
1506 ++a_glyph, ++b_glyph;
1507
1508 if (a_glyph != a_end)
1509 return 0;
1510 }
1511
1512 if (a->truncated_on_left_p != b->truncated_on_left_p
1513 || a->fill_line_p != b->fill_line_p
1514 || a->truncated_on_right_p != b->truncated_on_right_p
1515 || a->overlay_arrow_p != b->overlay_arrow_p
1516 || a->continued_p != b->continued_p
1517 || a->indicate_empty_line_p != b->indicate_empty_line_p
1518 || a->overlapped_p != b->overlapped_p
1519 || (MATRIX_ROW_CONTINUATION_LINE_P (a)
1520 != MATRIX_ROW_CONTINUATION_LINE_P (b))
1521 /* Different partially visible characters on left margin. */
1522 || a->x != b->x
1523 /* Different height. */
1524 || a->ascent != b->ascent
1525 || a->phys_ascent != b->phys_ascent
1526 || a->phys_height != b->phys_height
1527 || a->visible_height != b->visible_height)
1528 return 0;
1529 }
1530
1531 return 1;
1532 }
1533
1534
1535 \f
1536 /***********************************************************************
1537 Glyph Pool
1538
1539 See dispextern.h for an overall explanation of glyph pools.
1540 ***********************************************************************/
1541
1542 /* Allocate a glyph_pool structure. The structure returned is
1543 initialized with zeros. The global variable glyph_pool_count is
1544 incremented for each pool allocated. */
1545
1546 static struct glyph_pool *
1547 new_glyph_pool ()
1548 {
1549 struct glyph_pool *result;
1550
1551 /* Allocate a new glyph_pool and clear it. */
1552 result = (struct glyph_pool *) xmalloc (sizeof *result);
1553 bzero (result, sizeof *result);
1554
1555 /* For memory leak and double deletion checking. */
1556 ++glyph_pool_count;
1557
1558 return result;
1559 }
1560
1561
1562 /* Free a glyph_pool structure POOL. The function may be called with
1563 a null POOL pointer. The global variable glyph_pool_count is
1564 decremented with every pool structure freed. If this count gets
1565 negative, more structures were freed than allocated, i.e. one
1566 structure must have been freed more than once or a bogus pointer
1567 was passed to free_glyph_pool. */
1568
1569 static void
1570 free_glyph_pool (pool)
1571 struct glyph_pool *pool;
1572 {
1573 if (pool)
1574 {
1575 /* More freed than allocated? */
1576 --glyph_pool_count;
1577 xassert (glyph_pool_count >= 0);
1578
1579 xfree (pool->glyphs);
1580 xfree (pool);
1581 }
1582 }
1583
1584
1585 /* Enlarge a glyph pool POOL. MATRIX_DIM gives the number of rows and
1586 columns we need. This function never shrinks a pool. The only
1587 case in which this would make sense, would be when a frame's size
1588 is changed from a large value to a smaller one. But, if someone
1589 does it once, we can expect that he will do it again.
1590
1591 Value is non-zero if the pool changed in a way which makes
1592 re-adjusting window glyph matrices necessary. */
1593
1594 static int
1595 realloc_glyph_pool (pool, matrix_dim)
1596 struct glyph_pool *pool;
1597 struct dim matrix_dim;
1598 {
1599 int needed;
1600 int changed_p;
1601
1602 changed_p = (pool->glyphs == 0
1603 || matrix_dim.height != pool->nrows
1604 || matrix_dim.width != pool->ncolumns);
1605
1606 /* Enlarge the glyph pool. */
1607 needed = matrix_dim.width * matrix_dim.height;
1608 if (needed > pool->nglyphs)
1609 {
1610 int size = needed * sizeof (struct glyph);
1611
1612 if (pool->glyphs)
1613 pool->glyphs = (struct glyph *) xrealloc (pool->glyphs, size);
1614 else
1615 {
1616 pool->glyphs = (struct glyph *) xmalloc (size);
1617 bzero (pool->glyphs, size);
1618 }
1619
1620 pool->nglyphs = needed;
1621 }
1622
1623 /* Remember the number of rows and columns because (a) we use them
1624 to do sanity checks, and (b) the number of columns determines
1625 where rows in the frame matrix start---this must be available to
1626 determine pointers to rows of window sub-matrices. */
1627 pool->nrows = matrix_dim.height;
1628 pool->ncolumns = matrix_dim.width;
1629
1630 return changed_p;
1631 }
1632
1633
1634 \f
1635 /***********************************************************************
1636 Debug Code
1637 ***********************************************************************/
1638
1639 #if GLYPH_DEBUG
1640
1641
1642 /* Flush standard output. This is sometimes useful to call from
1643 the debugger. */
1644
1645 void
1646 flush_stdout ()
1647 {
1648 fflush (stdout);
1649 }
1650
1651
1652 /* Check that no glyph pointers have been lost in MATRIX. If a
1653 pointer has been lost, e.g. by using a structure assignment between
1654 rows, at least one pointer must occur more than once in the rows of
1655 MATRIX. */
1656
1657 void
1658 check_matrix_pointer_lossage (matrix)
1659 struct glyph_matrix *matrix;
1660 {
1661 int i, j;
1662
1663 for (i = 0; i < matrix->nrows; ++i)
1664 for (j = 0; j < matrix->nrows; ++j)
1665 xassert (i == j
1666 || (matrix->rows[i].glyphs[TEXT_AREA]
1667 != matrix->rows[j].glyphs[TEXT_AREA]));
1668 }
1669
1670
1671 /* Get a pointer to glyph row ROW in MATRIX, with bounds checks. */
1672
1673 struct glyph_row *
1674 matrix_row (matrix, row)
1675 struct glyph_matrix *matrix;
1676 int row;
1677 {
1678 xassert (matrix && matrix->rows);
1679 xassert (row >= 0 && row < matrix->nrows);
1680
1681 /* That's really too slow for normal testing because this function
1682 is called almost everywhere. Although---it's still astonishingly
1683 fast, so it is valuable to have for debugging purposes. */
1684 #if 0
1685 check_matrix_pointer_lossage (matrix);
1686 #endif
1687
1688 return matrix->rows + row;
1689 }
1690
1691
1692 #if 0 /* This function makes invalid assumptions when text is
1693 partially invisible. But it might come handy for debugging
1694 nevertheless. */
1695
1696 /* Check invariants that must hold for an up to date current matrix of
1697 window W. */
1698
1699 static void
1700 check_matrix_invariants (w)
1701 struct window *w;
1702 {
1703 struct glyph_matrix *matrix = w->current_matrix;
1704 int yb = window_text_bottom_y (w);
1705 struct glyph_row *row = matrix->rows;
1706 struct glyph_row *last_text_row = NULL;
1707 struct buffer *saved = current_buffer;
1708 struct buffer *buffer = XBUFFER (w->buffer);
1709 int c;
1710
1711 /* This can sometimes happen for a fresh window. */
1712 if (matrix->nrows < 2)
1713 return;
1714
1715 set_buffer_temp (buffer);
1716
1717 /* Note: last row is always reserved for the mode line. */
1718 while (MATRIX_ROW_DISPLAYS_TEXT_P (row)
1719 && MATRIX_ROW_BOTTOM_Y (row) < yb)
1720 {
1721 struct glyph_row *next = row + 1;
1722
1723 if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
1724 last_text_row = row;
1725
1726 /* Check that character and byte positions are in sync. */
1727 xassert (MATRIX_ROW_START_BYTEPOS (row)
1728 == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row)));
1729
1730 /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can
1731 have such a position temporarily in case of a minibuffer
1732 displaying something like `[Sole completion]' at its end. */
1733 if (MATRIX_ROW_END_CHARPOS (row) < BUF_ZV (current_buffer))
1734 xassert (MATRIX_ROW_END_BYTEPOS (row)
1735 == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row)));
1736
1737 /* Check that end position of `row' is equal to start position
1738 of next row. */
1739 if (next->enabled_p && MATRIX_ROW_DISPLAYS_TEXT_P (next))
1740 {
1741 xassert (MATRIX_ROW_END_CHARPOS (row)
1742 == MATRIX_ROW_START_CHARPOS (next));
1743 xassert (MATRIX_ROW_END_BYTEPOS (row)
1744 == MATRIX_ROW_START_BYTEPOS (next));
1745 }
1746 row = next;
1747 }
1748
1749 xassert (w->current_matrix->nrows == w->desired_matrix->nrows);
1750 xassert (w->desired_matrix->rows != NULL);
1751 set_buffer_temp (saved);
1752 }
1753
1754 #endif /* 0 */
1755
1756 #endif /* GLYPH_DEBUG != 0 */
1757
1758
1759 \f
1760 /**********************************************************************
1761 Allocating/ Adjusting Glyph Matrices
1762 **********************************************************************/
1763
1764 /* Allocate glyph matrices over a window tree for a frame-based
1765 redisplay
1766
1767 X and Y are column/row within the frame glyph matrix where
1768 sub-matrices for the window tree rooted at WINDOW must be
1769 allocated. CH_DIM contains the dimensions of the smallest
1770 character that could be used during display. DIM_ONLY_P non-zero
1771 means that the caller of this function is only interested in the
1772 result matrix dimension, and matrix adjustments should not be
1773 performed.
1774
1775 The function returns the total width/height of the sub-matrices of
1776 the window tree. If called on a frame root window, the computation
1777 will take the mini-buffer window into account.
1778
1779 *WINDOW_CHANGE_FLAGS is set to a bit mask with bits
1780
1781 NEW_LEAF_MATRIX set if any window in the tree did not have a
1782 glyph matrices yet, and
1783
1784 CHANGED_LEAF_MATRIX set if the dimension or location of a matrix of
1785 any window in the tree will be changed or have been changed (see
1786 DIM_ONLY_P)
1787
1788 *WINDOW_CHANGE_FLAGS must be initialized by the caller of this
1789 function.
1790
1791 Windows are arranged into chains of windows on the same level
1792 through the next fields of window structures. Such a level can be
1793 either a sequence of horizontally adjacent windows from left to
1794 right, or a sequence of vertically adjacent windows from top to
1795 bottom. Each window in a horizontal sequence can be either a leaf
1796 window or a vertical sequence; a window in a vertical sequence can
1797 be either a leaf or a horizontal sequence. All windows in a
1798 horizontal sequence have the same height, and all windows in a
1799 vertical sequence have the same width.
1800
1801 This function uses, for historical reasons, a more general
1802 algorithm to determine glyph matrix dimensions that would be
1803 necessary.
1804
1805 The matrix height of a horizontal sequence is determined by the
1806 maximum height of any matrix in the sequence. The matrix width of
1807 a horizontal sequence is computed by adding up matrix widths of
1808 windows in the sequence.
1809
1810 |<------- result width ------->|
1811 +---------+----------+---------+ ---
1812 | | | | |
1813 | | | |
1814 +---------+ | | result height
1815 | +---------+
1816 | | |
1817 +----------+ ---
1818
1819 The matrix width of a vertical sequence is the maximum matrix width
1820 of any window in the sequence. Its height is computed by adding up
1821 matrix heights of windows in the sequence.
1822
1823 |<---- result width -->|
1824 +---------+ ---
1825 | | |
1826 | | |
1827 +---------+--+ |
1828 | | |
1829 | | result height
1830 | |
1831 +------------+---------+ |
1832 | | |
1833 | | |
1834 +------------+---------+ --- */
1835
1836 /* Bit indicating that a new matrix will be allocated or has been
1837 allocated. */
1838
1839 #define NEW_LEAF_MATRIX (1 << 0)
1840
1841 /* Bit indicating that a matrix will or has changed its location or
1842 size. */
1843
1844 #define CHANGED_LEAF_MATRIX (1 << 1)
1845
1846 static struct dim
1847 allocate_matrices_for_frame_redisplay (window, x, y, dim_only_p,
1848 window_change_flags)
1849 Lisp_Object window;
1850 int x, y;
1851 int dim_only_p;
1852 int *window_change_flags;
1853 {
1854 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (window)));
1855 int x0 = x, y0 = y;
1856 int wmax = 0, hmax = 0;
1857 struct dim total;
1858 struct dim dim;
1859 struct window *w;
1860 int in_horz_combination_p;
1861
1862 /* What combination is WINDOW part of? Compute this once since the
1863 result is the same for all windows in the `next' chain. The
1864 special case of a root window (parent equal to nil) is treated
1865 like a vertical combination because a root window's `next'
1866 points to the mini-buffer window, if any, which is arranged
1867 vertically below other windows. */
1868 in_horz_combination_p
1869 = (!NILP (XWINDOW (window)->parent)
1870 && !NILP (XWINDOW (XWINDOW (window)->parent)->hchild));
1871
1872 /* For WINDOW and all windows on the same level. */
1873 do
1874 {
1875 w = XWINDOW (window);
1876
1877 /* Get the dimension of the window sub-matrix for W, depending
1878 on whether this is a combination or a leaf window. */
1879 if (!NILP (w->hchild))
1880 dim = allocate_matrices_for_frame_redisplay (w->hchild, x, y,
1881 dim_only_p,
1882 window_change_flags);
1883 else if (!NILP (w->vchild))
1884 dim = allocate_matrices_for_frame_redisplay (w->vchild, x, y,
1885 dim_only_p,
1886 window_change_flags);
1887 else
1888 {
1889 /* If not already done, allocate sub-matrix structures. */
1890 if (w->desired_matrix == NULL)
1891 {
1892 w->desired_matrix = new_glyph_matrix (f->desired_pool);
1893 w->current_matrix = new_glyph_matrix (f->current_pool);
1894 *window_change_flags |= NEW_LEAF_MATRIX;
1895 }
1896
1897 /* Width and height MUST be chosen so that there are no
1898 holes in the frame matrix. */
1899 dim.width = required_matrix_width (w);
1900 dim.height = required_matrix_height (w);
1901
1902 /* Will matrix be re-allocated? */
1903 if (x != w->desired_matrix->matrix_x
1904 || y != w->desired_matrix->matrix_y
1905 || dim.width != w->desired_matrix->matrix_w
1906 || dim.height != w->desired_matrix->matrix_h
1907 || (margin_glyphs_to_reserve (w, dim.width,
1908 w->right_margin_width)
1909 != w->desired_matrix->left_margin_glyphs)
1910 || (margin_glyphs_to_reserve (w, dim.width,
1911 w->left_margin_width)
1912 != w->desired_matrix->right_margin_glyphs))
1913 *window_change_flags |= CHANGED_LEAF_MATRIX;
1914
1915 /* Actually change matrices, if allowed. Do not consider
1916 CHANGED_LEAF_MATRIX computed above here because the pool
1917 may have been changed which we don't now here. We trust
1918 that we only will be called with DIM_ONLY_P != 0 when
1919 necessary. */
1920 if (!dim_only_p)
1921 {
1922 adjust_glyph_matrix (w, w->desired_matrix, x, y, dim);
1923 adjust_glyph_matrix (w, w->current_matrix, x, y, dim);
1924 }
1925 }
1926
1927 /* If we are part of a horizontal combination, advance x for
1928 windows to the right of W; otherwise advance y for windows
1929 below W. */
1930 if (in_horz_combination_p)
1931 x += dim.width;
1932 else
1933 y += dim.height;
1934
1935 /* Remember maximum glyph matrix dimensions. */
1936 wmax = max (wmax, dim.width);
1937 hmax = max (hmax, dim.height);
1938
1939 /* Next window on same level. */
1940 window = w->next;
1941 }
1942 while (!NILP (window));
1943
1944 /* Set `total' to the total glyph matrix dimension of this window
1945 level. In a vertical combination, the width is the width of the
1946 widest window; the height is the y we finally reached, corrected
1947 by the y we started with. In a horizontal combination, the total
1948 height is the height of the tallest window, and the width is the
1949 x we finally reached, corrected by the x we started with. */
1950 if (in_horz_combination_p)
1951 {
1952 total.width = x - x0;
1953 total.height = hmax;
1954 }
1955 else
1956 {
1957 total.width = wmax;
1958 total.height = y - y0;
1959 }
1960
1961 return total;
1962 }
1963
1964
1965 /* Return the required height of glyph matrices for window W. */
1966
1967 int
1968 required_matrix_height (w)
1969 struct window *w;
1970 {
1971 #ifdef HAVE_WINDOW_SYSTEM
1972 struct frame *f = XFRAME (w->frame);
1973
1974 if (FRAME_WINDOW_P (f))
1975 {
1976 int ch_height = FRAME_SMALLEST_FONT_HEIGHT (f);
1977 int window_pixel_height = window_box_height (w) + abs (w->vscroll);
1978 return (((window_pixel_height + ch_height - 1)
1979 / ch_height)
1980 /* One partially visible line at the top and
1981 bottom of the window. */
1982 + 2
1983 /* 2 for header and mode line. */
1984 + 2);
1985 }
1986 #endif /* HAVE_WINDOW_SYSTEM */
1987
1988 return XINT (w->height);
1989 }
1990
1991
1992 /* Return the required width of glyph matrices for window W. */
1993
1994 int
1995 required_matrix_width (w)
1996 struct window *w;
1997 {
1998 #ifdef HAVE_WINDOW_SYSTEM
1999 struct frame *f = XFRAME (w->frame);
2000 if (FRAME_WINDOW_P (f))
2001 {
2002 int ch_width = FRAME_SMALLEST_CHAR_WIDTH (f);
2003 int window_pixel_width = XFLOATINT (w->width) * CANON_X_UNIT (f);
2004
2005 /* Compute number of glyphs needed in a glyph row. */
2006 return (((window_pixel_width + ch_width - 1)
2007 / ch_width)
2008 /* 2 partially visible columns in the text area. */
2009 + 2
2010 /* One partially visible column at the right
2011 edge of each marginal area. */
2012 + 1 + 1);
2013 }
2014 #endif /* HAVE_WINDOW_SYSTEM */
2015
2016 return XINT (w->width);
2017 }
2018
2019
2020 /* Allocate window matrices for window-based redisplay. W is the
2021 window whose matrices must be allocated/reallocated. CH_DIM is the
2022 size of the smallest character that could potentially be used on W. */
2023
2024 static void
2025 allocate_matrices_for_window_redisplay (w)
2026 struct window *w;
2027 {
2028 while (w)
2029 {
2030 if (!NILP (w->vchild))
2031 allocate_matrices_for_window_redisplay (XWINDOW (w->vchild));
2032 else if (!NILP (w->hchild))
2033 allocate_matrices_for_window_redisplay (XWINDOW (w->hchild));
2034 else
2035 {
2036 /* W is a leaf window. */
2037 struct dim dim;
2038
2039 /* If matrices are not yet allocated, allocate them now. */
2040 if (w->desired_matrix == NULL)
2041 {
2042 w->desired_matrix = new_glyph_matrix (NULL);
2043 w->current_matrix = new_glyph_matrix (NULL);
2044 }
2045
2046 dim.width = required_matrix_width (w);
2047 dim.height = required_matrix_height (w);
2048 adjust_glyph_matrix (w, w->desired_matrix, 0, 0, dim);
2049 adjust_glyph_matrix (w, w->current_matrix, 0, 0, dim);
2050 }
2051
2052 w = NILP (w->next) ? NULL : XWINDOW (w->next);
2053 }
2054 }
2055
2056
2057 /* Re-allocate/ re-compute glyph matrices on frame F. If F is null,
2058 do it for all frames; otherwise do it just for the given frame.
2059 This function must be called when a new frame is created, its size
2060 changes, or its window configuration changes. */
2061
2062 void
2063 adjust_glyphs (f)
2064 struct frame *f;
2065 {
2066 /* Block input so that expose events and other events that access
2067 glyph matrices are not processed while we are changing them. */
2068 BLOCK_INPUT;
2069
2070 if (f)
2071 adjust_frame_glyphs (f);
2072 else
2073 {
2074 Lisp_Object tail, lisp_frame;
2075
2076 FOR_EACH_FRAME (tail, lisp_frame)
2077 adjust_frame_glyphs (XFRAME (lisp_frame));
2078 }
2079
2080 UNBLOCK_INPUT;
2081 }
2082
2083
2084 /* Adjust frame glyphs when Emacs is initialized.
2085
2086 To be called from init_display.
2087
2088 We need a glyph matrix because redraw will happen soon.
2089 Unfortunately, window sizes on selected_frame are not yet set to
2090 meaningful values. I believe we can assume that there are only two
2091 windows on the frame---the mini-buffer and the root window. Frame
2092 height and width seem to be correct so far. So, set the sizes of
2093 windows to estimated values. */
2094
2095 static void
2096 adjust_frame_glyphs_initially ()
2097 {
2098 struct frame *sf = SELECTED_FRAME ();
2099 struct window *root = XWINDOW (sf->root_window);
2100 struct window *mini = XWINDOW (root->next);
2101 int frame_height = FRAME_HEIGHT (sf);
2102 int frame_width = FRAME_WIDTH (sf);
2103 int top_margin = FRAME_TOP_MARGIN (sf);
2104
2105 /* Do it for the root window. */
2106 XSETFASTINT (root->top, top_margin);
2107 XSETFASTINT (root->width, frame_width);
2108 set_window_height (sf->root_window, frame_height - 1 - top_margin, 0);
2109
2110 /* Do it for the mini-buffer window. */
2111 XSETFASTINT (mini->top, frame_height - 1);
2112 XSETFASTINT (mini->width, frame_width);
2113 set_window_height (root->next, 1, 0);
2114
2115 adjust_frame_glyphs (sf);
2116 glyphs_initialized_initially_p = 1;
2117 }
2118
2119
2120 /* Allocate/reallocate glyph matrices of a single frame F. */
2121
2122 static void
2123 adjust_frame_glyphs (f)
2124 struct frame *f;
2125 {
2126 if (FRAME_WINDOW_P (f))
2127 adjust_frame_glyphs_for_window_redisplay (f);
2128 else
2129 adjust_frame_glyphs_for_frame_redisplay (f);
2130
2131 /* Don't forget the message buffer and the buffer for
2132 decode_mode_spec. */
2133 adjust_frame_message_buffer (f);
2134 adjust_decode_mode_spec_buffer (f);
2135
2136 f->glyphs_initialized_p = 1;
2137 }
2138
2139
2140 /* In the window tree with root W, build current matrices of leaf
2141 windows from the frame's current matrix. */
2142
2143 static void
2144 fake_current_matrices (window)
2145 Lisp_Object window;
2146 {
2147 struct window *w;
2148
2149 for (; !NILP (window); window = w->next)
2150 {
2151 w = XWINDOW (window);
2152
2153 if (!NILP (w->hchild))
2154 fake_current_matrices (w->hchild);
2155 else if (!NILP (w->vchild))
2156 fake_current_matrices (w->vchild);
2157 else
2158 {
2159 int i;
2160 struct frame *f = XFRAME (w->frame);
2161 struct glyph_matrix *m = w->current_matrix;
2162 struct glyph_matrix *fm = f->current_matrix;
2163
2164 xassert (m->matrix_h == XFASTINT (w->height));
2165 xassert (m->matrix_w == XFASTINT (w->width));
2166
2167 for (i = 0; i < m->matrix_h; ++i)
2168 {
2169 struct glyph_row *r = m->rows + i;
2170 struct glyph_row *fr = fm->rows + i + XFASTINT (w->top);
2171
2172 xassert (r->glyphs[TEXT_AREA] >= fr->glyphs[TEXT_AREA]
2173 && r->glyphs[LAST_AREA] <= fr->glyphs[LAST_AREA]);
2174
2175 r->enabled_p = fr->enabled_p;
2176 if (r->enabled_p)
2177 {
2178 r->used[LEFT_MARGIN_AREA] = m->left_margin_glyphs;
2179 r->used[RIGHT_MARGIN_AREA] = m->right_margin_glyphs;
2180 r->used[TEXT_AREA] = (m->matrix_w
2181 - r->used[LEFT_MARGIN_AREA]
2182 - r->used[RIGHT_MARGIN_AREA]);
2183 r->mode_line_p = 0;
2184 }
2185 }
2186 }
2187 }
2188 }
2189
2190
2191 /* Save away the contents of frame F's current frame matrix. Value is
2192 a glyph matrix holding the contents of F's current frame matrix. */
2193
2194 static struct glyph_matrix *
2195 save_current_matrix (f)
2196 struct frame *f;
2197 {
2198 int i;
2199 struct glyph_matrix *saved;
2200
2201 saved = (struct glyph_matrix *) xmalloc (sizeof *saved);
2202 bzero (saved, sizeof *saved);
2203 saved->nrows = f->current_matrix->nrows;
2204 saved->rows = (struct glyph_row *) xmalloc (saved->nrows
2205 * sizeof *saved->rows);
2206 bzero (saved->rows, saved->nrows * sizeof *saved->rows);
2207
2208 for (i = 0; i < saved->nrows; ++i)
2209 {
2210 struct glyph_row *from = f->current_matrix->rows + i;
2211 struct glyph_row *to = saved->rows + i;
2212 size_t nbytes = from->used[TEXT_AREA] * sizeof (struct glyph);
2213 to->glyphs[TEXT_AREA] = (struct glyph *) xmalloc (nbytes);
2214 bcopy (from->glyphs[TEXT_AREA], to->glyphs[TEXT_AREA], nbytes);
2215 to->used[TEXT_AREA] = from->used[TEXT_AREA];
2216 }
2217
2218 return saved;
2219 }
2220
2221
2222 /* Restore the contents of frame F's current frame matrix from SAVED,
2223 and free memory associated with SAVED. */
2224
2225 static void
2226 restore_current_matrix (f, saved)
2227 struct frame *f;
2228 struct glyph_matrix *saved;
2229 {
2230 int i;
2231
2232 for (i = 0; i < saved->nrows; ++i)
2233 {
2234 struct glyph_row *from = saved->rows + i;
2235 struct glyph_row *to = f->current_matrix->rows + i;
2236 size_t nbytes = from->used[TEXT_AREA] * sizeof (struct glyph);
2237 bcopy (from->glyphs[TEXT_AREA], to->glyphs[TEXT_AREA], nbytes);
2238 to->used[TEXT_AREA] = from->used[TEXT_AREA];
2239 xfree (from->glyphs[TEXT_AREA]);
2240 }
2241
2242 xfree (saved->rows);
2243 xfree (saved);
2244 }
2245
2246
2247
2248 /* Allocate/reallocate glyph matrices of a single frame F for
2249 frame-based redisplay. */
2250
2251 static void
2252 adjust_frame_glyphs_for_frame_redisplay (f)
2253 struct frame *f;
2254 {
2255 struct dim ch_dim;
2256 struct dim matrix_dim;
2257 int pool_changed_p;
2258 int window_change_flags;
2259 int top_window_y;
2260
2261 if (!FRAME_LIVE_P (f))
2262 return;
2263
2264 /* Determine the smallest character in any font for F. On
2265 console windows, all characters have dimension (1, 1). */
2266 ch_dim.width = ch_dim.height = 1;
2267
2268 top_window_y = FRAME_TOP_MARGIN (f);
2269
2270 /* Allocate glyph pool structures if not already done. */
2271 if (f->desired_pool == NULL)
2272 {
2273 f->desired_pool = new_glyph_pool ();
2274 f->current_pool = new_glyph_pool ();
2275 }
2276
2277 /* Allocate frames matrix structures if needed. */
2278 if (f->desired_matrix == NULL)
2279 {
2280 f->desired_matrix = new_glyph_matrix (f->desired_pool);
2281 f->current_matrix = new_glyph_matrix (f->current_pool);
2282 }
2283
2284 /* Compute window glyph matrices. (This takes the mini-buffer
2285 window into account). The result is the size of the frame glyph
2286 matrix needed. The variable window_change_flags is set to a bit
2287 mask indicating whether new matrices will be allocated or
2288 existing matrices change their size or location within the frame
2289 matrix. */
2290 window_change_flags = 0;
2291 matrix_dim
2292 = allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f),
2293 0, top_window_y,
2294 1,
2295 &window_change_flags);
2296
2297 /* Add in menu bar lines, if any. */
2298 matrix_dim.height += top_window_y;
2299
2300 /* Enlarge pools as necessary. */
2301 pool_changed_p = realloc_glyph_pool (f->desired_pool, matrix_dim);
2302 realloc_glyph_pool (f->current_pool, matrix_dim);
2303
2304 /* Set up glyph pointers within window matrices. Do this only if
2305 absolutely necessary since it requires a frame redraw. */
2306 if (pool_changed_p || window_change_flags)
2307 {
2308 /* Do it for window matrices. */
2309 allocate_matrices_for_frame_redisplay (FRAME_ROOT_WINDOW (f),
2310 0, top_window_y, 0,
2311 &window_change_flags);
2312
2313 /* Size of frame matrices must equal size of frame. Note
2314 that we are called for X frames with window widths NOT equal
2315 to the frame width (from CHANGE_FRAME_SIZE_1). */
2316 xassert (matrix_dim.width == FRAME_WIDTH (f)
2317 && matrix_dim.height == FRAME_HEIGHT (f));
2318
2319 /* Pointers to glyph memory in glyph rows are exchanged during
2320 the update phase of redisplay, which means in general that a
2321 frame's current matrix consists of pointers into both the
2322 desired and current glyph pool of the frame. Adjusting a
2323 matrix sets the frame matrix up so that pointers are all into
2324 the same pool. If we want to preserve glyph contents of the
2325 current matrix over a call to adjust_glyph_matrix, we must
2326 make a copy of the current glyphs, and restore the current
2327 matrix' contents from that copy. */
2328 if (display_completed
2329 && !FRAME_GARBAGED_P (f)
2330 && matrix_dim.width == f->current_matrix->matrix_w
2331 && matrix_dim.height == f->current_matrix->matrix_h)
2332 {
2333 struct glyph_matrix *copy = save_current_matrix (f);
2334 adjust_glyph_matrix (NULL, f->desired_matrix, 0, 0, matrix_dim);
2335 adjust_glyph_matrix (NULL, f->current_matrix, 0, 0, matrix_dim);
2336 restore_current_matrix (f, copy);
2337 fake_current_matrices (FRAME_ROOT_WINDOW (f));
2338 }
2339 else
2340 {
2341 adjust_glyph_matrix (NULL, f->desired_matrix, 0, 0, matrix_dim);
2342 adjust_glyph_matrix (NULL, f->current_matrix, 0, 0, matrix_dim);
2343 SET_FRAME_GARBAGED (f);
2344 }
2345 }
2346 }
2347
2348
2349 /* Allocate/reallocate glyph matrices of a single frame F for
2350 window-based redisplay. */
2351
2352 static void
2353 adjust_frame_glyphs_for_window_redisplay (f)
2354 struct frame *f;
2355 {
2356 struct dim ch_dim;
2357 struct window *w;
2358
2359 xassert (FRAME_WINDOW_P (f) && FRAME_LIVE_P (f));
2360
2361 /* Get minimum sizes. */
2362 #ifdef HAVE_WINDOW_SYSTEM
2363 ch_dim.width = FRAME_SMALLEST_CHAR_WIDTH (f);
2364 ch_dim.height = FRAME_SMALLEST_FONT_HEIGHT (f);
2365 #else
2366 ch_dim.width = ch_dim.height = 1;
2367 #endif
2368
2369 /* Allocate/reallocate window matrices. */
2370 allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f)));
2371
2372 /* Allocate/ reallocate matrices of the dummy window used to display
2373 the menu bar under X when no X toolkit support is available. */
2374 #ifndef USE_X_TOOLKIT
2375 {
2376 /* Allocate a dummy window if not already done. */
2377 if (NILP (f->menu_bar_window))
2378 {
2379 f->menu_bar_window = make_window ();
2380 w = XWINDOW (f->menu_bar_window);
2381 XSETFRAME (w->frame, f);
2382 w->pseudo_window_p = 1;
2383 }
2384 else
2385 w = XWINDOW (f->menu_bar_window);
2386
2387 /* Set window dimensions to frame dimensions and allocate or
2388 adjust glyph matrices of W. */
2389 XSETFASTINT (w->top, 0);
2390 XSETFASTINT (w->left, 0);
2391 XSETFASTINT (w->height, FRAME_MENU_BAR_LINES (f));
2392 XSETFASTINT (w->width, FRAME_WINDOW_WIDTH (f));
2393 allocate_matrices_for_window_redisplay (w);
2394 }
2395 #endif /* not USE_X_TOOLKIT */
2396
2397 /* Allocate/ reallocate matrices of the tool bar window. If we
2398 don't have a tool bar window yet, make one. */
2399 if (NILP (f->tool_bar_window))
2400 {
2401 f->tool_bar_window = make_window ();
2402 w = XWINDOW (f->tool_bar_window);
2403 XSETFRAME (w->frame, f);
2404 w->pseudo_window_p = 1;
2405 }
2406 else
2407 w = XWINDOW (f->tool_bar_window);
2408
2409 XSETFASTINT (w->top, FRAME_MENU_BAR_LINES (f));
2410 XSETFASTINT (w->left, 0);
2411 XSETFASTINT (w->height, FRAME_TOOL_BAR_LINES (f));
2412 XSETFASTINT (w->width, FRAME_WINDOW_WIDTH (f));
2413 allocate_matrices_for_window_redisplay (w);
2414 }
2415
2416
2417 /* Adjust/ allocate message buffer of frame F.
2418
2419 Note that the message buffer is never freed. Since I could not
2420 find a free in 19.34, I assume that freeing it would be
2421 problematic in some way and don't do it either.
2422
2423 (Implementation note: It should be checked if we can free it
2424 eventually without causing trouble). */
2425
2426 static void
2427 adjust_frame_message_buffer (f)
2428 struct frame *f;
2429 {
2430 int size = FRAME_MESSAGE_BUF_SIZE (f) + 1;
2431
2432 if (FRAME_MESSAGE_BUF (f))
2433 {
2434 char *buffer = FRAME_MESSAGE_BUF (f);
2435 char *new_buffer = (char *) xrealloc (buffer, size);
2436 FRAME_MESSAGE_BUF (f) = new_buffer;
2437 }
2438 else
2439 FRAME_MESSAGE_BUF (f) = (char *) xmalloc (size);
2440 }
2441
2442
2443 /* Re-allocate buffer for decode_mode_spec on frame F. */
2444
2445 static void
2446 adjust_decode_mode_spec_buffer (f)
2447 struct frame *f;
2448 {
2449 f->decode_mode_spec_buffer
2450 = (char *) xrealloc (f->decode_mode_spec_buffer,
2451 FRAME_MESSAGE_BUF_SIZE (f) + 1);
2452 }
2453
2454
2455 \f
2456 /**********************************************************************
2457 Freeing Glyph Matrices
2458 **********************************************************************/
2459
2460 /* Free glyph memory for a frame F. F may be null. This function can
2461 be called for the same frame more than once. The root window of
2462 F may be nil when this function is called. This is the case when
2463 the function is called when F is destroyed. */
2464
2465 void
2466 free_glyphs (f)
2467 struct frame *f;
2468 {
2469 if (f && f->glyphs_initialized_p)
2470 {
2471 /* Block interrupt input so that we don't get surprised by an X
2472 event while we're in an inconsistent state. */
2473 BLOCK_INPUT;
2474 f->glyphs_initialized_p = 0;
2475
2476 /* Release window sub-matrices. */
2477 if (!NILP (f->root_window))
2478 free_window_matrices (XWINDOW (f->root_window));
2479
2480 /* Free the dummy window for menu bars without X toolkit and its
2481 glyph matrices. */
2482 if (!NILP (f->menu_bar_window))
2483 {
2484 struct window *w = XWINDOW (f->menu_bar_window);
2485 free_glyph_matrix (w->desired_matrix);
2486 free_glyph_matrix (w->current_matrix);
2487 w->desired_matrix = w->current_matrix = NULL;
2488 f->menu_bar_window = Qnil;
2489 }
2490
2491 /* Free the tool bar window and its glyph matrices. */
2492 if (!NILP (f->tool_bar_window))
2493 {
2494 struct window *w = XWINDOW (f->tool_bar_window);
2495 free_glyph_matrix (w->desired_matrix);
2496 free_glyph_matrix (w->current_matrix);
2497 w->desired_matrix = w->current_matrix = NULL;
2498 f->tool_bar_window = Qnil;
2499 }
2500
2501 /* Release frame glyph matrices. Reset fields to zero in
2502 case we are called a second time. */
2503 if (f->desired_matrix)
2504 {
2505 free_glyph_matrix (f->desired_matrix);
2506 free_glyph_matrix (f->current_matrix);
2507 f->desired_matrix = f->current_matrix = NULL;
2508 }
2509
2510 /* Release glyph pools. */
2511 if (f->desired_pool)
2512 {
2513 free_glyph_pool (f->desired_pool);
2514 free_glyph_pool (f->current_pool);
2515 f->desired_pool = f->current_pool = NULL;
2516 }
2517
2518 UNBLOCK_INPUT;
2519 }
2520 }
2521
2522
2523 /* Free glyph sub-matrices in the window tree rooted at W. This
2524 function may be called with a null pointer, and it may be called on
2525 the same tree more than once. */
2526
2527 void
2528 free_window_matrices (w)
2529 struct window *w;
2530 {
2531 while (w)
2532 {
2533 if (!NILP (w->hchild))
2534 free_window_matrices (XWINDOW (w->hchild));
2535 else if (!NILP (w->vchild))
2536 free_window_matrices (XWINDOW (w->vchild));
2537 else
2538 {
2539 /* This is a leaf window. Free its memory and reset fields
2540 to zero in case this function is called a second time for
2541 W. */
2542 free_glyph_matrix (w->current_matrix);
2543 free_glyph_matrix (w->desired_matrix);
2544 w->current_matrix = w->desired_matrix = NULL;
2545 }
2546
2547 /* Next window on same level. */
2548 w = NILP (w->next) ? 0 : XWINDOW (w->next);
2549 }
2550 }
2551
2552
2553 /* Check glyph memory leaks. This function is called from
2554 shut_down_emacs. Note that frames are not destroyed when Emacs
2555 exits. We therefore free all glyph memory for all active frames
2556 explicitly and check that nothing is left allocated. */
2557
2558 void
2559 check_glyph_memory ()
2560 {
2561 Lisp_Object tail, frame;
2562
2563 /* Free glyph memory for all frames. */
2564 FOR_EACH_FRAME (tail, frame)
2565 free_glyphs (XFRAME (frame));
2566
2567 /* Check that nothing is left allocated. */
2568 if (glyph_matrix_count)
2569 abort ();
2570 if (glyph_pool_count)
2571 abort ();
2572 }
2573
2574
2575 \f
2576 /**********************************************************************
2577 Building a Frame Matrix
2578 **********************************************************************/
2579
2580 /* Most of the redisplay code works on glyph matrices attached to
2581 windows. This is a good solution most of the time, but it is not
2582 suitable for terminal code. Terminal output functions cannot rely
2583 on being able to set an arbitrary terminal window. Instead they
2584 must be provided with a view of the whole frame, i.e. the whole
2585 screen. We build such a view by constructing a frame matrix from
2586 window matrices in this section.
2587
2588 Windows that must be updated have their must_be_update_p flag set.
2589 For all such windows, their desired matrix is made part of the
2590 desired frame matrix. For other windows, their current matrix is
2591 made part of the desired frame matrix.
2592
2593 +-----------------+----------------+
2594 | desired | desired |
2595 | | |
2596 +-----------------+----------------+
2597 | current |
2598 | |
2599 +----------------------------------+
2600
2601 Desired window matrices can be made part of the frame matrix in a
2602 cheap way: We exploit the fact that the desired frame matrix and
2603 desired window matrices share their glyph memory. This is not
2604 possible for current window matrices. Their glyphs are copied to
2605 the desired frame matrix. The latter is equivalent to
2606 preserve_other_columns in the old redisplay.
2607
2608 Used glyphs counters for frame matrix rows are the result of adding
2609 up glyph lengths of the window matrices. A line in the frame
2610 matrix is enabled, if a corresponding line in a window matrix is
2611 enabled.
2612
2613 After building the desired frame matrix, it will be passed to
2614 terminal code, which will manipulate both the desired and current
2615 frame matrix. Changes applied to the frame's current matrix have
2616 to be visible in current window matrices afterwards, of course.
2617
2618 This problem is solved like this:
2619
2620 1. Window and frame matrices share glyphs. Window matrices are
2621 constructed in a way that their glyph contents ARE the glyph
2622 contents needed in a frame matrix. Thus, any modification of
2623 glyphs done in terminal code will be reflected in window matrices
2624 automatically.
2625
2626 2. Exchanges of rows in a frame matrix done by terminal code are
2627 intercepted by hook functions so that corresponding row operations
2628 on window matrices can be performed. This is necessary because we
2629 use pointers to glyphs in glyph row structures. To satisfy the
2630 assumption of point 1 above that glyphs are updated implicitly in
2631 window matrices when they are manipulated via the frame matrix,
2632 window and frame matrix must of course agree where to find the
2633 glyphs for their rows. Possible manipulations that must be
2634 mirrored are assignments of rows of the desired frame matrix to the
2635 current frame matrix and scrolling the current frame matrix. */
2636
2637 /* Build frame F's desired matrix from window matrices. Only windows
2638 which have the flag must_be_updated_p set have to be updated. Menu
2639 bar lines of a frame are not covered by window matrices, so make
2640 sure not to touch them in this function. */
2641
2642 static void
2643 build_frame_matrix (f)
2644 struct frame *f;
2645 {
2646 int i;
2647
2648 /* F must have a frame matrix when this function is called. */
2649 xassert (!FRAME_WINDOW_P (f));
2650
2651 /* Clear all rows in the frame matrix covered by window matrices.
2652 Menu bar lines are not covered by windows. */
2653 for (i = FRAME_TOP_MARGIN (f); i < f->desired_matrix->nrows; ++i)
2654 clear_glyph_row (MATRIX_ROW (f->desired_matrix, i));
2655
2656 /* Build the matrix by walking the window tree. */
2657 build_frame_matrix_from_window_tree (f->desired_matrix,
2658 XWINDOW (FRAME_ROOT_WINDOW (f)));
2659 }
2660
2661
2662 /* Walk a window tree, building a frame matrix MATRIX from window
2663 matrices. W is the root of a window tree. */
2664
2665 static void
2666 build_frame_matrix_from_window_tree (matrix, w)
2667 struct glyph_matrix *matrix;
2668 struct window *w;
2669 {
2670 while (w)
2671 {
2672 if (!NILP (w->hchild))
2673 build_frame_matrix_from_window_tree (matrix, XWINDOW (w->hchild));
2674 else if (!NILP (w->vchild))
2675 build_frame_matrix_from_window_tree (matrix, XWINDOW (w->vchild));
2676 else
2677 build_frame_matrix_from_leaf_window (matrix, w);
2678
2679 w = NILP (w->next) ? 0 : XWINDOW (w->next);
2680 }
2681 }
2682
2683
2684 /* Add a window's matrix to a frame matrix. FRAME_MATRIX is the
2685 desired frame matrix built. W is a leaf window whose desired or
2686 current matrix is to be added to FRAME_MATRIX. W's flag
2687 must_be_updated_p determines which matrix it contributes to
2688 FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix
2689 is added to FRAME_MATRIX, otherwise W's current matrix is added.
2690 Adding a desired matrix means setting up used counters and such in
2691 frame rows, while adding a current window matrix to FRAME_MATRIX
2692 means copying glyphs. The latter case corresponds to
2693 preserve_other_columns in the old redisplay. */
2694
2695 static void
2696 build_frame_matrix_from_leaf_window (frame_matrix, w)
2697 struct glyph_matrix *frame_matrix;
2698 struct window *w;
2699 {
2700 struct glyph_matrix *window_matrix;
2701 int window_y, frame_y;
2702 /* If non-zero, a glyph to insert at the right border of W. */
2703 GLYPH right_border_glyph = 0;
2704
2705 /* Set window_matrix to the matrix we have to add to FRAME_MATRIX. */
2706 if (w->must_be_updated_p)
2707 {
2708 window_matrix = w->desired_matrix;
2709
2710 /* Decide whether we want to add a vertical border glyph. */
2711 if (!WINDOW_RIGHTMOST_P (w))
2712 {
2713 struct Lisp_Char_Table *dp = window_display_table (w);
2714 right_border_glyph = (dp && INTEGERP (DISP_BORDER_GLYPH (dp))
2715 ? XINT (DISP_BORDER_GLYPH (dp))
2716 : '|');
2717 }
2718 }
2719 else
2720 window_matrix = w->current_matrix;
2721
2722 /* For all rows in the window matrix and corresponding rows in the
2723 frame matrix. */
2724 window_y = 0;
2725 frame_y = window_matrix->matrix_y;
2726 while (window_y < window_matrix->nrows)
2727 {
2728 struct glyph_row *frame_row = frame_matrix->rows + frame_y;
2729 struct glyph_row *window_row = window_matrix->rows + window_y;
2730 int current_row_p = window_matrix == w->current_matrix;
2731
2732 /* Fill up the frame row with spaces up to the left margin of the
2733 window row. */
2734 fill_up_frame_row_with_spaces (frame_row, window_matrix->matrix_x);
2735
2736 /* Fill up areas in the window matrix row with spaces. */
2737 fill_up_glyph_row_with_spaces (window_row);
2738
2739 /* If only part of W's desired matrix has been built, and
2740 window_row wasn't displayed, use the corresponding current
2741 row instead. */
2742 if (window_matrix == w->desired_matrix
2743 && !window_row->enabled_p)
2744 {
2745 window_row = w->current_matrix->rows + window_y;
2746 current_row_p = 1;
2747 }
2748
2749 if (current_row_p)
2750 {
2751 /* Copy window row to frame row. */
2752 bcopy (window_row->glyphs[0],
2753 frame_row->glyphs[TEXT_AREA] + window_matrix->matrix_x,
2754 window_matrix->matrix_w * sizeof (struct glyph));
2755 }
2756 else
2757 {
2758 xassert (window_row->enabled_p);
2759
2760 /* Only when a desired row has been displayed, we want
2761 the corresponding frame row to be updated. */
2762 frame_row->enabled_p = 1;
2763
2764 /* Maybe insert a vertical border between horizontally adjacent
2765 windows. */
2766 if (right_border_glyph)
2767 {
2768 struct glyph *border = window_row->glyphs[LAST_AREA] - 1;
2769 SET_CHAR_GLYPH_FROM_GLYPH (*border, right_border_glyph);
2770 }
2771
2772 /* Window row window_y must be a slice of frame row
2773 frame_y. */
2774 xassert (glyph_row_slice_p (window_row, frame_row));
2775
2776 /* If rows are in sync, we don't have to copy glyphs because
2777 frame and window share glyphs. */
2778
2779 #if GLYPH_DEBUG
2780 strcpy (w->current_matrix->method, w->desired_matrix->method);
2781 add_window_display_history (w, w->current_matrix->method, 0);
2782 #endif
2783 }
2784
2785 /* Set number of used glyphs in the frame matrix. Since we fill
2786 up with spaces, and visit leaf windows from left to right it
2787 can be done simply. */
2788 frame_row->used[TEXT_AREA]
2789 = window_matrix->matrix_x + window_matrix->matrix_w;
2790
2791 /* Next row. */
2792 ++window_y;
2793 ++frame_y;
2794 }
2795 }
2796
2797
2798 /* Add spaces to a glyph row ROW in a window matrix.
2799
2800 Each row has the form:
2801
2802 +---------+-----------------------------+------------+
2803 | left | text | right |
2804 +---------+-----------------------------+------------+
2805
2806 Left and right marginal areas are optional. This function adds
2807 spaces to areas so that there are no empty holes between areas.
2808 In other words: If the right area is not empty, the text area
2809 is filled up with spaces up to the right area. If the text area
2810 is not empty, the left area is filled up.
2811
2812 To be called for frame-based redisplay, only. */
2813
2814 static void
2815 fill_up_glyph_row_with_spaces (row)
2816 struct glyph_row *row;
2817 {
2818 fill_up_glyph_row_area_with_spaces (row, LEFT_MARGIN_AREA);
2819 fill_up_glyph_row_area_with_spaces (row, TEXT_AREA);
2820 fill_up_glyph_row_area_with_spaces (row, RIGHT_MARGIN_AREA);
2821 }
2822
2823
2824 /* Fill area AREA of glyph row ROW with spaces. To be called for
2825 frame-based redisplay only. */
2826
2827 static void
2828 fill_up_glyph_row_area_with_spaces (row, area)
2829 struct glyph_row *row;
2830 int area;
2831 {
2832 if (row->glyphs[area] < row->glyphs[area + 1])
2833 {
2834 struct glyph *end = row->glyphs[area + 1];
2835 struct glyph *text = row->glyphs[area] + row->used[area];
2836
2837 while (text < end)
2838 *text++ = space_glyph;
2839 row->used[area] = text - row->glyphs[area];
2840 }
2841 }
2842
2843
2844 /* Add spaces to the end of ROW in a frame matrix until index UPTO is
2845 reached. In frame matrices only one area, TEXT_AREA, is used. */
2846
2847 static void
2848 fill_up_frame_row_with_spaces (row, upto)
2849 struct glyph_row *row;
2850 int upto;
2851 {
2852 int i = row->used[TEXT_AREA];
2853 struct glyph *glyph = row->glyphs[TEXT_AREA];
2854
2855 while (i < upto)
2856 glyph[i++] = space_glyph;
2857
2858 row->used[TEXT_AREA] = i;
2859 }
2860
2861
2862 \f
2863 /**********************************************************************
2864 Mirroring operations on frame matrices in window matrices
2865 **********************************************************************/
2866
2867 /* Set frame being updated via frame-based redisplay to F. This
2868 function must be called before updates to make explicit that we are
2869 working on frame matrices or not. */
2870
2871 static INLINE void
2872 set_frame_matrix_frame (f)
2873 struct frame *f;
2874 {
2875 frame_matrix_frame = f;
2876 }
2877
2878
2879 /* Make sure glyph row ROW in CURRENT_MATRIX is up to date.
2880 DESIRED_MATRIX is the desired matrix corresponding to
2881 CURRENT_MATRIX. The update is done by exchanging glyph pointers
2882 between rows in CURRENT_MATRIX and DESIRED_MATRIX. If
2883 frame_matrix_frame is non-null, this indicates that the exchange is
2884 done in frame matrices, and that we have to perform analogous
2885 operations in window matrices of frame_matrix_frame. */
2886
2887 static INLINE void
2888 make_current (desired_matrix, current_matrix, row)
2889 struct glyph_matrix *desired_matrix, *current_matrix;
2890 int row;
2891 {
2892 struct glyph_row *current_row = MATRIX_ROW (current_matrix, row);
2893 struct glyph_row *desired_row = MATRIX_ROW (desired_matrix, row);
2894 int mouse_face_p = current_row->mouse_face_p;
2895
2896 /* Do current_row = desired_row. This exchanges glyph pointers
2897 between both rows, and does a structure assignment otherwise. */
2898 assign_row (current_row, desired_row);
2899
2900 /* Enable current_row to mark it as valid. */
2901 current_row->enabled_p = 1;
2902 current_row->mouse_face_p = mouse_face_p;
2903
2904 /* If we are called on frame matrices, perform analogous operations
2905 for window matrices. */
2906 if (frame_matrix_frame)
2907 mirror_make_current (XWINDOW (frame_matrix_frame->root_window), row);
2908 }
2909
2910
2911 /* W is the root of a window tree. FRAME_ROW is the index of a row in
2912 W's frame which has been made current (by swapping pointers between
2913 current and desired matrix). Perform analogous operations in the
2914 matrices of leaf windows in the window tree rooted at W. */
2915
2916 static void
2917 mirror_make_current (w, frame_row)
2918 struct window *w;
2919 int frame_row;
2920 {
2921 while (w)
2922 {
2923 if (!NILP (w->hchild))
2924 mirror_make_current (XWINDOW (w->hchild), frame_row);
2925 else if (!NILP (w->vchild))
2926 mirror_make_current (XWINDOW (w->vchild), frame_row);
2927 else
2928 {
2929 /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS
2930 here because the checks performed in debug mode there
2931 will not allow the conversion. */
2932 int row = frame_row - w->desired_matrix->matrix_y;
2933
2934 /* If FRAME_ROW is within W, assign the desired row to the
2935 current row (exchanging glyph pointers). */
2936 if (row >= 0 && row < w->desired_matrix->matrix_h)
2937 {
2938 struct glyph_row *current_row
2939 = MATRIX_ROW (w->current_matrix, row);
2940 struct glyph_row *desired_row
2941 = MATRIX_ROW (w->desired_matrix, row);
2942
2943 if (desired_row->enabled_p)
2944 assign_row (current_row, desired_row);
2945 else
2946 swap_glyph_pointers (desired_row, current_row);
2947 current_row->enabled_p = 1;
2948 }
2949 }
2950
2951 w = NILP (w->next) ? 0 : XWINDOW (w->next);
2952 }
2953 }
2954
2955
2956 /* Perform row dance after scrolling. We are working on the range of
2957 lines UNCHANGED_AT_TOP + 1 to UNCHANGED_AT_TOP + NLINES (not
2958 including) in MATRIX. COPY_FROM is a vector containing, for each
2959 row I in the range 0 <= I < NLINES, the index of the original line
2960 to move to I. This index is relative to the row range, i.e. 0 <=
2961 index < NLINES. RETAINED_P is a vector containing zero for each
2962 row 0 <= I < NLINES which is empty.
2963
2964 This function is called from do_scrolling and do_direct_scrolling. */
2965
2966 void
2967 mirrored_line_dance (matrix, unchanged_at_top, nlines, copy_from,
2968 retained_p)
2969 struct glyph_matrix *matrix;
2970 int unchanged_at_top, nlines;
2971 int *copy_from;
2972 char *retained_p;
2973 {
2974 /* A copy of original rows. */
2975 struct glyph_row *old_rows;
2976
2977 /* Rows to assign to. */
2978 struct glyph_row *new_rows = MATRIX_ROW (matrix, unchanged_at_top);
2979
2980 int i;
2981
2982 /* Make a copy of the original rows. */
2983 old_rows = (struct glyph_row *) alloca (nlines * sizeof *old_rows);
2984 bcopy (new_rows, old_rows, nlines * sizeof *old_rows);
2985
2986 /* Assign new rows, maybe clear lines. */
2987 for (i = 0; i < nlines; ++i)
2988 {
2989 int enabled_before_p = new_rows[i].enabled_p;
2990
2991 xassert (i + unchanged_at_top < matrix->nrows);
2992 xassert (unchanged_at_top + copy_from[i] < matrix->nrows);
2993 new_rows[i] = old_rows[copy_from[i]];
2994 new_rows[i].enabled_p = enabled_before_p;
2995
2996 /* RETAINED_P is zero for empty lines. */
2997 if (!retained_p[copy_from[i]])
2998 new_rows[i].enabled_p = 0;
2999 }
3000
3001 /* Do the same for window matrices, if MATRIX is a frame matrix. */
3002 if (frame_matrix_frame)
3003 mirror_line_dance (XWINDOW (frame_matrix_frame->root_window),
3004 unchanged_at_top, nlines, copy_from, retained_p);
3005 }
3006
3007
3008 /* Synchronize glyph pointers in the current matrix of window W with
3009 the current frame matrix. */
3010
3011 static void
3012 sync_window_with_frame_matrix_rows (w)
3013 struct window *w;
3014 {
3015 struct frame *f = XFRAME (w->frame);
3016 struct glyph_row *window_row, *window_row_end, *frame_row;
3017 int left, right, x, width;
3018
3019 /* Preconditions: W must be a leaf window on a tty frame. */
3020 xassert (NILP (w->hchild) && NILP (w->vchild));
3021 xassert (!FRAME_WINDOW_P (f));
3022
3023 left = margin_glyphs_to_reserve (w, 1, w->left_margin_width);
3024 right = margin_glyphs_to_reserve (w, 1, w->right_margin_width);
3025 x = w->current_matrix->matrix_x;
3026 width = w->current_matrix->matrix_w;
3027
3028 window_row = w->current_matrix->rows;
3029 window_row_end = window_row + w->current_matrix->nrows;
3030 frame_row = f->current_matrix->rows + XFASTINT (w->top);
3031
3032 for (; window_row < window_row_end; ++window_row, ++frame_row)
3033 {
3034 window_row->glyphs[LEFT_MARGIN_AREA]
3035 = frame_row->glyphs[0] + x;
3036 window_row->glyphs[TEXT_AREA]
3037 = window_row->glyphs[LEFT_MARGIN_AREA] + left;
3038 window_row->glyphs[LAST_AREA]
3039 = window_row->glyphs[LEFT_MARGIN_AREA] + width;
3040 window_row->glyphs[RIGHT_MARGIN_AREA]
3041 = window_row->glyphs[LAST_AREA] - right;
3042 }
3043 }
3044
3045
3046 /* Return the window in the window tree rooted in W containing frame
3047 row ROW. Value is null if none is found. */
3048
3049 struct window *
3050 frame_row_to_window (w, row)
3051 struct window *w;
3052 int row;
3053 {
3054 struct window *found = NULL;
3055
3056 while (w && !found)
3057 {
3058 if (!NILP (w->hchild))
3059 found = frame_row_to_window (XWINDOW (w->hchild), row);
3060 else if (!NILP (w->vchild))
3061 found = frame_row_to_window (XWINDOW (w->vchild), row);
3062 else if (row >= XFASTINT (w->top)
3063 && row < XFASTINT (w->top) + XFASTINT (w->height))
3064 found = w;
3065
3066 w = NILP (w->next) ? 0 : XWINDOW (w->next);
3067 }
3068
3069 return found;
3070 }
3071
3072
3073 /* Perform a line dance in the window tree rooted at W, after
3074 scrolling a frame matrix in mirrored_line_dance.
3075
3076 We are working on the range of lines UNCHANGED_AT_TOP + 1 to
3077 UNCHANGED_AT_TOP + NLINES (not including) in W's frame matrix.
3078 COPY_FROM is a vector containing, for each row I in the range 0 <=
3079 I < NLINES, the index of the original line to move to I. This
3080 index is relative to the row range, i.e. 0 <= index < NLINES.
3081 RETAINED_P is a vector containing zero for each row 0 <= I < NLINES
3082 which is empty. */
3083
3084 static void
3085 mirror_line_dance (w, unchanged_at_top, nlines, copy_from, retained_p)
3086 struct window *w;
3087 int unchanged_at_top, nlines;
3088 int *copy_from;
3089 char *retained_p;
3090 {
3091 while (w)
3092 {
3093 if (!NILP (w->hchild))
3094 mirror_line_dance (XWINDOW (w->hchild), unchanged_at_top,
3095 nlines, copy_from, retained_p);
3096 else if (!NILP (w->vchild))
3097 mirror_line_dance (XWINDOW (w->vchild), unchanged_at_top,
3098 nlines, copy_from, retained_p);
3099 else
3100 {
3101 /* W is a leaf window, and we are working on its current
3102 matrix m. */
3103 struct glyph_matrix *m = w->current_matrix;
3104 int i, sync_p = 0;
3105 struct glyph_row *old_rows;
3106
3107 /* Make a copy of the original rows of matrix m. */
3108 old_rows = (struct glyph_row *) alloca (m->nrows * sizeof *old_rows);
3109 bcopy (m->rows, old_rows, m->nrows * sizeof *old_rows);
3110
3111 for (i = 0; i < nlines; ++i)
3112 {
3113 /* Frame relative line assigned to. */
3114 int frame_to = i + unchanged_at_top;
3115
3116 /* Frame relative line assigned. */
3117 int frame_from = copy_from[i] + unchanged_at_top;
3118
3119 /* Window relative line assigned to. */
3120 int window_to = frame_to - m->matrix_y;
3121
3122 /* Window relative line assigned. */
3123 int window_from = frame_from - m->matrix_y;
3124
3125 /* Is assigned line inside window? */
3126 int from_inside_window_p
3127 = window_from >= 0 && window_from < m->matrix_h;
3128
3129 /* Is assigned to line inside window? */
3130 int to_inside_window_p
3131 = window_to >= 0 && window_to < m->matrix_h;
3132
3133 if (from_inside_window_p && to_inside_window_p)
3134 {
3135 /* Enabled setting before assignment. */
3136 int enabled_before_p;
3137
3138 /* Do the assignment. The enabled_p flag is saved
3139 over the assignment because the old redisplay did
3140 that. */
3141 enabled_before_p = m->rows[window_to].enabled_p;
3142 m->rows[window_to] = old_rows[window_from];
3143 m->rows[window_to].enabled_p = enabled_before_p;
3144
3145 /* If frame line is empty, window line is empty, too. */
3146 if (!retained_p[copy_from[i]])
3147 m->rows[window_to].enabled_p = 0;
3148 }
3149 else if (to_inside_window_p)
3150 {
3151 /* A copy between windows. This is an infrequent
3152 case not worth optimizing. */
3153 struct frame *f = XFRAME (w->frame);
3154 struct window *root = XWINDOW (FRAME_ROOT_WINDOW (f));
3155 struct window *w2;
3156 struct glyph_matrix *m2;
3157 int m2_from;
3158
3159 w2 = frame_row_to_window (root, frame_to);
3160 m2 = w2->current_matrix;
3161 m2_from = frame_from - m2->matrix_y;
3162 copy_row_except_pointers (m->rows + window_to,
3163 m2->rows + m2_from);
3164
3165 /* If frame line is empty, window line is empty, too. */
3166 if (!retained_p[copy_from[i]])
3167 m->rows[window_to].enabled_p = 0;
3168 sync_p = 1;
3169 }
3170 else if (from_inside_window_p)
3171 sync_p = 1;
3172 }
3173
3174 /* If there was a copy between windows, make sure glyph
3175 pointers are in sync with the frame matrix. */
3176 if (sync_p)
3177 sync_window_with_frame_matrix_rows (w);
3178
3179 /* Check that no pointers are lost. */
3180 CHECK_MATRIX (m);
3181 }
3182
3183 /* Next window on same level. */
3184 w = NILP (w->next) ? 0 : XWINDOW (w->next);
3185 }
3186 }
3187
3188
3189 #if GLYPH_DEBUG
3190
3191 /* Check that window and frame matrices agree about their
3192 understanding where glyphs of the rows are to find. For each
3193 window in the window tree rooted at W, check that rows in the
3194 matrices of leaf window agree with their frame matrices about
3195 glyph pointers. */
3196
3197 void
3198 check_window_matrix_pointers (w)
3199 struct window *w;
3200 {
3201 while (w)
3202 {
3203 if (!NILP (w->hchild))
3204 check_window_matrix_pointers (XWINDOW (w->hchild));
3205 else if (!NILP (w->vchild))
3206 check_window_matrix_pointers (XWINDOW (w->vchild));
3207 else
3208 {
3209 struct frame *f = XFRAME (w->frame);
3210 check_matrix_pointers (w->desired_matrix, f->desired_matrix);
3211 check_matrix_pointers (w->current_matrix, f->current_matrix);
3212 }
3213
3214 w = NILP (w->next) ? 0 : XWINDOW (w->next);
3215 }
3216 }
3217
3218
3219 /* Check that window rows are slices of frame rows. WINDOW_MATRIX is
3220 a window and FRAME_MATRIX is the corresponding frame matrix. For
3221 each row in WINDOW_MATRIX check that it's a slice of the
3222 corresponding frame row. If it isn't, abort. */
3223
3224 static void
3225 check_matrix_pointers (window_matrix, frame_matrix)
3226 struct glyph_matrix *window_matrix, *frame_matrix;
3227 {
3228 /* Row number in WINDOW_MATRIX. */
3229 int i = 0;
3230
3231 /* Row number corresponding to I in FRAME_MATRIX. */
3232 int j = window_matrix->matrix_y;
3233
3234 /* For all rows check that the row in the window matrix is a
3235 slice of the row in the frame matrix. If it isn't we didn't
3236 mirror an operation on the frame matrix correctly. */
3237 while (i < window_matrix->nrows)
3238 {
3239 if (!glyph_row_slice_p (window_matrix->rows + i,
3240 frame_matrix->rows + j))
3241 abort ();
3242 ++i, ++j;
3243 }
3244 }
3245
3246 #endif /* GLYPH_DEBUG != 0 */
3247
3248
3249 \f
3250 /**********************************************************************
3251 VPOS and HPOS translations
3252 **********************************************************************/
3253
3254 #if GLYPH_DEBUG
3255
3256 /* Translate vertical position VPOS which is relative to window W to a
3257 vertical position relative to W's frame. */
3258
3259 static int
3260 window_to_frame_vpos (w, vpos)
3261 struct window *w;
3262 int vpos;
3263 {
3264 struct frame *f = XFRAME (w->frame);
3265
3266 xassert (!FRAME_WINDOW_P (f));
3267 xassert (vpos >= 0 && vpos <= w->desired_matrix->nrows);
3268 vpos += XFASTINT (w->top);
3269 xassert (vpos >= 0 && vpos <= FRAME_HEIGHT (f));
3270 return vpos;
3271 }
3272
3273
3274 /* Translate horizontal position HPOS which is relative to window W to
3275 a horizontal position relative to W's frame. */
3276
3277 static int
3278 window_to_frame_hpos (w, hpos)
3279 struct window *w;
3280 int hpos;
3281 {
3282 struct frame *f = XFRAME (w->frame);
3283
3284 xassert (!FRAME_WINDOW_P (f));
3285 hpos += XFASTINT (w->left);
3286 return hpos;
3287 }
3288
3289 #endif /* GLYPH_DEBUG */
3290
3291
3292 \f
3293 /**********************************************************************
3294 Redrawing Frames
3295 **********************************************************************/
3296
3297 DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 1, 1, 0,
3298 doc: /* Clear frame FRAME and output again what is supposed to appear on it. */)
3299 (frame)
3300 Lisp_Object frame;
3301 {
3302 struct frame *f;
3303
3304 CHECK_LIVE_FRAME (frame);
3305 f = XFRAME (frame);
3306
3307 /* Ignore redraw requests, if frame has no glyphs yet.
3308 (Implementation note: It still has to be checked why we are
3309 called so early here). */
3310 if (!glyphs_initialized_initially_p)
3311 return Qnil;
3312
3313 update_begin (f);
3314 if (FRAME_MSDOS_P (f))
3315 set_terminal_modes ();
3316 clear_frame ();
3317 clear_current_matrices (f);
3318 update_end (f);
3319 fflush (stdout);
3320 windows_or_buffers_changed++;
3321 /* Mark all windows as inaccurate, so that every window will have
3322 its redisplay done. */
3323 mark_window_display_accurate (FRAME_ROOT_WINDOW (f), 0);
3324 set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f)), 1);
3325 f->garbaged = 0;
3326 return Qnil;
3327 }
3328
3329
3330 /* Redraw frame F. This is nothing more than a call to the Lisp
3331 function redraw-frame. */
3332
3333 void
3334 redraw_frame (f)
3335 struct frame *f;
3336 {
3337 Lisp_Object frame;
3338 XSETFRAME (frame, f);
3339 Fredraw_frame (frame);
3340 }
3341
3342
3343 DEFUN ("redraw-display", Fredraw_display, Sredraw_display, 0, 0, "",
3344 doc: /* Clear and redisplay all visible frames. */)
3345 ()
3346 {
3347 Lisp_Object tail, frame;
3348
3349 FOR_EACH_FRAME (tail, frame)
3350 if (FRAME_VISIBLE_P (XFRAME (frame)))
3351 Fredraw_frame (frame);
3352
3353 return Qnil;
3354 }
3355
3356
3357 /* This is used when frame_garbaged is set. Call Fredraw_frame on all
3358 visible frames marked as garbaged. */
3359
3360 void
3361 redraw_garbaged_frames ()
3362 {
3363 Lisp_Object tail, frame;
3364
3365 FOR_EACH_FRAME (tail, frame)
3366 if (FRAME_VISIBLE_P (XFRAME (frame))
3367 && FRAME_GARBAGED_P (XFRAME (frame)))
3368 Fredraw_frame (frame);
3369 }
3370
3371
3372 \f
3373 /***********************************************************************
3374 Direct Operations
3375 ***********************************************************************/
3376
3377 /* Try to update display and current glyph matrix directly.
3378
3379 This function is called after a character G has been inserted into
3380 current_buffer. It tries to update the current glyph matrix and
3381 perform appropriate screen output to reflect the insertion. If it
3382 succeeds, the global flag redisplay_performed_directly_p will be
3383 set to 1, and thereby prevent the more costly general redisplay
3384 from running (see redisplay_internal).
3385
3386 This function is not called for `hairy' character insertions.
3387 In particular, it is not called when after or before change
3388 functions exist, like they are used by font-lock. See keyboard.c
3389 for details where this function is called. */
3390
3391 int
3392 direct_output_for_insert (g)
3393 int g;
3394 {
3395 register struct frame *f = SELECTED_FRAME ();
3396 struct window *w = XWINDOW (selected_window);
3397 struct it it, it2;
3398 struct glyph_row *glyph_row;
3399 struct glyph *glyphs, *glyph, *end;
3400 int n;
3401 /* Non-null means that redisplay of W is based on window matrices. */
3402 int window_redisplay_p = FRAME_WINDOW_P (f);
3403 /* Non-null means we are in overwrite mode. */
3404 int overwrite_p = !NILP (current_buffer->overwrite_mode);
3405 int added_width;
3406 struct text_pos pos;
3407 int delta, delta_bytes;
3408
3409 /* Not done directly. */
3410 redisplay_performed_directly_p = 0;
3411
3412 /* Quickly give up for some common cases. */
3413 if (cursor_in_echo_area
3414 /* Give up if fonts have changed. */
3415 || fonts_changed_p
3416 /* Give up if face attributes have been changed. */
3417 || face_change_count
3418 /* Give up if cursor position not really known. */
3419 || !display_completed
3420 /* Give up if buffer appears in two places. */
3421 || buffer_shared > 1
3422 /* Give up if currently displaying a message instead of the
3423 minibuffer contents. */
3424 || (EQ (selected_window, minibuf_window)
3425 && EQ (minibuf_window, echo_area_window))
3426 /* Give up for hscrolled mini-buffer because display of the prompt
3427 is handled specially there (see display_line). */
3428 || (MINI_WINDOW_P (w) && XFASTINT (w->hscroll))
3429 /* Give up if overwriting in the middle of a line. */
3430 || (overwrite_p
3431 && PT != ZV
3432 && FETCH_BYTE (PT) != '\n')
3433 /* Give up for tabs and line ends. */
3434 || g == '\t'
3435 || g == '\n'
3436 || g == '\r'
3437 /* Give up if unable to display the cursor in the window. */
3438 || w->cursor.vpos < 0
3439 /* Give up if we are showing a message or just cleared the message
3440 because we might need to resize the echo area window. */
3441 || !NILP (echo_area_buffer[0])
3442 || !NILP (echo_area_buffer[1])
3443 || (glyph_row = MATRIX_ROW (w->current_matrix, w->cursor.vpos),
3444 /* Can't do it in a continued line because continuation
3445 lines would change. */
3446 (glyph_row->continued_p
3447 /* Can't use this method if the line overlaps others or is
3448 overlapped by others because these other lines would
3449 have to be redisplayed. */
3450 || glyph_row->overlapping_p
3451 || glyph_row->overlapped_p))
3452 /* Can't do it for partial width windows on terminal frames
3453 because we can't clear to eol in such a window. */
3454 || (!window_redisplay_p && !WINDOW_FULL_WIDTH_P (w)))
3455 return 0;
3456
3457 /* If we can't insert glyphs, we can use this method only
3458 at the end of a line. */
3459 if (!char_ins_del_ok)
3460 if (PT != ZV && FETCH_BYTE (PT_BYTE) != '\n')
3461 return 0;
3462
3463 /* Set up a display iterator structure for W. Glyphs will be
3464 produced in scratch_glyph_row. Current position is W's cursor
3465 position. */
3466 clear_glyph_row (&scratch_glyph_row);
3467 SET_TEXT_POS (pos, PT, PT_BYTE);
3468 DEC_TEXT_POS (pos, !NILP (current_buffer->enable_multibyte_characters));
3469 init_iterator (&it, w, CHARPOS (pos), BYTEPOS (pos), &scratch_glyph_row,
3470 DEFAULT_FACE_ID);
3471
3472 glyph_row = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
3473 if (glyph_row->mouse_face_p)
3474 return 0;
3475
3476 /* Give up if highlighting trailing whitespace and we have trailing
3477 whitespace in glyph_row. We would have to remove the trailing
3478 whitespace face in that case. */
3479 if (!NILP (Vshow_trailing_whitespace)
3480 && glyph_row->used[TEXT_AREA])
3481 {
3482 struct glyph *last;
3483
3484 last = glyph_row->glyphs[TEXT_AREA] + glyph_row->used[TEXT_AREA] - 1;
3485 if (last->type == STRETCH_GLYPH
3486 || (last->type == CHAR_GLYPH
3487 && last->u.ch == ' '))
3488 return 0;
3489 }
3490
3491 /* Give up if there are overlay strings at pos. This would fail
3492 if the overlay string has newlines in it. */
3493 if (STRINGP (it.string))
3494 return 0;
3495
3496 it.hpos = w->cursor.hpos;
3497 it.vpos = w->cursor.vpos;
3498 it.current_x = w->cursor.x + it.first_visible_x;
3499 it.current_y = w->cursor.y;
3500 it.end_charpos = PT;
3501 it.stop_charpos = min (PT, it.stop_charpos);
3502 it.stop_charpos = max (IT_CHARPOS (it), it.stop_charpos);
3503
3504 /* More than one display element may be returned for PT - 1 if
3505 (i) it's a control character which is translated into `\003' or
3506 `^C', or (ii) it has a display table entry, or (iii) it's a
3507 combination of both. */
3508 delta = delta_bytes = 0;
3509 while (get_next_display_element (&it))
3510 {
3511 PRODUCE_GLYPHS (&it);
3512
3513 /* Give up if glyph doesn't fit completely on the line. */
3514 if (it.current_x >= it.last_visible_x)
3515 return 0;
3516
3517 /* Give up if new glyph has different ascent or descent than
3518 the original row, or if it is not a character glyph. */
3519 if (glyph_row->ascent != it.ascent
3520 || glyph_row->height != it.ascent + it.descent
3521 || glyph_row->phys_ascent != it.phys_ascent
3522 || glyph_row->phys_height != it.phys_ascent + it.phys_descent
3523 || it.what != IT_CHARACTER)
3524 return 0;
3525
3526 delta += 1;
3527 delta_bytes += it.len;
3528 set_iterator_to_next (&it, 1);
3529 }
3530
3531 /* Give up if we hit the right edge of the window. We would have
3532 to insert truncation or continuation glyphs. */
3533 added_width = it.current_x - (w->cursor.x + it.first_visible_x);
3534 if (glyph_row->pixel_width + added_width >= it.last_visible_x)
3535 return 0;
3536
3537 /* Give up if there is a \t following in the line. */
3538 it2 = it;
3539 it2.end_charpos = ZV;
3540 it2.stop_charpos = min (it2.stop_charpos, ZV);
3541 while (get_next_display_element (&it2)
3542 && !ITERATOR_AT_END_OF_LINE_P (&it2))
3543 {
3544 if (it2.c == '\t')
3545 return 0;
3546 set_iterator_to_next (&it2, 1);
3547 }
3548
3549 /* Number of new glyphs produced. */
3550 n = it.glyph_row->used[TEXT_AREA];
3551
3552 /* Start and end of glyphs in original row. */
3553 glyphs = glyph_row->glyphs[TEXT_AREA] + w->cursor.hpos;
3554 end = glyph_row->glyphs[1 + TEXT_AREA];
3555
3556 /* Make room for new glyphs, then insert them. */
3557 xassert (end - glyphs - n >= 0);
3558 safe_bcopy ((char *) glyphs, (char *) (glyphs + n),
3559 (end - glyphs - n) * sizeof (*end));
3560 bcopy (it.glyph_row->glyphs[TEXT_AREA], glyphs, n * sizeof *glyphs);
3561 glyph_row->used[TEXT_AREA] = min (glyph_row->used[TEXT_AREA] + n,
3562 end - glyph_row->glyphs[TEXT_AREA]);
3563
3564 /* Compute new line width. */
3565 glyph = glyph_row->glyphs[TEXT_AREA];
3566 end = glyph + glyph_row->used[TEXT_AREA];
3567 glyph_row->pixel_width = glyph_row->x;
3568 while (glyph < end)
3569 {
3570 glyph_row->pixel_width += glyph->pixel_width;
3571 ++glyph;
3572 }
3573
3574 /* Increment buffer positions for glyphs following the newly
3575 inserted ones. */
3576 for (glyph = glyphs + n; glyph < end; ++glyph)
3577 if (glyph->charpos > 0 && BUFFERP (glyph->object))
3578 glyph->charpos += delta;
3579
3580 if (MATRIX_ROW_END_CHARPOS (glyph_row) > 0)
3581 {
3582 MATRIX_ROW_END_CHARPOS (glyph_row) += delta;
3583 MATRIX_ROW_END_BYTEPOS (glyph_row) += delta_bytes;
3584 }
3585
3586 /* Adjust positions in lines following the one we are in. */
3587 increment_matrix_positions (w->current_matrix,
3588 w->cursor.vpos + 1,
3589 w->current_matrix->nrows,
3590 delta, delta_bytes);
3591
3592 glyph_row->contains_overlapping_glyphs_p
3593 |= it.glyph_row->contains_overlapping_glyphs_p;
3594
3595 glyph_row->displays_text_p = 1;
3596 w->window_end_vpos = make_number (max (w->cursor.vpos,
3597 XFASTINT (w->window_end_vpos)));
3598
3599 if (!NILP (Vshow_trailing_whitespace))
3600 highlight_trailing_whitespace (it.f, glyph_row);
3601
3602 /* Write glyphs. If at end of row, we can simply call write_glyphs.
3603 In the middle, we have to insert glyphs. Note that this is now
3604 implemented for X frames. The implementation uses updated_window
3605 and updated_row. */
3606 updated_row = glyph_row;
3607 updated_area = TEXT_AREA;
3608 update_begin (f);
3609 if (rif)
3610 {
3611 rif->update_window_begin_hook (w);
3612
3613 if (glyphs == end - n
3614 /* In front of a space added by append_space. */
3615 || (glyphs == end - n - 1
3616 && (end - n)->charpos <= 0))
3617 rif->write_glyphs (glyphs, n);
3618 else
3619 rif->insert_glyphs (glyphs, n);
3620 }
3621 else
3622 {
3623 if (glyphs == end - n)
3624 write_glyphs (glyphs, n);
3625 else
3626 insert_glyphs (glyphs, n);
3627 }
3628
3629 w->cursor.hpos += n;
3630 w->cursor.x = it.current_x - it.first_visible_x;
3631 xassert (w->cursor.hpos >= 0
3632 && w->cursor.hpos < w->desired_matrix->matrix_w);
3633
3634 /* How to set the cursor differs depending on whether we are
3635 using a frame matrix or a window matrix. Note that when
3636 a frame matrix is used, cursor_to expects frame coordinates,
3637 and the X and Y parameters are not used. */
3638 if (window_redisplay_p)
3639 rif->cursor_to (w->cursor.vpos, w->cursor.hpos,
3640 w->cursor.y, w->cursor.x);
3641 else
3642 {
3643 int x, y;
3644 x = (WINDOW_TO_FRAME_HPOS (w, w->cursor.hpos)
3645 + (INTEGERP (w->left_margin_width)
3646 ? XFASTINT (w->left_margin_width)
3647 : 0));
3648 y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
3649 cursor_to (y, x);
3650 }
3651
3652 if (rif)
3653 rif->update_window_end_hook (w, 1, 0);
3654 update_end (f);
3655 updated_row = NULL;
3656 fflush (stdout);
3657
3658 TRACE ((stderr, "direct output for insert\n"));
3659 mark_window_display_accurate (it.window, 1);
3660 redisplay_performed_directly_p = 1;
3661 return 1;
3662 }
3663
3664
3665 /* Perform a direct display update for moving PT by N positions
3666 left or right. N < 0 means a movement backwards. This function
3667 is currently only called for N == 1 or N == -1. */
3668
3669 int
3670 direct_output_forward_char (n)
3671 int n;
3672 {
3673 struct frame *f = SELECTED_FRAME ();
3674 struct window *w = XWINDOW (selected_window);
3675 struct glyph_row *row;
3676
3677 /* Give up if point moved out of or into a composition. */
3678 if (check_point_in_composition (current_buffer, XINT (w->last_point),
3679 current_buffer, PT))
3680 return 0;
3681
3682 /* Give up if face attributes have been changed. */
3683 if (face_change_count)
3684 return 0;
3685
3686 /* Give up if current matrix is not up to date or we are
3687 displaying a message. */
3688 if (!display_completed || cursor_in_echo_area)
3689 return 0;
3690
3691 /* Give up if the buffer's direction is reversed. */
3692 if (!NILP (XBUFFER (w->buffer)->direction_reversed))
3693 return 0;
3694
3695 /* Can't use direct output if highlighting a region. */
3696 if (!NILP (Vtransient_mark_mode) && !NILP (current_buffer->mark_active))
3697 return 0;
3698
3699 /* Can't use direct output if highlighting trailing whitespace. */
3700 if (!NILP (Vshow_trailing_whitespace))
3701 return 0;
3702
3703 /* Give up if we are showing a message or just cleared the message
3704 because we might need to resize the echo area window. */
3705 if (!NILP (echo_area_buffer[0]) || !NILP (echo_area_buffer[1]))
3706 return 0;
3707
3708 /* Give up if currently displaying a message instead of the
3709 minibuffer contents. */
3710 if (XWINDOW (minibuf_window) == w
3711 && EQ (minibuf_window, echo_area_window))
3712 return 0;
3713
3714 /* Give up if we don't know where the cursor is. */
3715 if (w->cursor.vpos < 0)
3716 return 0;
3717
3718 row = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
3719
3720 /* Give up if PT is outside of the last known cursor row. */
3721 if (PT <= MATRIX_ROW_START_CHARPOS (row)
3722 || PT >= MATRIX_ROW_END_CHARPOS (row))
3723 return 0;
3724
3725 set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
3726
3727 w->last_cursor = w->cursor;
3728 XSETFASTINT (w->last_point, PT);
3729
3730 xassert (w->cursor.hpos >= 0
3731 && w->cursor.hpos < w->desired_matrix->matrix_w);
3732
3733 if (FRAME_WINDOW_P (f))
3734 rif->cursor_to (w->cursor.vpos, w->cursor.hpos,
3735 w->cursor.y, w->cursor.x);
3736 else
3737 {
3738 int x, y;
3739 x = (WINDOW_TO_FRAME_HPOS (w, w->cursor.hpos)
3740 + (INTEGERP (w->left_margin_width)
3741 ? XFASTINT (w->left_margin_width)
3742 : 0));
3743 y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
3744 cursor_to (y, x);
3745 }
3746
3747 fflush (stdout);
3748 redisplay_performed_directly_p = 1;
3749 return 1;
3750 }
3751
3752
3753 \f
3754 /***********************************************************************
3755 Frame Update
3756 ***********************************************************************/
3757
3758 /* Update frame F based on the data in desired matrices.
3759
3760 If FORCE_P is non-zero, don't let redisplay be stopped by detecting
3761 pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try
3762 scrolling.
3763
3764 Value is non-zero if redisplay was stopped due to pending input. */
3765
3766 int
3767 update_frame (f, force_p, inhibit_hairy_id_p)
3768 struct frame *f;
3769 int force_p;
3770 int inhibit_hairy_id_p;
3771 {
3772 /* 1 means display has been paused because of pending input. */
3773 int paused_p;
3774 struct window *root_window = XWINDOW (f->root_window);
3775
3776 if (FRAME_WINDOW_P (f))
3777 {
3778 /* We are working on window matrix basis. All windows whose
3779 flag must_be_updated_p is set have to be updated. */
3780
3781 /* Record that we are not working on frame matrices. */
3782 set_frame_matrix_frame (NULL);
3783
3784 /* Update all windows in the window tree of F, maybe stopping
3785 when pending input is detected. */
3786 update_begin (f);
3787
3788 /* Update the menu bar on X frames that don't have toolkit
3789 support. */
3790 if (WINDOWP (f->menu_bar_window))
3791 update_window (XWINDOW (f->menu_bar_window), 1);
3792
3793 /* Update the tool-bar window, if present. */
3794 if (WINDOWP (f->tool_bar_window))
3795 {
3796 struct window *w = XWINDOW (f->tool_bar_window);
3797
3798 /* Update tool-bar window. */
3799 if (w->must_be_updated_p)
3800 {
3801 Lisp_Object tem;
3802
3803 update_window (w, 1);
3804 w->must_be_updated_p = 0;
3805
3806 /* Swap tool-bar strings. We swap because we want to
3807 reuse strings. */
3808 tem = f->current_tool_bar_string;
3809 f->current_tool_bar_string = f->desired_tool_bar_string;
3810 f->desired_tool_bar_string = tem;
3811 }
3812 }
3813
3814
3815 /* Update windows. */
3816 paused_p = update_window_tree (root_window, force_p);
3817 update_end (f);
3818
3819 #if 0 /* This flush is a performance bottleneck under X,
3820 and it doesn't seem to be necessary anyway. */
3821 rif->flush_display (f);
3822 #endif
3823 }
3824 else
3825 {
3826 /* We are working on frame matrix basis. Set the frame on whose
3827 frame matrix we operate. */
3828 set_frame_matrix_frame (f);
3829
3830 /* Build F's desired matrix from window matrices. */
3831 build_frame_matrix (f);
3832
3833 /* Update the display */
3834 update_begin (f);
3835 paused_p = update_frame_1 (f, force_p, inhibit_hairy_id_p);
3836 update_end (f);
3837
3838 if (termscript)
3839 fflush (termscript);
3840 fflush (stdout);
3841
3842 /* Check window matrices for lost pointers. */
3843 #if GLYPH_DEBUG
3844 check_window_matrix_pointers (root_window);
3845 add_frame_display_history (f, paused_p);
3846 #endif
3847 }
3848
3849 /* Reset flags indicating that a window should be updated. */
3850 set_window_update_flags (root_window, 0);
3851
3852 display_completed = !paused_p;
3853 return paused_p;
3854 }
3855
3856
3857 \f
3858 /************************************************************************
3859 Window-based updates
3860 ************************************************************************/
3861
3862 /* Perform updates in window tree rooted at W. FORCE_P non-zero means
3863 don't stop updating when input is pending. */
3864
3865 static int
3866 update_window_tree (w, force_p)
3867 struct window *w;
3868 int force_p;
3869 {
3870 int paused_p = 0;
3871
3872 while (w && !paused_p)
3873 {
3874 if (!NILP (w->hchild))
3875 paused_p |= update_window_tree (XWINDOW (w->hchild), force_p);
3876 else if (!NILP (w->vchild))
3877 paused_p |= update_window_tree (XWINDOW (w->vchild), force_p);
3878 else if (w->must_be_updated_p)
3879 paused_p |= update_window (w, force_p);
3880
3881 w = NILP (w->next) ? 0 : XWINDOW (w->next);
3882 }
3883
3884 return paused_p;
3885 }
3886
3887
3888 /* Update window W if its flag must_be_updated_p is non-zero. If
3889 FORCE_P is non-zero, don't stop updating if input is pending. */
3890
3891 void
3892 update_single_window (w, force_p)
3893 struct window *w;
3894 int force_p;
3895 {
3896 if (w->must_be_updated_p)
3897 {
3898 struct frame *f = XFRAME (WINDOW_FRAME (w));
3899
3900 /* Record that this is not a frame-based redisplay. */
3901 set_frame_matrix_frame (NULL);
3902
3903 /* Update W. */
3904 update_begin (f);
3905 update_window (w, force_p);
3906 update_end (f);
3907
3908 /* Reset flag in W. */
3909 w->must_be_updated_p = 0;
3910 }
3911 }
3912
3913
3914 /* Redraw lines from the current matrix of window W that are
3915 overlapped by other rows. YB is bottom-most y-position in W. */
3916
3917 static void
3918 redraw_overlapped_rows (w, yb)
3919 struct window *w;
3920 int yb;
3921 {
3922 int i;
3923
3924 /* If rows overlapping others have been changed, the rows being
3925 overlapped have to be redrawn. This won't draw lines that have
3926 already been drawn in update_window_line because overlapped_p in
3927 desired rows is 0, so after row assignment overlapped_p in
3928 current rows is 0. */
3929 for (i = 0; i < w->current_matrix->nrows; ++i)
3930 {
3931 struct glyph_row *row = w->current_matrix->rows + i;
3932
3933 if (!row->enabled_p)
3934 break;
3935 else if (row->mode_line_p)
3936 continue;
3937
3938 if (row->overlapped_p)
3939 {
3940 enum glyph_row_area area;
3941
3942 for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
3943 {
3944 updated_row = row;
3945 updated_area = area;
3946 rif->cursor_to (i, 0, row->y, area == TEXT_AREA ? row->x : 0);
3947 if (row->used[area])
3948 rif->write_glyphs (row->glyphs[area], row->used[area]);
3949 rif->clear_end_of_line (-1);
3950 }
3951
3952 row->overlapped_p = 0;
3953 }
3954
3955 if (MATRIX_ROW_BOTTOM_Y (row) >= yb)
3956 break;
3957 }
3958 }
3959
3960
3961 /* Redraw lines from the current matrix of window W that overlap
3962 others. YB is bottom-most y-position in W. */
3963
3964 static void
3965 redraw_overlapping_rows (w, yb)
3966 struct window *w;
3967 int yb;
3968 {
3969 int i, bottom_y;
3970 struct glyph_row *row;
3971
3972 for (i = 0; i < w->current_matrix->nrows; ++i)
3973 {
3974 row = w->current_matrix->rows + i;
3975
3976 if (!row->enabled_p)
3977 break;
3978 else if (row->mode_line_p)
3979 continue;
3980
3981 bottom_y = MATRIX_ROW_BOTTOM_Y (row);
3982
3983 if (row->overlapping_p && i > 0 && bottom_y < yb)
3984 {
3985 if (row->used[LEFT_MARGIN_AREA])
3986 rif->fix_overlapping_area (w, row, LEFT_MARGIN_AREA);
3987
3988 if (row->used[TEXT_AREA])
3989 rif->fix_overlapping_area (w, row, TEXT_AREA);
3990
3991 if (row->used[RIGHT_MARGIN_AREA])
3992 rif->fix_overlapping_area (w, row, RIGHT_MARGIN_AREA);
3993
3994 /* Record in neighbour rows that ROW overwrites part of their
3995 display. */
3996 if (row->phys_ascent > row->ascent && i > 0)
3997 MATRIX_ROW (w->current_matrix, i - 1)->overlapped_p = 1;
3998 if ((row->phys_height - row->phys_ascent
3999 > row->height - row->ascent)
4000 && bottom_y < yb)
4001 MATRIX_ROW (w->current_matrix, i + 1)->overlapped_p = 1;
4002 }
4003
4004 if (bottom_y >= yb)
4005 break;
4006 }
4007 }
4008
4009
4010 #ifdef GLYPH_DEBUG
4011
4012 /* Check that no row in the current matrix of window W is enabled
4013 which is below what's displayed in the window. */
4014
4015 void
4016 check_current_matrix_flags (w)
4017 struct window *w;
4018 {
4019 int last_seen_p = 0;
4020 int i, yb = window_text_bottom_y (w);
4021
4022 for (i = 0; i < w->current_matrix->nrows - 1; ++i)
4023 {
4024 struct glyph_row *row = MATRIX_ROW (w->current_matrix, i);
4025 if (!last_seen_p && MATRIX_ROW_BOTTOM_Y (row) >= yb)
4026 last_seen_p = 1;
4027 else if (last_seen_p && row->enabled_p)
4028 abort ();
4029 }
4030 }
4031
4032 #endif /* GLYPH_DEBUG */
4033
4034
4035 /* Update display of window W. FORCE_P non-zero means that we should
4036 not stop when detecting pending input. */
4037
4038 static int
4039 update_window (w, force_p)
4040 struct window *w;
4041 int force_p;
4042 {
4043 struct glyph_matrix *desired_matrix = w->desired_matrix;
4044 int paused_p;
4045 int preempt_count = baud_rate / 2400 + 1;
4046 extern int input_pending;
4047 extern Lisp_Object do_mouse_tracking;
4048 #if GLYPH_DEBUG
4049 struct frame *f = XFRAME (WINDOW_FRAME (w));
4050 extern struct frame *updating_frame;
4051 #endif
4052
4053 /* Check that W's frame doesn't have glyph matrices. */
4054 xassert (FRAME_WINDOW_P (f));
4055 xassert (updating_frame != NULL);
4056
4057 /* Check pending input the first time so that we can quickly return. */
4058 if (redisplay_dont_pause)
4059 force_p = 1;
4060 else
4061 detect_input_pending ();
4062
4063 /* If forced to complete the update, or if no input is pending, do
4064 the update. */
4065 if (force_p || !input_pending || !NILP (do_mouse_tracking))
4066 {
4067 struct glyph_row *row, *end;
4068 struct glyph_row *mode_line_row;
4069 struct glyph_row *header_line_row;
4070 int yb, changed_p = 0, mouse_face_overwritten_p = 0, n_updated;
4071
4072 rif->update_window_begin_hook (w);
4073 yb = window_text_bottom_y (w);
4074
4075 /* If window has a header line, update it before everything else.
4076 Adjust y-positions of other rows by the header line height. */
4077 row = desired_matrix->rows;
4078 end = row + desired_matrix->nrows - 1;
4079
4080 if (row->mode_line_p)
4081 {
4082 header_line_row = row;
4083 ++row;
4084 }
4085 else
4086 header_line_row = NULL;
4087
4088 /* Update the mode line, if necessary. */
4089 mode_line_row = MATRIX_MODE_LINE_ROW (desired_matrix);
4090 if (mode_line_row->mode_line_p && mode_line_row->enabled_p)
4091 {
4092 mode_line_row->y = yb;
4093 update_window_line (w, MATRIX_ROW_VPOS (mode_line_row,
4094 desired_matrix),
4095 &mouse_face_overwritten_p);
4096 changed_p = 1;
4097 }
4098
4099 /* Find first enabled row. Optimizations in redisplay_internal
4100 may lead to an update with only one row enabled. There may
4101 be also completely empty matrices. */
4102 while (row < end && !row->enabled_p)
4103 ++row;
4104
4105 /* Try reusing part of the display by copying. */
4106 if (row < end && !desired_matrix->no_scrolling_p)
4107 {
4108 int rc = scrolling_window (w, header_line_row != NULL);
4109 if (rc < 0)
4110 {
4111 /* All rows were found to be equal. */
4112 paused_p = 0;
4113 goto set_cursor;
4114 }
4115 else if (rc > 0)
4116 /* We've scrolled the display. */
4117 force_p = 1;
4118 changed_p = 1;
4119 }
4120
4121 /* Update the header line after scrolling because a new header
4122 line would otherwise overwrite lines at the top of the window
4123 that can be scrolled. */
4124 if (header_line_row && header_line_row->enabled_p)
4125 {
4126 header_line_row->y = 0;
4127 update_window_line (w, 0, &mouse_face_overwritten_p);
4128 changed_p = 1;
4129 }
4130
4131 /* Update the rest of the lines. */
4132 for (n_updated = 0; row < end && (force_p || !input_pending); ++row)
4133 if (row->enabled_p)
4134 {
4135 int vpos = MATRIX_ROW_VPOS (row, desired_matrix);
4136 int i;
4137
4138 /* We'll have to play a little bit with when to
4139 detect_input_pending. If it's done too often,
4140 scrolling large windows with repeated scroll-up
4141 commands will too quickly pause redisplay. */
4142 if (!force_p && ++n_updated % preempt_count == 0)
4143 detect_input_pending ();
4144
4145 changed_p |= update_window_line (w, vpos,
4146 &mouse_face_overwritten_p);
4147
4148 /* Mark all rows below the last visible one in the current
4149 matrix as invalid. This is necessary because of
4150 variable line heights. Consider the case of three
4151 successive redisplays, where the first displays 5
4152 lines, the second 3 lines, and the third 5 lines again.
4153 If the second redisplay wouldn't mark rows in the
4154 current matrix invalid, the third redisplay might be
4155 tempted to optimize redisplay based on lines displayed
4156 in the first redisplay. */
4157 if (MATRIX_ROW_BOTTOM_Y (row) >= yb)
4158 for (i = vpos + 1; i < w->current_matrix->nrows - 1; ++i)
4159 MATRIX_ROW (w->current_matrix, i)->enabled_p = 0;
4160 }
4161
4162 /* Was display preempted? */
4163 paused_p = row < end;
4164
4165 set_cursor:
4166
4167 /* Fix the appearance of overlapping/overlapped rows. */
4168 if (!paused_p && !w->pseudo_window_p)
4169 {
4170 if (changed_p && rif->fix_overlapping_area)
4171 {
4172 redraw_overlapped_rows (w, yb);
4173 redraw_overlapping_rows (w, yb);
4174 }
4175
4176 /* Make cursor visible at cursor position of W. */
4177 set_window_cursor_after_update (w);
4178
4179 #if 0 /* Check that current matrix invariants are satisfied. This is
4180 for debugging only. See the comment of check_matrix_invariants. */
4181 IF_DEBUG (check_matrix_invariants (w));
4182 #endif
4183 }
4184
4185 #if GLYPH_DEBUG
4186 /* Remember the redisplay method used to display the matrix. */
4187 strcpy (w->current_matrix->method, w->desired_matrix->method);
4188 #endif
4189
4190 /* End the update of window W. Don't set the cursor if we
4191 paused updating the display because in this case,
4192 set_window_cursor_after_update hasn't been called, and
4193 output_cursor doesn't contain the cursor location. */
4194 rif->update_window_end_hook (w, !paused_p, mouse_face_overwritten_p);
4195 }
4196 else
4197 paused_p = 1;
4198
4199 #if GLYPH_DEBUG
4200 /* check_current_matrix_flags (w); */
4201 add_window_display_history (w, w->current_matrix->method, paused_p);
4202 #endif
4203
4204 clear_glyph_matrix (desired_matrix);
4205
4206 return paused_p;
4207 }
4208
4209
4210 /* Update the display of area AREA in window W, row number VPOS.
4211 AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */
4212
4213 static void
4214 update_marginal_area (w, area, vpos)
4215 struct window *w;
4216 int area, vpos;
4217 {
4218 struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
4219
4220 /* Let functions in xterm.c know what area subsequent X positions
4221 will be relative to. */
4222 updated_area = area;
4223
4224 /* Set cursor to start of glyphs, write them, and clear to the end
4225 of the area. I don't think that something more sophisticated is
4226 necessary here, since marginal areas will not be the default. */
4227 rif->cursor_to (vpos, 0, desired_row->y, 0);
4228 if (desired_row->used[area])
4229 rif->write_glyphs (desired_row->glyphs[area], desired_row->used[area]);
4230 rif->clear_end_of_line (-1);
4231 }
4232
4233
4234 /* Update the display of the text area of row VPOS in window W.
4235 Value is non-zero if display has changed. */
4236
4237 static int
4238 update_text_area (w, vpos)
4239 struct window *w;
4240 int vpos;
4241 {
4242 struct glyph_row *current_row = MATRIX_ROW (w->current_matrix, vpos);
4243 struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
4244 int changed_p = 0;
4245
4246 /* Let functions in xterm.c know what area subsequent X positions
4247 will be relative to. */
4248 updated_area = TEXT_AREA;
4249
4250 /* If rows are at different X or Y, or rows have different height,
4251 or the current row is marked invalid, write the entire line. */
4252 if (!current_row->enabled_p
4253 || desired_row->y != current_row->y
4254 || desired_row->ascent != current_row->ascent
4255 || desired_row->phys_ascent != current_row->phys_ascent
4256 || desired_row->phys_height != current_row->phys_height
4257 || desired_row->visible_height != current_row->visible_height
4258 || current_row->overlapped_p
4259 || current_row->mouse_face_p
4260 || current_row->x != desired_row->x)
4261 {
4262 rif->cursor_to (vpos, 0, desired_row->y, desired_row->x);
4263
4264 if (desired_row->used[TEXT_AREA])
4265 rif->write_glyphs (desired_row->glyphs[TEXT_AREA],
4266 desired_row->used[TEXT_AREA]);
4267
4268 /* Clear to end of window. */
4269 rif->clear_end_of_line (-1);
4270 changed_p = 1;
4271
4272 /* This erases the cursor. We do this here because
4273 notice_overwritten_cursor cannot easily check this, which
4274 might indicate that the whole functionality of
4275 notice_overwritten_cursor would better be implemented here.
4276 On the other hand, we need notice_overwritten_cursor as long
4277 as mouse highlighting is done asynchronously outside of
4278 redisplay. */
4279 if (vpos == w->phys_cursor.vpos)
4280 w->phys_cursor_on_p = 0;
4281 }
4282 else
4283 {
4284 int stop, i, x;
4285 struct glyph *current_glyph = current_row->glyphs[TEXT_AREA];
4286 struct glyph *desired_glyph = desired_row->glyphs[TEXT_AREA];
4287 int overlapping_glyphs_p = current_row->contains_overlapping_glyphs_p;
4288 int desired_stop_pos = desired_row->used[TEXT_AREA];
4289
4290 /* If the desired row extends its face to the text area end,
4291 make sure we write at least one glyph, so that the face
4292 extension actually takes place. */
4293 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row))
4294 --desired_stop_pos;
4295
4296 stop = min (current_row->used[TEXT_AREA], desired_stop_pos);
4297 i = 0;
4298 x = desired_row->x;
4299
4300 /* Loop over glyphs that current and desired row may have
4301 in common. */
4302 while (i < stop)
4303 {
4304 int can_skip_p = 1;
4305
4306 /* Skip over glyphs that both rows have in common. These
4307 don't have to be written. We can't skip if the last
4308 current glyph overlaps the glyph to its right. For
4309 example, consider a current row of `if ' with the `f' in
4310 Courier bold so that it overlaps the ` ' to its right.
4311 If the desired row is ` ', we would skip over the space
4312 after the `if' and there would remain a pixel from the
4313 `f' on the screen. */
4314 if (overlapping_glyphs_p && i > 0)
4315 {
4316 struct glyph *glyph = &current_row->glyphs[TEXT_AREA][i - 1];
4317 int left, right;
4318
4319 rif->get_glyph_overhangs (glyph, XFRAME (w->frame),
4320 &left, &right);
4321 can_skip_p = right == 0;
4322 }
4323
4324 if (can_skip_p)
4325 {
4326 while (i < stop
4327 && GLYPH_EQUAL_P (desired_glyph, current_glyph))
4328 {
4329 x += desired_glyph->pixel_width;
4330 ++desired_glyph, ++current_glyph, ++i;
4331 }
4332
4333 /* Consider the case that the current row contains "xxx
4334 ppp ggg" in italic Courier font, and the desired row
4335 is "xxx ggg". The character `p' has lbearing, `g'
4336 has not. The loop above will stop in front of the
4337 first `p' in the current row. If we would start
4338 writing glyphs there, we wouldn't erase the lbearing
4339 of the `p'. The rest of the lbearing problem is then
4340 taken care of by x_draw_glyphs. */
4341 if (overlapping_glyphs_p
4342 && i > 0
4343 && i < current_row->used[TEXT_AREA]
4344 && (current_row->used[TEXT_AREA]
4345 != desired_row->used[TEXT_AREA]))
4346 {
4347 int left, right;
4348
4349 rif->get_glyph_overhangs (current_glyph, XFRAME (w->frame),
4350 &left, &right);
4351 while (left > 0 && i > 0)
4352 {
4353 --i, --desired_glyph, --current_glyph;
4354 x -= desired_glyph->pixel_width;
4355 left -= desired_glyph->pixel_width;
4356 }
4357 }
4358 }
4359
4360 /* Try to avoid writing the entire rest of the desired row
4361 by looking for a resync point. This mainly prevents
4362 mode line flickering in the case the mode line is in
4363 fixed-pitch font, which it usually will be. */
4364 if (i < desired_row->used[TEXT_AREA])
4365 {
4366 int start_x = x, start_hpos = i;
4367 struct glyph *start = desired_glyph;
4368 int current_x = x;
4369 int skip_first_p = !can_skip_p;
4370
4371 /* Find the next glyph that's equal again. */
4372 while (i < stop
4373 && (skip_first_p
4374 || !GLYPH_EQUAL_P (desired_glyph, current_glyph))
4375 && x == current_x)
4376 {
4377 x += desired_glyph->pixel_width;
4378 current_x += current_glyph->pixel_width;
4379 ++desired_glyph, ++current_glyph, ++i;
4380 skip_first_p = 0;
4381 }
4382
4383 if (i == start_hpos || x != current_x)
4384 {
4385 i = start_hpos;
4386 x = start_x;
4387 desired_glyph = start;
4388 break;
4389 }
4390
4391 rif->cursor_to (vpos, start_hpos, desired_row->y, start_x);
4392 rif->write_glyphs (start, i - start_hpos);
4393 changed_p = 1;
4394 }
4395 }
4396
4397 /* Write the rest. */
4398 if (i < desired_row->used[TEXT_AREA])
4399 {
4400 rif->cursor_to (vpos, i, desired_row->y, x);
4401 rif->write_glyphs (desired_glyph, desired_row->used[TEXT_AREA] - i);
4402 changed_p = 1;
4403 }
4404
4405 /* Maybe clear to end of line. */
4406 if (MATRIX_ROW_EXTENDS_FACE_P (desired_row))
4407 {
4408 /* If new row extends to the end of the text area, nothing
4409 has to be cleared, if and only if we did a write_glyphs
4410 above. This is made sure by setting desired_stop_pos
4411 appropriately above. */
4412 xassert (i < desired_row->used[TEXT_AREA]);
4413 }
4414 else if (MATRIX_ROW_EXTENDS_FACE_P (current_row))
4415 {
4416 /* If old row extends to the end of the text area, clear. */
4417 if (i >= desired_row->used[TEXT_AREA])
4418 rif->cursor_to (vpos, i, desired_row->y,
4419 desired_row->x + desired_row->pixel_width);
4420 rif->clear_end_of_line (-1);
4421 changed_p = 1;
4422 }
4423 else if (desired_row->pixel_width < current_row->pixel_width)
4424 {
4425 /* Otherwise clear to the end of the old row. Everything
4426 after that position should be clear already. */
4427 int x;
4428
4429 if (i >= desired_row->used[TEXT_AREA])
4430 rif->cursor_to (vpos, i, desired_row->y,
4431 desired_row->x + desired_row->pixel_width);
4432
4433 /* If cursor is displayed at the end of the line, make sure
4434 it's cleared. Nowadays we don't have a phys_cursor_glyph
4435 with which to erase the cursor (because this method
4436 doesn't work with lbearing/rbearing), so we must do it
4437 this way. */
4438 if (vpos == w->phys_cursor.vpos
4439 && w->phys_cursor.hpos >= desired_row->used[TEXT_AREA])
4440 {
4441 w->phys_cursor_on_p = 0;
4442 x = -1;
4443 }
4444 else
4445 x = current_row->x + current_row->pixel_width;
4446 rif->clear_end_of_line (x);
4447 changed_p = 1;
4448 }
4449 }
4450
4451 return changed_p;
4452 }
4453
4454
4455 /* Update row VPOS in window W. Value is non-zero if display has been
4456 changed. */
4457
4458 static int
4459 update_window_line (w, vpos, mouse_face_overwritten_p)
4460 struct window *w;
4461 int vpos, *mouse_face_overwritten_p;
4462 {
4463 struct glyph_row *current_row = MATRIX_ROW (w->current_matrix, vpos);
4464 struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
4465 int changed_p = 0;
4466
4467 /* Set the row being updated. This is important to let xterm.c
4468 know what line height values are in effect. */
4469 updated_row = desired_row;
4470
4471 /* A row can be completely invisible in case a desired matrix was
4472 built with a vscroll and then make_cursor_line_fully_visible shifts
4473 the matrix. Make sure to make such rows current anyway, since
4474 we need the correct y-position, for example, in the current matrix. */
4475 if (desired_row->mode_line_p
4476 || desired_row->visible_height > 0)
4477 {
4478 xassert (desired_row->enabled_p);
4479
4480 /* Update display of the left margin area, if there is one. */
4481 if (!desired_row->full_width_p
4482 && !NILP (w->left_margin_width))
4483 {
4484 changed_p = 1;
4485 update_marginal_area (w, LEFT_MARGIN_AREA, vpos);
4486 }
4487
4488 /* Update the display of the text area. */
4489 if (update_text_area (w, vpos))
4490 {
4491 changed_p = 1;
4492 if (current_row->mouse_face_p)
4493 *mouse_face_overwritten_p = 1;
4494 }
4495
4496 /* Update display of the right margin area, if there is one. */
4497 if (!desired_row->full_width_p
4498 && !NILP (w->right_margin_width))
4499 {
4500 changed_p = 1;
4501 update_marginal_area (w, RIGHT_MARGIN_AREA, vpos);
4502 }
4503
4504 /* Draw truncation marks etc. */
4505 if (!current_row->enabled_p
4506 || desired_row->y != current_row->y
4507 || desired_row->visible_height != current_row->visible_height
4508 || desired_row->overlay_arrow_p != current_row->overlay_arrow_p
4509 || desired_row->truncated_on_left_p != current_row->truncated_on_left_p
4510 || desired_row->truncated_on_right_p != current_row->truncated_on_right_p
4511 || desired_row->continued_p != current_row->continued_p
4512 || desired_row->mode_line_p != current_row->mode_line_p
4513 || (desired_row->indicate_empty_line_p
4514 != current_row->indicate_empty_line_p)
4515 || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row)
4516 != MATRIX_ROW_CONTINUATION_LINE_P (current_row)))
4517 rif->after_update_window_line_hook (desired_row);
4518 }
4519
4520 /* Update current_row from desired_row. */
4521 make_current (w->desired_matrix, w->current_matrix, vpos);
4522 updated_row = NULL;
4523 return changed_p;
4524 }
4525
4526
4527 /* Set the cursor after an update of window W. This function may only
4528 be called from update_window. */
4529
4530 static void
4531 set_window_cursor_after_update (w)
4532 struct window *w;
4533 {
4534 struct frame *f = XFRAME (w->frame);
4535 int cx, cy, vpos, hpos;
4536
4537 /* Not intended for frame matrix updates. */
4538 xassert (FRAME_WINDOW_P (f));
4539
4540 if (cursor_in_echo_area
4541 && !NILP (echo_area_buffer[0])
4542 /* If we are showing a message instead of the mini-buffer,
4543 show the cursor for the message instead. */
4544 && XWINDOW (minibuf_window) == w
4545 && EQ (minibuf_window, echo_area_window)
4546 /* These cases apply only to the frame that contains
4547 the active mini-buffer window. */
4548 && FRAME_HAS_MINIBUF_P (f)
4549 && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
4550 {
4551 cx = cy = vpos = hpos = 0;
4552
4553 if (cursor_in_echo_area >= 0)
4554 {
4555 /* If the mini-buffer is several lines high, find the last
4556 line that has any text on it. Note: either all lines
4557 are enabled or none. Otherwise we wouldn't be able to
4558 determine Y. */
4559 struct glyph_row *row, *last_row;
4560 struct glyph *glyph;
4561 int yb = window_text_bottom_y (w);
4562
4563 last_row = NULL;
4564 row = w->current_matrix->rows;
4565 while (row->enabled_p
4566 && (last_row == NULL
4567 || MATRIX_ROW_BOTTOM_Y (row) <= yb))
4568 {
4569 if (row->used[TEXT_AREA]
4570 && row->glyphs[TEXT_AREA][0].charpos >= 0)
4571 last_row = row;
4572 ++row;
4573 }
4574
4575 if (last_row)
4576 {
4577 struct glyph *start = last_row->glyphs[TEXT_AREA];
4578 struct glyph *last = start + last_row->used[TEXT_AREA] - 1;
4579
4580 while (last > start && last->charpos < 0)
4581 --last;
4582
4583 for (glyph = start; glyph < last; ++glyph)
4584 {
4585 cx += glyph->pixel_width;
4586 ++hpos;
4587 }
4588
4589 cy = last_row->y;
4590 vpos = MATRIX_ROW_VPOS (last_row, w->current_matrix);
4591 }
4592 }
4593 }
4594 else
4595 {
4596 cx = w->cursor.x;
4597 cy = w->cursor.y;
4598 hpos = w->cursor.hpos;
4599 vpos = w->cursor.vpos;
4600 }
4601
4602 /* Window cursor can be out of sync for horizontally split windows. */
4603 hpos = max (0, hpos);
4604 hpos = min (w->current_matrix->matrix_w - 1, hpos);
4605 vpos = max (0, vpos);
4606 vpos = min (w->current_matrix->nrows - 1, vpos);
4607 rif->cursor_to (vpos, hpos, cy, cx);
4608 }
4609
4610
4611 /* Set WINDOW->must_be_updated_p to ON_P for all windows in the window
4612 tree rooted at W. */
4613
4614 void
4615 set_window_update_flags (w, on_p)
4616 struct window *w;
4617 int on_p;
4618 {
4619 while (w)
4620 {
4621 if (!NILP (w->hchild))
4622 set_window_update_flags (XWINDOW (w->hchild), on_p);
4623 else if (!NILP (w->vchild))
4624 set_window_update_flags (XWINDOW (w->vchild), on_p);
4625 else
4626 w->must_be_updated_p = on_p;
4627
4628 w = NILP (w->next) ? 0 : XWINDOW (w->next);
4629 }
4630 }
4631
4632
4633 \f
4634 /***********************************************************************
4635 Window-Based Scrolling
4636 ***********************************************************************/
4637
4638 /* Structure describing rows in scrolling_window. */
4639
4640 struct row_entry
4641 {
4642 /* Number of occurrences of this row in desired and current matrix. */
4643 int old_uses, new_uses;
4644
4645 /* Vpos of row in new matrix. */
4646 int new_line_number;
4647
4648 /* Bucket index of this row_entry in the hash table row_table. */
4649 int bucket;
4650
4651 /* The row described by this entry. */
4652 struct glyph_row *row;
4653
4654 /* Hash collision chain. */
4655 struct row_entry *next;
4656 };
4657
4658 /* A pool to allocate row_entry structures from, and the size of the
4659 pool. The pool is reallocated in scrolling_window when we find
4660 that we need a larger one. */
4661
4662 static struct row_entry *row_entry_pool;
4663 static int row_entry_pool_size;
4664
4665 /* Index of next free entry in row_entry_pool. */
4666
4667 static int row_entry_idx;
4668
4669 /* The hash table used during scrolling, and the table's size. This
4670 table is used to quickly identify equal rows in the desired and
4671 current matrix. */
4672
4673 static struct row_entry **row_table;
4674 static int row_table_size;
4675
4676 /* Vectors of pointers to row_entry structures belonging to the
4677 current and desired matrix, and the size of the vectors. */
4678
4679 static struct row_entry **old_lines, **new_lines;
4680 static int old_lines_size, new_lines_size;
4681
4682 /* A pool to allocate run structures from, and its size. */
4683
4684 static struct run *run_pool;
4685 static int runs_size;
4686
4687 /* A vector of runs of lines found during scrolling. */
4688
4689 static struct run **runs;
4690
4691 /* Add glyph row ROW to the scrolling hash table during the scrolling
4692 of window W. */
4693
4694 static INLINE struct row_entry *
4695 add_row_entry (w, row)
4696 struct window *w;
4697 struct glyph_row *row;
4698 {
4699 struct row_entry *entry;
4700 int i = row->hash % row_table_size;
4701
4702 entry = row_table[i];
4703 while (entry && !row_equal_p (w, entry->row, row, 1))
4704 entry = entry->next;
4705
4706 if (entry == NULL)
4707 {
4708 entry = row_entry_pool + row_entry_idx++;
4709 entry->row = row;
4710 entry->old_uses = entry->new_uses = 0;
4711 entry->new_line_number = 0;
4712 entry->bucket = i;
4713 entry->next = row_table[i];
4714 row_table[i] = entry;
4715 }
4716
4717 return entry;
4718 }
4719
4720
4721 /* Try to reuse part of the current display of W by scrolling lines.
4722 HEADER_LINE_P non-zero means W has a header line.
4723
4724 The algorithm is taken from Communications of the ACM, Apr78 "A
4725 Technique for Isolating Differences Between Files." It should take
4726 O(N) time.
4727
4728 A short outline of the steps of the algorithm
4729
4730 1. Skip lines equal at the start and end of both matrices.
4731
4732 2. Enter rows in the current and desired matrix into a symbol
4733 table, counting how often they appear in both matrices.
4734
4735 3. Rows that appear exactly once in both matrices serve as anchors,
4736 i.e. we assume that such lines are likely to have been moved.
4737
4738 4. Starting from anchor lines, extend regions to be scrolled both
4739 forward and backward.
4740
4741 Value is
4742
4743 -1 if all rows were found to be equal.
4744 0 to indicate that we did not scroll the display, or
4745 1 if we did scroll. */
4746
4747 static int
4748 scrolling_window (w, header_line_p)
4749 struct window *w;
4750 int header_line_p;
4751 {
4752 struct glyph_matrix *desired_matrix = w->desired_matrix;
4753 struct glyph_matrix *current_matrix = w->current_matrix;
4754 int yb = window_text_bottom_y (w);
4755 int i, j, first_old, first_new, last_old, last_new;
4756 int nruns, nbytes, n, run_idx;
4757 struct row_entry *entry;
4758
4759 /* Skip over rows equal at the start. */
4760 for (i = header_line_p ? 1 : 0; i < current_matrix->nrows - 1; ++i)
4761 {
4762 struct glyph_row *d = MATRIX_ROW (desired_matrix, i);
4763 struct glyph_row *c = MATRIX_ROW (current_matrix, i);
4764
4765 if (c->enabled_p
4766 && d->enabled_p
4767 && c->y == d->y
4768 && MATRIX_ROW_BOTTOM_Y (c) <= yb
4769 && MATRIX_ROW_BOTTOM_Y (d) <= yb
4770 && row_equal_p (w, c, d, 1))
4771 {
4772 assign_row (c, d);
4773 d->enabled_p = 0;
4774 }
4775 else
4776 break;
4777 }
4778
4779 /* Give up if some rows in the desired matrix are not enabled. */
4780 if (!MATRIX_ROW (desired_matrix, i)->enabled_p)
4781 return -1;
4782
4783 first_old = first_new = i;
4784
4785 /* Set last_new to the index + 1 of the last enabled row in the
4786 desired matrix. */
4787 i = first_new + 1;
4788 while (i < desired_matrix->nrows - 1
4789 && MATRIX_ROW (desired_matrix, i)->enabled_p
4790 && MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (desired_matrix, i)) <= yb)
4791 ++i;
4792
4793 if (!MATRIX_ROW (desired_matrix, i)->enabled_p)
4794 return 0;
4795
4796 last_new = i;
4797
4798 /* Set last_old to the index + 1 of the last enabled row in the
4799 current matrix. We don't look at the enabled flag here because
4800 we plan to reuse part of the display even if other parts are
4801 disabled. */
4802 i = first_old + 1;
4803 while (i < current_matrix->nrows - 1)
4804 {
4805 int bottom = MATRIX_ROW_BOTTOM_Y (MATRIX_ROW (current_matrix, i));
4806 if (bottom <= yb)
4807 ++i;
4808 if (bottom >= yb)
4809 break;
4810 }
4811
4812 last_old = i;
4813
4814 /* Skip over rows equal at the bottom. */
4815 i = last_new;
4816 j = last_old;
4817 while (i - 1 > first_new
4818 && j - 1 > first_old
4819 && MATRIX_ROW (current_matrix, i - 1)->enabled_p
4820 && (MATRIX_ROW (current_matrix, i - 1)->y
4821 == MATRIX_ROW (desired_matrix, j - 1)->y)
4822 && row_equal_p (w,
4823 MATRIX_ROW (desired_matrix, i - 1),
4824 MATRIX_ROW (current_matrix, j - 1), 1))
4825 --i, --j;
4826 last_new = i;
4827 last_old = j;
4828
4829 /* Nothing to do if all rows are equal. */
4830 if (last_new == first_new)
4831 return 0;
4832
4833 /* Reallocate vectors, tables etc. if necessary. */
4834
4835 if (current_matrix->nrows > old_lines_size)
4836 {
4837 old_lines_size = current_matrix->nrows;
4838 nbytes = old_lines_size * sizeof *old_lines;
4839 old_lines = (struct row_entry **) xrealloc (old_lines, nbytes);
4840 }
4841
4842 if (desired_matrix->nrows > new_lines_size)
4843 {
4844 new_lines_size = desired_matrix->nrows;
4845 nbytes = new_lines_size * sizeof *new_lines;
4846 new_lines = (struct row_entry **) xrealloc (new_lines, nbytes);
4847 }
4848
4849 n = desired_matrix->nrows + current_matrix->nrows;
4850 if (3 * n > row_table_size)
4851 {
4852 row_table_size = next_almost_prime (3 * n);
4853 nbytes = row_table_size * sizeof *row_table;
4854 row_table = (struct row_entry **) xrealloc (row_table, nbytes);
4855 bzero (row_table, nbytes);
4856 }
4857
4858 if (n > row_entry_pool_size)
4859 {
4860 row_entry_pool_size = n;
4861 nbytes = row_entry_pool_size * sizeof *row_entry_pool;
4862 row_entry_pool = (struct row_entry *) xrealloc (row_entry_pool, nbytes);
4863 }
4864
4865 if (desired_matrix->nrows > runs_size)
4866 {
4867 runs_size = desired_matrix->nrows;
4868 nbytes = runs_size * sizeof *runs;
4869 runs = (struct run **) xrealloc (runs, nbytes);
4870 nbytes = runs_size * sizeof *run_pool;
4871 run_pool = (struct run *) xrealloc (run_pool, nbytes);
4872 }
4873
4874 nruns = run_idx = 0;
4875 row_entry_idx = 0;
4876
4877 /* Add rows from the current and desired matrix to the hash table
4878 row_hash_table to be able to find equal ones quickly. */
4879
4880 for (i = first_old; i < last_old; ++i)
4881 {
4882 if (MATRIX_ROW (current_matrix, i)->enabled_p)
4883 {
4884 entry = add_row_entry (w, MATRIX_ROW (current_matrix, i));
4885 old_lines[i] = entry;
4886 ++entry->old_uses;
4887 }
4888 else
4889 old_lines[i] = NULL;
4890 }
4891
4892 for (i = first_new; i < last_new; ++i)
4893 {
4894 xassert (MATRIX_ROW_ENABLED_P (desired_matrix, i));
4895 entry = add_row_entry (w, MATRIX_ROW (desired_matrix, i));
4896 ++entry->new_uses;
4897 entry->new_line_number = i;
4898 new_lines[i] = entry;
4899 }
4900
4901 /* Identify moves based on lines that are unique and equal
4902 in both matrices. */
4903 for (i = first_old; i < last_old;)
4904 if (old_lines[i]
4905 && old_lines[i]->old_uses == 1
4906 && old_lines[i]->new_uses == 1)
4907 {
4908 int j, k;
4909 int new_line = old_lines[i]->new_line_number;
4910 struct run *run = run_pool + run_idx++;
4911
4912 /* Record move. */
4913 run->current_vpos = i;
4914 run->current_y = MATRIX_ROW (current_matrix, i)->y;
4915 run->desired_vpos = new_line;
4916 run->desired_y = MATRIX_ROW (desired_matrix, new_line)->y;
4917 run->nrows = 1;
4918 run->height = MATRIX_ROW (current_matrix, i)->height;
4919
4920 /* Extend backward. */
4921 j = i - 1;
4922 k = new_line - 1;
4923 while (j > first_old
4924 && k > first_new
4925 && old_lines[j] == new_lines[k])
4926 {
4927 int h = MATRIX_ROW (current_matrix, j)->height;
4928 --run->current_vpos;
4929 --run->desired_vpos;
4930 ++run->nrows;
4931 run->height += h;
4932 run->desired_y -= h;
4933 run->current_y -= h;
4934 --j, --k;
4935 }
4936
4937 /* Extend forward. */
4938 j = i + 1;
4939 k = new_line + 1;
4940 while (j < last_old
4941 && k < last_new
4942 && old_lines[j] == new_lines[k])
4943 {
4944 int h = MATRIX_ROW (current_matrix, j)->height;
4945 ++run->nrows;
4946 run->height += h;
4947 ++j, ++k;
4948 }
4949
4950 /* Insert run into list of all runs. Order runs by copied
4951 pixel lines. Note that we record runs that don't have to
4952 be copied because they are already in place. This is done
4953 because we can avoid calling update_window_line in this
4954 case. */
4955 for (j = 0; j < nruns && runs[j]->height > run->height; ++j)
4956 ;
4957 for (k = nruns; k > j; --k)
4958 runs[k] = runs[k - 1];
4959 runs[j] = run;
4960 ++nruns;
4961
4962 i += run->nrows;
4963 }
4964 else
4965 ++i;
4966
4967 /* Do the moves. Do it in a way that we don't overwrite something
4968 we want to copy later on. This is not solvable in general
4969 because there is only one display and we don't have a way to
4970 exchange areas on this display. Example:
4971
4972 +-----------+ +-----------+
4973 | A | | B |
4974 +-----------+ --> +-----------+
4975 | B | | A |
4976 +-----------+ +-----------+
4977
4978 Instead, prefer bigger moves, and invalidate moves that would
4979 copy from where we copied to. */
4980
4981 for (i = 0; i < nruns; ++i)
4982 if (runs[i]->nrows > 0)
4983 {
4984 struct run *r = runs[i];
4985
4986 /* Copy on the display. */
4987 if (r->current_y != r->desired_y)
4988 {
4989 rif->scroll_run_hook (w, r);
4990
4991 /* Invalidate runs that copy from where we copied to. */
4992 for (j = i + 1; j < nruns; ++j)
4993 {
4994 struct run *p = runs[j];
4995
4996 if ((p->current_y >= r->desired_y
4997 && p->current_y < r->desired_y + r->height)
4998 || (p->current_y + p->height >= r->desired_y
4999 && (p->current_y + p->height
5000 < r->desired_y + r->height)))
5001 p->nrows = 0;
5002 }
5003 }
5004
5005 /* Assign matrix rows. */
5006 for (j = 0; j < r->nrows; ++j)
5007 {
5008 struct glyph_row *from, *to;
5009 int to_overlapped_p;
5010
5011 to = MATRIX_ROW (current_matrix, r->desired_vpos + j);
5012 from = MATRIX_ROW (desired_matrix, r->desired_vpos + j);
5013 to_overlapped_p = to->overlapped_p;
5014 assign_row (to, from);
5015 to->enabled_p = 1, from->enabled_p = 0;
5016 to->overlapped_p = to_overlapped_p;
5017 }
5018 }
5019
5020 /* Clear the hash table, for the next time. */
5021 for (i = 0; i < row_entry_idx; ++i)
5022 row_table[row_entry_pool[i].bucket] = NULL;
5023
5024 /* Value is non-zero to indicate that we scrolled the display. */
5025 return 1;
5026 }
5027
5028
5029 \f
5030 /************************************************************************
5031 Frame-Based Updates
5032 ************************************************************************/
5033
5034 /* Update the desired frame matrix of frame F.
5035
5036 FORCE_P non-zero means that the update should not be stopped by
5037 pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling
5038 should not be tried.
5039
5040 Value is non-zero if update was stopped due to pending input. */
5041
5042 static int
5043 update_frame_1 (f, force_p, inhibit_id_p)
5044 struct frame *f;
5045 int force_p;
5046 int inhibit_id_p;
5047 {
5048 /* Frame matrices to work on. */
5049 struct glyph_matrix *current_matrix = f->current_matrix;
5050 struct glyph_matrix *desired_matrix = f->desired_matrix;
5051 int i;
5052 int pause;
5053 int preempt_count = baud_rate / 2400 + 1;
5054 extern int input_pending;
5055
5056 xassert (current_matrix && desired_matrix);
5057
5058 if (baud_rate != FRAME_COST_BAUD_RATE (f))
5059 calculate_costs (f);
5060
5061 if (preempt_count <= 0)
5062 preempt_count = 1;
5063
5064 if (redisplay_dont_pause)
5065 force_p = 1;
5066 else if (!force_p && detect_input_pending ())
5067 {
5068 pause = 1;
5069 goto do_pause;
5070 }
5071
5072 /* If we cannot insert/delete lines, it's no use trying it. */
5073 if (!line_ins_del_ok)
5074 inhibit_id_p = 1;
5075
5076 /* See if any of the desired lines are enabled; don't compute for
5077 i/d line if just want cursor motion. */
5078 for (i = 0; i < desired_matrix->nrows; i++)
5079 if (MATRIX_ROW_ENABLED_P (desired_matrix, i))
5080 break;
5081
5082 /* Try doing i/d line, if not yet inhibited. */
5083 if (!inhibit_id_p && i < desired_matrix->nrows)
5084 force_p |= scrolling (f);
5085
5086 /* Update the individual lines as needed. Do bottom line first. */
5087 if (MATRIX_ROW_ENABLED_P (desired_matrix, desired_matrix->nrows - 1))
5088 update_frame_line (f, desired_matrix->nrows - 1);
5089
5090 /* Now update the rest of the lines. */
5091 for (i = 0; i < desired_matrix->nrows - 1 && (force_p || !input_pending); i++)
5092 {
5093 if (MATRIX_ROW_ENABLED_P (desired_matrix, i))
5094 {
5095 if (FRAME_TERMCAP_P (f))
5096 {
5097 /* Flush out every so many lines.
5098 Also flush out if likely to have more than 1k buffered
5099 otherwise. I'm told that some telnet connections get
5100 really screwed by more than 1k output at once. */
5101 int outq = PENDING_OUTPUT_COUNT (stdout);
5102 if (outq > 900
5103 || (outq > 20 && ((i - 1) % preempt_count == 0)))
5104 {
5105 fflush (stdout);
5106 if (preempt_count == 1)
5107 {
5108 #ifdef EMACS_OUTQSIZE
5109 if (EMACS_OUTQSIZE (0, &outq) < 0)
5110 /* Probably not a tty. Ignore the error and reset
5111 the outq count. */
5112 outq = PENDING_OUTPUT_COUNT (stdout);
5113 #endif
5114 outq *= 10;
5115 if (baud_rate <= outq && baud_rate > 0)
5116 sleep (outq / baud_rate);
5117 }
5118 }
5119 }
5120
5121 if ((i - 1) % preempt_count == 0)
5122 detect_input_pending ();
5123
5124 update_frame_line (f, i);
5125 }
5126 }
5127
5128 pause = (i < FRAME_HEIGHT (f) - 1) ? i : 0;
5129
5130 /* Now just clean up termcap drivers and set cursor, etc. */
5131 if (!pause)
5132 {
5133 if ((cursor_in_echo_area
5134 /* If we are showing a message instead of the mini-buffer,
5135 show the cursor for the message instead of for the
5136 (now hidden) mini-buffer contents. */
5137 || (EQ (minibuf_window, selected_window)
5138 && EQ (minibuf_window, echo_area_window)
5139 && !NILP (echo_area_buffer[0])))
5140 /* These cases apply only to the frame that contains
5141 the active mini-buffer window. */
5142 && FRAME_HAS_MINIBUF_P (f)
5143 && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
5144 {
5145 int top = XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top);
5146 int row, col;
5147
5148 if (cursor_in_echo_area < 0)
5149 {
5150 /* Negative value of cursor_in_echo_area means put
5151 cursor at beginning of line. */
5152 row = top;
5153 col = 0;
5154 }
5155 else
5156 {
5157 /* Positive value of cursor_in_echo_area means put
5158 cursor at the end of the prompt. If the mini-buffer
5159 is several lines high, find the last line that has
5160 any text on it. */
5161 row = FRAME_HEIGHT (f);
5162 do
5163 {
5164 --row;
5165 col = 0;
5166
5167 if (MATRIX_ROW_ENABLED_P (current_matrix, row))
5168 {
5169 /* Frame rows are filled up with spaces that
5170 must be ignored here. */
5171 struct glyph_row *r = MATRIX_ROW (current_matrix,
5172 row);
5173 struct glyph *start = r->glyphs[TEXT_AREA];
5174 struct glyph *last = start + r->used[TEXT_AREA];
5175
5176 while (last > start
5177 && (last - 1)->charpos < 0)
5178 --last;
5179
5180 col = last - start;
5181 }
5182 }
5183 while (row > top && col == 0);
5184
5185 /* Make sure COL is not out of range. */
5186 if (col >= FRAME_CURSOR_X_LIMIT (f))
5187 {
5188 /* If we have another row, advance cursor into it. */
5189 if (row < FRAME_HEIGHT (f) - 1)
5190 {
5191 col = FRAME_LEFT_SCROLL_BAR_WIDTH (f);
5192 row++;
5193 }
5194 /* Otherwise move it back in range. */
5195 else
5196 col = FRAME_CURSOR_X_LIMIT (f) - 1;
5197 }
5198 }
5199
5200 cursor_to (row, col);
5201 }
5202 else
5203 {
5204 /* We have only one cursor on terminal frames. Use it to
5205 display the cursor of the selected window. */
5206 struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
5207 if (w->cursor.vpos >= 0
5208 /* The cursor vpos may be temporarily out of bounds
5209 in the following situation: There is one window,
5210 with the cursor in the lower half of it. The window
5211 is split, and a message causes a redisplay before
5212 a new cursor position has been computed. */
5213 && w->cursor.vpos < XFASTINT (w->height))
5214 {
5215 int x = WINDOW_TO_FRAME_HPOS (w, w->cursor.hpos);
5216 int y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
5217
5218 if (INTEGERP (w->left_margin_width))
5219 x += XFASTINT (w->left_margin_width);
5220
5221 /* x = max (min (x, FRAME_WINDOW_WIDTH (f) - 1), 0); */
5222 cursor_to (y, x);
5223 }
5224 }
5225 }
5226
5227 do_pause:
5228
5229 clear_desired_matrices (f);
5230 return pause;
5231 }
5232
5233
5234 /* Do line insertions/deletions on frame F for frame-based redisplay. */
5235
5236 int
5237 scrolling (frame)
5238 struct frame *frame;
5239 {
5240 int unchanged_at_top, unchanged_at_bottom;
5241 int window_size;
5242 int changed_lines;
5243 int *old_hash = (int *) alloca (FRAME_HEIGHT (frame) * sizeof (int));
5244 int *new_hash = (int *) alloca (FRAME_HEIGHT (frame) * sizeof (int));
5245 int *draw_cost = (int *) alloca (FRAME_HEIGHT (frame) * sizeof (int));
5246 int *old_draw_cost = (int *) alloca (FRAME_HEIGHT (frame) * sizeof (int));
5247 register int i;
5248 int free_at_end_vpos = FRAME_HEIGHT (frame);
5249 struct glyph_matrix *current_matrix = frame->current_matrix;
5250 struct glyph_matrix *desired_matrix = frame->desired_matrix;
5251
5252 if (!current_matrix)
5253 abort ();
5254
5255 /* Compute hash codes of all the lines. Also calculate number of
5256 changed lines, number of unchanged lines at the beginning, and
5257 number of unchanged lines at the end. */
5258 changed_lines = 0;
5259 unchanged_at_top = 0;
5260 unchanged_at_bottom = FRAME_HEIGHT (frame);
5261 for (i = 0; i < FRAME_HEIGHT (frame); i++)
5262 {
5263 /* Give up on this scrolling if some old lines are not enabled. */
5264 if (!MATRIX_ROW_ENABLED_P (current_matrix, i))
5265 return 0;
5266 old_hash[i] = line_hash_code (MATRIX_ROW (current_matrix, i));
5267 if (! MATRIX_ROW_ENABLED_P (desired_matrix, i))
5268 {
5269 /* This line cannot be redrawn, so don't let scrolling mess it. */
5270 new_hash[i] = old_hash[i];
5271 #define INFINITY 1000000 /* Taken from scroll.c */
5272 draw_cost[i] = INFINITY;
5273 }
5274 else
5275 {
5276 new_hash[i] = line_hash_code (MATRIX_ROW (desired_matrix, i));
5277 draw_cost[i] = line_draw_cost (desired_matrix, i);
5278 }
5279
5280 if (old_hash[i] != new_hash[i])
5281 {
5282 changed_lines++;
5283 unchanged_at_bottom = FRAME_HEIGHT (frame) - i - 1;
5284 }
5285 else if (i == unchanged_at_top)
5286 unchanged_at_top++;
5287 old_draw_cost[i] = line_draw_cost (current_matrix, i);
5288 }
5289
5290 /* If changed lines are few, don't allow preemption, don't scroll. */
5291 if ((!scroll_region_ok && changed_lines < baud_rate / 2400)
5292 || unchanged_at_bottom == FRAME_HEIGHT (frame))
5293 return 1;
5294
5295 window_size = (FRAME_HEIGHT (frame) - unchanged_at_top
5296 - unchanged_at_bottom);
5297
5298 if (scroll_region_ok)
5299 free_at_end_vpos -= unchanged_at_bottom;
5300 else if (memory_below_frame)
5301 free_at_end_vpos = -1;
5302
5303 /* If large window, fast terminal and few lines in common between
5304 current frame and desired frame, don't bother with i/d calc. */
5305 if (!scroll_region_ok && window_size >= 18 && baud_rate > 2400
5306 && (window_size >=
5307 10 * scrolling_max_lines_saved (unchanged_at_top,
5308 FRAME_HEIGHT (frame) - unchanged_at_bottom,
5309 old_hash, new_hash, draw_cost)))
5310 return 0;
5311
5312 if (window_size < 2)
5313 return 0;
5314
5315 scrolling_1 (frame, window_size, unchanged_at_top, unchanged_at_bottom,
5316 draw_cost + unchanged_at_top - 1,
5317 old_draw_cost + unchanged_at_top - 1,
5318 old_hash + unchanged_at_top - 1,
5319 new_hash + unchanged_at_top - 1,
5320 free_at_end_vpos - unchanged_at_top);
5321
5322 return 0;
5323 }
5324
5325
5326 /* Count the number of blanks at the start of the vector of glyphs R
5327 which is LEN glyphs long. */
5328
5329 static int
5330 count_blanks (r, len)
5331 struct glyph *r;
5332 int len;
5333 {
5334 int i;
5335
5336 for (i = 0; i < len; ++i)
5337 if (!CHAR_GLYPH_SPACE_P (r[i]))
5338 break;
5339
5340 return i;
5341 }
5342
5343
5344 /* Count the number of glyphs in common at the start of the glyph
5345 vectors STR1 and STR2. END1 is the end of STR1 and END2 is the end
5346 of STR2. Value is the number of equal glyphs equal at the start. */
5347
5348 static int
5349 count_match (str1, end1, str2, end2)
5350 struct glyph *str1, *end1, *str2, *end2;
5351 {
5352 struct glyph *p1 = str1;
5353 struct glyph *p2 = str2;
5354
5355 while (p1 < end1
5356 && p2 < end2
5357 && GLYPH_CHAR_AND_FACE_EQUAL_P (p1, p2))
5358 ++p1, ++p2;
5359
5360 return p1 - str1;
5361 }
5362
5363
5364 /* Char insertion/deletion cost vector, from term.c */
5365
5366 extern int *char_ins_del_vector;
5367 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
5368
5369
5370 /* Perform a frame-based update on line VPOS in frame FRAME. */
5371
5372 static void
5373 update_frame_line (f, vpos)
5374 struct frame *f;
5375 int vpos;
5376 {
5377 struct glyph *obody, *nbody, *op1, *op2, *np1, *nend;
5378 int tem;
5379 int osp, nsp, begmatch, endmatch, olen, nlen;
5380 struct glyph_matrix *current_matrix = f->current_matrix;
5381 struct glyph_matrix *desired_matrix = f->desired_matrix;
5382 struct glyph_row *current_row = MATRIX_ROW (current_matrix, vpos);
5383 struct glyph_row *desired_row = MATRIX_ROW (desired_matrix, vpos);
5384 int must_write_whole_line_p;
5385 int write_spaces_p = must_write_spaces;
5386 int colored_spaces_p = (FACE_FROM_ID (f, DEFAULT_FACE_ID)->background
5387 != FACE_TTY_DEFAULT_BG_COLOR);
5388
5389 if (colored_spaces_p)
5390 write_spaces_p = 1;
5391
5392 /* Current row not enabled means it has unknown contents. We must
5393 write the whole desired line in that case. */
5394 must_write_whole_line_p = !current_row->enabled_p;
5395 if (must_write_whole_line_p)
5396 {
5397 obody = 0;
5398 olen = 0;
5399 }
5400 else
5401 {
5402 obody = MATRIX_ROW_GLYPH_START (current_matrix, vpos);
5403 olen = current_row->used[TEXT_AREA];
5404
5405 /* Ignore trailing spaces, if we can. */
5406 if (!write_spaces_p)
5407 while (olen > 0 && CHAR_GLYPH_SPACE_P (obody[olen-1]))
5408 olen--;
5409 }
5410
5411 current_row->enabled_p = 1;
5412 current_row->used[TEXT_AREA] = desired_row->used[TEXT_AREA];
5413
5414 /* If desired line is empty, just clear the line. */
5415 if (!desired_row->enabled_p)
5416 {
5417 nlen = 0;
5418 goto just_erase;
5419 }
5420
5421 nbody = desired_row->glyphs[TEXT_AREA];
5422 nlen = desired_row->used[TEXT_AREA];
5423 nend = nbody + nlen;
5424
5425 /* If display line has unknown contents, write the whole line. */
5426 if (must_write_whole_line_p)
5427 {
5428 /* Ignore spaces at the end, if we can. */
5429 if (!write_spaces_p)
5430 while (nlen > 0 && CHAR_GLYPH_SPACE_P (nbody[nlen - 1]))
5431 --nlen;
5432
5433 /* Write the contents of the desired line. */
5434 if (nlen)
5435 {
5436 cursor_to (vpos, 0);
5437 write_glyphs (nbody, nlen);
5438 }
5439
5440 /* Don't call clear_end_of_line if we already wrote the whole
5441 line. The cursor will not be at the right margin in that
5442 case but in the line below. */
5443 if (nlen < FRAME_WINDOW_WIDTH (f))
5444 {
5445 cursor_to (vpos, nlen);
5446 clear_end_of_line (FRAME_WINDOW_WIDTH (f));
5447 }
5448 else
5449 /* Make sure we are in the right row, otherwise cursor movement
5450 with cmgoto might use `ch' in the wrong row. */
5451 cursor_to (vpos, 0);
5452
5453 make_current (desired_matrix, current_matrix, vpos);
5454 return;
5455 }
5456
5457 /* Pretend trailing spaces are not there at all,
5458 unless for one reason or another we must write all spaces. */
5459 if (!write_spaces_p)
5460 while (nlen > 0 && CHAR_GLYPH_SPACE_P (nbody[nlen - 1]))
5461 nlen--;
5462
5463 /* If there's no i/d char, quickly do the best we can without it. */
5464 if (!char_ins_del_ok)
5465 {
5466 int i, j;
5467
5468 /* Find the first glyph in desired row that doesn't agree with
5469 a glyph in the current row, and write the rest from there on. */
5470 for (i = 0; i < nlen; i++)
5471 {
5472 if (i >= olen || !GLYPH_EQUAL_P (nbody + i, obody + i))
5473 {
5474 /* Find the end of the run of different glyphs. */
5475 j = i + 1;
5476 while (j < nlen
5477 && (j >= olen
5478 || !GLYPH_EQUAL_P (nbody + j, obody + j)
5479 || CHAR_GLYPH_PADDING_P (nbody[j])))
5480 ++j;
5481
5482 /* Output this run of non-matching chars. */
5483 cursor_to (vpos, i);
5484 write_glyphs (nbody + i, j - i);
5485 i = j - 1;
5486
5487 /* Now find the next non-match. */
5488 }
5489 }
5490
5491 /* Clear the rest of the line, or the non-clear part of it. */
5492 if (olen > nlen)
5493 {
5494 cursor_to (vpos, nlen);
5495 clear_end_of_line (olen);
5496 }
5497
5498 /* Make current row = desired row. */
5499 make_current (desired_matrix, current_matrix, vpos);
5500 return;
5501 }
5502
5503 /* Here when CHAR_INS_DEL_OK != 0, i.e. we can insert or delete
5504 characters in a row. */
5505
5506 if (!olen)
5507 {
5508 /* If current line is blank, skip over initial spaces, if
5509 possible, and write the rest. */
5510 if (write_spaces_p)
5511 nsp = 0;
5512 else
5513 nsp = count_blanks (nbody, nlen);
5514
5515 if (nlen > nsp)
5516 {
5517 cursor_to (vpos, nsp);
5518 write_glyphs (nbody + nsp, nlen - nsp);
5519 }
5520
5521 /* Exchange contents between current_frame and new_frame. */
5522 make_current (desired_matrix, current_matrix, vpos);
5523 return;
5524 }
5525
5526 /* Compute number of leading blanks in old and new contents. */
5527 osp = count_blanks (obody, olen);
5528 nsp = (colored_spaces_p ? 0 : count_blanks (nbody, nlen));
5529
5530 /* Compute number of matching chars starting with first non-blank. */
5531 begmatch = count_match (obody + osp, obody + olen,
5532 nbody + nsp, nbody + nlen);
5533
5534 /* Spaces in new match implicit space past the end of old. */
5535 /* A bug causing this to be a no-op was fixed in 18.29. */
5536 if (!write_spaces_p && osp + begmatch == olen)
5537 {
5538 np1 = nbody + nsp;
5539 while (np1 + begmatch < nend && CHAR_GLYPH_SPACE_P (np1[begmatch]))
5540 ++begmatch;
5541 }
5542
5543 /* Avoid doing insert/delete char
5544 just cause number of leading spaces differs
5545 when the following text does not match. */
5546 if (begmatch == 0 && osp != nsp)
5547 osp = nsp = min (osp, nsp);
5548
5549 /* Find matching characters at end of line */
5550 op1 = obody + olen;
5551 np1 = nbody + nlen;
5552 op2 = op1 + begmatch - min (olen - osp, nlen - nsp);
5553 while (op1 > op2
5554 && GLYPH_EQUAL_P (op1 - 1, np1 - 1))
5555 {
5556 op1--;
5557 np1--;
5558 }
5559 endmatch = obody + olen - op1;
5560
5561 /* tem gets the distance to insert or delete.
5562 endmatch is how many characters we save by doing so.
5563 Is it worth it? */
5564
5565 tem = (nlen - nsp) - (olen - osp);
5566 if (endmatch && tem
5567 && (!char_ins_del_ok || endmatch <= char_ins_del_cost (f)[tem]))
5568 endmatch = 0;
5569
5570 /* nsp - osp is the distance to insert or delete.
5571 If that is nonzero, begmatch is known to be nonzero also.
5572 begmatch + endmatch is how much we save by doing the ins/del.
5573 Is it worth it? */
5574
5575 if (nsp != osp
5576 && (!char_ins_del_ok
5577 || begmatch + endmatch <= char_ins_del_cost (f)[nsp - osp]))
5578 {
5579 begmatch = 0;
5580 endmatch = 0;
5581 osp = nsp = min (osp, nsp);
5582 }
5583
5584 /* Now go through the line, inserting, writing and
5585 deleting as appropriate. */
5586
5587 if (osp > nsp)
5588 {
5589 cursor_to (vpos, nsp);
5590 delete_glyphs (osp - nsp);
5591 }
5592 else if (nsp > osp)
5593 {
5594 /* If going to delete chars later in line
5595 and insert earlier in the line,
5596 must delete first to avoid losing data in the insert */
5597 if (endmatch && nlen < olen + nsp - osp)
5598 {
5599 cursor_to (vpos, nlen - endmatch + osp - nsp);
5600 delete_glyphs (olen + nsp - osp - nlen);
5601 olen = nlen - (nsp - osp);
5602 }
5603 cursor_to (vpos, osp);
5604 insert_glyphs (0, nsp - osp);
5605 }
5606 olen += nsp - osp;
5607
5608 tem = nsp + begmatch + endmatch;
5609 if (nlen != tem || olen != tem)
5610 {
5611 if (!endmatch || nlen == olen)
5612 {
5613 /* If new text being written reaches right margin, there is
5614 no need to do clear-to-eol at the end of this function
5615 (and it would not be safe, since cursor is not going to
5616 be "at the margin" after the text is done). */
5617 if (nlen == FRAME_WINDOW_WIDTH (f))
5618 olen = 0;
5619
5620 /* Function write_glyphs is prepared to do nothing
5621 if passed a length <= 0. Check it here to avoid
5622 unnecessary cursor movement. */
5623 if (nlen - tem > 0)
5624 {
5625 cursor_to (vpos, nsp + begmatch);
5626 write_glyphs (nbody + nsp + begmatch, nlen - tem);
5627 }
5628 }
5629 else if (nlen > olen)
5630 {
5631 /* Here, we used to have the following simple code:
5632 ----------------------------------------
5633 write_glyphs (nbody + nsp + begmatch, olen - tem);
5634 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
5635 ----------------------------------------
5636 but it doesn't work if nbody[nsp + begmatch + olen - tem]
5637 is a padding glyph. */
5638 int out = olen - tem; /* Columns to be overwritten originally. */
5639 int del;
5640
5641 cursor_to (vpos, nsp + begmatch);
5642
5643 /* Calculate columns we can actually overwrite. */
5644 while (CHAR_GLYPH_PADDING_P (nbody[nsp + begmatch + out]))
5645 out--;
5646 write_glyphs (nbody + nsp + begmatch, out);
5647
5648 /* If we left columns to be overwritten, we must delete them. */
5649 del = olen - tem - out;
5650 if (del > 0)
5651 delete_glyphs (del);
5652
5653 /* At last, we insert columns not yet written out. */
5654 insert_glyphs (nbody + nsp + begmatch + out, nlen - olen + del);
5655 olen = nlen;
5656 }
5657 else if (olen > nlen)
5658 {
5659 cursor_to (vpos, nsp + begmatch);
5660 write_glyphs (nbody + nsp + begmatch, nlen - tem);
5661 delete_glyphs (olen - nlen);
5662 olen = nlen;
5663 }
5664 }
5665
5666 just_erase:
5667 /* If any unerased characters remain after the new line, erase them. */
5668 if (olen > nlen)
5669 {
5670 cursor_to (vpos, nlen);
5671 clear_end_of_line (olen);
5672 }
5673
5674 /* Exchange contents between current_frame and new_frame. */
5675 make_current (desired_matrix, current_matrix, vpos);
5676 }
5677
5678
5679 \f
5680 /***********************************************************************
5681 X/Y Position -> Buffer Position
5682 ***********************************************************************/
5683
5684 /* Determine what's under window-relative pixel position (*X, *Y).
5685 Return in *OBJECT the object (string or buffer) that's there.
5686 Return in *POS the position in that object. Adjust *X and *Y
5687 to character boundaries. */
5688
5689 void
5690 buffer_posn_from_coords (w, x, y, object, pos)
5691 struct window *w;
5692 int *x, *y;
5693 Lisp_Object *object;
5694 struct display_pos *pos;
5695 {
5696 struct it it;
5697 struct buffer *old_current_buffer = current_buffer;
5698 struct text_pos startp;
5699 int left_area_width;
5700
5701 current_buffer = XBUFFER (w->buffer);
5702 SET_TEXT_POS_FROM_MARKER (startp, w->start);
5703 CHARPOS (startp) = min (ZV, max (BEGV, CHARPOS (startp)));
5704 BYTEPOS (startp) = min (ZV_BYTE, max (BEGV_BYTE, BYTEPOS (startp)));
5705 start_display (&it, w, startp);
5706
5707 left_area_width = WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH (w);
5708 move_it_to (&it, -1, *x + it.first_visible_x - left_area_width, *y, -1,
5709 MOVE_TO_X | MOVE_TO_Y);
5710
5711 *x = it.current_x - it.first_visible_x + left_area_width;
5712 *y = it.current_y;
5713 current_buffer = old_current_buffer;
5714
5715 *object = STRINGP (it.string) ? it.string : w->buffer;
5716 *pos = it.current;
5717 }
5718
5719
5720 /* Value is the string under window-relative coordinates X/Y in the
5721 mode or header line of window W, or nil if none. MODE_LINE_P non-zero
5722 means look at the mode line. *CHARPOS is set to the position in
5723 the string returned. */
5724
5725 Lisp_Object
5726 mode_line_string (w, x, y, mode_line_p, charpos)
5727 struct window *w;
5728 int x, y, mode_line_p;
5729 int *charpos;
5730 {
5731 struct glyph_row *row;
5732 struct glyph *glyph, *end;
5733 struct frame *f = XFRAME (w->frame);
5734 int x0;
5735 Lisp_Object string = Qnil;
5736
5737 if (mode_line_p)
5738 row = MATRIX_MODE_LINE_ROW (w->current_matrix);
5739 else
5740 row = MATRIX_HEADER_LINE_ROW (w->current_matrix);
5741
5742 if (row->mode_line_p && row->enabled_p)
5743 {
5744 /* The mode lines are displayed over scroll bars and fringes,
5745 and X is window-relative. Correct X by the scroll bar
5746 and fringe width. */
5747 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f))
5748 x += FRAME_SCROLL_BAR_COLS (f) * CANON_X_UNIT (f);
5749 x += FRAME_LEFT_FRINGE_WIDTH (f);
5750
5751 /* Find the glyph under X. If we find one with a string object,
5752 it's the one we were looking for. */
5753 glyph = row->glyphs[TEXT_AREA];
5754 end = glyph + row->used[TEXT_AREA];
5755 for (x0 = 0; glyph < end; x0 += glyph->pixel_width, ++glyph)
5756 if (x >= x0 && x < x0 + glyph->pixel_width)
5757 {
5758 string = glyph->object;
5759 *charpos = glyph->charpos;
5760 break;
5761 }
5762 }
5763
5764 return string;
5765 }
5766
5767
5768 /* Value is the string under window-relative coordinates X/Y in either
5769 marginal area, or nil if none. *CHARPOS is set to the position in
5770 the string returned. */
5771
5772 Lisp_Object
5773 marginal_area_string (w, x, y, area, charpos)
5774 struct window *w;
5775 int x, y;
5776 int area;
5777 int *charpos;
5778 {
5779 struct glyph_row *row = w->current_matrix->rows;
5780 struct glyph *glyph, *end;
5781 int x0, i, wy = y;
5782 Lisp_Object string = Qnil;
5783
5784 if (area == 6)
5785 area = LEFT_MARGIN_AREA;
5786 else if (area == 7)
5787 area = RIGHT_MARGIN_AREA;
5788 else
5789 abort ();
5790
5791 for (i = 0; row->enabled_p && i < w->current_matrix->nrows; ++i, ++row)
5792 if (wy >= row->y && wy < MATRIX_ROW_BOTTOM_Y (row))
5793 break;
5794
5795 if (row->enabled_p)
5796 {
5797 /* Find the glyph under X. If we find one with a string object,
5798 it's the one we were looking for. */
5799 glyph = row->glyphs[area];
5800 end = glyph + row->used[area];
5801 if (area == RIGHT_MARGIN_AREA)
5802 x0 = (window_box_width (w, TEXT_AREA)
5803 + window_box_width (w, LEFT_MARGIN_AREA));
5804 else
5805 x0 = 0;
5806 for (; glyph < end; x0 += glyph->pixel_width, ++glyph)
5807 if (x >= x0 && x < x0 + glyph->pixel_width)
5808 {
5809 string = glyph->object;
5810 *charpos = glyph->charpos;
5811 break;
5812 }
5813 }
5814
5815 return string;
5816 }
5817
5818
5819 /***********************************************************************
5820 Changing Frame Sizes
5821 ***********************************************************************/
5822
5823 #ifdef SIGWINCH
5824
5825 SIGTYPE
5826 window_change_signal (signalnum) /* If we don't have an argument, */
5827 int signalnum; /* some compilers complain in signal calls. */
5828 {
5829 int width, height;
5830 #ifndef USE_CRT_DLL
5831 extern int errno;
5832 #endif
5833 int old_errno = errno;
5834
5835 get_frame_size (&width, &height);
5836
5837 /* The frame size change obviously applies to a termcap-controlled
5838 frame. Find such a frame in the list, and assume it's the only
5839 one (since the redisplay code always writes to stdout, not a
5840 FILE * specified in the frame structure). Record the new size,
5841 but don't reallocate the data structures now. Let that be done
5842 later outside of the signal handler. */
5843
5844 {
5845 Lisp_Object tail, frame;
5846
5847 FOR_EACH_FRAME (tail, frame)
5848 {
5849 if (FRAME_TERMCAP_P (XFRAME (frame)))
5850 {
5851 change_frame_size (XFRAME (frame), height, width, 0, 1, 0);
5852 break;
5853 }
5854 }
5855 }
5856
5857 signal (SIGWINCH, window_change_signal);
5858 errno = old_errno;
5859 }
5860 #endif /* SIGWINCH */
5861
5862
5863 /* Do any change in frame size that was requested by a signal. SAFE
5864 non-zero means this function is called from a place where it is
5865 safe to change frame sizes while a redisplay is in progress. */
5866
5867 void
5868 do_pending_window_change (safe)
5869 int safe;
5870 {
5871 /* If window_change_signal should have run before, run it now. */
5872 if (redisplaying_p && !safe)
5873 return;
5874
5875 while (delayed_size_change)
5876 {
5877 Lisp_Object tail, frame;
5878
5879 delayed_size_change = 0;
5880
5881 FOR_EACH_FRAME (tail, frame)
5882 {
5883 struct frame *f = XFRAME (frame);
5884
5885 int height = FRAME_NEW_HEIGHT (f);
5886 int width = FRAME_NEW_WIDTH (f);
5887
5888 if (height != 0 || width != 0)
5889 change_frame_size (f, height, width, 0, 0, safe);
5890 }
5891 }
5892 }
5893
5894
5895 /* Change the frame height and/or width. Values may be given as zero to
5896 indicate no change is to take place.
5897
5898 If DELAY is non-zero, then assume we're being called from a signal
5899 handler, and queue the change for later - perhaps the next
5900 redisplay. Since this tries to resize windows, we can't call it
5901 from a signal handler.
5902
5903 SAFE non-zero means this function is called from a place where it's
5904 safe to change frame sizes while a redisplay is in progress. */
5905
5906 void
5907 change_frame_size (f, newheight, newwidth, pretend, delay, safe)
5908 register struct frame *f;
5909 int newheight, newwidth, pretend, delay, safe;
5910 {
5911 Lisp_Object tail, frame;
5912
5913 if (! FRAME_WINDOW_P (f))
5914 {
5915 /* When using termcap, or on MS-DOS, all frames use
5916 the same screen, so a change in size affects all frames. */
5917 FOR_EACH_FRAME (tail, frame)
5918 if (! FRAME_WINDOW_P (XFRAME (frame)))
5919 change_frame_size_1 (XFRAME (frame), newheight, newwidth,
5920 pretend, delay, safe);
5921 }
5922 else
5923 change_frame_size_1 (f, newheight, newwidth, pretend, delay, safe);
5924 }
5925
5926 static void
5927 change_frame_size_1 (f, newheight, newwidth, pretend, delay, safe)
5928 register struct frame *f;
5929 int newheight, newwidth, pretend, delay, safe;
5930 {
5931 int new_frame_window_width;
5932 int count = SPECPDL_INDEX ();
5933
5934 /* If we can't deal with the change now, queue it for later. */
5935 if (delay || (redisplaying_p && !safe))
5936 {
5937 FRAME_NEW_HEIGHT (f) = newheight;
5938 FRAME_NEW_WIDTH (f) = newwidth;
5939 delayed_size_change = 1;
5940 return;
5941 }
5942
5943 /* This size-change overrides any pending one for this frame. */
5944 FRAME_NEW_HEIGHT (f) = 0;
5945 FRAME_NEW_WIDTH (f) = 0;
5946
5947 /* If an argument is zero, set it to the current value. */
5948 if (newheight == 0)
5949 newheight = FRAME_HEIGHT (f);
5950 if (newwidth == 0)
5951 newwidth = FRAME_WIDTH (f);
5952
5953 /* Compute width of windows in F.
5954 This is the width of the frame without vertical scroll bars. */
5955 new_frame_window_width = FRAME_WINDOW_WIDTH_ARG (f, newwidth);
5956
5957 /* Round up to the smallest acceptable size. */
5958 check_frame_size (f, &newheight, &newwidth);
5959
5960 /* If we're not changing the frame size, quit now. */
5961 if (newheight == FRAME_HEIGHT (f)
5962 && new_frame_window_width == FRAME_WINDOW_WIDTH (f))
5963 return;
5964
5965 BLOCK_INPUT;
5966
5967 #ifdef MSDOS
5968 /* We only can set screen dimensions to certain values supported
5969 by our video hardware. Try to find the smallest size greater
5970 or equal to the requested dimensions. */
5971 dos_set_window_size (&newheight, &newwidth);
5972 #endif
5973
5974 if (newheight != FRAME_HEIGHT (f))
5975 {
5976 if (FRAME_HAS_MINIBUF_P (f) && !FRAME_MINIBUF_ONLY_P (f))
5977 {
5978 /* Frame has both root and mini-buffer. */
5979 XSETFASTINT (XWINDOW (FRAME_ROOT_WINDOW (f))->top,
5980 FRAME_TOP_MARGIN (f));
5981 set_window_height (FRAME_ROOT_WINDOW (f),
5982 (newheight
5983 - 1
5984 - FRAME_TOP_MARGIN (f)),
5985 0);
5986 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top,
5987 newheight - 1);
5988 set_window_height (FRAME_MINIBUF_WINDOW (f), 1, 0);
5989 }
5990 else
5991 /* Frame has just one top-level window. */
5992 set_window_height (FRAME_ROOT_WINDOW (f),
5993 newheight - FRAME_TOP_MARGIN (f), 0);
5994
5995 if (FRAME_TERMCAP_P (f) && !pretend)
5996 FrameRows = newheight;
5997 }
5998
5999 if (new_frame_window_width != FRAME_WINDOW_WIDTH (f))
6000 {
6001 set_window_width (FRAME_ROOT_WINDOW (f), new_frame_window_width, 0);
6002 if (FRAME_HAS_MINIBUF_P (f))
6003 set_window_width (FRAME_MINIBUF_WINDOW (f), new_frame_window_width, 0);
6004
6005 if (FRAME_TERMCAP_P (f) && !pretend)
6006 FrameCols = newwidth;
6007
6008 if (WINDOWP (f->tool_bar_window))
6009 XSETFASTINT (XWINDOW (f->tool_bar_window)->width, newwidth);
6010 }
6011
6012 FRAME_HEIGHT (f) = newheight;
6013 SET_FRAME_WIDTH (f, newwidth);
6014
6015 {
6016 struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
6017 int text_area_x, text_area_y, text_area_width, text_area_height;
6018
6019 window_box (w, TEXT_AREA, &text_area_x, &text_area_y, &text_area_width,
6020 &text_area_height);
6021 if (w->cursor.x >= text_area_x + text_area_width)
6022 w->cursor.hpos = w->cursor.x = 0;
6023 if (w->cursor.y >= text_area_y + text_area_height)
6024 w->cursor.vpos = w->cursor.y = 0;
6025 }
6026
6027 adjust_glyphs (f);
6028 calculate_costs (f);
6029 SET_FRAME_GARBAGED (f);
6030 f->resized_p = 1;
6031
6032 UNBLOCK_INPUT;
6033
6034 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
6035
6036 /* This isn't quite a no-op: it runs window-configuration-change-hook. */
6037 Fset_window_buffer (FRAME_SELECTED_WINDOW (f),
6038 XWINDOW (FRAME_SELECTED_WINDOW (f))->buffer);
6039
6040 unbind_to (count, Qnil);
6041 }
6042
6043
6044 \f
6045 /***********************************************************************
6046 Terminal Related Lisp Functions
6047 ***********************************************************************/
6048
6049 DEFUN ("open-termscript", Fopen_termscript, Sopen_termscript,
6050 1, 1, "FOpen termscript file: ",
6051 doc: /* Start writing all terminal output to FILE as well as the terminal.
6052 FILE = nil means just close any termscript file currently open. */)
6053 (file)
6054 Lisp_Object file;
6055 {
6056 if (termscript != 0) fclose (termscript);
6057 termscript = 0;
6058
6059 if (! NILP (file))
6060 {
6061 file = Fexpand_file_name (file, Qnil);
6062 termscript = fopen (SDATA (file), "w");
6063 if (termscript == 0)
6064 report_file_error ("Opening termscript", Fcons (file, Qnil));
6065 }
6066 return Qnil;
6067 }
6068
6069
6070 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal,
6071 Ssend_string_to_terminal, 1, 1, 0,
6072 doc: /* Send STRING to the terminal without alteration.
6073 Control characters in STRING will have terminal-dependent effects. */)
6074 (string)
6075 Lisp_Object string;
6076 {
6077 /* ??? Perhaps we should do something special for multibyte strings here. */
6078 CHECK_STRING (string);
6079 fwrite (SDATA (string), 1, SBYTES (string), stdout);
6080 fflush (stdout);
6081 if (termscript)
6082 {
6083 fwrite (SDATA (string), 1, SBYTES (string),
6084 termscript);
6085 fflush (termscript);
6086 }
6087 return Qnil;
6088 }
6089
6090
6091 DEFUN ("ding", Fding, Sding, 0, 1, 0,
6092 doc: /* Beep, or flash the screen.
6093 Also, unless an argument is given,
6094 terminate any keyboard macro currently executing. */)
6095 (arg)
6096 Lisp_Object arg;
6097 {
6098 if (!NILP (arg))
6099 {
6100 if (noninteractive)
6101 putchar (07);
6102 else
6103 ring_bell ();
6104 fflush (stdout);
6105 }
6106 else
6107 bitch_at_user ();
6108
6109 return Qnil;
6110 }
6111
6112 void
6113 bitch_at_user ()
6114 {
6115 if (noninteractive)
6116 putchar (07);
6117 else if (!INTERACTIVE) /* Stop executing a keyboard macro. */
6118 error ("Keyboard macro terminated by a command ringing the bell");
6119 else
6120 ring_bell ();
6121 fflush (stdout);
6122 }
6123
6124
6125 \f
6126 /***********************************************************************
6127 Sleeping, Waiting
6128 ***********************************************************************/
6129
6130 DEFUN ("sleep-for", Fsleep_for, Ssleep_for, 1, 2, 0,
6131 doc: /* Pause, without updating display, for SECONDS seconds.
6132 SECONDS may be a floating-point value, meaning that you can wait for a
6133 fraction of a second. Optional second arg MILLISECONDS specifies an
6134 additional wait period, in milliseconds; this may be useful if your
6135 Emacs was built without floating point support.
6136 \(Not all operating systems support waiting for a fraction of a second.) */)
6137 (seconds, milliseconds)
6138 Lisp_Object seconds, milliseconds;
6139 {
6140 int sec, usec;
6141
6142 if (NILP (milliseconds))
6143 XSETINT (milliseconds, 0);
6144 else
6145 CHECK_NUMBER (milliseconds);
6146 usec = XINT (milliseconds) * 1000;
6147
6148 {
6149 double duration = extract_float (seconds);
6150 sec = (int) duration;
6151 usec += (duration - sec) * 1000000;
6152 }
6153
6154 #ifndef EMACS_HAS_USECS
6155 if (sec == 0 && usec != 0)
6156 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE);
6157 #endif
6158
6159 /* Assure that 0 <= usec < 1000000. */
6160 if (usec < 0)
6161 {
6162 /* We can't rely on the rounding being correct if usec is negative. */
6163 if (-1000000 < usec)
6164 sec--, usec += 1000000;
6165 else
6166 sec -= -usec / 1000000, usec = 1000000 - (-usec % 1000000);
6167 }
6168 else
6169 sec += usec / 1000000, usec %= 1000000;
6170
6171 if (sec < 0 || (sec == 0 && usec == 0))
6172 return Qnil;
6173
6174 {
6175 Lisp_Object zero;
6176
6177 XSETFASTINT (zero, 0);
6178 wait_reading_process_input (sec, usec, zero, 0);
6179 }
6180
6181 /* We should always have wait_reading_process_input; we have a dummy
6182 implementation for systems which don't support subprocesses. */
6183 #if 0
6184 /* No wait_reading_process_input */
6185 immediate_quit = 1;
6186 QUIT;
6187
6188 #ifdef VMS
6189 sys_sleep (sec);
6190 #else /* not VMS */
6191 /* The reason this is done this way
6192 (rather than defined (H_S) && defined (H_T))
6193 is because the VMS preprocessor doesn't grok `defined'. */
6194 #ifdef HAVE_SELECT
6195 EMACS_GET_TIME (end_time);
6196 EMACS_SET_SECS_USECS (timeout, sec, usec);
6197 EMACS_ADD_TIME (end_time, end_time, timeout);
6198
6199 while (1)
6200 {
6201 EMACS_GET_TIME (timeout);
6202 EMACS_SUB_TIME (timeout, end_time, timeout);
6203 if (EMACS_TIME_NEG_P (timeout)
6204 || !select (1, 0, 0, 0, &timeout))
6205 break;
6206 }
6207 #else /* not HAVE_SELECT */
6208 sleep (sec);
6209 #endif /* HAVE_SELECT */
6210 #endif /* not VMS */
6211
6212 immediate_quit = 0;
6213 #endif /* no subprocesses */
6214
6215 return Qnil;
6216 }
6217
6218
6219 /* This is just like wait_reading_process_input, except that
6220 it does the redisplay.
6221
6222 It's also much like Fsit_for, except that it can be used for
6223 waiting for input as well. */
6224
6225 Lisp_Object
6226 sit_for (sec, usec, reading, display, initial_display)
6227 int sec, usec, reading, display, initial_display;
6228 {
6229 Lisp_Object read_kbd;
6230
6231 swallow_events (display);
6232
6233 if (detect_input_pending_run_timers (display) || !NILP (Vexecuting_macro))
6234 return Qnil;
6235
6236 if (initial_display)
6237 redisplay_preserve_echo_area (2);
6238
6239 if (sec == 0 && usec == 0)
6240 return Qt;
6241
6242 #ifdef SIGIO
6243 gobble_input (0);
6244 #endif
6245
6246 XSETINT (read_kbd, reading ? -1 : 1);
6247 wait_reading_process_input (sec, usec, read_kbd, display);
6248
6249 return detect_input_pending () ? Qnil : Qt;
6250 }
6251
6252
6253 DEFUN ("sit-for", Fsit_for, Ssit_for, 1, 3, 0,
6254 doc: /* Perform redisplay, then wait for SECONDS seconds or until input is available.
6255 SECONDS may be a floating-point value, meaning that you can wait for a
6256 fraction of a second. Optional second arg MILLISECONDS specifies an
6257 additional wait period, in milliseconds; this may be useful if your
6258 Emacs was built without floating point support.
6259 \(Not all operating systems support waiting for a fraction of a second.)
6260 Optional third arg NODISP non-nil means don't redisplay, just wait for input.
6261 Redisplay is preempted as always if input arrives, and does not happen
6262 if input is available before it starts.
6263 Value is t if waited the full time with no input arriving. */)
6264 (seconds, milliseconds, nodisp)
6265 Lisp_Object seconds, milliseconds, nodisp;
6266 {
6267 int sec, usec;
6268
6269 if (NILP (milliseconds))
6270 XSETINT (milliseconds, 0);
6271 else
6272 CHECK_NUMBER (milliseconds);
6273 usec = XINT (milliseconds) * 1000;
6274
6275 {
6276 double duration = extract_float (seconds);
6277 sec = (int) duration;
6278 usec += (duration - sec) * 1000000;
6279 }
6280
6281 #ifndef EMACS_HAS_USECS
6282 if (usec != 0 && sec == 0)
6283 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE);
6284 #endif
6285
6286 return sit_for (sec, usec, 0, NILP (nodisp), NILP (nodisp));
6287 }
6288
6289
6290 \f
6291 /***********************************************************************
6292 Other Lisp Functions
6293 ***********************************************************************/
6294
6295 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
6296 session's frames, frame names, buffers, buffer-read-only flags, and
6297 buffer-modified-flags, and a trailing sentinel (so we don't need to
6298 add length checks). */
6299
6300 static Lisp_Object frame_and_buffer_state;
6301
6302
6303 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p,
6304 Sframe_or_buffer_changed_p, 0, 0, 0,
6305 doc: /* Return non-nil if the frame and buffer state appears to have changed.
6306 The state variable is an internal vector containing all frames and buffers,
6307 aside from buffers whose names start with space,
6308 along with the buffers' read-only and modified flags, which allows a fast
6309 check to see whether the menu bars might need to be recomputed.
6310 If this function returns non-nil, it updates the internal vector to reflect
6311 the current state. */)
6312 ()
6313 {
6314 Lisp_Object tail, frame, buf;
6315 Lisp_Object *vecp;
6316 int n;
6317
6318 vecp = XVECTOR (frame_and_buffer_state)->contents;
6319 FOR_EACH_FRAME (tail, frame)
6320 {
6321 if (!EQ (*vecp++, frame))
6322 goto changed;
6323 if (!EQ (*vecp++, XFRAME (frame)->name))
6324 goto changed;
6325 }
6326 /* Check that the buffer info matches.
6327 No need to test for the end of the vector
6328 because the last element of the vector is lambda
6329 and that will always cause a mismatch. */
6330 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
6331 {
6332 buf = XCDR (XCAR (tail));
6333 /* Ignore buffers that aren't included in buffer lists. */
6334 if (SREF (XBUFFER (buf)->name, 0) == ' ')
6335 continue;
6336 if (!EQ (*vecp++, buf))
6337 goto changed;
6338 if (!EQ (*vecp++, XBUFFER (buf)->read_only))
6339 goto changed;
6340 if (!EQ (*vecp++, Fbuffer_modified_p (buf)))
6341 goto changed;
6342 }
6343 /* Detect deletion of a buffer at the end of the list. */
6344 if (EQ (*vecp, Qlambda))
6345 return Qnil;
6346 changed:
6347 /* Start with 1 so there is room for at least one lambda at the end. */
6348 n = 1;
6349 FOR_EACH_FRAME (tail, frame)
6350 n += 2;
6351 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
6352 n += 3;
6353 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
6354 if (n > XVECTOR (frame_and_buffer_state)->size
6355 || n + 20 < XVECTOR (frame_and_buffer_state)->size / 2)
6356 /* Add 20 extra so we grow it less often. */
6357 frame_and_buffer_state = Fmake_vector (make_number (n + 20), Qlambda);
6358 vecp = XVECTOR (frame_and_buffer_state)->contents;
6359 FOR_EACH_FRAME (tail, frame)
6360 {
6361 *vecp++ = frame;
6362 *vecp++ = XFRAME (frame)->name;
6363 }
6364 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
6365 {
6366 buf = XCDR (XCAR (tail));
6367 /* Ignore buffers that aren't included in buffer lists. */
6368 if (SREF (XBUFFER (buf)->name, 0) == ' ')
6369 continue;
6370 *vecp++ = buf;
6371 *vecp++ = XBUFFER (buf)->read_only;
6372 *vecp++ = Fbuffer_modified_p (buf);
6373 }
6374 /* Fill up the vector with lambdas (always at least one). */
6375 *vecp++ = Qlambda;
6376 while (vecp - XVECTOR (frame_and_buffer_state)->contents
6377 < XVECTOR (frame_and_buffer_state)->size)
6378 *vecp++ = Qlambda;
6379 /* Make sure we didn't overflow the vector. */
6380 if (vecp - XVECTOR (frame_and_buffer_state)->contents
6381 > XVECTOR (frame_and_buffer_state)->size)
6382 abort ();
6383 return Qt;
6384 }
6385
6386
6387 \f
6388 /***********************************************************************
6389 Initialization
6390 ***********************************************************************/
6391
6392 char *terminal_type;
6393
6394 /* Initialization done when Emacs fork is started, before doing stty.
6395 Determine terminal type and set terminal_driver. Then invoke its
6396 decoding routine to set up variables in the terminal package. */
6397
6398 void
6399 init_display ()
6400 {
6401 #ifdef HAVE_X_WINDOWS
6402 extern int display_arg;
6403 #endif
6404
6405 /* Construct the space glyph. */
6406 space_glyph.type = CHAR_GLYPH;
6407 SET_CHAR_GLYPH_FROM_GLYPH (space_glyph, ' ');
6408 space_glyph.charpos = -1;
6409
6410 meta_key = 0;
6411 inverse_video = 0;
6412 cursor_in_echo_area = 0;
6413 terminal_type = (char *) 0;
6414
6415 /* Now is the time to initialize this; it's used by init_sys_modes
6416 during startup. */
6417 Vwindow_system = Qnil;
6418
6419 /* If the user wants to use a window system, we shouldn't bother
6420 initializing the terminal. This is especially important when the
6421 terminal is so dumb that emacs gives up before and doesn't bother
6422 using the window system.
6423
6424 If the DISPLAY environment variable is set and nonempty,
6425 try to use X, and die with an error message if that doesn't work. */
6426
6427 #ifdef HAVE_X_WINDOWS
6428 if (! display_arg)
6429 {
6430 char *display;
6431 #ifdef VMS
6432 display = getenv ("DECW$DISPLAY");
6433 #else
6434 display = getenv ("DISPLAY");
6435 #endif
6436
6437 display_arg = (display != 0 && *display != 0);
6438 }
6439
6440 if (!inhibit_window_system && display_arg
6441 #ifndef CANNOT_DUMP
6442 && initialized
6443 #endif
6444 )
6445 {
6446 Vwindow_system = intern ("x");
6447 #ifdef HAVE_X11
6448 Vwindow_system_version = make_number (11);
6449 #else
6450 Vwindow_system_version = make_number (10);
6451 #endif
6452 #if defined (GNU_LINUX) && defined (HAVE_LIBNCURSES)
6453 /* In some versions of ncurses,
6454 tputs crashes if we have not called tgetent.
6455 So call tgetent. */
6456 { char b[2044]; tgetent (b, "xterm");}
6457 #endif
6458 adjust_frame_glyphs_initially ();
6459 return;
6460 }
6461 #endif /* HAVE_X_WINDOWS */
6462
6463 #ifdef HAVE_NTGUI
6464 if (!inhibit_window_system)
6465 {
6466 Vwindow_system = intern ("w32");
6467 Vwindow_system_version = make_number (1);
6468 adjust_frame_glyphs_initially ();
6469 return;
6470 }
6471 #endif /* HAVE_NTGUI */
6472
6473 #ifdef MAC_OS
6474 if (!inhibit_window_system)
6475 {
6476 Vwindow_system = intern ("mac");
6477 Vwindow_system_version = make_number (1);
6478 adjust_frame_glyphs_initially ();
6479 return;
6480 }
6481 #endif /* MAC_OS */
6482
6483 /* If no window system has been specified, try to use the terminal. */
6484 if (! isatty (0))
6485 {
6486 fatal ("standard input is not a tty");
6487 exit (1);
6488 }
6489
6490 /* Look at the TERM variable. */
6491 terminal_type = (char *) getenv ("TERM");
6492 if (!terminal_type)
6493 {
6494 #ifdef VMS
6495 fprintf (stderr, "Please specify your terminal type.\n\
6496 For types defined in VMS, use set term /device=TYPE.\n\
6497 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
6498 \(The quotation marks are necessary since terminal types are lower case.)\n");
6499 #else
6500 fprintf (stderr, "Please set the environment variable TERM; see tset(1).\n");
6501 #endif
6502 exit (1);
6503 }
6504
6505 #ifdef VMS
6506 /* VMS DCL tends to up-case things, so down-case term type.
6507 Hardly any uppercase letters in terminal types; should be none. */
6508 {
6509 char *new = (char *) xmalloc (strlen (terminal_type) + 1);
6510 char *p;
6511
6512 strcpy (new, terminal_type);
6513
6514 for (p = new; *p; p++)
6515 if (isupper (*p))
6516 *p = tolower (*p);
6517
6518 terminal_type = new;
6519 }
6520 #endif /* VMS */
6521
6522 term_init (terminal_type);
6523
6524 {
6525 struct frame *sf = SELECTED_FRAME ();
6526 int width = FRAME_WINDOW_WIDTH (sf);
6527 int height = FRAME_HEIGHT (sf);
6528
6529 unsigned int total_glyphs = height * (width + 2) * sizeof (struct glyph);
6530
6531 /* If these sizes are so big they cause overflow, just ignore the
6532 change. It's not clear what better we could do. */
6533 if (total_glyphs / sizeof (struct glyph) / height != width + 2)
6534 fatal ("screen size %dx%d too big", width, height);
6535 }
6536
6537 adjust_frame_glyphs_initially ();
6538 calculate_costs (XFRAME (selected_frame));
6539
6540 #ifdef SIGWINCH
6541 #ifndef CANNOT_DUMP
6542 if (initialized)
6543 #endif /* CANNOT_DUMP */
6544 signal (SIGWINCH, window_change_signal);
6545 #endif /* SIGWINCH */
6546
6547 /* Set up faces of the initial terminal frame of a dumped Emacs. */
6548 if (initialized
6549 && !noninteractive
6550 #ifdef MSDOS
6551 /* The MSDOS terminal turns on its ``window system'' relatively
6552 late into the startup, so we cannot do the frame faces'
6553 initialization just yet. It will be done later by pc-win.el
6554 and internal_terminal_init. */
6555 && (strcmp (terminal_type, "internal") != 0 || inhibit_window_system)
6556 #endif
6557 && NILP (Vwindow_system))
6558 {
6559 /* For the initial frame, we don't have any way of knowing what
6560 are the foreground and background colors of the terminal. */
6561 struct frame *sf = SELECTED_FRAME();
6562
6563 FRAME_FOREGROUND_PIXEL (sf) = FACE_TTY_DEFAULT_FG_COLOR;
6564 FRAME_BACKGROUND_PIXEL (sf) = FACE_TTY_DEFAULT_BG_COLOR;
6565 call0 (intern ("tty-set-up-initial-frame-faces"));
6566 }
6567 }
6568
6569
6570 \f
6571 /***********************************************************************
6572 Blinking cursor
6573 ***********************************************************************/
6574
6575 DEFUN ("internal-show-cursor", Finternal_show_cursor,
6576 Sinternal_show_cursor, 2, 2, 0,
6577 doc: /* Set the cursor-visibility flag of WINDOW to SHOW.
6578 WINDOW nil means use the selected window. SHOW non-nil means
6579 show a cursor in WINDOW in the next redisplay. SHOW nil means
6580 don't show a cursor. */)
6581 (window, show)
6582 Lisp_Object window, show;
6583 {
6584 /* Don't change cursor state while redisplaying. This could confuse
6585 output routines. */
6586 if (!redisplaying_p)
6587 {
6588 if (NILP (window))
6589 window = selected_window;
6590 else
6591 CHECK_WINDOW (window);
6592
6593 XWINDOW (window)->cursor_off_p = NILP (show);
6594 }
6595
6596 return Qnil;
6597 }
6598
6599
6600 DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p,
6601 Sinternal_show_cursor_p, 0, 1, 0,
6602 doc: /* Value is non-nil if next redisplay will display a cursor in WINDOW.
6603 WINDOW nil or omitted means report on the selected window. */)
6604 (window)
6605 Lisp_Object window;
6606 {
6607 struct window *w;
6608
6609 if (NILP (window))
6610 window = selected_window;
6611 else
6612 CHECK_WINDOW (window);
6613
6614 w = XWINDOW (window);
6615 return w->cursor_off_p ? Qnil : Qt;
6616 }
6617
6618 \f
6619 /***********************************************************************
6620 Initialization
6621 ***********************************************************************/
6622
6623 void
6624 syms_of_display ()
6625 {
6626 defsubr (&Sredraw_frame);
6627 defsubr (&Sredraw_display);
6628 defsubr (&Sframe_or_buffer_changed_p);
6629 defsubr (&Sopen_termscript);
6630 defsubr (&Sding);
6631 defsubr (&Ssit_for);
6632 defsubr (&Ssleep_for);
6633 defsubr (&Ssend_string_to_terminal);
6634 defsubr (&Sinternal_show_cursor);
6635 defsubr (&Sinternal_show_cursor_p);
6636
6637 #if GLYPH_DEBUG
6638 defsubr (&Sdump_redisplay_history);
6639 #endif
6640
6641 frame_and_buffer_state = Fmake_vector (make_number (20), Qlambda);
6642 staticpro (&frame_and_buffer_state);
6643
6644 Qdisplay_table = intern ("display-table");
6645 staticpro (&Qdisplay_table);
6646 Qredisplay_dont_pause = intern ("redisplay-dont-pause");
6647 staticpro (&Qredisplay_dont_pause);
6648
6649 DEFVAR_INT ("baud-rate", &baud_rate,
6650 doc: /* *The output baud rate of the terminal.
6651 On most systems, changing this value will affect the amount of padding
6652 and the other strategic decisions made during redisplay. */);
6653
6654 DEFVAR_BOOL ("inverse-video", &inverse_video,
6655 doc: /* *Non-nil means invert the entire frame display.
6656 This means everything is in inverse video which otherwise would not be. */);
6657
6658 DEFVAR_BOOL ("visible-bell", &visible_bell,
6659 doc: /* *Non-nil means try to flash the frame to represent a bell.
6660
6661 See also `ring-bell-function'. */);
6662
6663 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter,
6664 doc: /* *Non-nil means no need to redraw entire frame after suspending.
6665 A non-nil value is useful if the terminal can automatically preserve
6666 Emacs's frame display when you reenter Emacs.
6667 It is up to you to set this variable if your terminal can do that. */);
6668
6669 DEFVAR_LISP ("window-system", &Vwindow_system,
6670 doc: /* Name of window system that Emacs is displaying through.
6671 The value is a symbol--for instance, `x' for X windows.
6672 The value is nil if Emacs is using a text-only terminal. */);
6673
6674 DEFVAR_LISP ("window-system-version", &Vwindow_system_version,
6675 doc: /* The version number of the window system in use.
6676 For X windows, this is 10 or 11. */);
6677
6678 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area,
6679 doc: /* Non-nil means put cursor in minibuffer, at end of any message there. */);
6680
6681 DEFVAR_LISP ("glyph-table", &Vglyph_table,
6682 doc: /* Table defining how to output a glyph code to the frame.
6683 If not nil, this is a vector indexed by glyph code to define the glyph.
6684 Each element can be:
6685 integer: a glyph code which this glyph is an alias for.
6686 string: output this glyph using that string (not impl. in X windows).
6687 nil: this glyph mod 524288 is the code of a character to output,
6688 and this glyph / 524288 is the face number (see `face-id') to use
6689 while outputting it. */);
6690 Vglyph_table = Qnil;
6691
6692 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table,
6693 doc: /* Display table to use for buffers that specify none.
6694 See `buffer-display-table' for more information. */);
6695 Vstandard_display_table = Qnil;
6696
6697 DEFVAR_BOOL ("redisplay-dont-pause", &redisplay_dont_pause,
6698 doc: /* *Non-nil means update isn't paused when input is detected. */);
6699 redisplay_dont_pause = 0;
6700
6701 /* Initialize `window-system', unless init_display already decided it. */
6702 #ifdef CANNOT_DUMP
6703 if (noninteractive)
6704 #endif
6705 {
6706 Vwindow_system = Qnil;
6707 Vwindow_system_version = Qnil;
6708 }
6709 }