1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985, 86, 87, 88, 93, 94 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"
45 #endif /* HAVE_X_WINDOWS */
47 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
52 #define max(a, b) ((a) > (b) ? (a) : (b))
53 #define min(a, b) ((a) < (b) ? (a) : (b))
55 /* Get number of chars of output now in the buffer of a stdio stream.
56 This ought to be built in in stdio, but it isn't.
57 Some s- files override this because their stdio internals differ. */
58 #ifdef __GNU_LIBRARY__
59 /* The s- file might have overridden the definition with one that works for
60 the system's C library. But we are using the GNU C library, so this is
61 the right definition for every system. */
62 #ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT
63 #define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT
65 #undef PENDING_OUTPUT_COUNT
66 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
68 #else /* not __GNU_LIBRARY__ */
69 #ifndef PENDING_OUTPUT_COUNT
70 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
74 /* Nonzero upon entry to redisplay means do not assume anything about
75 current contents of actual terminal frame; clear and redraw it. */
79 /* Nonzero means last display completed. Zero means it was preempted. */
81 int display_completed
;
83 /* Lisp variable visible-bell; enables use of screen-flash
84 instead of audible bell. */
88 /* Invert the color of the whole frame, at a low level. */
92 /* Line speed of the terminal. */
96 /* nil or a symbol naming the window system under which emacs is
97 running ('x is the only current possibility). */
99 Lisp_Object Vwindow_system
;
101 /* Version number of X windows: 10, 11 or nil. */
102 Lisp_Object Vwindow_system_version
;
104 /* Vector of glyph definitions. Indexed by glyph number,
105 the contents are a string which is how to output the glyph.
107 If Vglyph_table is nil, a glyph is output by using its low 8 bits
108 as a character code. */
110 Lisp_Object Vglyph_table
;
112 /* Display table to use for vectors that don't specify their own. */
114 Lisp_Object Vstandard_display_table
;
116 /* Nonzero means reading single-character input with prompt
117 so put cursor on minibuffer after the prompt.
118 positive means at end of text in echo area;
119 negative means at beginning of line. */
120 int cursor_in_echo_area
;
122 /* The currently selected frame.
123 In a single-frame version, this variable always remains 0. */
125 FRAME_PTR selected_frame
;
127 /* A frame which is not just a minibuffer, or 0 if there are no such
128 frames. This is usually the most recent such frame that was
129 selected. In a single-frame version, this variable always remains 0. */
130 FRAME_PTR last_nonminibuf_frame
;
132 /* In a single-frame version, the information that would otherwise
133 exist inside frame objects lives in the following structure instead.
135 NOTE: the_only_frame is not checked for garbage collection; don't
136 store collectible objects in any of its fields!
138 You're not/The only frame in town/... */
141 struct frame the_only_frame
;
144 /* This is a vector, made larger whenever it isn't large enough,
145 which is used inside `update_frame' to hold the old contents
146 of the FRAME_PHYS_LINES of the frame being updated. */
147 struct frame_glyphs
**ophys_lines
;
148 /* Length of vector currently allocated. */
149 int ophys_lines_length
;
151 FILE *termscript
; /* Stdio stream being used for copy of all output. */
153 struct cm Wcm
; /* Structure for info on cursor positioning */
155 extern short ospeed
; /* Output speed (from sg_ospeed) */
157 int delayed_size_change
; /* 1 means SIGWINCH happened when not safe. */
161 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
162 "Clear frame FRAME and output again what is supposed to appear on it.")
168 CHECK_LIVE_FRAME (frame
, 0);
171 /* set_terminal_modes (); */
173 clear_frame_records (f
);
176 windows_or_buffers_changed
++;
177 /* Mark all windows as INaccurate,
178 so that every window will have its redisplay done. */
179 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
188 XSET (frame
, Lisp_Frame
, f
);
189 Fredraw_frame (frame
);
194 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
195 "Clear frame FRAME and output again what is supposed to appear on it.")
200 set_terminal_modes ();
204 clear_frame_records (0);
205 windows_or_buffers_changed
++;
206 /* Mark all windows as INaccurate,
207 so that every window will have its redisplay done. */
208 mark_window_display_accurate (FRAME_ROOT_WINDOW (0), 0);
214 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
215 "Clear and redisplay all visible frames.")
218 Lisp_Object tail
, frame
;
220 FOR_EACH_FRAME (tail
, frame
)
221 if (FRAME_VISIBLE_P (XFRAME (frame
)))
222 Fredraw_frame (frame
);
227 /* This is used when frame_garbaged is set.
228 Redraw the individual frames marked as garbaged. */
231 redraw_garbaged_frames ()
233 Lisp_Object tail
, frame
;
235 FOR_EACH_FRAME (tail
, frame
)
236 if (FRAME_VISIBLE_P (XFRAME (frame
))
237 && FRAME_GARBAGED_P (XFRAME (frame
)))
238 Fredraw_frame (frame
);
242 static struct frame_glyphs
*
243 make_frame_glyphs (frame
, empty
)
244 register FRAME_PTR frame
;
248 register width
= FRAME_WIDTH (frame
);
249 register height
= FRAME_HEIGHT (frame
);
250 register struct frame_glyphs
*new
251 = (struct frame_glyphs
*) xmalloc (sizeof (struct frame_glyphs
));
253 SET_GLYPHS_FRAME (new, frame
);
254 new->height
= height
;
256 new->used
= (int *) xmalloc (height
* sizeof (int));
257 new->glyphs
= (GLYPH
**) xmalloc (height
* sizeof (GLYPH
*));
258 new->charstarts
= (int **) xmalloc (height
* sizeof (int *));
259 new->highlight
= (char *) xmalloc (height
* sizeof (char));
260 new->enable
= (char *) xmalloc (height
* sizeof (char));
261 bzero (new->enable
, height
* sizeof (char));
262 new->bufp
= (int *) xmalloc (height
* sizeof (int));
264 #ifdef HAVE_X_WINDOWS
265 if (FRAME_X_P (frame
))
267 new->top_left_x
= (short *) xmalloc (height
* sizeof (short));
268 new->top_left_y
= (short *) xmalloc (height
* sizeof (short));
269 new->pix_width
= (short *) xmalloc (height
* sizeof (short));
270 new->pix_height
= (short *) xmalloc (height
* sizeof (short));
271 new->max_ascent
= (short *) xmalloc (height
* sizeof (short));
277 /* Make the buffer used by decode_mode_spec. This buffer is also
278 used as temporary storage when updating the frame. See scroll.c. */
279 unsigned int total_glyphs
= (width
+ 2) * sizeof (GLYPH
);
280 unsigned int total_charstarts
= (width
+ 2) * sizeof (int);
282 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
283 bzero (new->total_contents
, total_glyphs
);
285 new->total_charstarts
= (int *) xmalloc (total_charstarts
);
286 bzero (new->total_charstarts
, total_glyphs
);
290 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (GLYPH
);
292 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
293 bzero (new->total_contents
, total_glyphs
);
294 for (i
= 0; i
< height
; i
++)
295 new->glyphs
[i
] = new->total_contents
+ i
* (width
+ 2) + 1;
297 if (!FRAME_TERMCAP_P (frame
))
299 unsigned int total_charstarts
= height
* (width
+ 2) * sizeof (int);
301 new->total_charstarts
= (int *) xmalloc (total_charstarts
);
302 bzero (new->total_charstarts
, total_charstarts
);
303 for (i
= 0; i
< height
; i
++)
304 new->charstarts
[i
] = new->total_charstarts
+ i
* (width
+ 2) + 1;
308 /* Without a window system, we don't really need charstarts.
309 So use a small amount of space to make enough data structure
310 to prevent crashes in display_text_line. */
311 new->total_charstarts
= (int *) xmalloc ((width
+ 2) * sizeof (int));
312 for (i
= 0; i
< height
; i
++)
313 new->charstarts
[i
] = new->total_charstarts
;
321 free_frame_glyphs (frame
, glyphs
)
323 struct frame_glyphs
*glyphs
;
325 if (glyphs
->total_contents
)
326 xfree (glyphs
->total_contents
);
327 if (glyphs
->total_charstarts
)
328 xfree (glyphs
->total_charstarts
);
330 xfree (glyphs
->used
);
331 xfree (glyphs
->glyphs
);
332 xfree (glyphs
->highlight
);
333 xfree (glyphs
->enable
);
334 xfree (glyphs
->bufp
);
335 if (glyphs
->charstarts
)
336 xfree (glyphs
->charstarts
);
338 #ifdef HAVE_X_WINDOWS
339 if (FRAME_X_P (frame
))
341 xfree (glyphs
->top_left_x
);
342 xfree (glyphs
->top_left_y
);
343 xfree (glyphs
->pix_width
);
344 xfree (glyphs
->pix_height
);
345 xfree (glyphs
->max_ascent
);
353 remake_frame_glyphs (frame
)
356 if (FRAME_CURRENT_GLYPHS (frame
))
357 free_frame_glyphs (frame
, FRAME_CURRENT_GLYPHS (frame
));
358 if (FRAME_DESIRED_GLYPHS (frame
))
359 free_frame_glyphs (frame
, FRAME_DESIRED_GLYPHS (frame
));
360 if (FRAME_TEMP_GLYPHS (frame
))
361 free_frame_glyphs (frame
, FRAME_TEMP_GLYPHS (frame
));
363 if (FRAME_MESSAGE_BUF (frame
))
365 /* Reallocate the frame's message buffer; remember that
366 echo_area_glyphs may be pointing here. */
367 char *old_message_buf
= FRAME_MESSAGE_BUF (frame
);
369 FRAME_MESSAGE_BUF (frame
)
370 = (char *) xrealloc (FRAME_MESSAGE_BUF (frame
),
371 FRAME_WIDTH (frame
) + 1);
373 if (echo_area_glyphs
== old_message_buf
)
374 echo_area_glyphs
= FRAME_MESSAGE_BUF (frame
);
375 if (previous_echo_glyphs
== old_message_buf
)
376 previous_echo_glyphs
= FRAME_MESSAGE_BUF (frame
);
379 FRAME_MESSAGE_BUF (frame
)
380 = (char *) xmalloc (FRAME_WIDTH (frame
) + 1);
382 FRAME_CURRENT_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
383 FRAME_DESIRED_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
384 FRAME_TEMP_GLYPHS (frame
) = make_frame_glyphs (frame
, 1);
385 SET_FRAME_GARBAGED (frame
);
388 /* Return the hash code of contents of line VPOS in frame-matrix M. */
391 line_hash_code (m
, vpos
)
392 register struct frame_glyphs
*m
;
395 register GLYPH
*body
, *end
;
398 if (!m
->enable
[vpos
])
401 /* Give all highlighted lines the same hash code
402 so as to encourage scrolling to leave them in place. */
403 if (m
->highlight
[vpos
])
406 body
= m
->glyphs
[vpos
];
408 if (must_write_spaces
)
415 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
- SPACEGLYPH
;
424 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
;
432 /* Return number of characters in line in M at vpos VPOS,
433 except don't count leading and trailing spaces
434 unless the terminal requires those to be explicitly output. */
437 line_draw_cost (m
, vpos
)
438 struct frame_glyphs
*m
;
441 register GLYPH
*beg
= m
->glyphs
[vpos
];
442 register GLYPH
*end
= m
->glyphs
[vpos
] + m
->used
[vpos
];
444 register int tlen
= GLYPH_TABLE_LENGTH
;
445 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
447 /* Ignore trailing and leading spaces if we can. */
448 if (!must_write_spaces
)
450 while ((end
!= beg
) && (*end
== SPACEGLYPH
))
453 return (0); /* All blank line. */
455 while (*beg
== SPACEGLYPH
)
459 /* If we don't have a glyph-table, each glyph is one character,
460 so return the number of glyphs. */
464 /* Otherwise, scan the glyphs and accumulate their total size in I. */
466 while ((beg
<= end
) && *beg
)
468 register GLYPH g
= *beg
++;
470 if (GLYPH_SIMPLE_P (tbase
, tlen
, g
))
473 i
+= GLYPH_LENGTH (tbase
, g
);
478 /* The functions on this page are the interface from xdisp.c to redisplay.
480 The only other interface into redisplay is through setting
481 FRAME_CURSOR_X (frame) and FRAME_CURSOR_Y (frame)
482 and SET_FRAME_GARBAGED (frame). */
484 /* cancel_line eliminates any request to display a line at position `vpos' */
486 cancel_line (vpos
, frame
)
488 register FRAME_PTR frame
;
490 FRAME_DESIRED_GLYPHS (frame
)->enable
[vpos
] = 0;
493 clear_frame_records (frame
)
494 register FRAME_PTR frame
;
496 bzero (FRAME_CURRENT_GLYPHS (frame
)->enable
, FRAME_HEIGHT (frame
));
499 /* Prepare to display on line VPOS starting at HPOS within it. */
502 get_display_line (frame
, vpos
, hpos
)
503 register FRAME_PTR frame
;
507 register struct frame_glyphs
*glyphs
;
508 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (frame
);
514 if ((desired_glyphs
->enable
[vpos
]) && desired_glyphs
->used
[vpos
] > hpos
)
517 if (! desired_glyphs
->enable
[vpos
])
519 desired_glyphs
->used
[vpos
] = 0;
520 desired_glyphs
->highlight
[vpos
] = 0;
521 desired_glyphs
->enable
[vpos
] = 1;
524 if (hpos
> desired_glyphs
->used
[vpos
])
526 GLYPH
*g
= desired_glyphs
->glyphs
[vpos
] + desired_glyphs
->used
[vpos
];
527 GLYPH
*end
= desired_glyphs
->glyphs
[vpos
] + hpos
;
529 desired_glyphs
->used
[vpos
] = hpos
;
535 /* Like bcopy except never gets confused by overlap. */
538 safe_bcopy (from
, to
, size
)
542 if (size
<= 0 || from
== to
)
545 /* If the source and destination don't overlap, then bcopy can
546 handle it. If they do overlap, but the destination is lower in
547 memory than the source, we'll assume bcopy can handle that. */
548 if (to
< from
|| from
+ size
<= to
)
549 bcopy (from
, to
, size
);
551 /* Otherwise, we'll copy from the end. */
554 register char *endf
= from
+ size
;
555 register char *endt
= to
+ size
;
557 /* If TO - FROM is large, then we should break the copy into
558 nonoverlapping chunks of TO - FROM bytes each. However, if
559 TO - FROM is small, then the bcopy function call overhead
560 makes this not worth it. The crossover point could be about
561 anywhere. Since I don't think the obvious copy loop is too
562 bad, I'm trying to err in its favor. */
567 while (endf
!= from
);
579 bcopy (endf
, endt
, to
- from
);
582 /* If SIZE wasn't a multiple of TO - FROM, there will be a
583 little left over. The amount left over is
584 (endt + (to - from)) - to, which is endt - from. */
585 bcopy (from
, to
, endt
- from
);
590 /* Rotate a vector of SIZE bytes right, by DISTANCE bytes.
591 DISTANCE may be negative. */
594 rotate_vector (vector
, size
, distance
)
599 char *temp
= (char *) alloca (size
);
604 bcopy (vector
, temp
+ distance
, size
- distance
);
605 bcopy (vector
+ size
- distance
, temp
, distance
);
606 bcopy (temp
, vector
, size
);
609 /* Scroll lines from vpos FROM up to but not including vpos END
610 down by AMOUNT lines (AMOUNT may be negative).
611 Returns nonzero if done, zero if terminal cannot scroll them. */
614 scroll_frame_lines (frame
, from
, end
, amount
, newpos
)
615 register FRAME_PTR frame
;
616 int from
, end
, amount
, newpos
;
619 register struct frame_glyphs
*current_frame
620 = FRAME_CURRENT_GLYPHS (frame
);
622 int width
= FRAME_WIDTH (frame
);
624 if (!line_ins_del_ok
)
632 update_begin (frame
);
633 set_terminal_window (end
+ amount
);
634 if (!scroll_region_ok
)
635 ins_del_lines (end
, -amount
);
636 ins_del_lines (from
, amount
);
637 set_terminal_window (0);
639 rotate_vector (current_frame
->glyphs
+ from
,
640 sizeof (GLYPH
*) * (end
+ amount
- from
),
641 amount
* sizeof (GLYPH
*));
643 rotate_vector (current_frame
->charstarts
+ from
,
644 sizeof (int *) * (end
+ amount
- from
),
645 amount
* sizeof (int *));
647 safe_bcopy (current_frame
->used
+ from
,
648 current_frame
->used
+ from
+ amount
,
649 (end
- from
) * sizeof current_frame
->used
[0]);
651 safe_bcopy (current_frame
->highlight
+ from
,
652 current_frame
->highlight
+ from
+ amount
,
653 (end
- from
) * sizeof current_frame
->highlight
[0]);
655 safe_bcopy (current_frame
->enable
+ from
,
656 current_frame
->enable
+ from
+ amount
,
657 (end
- from
) * sizeof current_frame
->enable
[0]);
659 /* Adjust the lines by an amount
660 that puts the first of them at NEWPOS. */
661 pos_adjust
= newpos
- current_frame
->charstarts
[from
+ amount
][0];
663 /* Offset each char position in the charstarts lines we moved
665 for (i
= from
+ amount
; i
< end
+ amount
; i
++)
667 int *line
= current_frame
->charstarts
[i
];
669 for (col
= 0; col
< width
; col
++)
671 line
[col
] += pos_adjust
;
673 for (i
= from
; i
< from
+ amount
; i
++)
675 int *line
= current_frame
->charstarts
[i
];
678 for (col
= 0; col
< width
; col
++)
682 /* Mark the lines made empty by scrolling as enabled, empty and
684 bzero (current_frame
->used
+ from
,
685 amount
* sizeof current_frame
->used
[0]);
686 bzero (current_frame
->highlight
+ from
,
687 amount
* sizeof current_frame
->highlight
[0]);
688 for (i
= from
; i
< from
+ amount
; i
++)
690 current_frame
->glyphs
[i
][0] = '\0';
691 current_frame
->charstarts
[i
][0] = -1;
692 current_frame
->enable
[i
] = 1;
695 safe_bcopy (current_frame
->bufp
+ from
,
696 current_frame
->bufp
+ from
+ amount
,
697 (end
- from
) * sizeof current_frame
->bufp
[0]);
699 #ifdef HAVE_X_WINDOWS
700 if (FRAME_X_P (frame
))
702 safe_bcopy (current_frame
->top_left_x
+ from
,
703 current_frame
->top_left_x
+ from
+ amount
,
704 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
706 safe_bcopy (current_frame
->top_left_y
+ from
,
707 current_frame
->top_left_y
+ from
+ amount
,
708 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
710 safe_bcopy (current_frame
->pix_width
+ from
,
711 current_frame
->pix_width
+ from
+ amount
,
712 (end
- from
) * sizeof current_frame
->pix_width
[0]);
714 safe_bcopy (current_frame
->pix_height
+ from
,
715 current_frame
->pix_height
+ from
+ amount
,
716 (end
- from
) * sizeof current_frame
->pix_height
[0]);
718 safe_bcopy (current_frame
->max_ascent
+ from
,
719 current_frame
->max_ascent
+ from
+ amount
,
720 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
722 #endif /* HAVE_X_WINDOWS */
728 update_begin (frame
);
729 set_terminal_window (end
);
730 ins_del_lines (from
+ amount
, amount
);
731 if (!scroll_region_ok
)
732 ins_del_lines (end
+ amount
, -amount
);
733 set_terminal_window (0);
735 rotate_vector (current_frame
->glyphs
+ from
+ amount
,
736 sizeof (GLYPH
*) * (end
- from
- amount
),
737 amount
* sizeof (GLYPH
*));
739 rotate_vector (current_frame
->charstarts
+ from
+ amount
,
740 sizeof (int *) * (end
- from
- amount
),
741 amount
* sizeof (int *));
743 safe_bcopy (current_frame
->used
+ from
,
744 current_frame
->used
+ from
+ amount
,
745 (end
- from
) * sizeof current_frame
->used
[0]);
747 safe_bcopy (current_frame
->highlight
+ from
,
748 current_frame
->highlight
+ from
+ amount
,
749 (end
- from
) * sizeof current_frame
->highlight
[0]);
751 safe_bcopy (current_frame
->enable
+ from
,
752 current_frame
->enable
+ from
+ amount
,
753 (end
- from
) * sizeof current_frame
->enable
[0]);
755 /* Adjust the lines by an amount
756 that puts the first of them at NEWPOS. */
757 pos_adjust
= newpos
- current_frame
->charstarts
[from
+ amount
][0];
759 /* Offset each char position in the charstarts lines we moved
761 for (i
= from
+ amount
; i
< end
+ amount
; i
++)
763 int *line
= current_frame
->charstarts
[i
];
765 for (col
= 0; col
< width
; col
++)
767 line
[col
] += pos_adjust
;
769 for (i
= end
+ amount
; i
< end
; i
++)
771 int *line
= current_frame
->charstarts
[i
];
774 for (col
= 0; col
< width
; col
++)
778 /* Mark the lines made empty by scrolling as enabled, empty and
780 bzero (current_frame
->used
+ end
+ amount
,
781 - amount
* sizeof current_frame
->used
[0]);
782 bzero (current_frame
->highlight
+ end
+ amount
,
783 - amount
* sizeof current_frame
->highlight
[0]);
784 for (i
= end
+ amount
; i
< end
; i
++)
786 current_frame
->glyphs
[i
][0] = '\0';
787 current_frame
->charstarts
[i
][0] = 0;
788 current_frame
->enable
[i
] = 1;
791 safe_bcopy (current_frame
->bufp
+ from
,
792 current_frame
->bufp
+ from
+ amount
,
793 (end
- from
) * sizeof current_frame
->bufp
[0]);
795 #ifdef HAVE_X_WINDOWS
796 if (FRAME_X_P (frame
))
798 safe_bcopy (current_frame
->top_left_x
+ from
,
799 current_frame
->top_left_x
+ from
+ amount
,
800 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
802 safe_bcopy (current_frame
->top_left_y
+ from
,
803 current_frame
->top_left_y
+ from
+ amount
,
804 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
806 safe_bcopy (current_frame
->pix_width
+ from
,
807 current_frame
->pix_width
+ from
+ amount
,
808 (end
- from
) * sizeof current_frame
->pix_width
[0]);
810 safe_bcopy (current_frame
->pix_height
+ from
,
811 current_frame
->pix_height
+ from
+ amount
,
812 (end
- from
) * sizeof current_frame
->pix_height
[0]);
814 safe_bcopy (current_frame
->max_ascent
+ from
,
815 current_frame
->max_ascent
+ from
+ amount
,
816 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
818 #endif /* HAVE_X_WINDOWS */
825 /* After updating a window W that isn't the full frame wide,
826 copy all the columns that W does not occupy
827 into the FRAME_DESIRED_GLYPHS (frame) from the FRAME_PHYS_GLYPHS (frame)
828 so that update_frame will not change those columns. */
830 preserve_other_columns (w
)
834 register struct frame_glyphs
*current_frame
, *desired_frame
;
835 register FRAME_PTR frame
= XFRAME (w
->frame
);
836 int start
= XFASTINT (w
->left
);
837 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
838 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
840 current_frame
= FRAME_CURRENT_GLYPHS (frame
);
841 desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
843 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
845 if (current_frame
->enable
[vpos
] && desired_frame
->enable
[vpos
])
851 bcopy (current_frame
->glyphs
[vpos
],
852 desired_frame
->glyphs
[vpos
],
853 start
* sizeof (current_frame
->glyphs
[vpos
]));
854 bcopy (current_frame
->charstarts
[vpos
],
855 desired_frame
->charstarts
[vpos
],
856 start
* sizeof (current_frame
->charstarts
[vpos
]));
857 len
= min (start
, current_frame
->used
[vpos
]);
858 if (desired_frame
->used
[vpos
] < len
)
859 desired_frame
->used
[vpos
] = len
;
861 if (current_frame
->used
[vpos
] > end
862 && desired_frame
->used
[vpos
] < current_frame
->used
[vpos
])
864 while (desired_frame
->used
[vpos
] < end
)
866 int used
= desired_frame
->used
[vpos
]++;
867 desired_frame
->glyphs
[vpos
][used
] = SPACEGLYPH
;
868 desired_frame
->glyphs
[vpos
][used
] = 0;
870 bcopy (current_frame
->glyphs
[vpos
] + end
,
871 desired_frame
->glyphs
[vpos
] + end
,
872 ((current_frame
->used
[vpos
] - end
)
873 * sizeof (current_frame
->glyphs
[vpos
])));
874 bcopy (current_frame
->charstarts
[vpos
] + end
,
875 desired_frame
->charstarts
[vpos
] + end
,
876 ((current_frame
->used
[vpos
] - end
)
877 * sizeof (current_frame
->charstarts
[vpos
])));
878 desired_frame
->used
[vpos
] = current_frame
->used
[vpos
];
886 /* If window w does not need to be updated and isn't the full frame wide,
887 copy all the columns that w does occupy
888 into the FRAME_DESIRED_LINES (frame) from the FRAME_PHYS_LINES (frame)
889 so that update_frame will not change those columns.
891 Have not been able to figure out how to use this correctly. */
893 preserve_my_columns (w
)
896 register int vpos
, fin
;
897 register struct frame_glyphs
*l1
, *l2
;
898 register FRAME_PTR frame
= XFRAME (w
->frame
);
899 int start
= XFASTINT (w
->left
);
900 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
901 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
903 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
905 if ((l1
= FRAME_DESIRED_GLYPHS (frame
)->glyphs
[vpos
+ 1])
906 && (l2
= FRAME_PHYS_GLYPHS (frame
)->glyphs
[vpos
+ 1]))
908 if (l2
->length
> start
&& l1
->length
< l2
->length
)
911 if (fin
> end
) fin
= end
;
912 while (l1
->length
< start
)
913 l1
->body
[l1
->length
++] = ' ';
914 bcopy (l2
->body
+ start
, l1
->body
+ start
, fin
- start
);
923 /* Adjust by ADJUST the charstart values in window W
924 after vpos VPOS, which counts relative to the frame
925 (not relative to W itself). */
928 adjust_window_charstarts (w
, vpos
, adjust
)
933 int left
= XFASTINT (w
->left
);
934 int top
= XFASTINT (w
->top
);
935 int right
= left
+ window_internal_width (w
);
936 int bottom
= top
+ window_internal_height (w
);
939 for (i
= vpos
+ 1; i
< bottom
; i
++)
942 = FRAME_CURRENT_GLYPHS (XFRAME (WINDOW_FRAME (w
)))->charstarts
[i
];
944 for (j
= left
; j
< right
; j
++)
945 if (charstart
[j
] > 0)
946 charstart
[j
] += adjust
;
950 /* Check the charstarts values in the area of window W
951 for internal consistency. We cannot check that they are "right";
952 we can only look for something nonsensical. */
954 verify_charstarts (w
)
957 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
959 int top
= XFASTINT (w
->top
);
960 int bottom
= top
+ window_internal_height (w
);
961 int left
= XFASTINT (w
->left
);
962 int right
= left
+ window_internal_width (w
);
964 int truncate
= (XINT (w
->hscroll
)
965 || (truncate_partial_width_windows
966 && (XFASTINT (w
->width
) < FRAME_WIDTH (f
)))
967 || !NILP (XBUFFER (w
->buffer
)->truncate_lines
));
969 for (i
= top
; i
< bottom
; i
++)
973 int *charstart
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[i
];
979 /* If we are truncating lines, allow a jump
980 in charstarts from one line to the next. */
981 if (charstart
[left
] < next_line
)
986 if (charstart
[left
] != next_line
)
991 for (j
= left
; j
< right
; j
++)
992 if (charstart
[j
] > 0)
994 /* Record where the next line should start. */
996 if (BUF_ZV (XBUFFER (w
->buffer
)) != last
)
998 /* If there's a newline between the two lines, count that. */
999 int endchar
= *BUF_CHAR_ADDRESS (XBUFFER (w
->buffer
), last
);
1000 if (endchar
== '\n')
1006 /* On discovering that the redisplay for a window was no good,
1007 cancel the columns of that window, so that when the window is
1008 displayed over again get_display_line will not complain. */
1010 cancel_my_columns (w
)
1014 register struct frame_glyphs
*desired_glyphs
1015 = FRAME_DESIRED_GLYPHS (XFRAME (w
->frame
));
1016 register int start
= XFASTINT (w
->left
);
1017 register int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
1019 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
1020 if (desired_glyphs
->enable
[vpos
]
1021 && desired_glyphs
->used
[vpos
] >= start
)
1022 desired_glyphs
->used
[vpos
] = start
;
1025 /* These functions try to perform directly and immediately on the frame
1026 the necessary output for one change in the buffer.
1027 They may return 0 meaning nothing was done if anything is difficult,
1028 or 1 meaning the output was performed properly.
1029 They assume that the frame was up to date before the buffer
1030 change being displayed. They make various other assumptions too;
1031 see command_loop_1 where these are called. */
1034 direct_output_for_insert (g
)
1037 register FRAME_PTR frame
= selected_frame
;
1038 register struct frame_glyphs
*current_frame
1039 = FRAME_CURRENT_GLYPHS (frame
);
1041 #ifndef COMPILER_REGISTER_BUG
1043 #endif /* COMPILER_REGISTER_BUG */
1044 struct window
*w
= XWINDOW (selected_window
);
1045 #ifndef COMPILER_REGISTER_BUG
1047 #endif /* COMPILER_REGISTER_BUG */
1048 int hpos
= FRAME_CURSOR_X (frame
);
1049 #ifndef COMPILER_REGISTER_BUG
1051 #endif /* COMPILER_REGISTER_BUG */
1052 int vpos
= FRAME_CURSOR_Y (frame
);
1054 /* Give up if about to continue line. */
1055 if (hpos
>= XFASTINT (w
->left
) + window_internal_width (w
) - 1
1057 /* Avoid losing if cursor is in invisible text off left margin */
1058 || (XINT (w
->hscroll
) && hpos
== XFASTINT (w
->left
))
1060 /* Give up if cursor outside window (in minibuf, probably) */
1061 || cursor_in_echo_area
1062 || FRAME_CURSOR_Y (frame
) < XFASTINT (w
->top
)
1063 || FRAME_CURSOR_Y (frame
) >= XFASTINT (w
->top
) + XFASTINT (w
->height
)
1065 /* Give up if cursor not really at FRAME_CURSOR_X, FRAME_CURSOR_Y */
1066 || !display_completed
1068 /* Give up if buffer appears in two places. */
1069 || buffer_shared
> 1
1071 #ifdef USE_TEXT_PROPERTIES
1072 /* Intervals have already been adjusted, point is after the
1073 character that was just inserted. */
1074 /* Give up if character is invisible. */
1075 /* Give up if character has a face property.
1076 At the moment we only lose at end of line or end of buffer
1077 and only with faces that have some background */
1078 /* Instead of wasting time, give up if character has any text properties */
1079 || ! NILP (Ftext_properties_at (XFASTINT (point
- 1), Qnil
))
1082 /* Give up if w is minibuffer and a message is being displayed there */
1083 || (MINI_WINDOW_P (w
) && echo_area_glyphs
))
1087 #ifdef HAVE_X_WINDOWS
1089 int face
= compute_char_face (frame
, w
, point
- 1, -1, -1, &dummy
, point
);
1091 current_frame
->glyphs
[vpos
][hpos
] = MAKE_GLYPH (frame
, g
, face
);
1092 current_frame
->charstarts
[vpos
][hpos
] = point
- 1;
1093 /* Record the entry for after the newly inserted character. */
1094 current_frame
->charstarts
[vpos
][hpos
+ 1] = point
;
1095 adjust_window_charstarts (w
, vpos
, 1);
1097 unchanged_modified
= MODIFF
;
1098 beg_unchanged
= GPT
- BEG
;
1099 XFASTINT (w
->last_point
) = point
;
1100 XFASTINT (w
->last_point_x
) = hpos
;
1101 XFASTINT (w
->last_modified
) = MODIFF
;
1103 reassert_line_highlight (0, vpos
);
1104 write_glyphs (¤t_frame
->glyphs
[vpos
][hpos
], 1);
1106 ++FRAME_CURSOR_X (frame
);
1107 if (hpos
== current_frame
->used
[vpos
])
1109 current_frame
->used
[vpos
] = hpos
+ 1;
1110 current_frame
->glyphs
[vpos
][hpos
+ 1] = 0;
1117 direct_output_forward_char (n
)
1120 register FRAME_PTR frame
= selected_frame
;
1121 register struct window
*w
= XWINDOW (selected_window
);
1123 int hpos
= FRAME_CURSOR_X (frame
);
1125 /* Give up if in truncated text at end of line. */
1126 if (hpos
>= XFASTINT (w
->left
) + window_internal_width (w
) - 1)
1129 /* Avoid losing if cursor is in invisible text off left margin
1130 or about to go off either side of window. */
1131 if ((FRAME_CURSOR_X (frame
) == XFASTINT (w
->left
)
1132 && (XINT (w
->hscroll
) || n
< 0))
1134 && (FRAME_CURSOR_X (frame
) + 1 >= window_internal_width (w
) - 1))
1135 || cursor_in_echo_area
)
1138 /* Can't use direct output if highlighting a region. */
1139 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
1142 #ifdef USE_TEXT_PROPERTIES
1143 /* Don't use direct output next to an invisible character
1144 since we might need to do something special. */
1146 XFASTINT (position
) = point
;
1147 if (XFASTINT (position
) < ZV
1148 && ! NILP (Fget_char_property (position
,
1153 XFASTINT (position
) = point
- 1;
1154 if (XFASTINT (position
) >= BEGV
1155 && ! NILP (Fget_char_property (position
,
1161 FRAME_CURSOR_X (frame
) += n
;
1162 XFASTINT (w
->last_point_x
) = FRAME_CURSOR_X (frame
);
1163 XFASTINT (w
->last_point
) = point
;
1164 cursor_to (FRAME_CURSOR_Y (frame
), FRAME_CURSOR_X (frame
));
1170 static void update_line ();
1172 /* Update frame F based on the data in FRAME_DESIRED_GLYPHS.
1173 Value is nonzero if redisplay stopped due to pending input.
1174 FORCE nonzero means do not stop for pending input. */
1177 update_frame (f
, force
, inhibit_hairy_id
)
1180 int inhibit_hairy_id
;
1182 register struct frame_glyphs
*current_frame
;
1183 register struct frame_glyphs
*desired_frame
= 0;
1186 int preempt_count
= baud_rate
/ 2400 + 1;
1187 extern input_pending
;
1188 #ifdef HAVE_X_WINDOWS
1189 register int downto
, leftmost
;
1192 if (preempt_count
<= 0)
1195 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1197 detect_input_pending ();
1198 if (input_pending
&& !force
)
1206 if (!line_ins_del_ok
)
1207 inhibit_hairy_id
= 1;
1209 /* These are separate to avoid a possible bug in the AIX C compiler. */
1210 current_frame
= FRAME_CURRENT_GLYPHS (f
);
1211 desired_frame
= FRAME_DESIRED_GLYPHS (f
);
1213 /* See if any of the desired lines are enabled; don't compute for
1214 i/d line if just want cursor motion. */
1215 for (i
= 0; i
< FRAME_HEIGHT (f
); i
++)
1216 if (desired_frame
->enable
[i
])
1219 /* Try doing i/d line, if not yet inhibited. */
1220 if (!inhibit_hairy_id
&& i
< FRAME_HEIGHT (f
))
1221 force
|= scrolling (f
);
1223 /* Update the individual lines as needed. Do bottom line first. */
1225 if (desired_frame
->enable
[FRAME_HEIGHT (f
) - 1])
1226 update_line (f
, FRAME_HEIGHT (f
) - 1);
1228 #ifdef HAVE_X_WINDOWS
1231 leftmost
= downto
= f
->display
.x
->internal_border_width
;
1232 if (desired_frame
->enable
[0])
1234 current_frame
->top_left_x
[FRAME_HEIGHT (f
) - 1] = leftmost
;
1235 current_frame
->top_left_y
[FRAME_HEIGHT (f
) - 1]
1236 = PIXEL_HEIGHT (f
) - f
->display
.x
->internal_border_width
1237 - current_frame
->pix_height
[FRAME_HEIGHT (f
) - 1];
1238 current_frame
->top_left_x
[0] = leftmost
;
1239 current_frame
->top_left_y
[0] = downto
;
1242 #endif /* HAVE_X_WINDOWS */
1244 /* Now update the rest of the lines. */
1245 for (i
= 0; i
< FRAME_HEIGHT (f
) - 1 && (force
|| !input_pending
); i
++)
1247 if (desired_frame
->enable
[i
])
1249 if (FRAME_TERMCAP_P (f
))
1251 /* Flush out every so many lines.
1252 Also flush out if likely to have more than 1k buffered
1253 otherwise. I'm told that some telnet connections get
1254 really screwed by more than 1k output at once. */
1255 int outq
= PENDING_OUTPUT_COUNT (stdout
);
1257 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
1260 if (preempt_count
== 1)
1262 #ifdef EMACS_OUTQSIZE
1263 if (EMACS_OUTQSIZE (0, &outq
) < 0)
1264 /* Probably not a tty. Ignore the error and reset
1265 * the outq count. */
1266 outq
= PENDING_OUTPUT_COUNT (stdout
);
1269 if (baud_rate
<= outq
&& baud_rate
> 0)
1270 sleep (outq
/ baud_rate
);
1273 if ((i
- 1) % preempt_count
== 0)
1274 detect_input_pending ();
1278 #ifdef HAVE_X_WINDOWS
1281 current_frame
->top_left_y
[i
] = downto
;
1282 current_frame
->top_left_x
[i
] = leftmost
;
1284 #endif /* HAVE_X_WINDOWS */
1287 #ifdef HAVE_X_WINDOWS
1289 downto
+= current_frame
->pix_height
[i
];
1292 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
1294 /* Now just clean up termcap drivers and set cursor, etc. */
1297 if (cursor_in_echo_area
1298 && FRAME_HAS_MINIBUF_P (f
))
1300 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
1303 if (cursor_in_echo_area
< 0)
1310 /* If the minibuffer is several lines high, find the last
1311 line that has any text on it. */
1312 row
= FRAME_HEIGHT (f
);
1316 if (current_frame
->enable
[row
])
1317 col
= current_frame
->used
[row
];
1321 while (row
> top
&& col
== 0);
1323 if (col
>= FRAME_WIDTH (f
))
1326 if (row
< FRAME_HEIGHT (f
) - 1)
1331 cursor_to (row
, col
);
1334 cursor_to (FRAME_CURSOR_Y (f
), max (min (FRAME_CURSOR_X (f
),
1335 FRAME_WIDTH (f
) - 1), 0));
1341 fflush (termscript
);
1344 /* Here if output is preempted because input is detected. */
1347 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1348 display_completed
= !pause
;
1350 bzero (FRAME_DESIRED_GLYPHS (f
)->enable
, FRAME_HEIGHT (f
));
1354 /* Called when about to quit, to check for doing so
1355 at an improper time. */
1360 if (FRAME_DESIRED_GLYPHS (selected_frame
) == 0)
1362 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[0])
1364 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[FRAME_HEIGHT (selected_frame
) - 1])
1368 /* Decide what insert/delete line to do, and do it */
1370 extern void scrolling_1 ();
1375 int unchanged_at_top
, unchanged_at_bottom
;
1378 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1379 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1380 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1382 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
1383 register struct frame_glyphs
*current_frame
= FRAME_CURRENT_GLYPHS (frame
);
1384 register struct frame_glyphs
*desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
1386 /* Compute hash codes of all the lines.
1387 Also calculate number of changed lines,
1388 number of unchanged lines at the beginning,
1389 and number of unchanged lines at the end. */
1392 unchanged_at_top
= 0;
1393 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
1394 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
1396 /* Give up on this scrolling if some old lines are not enabled. */
1397 if (!current_frame
->enable
[i
])
1399 old_hash
[i
] = line_hash_code (current_frame
, i
);
1400 if (! desired_frame
->enable
[i
])
1401 new_hash
[i
] = old_hash
[i
];
1403 new_hash
[i
] = line_hash_code (desired_frame
, i
);
1405 if (old_hash
[i
] != new_hash
[i
])
1408 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
1410 else if (i
== unchanged_at_top
)
1412 draw_cost
[i
] = line_draw_cost (desired_frame
, i
);
1415 /* If changed lines are few, don't allow preemption, don't scroll. */
1416 if (changed_lines
< baud_rate
/ 2400
1417 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
1420 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
1421 - unchanged_at_bottom
);
1423 if (scroll_region_ok
)
1424 free_at_end_vpos
-= unchanged_at_bottom
;
1425 else if (memory_below_frame
)
1426 free_at_end_vpos
= -1;
1428 /* If large window, fast terminal and few lines in common between
1429 current frame and desired frame, don't bother with i/d calc. */
1430 if (window_size
>= 18 && baud_rate
> 2400
1432 10 * scrolling_max_lines_saved (unchanged_at_top
,
1433 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
1434 old_hash
, new_hash
, draw_cost
)))
1437 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
1438 draw_cost
+ unchanged_at_top
- 1,
1439 old_hash
+ unchanged_at_top
- 1,
1440 new_hash
+ unchanged_at_top
- 1,
1441 free_at_end_vpos
- unchanged_at_top
);
1446 /* Return the offset in its buffer of the character at location col, line
1447 in the given window. */
1449 buffer_posn_from_coords (window
, col
, line
)
1450 struct window
*window
;
1453 int hscroll
= XINT (window
->hscroll
);
1454 int window_left
= XFASTINT (window
->left
);
1456 /* The actual width of the window is window->width less one for the
1457 DISP_CONTINUE_GLYPH, and less one if it's not the rightmost
1459 int window_width
= window_internal_width (window
) - 1;
1461 int startp
= marker_position (window
->start
);
1463 /* Since compute_motion will only operate on the current buffer,
1464 we need to save the old one and restore it when we're done. */
1465 struct buffer
*old_current_buffer
= current_buffer
;
1466 struct position
*posn
;
1468 current_buffer
= XBUFFER (window
->buffer
);
1470 /* It would be nice if we could use FRAME_CURRENT_GLYPHS (XFRAME
1471 (window->frame))->bufp to avoid scanning from the very top of
1472 the window, but it isn't maintained correctly, and I'm not even
1473 sure I will keep it. */
1474 posn
= compute_motion (startp
, 0,
1475 (window
== XWINDOW (minibuf_window
) && startp
== 1
1476 ? minibuf_prompt_width
: 0)
1477 + (hscroll
? 1 - hscroll
: 0),
1479 window_width
, hscroll
, 0, window
);
1481 current_buffer
= old_current_buffer
;
1483 /* compute_motion considers frame points past the end of a line
1484 to be *after* the newline, i.e. at the start of the next line.
1485 This is reasonable, but not really what we want. So if the
1486 result is on a line below LINE, back it up one character. */
1487 if (posn
->vpos
> line
)
1488 return posn
->bufpos
- 1;
1490 return posn
->bufpos
;
1497 register GLYPH
*p
= r
;
1498 while (*p
++ == SPACEGLYPH
);
1503 count_match (str1
, str2
)
1506 register GLYPH
*p1
= str1
;
1507 register GLYPH
*p2
= str2
;
1508 while (*p1
++ == *p2
++);
1509 return p1
- str1
- 1;
1512 /* Char insertion/deletion cost vector, from term.c */
1513 extern int *char_ins_del_vector
;
1515 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WIDTH((f))])
1518 update_line (frame
, vpos
)
1519 register FRAME_PTR frame
;
1522 register GLYPH
*obody
, *nbody
, *op1
, *op2
, *np1
, *temp
;
1525 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
1527 register struct frame_glyphs
*current_frame
1528 = FRAME_CURRENT_GLYPHS (frame
);
1529 register struct frame_glyphs
*desired_frame
1530 = FRAME_DESIRED_GLYPHS (frame
);
1532 if (desired_frame
->highlight
[vpos
]
1533 != (current_frame
->enable
[vpos
] && current_frame
->highlight
[vpos
]))
1535 change_line_highlight (desired_frame
->highlight
[vpos
], vpos
,
1536 (current_frame
->enable
[vpos
] ?
1537 current_frame
->used
[vpos
] : 0));
1538 current_frame
->enable
[vpos
] = 0;
1541 reassert_line_highlight (desired_frame
->highlight
[vpos
], vpos
);
1543 if (! current_frame
->enable
[vpos
])
1549 obody
= current_frame
->glyphs
[vpos
];
1550 olen
= current_frame
->used
[vpos
];
1551 if (! current_frame
->highlight
[vpos
])
1553 if (!must_write_spaces
)
1554 while (obody
[olen
- 1] == SPACEGLYPH
&& olen
> 0)
1559 /* For an inverse-video line, remember we gave it
1560 spaces all the way to the frame edge
1561 so that the reverse video extends all the way across. */
1563 while (olen
< FRAME_WIDTH (frame
) - 1)
1564 obody
[olen
++] = SPACEGLYPH
;
1568 /* One way or another, this will enable the line being updated. */
1569 current_frame
->enable
[vpos
] = 1;
1570 current_frame
->used
[vpos
] = desired_frame
->used
[vpos
];
1571 current_frame
->highlight
[vpos
] = desired_frame
->highlight
[vpos
];
1572 current_frame
->bufp
[vpos
] = desired_frame
->bufp
[vpos
];
1574 #ifdef HAVE_X_WINDOWS
1575 if (FRAME_X_P (frame
))
1577 current_frame
->pix_width
[vpos
]
1578 = current_frame
->used
[vpos
]
1579 * FONT_WIDTH (frame
->display
.x
->font
);
1580 current_frame
->pix_height
[vpos
]
1581 = frame
->display
.x
->line_height
;
1583 #endif /* HAVE_X_WINDOWS */
1585 if (!desired_frame
->enable
[vpos
])
1591 nbody
= desired_frame
->glyphs
[vpos
];
1592 nlen
= desired_frame
->used
[vpos
];
1594 /* Pretend trailing spaces are not there at all,
1595 unless for one reason or another we must write all spaces. */
1596 if (! desired_frame
->highlight
[vpos
])
1598 if (!must_write_spaces
)
1599 /* We know that the previous character byte contains 0. */
1600 while (nbody
[nlen
- 1] == SPACEGLYPH
)
1605 /* For an inverse-video line, give it extra trailing spaces
1606 all the way to the frame edge
1607 so that the reverse video extends all the way across. */
1609 while (nlen
< FRAME_WIDTH (frame
) - 1)
1610 nbody
[nlen
++] = SPACEGLYPH
;
1613 /* If there's no i/d char, quickly do the best we can without it. */
1614 if (!char_ins_del_ok
)
1619 if (FRAME_X_P (frame
))
1621 /* Under X, erase everything we are going to rewrite,
1622 and rewrite everything from the first char that's changed.
1623 This is part of supporting fonts like Courier
1624 whose chars can overlap outside the char width. */
1625 for (i
= 0; i
< nlen
; i
++)
1626 if (i
>= olen
|| nbody
[i
] != obody
[i
])
1629 cursor_to (vpos
, i
);
1631 clear_end_of_line (olen
);
1632 write_glyphs (nbody
+ i
, nlen
- i
);
1637 for (i
= 0; i
< nlen
; i
++)
1639 if (i
>= olen
|| nbody
[i
] != obody
[i
]) /* A non-matching char. */
1641 cursor_to (vpos
, i
);
1642 for (j
= 1; (i
+ j
< nlen
&&
1643 (i
+ j
>= olen
|| nbody
[i
+j
] != obody
[i
+j
]));
1646 /* Output this run of non-matching chars. */
1647 write_glyphs (nbody
+ i
, j
);
1650 /* Now find the next non-match. */
1654 /* Clear the rest of the line, or the non-clear part of it. */
1657 cursor_to (vpos
, nlen
);
1658 clear_end_of_line (olen
);
1661 /* Exchange contents between current_frame and new_frame. */
1662 temp
= desired_frame
->glyphs
[vpos
];
1663 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1664 current_frame
->glyphs
[vpos
] = temp
;
1666 /* Exchange charstarts between current_frame and new_frame. */
1667 temp1
= desired_frame
->charstarts
[vpos
];
1668 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1669 current_frame
->charstarts
[vpos
] = temp1
;
1676 nsp
= (must_write_spaces
|| desired_frame
->highlight
[vpos
])
1677 ? 0 : count_blanks (nbody
);
1680 cursor_to (vpos
, nsp
);
1681 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
1684 /* Exchange contents between current_frame and new_frame. */
1685 temp
= desired_frame
->glyphs
[vpos
];
1686 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1687 current_frame
->glyphs
[vpos
] = temp
;
1689 /* Exchange charstarts between current_frame and new_frame. */
1690 temp1
= desired_frame
->charstarts
[vpos
];
1691 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1692 current_frame
->charstarts
[vpos
] = temp1
;
1701 /* Compute number of leading blanks in old and new contents. */
1702 osp
= count_blanks (obody
);
1703 if (!desired_frame
->highlight
[vpos
])
1704 nsp
= count_blanks (nbody
);
1708 /* Compute number of matching chars starting with first nonblank. */
1709 begmatch
= count_match (obody
+ osp
, nbody
+ nsp
);
1711 /* Spaces in new match implicit space past the end of old. */
1712 /* A bug causing this to be a no-op was fixed in 18.29. */
1713 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
1716 while (np1
[begmatch
] == SPACEGLYPH
)
1720 /* Avoid doing insert/delete char
1721 just cause number of leading spaces differs
1722 when the following text does not match. */
1723 if (begmatch
== 0 && osp
!= nsp
)
1724 osp
= nsp
= min (osp
, nsp
);
1726 /* Find matching characters at end of line */
1729 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
1730 while (op1
> op2
&& op1
[-1] == np1
[-1])
1735 endmatch
= obody
+ olen
- op1
;
1737 /* Put correct value back in nbody[nlen].
1738 This is important because direct_output_for_insert
1739 can write into the line at a later point.
1740 If this screws up the zero at the end of the line, re-establish it. */
1744 /* tem gets the distance to insert or delete.
1745 endmatch is how many characters we save by doing so.
1748 tem
= (nlen
- nsp
) - (olen
- osp
);
1750 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
1753 /* nsp - osp is the distance to insert or delete.
1754 If that is nonzero, begmatch is known to be nonzero also.
1755 begmatch + endmatch is how much we save by doing the ins/del.
1759 && (!char_ins_del_ok
1760 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
1764 osp
= nsp
= min (osp
, nsp
);
1767 /* Now go through the line, inserting, writing and
1768 deleting as appropriate. */
1772 cursor_to (vpos
, nsp
);
1773 delete_glyphs (osp
- nsp
);
1777 /* If going to delete chars later in line
1778 and insert earlier in the line,
1779 must delete first to avoid losing data in the insert */
1780 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
1782 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
1783 delete_glyphs (olen
+ nsp
- osp
- nlen
);
1784 olen
= nlen
- (nsp
- osp
);
1786 cursor_to (vpos
, osp
);
1787 insert_glyphs ((char *)0, nsp
- osp
);
1791 tem
= nsp
+ begmatch
+ endmatch
;
1792 if (nlen
!= tem
|| olen
!= tem
)
1794 cursor_to (vpos
, nsp
+ begmatch
);
1795 if (!endmatch
|| nlen
== olen
)
1797 /* If new text being written reaches right margin,
1798 there is no need to do clear-to-eol at the end.
1799 (and it would not be safe, since cursor is not
1800 going to be "at the margin" after the text is done) */
1801 if (nlen
== FRAME_WIDTH (frame
))
1803 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1807 /* the following code loses disastrously if tem == nlen.
1808 Rather than trying to fix that case, I am trying the simpler
1809 solution found above. */
1811 /* If the text reaches to the right margin,
1812 it will lose one way or another (depending on AutoWrap)
1813 to clear to end of line after outputting all the text.
1814 So pause with one character to go and clear the line then. */
1815 if (nlen
== FRAME_WIDTH (frame
) && fast_clear_end_of_line
&& olen
> nlen
)
1817 /* endmatch must be zero, and tem must equal nsp + begmatch */
1818 write_glyphs (nbody
+ tem
, nlen
- tem
- 1);
1819 clear_end_of_line (olen
);
1820 olen
= 0; /* Don't let it be cleared again later */
1821 write_glyphs (nbody
+ nlen
- 1, 1);
1824 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1825 #endif /* OBSOLETE */
1828 else if (nlen
> olen
)
1830 write_glyphs (nbody
+ nsp
+ begmatch
, olen
- tem
);
1831 insert_glyphs (nbody
+ nsp
+ begmatch
+ olen
- tem
, nlen
- olen
);
1834 else if (olen
> nlen
)
1836 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1837 delete_glyphs (olen
- nlen
);
1843 /* If any unerased characters remain after the new line, erase them. */
1846 cursor_to (vpos
, nlen
);
1847 clear_end_of_line (olen
);
1850 /* Exchange contents between current_frame and new_frame. */
1851 temp
= desired_frame
->glyphs
[vpos
];
1852 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1853 current_frame
->glyphs
[vpos
] = temp
;
1855 /* Exchange charstarts between current_frame and new_frame. */
1856 temp1
= desired_frame
->charstarts
[vpos
];
1857 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1858 current_frame
->charstarts
[vpos
] = temp1
;
1861 /* A vector of size >= NFRAMES + 3 * NBUFFERS + 1, containing the session's
1862 frames, buffers, buffer-read-only flags, and buffer-modified-flags,
1863 and a trailing sentinel (so we don't need to add length checks). */
1864 static Lisp_Object frame_and_buffer_state
;
1866 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
1867 Sframe_or_buffer_changed_p
, 0, 0, 0,
1868 "Return non-nil if the frame and buffer state appears to have changed.\n\
1869 The state variable is an internal vector containing all frames and buffers,\n\
1870 along with the buffers' read-only and modified flags, which allows a fast\n\
1871 check to see whether the menu bars might need to be recomputed.\n\
1872 If this function returns non-nil, it updates the internal vector to reflect\n\
1873 the current state.\n")
1876 Lisp_Object tail
, frame
, buf
;
1879 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
1880 FOR_EACH_FRAME (tail
, frame
)
1881 if (!EQ (*vecp
++, frame
))
1883 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1885 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
1886 if (!EQ (*vecp
++, buf
))
1888 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
1890 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
1896 FOR_EACH_FRAME (tail
, frame
)
1898 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1900 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
1901 if (n
> XVECTOR (frame_and_buffer_state
)->size
1902 || n
< XVECTOR (frame_and_buffer_state
)->size
/ 2)
1903 frame_and_buffer_state
= Fmake_vector (make_number (n
), Qlambda
);
1904 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
1905 FOR_EACH_FRAME (tail
, frame
)
1907 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1909 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
1911 *vecp
++ = XBUFFER (buf
)->read_only
;
1912 *vecp
++ = Fbuffer_modified_p (buf
);
1914 /* If we left any slack in the vector, fill it up now. */
1915 for (; n
< XVECTOR (frame_and_buffer_state
)->size
; ++n
)
1920 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
1921 1, 1, "FOpen termscript file: ",
1922 "Start writing all terminal output to FILE as well as the terminal.\n\
1923 FILE = nil means just close any termscript file currently open.")
1927 if (termscript
!= 0) fclose (termscript
);
1932 file
= Fexpand_file_name (file
, Qnil
);
1933 termscript
= fopen (XSTRING (file
)->data
, "w");
1934 if (termscript
== 0)
1935 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
1943 window_change_signal ()
1947 int old_errno
= errno
;
1949 get_frame_size (&width
, &height
);
1951 /* The frame size change obviously applies to a termcap-controlled
1952 frame. Find such a frame in the list, and assume it's the only
1953 one (since the redisplay code always writes to stdout, not a
1954 FILE * specified in the frame structure). Record the new size,
1955 but don't reallocate the data structures now. Let that be done
1956 later outside of the signal handler. */
1959 Lisp_Object tail
, frame
;
1961 FOR_EACH_FRAME (tail
, frame
)
1963 if (FRAME_TERMCAP_P (XFRAME (frame
)))
1965 change_frame_size (XFRAME (frame
), height
, width
, 0, 1);
1971 signal (SIGWINCH
, window_change_signal
);
1974 #endif /* SIGWINCH */
1977 /* Do any change in frame size that was requested by a signal. */
1979 do_pending_window_change ()
1981 /* If window_change_signal should have run before, run it now. */
1982 while (delayed_size_change
)
1984 Lisp_Object tail
, frame
;
1986 delayed_size_change
= 0;
1988 FOR_EACH_FRAME (tail
, frame
)
1990 FRAME_PTR f
= XFRAME (frame
);
1992 int height
= FRAME_NEW_HEIGHT (f
);
1993 int width
= FRAME_NEW_WIDTH (f
);
1995 if (height
!= 0 || width
!= 0)
1996 change_frame_size (f
, height
, width
, 0, 0);
2002 /* Change the frame height and/or width. Values may be given as zero to
2003 indicate no change is to take place.
2005 If DELAY is non-zero, then assume we're being called from a signal
2006 handler, and queue the change for later - perhaps the next
2007 redisplay. Since this tries to resize windows, we can't call it
2008 from a signal handler. */
2010 change_frame_size (frame
, newheight
, newwidth
, pretend
, delay
)
2011 register FRAME_PTR frame
;
2012 int newheight
, newwidth
, pretend
;
2014 /* If we can't deal with the change now, queue it for later. */
2017 FRAME_NEW_HEIGHT (frame
) = newheight
;
2018 FRAME_NEW_WIDTH (frame
) = newwidth
;
2019 delayed_size_change
= 1;
2023 /* This size-change overrides any pending one for this frame. */
2024 FRAME_NEW_HEIGHT (frame
) = 0;
2025 FRAME_NEW_WIDTH (frame
) = 0;
2027 /* If an argument is zero, set it to the current value. */
2028 newheight
|| (newheight
= FRAME_HEIGHT (frame
));
2029 newwidth
|| (newwidth
= FRAME_WIDTH (frame
));
2031 /* Round up to the smallest acceptable size. */
2032 check_frame_size (frame
, &newheight
, &newwidth
);
2034 /* If we're not changing the frame size, quit now. */
2035 if (newheight
== FRAME_HEIGHT (frame
)
2036 && newwidth
== FRAME_WIDTH (frame
))
2039 if (newheight
!= FRAME_HEIGHT (frame
))
2041 if (FRAME_HAS_MINIBUF_P (frame
)
2042 && ! FRAME_MINIBUF_ONLY_P (frame
))
2044 /* Frame has both root and minibuffer. */
2045 set_window_height (FRAME_ROOT_WINDOW (frame
),
2046 newheight
- 1 - FRAME_MENU_BAR_LINES (frame
), 0);
2047 XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (frame
))->top
)
2049 set_window_height (FRAME_MINIBUF_WINDOW (frame
), 1, 0);
2052 /* Frame has just one top-level window. */
2053 set_window_height (FRAME_ROOT_WINDOW (frame
),
2054 newheight
- FRAME_MENU_BAR_LINES (frame
), 0);
2056 if (FRAME_TERMCAP_P (frame
) && !pretend
)
2057 FrameRows
= newheight
;
2060 if (frame
->output_method
== output_termcap
)
2062 frame_height
= newheight
;
2064 FrameRows
= newheight
;
2069 if (newwidth
!= FRAME_WIDTH (frame
))
2071 set_window_width (FRAME_ROOT_WINDOW (frame
), newwidth
, 0);
2072 if (FRAME_HAS_MINIBUF_P (frame
))
2073 set_window_width (FRAME_MINIBUF_WINDOW (frame
), newwidth
, 0);
2075 if (FRAME_TERMCAP_P (frame
) && !pretend
)
2076 FrameCols
= newwidth
;
2078 if (frame
->output_method
== output_termcap
)
2080 frame_width
= newwidth
;
2082 FrameCols
= newwidth
;
2087 FRAME_HEIGHT (frame
) = newheight
;
2088 FRAME_WIDTH (frame
) = newwidth
;
2090 if (FRAME_CURSOR_X (frame
) >= FRAME_WIDTH (frame
))
2091 FRAME_CURSOR_X (frame
) = FRAME_WIDTH (frame
) - 1;
2092 if (FRAME_CURSOR_Y (frame
) >= FRAME_HEIGHT (frame
))
2093 FRAME_CURSOR_Y (frame
) = FRAME_HEIGHT (frame
) - 1;
2095 remake_frame_glyphs (frame
);
2096 calculate_costs (frame
);
2099 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
2100 Ssend_string_to_terminal
, 1, 1, 0,
2101 "Send STRING to the terminal without alteration.\n\
2102 Control characters in STRING will have terminal-dependent effects.")
2106 CHECK_STRING (str
, 0);
2107 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, stdout
);
2111 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, termscript
);
2112 fflush (termscript
);
2117 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
2118 "Beep, or flash the screen.\n\
2119 Also, unless an argument is given,\n\
2120 terminate any keyboard macro currently executing.")
2142 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
2143 error ("Keyboard macro terminated by a command ringing the bell");
2149 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
2150 "Pause, without updating display, for SECONDS seconds.\n\
2151 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2152 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2153 additional wait period, in milliseconds; this may be useful if your\n\
2154 Emacs was built without floating point support.\n\
2155 \(Not all operating systems support waiting for a fraction of a second.)")
2156 (seconds
, milliseconds
)
2157 Lisp_Object seconds
, milliseconds
;
2161 if (NILP (milliseconds
))
2162 XSET (milliseconds
, Lisp_Int
, 0);
2164 CHECK_NUMBER (milliseconds
, 1);
2165 usec
= XINT (milliseconds
) * 1000;
2167 #ifdef LISP_FLOAT_TYPE
2169 double duration
= extract_float (seconds
);
2170 sec
= (int) duration
;
2171 usec
+= (duration
- sec
) * 1000000;
2174 CHECK_NUMBER (seconds
, 0);
2175 sec
= XINT (seconds
);
2178 #ifndef EMACS_HAS_USECS
2179 if (sec
== 0 && usec
!= 0)
2180 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
2183 /* Assure that 0 <= usec < 1000000. */
2186 /* We can't rely on the rounding being correct if user is negative. */
2187 if (-1000000 < usec
)
2188 sec
--, usec
+= 1000000;
2190 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
2193 sec
+= usec
/ 1000000, usec
%= 1000000;
2201 XFASTINT (zero
) = 0;
2202 wait_reading_process_input (sec
, usec
, zero
, 0);
2205 /* We should always have wait_reading_process_input; we have a dummy
2206 implementation for systems which don't support subprocesses. */
2208 /* No wait_reading_process_input */
2215 /* The reason this is done this way
2216 (rather than defined (H_S) && defined (H_T))
2217 is because the VMS preprocessor doesn't grok `defined' */
2219 EMACS_GET_TIME (end_time
);
2220 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
2221 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
2225 EMACS_GET_TIME (timeout
);
2226 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
2227 if (EMACS_TIME_NEG_P (timeout
)
2228 || !select (1, 0, 0, 0, &timeout
))
2231 #else /* not HAVE_SELECT */
2233 #endif /* HAVE_SELECT */
2234 #endif /* not VMS */
2237 #endif /* no subprocesses */
2242 /* This is just like wait_reading_process_input, except that
2243 it does the redisplay.
2245 It's also much like Fsit_for, except that it can be used for
2246 waiting for input as well. One differnce is that sit_for
2247 does not call prepare_menu_bars; Fsit_for does call that. */
2250 sit_for (sec
, usec
, reading
, display
)
2251 int sec
, usec
, reading
, display
;
2253 Lisp_Object read_kbd
;
2255 if (detect_input_pending ())
2259 redisplay_preserve_echo_area ();
2261 if (sec
== 0 && usec
== 0)
2268 XSET (read_kbd
, Lisp_Int
, reading
? -1 : 1);
2269 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
2272 /* wait_reading_process_input should always be available now; it is
2273 simulated in a simple way on systems that don't support
2276 /* No wait_reading_process_input available. */
2282 input_wait_timeout (XINT (arg
));
2284 #ifndef HAVE_TIMEVAL
2286 select (1, &waitchannels
, 0, 0, &timeout_sec
);
2287 #else /* HAVE_TIMEVAL */
2288 timeout
.tv_sec
= sec
;
2289 timeout
.tv_usec
= usec
;
2290 select (1, &waitchannels
, 0, 0, &timeout
);
2291 #endif /* HAVE_TIMEVAL */
2292 #endif /* not VMS */
2297 return detect_input_pending () ? Qnil
: Qt
;
2300 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
2301 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
2302 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2303 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2304 additional wait period, in milliseconds; this may be useful if your\n\
2305 Emacs was built without floating point support.\n\
2306 \(Not all operating systems support waiting for a fraction of a second.)\n\
2307 Optional third arg non-nil means don't redisplay, just wait for input.\n\
2308 Redisplay is preempted as always if input arrives, and does not happen\n\
2309 if input is available before it starts.\n\
2310 Value is t if waited the full time with no input arriving.")
2311 (seconds
, milliseconds
, nodisp
)
2312 Lisp_Object seconds
, milliseconds
, nodisp
;
2316 if (NILP (milliseconds
))
2317 XSET (milliseconds
, Lisp_Int
, 0);
2319 CHECK_NUMBER (milliseconds
, 1);
2320 usec
= XINT (milliseconds
) * 1000;
2322 #ifdef LISP_FLOAT_TYPE
2324 double duration
= extract_float (seconds
);
2325 sec
= (int) duration
;
2326 usec
+= (duration
- sec
) * 1000000;
2329 CHECK_NUMBER (seconds
, 0);
2330 sec
= XINT (seconds
);
2333 #ifndef EMACS_HAS_USECS
2334 if (usec
!= 0 && sec
== 0)
2335 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
2339 prepare_menu_bars ();
2340 return sit_for (sec
, usec
, 0, NILP (nodisp
));
2343 char *terminal_type
;
2345 /* Initialization done when Emacs fork is started, before doing stty. */
2346 /* Determine terminal type and set terminal_driver */
2347 /* Then invoke its decoding routine to set up variables
2348 in the terminal package */
2352 #ifdef HAVE_X_WINDOWS
2353 extern int display_arg
;
2358 cursor_in_echo_area
= 0;
2359 terminal_type
= (char *) 0;
2361 /* Now is the time to initialize this; it's used by init_sys_modes
2363 Vwindow_system
= Qnil
;
2365 /* If the user wants to use a window system, we shouldn't bother
2366 initializing the terminal. This is especially important when the
2367 terminal is so dumb that emacs gives up before and doesn't bother
2368 using the window system.
2370 If the DISPLAY environment variable is set, try to use X, and die
2371 with an error message if that doesn't work. */
2373 #ifdef HAVE_X_WINDOWS
2377 display_arg
= (getenv ("DECW$DISPLAY") != 0);
2379 display_arg
= (getenv ("DISPLAY") != 0);
2383 if (!inhibit_window_system
&& display_arg
)
2385 Vwindow_system
= intern ("x");
2387 Vwindow_system_version
= make_number (11);
2389 Vwindow_system_version
= make_number (10);
2393 #endif /* HAVE_X_WINDOWS */
2395 /* If no window system has been specified, try to use the terminal. */
2398 fprintf (stderr
, "emacs: standard input is not a tty\n");
2402 /* Look at the TERM variable */
2403 terminal_type
= (char *) getenv ("TERM");
2407 fprintf (stderr
, "Please specify your terminal type.\n\
2408 For types defined in VMS, use set term /device=TYPE.\n\
2409 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
2410 \(The quotation marks are necessary since terminal types are lower case.)\n");
2412 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
2418 /* VMS DCL tends to upcase things, so downcase term type.
2419 Hardly any uppercase letters in terminal types; should be none. */
2421 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
2424 strcpy (new, terminal_type
);
2426 for (p
= new; *p
; p
++)
2430 terminal_type
= new;
2434 term_init (terminal_type
);
2436 remake_frame_glyphs (selected_frame
);
2437 calculate_costs (selected_frame
);
2439 /* X and Y coordinates of the cursor between updates. */
2440 FRAME_CURSOR_X (selected_frame
) = 0;
2441 FRAME_CURSOR_Y (selected_frame
) = 0;
2446 #endif /* CANNOT_DUMP */
2447 signal (SIGWINCH
, window_change_signal
);
2448 #endif /* SIGWINCH */
2454 defsubr (&Sredraw_frame
);
2456 defsubr (&Sredraw_display
);
2457 defsubr (&Sframe_or_buffer_changed_p
);
2458 defsubr (&Sopen_termscript
);
2460 defsubr (&Ssit_for
);
2461 defsubr (&Ssleep_for
);
2462 defsubr (&Ssend_string_to_terminal
);
2464 frame_and_buffer_state
= Fmake_vector (make_number (1), Qlambda
);
2465 staticpro (&frame_and_buffer_state
);
2467 DEFVAR_INT ("baud-rate", &baud_rate
,
2468 "The output baud rate of the terminal.\n\
2469 On most systems, changing this value will affect the amount of padding\n\
2470 and the other strategic decisions made during redisplay.");
2471 DEFVAR_BOOL ("inverse-video", &inverse_video
,
2472 "*Non-nil means invert the entire frame display.\n\
2473 This means everything is in inverse video which otherwise would not be.");
2474 DEFVAR_BOOL ("visible-bell", &visible_bell
,
2475 "*Non-nil means try to flash the frame to represent a bell.");
2476 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
2477 "*Non-nil means no need to redraw entire frame after suspending.\n\
2478 A non-nil value is useful if the terminal can automatically preserve\n\
2479 Emacs's frame display when you reenter Emacs.\n\
2480 It is up to you to set this variable if your terminal can do that.");
2481 DEFVAR_LISP ("window-system", &Vwindow_system
,
2482 "A symbol naming the window-system under which Emacs is running\n\
2483 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
2484 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
2485 "The version number of the window system in use.\n\
2486 For X windows, this is 10 or 11.");
2487 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
2488 "Non-nil means put cursor in minibuffer, at end of any message there.");
2489 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
2490 "Table defining how to output a glyph code to the frame.\n\
2491 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
2492 Each element can be:\n\
2493 integer: a glyph code which this glyph is an alias for.\n\
2494 string: output this glyph using that string (not impl. in X windows).\n\
2495 nil: this glyph mod 256 is char code to output,\n\
2496 and this glyph / 256 is face code for X windows (see `face-id').");
2497 Vglyph_table
= Qnil
;
2499 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
2500 "Display table to use for buffers that specify none.\n\
2501 See `buffer-display-table' for more information.");
2502 Vstandard_display_table
= Qnil
;
2504 /* Initialize `window-system', unless init_display already decided it. */
2509 Vwindow_system
= Qnil
;
2510 Vwindow_system_version
= Qnil
;