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 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
58 /* Nonzero upon entry to redisplay means do not assume anything about
59 current contents of actual terminal frame; clear and redraw it. */
63 /* Nonzero means last display completed. Zero means it was preempted. */
65 int display_completed
;
67 /* Lisp variable visible-bell; enables use of screen-flash
68 instead of audible bell. */
72 /* Invert the color of the whole frame, at a low level. */
76 /* Line speed of the terminal. */
80 /* nil or a symbol naming the window system under which emacs is
81 running ('x is the only current possibility). */
83 Lisp_Object Vwindow_system
;
85 /* Version number of X windows: 10, 11 or nil. */
86 Lisp_Object Vwindow_system_version
;
88 /* Vector of glyph definitions. Indexed by glyph number,
89 the contents are a string which is how to output the glyph.
91 If Vglyph_table is nil, a glyph is output by using its low 8 bits
92 as a character code. */
94 Lisp_Object Vglyph_table
;
96 /* Display table to use for vectors that don't specify their own. */
98 Lisp_Object Vstandard_display_table
;
100 /* Nonzero means reading single-character input with prompt
101 so put cursor on minibuffer after the prompt.
102 positive means at end of text in echo area;
103 negative means at beginning of line. */
104 int cursor_in_echo_area
;
106 /* The currently selected frame.
107 In a single-frame version, this variable always remains 0. */
109 FRAME_PTR selected_frame
;
111 /* A frame which is not just a minibuffer, or 0 if there are no such
112 frames. This is usually the most recent such frame that was
113 selected. In a single-frame version, this variable always remains 0. */
114 FRAME_PTR last_nonminibuf_frame
;
116 /* In a single-frame version, the information that would otherwise
117 exist inside frame objects lives in the following structure instead.
119 NOTE: the_only_frame is not checked for garbage collection; don't
120 store collectible objects in any of its fields!
122 You're not/The only frame in town/... */
125 struct frame the_only_frame
;
128 /* This is a vector, made larger whenever it isn't large enough,
129 which is used inside `update_frame' to hold the old contents
130 of the FRAME_PHYS_LINES of the frame being updated. */
131 struct frame_glyphs
**ophys_lines
;
132 /* Length of vector currently allocated. */
133 int ophys_lines_length
;
135 FILE *termscript
; /* Stdio stream being used for copy of all output. */
137 struct cm Wcm
; /* Structure for info on cursor positioning */
139 extern short ospeed
; /* Output speed (from sg_ospeed) */
141 int delayed_size_change
; /* 1 means SIGWINCH happened when not safe. */
145 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
146 "Clear frame FRAME and output again what is supposed to appear on it.")
152 CHECK_LIVE_FRAME (frame
, 0);
155 /* set_terminal_modes (); */
157 clear_frame_records (f
);
160 windows_or_buffers_changed
++;
161 /* Mark all windows as INaccurate,
162 so that every window will have its redisplay done. */
163 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
172 XSET (frame
, Lisp_Frame
, f
);
173 Fredraw_frame (frame
);
178 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, "",
179 "Clear frame FRAME and output again what is supposed to appear on it.")
184 set_terminal_modes ();
188 clear_frame_records (0);
189 windows_or_buffers_changed
++;
190 /* Mark all windows as INaccurate,
191 so that every window will have its redisplay done. */
192 mark_window_display_accurate (FRAME_ROOT_WINDOW (0), 0);
198 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
199 "Clear and redisplay all visible frames.")
202 Lisp_Object tail
, frame
;
204 FOR_EACH_FRAME (tail
, frame
)
205 if (FRAME_VISIBLE_P (XFRAME (frame
)))
206 Fredraw_frame (frame
);
211 /* This is used when frame_garbaged is set.
212 Redraw the individual frames marked as garbaged. */
215 redraw_garbaged_frames ()
217 Lisp_Object tail
, frame
;
219 FOR_EACH_FRAME (tail
, frame
)
220 if (FRAME_VISIBLE_P (XFRAME (frame
))
221 && FRAME_GARBAGED_P (XFRAME (frame
)))
222 Fredraw_frame (frame
);
226 static struct frame_glyphs
*
227 make_frame_glyphs (frame
, empty
)
228 register FRAME_PTR frame
;
232 register width
= FRAME_WIDTH (frame
);
233 register height
= FRAME_HEIGHT (frame
);
234 register struct frame_glyphs
*new =
235 (struct frame_glyphs
*) xmalloc (sizeof (struct frame_glyphs
));
237 SET_GLYPHS_FRAME (new, frame
);
238 new->height
= height
;
240 new->used
= (int *) xmalloc (height
* sizeof (int));
241 new->glyphs
= (GLYPH
**) xmalloc (height
* sizeof (GLYPH
*));
242 new->highlight
= (char *) xmalloc (height
* sizeof (char));
243 new->enable
= (char *) xmalloc (height
* sizeof (char));
244 bzero (new->enable
, height
* sizeof (char));
245 new->bufp
= (int *) xmalloc (height
* sizeof (int));
247 #ifdef HAVE_X_WINDOWS
248 if (FRAME_X_P (frame
))
250 new->top_left_x
= (short *) xmalloc (height
* sizeof (short));
251 new->top_left_y
= (short *) xmalloc (height
* sizeof (short));
252 new->pix_width
= (short *) xmalloc (height
* sizeof (short));
253 new->pix_height
= (short *) xmalloc (height
* sizeof (short));
254 new->max_ascent
= (short *) xmalloc (height
* sizeof (short));
260 /* Make the buffer used by decode_mode_spec. This buffer is also
261 used as temporary storage when updating the frame. See scroll.c. */
262 unsigned int total_glyphs
= (width
+ 2) * sizeof (GLYPH
);
264 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
265 bzero (new->total_contents
, total_glyphs
);
269 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (GLYPH
);
271 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
272 bzero (new->total_contents
, total_glyphs
);
273 for (i
= 0; i
< height
; i
++)
274 new->glyphs
[i
] = new->total_contents
+ i
* (width
+ 2) + 1;
281 free_frame_glyphs (frame
, glyphs
)
283 struct frame_glyphs
*glyphs
;
285 if (glyphs
->total_contents
)
286 xfree (glyphs
->total_contents
);
288 xfree (glyphs
->used
);
289 xfree (glyphs
->glyphs
);
290 xfree (glyphs
->highlight
);
291 xfree (glyphs
->enable
);
292 xfree (glyphs
->bufp
);
294 #ifdef HAVE_X_WINDOWS
295 if (FRAME_X_P (frame
))
297 xfree (glyphs
->top_left_x
);
298 xfree (glyphs
->top_left_y
);
299 xfree (glyphs
->pix_width
);
300 xfree (glyphs
->pix_height
);
301 xfree (glyphs
->max_ascent
);
309 remake_frame_glyphs (frame
)
312 if (FRAME_CURRENT_GLYPHS (frame
))
313 free_frame_glyphs (frame
, FRAME_CURRENT_GLYPHS (frame
));
314 if (FRAME_DESIRED_GLYPHS (frame
))
315 free_frame_glyphs (frame
, FRAME_DESIRED_GLYPHS (frame
));
316 if (FRAME_TEMP_GLYPHS (frame
))
317 free_frame_glyphs (frame
, FRAME_TEMP_GLYPHS (frame
));
319 if (FRAME_MESSAGE_BUF (frame
))
321 /* Reallocate the frame's message buffer; remember that
322 echo_area_glyphs may be pointing here. */
323 char *old_message_buf
= FRAME_MESSAGE_BUF (frame
);
325 FRAME_MESSAGE_BUF (frame
)
326 = (char *) xrealloc (FRAME_MESSAGE_BUF (frame
),
327 FRAME_WIDTH (frame
) + 1);
329 if (echo_area_glyphs
== old_message_buf
)
330 echo_area_glyphs
= FRAME_MESSAGE_BUF (frame
);
331 if (previous_echo_glyphs
== old_message_buf
)
332 previous_echo_glyphs
= FRAME_MESSAGE_BUF (frame
);
335 FRAME_MESSAGE_BUF (frame
)
336 = (char *) xmalloc (FRAME_WIDTH (frame
) + 1);
338 FRAME_CURRENT_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
339 FRAME_DESIRED_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
340 FRAME_TEMP_GLYPHS (frame
) = make_frame_glyphs (frame
, 1);
341 SET_FRAME_GARBAGED (frame
);
344 /* Return the hash code of contents of line VPOS in frame-matrix M. */
347 line_hash_code (m
, vpos
)
348 register struct frame_glyphs
*m
;
351 register GLYPH
*body
, *end
;
354 if (!m
->enable
[vpos
])
357 /* Give all highlighted lines the same hash code
358 so as to encourage scrolling to leave them in place. */
359 if (m
->highlight
[vpos
])
362 body
= m
->glyphs
[vpos
];
364 if (must_write_spaces
)
371 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
- SPACEGLYPH
;
380 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
;
388 /* Return number of characters in line in M at vpos VPOS,
389 except don't count leading and trailing spaces
390 unless the terminal requires those to be explicitly output. */
393 line_draw_cost (m
, vpos
)
394 struct frame_glyphs
*m
;
397 register GLYPH
*beg
= m
->glyphs
[vpos
];
398 register GLYPH
*end
= m
->glyphs
[vpos
] + m
->used
[vpos
];
400 register int tlen
= GLYPH_TABLE_LENGTH
;
401 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
403 /* Ignore trailing and leading spaces if we can. */
404 if (!must_write_spaces
)
406 while ((end
!= beg
) && (*end
== SPACEGLYPH
))
409 return (0); /* All blank line. */
411 while (*beg
== SPACEGLYPH
)
415 /* If we don't have a glyph-table, each glyph is one character,
416 so return the number of glyphs. */
420 /* Otherwise, scan the glyphs and accumulate their total size in I. */
422 while ((beg
<= end
) && *beg
)
424 register GLYPH g
= *beg
++;
426 if (GLYPH_SIMPLE_P (tbase
, tlen
, g
))
429 i
+= GLYPH_LENGTH (tbase
, g
);
434 /* The functions on this page are the interface from xdisp.c to redisplay.
436 The only other interface into redisplay is through setting
437 FRAME_CURSOR_X (frame) and FRAME_CURSOR_Y (frame)
438 and SET_FRAME_GARBAGED (frame). */
440 /* cancel_line eliminates any request to display a line at position `vpos' */
442 cancel_line (vpos
, frame
)
444 register FRAME_PTR frame
;
446 FRAME_DESIRED_GLYPHS (frame
)->enable
[vpos
] = 0;
449 clear_frame_records (frame
)
450 register FRAME_PTR frame
;
452 bzero (FRAME_CURRENT_GLYPHS (frame
)->enable
, FRAME_HEIGHT (frame
));
455 /* Prepare to display on line VPOS starting at HPOS within it. */
458 get_display_line (frame
, vpos
, hpos
)
459 register FRAME_PTR frame
;
463 register struct frame_glyphs
*glyphs
;
464 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (frame
);
470 if ((desired_glyphs
->enable
[vpos
]) && desired_glyphs
->used
[vpos
] > hpos
)
473 if (! desired_glyphs
->enable
[vpos
])
475 desired_glyphs
->used
[vpos
] = 0;
476 desired_glyphs
->highlight
[vpos
] = 0;
477 desired_glyphs
->enable
[vpos
] = 1;
480 if (hpos
> desired_glyphs
->used
[vpos
])
482 GLYPH
*g
= desired_glyphs
->glyphs
[vpos
] + desired_glyphs
->used
[vpos
];
483 GLYPH
*end
= desired_glyphs
->glyphs
[vpos
] + hpos
;
485 desired_glyphs
->used
[vpos
] = hpos
;
491 /* Like bcopy except never gets confused by overlap. */
494 safe_bcopy (from
, to
, size
)
498 if (size
<= 0 || from
== to
)
501 /* If the source and destination don't overlap, then bcopy can
502 handle it. If they do overlap, but the destination is lower in
503 memory than the source, we'll assume bcopy can handle that. */
504 if (to
< from
|| from
+ size
<= to
)
505 bcopy (from
, to
, size
);
507 /* Otherwise, we'll copy from the end. */
510 register char *endf
= from
+ size
;
511 register char *endt
= to
+ size
;
513 /* If TO - FROM is large, then we should break the copy into
514 nonoverlapping chunks of TO - FROM bytes each. However, if
515 TO - FROM is small, then the bcopy function call overhead
516 makes this not worth it. The crossover point could be about
517 anywhere. Since I don't think the obvious copy loop is too
518 bad, I'm trying to err in its favor. */
523 while (endf
!= from
);
535 bcopy (endf
, endt
, to
- from
);
538 /* If SIZE wasn't a multiple of TO - FROM, there will be a
539 little left over. The amount left over is
540 (endt + (to - from)) - to, which is endt - from. */
541 bcopy (from
, to
, endt
- from
);
546 /* Rotate a vector of SIZE bytes right, by DISTANCE bytes.
547 DISTANCE may be negative. */
550 rotate_vector (vector
, size
, distance
)
555 char *temp
= (char *) alloca (size
);
560 bcopy (vector
, temp
+ distance
, size
- distance
);
561 bcopy (vector
+ size
- distance
, temp
, distance
);
562 bcopy (temp
, vector
, size
);
565 /* Scroll lines from vpos FROM up to but not including vpos END
566 down by AMOUNT lines (AMOUNT may be negative).
567 Returns nonzero if done, zero if terminal cannot scroll them. */
570 scroll_frame_lines (frame
, from
, end
, amount
)
571 register FRAME_PTR frame
;
572 int from
, end
, amount
;
575 register struct frame_glyphs
*current_frame
576 = FRAME_CURRENT_GLYPHS (frame
);
578 if (!line_ins_del_ok
)
586 update_begin (frame
);
587 set_terminal_window (end
+ amount
);
588 if (!scroll_region_ok
)
589 ins_del_lines (end
, -amount
);
590 ins_del_lines (from
, amount
);
591 set_terminal_window (0);
593 rotate_vector (current_frame
->glyphs
+ from
,
594 sizeof (GLYPH
*) * (end
+ amount
- from
),
595 amount
* sizeof (GLYPH
*));
597 safe_bcopy (current_frame
->used
+ from
,
598 current_frame
->used
+ from
+ amount
,
599 (end
- from
) * sizeof current_frame
->used
[0]);
601 safe_bcopy (current_frame
->highlight
+ from
,
602 current_frame
->highlight
+ from
+ amount
,
603 (end
- from
) * sizeof current_frame
->highlight
[0]);
605 safe_bcopy (current_frame
->enable
+ from
,
606 current_frame
->enable
+ from
+ amount
,
607 (end
- from
) * sizeof current_frame
->enable
[0]);
609 /* Mark the lines made empty by scrolling as enabled, empty and
611 bzero (current_frame
->used
+ from
,
612 amount
* sizeof current_frame
->used
[0]);
613 bzero (current_frame
->highlight
+ from
,
614 amount
* sizeof current_frame
->highlight
[0]);
615 for (i
= from
; i
< from
+ amount
; i
++)
617 current_frame
->glyphs
[i
][0] = '\0';
618 current_frame
->enable
[i
] = 1;
621 safe_bcopy (current_frame
->bufp
+ from
,
622 current_frame
->bufp
+ from
+ amount
,
623 (end
- from
) * sizeof current_frame
->bufp
[0]);
625 #ifdef HAVE_X_WINDOWS
626 if (FRAME_X_P (frame
))
628 safe_bcopy (current_frame
->top_left_x
+ from
,
629 current_frame
->top_left_x
+ from
+ amount
,
630 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
632 safe_bcopy (current_frame
->top_left_y
+ from
,
633 current_frame
->top_left_y
+ from
+ amount
,
634 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
636 safe_bcopy (current_frame
->pix_width
+ from
,
637 current_frame
->pix_width
+ from
+ amount
,
638 (end
- from
) * sizeof current_frame
->pix_width
[0]);
640 safe_bcopy (current_frame
->pix_height
+ from
,
641 current_frame
->pix_height
+ from
+ amount
,
642 (end
- from
) * sizeof current_frame
->pix_height
[0]);
644 safe_bcopy (current_frame
->max_ascent
+ from
,
645 current_frame
->max_ascent
+ from
+ amount
,
646 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
648 #endif /* HAVE_X_WINDOWS */
654 update_begin (frame
);
655 set_terminal_window (end
);
656 ins_del_lines (from
+ amount
, amount
);
657 if (!scroll_region_ok
)
658 ins_del_lines (end
+ amount
, -amount
);
659 set_terminal_window (0);
661 rotate_vector (current_frame
->glyphs
+ from
+ amount
,
662 sizeof (GLYPH
*) * (end
- from
- amount
),
663 amount
* sizeof (GLYPH
*));
665 safe_bcopy (current_frame
->used
+ from
,
666 current_frame
->used
+ from
+ amount
,
667 (end
- from
) * sizeof current_frame
->used
[0]);
669 safe_bcopy (current_frame
->highlight
+ from
,
670 current_frame
->highlight
+ from
+ amount
,
671 (end
- from
) * sizeof current_frame
->highlight
[0]);
673 safe_bcopy (current_frame
->enable
+ from
,
674 current_frame
->enable
+ from
+ amount
,
675 (end
- from
) * sizeof current_frame
->enable
[0]);
677 /* Mark the lines made empty by scrolling as enabled, empty and
679 bzero (current_frame
->used
+ end
+ amount
,
680 - amount
* sizeof current_frame
->used
[0]);
681 bzero (current_frame
->highlight
+ end
+ amount
,
682 - amount
* sizeof current_frame
->highlight
[0]);
683 for (i
= end
+ amount
; i
< end
; i
++)
685 current_frame
->glyphs
[i
][0] = '\0';
686 current_frame
->enable
[i
] = 1;
689 safe_bcopy (current_frame
->bufp
+ from
,
690 current_frame
->bufp
+ from
+ amount
,
691 (end
- from
) * sizeof current_frame
->bufp
[0]);
693 #ifdef HAVE_X_WINDOWS
694 if (FRAME_X_P (frame
))
696 safe_bcopy (current_frame
->top_left_x
+ from
,
697 current_frame
->top_left_x
+ from
+ amount
,
698 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
700 safe_bcopy (current_frame
->top_left_y
+ from
,
701 current_frame
->top_left_y
+ from
+ amount
,
702 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
704 safe_bcopy (current_frame
->pix_width
+ from
,
705 current_frame
->pix_width
+ from
+ amount
,
706 (end
- from
) * sizeof current_frame
->pix_width
[0]);
708 safe_bcopy (current_frame
->pix_height
+ from
,
709 current_frame
->pix_height
+ from
+ amount
,
710 (end
- from
) * sizeof current_frame
->pix_height
[0]);
712 safe_bcopy (current_frame
->max_ascent
+ from
,
713 current_frame
->max_ascent
+ from
+ amount
,
714 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
716 #endif /* HAVE_X_WINDOWS */
723 /* After updating a window W that isn't the full frame wide,
724 copy all the columns that W does not occupy
725 into the FRAME_DESIRED_GLYPHS (frame) from the FRAME_PHYS_GLYPHS (frame)
726 so that update_frame will not change those columns. */
728 preserve_other_columns (w
)
732 register struct frame_glyphs
*current_frame
, *desired_frame
;
733 register FRAME_PTR frame
= XFRAME (w
->frame
);
734 int start
= XFASTINT (w
->left
);
735 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
736 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
738 current_frame
= FRAME_CURRENT_GLYPHS (frame
);
739 desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
741 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
743 if (current_frame
->enable
[vpos
] && desired_frame
->enable
[vpos
])
749 bcopy (current_frame
->glyphs
[vpos
],
750 desired_frame
->glyphs
[vpos
],
751 start
* sizeof (current_frame
->glyphs
[vpos
]));
752 len
= min (start
, current_frame
->used
[vpos
]);
753 if (desired_frame
->used
[vpos
] < len
)
754 desired_frame
->used
[vpos
] = len
;
756 if (current_frame
->used
[vpos
] > end
757 && desired_frame
->used
[vpos
] < current_frame
->used
[vpos
])
759 while (desired_frame
->used
[vpos
] < end
)
760 desired_frame
->glyphs
[vpos
][desired_frame
->used
[vpos
]++]
762 bcopy (current_frame
->glyphs
[vpos
] + end
,
763 desired_frame
->glyphs
[vpos
] + end
,
764 ((current_frame
->used
[vpos
] - end
)
765 * sizeof (current_frame
->glyphs
[vpos
])));
766 desired_frame
->used
[vpos
] = current_frame
->used
[vpos
];
774 /* If window w does not need to be updated and isn't the full frame wide,
775 copy all the columns that w does occupy
776 into the FRAME_DESIRED_LINES (frame) from the FRAME_PHYS_LINES (frame)
777 so that update_frame will not change those columns.
779 Have not been able to figure out how to use this correctly. */
781 preserve_my_columns (w
)
784 register int vpos
, fin
;
785 register struct frame_glyphs
*l1
, *l2
;
786 register FRAME_PTR frame
= XFRAME (w
->frame
);
787 int start
= XFASTINT (w
->left
);
788 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
789 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
791 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
793 if ((l1
= FRAME_DESIRED_GLYPHS (frame
)->glyphs
[vpos
+ 1])
794 && (l2
= FRAME_PHYS_GLYPHS (frame
)->glyphs
[vpos
+ 1]))
796 if (l2
->length
> start
&& l1
->length
< l2
->length
)
799 if (fin
> end
) fin
= end
;
800 while (l1
->length
< start
)
801 l1
->body
[l1
->length
++] = ' ';
802 bcopy (l2
->body
+ start
, l1
->body
+ start
, fin
- start
);
811 /* On discovering that the redisplay for a window was no good,
812 cancel the columns of that window, so that when the window is
813 displayed over again get_display_line will not complain. */
815 cancel_my_columns (w
)
819 register struct frame_glyphs
*desired_glyphs
=
820 FRAME_DESIRED_GLYPHS (XFRAME (w
->frame
));
821 register int start
= XFASTINT (w
->left
);
822 register int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
824 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
825 if (desired_glyphs
->enable
[vpos
]
826 && desired_glyphs
->used
[vpos
] >= start
)
827 desired_glyphs
->used
[vpos
] = start
;
830 /* These functions try to perform directly and immediately on the frame
831 the necessary output for one change in the buffer.
832 They may return 0 meaning nothing was done if anything is difficult,
833 or 1 meaning the output was performed properly.
834 They assume that the frame was up to date before the buffer
835 change being displayed. They make various other assumptions too;
836 see command_loop_1 where these are called. */
839 direct_output_for_insert (g
)
842 register FRAME_PTR frame
= selected_frame
;
843 register struct frame_glyphs
*current_frame
844 = FRAME_CURRENT_GLYPHS (frame
);
846 #ifndef COMPILER_REGISTER_BUG
848 #endif /* COMPILER_REGISTER_BUG */
849 struct window
*w
= XWINDOW (selected_window
);
850 #ifndef COMPILER_REGISTER_BUG
852 #endif /* COMPILER_REGISTER_BUG */
853 int hpos
= FRAME_CURSOR_X (frame
);
854 #ifndef COMPILER_REGISTER_BUG
856 #endif /* COMPILER_REGISTER_BUG */
857 int vpos
= FRAME_CURSOR_Y (frame
);
859 /* Give up if about to continue line. */
860 if (hpos
>= XFASTINT (w
->left
) + window_internal_width (w
) - 1
862 /* Avoid losing if cursor is in invisible text off left margin */
863 || (XINT (w
->hscroll
) && hpos
== XFASTINT (w
->left
))
865 /* Give up if cursor outside window (in minibuf, probably) */
866 || cursor_in_echo_area
867 || FRAME_CURSOR_Y (frame
) < XFASTINT (w
->top
)
868 || FRAME_CURSOR_Y (frame
) >= XFASTINT (w
->top
) + XFASTINT (w
->height
)
870 /* Give up if cursor not really at FRAME_CURSOR_X, FRAME_CURSOR_Y */
871 || !display_completed
873 /* Give up if buffer appears in two places. */
876 #ifdef USE_TEXT_PROPERTIES
877 /* Intervals have already been adjusted, point is after the
878 character that was just inserted. */
879 /* Give up if character has is invisible. */
880 /* Give up if character has a face property.
881 At the moment we only lose at end of line or end of buffer
882 and only with faces that have some background */
883 /* Instead of wasting time, give up if character has any text properties */
884 || ! NILP (Ftext_properties_at (XFASTINT (point
- 1), Qnil
))
887 /* Give up if w is minibuffer and a message is being displayed there */
888 || (MINI_WINDOW_P (w
) && echo_area_glyphs
))
892 #ifdef HAVE_X_WINDOWS
894 int face
= compute_char_face (frame
, w
, point
- 1, -1, -1, &dummy
);
899 current_frame
->glyphs
[vpos
][hpos
] = MAKE_GLYPH (g
, face
);
901 unchanged_modified
= MODIFF
;
902 beg_unchanged
= GPT
- BEG
;
903 XFASTINT (w
->last_point
) = point
;
904 XFASTINT (w
->last_point_x
) = hpos
;
905 XFASTINT (w
->last_modified
) = MODIFF
;
907 reassert_line_highlight (0, vpos
);
908 write_glyphs (¤t_frame
->glyphs
[vpos
][hpos
], 1);
910 ++FRAME_CURSOR_X (frame
);
911 if (hpos
== current_frame
->used
[vpos
])
913 current_frame
->used
[vpos
] = hpos
+ 1;
914 current_frame
->glyphs
[vpos
][hpos
+ 1] = 0;
921 direct_output_forward_char (n
)
924 register FRAME_PTR frame
= selected_frame
;
925 register struct window
*w
= XWINDOW (selected_window
);
928 /* Avoid losing if cursor is in invisible text off left margin
929 or about to go off either side of window. */
930 if ((FRAME_CURSOR_X (frame
) == XFASTINT (w
->left
)
931 && (XINT (w
->hscroll
) || n
< 0))
933 && (FRAME_CURSOR_X (frame
) + 1 >= window_internal_width (w
) - 1))
934 || cursor_in_echo_area
)
937 /* Can't use direct output if highlighting a region. */
938 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
941 #ifdef USE_TEXT_PROPERTIES
942 /* Don't use direct output next to an invisible character
943 since we might need to do something special. */
945 XFASTINT (position
) = point
;
946 if (XFASTINT (position
) < ZV
947 && ! NILP (Fget_text_property (position
,
949 Fcurrent_buffer ())))
952 XFASTINT (position
) = point
- 1;
953 if (XFASTINT (position
) >= BEGV
954 && ! NILP (Fget_text_property (position
,
956 Fcurrent_buffer ())))
960 FRAME_CURSOR_X (frame
) += n
;
961 XFASTINT (w
->last_point_x
) = FRAME_CURSOR_X (frame
);
962 XFASTINT (w
->last_point
) = point
;
963 cursor_to (FRAME_CURSOR_Y (frame
), FRAME_CURSOR_X (frame
));
969 static void update_line ();
971 /* Update frame F based on the data in FRAME_DESIRED_GLYPHS.
972 Value is nonzero if redisplay stopped due to pending input.
973 FORCE nonzero means do not stop for pending input. */
976 update_frame (f
, force
, inhibit_hairy_id
)
979 int inhibit_hairy_id
;
981 register struct frame_glyphs
*current_frame
= FRAME_CURRENT_GLYPHS (f
);
982 register struct frame_glyphs
*desired_frame
= FRAME_DESIRED_GLYPHS (f
);
985 int preempt_count
= baud_rate
/ 2400 + 1;
986 extern input_pending
;
987 #ifdef HAVE_X_WINDOWS
988 register int downto
, leftmost
;
991 if (preempt_count
<= 0)
994 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
996 detect_input_pending ();
997 if (input_pending
&& !force
)
1005 if (!line_ins_del_ok
)
1006 inhibit_hairy_id
= 1;
1008 /* See if any of the desired lines are enabled; don't compute for
1009 i/d line if just want cursor motion. */
1010 for (i
= 0; i
< FRAME_HEIGHT (f
); i
++)
1011 if (desired_frame
->enable
[i
])
1014 /* Try doing i/d line, if not yet inhibited. */
1015 if (!inhibit_hairy_id
&& i
< FRAME_HEIGHT (f
))
1016 force
|= scrolling (f
);
1018 /* Update the individual lines as needed. Do bottom line first. */
1020 if (desired_frame
->enable
[FRAME_HEIGHT (f
) - 1])
1021 update_line (f
, FRAME_HEIGHT (f
) - 1);
1023 #ifdef HAVE_X_WINDOWS
1026 leftmost
= downto
= f
->display
.x
->internal_border_width
;
1027 if (desired_frame
->enable
[0])
1029 current_frame
->top_left_x
[FRAME_HEIGHT (f
) - 1] = leftmost
;
1030 current_frame
->top_left_y
[FRAME_HEIGHT (f
) - 1]
1031 = PIXEL_HEIGHT (f
) - f
->display
.x
->internal_border_width
1032 - current_frame
->pix_height
[FRAME_HEIGHT (f
) - 1];
1033 current_frame
->top_left_x
[0] = leftmost
;
1034 current_frame
->top_left_y
[0] = downto
;
1037 #endif /* HAVE_X_WINDOWS */
1039 /* Now update the rest of the lines. */
1040 for (i
= 0; i
< FRAME_HEIGHT (f
) - 1 && (force
|| !input_pending
); i
++)
1042 if (desired_frame
->enable
[i
])
1044 if (FRAME_TERMCAP_P (f
))
1046 /* Flush out every so many lines.
1047 Also flush out if likely to have more than 1k buffered
1048 otherwise. I'm told that some telnet connections get
1049 really screwed by more than 1k output at once. */
1050 int outq
= PENDING_OUTPUT_COUNT (stdout
);
1052 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
1055 if (preempt_count
== 1)
1057 #ifdef EMACS_OUTQSIZE
1058 if (EMACS_OUTQSIZE (0, &outq
) < 0)
1059 /* Probably not a tty. Ignore the error and reset
1060 * the outq count. */
1061 outq
= PENDING_OUTPUT_COUNT (stdout
);
1065 sleep (outq
/ baud_rate
);
1068 if ((i
- 1) % preempt_count
== 0)
1069 detect_input_pending ();
1073 #ifdef HAVE_X_WINDOWS
1076 current_frame
->top_left_y
[i
] = downto
;
1077 current_frame
->top_left_x
[i
] = leftmost
;
1079 #endif /* HAVE_X_WINDOWS */
1082 #ifdef HAVE_X_WINDOWS
1084 downto
+= current_frame
->pix_height
[i
];
1087 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
1089 /* Now just clean up termcap drivers and set cursor, etc. */
1092 if (cursor_in_echo_area
1093 && FRAME_HAS_MINIBUF_P (f
))
1095 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
1098 if (cursor_in_echo_area
< 0)
1105 /* If the minibuffer is several lines high, find the last
1106 line that has any text on it. */
1107 row
= FRAME_HEIGHT (f
);
1111 if (current_frame
->enable
[row
])
1112 col
= current_frame
->used
[row
];
1116 while (row
> top
&& col
== 0);
1118 if (col
>= FRAME_WIDTH (f
))
1121 if (row
< FRAME_HEIGHT (f
) - 1)
1126 cursor_to (row
, col
);
1129 cursor_to (FRAME_CURSOR_Y (f
), max (min (FRAME_CURSOR_X (f
),
1130 FRAME_WIDTH (f
) - 1), 0));
1136 fflush (termscript
);
1139 /* Here if output is preempted because input is detected. */
1142 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1143 display_completed
= !pause
;
1145 bzero (desired_frame
->enable
, FRAME_HEIGHT (f
));
1149 /* Called when about to quit, to check for doing so
1150 at an improper time. */
1155 if (FRAME_DESIRED_GLYPHS (selected_frame
) == 0)
1157 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[0])
1159 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[FRAME_HEIGHT (selected_frame
) - 1])
1163 /* Decide what insert/delete line to do, and do it */
1165 extern void scrolling_1 ();
1170 int unchanged_at_top
, unchanged_at_bottom
;
1173 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1174 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1175 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1177 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
1178 register struct frame_glyphs
*current_frame
= FRAME_CURRENT_GLYPHS (frame
);
1179 register struct frame_glyphs
*desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
1181 /* Compute hash codes of all the lines.
1182 Also calculate number of changed lines,
1183 number of unchanged lines at the beginning,
1184 and number of unchanged lines at the end. */
1187 unchanged_at_top
= 0;
1188 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
1189 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
1191 /* Give up on this scrolling if some old lines are not enabled. */
1192 if (!current_frame
->enable
[i
])
1194 old_hash
[i
] = line_hash_code (current_frame
, i
);
1195 if (! desired_frame
->enable
[i
])
1196 new_hash
[i
] = old_hash
[i
];
1198 new_hash
[i
] = line_hash_code (desired_frame
, i
);
1200 if (old_hash
[i
] != new_hash
[i
])
1203 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
1205 else if (i
== unchanged_at_top
)
1207 draw_cost
[i
] = line_draw_cost (desired_frame
, i
);
1210 /* If changed lines are few, don't allow preemption, don't scroll. */
1211 if (changed_lines
< baud_rate
/ 2400
1212 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
1215 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
1216 - unchanged_at_bottom
);
1218 if (scroll_region_ok
)
1219 free_at_end_vpos
-= unchanged_at_bottom
;
1220 else if (memory_below_frame
)
1221 free_at_end_vpos
= -1;
1223 /* If large window, fast terminal and few lines in common between
1224 current frame and desired frame, don't bother with i/d calc. */
1225 if (window_size
>= 18 && baud_rate
> 2400
1227 10 * scrolling_max_lines_saved (unchanged_at_top
,
1228 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
1229 old_hash
, new_hash
, draw_cost
)))
1232 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
1233 draw_cost
+ unchanged_at_top
- 1,
1234 old_hash
+ unchanged_at_top
- 1,
1235 new_hash
+ unchanged_at_top
- 1,
1236 free_at_end_vpos
- unchanged_at_top
);
1241 /* Return the offset in its buffer of the character at location col, line
1242 in the given window. */
1244 buffer_posn_from_coords (window
, col
, line
)
1245 struct window
*window
;
1248 int window_left
= XFASTINT (window
->left
);
1250 /* The actual width of the window is window->width less one for the
1251 DISP_CONTINUE_GLYPH, and less one if it's not the rightmost
1253 int window_width
= window_internal_width (window
) - 1;
1255 int startp
= marker_position (window
->start
);
1257 /* Since compute_motion will only operate on the current buffer,
1258 we need to save the old one and restore it when we're done. */
1259 struct buffer
*old_current_buffer
= current_buffer
;
1260 struct position
*posn
;
1262 current_buffer
= XBUFFER (window
->buffer
);
1264 /* It would be nice if we could use FRAME_CURRENT_GLYPHS (XFRAME
1265 (window->frame))->bufp to avoid scanning from the very top of
1266 the window, but it isn't maintained correctly, and I'm not even
1267 sure I will keep it. */
1268 posn
= compute_motion (startp
, 0,
1269 (window
== XWINDOW (minibuf_window
) && startp
== 1
1270 ? minibuf_prompt_width
: 0),
1272 window_width
, XINT (window
->hscroll
), 0);
1274 current_buffer
= old_current_buffer
;
1276 /* compute_motion considers frame points past the end of a line
1277 to be *after* the newline, i.e. at the start of the next line.
1278 This is reasonable, but not really what we want. So if the
1279 result is on a line below LINE, back it up one character. */
1280 if (posn
->vpos
> line
)
1281 return posn
->bufpos
- 1;
1283 return posn
->bufpos
;
1290 register GLYPH
*p
= r
;
1291 while (*p
++ == SPACEGLYPH
);
1296 count_match (str1
, str2
)
1299 register GLYPH
*p1
= str1
;
1300 register GLYPH
*p2
= str2
;
1301 while (*p1
++ == *p2
++);
1302 return p1
- str1
- 1;
1305 /* Char insertion/deletion cost vector, from term.c */
1306 extern int *char_ins_del_vector
;
1308 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WIDTH((f))])
1311 update_line (frame
, vpos
)
1312 register FRAME_PTR frame
;
1315 register GLYPH
*obody
, *nbody
, *op1
, *op2
, *np1
, *temp
;
1317 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
1319 register struct frame_glyphs
*current_frame
1320 = FRAME_CURRENT_GLYPHS (frame
);
1321 register struct frame_glyphs
*desired_frame
1322 = FRAME_DESIRED_GLYPHS (frame
);
1324 if (desired_frame
->highlight
[vpos
]
1325 != (current_frame
->enable
[vpos
] && current_frame
->highlight
[vpos
]))
1327 change_line_highlight (desired_frame
->highlight
[vpos
], vpos
,
1328 (current_frame
->enable
[vpos
] ?
1329 current_frame
->used
[vpos
] : 0));
1330 current_frame
->enable
[vpos
] = 0;
1333 reassert_line_highlight (desired_frame
->highlight
[vpos
], vpos
);
1335 if (! current_frame
->enable
[vpos
])
1341 obody
= current_frame
->glyphs
[vpos
];
1342 olen
= current_frame
->used
[vpos
];
1343 if (! current_frame
->highlight
[vpos
])
1345 if (!must_write_spaces
)
1346 while (obody
[olen
- 1] == SPACEGLYPH
&& olen
> 0)
1351 /* For an inverse-video line, remember we gave it
1352 spaces all the way to the frame edge
1353 so that the reverse video extends all the way across. */
1355 while (olen
< FRAME_WIDTH (frame
) - 1)
1356 obody
[olen
++] = SPACEGLYPH
;
1360 /* One way or another, this will enable the line being updated. */
1361 current_frame
->enable
[vpos
] = 1;
1362 current_frame
->used
[vpos
] = desired_frame
->used
[vpos
];
1363 current_frame
->highlight
[vpos
] = desired_frame
->highlight
[vpos
];
1364 current_frame
->bufp
[vpos
] = desired_frame
->bufp
[vpos
];
1366 #ifdef HAVE_X_WINDOWS
1367 if (FRAME_X_P (frame
))
1369 current_frame
->pix_width
[vpos
]
1370 = current_frame
->used
[vpos
]
1371 * FONT_WIDTH (frame
->display
.x
->font
);
1372 current_frame
->pix_height
[vpos
]
1373 = FONT_HEIGHT (frame
->display
.x
->font
);
1375 #endif /* HAVE_X_WINDOWS */
1377 if (!desired_frame
->enable
[vpos
])
1383 nbody
= desired_frame
->glyphs
[vpos
];
1384 nlen
= desired_frame
->used
[vpos
];
1386 /* Pretend trailing spaces are not there at all,
1387 unless for one reason or another we must write all spaces. */
1388 if (! desired_frame
->highlight
[vpos
])
1390 if (!must_write_spaces
)
1391 /* We know that the previous character byte contains 0. */
1392 while (nbody
[nlen
- 1] == SPACEGLYPH
)
1397 /* For an inverse-video line, give it extra trailing spaces
1398 all the way to the frame edge
1399 so that the reverse video extends all the way across. */
1401 while (nlen
< FRAME_WIDTH (frame
) - 1)
1402 nbody
[nlen
++] = SPACEGLYPH
;
1405 /* If there's no i/d char, quickly do the best we can without it. */
1406 if (!char_ins_del_ok
)
1411 if (FRAME_X_P (frame
))
1413 /* Under X, erase everything we are going to rewrite,
1414 and rewrite everything from the first char that's changed.
1415 This is part of supporting fonts like Courier
1416 whose chars can overlap outside the char width. */
1417 for (i
= 0; i
< nlen
; i
++)
1418 if (i
>= olen
|| nbody
[i
] != obody
[i
])
1421 cursor_to (vpos
, i
);
1423 clear_end_of_line (olen
);
1424 write_glyphs (nbody
+ i
, nlen
- i
);
1429 for (i
= 0; i
< nlen
; i
++)
1431 if (i
>= olen
|| nbody
[i
] != obody
[i
]) /* A non-matching char. */
1433 cursor_to (vpos
, i
);
1434 for (j
= 1; (i
+ j
< nlen
&&
1435 (i
+ j
>= olen
|| nbody
[i
+j
] != obody
[i
+j
]));
1438 /* Output this run of non-matching chars. */
1439 write_glyphs (nbody
+ i
, j
);
1442 /* Now find the next non-match. */
1446 /* Clear the rest of the line, or the non-clear part of it. */
1449 cursor_to (vpos
, nlen
);
1450 clear_end_of_line (olen
);
1453 /* Exchange contents between current_frame and new_frame. */
1454 temp
= desired_frame
->glyphs
[vpos
];
1455 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1456 current_frame
->glyphs
[vpos
] = temp
;
1463 nsp
= (must_write_spaces
|| desired_frame
->highlight
[vpos
])
1464 ? 0 : count_blanks (nbody
);
1467 cursor_to (vpos
, nsp
);
1468 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
1471 /* Exchange contents between current_frame and new_frame. */
1472 temp
= desired_frame
->glyphs
[vpos
];
1473 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1474 current_frame
->glyphs
[vpos
] = temp
;
1483 /* Compute number of leading blanks in old and new contents. */
1484 osp
= count_blanks (obody
);
1485 if (!desired_frame
->highlight
[vpos
])
1486 nsp
= count_blanks (nbody
);
1490 /* Compute number of matching chars starting with first nonblank. */
1491 begmatch
= count_match (obody
+ osp
, nbody
+ nsp
);
1493 /* Spaces in new match implicit space past the end of old. */
1494 /* A bug causing this to be a no-op was fixed in 18.29. */
1495 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
1498 while (np1
[begmatch
] == SPACEGLYPH
)
1502 /* Avoid doing insert/delete char
1503 just cause number of leading spaces differs
1504 when the following text does not match. */
1505 if (begmatch
== 0 && osp
!= nsp
)
1506 osp
= nsp
= min (osp
, nsp
);
1508 /* Find matching characters at end of line */
1511 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
1512 while (op1
> op2
&& op1
[-1] == np1
[-1])
1517 endmatch
= obody
+ olen
- op1
;
1519 /* Put correct value back in nbody[nlen].
1520 This is important because direct_output_for_insert
1521 can write into the line at a later point.
1522 If this screws up the zero at the end of the line, re-establish it. */
1526 /* tem gets the distance to insert or delete.
1527 endmatch is how many characters we save by doing so.
1530 tem
= (nlen
- nsp
) - (olen
- osp
);
1532 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
1535 /* nsp - osp is the distance to insert or delete.
1536 If that is nonzero, begmatch is known to be nonzero also.
1537 begmatch + endmatch is how much we save by doing the ins/del.
1541 && (!char_ins_del_ok
1542 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
1546 osp
= nsp
= min (osp
, nsp
);
1549 /* Now go through the line, inserting, writing and
1550 deleting as appropriate. */
1554 cursor_to (vpos
, nsp
);
1555 delete_glyphs (osp
- nsp
);
1559 /* If going to delete chars later in line
1560 and insert earlier in the line,
1561 must delete first to avoid losing data in the insert */
1562 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
1564 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
1565 delete_glyphs (olen
+ nsp
- osp
- nlen
);
1566 olen
= nlen
- (nsp
- osp
);
1568 cursor_to (vpos
, osp
);
1569 insert_glyphs ((char *)0, nsp
- osp
);
1573 tem
= nsp
+ begmatch
+ endmatch
;
1574 if (nlen
!= tem
|| olen
!= tem
)
1576 cursor_to (vpos
, nsp
+ begmatch
);
1577 if (!endmatch
|| nlen
== olen
)
1579 /* If new text being written reaches right margin,
1580 there is no need to do clear-to-eol at the end.
1581 (and it would not be safe, since cursor is not
1582 going to be "at the margin" after the text is done) */
1583 if (nlen
== FRAME_WIDTH (frame
))
1585 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1589 /* the following code loses disastrously if tem == nlen.
1590 Rather than trying to fix that case, I am trying the simpler
1591 solution found above. */
1593 /* If the text reaches to the right margin,
1594 it will lose one way or another (depending on AutoWrap)
1595 to clear to end of line after outputting all the text.
1596 So pause with one character to go and clear the line then. */
1597 if (nlen
== FRAME_WIDTH (frame
) && fast_clear_end_of_line
&& olen
> nlen
)
1599 /* endmatch must be zero, and tem must equal nsp + begmatch */
1600 write_glyphs (nbody
+ tem
, nlen
- tem
- 1);
1601 clear_end_of_line (olen
);
1602 olen
= 0; /* Don't let it be cleared again later */
1603 write_glyphs (nbody
+ nlen
- 1, 1);
1606 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1607 #endif /* OBSOLETE */
1610 else if (nlen
> olen
)
1612 write_glyphs (nbody
+ nsp
+ begmatch
, olen
- tem
);
1613 insert_glyphs (nbody
+ nsp
+ begmatch
+ olen
- tem
, nlen
- olen
);
1616 else if (olen
> nlen
)
1618 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1619 delete_glyphs (olen
- nlen
);
1625 /* If any unerased characters remain after the new line, erase them. */
1628 cursor_to (vpos
, nlen
);
1629 clear_end_of_line (olen
);
1632 /* Exchange contents between current_frame and new_frame. */
1633 temp
= desired_frame
->glyphs
[vpos
];
1634 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1635 current_frame
->glyphs
[vpos
] = temp
;
1638 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
1639 1, 1, "FOpen termscript file: ",
1640 "Start writing all terminal output to FILE as well as the terminal.\n\
1641 FILE = nil means just close any termscript file currently open.")
1645 if (termscript
!= 0) fclose (termscript
);
1650 file
= Fexpand_file_name (file
, Qnil
);
1651 termscript
= fopen (XSTRING (file
)->data
, "w");
1652 if (termscript
== 0)
1653 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
1661 window_change_signal ()
1665 int old_errno
= errno
;
1667 get_frame_size (&width
, &height
);
1669 /* The frame size change obviously applies to a termcap-controlled
1670 frame. Find such a frame in the list, and assume it's the only
1671 one (since the redisplay code always writes to stdout, not a
1672 FILE * specified in the frame structure). Record the new size,
1673 but don't reallocate the data structures now. Let that be done
1674 later outside of the signal handler. */
1677 Lisp_Object tail
, frame
;
1679 FOR_EACH_FRAME (tail
, frame
)
1681 if (FRAME_TERMCAP_P (XFRAME (frame
)))
1683 change_frame_size (XFRAME (frame
), height
, width
, 0, 1);
1689 signal (SIGWINCH
, window_change_signal
);
1692 #endif /* SIGWINCH */
1695 /* Do any change in frame size that was requested by a signal. */
1697 do_pending_window_change ()
1699 /* If window_change_signal should have run before, run it now. */
1700 while (delayed_size_change
)
1702 Lisp_Object tail
, frame
;
1704 delayed_size_change
= 0;
1706 FOR_EACH_FRAME (tail
, frame
)
1708 FRAME_PTR f
= XFRAME (frame
);
1710 int height
= FRAME_NEW_HEIGHT (f
);
1711 int width
= FRAME_NEW_WIDTH (f
);
1713 if (height
!= 0 || width
!= 0)
1714 change_frame_size (f
, height
, width
, 0, 0);
1720 /* Change the frame height and/or width. Values may be given as zero to
1721 indicate no change is to take place.
1723 If DELAY is non-zero, then assume we're being called from a signal
1724 handler, and queue the change for later - perhaps the next
1725 redisplay. Since this tries to resize windows, we can't call it
1726 from a signal handler. */
1728 change_frame_size (frame
, newheight
, newwidth
, pretend
, delay
)
1729 register FRAME_PTR frame
;
1730 int newheight
, newwidth
, pretend
;
1732 /* If we can't deal with the change now, queue it for later. */
1735 FRAME_NEW_HEIGHT (frame
) = newheight
;
1736 FRAME_NEW_WIDTH (frame
) = newwidth
;
1737 delayed_size_change
= 1;
1741 /* This size-change overrides any pending one for this frame. */
1742 FRAME_NEW_HEIGHT (frame
) = 0;
1743 FRAME_NEW_WIDTH (frame
) = 0;
1745 /* If an argument is zero, set it to the current value. */
1746 newheight
|| (newheight
= FRAME_HEIGHT (frame
));
1747 newwidth
|| (newwidth
= FRAME_WIDTH (frame
));
1749 /* Round up to the smallest acceptable size. */
1750 check_frame_size (frame
, &newheight
, &newwidth
);
1752 /* If we're not changing the frame size, quit now. */
1753 if (newheight
== FRAME_HEIGHT (frame
)
1754 && newwidth
== FRAME_WIDTH (frame
))
1757 if (newheight
!= FRAME_HEIGHT (frame
))
1759 if (FRAME_HAS_MINIBUF_P (frame
)
1760 && ! FRAME_MINIBUF_ONLY_P (frame
))
1762 /* Frame has both root and minibuffer. */
1763 set_window_height (FRAME_ROOT_WINDOW (frame
),
1764 newheight
- 1 - FRAME_MENU_BAR_LINES (frame
), 0);
1765 XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (frame
))->top
)
1767 set_window_height (FRAME_MINIBUF_WINDOW (frame
), 1, 0);
1770 /* Frame has just one top-level window. */
1771 set_window_height (FRAME_ROOT_WINDOW (frame
),
1772 newheight
- FRAME_MENU_BAR_LINES (frame
), 0);
1774 if (FRAME_TERMCAP_P (frame
) && !pretend
)
1775 FrameRows
= newheight
;
1778 if (frame
->output_method
== output_termcap
)
1780 frame_height
= newheight
;
1782 FrameRows
= newheight
;
1787 if (newwidth
!= FRAME_WIDTH (frame
))
1789 set_window_width (FRAME_ROOT_WINDOW (frame
), newwidth
, 0);
1790 if (FRAME_HAS_MINIBUF_P (frame
))
1791 set_window_width (FRAME_MINIBUF_WINDOW (frame
), newwidth
, 0);
1793 if (FRAME_TERMCAP_P (frame
) && !pretend
)
1794 FrameCols
= newwidth
;
1796 if (frame
->output_method
== output_termcap
)
1798 frame_width
= newwidth
;
1800 FrameCols
= newwidth
;
1805 FRAME_HEIGHT (frame
) = newheight
;
1806 FRAME_WIDTH (frame
) = newwidth
;
1808 remake_frame_glyphs (frame
);
1809 calculate_costs (frame
);
1812 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
1813 Ssend_string_to_terminal
, 1, 1, 0,
1814 "Send STRING to the terminal without alteration.\n\
1815 Control characters in STRING will have terminal-dependent effects.")
1819 CHECK_STRING (str
, 0);
1820 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, stdout
);
1824 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, termscript
);
1825 fflush (termscript
);
1830 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
1831 "Beep, or flash the screen.\n\
1832 Also, unless an argument is given,\n\
1833 terminate any keyboard macro currently executing.")
1855 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
1856 error ("Keyboard macro terminated by a command ringing the bell");
1862 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
1863 "Pause, without updating display, for SECONDS seconds.\n\
1864 SECONDS may be a floating-point value, meaning that you can wait for a\n\
1865 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
1866 additional wait period, in milliseconds; this may be useful if your\n\
1867 Emacs was built without floating point support.\n\
1868 \(Not all operating systems support waiting for a fraction of a second.)")
1869 (seconds
, milliseconds
)
1870 Lisp_Object seconds
, milliseconds
;
1874 if (NILP (milliseconds
))
1875 XSET (milliseconds
, Lisp_Int
, 0);
1877 CHECK_NUMBER (milliseconds
, 1);
1878 usec
= XINT (milliseconds
) * 1000;
1880 #ifdef LISP_FLOAT_TYPE
1882 double duration
= extract_float (seconds
);
1883 sec
= (int) duration
;
1884 usec
+= (duration
- sec
) * 1000000;
1887 CHECK_NUMBER (seconds
, 0);
1888 sec
= XINT (seconds
);
1891 #ifndef EMACS_HAS_USECS
1892 if (sec
== 0 && usec
!= 0)
1893 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
1896 /* Assure that 0 <= usec < 1000000. */
1899 /* We can't rely on the rounding being correct if user is negative. */
1900 if (-1000000 < usec
)
1901 sec
--, usec
+= 1000000;
1903 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
1906 sec
+= usec
/ 1000000, usec
%= 1000000;
1914 XFASTINT (zero
) = 0;
1915 wait_reading_process_input (sec
, usec
, zero
, 0);
1918 /* We should always have wait_reading_process_input; we have a dummy
1919 implementation for systems which don't support subprocesses. */
1921 /* No wait_reading_process_input */
1928 /* The reason this is done this way
1929 (rather than defined (H_S) && defined (H_T))
1930 is because the VMS preprocessor doesn't grok `defined' */
1932 EMACS_GET_TIME (end_time
);
1933 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
1934 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
1938 EMACS_GET_TIME (timeout
);
1939 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
1940 if (EMACS_TIME_NEG_P (timeout
)
1941 || !select (1, 0, 0, 0, &timeout
))
1944 #else /* not HAVE_SELECT */
1946 #endif /* HAVE_SELECT */
1947 #endif /* not VMS */
1950 #endif /* no subprocesses */
1955 /* This is just like wait_reading_process_input, except that
1956 it does the redisplay.
1958 It's also just like Fsit_for, except that it can be used for
1959 waiting for input as well. */
1962 sit_for (sec
, usec
, reading
, display
)
1963 int sec
, usec
, reading
, display
;
1965 Lisp_Object read_kbd
;
1967 if (detect_input_pending ())
1971 redisplay_preserve_echo_area ();
1973 if (sec
== 0 && usec
== 0)
1980 XSET (read_kbd
, Lisp_Int
, reading
? -1 : 1);
1981 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
1984 /* wait_reading_process_input should always be available now; it is
1985 simulated in a simple way on systems that don't support
1988 /* No wait_reading_process_input available. */
1994 input_wait_timeout (XINT (arg
));
1996 #ifndef HAVE_TIMEVAL
1998 select (1, &waitchannels
, 0, 0, &timeout_sec
);
1999 #else /* HAVE_TIMEVAL */
2000 timeout
.tv_sec
= sec
;
2001 timeout
.tv_usec
= usec
;
2002 select (1, &waitchannels
, 0, 0, &timeout
);
2003 #endif /* HAVE_TIMEVAL */
2004 #endif /* not VMS */
2009 return detect_input_pending () ? Qnil
: Qt
;
2012 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
2013 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
2014 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2015 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2016 additional wait period, in milliseconds; this may be useful if your\n\
2017 Emacs was built without floating point support.\n\
2018 \(Not all operating systems support waiting for a fraction of a second.)\n\
2019 Optional third arg non-nil means don't redisplay, just wait for input.\n\
2020 Redisplay is preempted as always if input arrives, and does not happen\n\
2021 if input is available before it starts.\n\
2022 Value is t if waited the full time with no input arriving.")
2023 (seconds
, milliseconds
, nodisp
)
2024 Lisp_Object seconds
, milliseconds
, nodisp
;
2028 if (NILP (milliseconds
))
2029 XSET (milliseconds
, Lisp_Int
, 0);
2031 CHECK_NUMBER (milliseconds
, 1);
2032 usec
= XINT (milliseconds
) * 1000;
2034 #ifdef LISP_FLOAT_TYPE
2036 double duration
= extract_float (seconds
);
2037 sec
= (int) duration
;
2038 usec
+= (duration
- sec
) * 1000000;
2041 CHECK_NUMBER (seconds
, 0);
2042 sec
= XINT (seconds
);
2045 #ifndef EMACS_HAS_USECS
2046 if (usec
!= 0 && sec
== 0)
2047 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
2050 return sit_for (sec
, usec
, 0, NILP (nodisp
));
2053 char *terminal_type
;
2055 /* Initialization done when Emacs fork is started, before doing stty. */
2056 /* Determine terminal type and set terminal_driver */
2057 /* Then invoke its decoding routine to set up variables
2058 in the terminal package */
2062 #ifdef HAVE_X_WINDOWS
2063 extern int display_arg
;
2068 cursor_in_echo_area
= 0;
2069 terminal_type
= (char *) 0;
2071 /* Now is the time to initialize this; it's used by init_sys_modes
2073 Vwindow_system
= Qnil
;
2075 /* If the user wants to use a window system, we shouldn't bother
2076 initializing the terminal. This is especially important when the
2077 terminal is so dumb that emacs gives up before and doesn't bother
2078 using the window system.
2080 If the DISPLAY environment variable is set, try to use X, and die
2081 with an error message if that doesn't work. */
2083 #ifdef HAVE_X_WINDOWS
2087 display_arg
= (getenv ("DECW$DISPLAY") != 0);
2089 display_arg
= (getenv ("DISPLAY") != 0);
2093 if (!inhibit_window_system
&& display_arg
)
2095 Vwindow_system
= intern ("x");
2097 Vwindow_system_version
= make_number (11);
2099 Vwindow_system_version
= make_number (10);
2103 #endif /* HAVE_X_WINDOWS */
2105 /* If no window system has been specified, try to use the terminal. */
2108 fprintf (stderr
, "emacs: standard input is not a tty\n");
2112 /* Look at the TERM variable */
2113 terminal_type
= (char *) getenv ("TERM");
2117 fprintf (stderr
, "Please specify your terminal type.\n\
2118 For types defined in VMS, use set term /device=TYPE.\n\
2119 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
2120 \(The quotation marks are necessary since terminal types are lower case.)\n");
2122 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
2128 /* VMS DCL tends to upcase things, so downcase term type.
2129 Hardly any uppercase letters in terminal types; should be none. */
2131 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
2134 strcpy (new, terminal_type
);
2136 for (p
= new; *p
; p
++)
2140 terminal_type
= new;
2144 term_init (terminal_type
);
2146 remake_frame_glyphs (selected_frame
);
2147 calculate_costs (selected_frame
);
2149 /* X and Y coordinates of the cursor between updates. */
2150 FRAME_CURSOR_X (selected_frame
) = 0;
2151 FRAME_CURSOR_Y (selected_frame
) = 0;
2156 #endif /* CANNOT_DUMP */
2157 signal (SIGWINCH
, window_change_signal
);
2158 #endif /* SIGWINCH */
2164 defsubr (&Sredraw_frame
);
2166 defsubr (&Sredraw_display
);
2167 defsubr (&Sopen_termscript
);
2169 defsubr (&Ssit_for
);
2170 defsubr (&Ssleep_for
);
2171 defsubr (&Ssend_string_to_terminal
);
2173 DEFVAR_INT ("baud-rate", &baud_rate
,
2174 "The output baud rate of the terminal.\n\
2175 On most systems, changing this value will affect the amount of padding\n\
2176 and the other strategic decisions made during redisplay.");
2177 DEFVAR_BOOL ("inverse-video", &inverse_video
,
2178 "*Non-nil means invert the entire frame display.\n\
2179 This means everything is in inverse video which otherwise would not be.");
2180 DEFVAR_BOOL ("visible-bell", &visible_bell
,
2181 "*Non-nil means try to flash the frame to represent a bell.");
2182 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
2183 "*Non-nil means no need to redraw entire frame after suspending.\n\
2184 A non-nil value is useful if the terminal can automatically preserve\n\
2185 Emacs's frame display when you reenter Emacs.\n\
2186 It is up to you to set this variable if your terminal can do that.");
2187 DEFVAR_LISP ("window-system", &Vwindow_system
,
2188 "A symbol naming the window-system under which Emacs is running\n\
2189 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
2190 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
2191 "The version number of the window system in use.\n\
2192 For X windows, this is 10 or 11.");
2193 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
2194 "Non-nil means put cursor in minibuffer, at end of any message there.");
2195 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
2196 "Table defining how to output a glyph code to the frame.\n\
2197 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
2198 Each element can be:\n\
2199 integer: a glyph code which this glyph is an alias for.\n\
2200 string: output this glyph using that string (not impl. in X windows).\n\
2201 nil: this glyph mod 256 is char code to output,\n\
2202 and this glyph / 256 is face code for X windows (see `x-set-face').");
2203 Vglyph_table
= Qnil
;
2205 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
2206 "Display table to use for buffers that specify none.\n\
2207 See `buffer-display-table' for more information.");
2208 Vstandard_display_table
= Qnil
;
2210 /* Initialize `window-system', unless init_display already decided it. */
2215 Vwindow_system
= Qnil
;
2216 Vwindow_system_version
= Qnil
;