1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985, 1986, 1987, 1988, 1993 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
30 #include "termhooks.h"
32 #include "dispextern.h"
39 #include "intervals.h"
46 #endif /* HAVE_X_WINDOWS */
48 #define max(a, b) ((a) > (b) ? (a) : (b))
49 #define min(a, b) ((a) < (b) ? (a) : (b))
51 #ifndef PENDING_OUTPUT_COUNT
52 /* Get number of chars of output now in the buffer of a stdio stream.
53 This ought to be built in in stdio, but it isn't.
54 Some s- files override this because their stdio internals differ. */
55 #ifdef __GNU_LIBRARY__
56 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
58 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
62 /* Nonzero upon entry to redisplay means do not assume anything about
63 current contents of actual terminal frame; clear and redraw it. */
67 /* Nonzero means last display completed. Zero means it was preempted. */
69 int display_completed
;
71 /* Lisp variable visible-bell; enables use of screen-flash
72 instead of audible bell. */
76 /* Invert the color of the whole frame, at a low level. */
80 /* Line speed of the terminal. */
84 /* nil or a symbol naming the window system under which emacs is
85 running ('x is the only current possibility). */
87 Lisp_Object Vwindow_system
;
89 /* Version number of X windows: 10, 11 or nil. */
90 Lisp_Object Vwindow_system_version
;
92 /* Vector of glyph definitions. Indexed by glyph number,
93 the contents are a string which is how to output the glyph.
95 If Vglyph_table is nil, a glyph is output by using its low 8 bits
96 as a character code. */
98 Lisp_Object Vglyph_table
;
100 /* Display table to use for vectors that don't specify their own. */
102 Lisp_Object Vstandard_display_table
;
104 /* Nonzero means reading single-character input with prompt
105 so put cursor on minibuffer after the prompt.
106 positive means at end of text in echo area;
107 negative means at beginning of line. */
108 int cursor_in_echo_area
;
110 /* The currently selected frame.
111 In a single-frame version, this variable always remains 0. */
113 FRAME_PTR selected_frame
;
115 /* A frame which is not just a minibuffer, or 0 if there are no such
116 frames. This is usually the most recent such frame that was
117 selected. In a single-frame version, this variable always remains 0. */
118 FRAME_PTR last_nonminibuf_frame
;
120 /* In a single-frame version, the information that would otherwise
121 exist inside frame objects lives in the following structure instead.
123 NOTE: the_only_frame is not checked for garbage collection; don't
124 store collectible objects in any of its fields!
126 You're not/The only frame in town/... */
129 struct frame the_only_frame
;
132 /* This is a vector, made larger whenever it isn't large enough,
133 which is used inside `update_frame' to hold the old contents
134 of the FRAME_PHYS_LINES of the frame being updated. */
135 struct frame_glyphs
**ophys_lines
;
136 /* Length of vector currently allocated. */
137 int ophys_lines_length
;
139 FILE *termscript
; /* Stdio stream being used for copy of all output. */
141 struct cm Wcm
; /* Structure for info on cursor positioning */
143 extern short ospeed
; /* Output speed (from sg_ospeed) */
145 int delayed_size_change
; /* 1 means SIGWINCH happened when not safe. */
149 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
150 "Clear frame FRAME and output again what is supposed to appear on it.")
156 CHECK_LIVE_FRAME (frame
, 0);
159 /* set_terminal_modes (); */
161 clear_frame_records (f
);
164 windows_or_buffers_changed
++;
165 /* Mark all windows as INaccurate,
166 so that every window will have its redisplay done. */
167 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
176 XSET (frame
, Lisp_Frame
, f
);
177 Fredraw_frame (frame
);
182 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, "",
183 "Clear frame FRAME and output again what is supposed to appear on it.")
188 set_terminal_modes ();
192 clear_frame_records (0);
193 windows_or_buffers_changed
++;
194 /* Mark all windows as INaccurate,
195 so that every window will have its redisplay done. */
196 mark_window_display_accurate (FRAME_ROOT_WINDOW (0), 0);
202 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
203 "Clear and redisplay all visible frames.")
206 Lisp_Object tail
, frame
;
208 FOR_EACH_FRAME (tail
, frame
)
209 if (FRAME_VISIBLE_P (XFRAME (frame
)))
210 Fredraw_frame (frame
);
215 /* This is used when frame_garbaged is set.
216 Redraw the individual frames marked as garbaged. */
219 redraw_garbaged_frames ()
221 Lisp_Object tail
, frame
;
223 FOR_EACH_FRAME (tail
, frame
)
224 if (FRAME_VISIBLE_P (XFRAME (frame
))
225 && FRAME_GARBAGED_P (XFRAME (frame
)))
226 Fredraw_frame (frame
);
230 static struct frame_glyphs
*
231 make_frame_glyphs (frame
, empty
)
232 register FRAME_PTR frame
;
236 register width
= FRAME_WIDTH (frame
);
237 register height
= FRAME_HEIGHT (frame
);
238 register struct frame_glyphs
*new =
239 (struct frame_glyphs
*) xmalloc (sizeof (struct frame_glyphs
));
241 SET_GLYPHS_FRAME (new, frame
);
242 new->height
= height
;
244 new->used
= (int *) xmalloc (height
* sizeof (int));
245 new->glyphs
= (GLYPH
**) xmalloc (height
* sizeof (GLYPH
*));
246 new->highlight
= (char *) xmalloc (height
* sizeof (char));
247 new->enable
= (char *) xmalloc (height
* sizeof (char));
248 bzero (new->enable
, height
* sizeof (char));
249 new->bufp
= (int *) xmalloc (height
* sizeof (int));
251 #ifdef HAVE_X_WINDOWS
252 if (FRAME_X_P (frame
))
254 new->top_left_x
= (short *) xmalloc (height
* sizeof (short));
255 new->top_left_y
= (short *) xmalloc (height
* sizeof (short));
256 new->pix_width
= (short *) xmalloc (height
* sizeof (short));
257 new->pix_height
= (short *) xmalloc (height
* sizeof (short));
258 new->max_ascent
= (short *) xmalloc (height
* sizeof (short));
264 /* Make the buffer used by decode_mode_spec. This buffer is also
265 used as temporary storage when updating the frame. See scroll.c. */
266 unsigned int total_glyphs
= (width
+ 2) * sizeof (GLYPH
);
268 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
269 bzero (new->total_contents
, total_glyphs
);
273 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (GLYPH
);
275 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
276 bzero (new->total_contents
, total_glyphs
);
277 for (i
= 0; i
< height
; i
++)
278 new->glyphs
[i
] = new->total_contents
+ i
* (width
+ 2) + 1;
285 free_frame_glyphs (frame
, glyphs
)
287 struct frame_glyphs
*glyphs
;
289 if (glyphs
->total_contents
)
290 xfree (glyphs
->total_contents
);
292 xfree (glyphs
->used
);
293 xfree (glyphs
->glyphs
);
294 xfree (glyphs
->highlight
);
295 xfree (glyphs
->enable
);
296 xfree (glyphs
->bufp
);
298 #ifdef HAVE_X_WINDOWS
299 if (FRAME_X_P (frame
))
301 xfree (glyphs
->top_left_x
);
302 xfree (glyphs
->top_left_y
);
303 xfree (glyphs
->pix_width
);
304 xfree (glyphs
->pix_height
);
305 xfree (glyphs
->max_ascent
);
313 remake_frame_glyphs (frame
)
316 if (FRAME_CURRENT_GLYPHS (frame
))
317 free_frame_glyphs (frame
, FRAME_CURRENT_GLYPHS (frame
));
318 if (FRAME_DESIRED_GLYPHS (frame
))
319 free_frame_glyphs (frame
, FRAME_DESIRED_GLYPHS (frame
));
320 if (FRAME_TEMP_GLYPHS (frame
))
321 free_frame_glyphs (frame
, FRAME_TEMP_GLYPHS (frame
));
323 if (FRAME_MESSAGE_BUF (frame
))
325 /* Reallocate the frame's message buffer; remember that
326 echo_area_glyphs may be pointing here. */
327 char *old_message_buf
= FRAME_MESSAGE_BUF (frame
);
329 FRAME_MESSAGE_BUF (frame
)
330 = (char *) xrealloc (FRAME_MESSAGE_BUF (frame
),
331 FRAME_WIDTH (frame
) + 1);
333 if (echo_area_glyphs
== old_message_buf
)
334 echo_area_glyphs
= FRAME_MESSAGE_BUF (frame
);
335 if (previous_echo_glyphs
== old_message_buf
)
336 previous_echo_glyphs
= FRAME_MESSAGE_BUF (frame
);
339 FRAME_MESSAGE_BUF (frame
)
340 = (char *) xmalloc (FRAME_WIDTH (frame
) + 1);
342 FRAME_CURRENT_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
343 FRAME_DESIRED_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
344 FRAME_TEMP_GLYPHS (frame
) = make_frame_glyphs (frame
, 1);
345 SET_FRAME_GARBAGED (frame
);
348 /* Return the hash code of contents of line VPOS in frame-matrix M. */
351 line_hash_code (m
, vpos
)
352 register struct frame_glyphs
*m
;
355 register GLYPH
*body
, *end
;
358 if (!m
->enable
[vpos
])
361 /* Give all highlighted lines the same hash code
362 so as to encourage scrolling to leave them in place. */
363 if (m
->highlight
[vpos
])
366 body
= m
->glyphs
[vpos
];
368 if (must_write_spaces
)
375 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
- SPACEGLYPH
;
384 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
;
392 /* Return number of characters in line in M at vpos VPOS,
393 except don't count leading and trailing spaces
394 unless the terminal requires those to be explicitly output. */
397 line_draw_cost (m
, vpos
)
398 struct frame_glyphs
*m
;
401 register GLYPH
*beg
= m
->glyphs
[vpos
];
402 register GLYPH
*end
= m
->glyphs
[vpos
] + m
->used
[vpos
];
404 register int tlen
= GLYPH_TABLE_LENGTH
;
405 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
407 /* Ignore trailing and leading spaces if we can. */
408 if (!must_write_spaces
)
410 while ((end
!= beg
) && (*end
== SPACEGLYPH
))
413 return (0); /* All blank line. */
415 while (*beg
== SPACEGLYPH
)
419 /* If we don't have a glyph-table, each glyph is one character,
420 so return the number of glyphs. */
424 /* Otherwise, scan the glyphs and accumulate their total size in I. */
426 while ((beg
<= end
) && *beg
)
428 register GLYPH g
= *beg
++;
430 if (GLYPH_SIMPLE_P (tbase
, tlen
, g
))
433 i
+= GLYPH_LENGTH (tbase
, g
);
438 /* The functions on this page are the interface from xdisp.c to redisplay.
440 The only other interface into redisplay is through setting
441 FRAME_CURSOR_X (frame) and FRAME_CURSOR_Y (frame)
442 and SET_FRAME_GARBAGED (frame). */
444 /* cancel_line eliminates any request to display a line at position `vpos' */
446 cancel_line (vpos
, frame
)
448 register FRAME_PTR frame
;
450 FRAME_DESIRED_GLYPHS (frame
)->enable
[vpos
] = 0;
453 clear_frame_records (frame
)
454 register FRAME_PTR frame
;
456 bzero (FRAME_CURRENT_GLYPHS (frame
)->enable
, FRAME_HEIGHT (frame
));
459 /* Prepare to display on line VPOS starting at HPOS within it. */
462 get_display_line (frame
, vpos
, hpos
)
463 register FRAME_PTR frame
;
467 register struct frame_glyphs
*glyphs
;
468 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (frame
);
474 if ((desired_glyphs
->enable
[vpos
]) && desired_glyphs
->used
[vpos
] > hpos
)
477 if (! desired_glyphs
->enable
[vpos
])
479 desired_glyphs
->used
[vpos
] = 0;
480 desired_glyphs
->highlight
[vpos
] = 0;
481 desired_glyphs
->enable
[vpos
] = 1;
484 if (hpos
> desired_glyphs
->used
[vpos
])
486 GLYPH
*g
= desired_glyphs
->glyphs
[vpos
] + desired_glyphs
->used
[vpos
];
487 GLYPH
*end
= desired_glyphs
->glyphs
[vpos
] + hpos
;
489 desired_glyphs
->used
[vpos
] = hpos
;
495 /* Like bcopy except never gets confused by overlap. */
498 safe_bcopy (from
, to
, size
)
502 if (size
<= 0 || from
== to
)
505 /* If the source and destination don't overlap, then bcopy can
506 handle it. If they do overlap, but the destination is lower in
507 memory than the source, we'll assume bcopy can handle that. */
508 if (to
< from
|| from
+ size
<= to
)
509 bcopy (from
, to
, size
);
511 /* Otherwise, we'll copy from the end. */
514 register char *endf
= from
+ size
;
515 register char *endt
= to
+ size
;
517 /* If TO - FROM is large, then we should break the copy into
518 nonoverlapping chunks of TO - FROM bytes each. However, if
519 TO - FROM is small, then the bcopy function call overhead
520 makes this not worth it. The crossover point could be about
521 anywhere. Since I don't think the obvious copy loop is too
522 bad, I'm trying to err in its favor. */
527 while (endf
!= from
);
539 bcopy (endf
, endt
, to
- from
);
542 /* If SIZE wasn't a multiple of TO - FROM, there will be a
543 little left over. The amount left over is
544 (endt + (to - from)) - to, which is endt - from. */
545 bcopy (from
, to
, endt
- from
);
550 /* Rotate a vector of SIZE bytes right, by DISTANCE bytes.
551 DISTANCE may be negative. */
554 rotate_vector (vector
, size
, distance
)
559 char *temp
= (char *) alloca (size
);
564 bcopy (vector
, temp
+ distance
, size
- distance
);
565 bcopy (vector
+ size
- distance
, temp
, distance
);
566 bcopy (temp
, vector
, size
);
569 /* Scroll lines from vpos FROM up to but not including vpos END
570 down by AMOUNT lines (AMOUNT may be negative).
571 Returns nonzero if done, zero if terminal cannot scroll them. */
574 scroll_frame_lines (frame
, from
, end
, amount
)
575 register FRAME_PTR frame
;
576 int from
, end
, amount
;
579 register struct frame_glyphs
*current_frame
580 = FRAME_CURRENT_GLYPHS (frame
);
582 if (!line_ins_del_ok
)
590 update_begin (frame
);
591 set_terminal_window (end
+ amount
);
592 if (!scroll_region_ok
)
593 ins_del_lines (end
, -amount
);
594 ins_del_lines (from
, amount
);
595 set_terminal_window (0);
597 rotate_vector (current_frame
->glyphs
+ from
,
598 sizeof (GLYPH
*) * (end
+ amount
- from
),
599 amount
* sizeof (GLYPH
*));
601 safe_bcopy (current_frame
->used
+ from
,
602 current_frame
->used
+ from
+ amount
,
603 (end
- from
) * sizeof current_frame
->used
[0]);
605 safe_bcopy (current_frame
->highlight
+ from
,
606 current_frame
->highlight
+ from
+ amount
,
607 (end
- from
) * sizeof current_frame
->highlight
[0]);
609 safe_bcopy (current_frame
->enable
+ from
,
610 current_frame
->enable
+ from
+ amount
,
611 (end
- from
) * sizeof current_frame
->enable
[0]);
613 /* Mark the lines made empty by scrolling as enabled, empty and
615 bzero (current_frame
->used
+ from
,
616 amount
* sizeof current_frame
->used
[0]);
617 bzero (current_frame
->highlight
+ from
,
618 amount
* sizeof current_frame
->highlight
[0]);
619 for (i
= from
; i
< from
+ amount
; i
++)
621 current_frame
->glyphs
[i
][0] = '\0';
622 current_frame
->enable
[i
] = 1;
625 safe_bcopy (current_frame
->bufp
+ from
,
626 current_frame
->bufp
+ from
+ amount
,
627 (end
- from
) * sizeof current_frame
->bufp
[0]);
629 #ifdef HAVE_X_WINDOWS
630 if (FRAME_X_P (frame
))
632 safe_bcopy (current_frame
->top_left_x
+ from
,
633 current_frame
->top_left_x
+ from
+ amount
,
634 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
636 safe_bcopy (current_frame
->top_left_y
+ from
,
637 current_frame
->top_left_y
+ from
+ amount
,
638 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
640 safe_bcopy (current_frame
->pix_width
+ from
,
641 current_frame
->pix_width
+ from
+ amount
,
642 (end
- from
) * sizeof current_frame
->pix_width
[0]);
644 safe_bcopy (current_frame
->pix_height
+ from
,
645 current_frame
->pix_height
+ from
+ amount
,
646 (end
- from
) * sizeof current_frame
->pix_height
[0]);
648 safe_bcopy (current_frame
->max_ascent
+ from
,
649 current_frame
->max_ascent
+ from
+ amount
,
650 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
652 #endif /* HAVE_X_WINDOWS */
658 update_begin (frame
);
659 set_terminal_window (end
);
660 ins_del_lines (from
+ amount
, amount
);
661 if (!scroll_region_ok
)
662 ins_del_lines (end
+ amount
, -amount
);
663 set_terminal_window (0);
665 rotate_vector (current_frame
->glyphs
+ from
+ amount
,
666 sizeof (GLYPH
*) * (end
- from
- amount
),
667 amount
* sizeof (GLYPH
*));
669 safe_bcopy (current_frame
->used
+ from
,
670 current_frame
->used
+ from
+ amount
,
671 (end
- from
) * sizeof current_frame
->used
[0]);
673 safe_bcopy (current_frame
->highlight
+ from
,
674 current_frame
->highlight
+ from
+ amount
,
675 (end
- from
) * sizeof current_frame
->highlight
[0]);
677 safe_bcopy (current_frame
->enable
+ from
,
678 current_frame
->enable
+ from
+ amount
,
679 (end
- from
) * sizeof current_frame
->enable
[0]);
681 /* Mark the lines made empty by scrolling as enabled, empty and
683 bzero (current_frame
->used
+ end
+ amount
,
684 - amount
* sizeof current_frame
->used
[0]);
685 bzero (current_frame
->highlight
+ end
+ amount
,
686 - amount
* sizeof current_frame
->highlight
[0]);
687 for (i
= end
+ amount
; i
< end
; i
++)
689 current_frame
->glyphs
[i
][0] = '\0';
690 current_frame
->enable
[i
] = 1;
693 safe_bcopy (current_frame
->bufp
+ from
,
694 current_frame
->bufp
+ from
+ amount
,
695 (end
- from
) * sizeof current_frame
->bufp
[0]);
697 #ifdef HAVE_X_WINDOWS
698 if (FRAME_X_P (frame
))
700 safe_bcopy (current_frame
->top_left_x
+ from
,
701 current_frame
->top_left_x
+ from
+ amount
,
702 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
704 safe_bcopy (current_frame
->top_left_y
+ from
,
705 current_frame
->top_left_y
+ from
+ amount
,
706 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
708 safe_bcopy (current_frame
->pix_width
+ from
,
709 current_frame
->pix_width
+ from
+ amount
,
710 (end
- from
) * sizeof current_frame
->pix_width
[0]);
712 safe_bcopy (current_frame
->pix_height
+ from
,
713 current_frame
->pix_height
+ from
+ amount
,
714 (end
- from
) * sizeof current_frame
->pix_height
[0]);
716 safe_bcopy (current_frame
->max_ascent
+ from
,
717 current_frame
->max_ascent
+ from
+ amount
,
718 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
720 #endif /* HAVE_X_WINDOWS */
727 /* After updating a window W that isn't the full frame wide,
728 copy all the columns that W does not occupy
729 into the FRAME_DESIRED_GLYPHS (frame) from the FRAME_PHYS_GLYPHS (frame)
730 so that update_frame will not change those columns. */
732 preserve_other_columns (w
)
736 register struct frame_glyphs
*current_frame
, *desired_frame
;
737 register FRAME_PTR frame
= XFRAME (w
->frame
);
738 int start
= XFASTINT (w
->left
);
739 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
740 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
742 current_frame
= FRAME_CURRENT_GLYPHS (frame
);
743 desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
745 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
747 if (current_frame
->enable
[vpos
] && desired_frame
->enable
[vpos
])
753 bcopy (current_frame
->glyphs
[vpos
],
754 desired_frame
->glyphs
[vpos
],
755 start
* sizeof (current_frame
->glyphs
[vpos
]));
756 len
= min (start
, current_frame
->used
[vpos
]);
757 if (desired_frame
->used
[vpos
] < len
)
758 desired_frame
->used
[vpos
] = len
;
760 if (current_frame
->used
[vpos
] > end
761 && desired_frame
->used
[vpos
] < current_frame
->used
[vpos
])
763 while (desired_frame
->used
[vpos
] < end
)
764 desired_frame
->glyphs
[vpos
][desired_frame
->used
[vpos
]++]
766 bcopy (current_frame
->glyphs
[vpos
] + end
,
767 desired_frame
->glyphs
[vpos
] + end
,
768 ((current_frame
->used
[vpos
] - end
)
769 * sizeof (current_frame
->glyphs
[vpos
])));
770 desired_frame
->used
[vpos
] = current_frame
->used
[vpos
];
778 /* If window w does not need to be updated and isn't the full frame wide,
779 copy all the columns that w does occupy
780 into the FRAME_DESIRED_LINES (frame) from the FRAME_PHYS_LINES (frame)
781 so that update_frame will not change those columns.
783 Have not been able to figure out how to use this correctly. */
785 preserve_my_columns (w
)
788 register int vpos
, fin
;
789 register struct frame_glyphs
*l1
, *l2
;
790 register FRAME_PTR frame
= XFRAME (w
->frame
);
791 int start
= XFASTINT (w
->left
);
792 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
793 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
795 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
797 if ((l1
= FRAME_DESIRED_GLYPHS (frame
)->glyphs
[vpos
+ 1])
798 && (l2
= FRAME_PHYS_GLYPHS (frame
)->glyphs
[vpos
+ 1]))
800 if (l2
->length
> start
&& l1
->length
< l2
->length
)
803 if (fin
> end
) fin
= end
;
804 while (l1
->length
< start
)
805 l1
->body
[l1
->length
++] = ' ';
806 bcopy (l2
->body
+ start
, l1
->body
+ start
, fin
- start
);
815 /* On discovering that the redisplay for a window was no good,
816 cancel the columns of that window, so that when the window is
817 displayed over again get_display_line will not complain. */
819 cancel_my_columns (w
)
823 register struct frame_glyphs
*desired_glyphs
=
824 FRAME_DESIRED_GLYPHS (XFRAME (w
->frame
));
825 register int start
= XFASTINT (w
->left
);
826 register int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
828 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
829 if (desired_glyphs
->enable
[vpos
]
830 && desired_glyphs
->used
[vpos
] >= start
)
831 desired_glyphs
->used
[vpos
] = start
;
834 /* These functions try to perform directly and immediately on the frame
835 the necessary output for one change in the buffer.
836 They may return 0 meaning nothing was done if anything is difficult,
837 or 1 meaning the output was performed properly.
838 They assume that the frame was up to date before the buffer
839 change being displayed. They make various other assumptions too;
840 see command_loop_1 where these are called. */
843 direct_output_for_insert (g
)
846 register FRAME_PTR frame
= selected_frame
;
847 register struct frame_glyphs
*current_frame
848 = FRAME_CURRENT_GLYPHS (frame
);
850 #ifndef COMPILER_REGISTER_BUG
852 #endif /* COMPILER_REGISTER_BUG */
853 struct window
*w
= XWINDOW (selected_window
);
854 #ifndef COMPILER_REGISTER_BUG
856 #endif /* COMPILER_REGISTER_BUG */
857 int hpos
= FRAME_CURSOR_X (frame
);
858 #ifndef COMPILER_REGISTER_BUG
860 #endif /* COMPILER_REGISTER_BUG */
861 int vpos
= FRAME_CURSOR_Y (frame
);
863 /* Give up if about to continue line. */
864 if (hpos
>= XFASTINT (w
->left
) + window_internal_width (w
) - 1
866 /* Avoid losing if cursor is in invisible text off left margin */
867 || (XINT (w
->hscroll
) && hpos
== XFASTINT (w
->left
))
869 /* Give up if cursor outside window (in minibuf, probably) */
870 || cursor_in_echo_area
871 || FRAME_CURSOR_Y (frame
) < XFASTINT (w
->top
)
872 || FRAME_CURSOR_Y (frame
) >= XFASTINT (w
->top
) + XFASTINT (w
->height
)
874 /* Give up if cursor not really at FRAME_CURSOR_X, FRAME_CURSOR_Y */
875 || !display_completed
877 /* Give up if buffer appears in two places. */
880 #ifdef USE_TEXT_PROPERTIES
881 /* Intervals have already been adjusted, point is after the
882 character that was just inserted. */
883 /* Give up if character has is invisible. */
884 /* Give up if character has a face property.
885 At the moment we only lose at end of line or end of buffer
886 and only with faces that have some background */
887 /* Instead of wasting time, give up if character has any text properties */
888 || ! NILP (Ftext_properties_at (XFASTINT (point
- 1), Qnil
))
891 /* Give up if w is minibuffer and a message is being displayed there */
892 || (MINI_WINDOW_P (w
) && echo_area_glyphs
))
896 #ifdef HAVE_X_WINDOWS
898 int face
= compute_char_face (frame
, w
, point
- 1, -1, -1, &dummy
, point
);
903 current_frame
->glyphs
[vpos
][hpos
] = MAKE_GLYPH (g
, face
);
905 unchanged_modified
= MODIFF
;
906 beg_unchanged
= GPT
- BEG
;
907 XFASTINT (w
->last_point
) = point
;
908 XFASTINT (w
->last_point_x
) = hpos
;
909 XFASTINT (w
->last_modified
) = MODIFF
;
911 reassert_line_highlight (0, vpos
);
912 write_glyphs (¤t_frame
->glyphs
[vpos
][hpos
], 1);
914 ++FRAME_CURSOR_X (frame
);
915 if (hpos
== current_frame
->used
[vpos
])
917 current_frame
->used
[vpos
] = hpos
+ 1;
918 current_frame
->glyphs
[vpos
][hpos
+ 1] = 0;
925 direct_output_forward_char (n
)
928 register FRAME_PTR frame
= selected_frame
;
929 register struct window
*w
= XWINDOW (selected_window
);
931 int hpos
= FRAME_CURSOR_X (frame
);
933 /* Give up if in truncated text at end of line. */
934 if (hpos
>= XFASTINT (w
->left
) + window_internal_width (w
) - 1)
937 /* Avoid losing if cursor is in invisible text off left margin
938 or about to go off either side of window. */
939 if ((FRAME_CURSOR_X (frame
) == XFASTINT (w
->left
)
940 && (XINT (w
->hscroll
) || n
< 0))
942 && (FRAME_CURSOR_X (frame
) + 1 >= window_internal_width (w
) - 1))
943 || cursor_in_echo_area
)
946 /* Can't use direct output if highlighting a region. */
947 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
950 #ifdef USE_TEXT_PROPERTIES
951 /* Don't use direct output next to an invisible character
952 since we might need to do something special. */
954 XFASTINT (position
) = point
;
955 if (XFASTINT (position
) < ZV
956 && ! NILP (Fget_text_property (position
,
958 Fcurrent_buffer ())))
961 XFASTINT (position
) = point
- 1;
962 if (XFASTINT (position
) >= BEGV
963 && ! NILP (Fget_text_property (position
,
965 Fcurrent_buffer ())))
969 FRAME_CURSOR_X (frame
) += n
;
970 XFASTINT (w
->last_point_x
) = FRAME_CURSOR_X (frame
);
971 XFASTINT (w
->last_point
) = point
;
972 cursor_to (FRAME_CURSOR_Y (frame
), FRAME_CURSOR_X (frame
));
978 static void update_line ();
980 /* Update frame F based on the data in FRAME_DESIRED_GLYPHS.
981 Value is nonzero if redisplay stopped due to pending input.
982 FORCE nonzero means do not stop for pending input. */
985 update_frame (f
, force
, inhibit_hairy_id
)
988 int inhibit_hairy_id
;
990 register struct frame_glyphs
*current_frame
= FRAME_CURRENT_GLYPHS (f
);
991 register struct frame_glyphs
*desired_frame
= FRAME_DESIRED_GLYPHS (f
);
994 int preempt_count
= baud_rate
/ 2400 + 1;
995 extern input_pending
;
996 #ifdef HAVE_X_WINDOWS
997 register int downto
, leftmost
;
1000 if (preempt_count
<= 0)
1003 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1005 detect_input_pending ();
1006 if (input_pending
&& !force
)
1014 if (!line_ins_del_ok
)
1015 inhibit_hairy_id
= 1;
1017 /* See if any of the desired lines are enabled; don't compute for
1018 i/d line if just want cursor motion. */
1019 for (i
= 0; i
< FRAME_HEIGHT (f
); i
++)
1020 if (desired_frame
->enable
[i
])
1023 /* Try doing i/d line, if not yet inhibited. */
1024 if (!inhibit_hairy_id
&& i
< FRAME_HEIGHT (f
))
1025 force
|= scrolling (f
);
1027 /* Update the individual lines as needed. Do bottom line first. */
1029 if (desired_frame
->enable
[FRAME_HEIGHT (f
) - 1])
1030 update_line (f
, FRAME_HEIGHT (f
) - 1);
1032 #ifdef HAVE_X_WINDOWS
1035 leftmost
= downto
= f
->display
.x
->internal_border_width
;
1036 if (desired_frame
->enable
[0])
1038 current_frame
->top_left_x
[FRAME_HEIGHT (f
) - 1] = leftmost
;
1039 current_frame
->top_left_y
[FRAME_HEIGHT (f
) - 1]
1040 = PIXEL_HEIGHT (f
) - f
->display
.x
->internal_border_width
1041 - current_frame
->pix_height
[FRAME_HEIGHT (f
) - 1];
1042 current_frame
->top_left_x
[0] = leftmost
;
1043 current_frame
->top_left_y
[0] = downto
;
1046 #endif /* HAVE_X_WINDOWS */
1048 /* Now update the rest of the lines. */
1049 for (i
= 0; i
< FRAME_HEIGHT (f
) - 1 && (force
|| !input_pending
); i
++)
1051 if (desired_frame
->enable
[i
])
1053 if (FRAME_TERMCAP_P (f
))
1055 /* Flush out every so many lines.
1056 Also flush out if likely to have more than 1k buffered
1057 otherwise. I'm told that some telnet connections get
1058 really screwed by more than 1k output at once. */
1059 int outq
= PENDING_OUTPUT_COUNT (stdout
);
1061 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
1064 if (preempt_count
== 1)
1066 #ifdef EMACS_OUTQSIZE
1067 if (EMACS_OUTQSIZE (0, &outq
) < 0)
1068 /* Probably not a tty. Ignore the error and reset
1069 * the outq count. */
1070 outq
= PENDING_OUTPUT_COUNT (stdout
);
1073 if (baud_rate
>= outq
)
1074 sleep (outq
/ baud_rate
);
1077 if ((i
- 1) % preempt_count
== 0)
1078 detect_input_pending ();
1082 #ifdef HAVE_X_WINDOWS
1085 current_frame
->top_left_y
[i
] = downto
;
1086 current_frame
->top_left_x
[i
] = leftmost
;
1088 #endif /* HAVE_X_WINDOWS */
1091 #ifdef HAVE_X_WINDOWS
1093 downto
+= current_frame
->pix_height
[i
];
1096 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
1098 /* Now just clean up termcap drivers and set cursor, etc. */
1101 if (cursor_in_echo_area
1102 && FRAME_HAS_MINIBUF_P (f
))
1104 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
1107 if (cursor_in_echo_area
< 0)
1114 /* If the minibuffer is several lines high, find the last
1115 line that has any text on it. */
1116 row
= FRAME_HEIGHT (f
);
1120 if (current_frame
->enable
[row
])
1121 col
= current_frame
->used
[row
];
1125 while (row
> top
&& col
== 0);
1127 if (col
>= FRAME_WIDTH (f
))
1130 if (row
< FRAME_HEIGHT (f
) - 1)
1135 cursor_to (row
, col
);
1138 cursor_to (FRAME_CURSOR_Y (f
), max (min (FRAME_CURSOR_X (f
),
1139 FRAME_WIDTH (f
) - 1), 0));
1145 fflush (termscript
);
1148 /* Here if output is preempted because input is detected. */
1151 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1152 display_completed
= !pause
;
1154 bzero (desired_frame
->enable
, FRAME_HEIGHT (f
));
1158 /* Called when about to quit, to check for doing so
1159 at an improper time. */
1164 if (FRAME_DESIRED_GLYPHS (selected_frame
) == 0)
1166 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[0])
1168 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[FRAME_HEIGHT (selected_frame
) - 1])
1172 /* Decide what insert/delete line to do, and do it */
1174 extern void scrolling_1 ();
1179 int unchanged_at_top
, unchanged_at_bottom
;
1182 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1183 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1184 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1186 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
1187 register struct frame_glyphs
*current_frame
= FRAME_CURRENT_GLYPHS (frame
);
1188 register struct frame_glyphs
*desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
1190 /* Compute hash codes of all the lines.
1191 Also calculate number of changed lines,
1192 number of unchanged lines at the beginning,
1193 and number of unchanged lines at the end. */
1196 unchanged_at_top
= 0;
1197 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
1198 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
1200 /* Give up on this scrolling if some old lines are not enabled. */
1201 if (!current_frame
->enable
[i
])
1203 old_hash
[i
] = line_hash_code (current_frame
, i
);
1204 if (! desired_frame
->enable
[i
])
1205 new_hash
[i
] = old_hash
[i
];
1207 new_hash
[i
] = line_hash_code (desired_frame
, i
);
1209 if (old_hash
[i
] != new_hash
[i
])
1212 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
1214 else if (i
== unchanged_at_top
)
1216 draw_cost
[i
] = line_draw_cost (desired_frame
, i
);
1219 /* If changed lines are few, don't allow preemption, don't scroll. */
1220 if (changed_lines
< baud_rate
/ 2400
1221 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
1224 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
1225 - unchanged_at_bottom
);
1227 if (scroll_region_ok
)
1228 free_at_end_vpos
-= unchanged_at_bottom
;
1229 else if (memory_below_frame
)
1230 free_at_end_vpos
= -1;
1232 /* If large window, fast terminal and few lines in common between
1233 current frame and desired frame, don't bother with i/d calc. */
1234 if (window_size
>= 18 && baud_rate
> 2400
1236 10 * scrolling_max_lines_saved (unchanged_at_top
,
1237 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
1238 old_hash
, new_hash
, draw_cost
)))
1241 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
1242 draw_cost
+ unchanged_at_top
- 1,
1243 old_hash
+ unchanged_at_top
- 1,
1244 new_hash
+ unchanged_at_top
- 1,
1245 free_at_end_vpos
- unchanged_at_top
);
1250 /* Return the offset in its buffer of the character at location col, line
1251 in the given window. */
1253 buffer_posn_from_coords (window
, col
, line
)
1254 struct window
*window
;
1257 int window_left
= XFASTINT (window
->left
);
1259 /* The actual width of the window is window->width less one for the
1260 DISP_CONTINUE_GLYPH, and less one if it's not the rightmost
1262 int window_width
= window_internal_width (window
) - 1;
1264 int startp
= marker_position (window
->start
);
1266 /* Since compute_motion will only operate on the current buffer,
1267 we need to save the old one and restore it when we're done. */
1268 struct buffer
*old_current_buffer
= current_buffer
;
1269 struct position
*posn
;
1271 current_buffer
= XBUFFER (window
->buffer
);
1273 /* It would be nice if we could use FRAME_CURRENT_GLYPHS (XFRAME
1274 (window->frame))->bufp to avoid scanning from the very top of
1275 the window, but it isn't maintained correctly, and I'm not even
1276 sure I will keep it. */
1277 posn
= compute_motion (startp
, 0,
1278 (window
== XWINDOW (minibuf_window
) && startp
== 1
1279 ? minibuf_prompt_width
: 0),
1281 window_width
, XINT (window
->hscroll
), 0);
1283 current_buffer
= old_current_buffer
;
1285 /* compute_motion considers frame points past the end of a line
1286 to be *after* the newline, i.e. at the start of the next line.
1287 This is reasonable, but not really what we want. So if the
1288 result is on a line below LINE, back it up one character. */
1289 if (posn
->vpos
> line
)
1290 return posn
->bufpos
- 1;
1292 return posn
->bufpos
;
1299 register GLYPH
*p
= r
;
1300 while (*p
++ == SPACEGLYPH
);
1305 count_match (str1
, str2
)
1308 register GLYPH
*p1
= str1
;
1309 register GLYPH
*p2
= str2
;
1310 while (*p1
++ == *p2
++);
1311 return p1
- str1
- 1;
1314 /* Char insertion/deletion cost vector, from term.c */
1315 extern int *char_ins_del_vector
;
1317 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WIDTH((f))])
1320 update_line (frame
, vpos
)
1321 register FRAME_PTR frame
;
1324 register GLYPH
*obody
, *nbody
, *op1
, *op2
, *np1
, *temp
;
1326 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
1328 register struct frame_glyphs
*current_frame
1329 = FRAME_CURRENT_GLYPHS (frame
);
1330 register struct frame_glyphs
*desired_frame
1331 = FRAME_DESIRED_GLYPHS (frame
);
1333 if (desired_frame
->highlight
[vpos
]
1334 != (current_frame
->enable
[vpos
] && current_frame
->highlight
[vpos
]))
1336 change_line_highlight (desired_frame
->highlight
[vpos
], vpos
,
1337 (current_frame
->enable
[vpos
] ?
1338 current_frame
->used
[vpos
] : 0));
1339 current_frame
->enable
[vpos
] = 0;
1342 reassert_line_highlight (desired_frame
->highlight
[vpos
], vpos
);
1344 if (! current_frame
->enable
[vpos
])
1350 obody
= current_frame
->glyphs
[vpos
];
1351 olen
= current_frame
->used
[vpos
];
1352 if (! current_frame
->highlight
[vpos
])
1354 if (!must_write_spaces
)
1355 while (obody
[olen
- 1] == SPACEGLYPH
&& olen
> 0)
1360 /* For an inverse-video line, remember we gave it
1361 spaces all the way to the frame edge
1362 so that the reverse video extends all the way across. */
1364 while (olen
< FRAME_WIDTH (frame
) - 1)
1365 obody
[olen
++] = SPACEGLYPH
;
1369 /* One way or another, this will enable the line being updated. */
1370 current_frame
->enable
[vpos
] = 1;
1371 current_frame
->used
[vpos
] = desired_frame
->used
[vpos
];
1372 current_frame
->highlight
[vpos
] = desired_frame
->highlight
[vpos
];
1373 current_frame
->bufp
[vpos
] = desired_frame
->bufp
[vpos
];
1375 #ifdef HAVE_X_WINDOWS
1376 if (FRAME_X_P (frame
))
1378 current_frame
->pix_width
[vpos
]
1379 = current_frame
->used
[vpos
]
1380 * FONT_WIDTH (frame
->display
.x
->font
);
1381 current_frame
->pix_height
[vpos
]
1382 = FONT_HEIGHT (frame
->display
.x
->font
);
1384 #endif /* HAVE_X_WINDOWS */
1386 if (!desired_frame
->enable
[vpos
])
1392 nbody
= desired_frame
->glyphs
[vpos
];
1393 nlen
= desired_frame
->used
[vpos
];
1395 /* Pretend trailing spaces are not there at all,
1396 unless for one reason or another we must write all spaces. */
1397 if (! desired_frame
->highlight
[vpos
])
1399 if (!must_write_spaces
)
1400 /* We know that the previous character byte contains 0. */
1401 while (nbody
[nlen
- 1] == SPACEGLYPH
)
1406 /* For an inverse-video line, give it extra trailing spaces
1407 all the way to the frame edge
1408 so that the reverse video extends all the way across. */
1410 while (nlen
< FRAME_WIDTH (frame
) - 1)
1411 nbody
[nlen
++] = SPACEGLYPH
;
1414 /* If there's no i/d char, quickly do the best we can without it. */
1415 if (!char_ins_del_ok
)
1420 if (FRAME_X_P (frame
))
1422 /* Under X, erase everything we are going to rewrite,
1423 and rewrite everything from the first char that's changed.
1424 This is part of supporting fonts like Courier
1425 whose chars can overlap outside the char width. */
1426 for (i
= 0; i
< nlen
; i
++)
1427 if (i
>= olen
|| nbody
[i
] != obody
[i
])
1430 cursor_to (vpos
, i
);
1432 clear_end_of_line (olen
);
1433 write_glyphs (nbody
+ i
, nlen
- i
);
1438 for (i
= 0; i
< nlen
; i
++)
1440 if (i
>= olen
|| nbody
[i
] != obody
[i
]) /* A non-matching char. */
1442 cursor_to (vpos
, i
);
1443 for (j
= 1; (i
+ j
< nlen
&&
1444 (i
+ j
>= olen
|| nbody
[i
+j
] != obody
[i
+j
]));
1447 /* Output this run of non-matching chars. */
1448 write_glyphs (nbody
+ i
, j
);
1451 /* Now find the next non-match. */
1455 /* Clear the rest of the line, or the non-clear part of it. */
1458 cursor_to (vpos
, nlen
);
1459 clear_end_of_line (olen
);
1462 /* Exchange contents between current_frame and new_frame. */
1463 temp
= desired_frame
->glyphs
[vpos
];
1464 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1465 current_frame
->glyphs
[vpos
] = temp
;
1472 nsp
= (must_write_spaces
|| desired_frame
->highlight
[vpos
])
1473 ? 0 : count_blanks (nbody
);
1476 cursor_to (vpos
, nsp
);
1477 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
1480 /* Exchange contents between current_frame and new_frame. */
1481 temp
= desired_frame
->glyphs
[vpos
];
1482 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1483 current_frame
->glyphs
[vpos
] = temp
;
1492 /* Compute number of leading blanks in old and new contents. */
1493 osp
= count_blanks (obody
);
1494 if (!desired_frame
->highlight
[vpos
])
1495 nsp
= count_blanks (nbody
);
1499 /* Compute number of matching chars starting with first nonblank. */
1500 begmatch
= count_match (obody
+ osp
, nbody
+ nsp
);
1502 /* Spaces in new match implicit space past the end of old. */
1503 /* A bug causing this to be a no-op was fixed in 18.29. */
1504 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
1507 while (np1
[begmatch
] == SPACEGLYPH
)
1511 /* Avoid doing insert/delete char
1512 just cause number of leading spaces differs
1513 when the following text does not match. */
1514 if (begmatch
== 0 && osp
!= nsp
)
1515 osp
= nsp
= min (osp
, nsp
);
1517 /* Find matching characters at end of line */
1520 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
1521 while (op1
> op2
&& op1
[-1] == np1
[-1])
1526 endmatch
= obody
+ olen
- op1
;
1528 /* Put correct value back in nbody[nlen].
1529 This is important because direct_output_for_insert
1530 can write into the line at a later point.
1531 If this screws up the zero at the end of the line, re-establish it. */
1535 /* tem gets the distance to insert or delete.
1536 endmatch is how many characters we save by doing so.
1539 tem
= (nlen
- nsp
) - (olen
- osp
);
1541 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
1544 /* nsp - osp is the distance to insert or delete.
1545 If that is nonzero, begmatch is known to be nonzero also.
1546 begmatch + endmatch is how much we save by doing the ins/del.
1550 && (!char_ins_del_ok
1551 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
1555 osp
= nsp
= min (osp
, nsp
);
1558 /* Now go through the line, inserting, writing and
1559 deleting as appropriate. */
1563 cursor_to (vpos
, nsp
);
1564 delete_glyphs (osp
- nsp
);
1568 /* If going to delete chars later in line
1569 and insert earlier in the line,
1570 must delete first to avoid losing data in the insert */
1571 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
1573 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
1574 delete_glyphs (olen
+ nsp
- osp
- nlen
);
1575 olen
= nlen
- (nsp
- osp
);
1577 cursor_to (vpos
, osp
);
1578 insert_glyphs ((char *)0, nsp
- osp
);
1582 tem
= nsp
+ begmatch
+ endmatch
;
1583 if (nlen
!= tem
|| olen
!= tem
)
1585 cursor_to (vpos
, nsp
+ begmatch
);
1586 if (!endmatch
|| nlen
== olen
)
1588 /* If new text being written reaches right margin,
1589 there is no need to do clear-to-eol at the end.
1590 (and it would not be safe, since cursor is not
1591 going to be "at the margin" after the text is done) */
1592 if (nlen
== FRAME_WIDTH (frame
))
1594 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1598 /* the following code loses disastrously if tem == nlen.
1599 Rather than trying to fix that case, I am trying the simpler
1600 solution found above. */
1602 /* If the text reaches to the right margin,
1603 it will lose one way or another (depending on AutoWrap)
1604 to clear to end of line after outputting all the text.
1605 So pause with one character to go and clear the line then. */
1606 if (nlen
== FRAME_WIDTH (frame
) && fast_clear_end_of_line
&& olen
> nlen
)
1608 /* endmatch must be zero, and tem must equal nsp + begmatch */
1609 write_glyphs (nbody
+ tem
, nlen
- tem
- 1);
1610 clear_end_of_line (olen
);
1611 olen
= 0; /* Don't let it be cleared again later */
1612 write_glyphs (nbody
+ nlen
- 1, 1);
1615 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1616 #endif /* OBSOLETE */
1619 else if (nlen
> olen
)
1621 write_glyphs (nbody
+ nsp
+ begmatch
, olen
- tem
);
1622 insert_glyphs (nbody
+ nsp
+ begmatch
+ olen
- tem
, nlen
- olen
);
1625 else if (olen
> nlen
)
1627 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1628 delete_glyphs (olen
- nlen
);
1634 /* If any unerased characters remain after the new line, erase them. */
1637 cursor_to (vpos
, nlen
);
1638 clear_end_of_line (olen
);
1641 /* Exchange contents between current_frame and new_frame. */
1642 temp
= desired_frame
->glyphs
[vpos
];
1643 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1644 current_frame
->glyphs
[vpos
] = temp
;
1647 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
1648 1, 1, "FOpen termscript file: ",
1649 "Start writing all terminal output to FILE as well as the terminal.\n\
1650 FILE = nil means just close any termscript file currently open.")
1654 if (termscript
!= 0) fclose (termscript
);
1659 file
= Fexpand_file_name (file
, Qnil
);
1660 termscript
= fopen (XSTRING (file
)->data
, "w");
1661 if (termscript
== 0)
1662 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
1670 window_change_signal ()
1674 int old_errno
= errno
;
1676 get_frame_size (&width
, &height
);
1678 /* The frame size change obviously applies to a termcap-controlled
1679 frame. Find such a frame in the list, and assume it's the only
1680 one (since the redisplay code always writes to stdout, not a
1681 FILE * specified in the frame structure). Record the new size,
1682 but don't reallocate the data structures now. Let that be done
1683 later outside of the signal handler. */
1686 Lisp_Object tail
, frame
;
1688 FOR_EACH_FRAME (tail
, frame
)
1690 if (FRAME_TERMCAP_P (XFRAME (frame
)))
1692 change_frame_size (XFRAME (frame
), height
, width
, 0, 1);
1698 signal (SIGWINCH
, window_change_signal
);
1701 #endif /* SIGWINCH */
1704 /* Do any change in frame size that was requested by a signal. */
1706 do_pending_window_change ()
1708 /* If window_change_signal should have run before, run it now. */
1709 while (delayed_size_change
)
1711 Lisp_Object tail
, frame
;
1713 delayed_size_change
= 0;
1715 FOR_EACH_FRAME (tail
, frame
)
1717 FRAME_PTR f
= XFRAME (frame
);
1719 int height
= FRAME_NEW_HEIGHT (f
);
1720 int width
= FRAME_NEW_WIDTH (f
);
1722 if (height
!= 0 || width
!= 0)
1723 change_frame_size (f
, height
, width
, 0, 0);
1729 /* Change the frame height and/or width. Values may be given as zero to
1730 indicate no change is to take place.
1732 If DELAY is non-zero, then assume we're being called from a signal
1733 handler, and queue the change for later - perhaps the next
1734 redisplay. Since this tries to resize windows, we can't call it
1735 from a signal handler. */
1737 change_frame_size (frame
, newheight
, newwidth
, pretend
, delay
)
1738 register FRAME_PTR frame
;
1739 int newheight
, newwidth
, pretend
;
1741 /* If we can't deal with the change now, queue it for later. */
1744 FRAME_NEW_HEIGHT (frame
) = newheight
;
1745 FRAME_NEW_WIDTH (frame
) = newwidth
;
1746 delayed_size_change
= 1;
1750 /* This size-change overrides any pending one for this frame. */
1751 FRAME_NEW_HEIGHT (frame
) = 0;
1752 FRAME_NEW_WIDTH (frame
) = 0;
1754 /* If an argument is zero, set it to the current value. */
1755 newheight
|| (newheight
= FRAME_HEIGHT (frame
));
1756 newwidth
|| (newwidth
= FRAME_WIDTH (frame
));
1758 /* Round up to the smallest acceptable size. */
1759 check_frame_size (frame
, &newheight
, &newwidth
);
1761 /* If we're not changing the frame size, quit now. */
1762 if (newheight
== FRAME_HEIGHT (frame
)
1763 && newwidth
== FRAME_WIDTH (frame
))
1766 if (newheight
!= FRAME_HEIGHT (frame
))
1768 if (FRAME_HAS_MINIBUF_P (frame
)
1769 && ! FRAME_MINIBUF_ONLY_P (frame
))
1771 /* Frame has both root and minibuffer. */
1772 set_window_height (FRAME_ROOT_WINDOW (frame
),
1773 newheight
- 1 - FRAME_MENU_BAR_LINES (frame
), 0);
1774 XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (frame
))->top
)
1776 set_window_height (FRAME_MINIBUF_WINDOW (frame
), 1, 0);
1779 /* Frame has just one top-level window. */
1780 set_window_height (FRAME_ROOT_WINDOW (frame
),
1781 newheight
- FRAME_MENU_BAR_LINES (frame
), 0);
1783 if (FRAME_TERMCAP_P (frame
) && !pretend
)
1784 FrameRows
= newheight
;
1787 if (frame
->output_method
== output_termcap
)
1789 frame_height
= newheight
;
1791 FrameRows
= newheight
;
1796 if (newwidth
!= FRAME_WIDTH (frame
))
1798 set_window_width (FRAME_ROOT_WINDOW (frame
), newwidth
, 0);
1799 if (FRAME_HAS_MINIBUF_P (frame
))
1800 set_window_width (FRAME_MINIBUF_WINDOW (frame
), newwidth
, 0);
1802 if (FRAME_TERMCAP_P (frame
) && !pretend
)
1803 FrameCols
= newwidth
;
1805 if (frame
->output_method
== output_termcap
)
1807 frame_width
= newwidth
;
1809 FrameCols
= newwidth
;
1814 FRAME_HEIGHT (frame
) = newheight
;
1815 FRAME_WIDTH (frame
) = newwidth
;
1817 remake_frame_glyphs (frame
);
1818 calculate_costs (frame
);
1821 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
1822 Ssend_string_to_terminal
, 1, 1, 0,
1823 "Send STRING to the terminal without alteration.\n\
1824 Control characters in STRING will have terminal-dependent effects.")
1828 CHECK_STRING (str
, 0);
1829 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, stdout
);
1833 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, termscript
);
1834 fflush (termscript
);
1839 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
1840 "Beep, or flash the screen.\n\
1841 Also, unless an argument is given,\n\
1842 terminate any keyboard macro currently executing.")
1864 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
1865 error ("Keyboard macro terminated by a command ringing the bell");
1871 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
1872 "Pause, without updating display, for SECONDS seconds.\n\
1873 SECONDS may be a floating-point value, meaning that you can wait for a\n\
1874 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
1875 additional wait period, in milliseconds; this may be useful if your\n\
1876 Emacs was built without floating point support.\n\
1877 \(Not all operating systems support waiting for a fraction of a second.)")
1878 (seconds
, milliseconds
)
1879 Lisp_Object seconds
, milliseconds
;
1883 if (NILP (milliseconds
))
1884 XSET (milliseconds
, Lisp_Int
, 0);
1886 CHECK_NUMBER (milliseconds
, 1);
1887 usec
= XINT (milliseconds
) * 1000;
1889 #ifdef LISP_FLOAT_TYPE
1891 double duration
= extract_float (seconds
);
1892 sec
= (int) duration
;
1893 usec
+= (duration
- sec
) * 1000000;
1896 CHECK_NUMBER (seconds
, 0);
1897 sec
= XINT (seconds
);
1900 #ifndef EMACS_HAS_USECS
1901 if (sec
== 0 && usec
!= 0)
1902 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
1905 /* Assure that 0 <= usec < 1000000. */
1908 /* We can't rely on the rounding being correct if user is negative. */
1909 if (-1000000 < usec
)
1910 sec
--, usec
+= 1000000;
1912 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
1915 sec
+= usec
/ 1000000, usec
%= 1000000;
1923 XFASTINT (zero
) = 0;
1924 wait_reading_process_input (sec
, usec
, zero
, 0);
1927 /* We should always have wait_reading_process_input; we have a dummy
1928 implementation for systems which don't support subprocesses. */
1930 /* No wait_reading_process_input */
1937 /* The reason this is done this way
1938 (rather than defined (H_S) && defined (H_T))
1939 is because the VMS preprocessor doesn't grok `defined' */
1941 EMACS_GET_TIME (end_time
);
1942 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
1943 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
1947 EMACS_GET_TIME (timeout
);
1948 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
1949 if (EMACS_TIME_NEG_P (timeout
)
1950 || !select (1, 0, 0, 0, &timeout
))
1953 #else /* not HAVE_SELECT */
1955 #endif /* HAVE_SELECT */
1956 #endif /* not VMS */
1959 #endif /* no subprocesses */
1964 /* This is just like wait_reading_process_input, except that
1965 it does the redisplay.
1967 It's also much like Fsit_for, except that it can be used for
1968 waiting for input as well. One differnce is that sit_for
1969 does not call prepare_menu_bars; Fsit_for does call that. */
1972 sit_for (sec
, usec
, reading
, display
)
1973 int sec
, usec
, reading
, display
;
1975 Lisp_Object read_kbd
;
1977 if (detect_input_pending ())
1981 redisplay_preserve_echo_area ();
1983 if (sec
== 0 && usec
== 0)
1990 XSET (read_kbd
, Lisp_Int
, reading
? -1 : 1);
1991 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
1994 /* wait_reading_process_input should always be available now; it is
1995 simulated in a simple way on systems that don't support
1998 /* No wait_reading_process_input available. */
2004 input_wait_timeout (XINT (arg
));
2006 #ifndef HAVE_TIMEVAL
2008 select (1, &waitchannels
, 0, 0, &timeout_sec
);
2009 #else /* HAVE_TIMEVAL */
2010 timeout
.tv_sec
= sec
;
2011 timeout
.tv_usec
= usec
;
2012 select (1, &waitchannels
, 0, 0, &timeout
);
2013 #endif /* HAVE_TIMEVAL */
2014 #endif /* not VMS */
2019 return detect_input_pending () ? Qnil
: Qt
;
2022 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
2023 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
2024 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2025 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2026 additional wait period, in milliseconds; this may be useful if your\n\
2027 Emacs was built without floating point support.\n\
2028 \(Not all operating systems support waiting for a fraction of a second.)\n\
2029 Optional third arg non-nil means don't redisplay, just wait for input.\n\
2030 Redisplay is preempted as always if input arrives, and does not happen\n\
2031 if input is available before it starts.\n\
2032 Value is t if waited the full time with no input arriving.")
2033 (seconds
, milliseconds
, nodisp
)
2034 Lisp_Object seconds
, milliseconds
, nodisp
;
2038 if (NILP (milliseconds
))
2039 XSET (milliseconds
, Lisp_Int
, 0);
2041 CHECK_NUMBER (milliseconds
, 1);
2042 usec
= XINT (milliseconds
) * 1000;
2044 #ifdef LISP_FLOAT_TYPE
2046 double duration
= extract_float (seconds
);
2047 sec
= (int) duration
;
2048 usec
+= (duration
- sec
) * 1000000;
2051 CHECK_NUMBER (seconds
, 0);
2052 sec
= XINT (seconds
);
2055 #ifndef EMACS_HAS_USECS
2056 if (usec
!= 0 && sec
== 0)
2057 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
2061 prepare_menu_bars ();
2062 return sit_for (sec
, usec
, 0, NILP (nodisp
));
2065 char *terminal_type
;
2067 /* Initialization done when Emacs fork is started, before doing stty. */
2068 /* Determine terminal type and set terminal_driver */
2069 /* Then invoke its decoding routine to set up variables
2070 in the terminal package */
2074 #ifdef HAVE_X_WINDOWS
2075 extern int display_arg
;
2080 cursor_in_echo_area
= 0;
2081 terminal_type
= (char *) 0;
2083 /* Now is the time to initialize this; it's used by init_sys_modes
2085 Vwindow_system
= Qnil
;
2087 /* If the user wants to use a window system, we shouldn't bother
2088 initializing the terminal. This is especially important when the
2089 terminal is so dumb that emacs gives up before and doesn't bother
2090 using the window system.
2092 If the DISPLAY environment variable is set, try to use X, and die
2093 with an error message if that doesn't work. */
2095 #ifdef HAVE_X_WINDOWS
2099 display_arg
= (getenv ("DECW$DISPLAY") != 0);
2101 display_arg
= (getenv ("DISPLAY") != 0);
2105 if (!inhibit_window_system
&& display_arg
)
2107 Vwindow_system
= intern ("x");
2109 Vwindow_system_version
= make_number (11);
2111 Vwindow_system_version
= make_number (10);
2115 #endif /* HAVE_X_WINDOWS */
2117 /* If no window system has been specified, try to use the terminal. */
2120 fprintf (stderr
, "emacs: standard input is not a tty\n");
2124 /* Look at the TERM variable */
2125 terminal_type
= (char *) getenv ("TERM");
2129 fprintf (stderr
, "Please specify your terminal type.\n\
2130 For types defined in VMS, use set term /device=TYPE.\n\
2131 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
2132 \(The quotation marks are necessary since terminal types are lower case.)\n");
2134 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
2140 /* VMS DCL tends to upcase things, so downcase term type.
2141 Hardly any uppercase letters in terminal types; should be none. */
2143 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
2146 strcpy (new, terminal_type
);
2148 for (p
= new; *p
; p
++)
2152 terminal_type
= new;
2156 term_init (terminal_type
);
2158 remake_frame_glyphs (selected_frame
);
2159 calculate_costs (selected_frame
);
2161 /* X and Y coordinates of the cursor between updates. */
2162 FRAME_CURSOR_X (selected_frame
) = 0;
2163 FRAME_CURSOR_Y (selected_frame
) = 0;
2168 #endif /* CANNOT_DUMP */
2169 signal (SIGWINCH
, window_change_signal
);
2170 #endif /* SIGWINCH */
2176 defsubr (&Sredraw_frame
);
2178 defsubr (&Sredraw_display
);
2179 defsubr (&Sopen_termscript
);
2181 defsubr (&Ssit_for
);
2182 defsubr (&Ssleep_for
);
2183 defsubr (&Ssend_string_to_terminal
);
2185 DEFVAR_INT ("baud-rate", &baud_rate
,
2186 "The output baud rate of the terminal.\n\
2187 On most systems, changing this value will affect the amount of padding\n\
2188 and the other strategic decisions made during redisplay.");
2189 DEFVAR_BOOL ("inverse-video", &inverse_video
,
2190 "*Non-nil means invert the entire frame display.\n\
2191 This means everything is in inverse video which otherwise would not be.");
2192 DEFVAR_BOOL ("visible-bell", &visible_bell
,
2193 "*Non-nil means try to flash the frame to represent a bell.");
2194 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
2195 "*Non-nil means no need to redraw entire frame after suspending.\n\
2196 A non-nil value is useful if the terminal can automatically preserve\n\
2197 Emacs's frame display when you reenter Emacs.\n\
2198 It is up to you to set this variable if your terminal can do that.");
2199 DEFVAR_LISP ("window-system", &Vwindow_system
,
2200 "A symbol naming the window-system under which Emacs is running\n\
2201 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
2202 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
2203 "The version number of the window system in use.\n\
2204 For X windows, this is 10 or 11.");
2205 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
2206 "Non-nil means put cursor in minibuffer, at end of any message there.");
2207 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
2208 "Table defining how to output a glyph code to the frame.\n\
2209 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
2210 Each element can be:\n\
2211 integer: a glyph code which this glyph is an alias for.\n\
2212 string: output this glyph using that string (not impl. in X windows).\n\
2213 nil: this glyph mod 256 is char code to output,\n\
2214 and this glyph / 256 is face code for X windows (see `x-set-face').");
2215 Vglyph_table
= Qnil
;
2217 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
2218 "Display table to use for buffers that specify none.\n\
2219 See `buffer-display-table' for more information.");
2220 Vstandard_display_table
= Qnil
;
2222 /* Initialize `window-system', unless init_display already decided it. */
2227 Vwindow_system
= Qnil
;
2228 Vwindow_system_version
= Qnil
;