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. */
31 #include "termhooks.h"
33 #include "dispextern.h"
40 #include "intervals.h"
46 #endif /* HAVE_X_WINDOWS */
48 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
53 #define max(a, b) ((a) > (b) ? (a) : (b))
54 #define min(a, b) ((a) < (b) ? (a) : (b))
56 /* Get number of chars of output now in the buffer of a stdio stream.
57 This ought to be built in in stdio, but it isn't.
58 Some s- files override this because their stdio internals differ. */
59 #ifdef __GNU_LIBRARY__
60 /* The s- file might have overridden the definition with one that works for
61 the system's C library. But we are using the GNU C library, so this is
62 the right definition for every system. */
63 #ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT
64 #define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT
66 #undef PENDING_OUTPUT_COUNT
67 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
69 #else /* not __GNU_LIBRARY__ */
70 #ifndef PENDING_OUTPUT_COUNT
71 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
75 /* Nonzero upon entry to redisplay means do not assume anything about
76 current contents of actual terminal frame; clear and redraw it. */
80 /* Nonzero means last display completed. Zero means it was preempted. */
82 int display_completed
;
84 /* Lisp variable visible-bell; enables use of screen-flash
85 instead of audible bell. */
89 /* Invert the color of the whole frame, at a low level. */
93 /* Line speed of the terminal. */
97 /* nil or a symbol naming the window system under which emacs is
98 running ('x is the only current possibility). */
100 Lisp_Object Vwindow_system
;
102 /* Version number of X windows: 10, 11 or nil. */
103 Lisp_Object Vwindow_system_version
;
105 /* Vector of glyph definitions. Indexed by glyph number,
106 the contents are a string which is how to output the glyph.
108 If Vglyph_table is nil, a glyph is output by using its low 8 bits
109 as a character code. */
111 Lisp_Object Vglyph_table
;
113 /* Display table to use for vectors that don't specify their own. */
115 Lisp_Object Vstandard_display_table
;
117 /* Nonzero means reading single-character input with prompt
118 so put cursor on minibuffer after the prompt.
119 positive means at end of text in echo area;
120 negative means at beginning of line. */
121 int cursor_in_echo_area
;
123 /* The currently selected frame.
124 In a single-frame version, this variable always remains 0. */
126 FRAME_PTR selected_frame
;
128 /* A frame which is not just a minibuffer, or 0 if there are no such
129 frames. This is usually the most recent such frame that was
130 selected. In a single-frame version, this variable always remains 0. */
131 FRAME_PTR last_nonminibuf_frame
;
133 /* In a single-frame version, the information that would otherwise
134 exist inside frame objects lives in the following structure instead.
136 NOTE: the_only_frame is not checked for garbage collection; don't
137 store collectible objects in any of its fields!
139 You're not/The only frame in town/... */
142 struct frame the_only_frame
;
145 /* This is a vector, made larger whenever it isn't large enough,
146 which is used inside `update_frame' to hold the old contents
147 of the FRAME_PHYS_LINES of the frame being updated. */
148 struct frame_glyphs
**ophys_lines
;
149 /* Length of vector currently allocated. */
150 int ophys_lines_length
;
152 FILE *termscript
; /* Stdio stream being used for copy of all output. */
154 struct cm Wcm
; /* Structure for info on cursor positioning */
156 extern short ospeed
; /* Output speed (from sg_ospeed) */
158 int delayed_size_change
; /* 1 means SIGWINCH happened when not safe. */
162 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
163 "Clear frame FRAME and output again what is supposed to appear on it.")
169 CHECK_LIVE_FRAME (frame
, 0);
172 /* set_terminal_modes (); */
174 clear_frame_records (f
);
177 windows_or_buffers_changed
++;
178 /* Mark all windows as INaccurate,
179 so that every window will have its redisplay done. */
180 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
189 XSET (frame
, Lisp_Frame
, f
);
190 Fredraw_frame (frame
);
195 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
196 "Clear frame FRAME and output again what is supposed to appear on it.")
201 set_terminal_modes ();
205 clear_frame_records (0);
206 windows_or_buffers_changed
++;
207 /* Mark all windows as INaccurate,
208 so that every window will have its redisplay done. */
209 mark_window_display_accurate (FRAME_ROOT_WINDOW (0), 0);
215 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
216 "Clear and redisplay all visible frames.")
219 Lisp_Object tail
, frame
;
221 FOR_EACH_FRAME (tail
, frame
)
222 if (FRAME_VISIBLE_P (XFRAME (frame
)))
223 Fredraw_frame (frame
);
228 /* This is used when frame_garbaged is set.
229 Redraw the individual frames marked as garbaged. */
232 redraw_garbaged_frames ()
234 Lisp_Object tail
, frame
;
236 FOR_EACH_FRAME (tail
, frame
)
237 if (FRAME_VISIBLE_P (XFRAME (frame
))
238 && FRAME_GARBAGED_P (XFRAME (frame
)))
239 Fredraw_frame (frame
);
243 static struct frame_glyphs
*
244 make_frame_glyphs (frame
, empty
)
245 register FRAME_PTR frame
;
249 register width
= FRAME_WIDTH (frame
);
250 register height
= FRAME_HEIGHT (frame
);
251 register struct frame_glyphs
*new
252 = (struct frame_glyphs
*) xmalloc (sizeof (struct frame_glyphs
));
254 SET_GLYPHS_FRAME (new, frame
);
255 new->height
= height
;
257 new->used
= (int *) xmalloc (height
* sizeof (int));
258 new->glyphs
= (GLYPH
**) xmalloc (height
* sizeof (GLYPH
*));
259 new->charstarts
= (int **) xmalloc (height
* sizeof (int *));
260 new->highlight
= (char *) xmalloc (height
* sizeof (char));
261 new->enable
= (char *) xmalloc (height
* sizeof (char));
262 bzero (new->enable
, height
* sizeof (char));
263 new->bufp
= (int *) xmalloc (height
* sizeof (int));
265 #ifdef HAVE_X_WINDOWS
266 if (FRAME_X_P (frame
))
268 new->top_left_x
= (short *) xmalloc (height
* sizeof (short));
269 new->top_left_y
= (short *) xmalloc (height
* sizeof (short));
270 new->pix_width
= (short *) xmalloc (height
* sizeof (short));
271 new->pix_height
= (short *) xmalloc (height
* sizeof (short));
272 new->max_ascent
= (short *) xmalloc (height
* sizeof (short));
278 /* Make the buffer used by decode_mode_spec. This buffer is also
279 used as temporary storage when updating the frame. See scroll.c. */
280 unsigned int total_glyphs
= (width
+ 2) * sizeof (GLYPH
);
281 unsigned int total_charstarts
= (width
+ 2) * sizeof (int);
283 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
284 bzero (new->total_contents
, total_glyphs
);
286 new->total_charstarts
= (int *) xmalloc (total_charstarts
);
287 bzero (new->total_charstarts
, total_glyphs
);
291 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (GLYPH
);
293 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
294 bzero (new->total_contents
, total_glyphs
);
295 for (i
= 0; i
< height
; i
++)
296 new->glyphs
[i
] = new->total_contents
+ i
* (width
+ 2) + 1;
298 if (!FRAME_TERMCAP_P (frame
))
300 unsigned int total_charstarts
= height
* (width
+ 2) * sizeof (int);
302 new->total_charstarts
= (int *) xmalloc (total_charstarts
);
303 bzero (new->total_charstarts
, total_charstarts
);
304 for (i
= 0; i
< height
; i
++)
305 new->charstarts
[i
] = new->total_charstarts
+ i
* (width
+ 2) + 1;
309 /* Without a window system, we don't really need charstarts.
310 So use a small amount of space to make enough data structure
311 to prevent crashes in display_text_line. */
312 new->total_charstarts
= (int *) xmalloc ((width
+ 2) * sizeof (int));
313 for (i
= 0; i
< height
; i
++)
314 new->charstarts
[i
] = new->total_charstarts
;
322 free_frame_glyphs (frame
, glyphs
)
324 struct frame_glyphs
*glyphs
;
326 if (glyphs
->total_contents
)
327 xfree (glyphs
->total_contents
);
328 if (glyphs
->total_charstarts
)
329 xfree (glyphs
->total_charstarts
);
331 xfree (glyphs
->used
);
332 xfree (glyphs
->glyphs
);
333 xfree (glyphs
->highlight
);
334 xfree (glyphs
->enable
);
335 xfree (glyphs
->bufp
);
336 if (glyphs
->charstarts
)
337 xfree (glyphs
->charstarts
);
339 #ifdef HAVE_X_WINDOWS
340 if (FRAME_X_P (frame
))
342 xfree (glyphs
->top_left_x
);
343 xfree (glyphs
->top_left_y
);
344 xfree (glyphs
->pix_width
);
345 xfree (glyphs
->pix_height
);
346 xfree (glyphs
->max_ascent
);
354 remake_frame_glyphs (frame
)
357 if (FRAME_CURRENT_GLYPHS (frame
))
358 free_frame_glyphs (frame
, FRAME_CURRENT_GLYPHS (frame
));
359 if (FRAME_DESIRED_GLYPHS (frame
))
360 free_frame_glyphs (frame
, FRAME_DESIRED_GLYPHS (frame
));
361 if (FRAME_TEMP_GLYPHS (frame
))
362 free_frame_glyphs (frame
, FRAME_TEMP_GLYPHS (frame
));
364 if (FRAME_MESSAGE_BUF (frame
))
366 /* Reallocate the frame's message buffer; remember that
367 echo_area_glyphs may be pointing here. */
368 char *old_message_buf
= FRAME_MESSAGE_BUF (frame
);
370 FRAME_MESSAGE_BUF (frame
)
371 = (char *) xrealloc (FRAME_MESSAGE_BUF (frame
),
372 FRAME_WIDTH (frame
) + 1);
374 if (echo_area_glyphs
== old_message_buf
)
375 echo_area_glyphs
= FRAME_MESSAGE_BUF (frame
);
376 if (previous_echo_glyphs
== old_message_buf
)
377 previous_echo_glyphs
= FRAME_MESSAGE_BUF (frame
);
380 FRAME_MESSAGE_BUF (frame
)
381 = (char *) xmalloc (FRAME_WIDTH (frame
) + 1);
383 FRAME_CURRENT_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
384 FRAME_DESIRED_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
385 FRAME_TEMP_GLYPHS (frame
) = make_frame_glyphs (frame
, 1);
386 SET_FRAME_GARBAGED (frame
);
389 /* Return the hash code of contents of line VPOS in frame-matrix M. */
392 line_hash_code (m
, vpos
)
393 register struct frame_glyphs
*m
;
396 register GLYPH
*body
, *end
;
399 if (!m
->enable
[vpos
])
402 /* Give all highlighted lines the same hash code
403 so as to encourage scrolling to leave them in place. */
404 if (m
->highlight
[vpos
])
407 body
= m
->glyphs
[vpos
];
409 if (must_write_spaces
)
416 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
- SPACEGLYPH
;
425 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
;
433 /* Return number of characters in line in M at vpos VPOS,
434 except don't count leading and trailing spaces
435 unless the terminal requires those to be explicitly output. */
438 line_draw_cost (m
, vpos
)
439 struct frame_glyphs
*m
;
442 register GLYPH
*beg
= m
->glyphs
[vpos
];
443 register GLYPH
*end
= m
->glyphs
[vpos
] + m
->used
[vpos
];
445 register int tlen
= GLYPH_TABLE_LENGTH
;
446 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
448 /* Ignore trailing and leading spaces if we can. */
449 if (!must_write_spaces
)
451 while ((end
!= beg
) && (*end
== SPACEGLYPH
))
454 return (0); /* All blank line. */
456 while (*beg
== SPACEGLYPH
)
460 /* If we don't have a glyph-table, each glyph is one character,
461 so return the number of glyphs. */
465 /* Otherwise, scan the glyphs and accumulate their total size in I. */
467 while ((beg
<= end
) && *beg
)
469 register GLYPH g
= *beg
++;
471 if (GLYPH_SIMPLE_P (tbase
, tlen
, g
))
474 i
+= GLYPH_LENGTH (tbase
, g
);
479 /* The functions on this page are the interface from xdisp.c to redisplay.
481 The only other interface into redisplay is through setting
482 FRAME_CURSOR_X (frame) and FRAME_CURSOR_Y (frame)
483 and SET_FRAME_GARBAGED (frame). */
485 /* cancel_line eliminates any request to display a line at position `vpos' */
487 cancel_line (vpos
, frame
)
489 register FRAME_PTR frame
;
491 FRAME_DESIRED_GLYPHS (frame
)->enable
[vpos
] = 0;
494 clear_frame_records (frame
)
495 register FRAME_PTR frame
;
497 bzero (FRAME_CURRENT_GLYPHS (frame
)->enable
, FRAME_HEIGHT (frame
));
500 /* Prepare to display on line VPOS starting at HPOS within it. */
503 get_display_line (frame
, vpos
, hpos
)
504 register FRAME_PTR frame
;
508 register struct frame_glyphs
*glyphs
;
509 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (frame
);
515 if ((desired_glyphs
->enable
[vpos
]) && desired_glyphs
->used
[vpos
] > hpos
)
518 if (! desired_glyphs
->enable
[vpos
])
520 desired_glyphs
->used
[vpos
] = 0;
521 desired_glyphs
->highlight
[vpos
] = 0;
522 desired_glyphs
->enable
[vpos
] = 1;
525 if (hpos
> desired_glyphs
->used
[vpos
])
527 GLYPH
*g
= desired_glyphs
->glyphs
[vpos
] + desired_glyphs
->used
[vpos
];
528 GLYPH
*end
= desired_glyphs
->glyphs
[vpos
] + hpos
;
530 desired_glyphs
->used
[vpos
] = hpos
;
536 /* Like bcopy except never gets confused by overlap. */
539 safe_bcopy (from
, to
, size
)
543 if (size
<= 0 || from
== to
)
546 /* If the source and destination don't overlap, then bcopy can
547 handle it. If they do overlap, but the destination is lower in
548 memory than the source, we'll assume bcopy can handle that. */
549 if (to
< from
|| from
+ size
<= to
)
550 bcopy (from
, to
, size
);
552 /* Otherwise, we'll copy from the end. */
555 register char *endf
= from
+ size
;
556 register char *endt
= to
+ size
;
558 /* If TO - FROM is large, then we should break the copy into
559 nonoverlapping chunks of TO - FROM bytes each. However, if
560 TO - FROM is small, then the bcopy function call overhead
561 makes this not worth it. The crossover point could be about
562 anywhere. Since I don't think the obvious copy loop is too
563 bad, I'm trying to err in its favor. */
568 while (endf
!= from
);
580 bcopy (endf
, endt
, to
- from
);
583 /* If SIZE wasn't a multiple of TO - FROM, there will be a
584 little left over. The amount left over is
585 (endt + (to - from)) - to, which is endt - from. */
586 bcopy (from
, to
, endt
- from
);
591 /* Rotate a vector of SIZE bytes right, by DISTANCE bytes.
592 DISTANCE may be negative. */
595 rotate_vector (vector
, size
, distance
)
600 char *temp
= (char *) alloca (size
);
605 bcopy (vector
, temp
+ distance
, size
- distance
);
606 bcopy (vector
+ size
- distance
, temp
, distance
);
607 bcopy (temp
, vector
, size
);
610 /* Scroll lines from vpos FROM up to but not including vpos END
611 down by AMOUNT lines (AMOUNT may be negative).
612 Returns nonzero if done, zero if terminal cannot scroll them. */
615 scroll_frame_lines (frame
, from
, end
, amount
, newpos
)
616 register FRAME_PTR frame
;
617 int from
, end
, amount
, newpos
;
620 register struct frame_glyphs
*current_frame
621 = FRAME_CURRENT_GLYPHS (frame
);
623 int width
= FRAME_WIDTH (frame
);
625 if (!line_ins_del_ok
)
633 update_begin (frame
);
634 set_terminal_window (end
+ amount
);
635 if (!scroll_region_ok
)
636 ins_del_lines (end
, -amount
);
637 ins_del_lines (from
, amount
);
638 set_terminal_window (0);
640 rotate_vector (current_frame
->glyphs
+ from
,
641 sizeof (GLYPH
*) * (end
+ amount
- from
),
642 amount
* sizeof (GLYPH
*));
644 rotate_vector (current_frame
->charstarts
+ from
,
645 sizeof (int *) * (end
+ amount
- from
),
646 amount
* sizeof (int *));
648 safe_bcopy (current_frame
->used
+ from
,
649 current_frame
->used
+ from
+ amount
,
650 (end
- from
) * sizeof current_frame
->used
[0]);
652 safe_bcopy (current_frame
->highlight
+ from
,
653 current_frame
->highlight
+ from
+ amount
,
654 (end
- from
) * sizeof current_frame
->highlight
[0]);
656 safe_bcopy (current_frame
->enable
+ from
,
657 current_frame
->enable
+ from
+ amount
,
658 (end
- from
) * sizeof current_frame
->enable
[0]);
660 /* Adjust the lines by an amount
661 that puts the first of them at NEWPOS. */
662 pos_adjust
= newpos
- current_frame
->charstarts
[from
+ amount
][0];
664 /* Offset each char position in the charstarts lines we moved
666 for (i
= from
+ amount
; i
< end
+ amount
; i
++)
668 int *line
= current_frame
->charstarts
[i
];
670 for (col
= 0; col
< width
; col
++)
672 line
[col
] += pos_adjust
;
674 for (i
= from
; i
< from
+ amount
; i
++)
676 int *line
= current_frame
->charstarts
[i
];
679 for (col
= 0; col
< width
; col
++)
683 /* Mark the lines made empty by scrolling as enabled, empty and
685 bzero (current_frame
->used
+ from
,
686 amount
* sizeof current_frame
->used
[0]);
687 bzero (current_frame
->highlight
+ from
,
688 amount
* sizeof current_frame
->highlight
[0]);
689 for (i
= from
; i
< from
+ amount
; i
++)
691 current_frame
->glyphs
[i
][0] = '\0';
692 current_frame
->charstarts
[i
][0] = -1;
693 current_frame
->enable
[i
] = 1;
696 safe_bcopy (current_frame
->bufp
+ from
,
697 current_frame
->bufp
+ from
+ amount
,
698 (end
- from
) * sizeof current_frame
->bufp
[0]);
700 #ifdef HAVE_X_WINDOWS
701 if (FRAME_X_P (frame
))
703 safe_bcopy (current_frame
->top_left_x
+ from
,
704 current_frame
->top_left_x
+ from
+ amount
,
705 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
707 safe_bcopy (current_frame
->top_left_y
+ from
,
708 current_frame
->top_left_y
+ from
+ amount
,
709 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
711 safe_bcopy (current_frame
->pix_width
+ from
,
712 current_frame
->pix_width
+ from
+ amount
,
713 (end
- from
) * sizeof current_frame
->pix_width
[0]);
715 safe_bcopy (current_frame
->pix_height
+ from
,
716 current_frame
->pix_height
+ from
+ amount
,
717 (end
- from
) * sizeof current_frame
->pix_height
[0]);
719 safe_bcopy (current_frame
->max_ascent
+ from
,
720 current_frame
->max_ascent
+ from
+ amount
,
721 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
723 #endif /* HAVE_X_WINDOWS */
729 update_begin (frame
);
730 set_terminal_window (end
);
731 ins_del_lines (from
+ amount
, amount
);
732 if (!scroll_region_ok
)
733 ins_del_lines (end
+ amount
, -amount
);
734 set_terminal_window (0);
736 rotate_vector (current_frame
->glyphs
+ from
+ amount
,
737 sizeof (GLYPH
*) * (end
- from
- amount
),
738 amount
* sizeof (GLYPH
*));
740 rotate_vector (current_frame
->charstarts
+ from
+ amount
,
741 sizeof (int *) * (end
- from
- amount
),
742 amount
* sizeof (int *));
744 safe_bcopy (current_frame
->used
+ from
,
745 current_frame
->used
+ from
+ amount
,
746 (end
- from
) * sizeof current_frame
->used
[0]);
748 safe_bcopy (current_frame
->highlight
+ from
,
749 current_frame
->highlight
+ from
+ amount
,
750 (end
- from
) * sizeof current_frame
->highlight
[0]);
752 safe_bcopy (current_frame
->enable
+ from
,
753 current_frame
->enable
+ from
+ amount
,
754 (end
- from
) * sizeof current_frame
->enable
[0]);
756 /* Adjust the lines by an amount
757 that puts the first of them at NEWPOS. */
758 pos_adjust
= newpos
- current_frame
->charstarts
[from
+ amount
][0];
760 /* Offset each char position in the charstarts lines we moved
762 for (i
= from
+ amount
; i
< end
+ amount
; i
++)
764 int *line
= current_frame
->charstarts
[i
];
766 for (col
= 0; col
< width
; col
++)
768 line
[col
] += pos_adjust
;
770 for (i
= end
+ amount
; i
< end
; i
++)
772 int *line
= current_frame
->charstarts
[i
];
775 for (col
= 0; col
< width
; col
++)
779 /* Mark the lines made empty by scrolling as enabled, empty and
781 bzero (current_frame
->used
+ end
+ amount
,
782 - amount
* sizeof current_frame
->used
[0]);
783 bzero (current_frame
->highlight
+ end
+ amount
,
784 - amount
* sizeof current_frame
->highlight
[0]);
785 for (i
= end
+ amount
; i
< end
; i
++)
787 current_frame
->glyphs
[i
][0] = '\0';
788 current_frame
->charstarts
[i
][0] = 0;
789 current_frame
->enable
[i
] = 1;
792 safe_bcopy (current_frame
->bufp
+ from
,
793 current_frame
->bufp
+ from
+ amount
,
794 (end
- from
) * sizeof current_frame
->bufp
[0]);
796 #ifdef HAVE_X_WINDOWS
797 if (FRAME_X_P (frame
))
799 safe_bcopy (current_frame
->top_left_x
+ from
,
800 current_frame
->top_left_x
+ from
+ amount
,
801 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
803 safe_bcopy (current_frame
->top_left_y
+ from
,
804 current_frame
->top_left_y
+ from
+ amount
,
805 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
807 safe_bcopy (current_frame
->pix_width
+ from
,
808 current_frame
->pix_width
+ from
+ amount
,
809 (end
- from
) * sizeof current_frame
->pix_width
[0]);
811 safe_bcopy (current_frame
->pix_height
+ from
,
812 current_frame
->pix_height
+ from
+ amount
,
813 (end
- from
) * sizeof current_frame
->pix_height
[0]);
815 safe_bcopy (current_frame
->max_ascent
+ from
,
816 current_frame
->max_ascent
+ from
+ amount
,
817 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
819 #endif /* HAVE_X_WINDOWS */
826 /* After updating a window W that isn't the full frame wide,
827 copy all the columns that W does not occupy
828 into the FRAME_DESIRED_GLYPHS (frame) from the FRAME_PHYS_GLYPHS (frame)
829 so that update_frame will not change those columns. */
831 preserve_other_columns (w
)
835 register struct frame_glyphs
*current_frame
, *desired_frame
;
836 register FRAME_PTR frame
= XFRAME (w
->frame
);
837 int start
= XFASTINT (w
->left
);
838 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
839 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
841 current_frame
= FRAME_CURRENT_GLYPHS (frame
);
842 desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
844 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
846 if (current_frame
->enable
[vpos
] && desired_frame
->enable
[vpos
])
852 bcopy (current_frame
->glyphs
[vpos
],
853 desired_frame
->glyphs
[vpos
],
854 start
* sizeof (current_frame
->glyphs
[vpos
][0]));
855 bcopy (current_frame
->charstarts
[vpos
],
856 desired_frame
->charstarts
[vpos
],
857 start
* sizeof (current_frame
->charstarts
[vpos
][0]));
858 len
= min (start
, current_frame
->used
[vpos
]);
859 if (desired_frame
->used
[vpos
] < len
)
860 desired_frame
->used
[vpos
] = len
;
862 if (current_frame
->used
[vpos
] > end
863 && desired_frame
->used
[vpos
] < current_frame
->used
[vpos
])
865 while (desired_frame
->used
[vpos
] < end
)
867 int used
= desired_frame
->used
[vpos
]++;
868 desired_frame
->glyphs
[vpos
][used
] = SPACEGLYPH
;
869 desired_frame
->glyphs
[vpos
][used
] = 0;
871 bcopy (current_frame
->glyphs
[vpos
] + end
,
872 desired_frame
->glyphs
[vpos
] + end
,
873 ((current_frame
->used
[vpos
] - end
)
874 * sizeof (current_frame
->glyphs
[vpos
][0])));
875 bcopy (current_frame
->charstarts
[vpos
] + end
,
876 desired_frame
->charstarts
[vpos
] + end
,
877 ((current_frame
->used
[vpos
] - end
)
878 * sizeof (current_frame
->charstarts
[vpos
][0])));
879 desired_frame
->used
[vpos
] = current_frame
->used
[vpos
];
887 /* If window w does not need to be updated and isn't the full frame wide,
888 copy all the columns that w does occupy
889 into the FRAME_DESIRED_LINES (frame) from the FRAME_PHYS_LINES (frame)
890 so that update_frame will not change those columns.
892 Have not been able to figure out how to use this correctly. */
894 preserve_my_columns (w
)
897 register int vpos
, fin
;
898 register struct frame_glyphs
*l1
, *l2
;
899 register FRAME_PTR frame
= XFRAME (w
->frame
);
900 int start
= XFASTINT (w
->left
);
901 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
902 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
904 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
906 if ((l1
= FRAME_DESIRED_GLYPHS (frame
)->glyphs
[vpos
+ 1])
907 && (l2
= FRAME_PHYS_GLYPHS (frame
)->glyphs
[vpos
+ 1]))
909 if (l2
->length
> start
&& l1
->length
< l2
->length
)
912 if (fin
> end
) fin
= end
;
913 while (l1
->length
< start
)
914 l1
->body
[l1
->length
++] = ' ';
915 bcopy (l2
->body
+ start
, l1
->body
+ start
, fin
- start
);
924 /* Adjust by ADJUST the charstart values in window W
925 after vpos VPOS, which counts relative to the frame
926 (not relative to W itself). */
929 adjust_window_charstarts (w
, vpos
, adjust
)
934 int left
= XFASTINT (w
->left
);
935 int top
= XFASTINT (w
->top
);
936 int right
= left
+ window_internal_width (w
);
937 int bottom
= top
+ window_internal_height (w
);
940 for (i
= vpos
+ 1; i
< bottom
; i
++)
943 = FRAME_CURRENT_GLYPHS (XFRAME (WINDOW_FRAME (w
)))->charstarts
[i
];
945 for (j
= left
; j
< right
; j
++)
946 if (charstart
[j
] > 0)
947 charstart
[j
] += adjust
;
951 /* Check the charstarts values in the area of window W
952 for internal consistency. We cannot check that they are "right";
953 we can only look for something nonsensical. */
955 verify_charstarts (w
)
958 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
960 int top
= XFASTINT (w
->top
);
961 int bottom
= top
+ window_internal_height (w
);
962 int left
= XFASTINT (w
->left
);
963 int right
= left
+ window_internal_width (w
);
965 int truncate
= (XINT (w
->hscroll
)
966 || (truncate_partial_width_windows
967 && (XFASTINT (w
->width
) < FRAME_WIDTH (f
)))
968 || !NILP (XBUFFER (w
->buffer
)->truncate_lines
));
970 for (i
= top
; i
< bottom
; i
++)
974 int *charstart
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[i
];
980 /* If we are truncating lines, allow a jump
981 in charstarts from one line to the next. */
982 if (charstart
[left
] < next_line
)
987 if (charstart
[left
] != next_line
)
992 for (j
= left
; j
< right
; j
++)
993 if (charstart
[j
] > 0)
995 /* Record where the next line should start. */
997 if (BUF_ZV (XBUFFER (w
->buffer
)) != last
)
999 /* If there's a newline between the two lines, count that. */
1000 int endchar
= *BUF_CHAR_ADDRESS (XBUFFER (w
->buffer
), last
);
1001 if (endchar
== '\n')
1007 /* On discovering that the redisplay for a window was no good,
1008 cancel the columns of that window, so that when the window is
1009 displayed over again get_display_line will not complain. */
1011 cancel_my_columns (w
)
1015 register struct frame_glyphs
*desired_glyphs
1016 = FRAME_DESIRED_GLYPHS (XFRAME (w
->frame
));
1017 register int start
= XFASTINT (w
->left
);
1018 register int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
1020 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
1021 if (desired_glyphs
->enable
[vpos
]
1022 && desired_glyphs
->used
[vpos
] >= start
)
1023 desired_glyphs
->used
[vpos
] = start
;
1026 /* These functions try to perform directly and immediately on the frame
1027 the necessary output for one change in the buffer.
1028 They may return 0 meaning nothing was done if anything is difficult,
1029 or 1 meaning the output was performed properly.
1030 They assume that the frame was up to date before the buffer
1031 change being displayed. They make various other assumptions too;
1032 see command_loop_1 where these are called. */
1035 direct_output_for_insert (g
)
1038 register FRAME_PTR frame
= selected_frame
;
1039 register struct frame_glyphs
*current_frame
1040 = FRAME_CURRENT_GLYPHS (frame
);
1042 #ifndef COMPILER_REGISTER_BUG
1044 #endif /* COMPILER_REGISTER_BUG */
1045 struct window
*w
= XWINDOW (selected_window
);
1046 #ifndef COMPILER_REGISTER_BUG
1048 #endif /* COMPILER_REGISTER_BUG */
1049 int hpos
= FRAME_CURSOR_X (frame
);
1050 #ifndef COMPILER_REGISTER_BUG
1052 #endif /* COMPILER_REGISTER_BUG */
1053 int vpos
= FRAME_CURSOR_Y (frame
);
1055 /* Give up if about to continue line. */
1056 if (hpos
>= XFASTINT (w
->left
) + window_internal_width (w
) - 1
1058 /* Avoid losing if cursor is in invisible text off left margin */
1059 || (XINT (w
->hscroll
) && hpos
== XFASTINT (w
->left
))
1061 /* Give up if cursor outside window (in minibuf, probably) */
1062 || cursor_in_echo_area
1063 || FRAME_CURSOR_Y (frame
) < XFASTINT (w
->top
)
1064 || FRAME_CURSOR_Y (frame
) >= XFASTINT (w
->top
) + XFASTINT (w
->height
)
1066 /* Give up if cursor not really at FRAME_CURSOR_X, FRAME_CURSOR_Y */
1067 || !display_completed
1069 /* Give up if buffer appears in two places. */
1070 || buffer_shared
> 1
1072 #ifdef USE_TEXT_PROPERTIES
1073 /* Intervals have already been adjusted, point is after the
1074 character that was just inserted. */
1075 /* Give up if character is invisible. */
1076 /* Give up if character has a face property.
1077 At the moment we only lose at end of line or end of buffer
1078 and only with faces that have some background */
1079 /* Instead of wasting time, give up if character has any text properties */
1080 || ! NILP (Ftext_properties_at (make_number (point
- 1), Qnil
))
1083 /* Give up if w is minibuffer and a message is being displayed there */
1084 || (MINI_WINDOW_P (w
) && echo_area_glyphs
))
1089 #ifdef HAVE_X_WINDOWS
1092 if (FRAME_X_P (frame
))
1093 face
= compute_char_face (frame
, w
, point
- 1, -1, -1, &dummy
, point
, 0);
1095 current_frame
->glyphs
[vpos
][hpos
] = MAKE_GLYPH (frame
, g
, face
);
1096 current_frame
->charstarts
[vpos
][hpos
] = point
- 1;
1097 /* Record the entry for after the newly inserted character. */
1098 current_frame
->charstarts
[vpos
][hpos
+ 1] = point
;
1099 adjust_window_charstarts (w
, vpos
, 1);
1101 unchanged_modified
= MODIFF
;
1102 beg_unchanged
= GPT
- BEG
;
1103 XFASTINT (w
->last_point
) = point
;
1104 XFASTINT (w
->last_point_x
) = hpos
;
1105 XFASTINT (w
->last_modified
) = MODIFF
;
1107 reassert_line_highlight (0, vpos
);
1108 write_glyphs (¤t_frame
->glyphs
[vpos
][hpos
], 1);
1110 ++FRAME_CURSOR_X (frame
);
1111 if (hpos
== current_frame
->used
[vpos
])
1113 current_frame
->used
[vpos
] = hpos
+ 1;
1114 current_frame
->glyphs
[vpos
][hpos
+ 1] = 0;
1121 direct_output_forward_char (n
)
1124 register FRAME_PTR frame
= selected_frame
;
1125 register struct window
*w
= XWINDOW (selected_window
);
1126 Lisp_Object position
;
1127 int hpos
= FRAME_CURSOR_X (frame
);
1129 /* Give up if in truncated text at end of line. */
1130 if (hpos
>= XFASTINT (w
->left
) + window_internal_width (w
) - 1)
1133 /* Avoid losing if cursor is in invisible text off left margin
1134 or about to go off either side of window. */
1135 if ((FRAME_CURSOR_X (frame
) == XFASTINT (w
->left
)
1136 && (XINT (w
->hscroll
) || n
< 0))
1138 && (FRAME_CURSOR_X (frame
) + 1 >= window_internal_width (w
) - 1))
1139 || cursor_in_echo_area
)
1142 /* Can't use direct output if highlighting a region. */
1143 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
1146 #ifdef USE_TEXT_PROPERTIES
1147 /* Don't use direct output next to an invisible character
1148 since we might need to do something special. */
1150 XFASTINT (position
) = point
;
1151 if (XFASTINT (position
) < ZV
1152 && ! NILP (Fget_char_property (position
,
1157 XFASTINT (position
) = point
- 1;
1158 if (XFASTINT (position
) >= BEGV
1159 && ! NILP (Fget_char_property (position
,
1165 FRAME_CURSOR_X (frame
) += n
;
1166 XFASTINT (w
->last_point_x
) = FRAME_CURSOR_X (frame
);
1167 XFASTINT (w
->last_point
) = point
;
1168 cursor_to (FRAME_CURSOR_Y (frame
), FRAME_CURSOR_X (frame
));
1174 static void update_line ();
1176 /* Update frame F based on the data in FRAME_DESIRED_GLYPHS.
1177 Value is nonzero if redisplay stopped due to pending input.
1178 FORCE nonzero means do not stop for pending input. */
1181 update_frame (f
, force
, inhibit_hairy_id
)
1184 int inhibit_hairy_id
;
1186 register struct frame_glyphs
*current_frame
;
1187 register struct frame_glyphs
*desired_frame
= 0;
1190 int preempt_count
= baud_rate
/ 2400 + 1;
1191 extern input_pending
;
1192 #ifdef HAVE_X_WINDOWS
1193 register int downto
, leftmost
;
1196 if (preempt_count
<= 0)
1199 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1201 detect_input_pending ();
1202 if (input_pending
&& !force
)
1210 if (!line_ins_del_ok
)
1211 inhibit_hairy_id
= 1;
1213 /* These are separate to avoid a possible bug in the AIX C compiler. */
1214 current_frame
= FRAME_CURRENT_GLYPHS (f
);
1215 desired_frame
= FRAME_DESIRED_GLYPHS (f
);
1217 /* See if any of the desired lines are enabled; don't compute for
1218 i/d line if just want cursor motion. */
1219 for (i
= 0; i
< FRAME_HEIGHT (f
); i
++)
1220 if (desired_frame
->enable
[i
])
1223 /* Try doing i/d line, if not yet inhibited. */
1224 if (!inhibit_hairy_id
&& i
< FRAME_HEIGHT (f
))
1225 force
|= scrolling (f
);
1227 /* Update the individual lines as needed. Do bottom line first. */
1229 if (desired_frame
->enable
[FRAME_HEIGHT (f
) - 1])
1230 update_line (f
, FRAME_HEIGHT (f
) - 1);
1232 #ifdef HAVE_X_WINDOWS
1235 leftmost
= downto
= f
->display
.x
->internal_border_width
;
1236 if (desired_frame
->enable
[0])
1238 current_frame
->top_left_x
[FRAME_HEIGHT (f
) - 1] = leftmost
;
1239 current_frame
->top_left_y
[FRAME_HEIGHT (f
) - 1]
1240 = PIXEL_HEIGHT (f
) - f
->display
.x
->internal_border_width
1241 - current_frame
->pix_height
[FRAME_HEIGHT (f
) - 1];
1242 current_frame
->top_left_x
[0] = leftmost
;
1243 current_frame
->top_left_y
[0] = downto
;
1246 #endif /* HAVE_X_WINDOWS */
1248 /* Now update the rest of the lines. */
1249 for (i
= 0; i
< FRAME_HEIGHT (f
) - 1 && (force
|| !input_pending
); i
++)
1251 if (desired_frame
->enable
[i
])
1253 if (FRAME_TERMCAP_P (f
))
1255 /* Flush out every so many lines.
1256 Also flush out if likely to have more than 1k buffered
1257 otherwise. I'm told that some telnet connections get
1258 really screwed by more than 1k output at once. */
1259 int outq
= PENDING_OUTPUT_COUNT (stdout
);
1261 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
1264 if (preempt_count
== 1)
1266 #ifdef EMACS_OUTQSIZE
1267 if (EMACS_OUTQSIZE (0, &outq
) < 0)
1268 /* Probably not a tty. Ignore the error and reset
1269 * the outq count. */
1270 outq
= PENDING_OUTPUT_COUNT (stdout
);
1273 if (baud_rate
<= outq
&& baud_rate
> 0)
1274 sleep (outq
/ baud_rate
);
1277 if ((i
- 1) % preempt_count
== 0)
1278 detect_input_pending ();
1282 #ifdef HAVE_X_WINDOWS
1285 current_frame
->top_left_y
[i
] = downto
;
1286 current_frame
->top_left_x
[i
] = leftmost
;
1288 #endif /* HAVE_X_WINDOWS */
1291 #ifdef HAVE_X_WINDOWS
1293 downto
+= current_frame
->pix_height
[i
];
1296 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
1298 /* Now just clean up termcap drivers and set cursor, etc. */
1301 if (cursor_in_echo_area
1302 && FRAME_HAS_MINIBUF_P (f
))
1304 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
1307 if (cursor_in_echo_area
< 0)
1314 /* If the minibuffer is several lines high, find the last
1315 line that has any text on it. */
1316 row
= FRAME_HEIGHT (f
);
1320 if (current_frame
->enable
[row
])
1321 col
= current_frame
->used
[row
];
1325 while (row
> top
&& col
== 0);
1327 if (col
>= FRAME_WIDTH (f
))
1330 if (row
< FRAME_HEIGHT (f
) - 1)
1335 cursor_to (row
, col
);
1338 cursor_to (FRAME_CURSOR_Y (f
), max (min (FRAME_CURSOR_X (f
),
1339 FRAME_WIDTH (f
) - 1), 0));
1345 fflush (termscript
);
1348 /* Here if output is preempted because input is detected. */
1351 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1352 display_completed
= !pause
;
1354 bzero (FRAME_DESIRED_GLYPHS (f
)->enable
, FRAME_HEIGHT (f
));
1358 /* Called when about to quit, to check for doing so
1359 at an improper time. */
1364 if (FRAME_DESIRED_GLYPHS (selected_frame
) == 0)
1366 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[0])
1368 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[FRAME_HEIGHT (selected_frame
) - 1])
1372 /* Decide what insert/delete line to do, and do it */
1374 extern void scrolling_1 ();
1379 int unchanged_at_top
, unchanged_at_bottom
;
1382 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1383 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1384 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1386 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
1387 register struct frame_glyphs
*current_frame
= FRAME_CURRENT_GLYPHS (frame
);
1388 register struct frame_glyphs
*desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
1390 /* Compute hash codes of all the lines.
1391 Also calculate number of changed lines,
1392 number of unchanged lines at the beginning,
1393 and number of unchanged lines at the end. */
1396 unchanged_at_top
= 0;
1397 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
1398 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
1400 /* Give up on this scrolling if some old lines are not enabled. */
1401 if (!current_frame
->enable
[i
])
1403 old_hash
[i
] = line_hash_code (current_frame
, i
);
1404 if (! desired_frame
->enable
[i
])
1405 new_hash
[i
] = old_hash
[i
];
1407 new_hash
[i
] = line_hash_code (desired_frame
, i
);
1409 if (old_hash
[i
] != new_hash
[i
])
1412 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
1414 else if (i
== unchanged_at_top
)
1416 draw_cost
[i
] = line_draw_cost (desired_frame
, i
);
1419 /* If changed lines are few, don't allow preemption, don't scroll. */
1420 if (changed_lines
< baud_rate
/ 2400
1421 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
1424 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
1425 - unchanged_at_bottom
);
1427 if (scroll_region_ok
)
1428 free_at_end_vpos
-= unchanged_at_bottom
;
1429 else if (memory_below_frame
)
1430 free_at_end_vpos
= -1;
1432 /* If large window, fast terminal and few lines in common between
1433 current frame and desired frame, don't bother with i/d calc. */
1434 if (window_size
>= 18 && baud_rate
> 2400
1436 10 * scrolling_max_lines_saved (unchanged_at_top
,
1437 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
1438 old_hash
, new_hash
, draw_cost
)))
1441 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
1442 draw_cost
+ unchanged_at_top
- 1,
1443 old_hash
+ unchanged_at_top
- 1,
1444 new_hash
+ unchanged_at_top
- 1,
1445 free_at_end_vpos
- unchanged_at_top
);
1450 /* Return the offset in its buffer of the character at location col, line
1451 in the given window. */
1453 buffer_posn_from_coords (window
, col
, line
)
1454 struct window
*window
;
1457 int hscroll
= XINT (window
->hscroll
);
1458 int window_left
= XFASTINT (window
->left
);
1460 /* The actual width of the window is window->width less one for the
1461 DISP_CONTINUE_GLYPH, and less one if it's not the rightmost
1463 int window_width
= window_internal_width (window
) - 1;
1465 int startp
= marker_position (window
->start
);
1467 /* Since compute_motion will only operate on the current buffer,
1468 we need to save the old one and restore it when we're done. */
1469 struct buffer
*old_current_buffer
= current_buffer
;
1470 struct position
*posn
;
1472 current_buffer
= XBUFFER (window
->buffer
);
1474 /* It would be nice if we could use FRAME_CURRENT_GLYPHS (XFRAME
1475 (window->frame))->bufp to avoid scanning from the very top of
1476 the window, but it isn't maintained correctly, and I'm not even
1477 sure I will keep it. */
1478 posn
= compute_motion (startp
, 0,
1479 (window
== XWINDOW (minibuf_window
) && startp
== 1
1480 ? minibuf_prompt_width
: 0)
1481 + (hscroll
? 1 - hscroll
: 0),
1483 window_width
, hscroll
, 0, window
);
1485 current_buffer
= old_current_buffer
;
1487 /* compute_motion considers frame points past the end of a line
1488 to be *after* the newline, i.e. at the start of the next line.
1489 This is reasonable, but not really what we want. So if the
1490 result is on a line below LINE, back it up one character. */
1491 if (posn
->vpos
> line
)
1492 return posn
->bufpos
- 1;
1494 return posn
->bufpos
;
1501 register GLYPH
*p
= r
;
1502 while (*p
++ == SPACEGLYPH
);
1507 count_match (str1
, str2
)
1510 register GLYPH
*p1
= str1
;
1511 register GLYPH
*p2
= str2
;
1512 while (*p1
++ == *p2
++);
1513 return p1
- str1
- 1;
1516 /* Char insertion/deletion cost vector, from term.c */
1517 extern int *char_ins_del_vector
;
1519 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WIDTH((f))])
1522 update_line (frame
, vpos
)
1523 register FRAME_PTR frame
;
1526 register GLYPH
*obody
, *nbody
, *op1
, *op2
, *np1
, *temp
;
1529 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
1531 register struct frame_glyphs
*current_frame
1532 = FRAME_CURRENT_GLYPHS (frame
);
1533 register struct frame_glyphs
*desired_frame
1534 = FRAME_DESIRED_GLYPHS (frame
);
1536 if (desired_frame
->highlight
[vpos
]
1537 != (current_frame
->enable
[vpos
] && current_frame
->highlight
[vpos
]))
1539 change_line_highlight (desired_frame
->highlight
[vpos
], vpos
,
1540 (current_frame
->enable
[vpos
] ?
1541 current_frame
->used
[vpos
] : 0));
1542 current_frame
->enable
[vpos
] = 0;
1545 reassert_line_highlight (desired_frame
->highlight
[vpos
], vpos
);
1547 if (! current_frame
->enable
[vpos
])
1553 obody
= current_frame
->glyphs
[vpos
];
1554 olen
= current_frame
->used
[vpos
];
1555 if (! current_frame
->highlight
[vpos
])
1557 if (!must_write_spaces
)
1558 while (obody
[olen
- 1] == SPACEGLYPH
&& olen
> 0)
1563 /* For an inverse-video line, remember we gave it
1564 spaces all the way to the frame edge
1565 so that the reverse video extends all the way across. */
1567 while (olen
< FRAME_WIDTH (frame
) - 1)
1568 obody
[olen
++] = SPACEGLYPH
;
1572 /* One way or another, this will enable the line being updated. */
1573 current_frame
->enable
[vpos
] = 1;
1574 current_frame
->used
[vpos
] = desired_frame
->used
[vpos
];
1575 current_frame
->highlight
[vpos
] = desired_frame
->highlight
[vpos
];
1576 current_frame
->bufp
[vpos
] = desired_frame
->bufp
[vpos
];
1578 #ifdef HAVE_X_WINDOWS
1579 if (FRAME_X_P (frame
))
1581 current_frame
->pix_width
[vpos
]
1582 = current_frame
->used
[vpos
]
1583 * FONT_WIDTH (frame
->display
.x
->font
);
1584 current_frame
->pix_height
[vpos
]
1585 = frame
->display
.x
->line_height
;
1587 #endif /* HAVE_X_WINDOWS */
1589 if (!desired_frame
->enable
[vpos
])
1595 nbody
= desired_frame
->glyphs
[vpos
];
1596 nlen
= desired_frame
->used
[vpos
];
1598 /* Pretend trailing spaces are not there at all,
1599 unless for one reason or another we must write all spaces. */
1600 if (! desired_frame
->highlight
[vpos
])
1602 if (!must_write_spaces
)
1603 /* We know that the previous character byte contains 0. */
1604 while (nbody
[nlen
- 1] == SPACEGLYPH
)
1609 /* For an inverse-video line, give it extra trailing spaces
1610 all the way to the frame edge
1611 so that the reverse video extends all the way across. */
1613 while (nlen
< FRAME_WIDTH (frame
) - 1)
1614 nbody
[nlen
++] = SPACEGLYPH
;
1617 /* If there's no i/d char, quickly do the best we can without it. */
1618 if (!char_ins_del_ok
)
1623 if (FRAME_X_P (frame
))
1625 /* Under X, erase everything we are going to rewrite,
1626 and rewrite everything from the first char that's changed.
1627 This is part of supporting fonts like Courier
1628 whose chars can overlap outside the char width. */
1629 for (i
= 0; i
< nlen
; i
++)
1630 if (i
>= olen
|| nbody
[i
] != obody
[i
])
1633 cursor_to (vpos
, i
);
1635 clear_end_of_line (olen
);
1636 write_glyphs (nbody
+ i
, nlen
- i
);
1641 for (i
= 0; i
< nlen
; i
++)
1643 if (i
>= olen
|| nbody
[i
] != obody
[i
]) /* A non-matching char. */
1645 cursor_to (vpos
, i
);
1646 for (j
= 1; (i
+ j
< nlen
&&
1647 (i
+ j
>= olen
|| nbody
[i
+j
] != obody
[i
+j
]));
1650 /* Output this run of non-matching chars. */
1651 write_glyphs (nbody
+ i
, j
);
1654 /* Now find the next non-match. */
1658 /* Clear the rest of the line, or the non-clear part of it. */
1661 cursor_to (vpos
, nlen
);
1662 clear_end_of_line (olen
);
1665 /* Exchange contents between current_frame and new_frame. */
1666 temp
= desired_frame
->glyphs
[vpos
];
1667 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1668 current_frame
->glyphs
[vpos
] = temp
;
1670 /* Exchange charstarts between current_frame and new_frame. */
1671 temp1
= desired_frame
->charstarts
[vpos
];
1672 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1673 current_frame
->charstarts
[vpos
] = temp1
;
1680 nsp
= (must_write_spaces
|| desired_frame
->highlight
[vpos
])
1681 ? 0 : count_blanks (nbody
);
1684 cursor_to (vpos
, nsp
);
1685 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
1688 /* Exchange contents between current_frame and new_frame. */
1689 temp
= desired_frame
->glyphs
[vpos
];
1690 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1691 current_frame
->glyphs
[vpos
] = temp
;
1693 /* Exchange charstarts between current_frame and new_frame. */
1694 temp1
= desired_frame
->charstarts
[vpos
];
1695 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1696 current_frame
->charstarts
[vpos
] = temp1
;
1705 /* Compute number of leading blanks in old and new contents. */
1706 osp
= count_blanks (obody
);
1707 if (!desired_frame
->highlight
[vpos
])
1708 nsp
= count_blanks (nbody
);
1712 /* Compute number of matching chars starting with first nonblank. */
1713 begmatch
= count_match (obody
+ osp
, nbody
+ nsp
);
1715 /* Spaces in new match implicit space past the end of old. */
1716 /* A bug causing this to be a no-op was fixed in 18.29. */
1717 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
1720 while (np1
[begmatch
] == SPACEGLYPH
)
1724 /* Avoid doing insert/delete char
1725 just cause number of leading spaces differs
1726 when the following text does not match. */
1727 if (begmatch
== 0 && osp
!= nsp
)
1728 osp
= nsp
= min (osp
, nsp
);
1730 /* Find matching characters at end of line */
1733 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
1734 while (op1
> op2
&& op1
[-1] == np1
[-1])
1739 endmatch
= obody
+ olen
- op1
;
1741 /* Put correct value back in nbody[nlen].
1742 This is important because direct_output_for_insert
1743 can write into the line at a later point.
1744 If this screws up the zero at the end of the line, re-establish it. */
1748 /* tem gets the distance to insert or delete.
1749 endmatch is how many characters we save by doing so.
1752 tem
= (nlen
- nsp
) - (olen
- osp
);
1754 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
1757 /* nsp - osp is the distance to insert or delete.
1758 If that is nonzero, begmatch is known to be nonzero also.
1759 begmatch + endmatch is how much we save by doing the ins/del.
1763 && (!char_ins_del_ok
1764 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
1768 osp
= nsp
= min (osp
, nsp
);
1771 /* Now go through the line, inserting, writing and
1772 deleting as appropriate. */
1776 cursor_to (vpos
, nsp
);
1777 delete_glyphs (osp
- nsp
);
1781 /* If going to delete chars later in line
1782 and insert earlier in the line,
1783 must delete first to avoid losing data in the insert */
1784 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
1786 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
1787 delete_glyphs (olen
+ nsp
- osp
- nlen
);
1788 olen
= nlen
- (nsp
- osp
);
1790 cursor_to (vpos
, osp
);
1791 insert_glyphs ((char *)0, nsp
- osp
);
1795 tem
= nsp
+ begmatch
+ endmatch
;
1796 if (nlen
!= tem
|| olen
!= tem
)
1798 cursor_to (vpos
, nsp
+ begmatch
);
1799 if (!endmatch
|| nlen
== olen
)
1801 /* If new text being written reaches right margin,
1802 there is no need to do clear-to-eol at the end.
1803 (and it would not be safe, since cursor is not
1804 going to be "at the margin" after the text is done) */
1805 if (nlen
== FRAME_WIDTH (frame
))
1807 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1811 /* the following code loses disastrously if tem == nlen.
1812 Rather than trying to fix that case, I am trying the simpler
1813 solution found above. */
1815 /* If the text reaches to the right margin,
1816 it will lose one way or another (depending on AutoWrap)
1817 to clear to end of line after outputting all the text.
1818 So pause with one character to go and clear the line then. */
1819 if (nlen
== FRAME_WIDTH (frame
) && fast_clear_end_of_line
&& olen
> nlen
)
1821 /* endmatch must be zero, and tem must equal nsp + begmatch */
1822 write_glyphs (nbody
+ tem
, nlen
- tem
- 1);
1823 clear_end_of_line (olen
);
1824 olen
= 0; /* Don't let it be cleared again later */
1825 write_glyphs (nbody
+ nlen
- 1, 1);
1828 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1829 #endif /* OBSOLETE */
1832 else if (nlen
> olen
)
1834 write_glyphs (nbody
+ nsp
+ begmatch
, olen
- tem
);
1835 insert_glyphs (nbody
+ nsp
+ begmatch
+ olen
- tem
, nlen
- olen
);
1838 else if (olen
> nlen
)
1840 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1841 delete_glyphs (olen
- nlen
);
1847 /* If any unerased characters remain after the new line, erase them. */
1850 cursor_to (vpos
, nlen
);
1851 clear_end_of_line (olen
);
1854 /* Exchange contents between current_frame and new_frame. */
1855 temp
= desired_frame
->glyphs
[vpos
];
1856 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1857 current_frame
->glyphs
[vpos
] = temp
;
1859 /* Exchange charstarts between current_frame and new_frame. */
1860 temp1
= desired_frame
->charstarts
[vpos
];
1861 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1862 current_frame
->charstarts
[vpos
] = temp1
;
1865 /* A vector of size >= NFRAMES + 3 * NBUFFERS + 1, containing the session's
1866 frames, buffers, buffer-read-only flags, and buffer-modified-flags,
1867 and a trailing sentinel (so we don't need to add length checks). */
1868 static Lisp_Object frame_and_buffer_state
;
1870 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
1871 Sframe_or_buffer_changed_p
, 0, 0, 0,
1872 "Return non-nil if the frame and buffer state appears to have changed.\n\
1873 The state variable is an internal vector containing all frames and buffers,\n\
1874 along with the buffers' read-only and modified flags, which allows a fast\n\
1875 check to see whether the menu bars might need to be recomputed.\n\
1876 If this function returns non-nil, it updates the internal vector to reflect\n\
1877 the current state.\n")
1880 Lisp_Object tail
, frame
, buf
;
1883 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
1884 FOR_EACH_FRAME (tail
, frame
)
1885 if (!EQ (*vecp
++, frame
))
1887 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1889 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
1890 if (!EQ (*vecp
++, buf
))
1892 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
1894 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
1900 FOR_EACH_FRAME (tail
, frame
)
1902 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1904 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
1905 if (n
> XVECTOR (frame_and_buffer_state
)->size
1906 || n
< XVECTOR (frame_and_buffer_state
)->size
/ 2)
1907 frame_and_buffer_state
= Fmake_vector (make_number (n
), Qlambda
);
1908 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
1909 FOR_EACH_FRAME (tail
, frame
)
1911 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1913 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
1915 *vecp
++ = XBUFFER (buf
)->read_only
;
1916 *vecp
++ = Fbuffer_modified_p (buf
);
1918 /* If we left any slack in the vector, fill it up now. */
1919 for (; n
< XVECTOR (frame_and_buffer_state
)->size
; ++n
)
1924 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
1925 1, 1, "FOpen termscript file: ",
1926 "Start writing all terminal output to FILE as well as the terminal.\n\
1927 FILE = nil means just close any termscript file currently open.")
1931 if (termscript
!= 0) fclose (termscript
);
1936 file
= Fexpand_file_name (file
, Qnil
);
1937 termscript
= fopen (XSTRING (file
)->data
, "w");
1938 if (termscript
== 0)
1939 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
1947 window_change_signal ()
1951 int old_errno
= errno
;
1953 get_frame_size (&width
, &height
);
1955 /* The frame size change obviously applies to a termcap-controlled
1956 frame. Find such a frame in the list, and assume it's the only
1957 one (since the redisplay code always writes to stdout, not a
1958 FILE * specified in the frame structure). Record the new size,
1959 but don't reallocate the data structures now. Let that be done
1960 later outside of the signal handler. */
1963 Lisp_Object tail
, frame
;
1965 FOR_EACH_FRAME (tail
, frame
)
1967 if (FRAME_TERMCAP_P (XFRAME (frame
)))
1969 change_frame_size (XFRAME (frame
), height
, width
, 0, 1);
1975 signal (SIGWINCH
, window_change_signal
);
1978 #endif /* SIGWINCH */
1981 /* Do any change in frame size that was requested by a signal. */
1983 do_pending_window_change ()
1985 /* If window_change_signal should have run before, run it now. */
1986 while (delayed_size_change
)
1988 Lisp_Object tail
, frame
;
1990 delayed_size_change
= 0;
1992 FOR_EACH_FRAME (tail
, frame
)
1994 FRAME_PTR f
= XFRAME (frame
);
1996 int height
= FRAME_NEW_HEIGHT (f
);
1997 int width
= FRAME_NEW_WIDTH (f
);
1999 if (height
!= 0 || width
!= 0)
2000 change_frame_size (f
, height
, width
, 0, 0);
2006 /* Change the frame height and/or width. Values may be given as zero to
2007 indicate no change is to take place.
2009 If DELAY is non-zero, then assume we're being called from a signal
2010 handler, and queue the change for later - perhaps the next
2011 redisplay. Since this tries to resize windows, we can't call it
2012 from a signal handler. */
2014 change_frame_size (frame
, newheight
, newwidth
, pretend
, delay
)
2015 register FRAME_PTR frame
;
2016 int newheight
, newwidth
, pretend
;
2018 /* If we can't deal with the change now, queue it for later. */
2021 FRAME_NEW_HEIGHT (frame
) = newheight
;
2022 FRAME_NEW_WIDTH (frame
) = newwidth
;
2023 delayed_size_change
= 1;
2027 /* This size-change overrides any pending one for this frame. */
2028 FRAME_NEW_HEIGHT (frame
) = 0;
2029 FRAME_NEW_WIDTH (frame
) = 0;
2031 /* If an argument is zero, set it to the current value. */
2032 newheight
|| (newheight
= FRAME_HEIGHT (frame
));
2033 newwidth
|| (newwidth
= FRAME_WIDTH (frame
));
2035 /* Round up to the smallest acceptable size. */
2036 check_frame_size (frame
, &newheight
, &newwidth
);
2038 /* If we're not changing the frame size, quit now. */
2039 if (newheight
== FRAME_HEIGHT (frame
)
2040 && newwidth
== FRAME_WIDTH (frame
))
2043 if (newheight
!= FRAME_HEIGHT (frame
))
2045 if (FRAME_HAS_MINIBUF_P (frame
)
2046 && ! FRAME_MINIBUF_ONLY_P (frame
))
2048 /* Frame has both root and minibuffer. */
2049 set_window_height (FRAME_ROOT_WINDOW (frame
),
2050 newheight
- 1 - FRAME_MENU_BAR_LINES (frame
), 0);
2051 XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (frame
))->top
)
2053 set_window_height (FRAME_MINIBUF_WINDOW (frame
), 1, 0);
2056 /* Frame has just one top-level window. */
2057 set_window_height (FRAME_ROOT_WINDOW (frame
),
2058 newheight
- FRAME_MENU_BAR_LINES (frame
), 0);
2060 if (FRAME_TERMCAP_P (frame
) && !pretend
)
2061 FrameRows
= newheight
;
2064 if (frame
->output_method
== output_termcap
)
2066 frame_height
= newheight
;
2068 FrameRows
= newheight
;
2073 if (newwidth
!= FRAME_WIDTH (frame
))
2075 set_window_width (FRAME_ROOT_WINDOW (frame
), newwidth
, 0);
2076 if (FRAME_HAS_MINIBUF_P (frame
))
2077 set_window_width (FRAME_MINIBUF_WINDOW (frame
), newwidth
, 0);
2079 if (FRAME_TERMCAP_P (frame
) && !pretend
)
2080 FrameCols
= newwidth
;
2082 if (frame
->output_method
== output_termcap
)
2084 frame_width
= newwidth
;
2086 FrameCols
= newwidth
;
2091 FRAME_HEIGHT (frame
) = newheight
;
2092 FRAME_WIDTH (frame
) = newwidth
;
2094 if (FRAME_CURSOR_X (frame
) >= FRAME_WIDTH (frame
))
2095 FRAME_CURSOR_X (frame
) = FRAME_WIDTH (frame
) - 1;
2096 if (FRAME_CURSOR_Y (frame
) >= FRAME_HEIGHT (frame
))
2097 FRAME_CURSOR_Y (frame
) = FRAME_HEIGHT (frame
) - 1;
2099 remake_frame_glyphs (frame
);
2100 calculate_costs (frame
);
2103 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
2104 Ssend_string_to_terminal
, 1, 1, 0,
2105 "Send STRING to the terminal without alteration.\n\
2106 Control characters in STRING will have terminal-dependent effects.")
2110 CHECK_STRING (str
, 0);
2111 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, stdout
);
2115 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, termscript
);
2116 fflush (termscript
);
2121 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
2122 "Beep, or flash the screen.\n\
2123 Also, unless an argument is given,\n\
2124 terminate any keyboard macro currently executing.")
2146 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
2147 error ("Keyboard macro terminated by a command ringing the bell");
2153 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
2154 "Pause, without updating display, for SECONDS seconds.\n\
2155 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2156 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2157 additional wait period, in milliseconds; this may be useful if your\n\
2158 Emacs was built without floating point support.\n\
2159 \(Not all operating systems support waiting for a fraction of a second.)")
2160 (seconds
, milliseconds
)
2161 Lisp_Object seconds
, milliseconds
;
2165 if (NILP (milliseconds
))
2166 XSET (milliseconds
, Lisp_Int
, 0);
2168 CHECK_NUMBER (milliseconds
, 1);
2169 usec
= XINT (milliseconds
) * 1000;
2171 #ifdef LISP_FLOAT_TYPE
2173 double duration
= extract_float (seconds
);
2174 sec
= (int) duration
;
2175 usec
+= (duration
- sec
) * 1000000;
2178 CHECK_NUMBER (seconds
, 0);
2179 sec
= XINT (seconds
);
2182 #ifndef EMACS_HAS_USECS
2183 if (sec
== 0 && usec
!= 0)
2184 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
2187 /* Assure that 0 <= usec < 1000000. */
2190 /* We can't rely on the rounding being correct if user is negative. */
2191 if (-1000000 < usec
)
2192 sec
--, usec
+= 1000000;
2194 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
2197 sec
+= usec
/ 1000000, usec
%= 1000000;
2205 XFASTINT (zero
) = 0;
2206 wait_reading_process_input (sec
, usec
, zero
, 0);
2209 /* We should always have wait_reading_process_input; we have a dummy
2210 implementation for systems which don't support subprocesses. */
2212 /* No wait_reading_process_input */
2219 /* The reason this is done this way
2220 (rather than defined (H_S) && defined (H_T))
2221 is because the VMS preprocessor doesn't grok `defined' */
2223 EMACS_GET_TIME (end_time
);
2224 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
2225 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
2229 EMACS_GET_TIME (timeout
);
2230 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
2231 if (EMACS_TIME_NEG_P (timeout
)
2232 || !select (1, 0, 0, 0, &timeout
))
2235 #else /* not HAVE_SELECT */
2237 #endif /* HAVE_SELECT */
2238 #endif /* not VMS */
2241 #endif /* no subprocesses */
2246 /* This is just like wait_reading_process_input, except that
2247 it does the redisplay.
2249 It's also much like Fsit_for, except that it can be used for
2250 waiting for input as well. One differnce is that sit_for
2251 does not call prepare_menu_bars; Fsit_for does call that. */
2254 sit_for (sec
, usec
, reading
, display
)
2255 int sec
, usec
, reading
, display
;
2257 Lisp_Object read_kbd
;
2259 if (detect_input_pending ())
2263 redisplay_preserve_echo_area ();
2265 if (sec
== 0 && usec
== 0)
2272 XSET (read_kbd
, Lisp_Int
, reading
? -1 : 1);
2273 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
2276 /* wait_reading_process_input should always be available now; it is
2277 simulated in a simple way on systems that don't support
2280 /* No wait_reading_process_input available. */
2286 input_wait_timeout (XINT (arg
));
2288 #ifndef HAVE_TIMEVAL
2290 select (1, &waitchannels
, 0, 0, &timeout_sec
);
2291 #else /* HAVE_TIMEVAL */
2292 timeout
.tv_sec
= sec
;
2293 timeout
.tv_usec
= usec
;
2294 select (1, &waitchannels
, 0, 0, &timeout
);
2295 #endif /* HAVE_TIMEVAL */
2296 #endif /* not VMS */
2301 return detect_input_pending () ? Qnil
: Qt
;
2304 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
2305 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
2306 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2307 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2308 additional wait period, in milliseconds; this may be useful if your\n\
2309 Emacs was built without floating point support.\n\
2310 \(Not all operating systems support waiting for a fraction of a second.)\n\
2311 Optional third arg non-nil means don't redisplay, just wait for input.\n\
2312 Redisplay is preempted as always if input arrives, and does not happen\n\
2313 if input is available before it starts.\n\
2314 Value is t if waited the full time with no input arriving.")
2315 (seconds
, milliseconds
, nodisp
)
2316 Lisp_Object seconds
, milliseconds
, nodisp
;
2320 if (NILP (milliseconds
))
2321 XSET (milliseconds
, Lisp_Int
, 0);
2323 CHECK_NUMBER (milliseconds
, 1);
2324 usec
= XINT (milliseconds
) * 1000;
2326 #ifdef LISP_FLOAT_TYPE
2328 double duration
= extract_float (seconds
);
2329 sec
= (int) duration
;
2330 usec
+= (duration
- sec
) * 1000000;
2333 CHECK_NUMBER (seconds
, 0);
2334 sec
= XINT (seconds
);
2337 #ifndef EMACS_HAS_USECS
2338 if (usec
!= 0 && sec
== 0)
2339 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
2343 prepare_menu_bars ();
2344 return sit_for (sec
, usec
, 0, NILP (nodisp
));
2347 char *terminal_type
;
2349 /* Initialization done when Emacs fork is started, before doing stty. */
2350 /* Determine terminal type and set terminal_driver */
2351 /* Then invoke its decoding routine to set up variables
2352 in the terminal package */
2356 #ifdef HAVE_X_WINDOWS
2357 extern int display_arg
;
2362 cursor_in_echo_area
= 0;
2363 terminal_type
= (char *) 0;
2365 /* Now is the time to initialize this; it's used by init_sys_modes
2367 Vwindow_system
= Qnil
;
2369 /* If the user wants to use a window system, we shouldn't bother
2370 initializing the terminal. This is especially important when the
2371 terminal is so dumb that emacs gives up before and doesn't bother
2372 using the window system.
2374 If the DISPLAY environment variable is set, try to use X, and die
2375 with an error message if that doesn't work. */
2377 #ifdef HAVE_X_WINDOWS
2381 display_arg
= (getenv ("DECW$DISPLAY") != 0);
2383 display_arg
= (getenv ("DISPLAY") != 0);
2387 if (!inhibit_window_system
&& display_arg
)
2389 Vwindow_system
= intern ("x");
2391 Vwindow_system_version
= make_number (11);
2393 Vwindow_system_version
= make_number (10);
2397 #endif /* HAVE_X_WINDOWS */
2399 /* If no window system has been specified, try to use the terminal. */
2402 fprintf (stderr
, "emacs: standard input is not a tty\n");
2406 /* Look at the TERM variable */
2407 terminal_type
= (char *) getenv ("TERM");
2411 fprintf (stderr
, "Please specify your terminal type.\n\
2412 For types defined in VMS, use set term /device=TYPE.\n\
2413 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
2414 \(The quotation marks are necessary since terminal types are lower case.)\n");
2416 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
2422 /* VMS DCL tends to upcase things, so downcase term type.
2423 Hardly any uppercase letters in terminal types; should be none. */
2425 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
2428 strcpy (new, terminal_type
);
2430 for (p
= new; *p
; p
++)
2434 terminal_type
= new;
2438 term_init (terminal_type
);
2440 remake_frame_glyphs (selected_frame
);
2441 calculate_costs (selected_frame
);
2443 /* X and Y coordinates of the cursor between updates. */
2444 FRAME_CURSOR_X (selected_frame
) = 0;
2445 FRAME_CURSOR_Y (selected_frame
) = 0;
2450 #endif /* CANNOT_DUMP */
2451 signal (SIGWINCH
, window_change_signal
);
2452 #endif /* SIGWINCH */
2458 defsubr (&Sredraw_frame
);
2460 defsubr (&Sredraw_display
);
2461 defsubr (&Sframe_or_buffer_changed_p
);
2462 defsubr (&Sopen_termscript
);
2464 defsubr (&Ssit_for
);
2465 defsubr (&Ssleep_for
);
2466 defsubr (&Ssend_string_to_terminal
);
2468 frame_and_buffer_state
= Fmake_vector (make_number (1), Qlambda
);
2469 staticpro (&frame_and_buffer_state
);
2471 DEFVAR_INT ("baud-rate", &baud_rate
,
2472 "*The output baud rate of the terminal.\n\
2473 On most systems, changing this value will affect the amount of padding\n\
2474 and the other strategic decisions made during redisplay.");
2475 DEFVAR_BOOL ("inverse-video", &inverse_video
,
2476 "*Non-nil means invert the entire frame display.\n\
2477 This means everything is in inverse video which otherwise would not be.");
2478 DEFVAR_BOOL ("visible-bell", &visible_bell
,
2479 "*Non-nil means try to flash the frame to represent a bell.");
2480 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
2481 "*Non-nil means no need to redraw entire frame after suspending.\n\
2482 A non-nil value is useful if the terminal can automatically preserve\n\
2483 Emacs's frame display when you reenter Emacs.\n\
2484 It is up to you to set this variable if your terminal can do that.");
2485 DEFVAR_LISP ("window-system", &Vwindow_system
,
2486 "A symbol naming the window-system under which Emacs is running\n\
2487 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
2488 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
2489 "The version number of the window system in use.\n\
2490 For X windows, this is 10 or 11.");
2491 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
2492 "Non-nil means put cursor in minibuffer, at end of any message there.");
2493 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
2494 "Table defining how to output a glyph code to the frame.\n\
2495 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
2496 Each element can be:\n\
2497 integer: a glyph code which this glyph is an alias for.\n\
2498 string: output this glyph using that string (not impl. in X windows).\n\
2499 nil: this glyph mod 256 is char code to output,\n\
2500 and this glyph / 256 is face code for X windows (see `face-id').");
2501 Vglyph_table
= Qnil
;
2503 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
2504 "Display table to use for buffers that specify none.\n\
2505 See `buffer-display-table' for more information.");
2506 Vstandard_display_table
= Qnil
;
2508 /* Initialize `window-system', unless init_display already decided it. */
2513 Vwindow_system
= Qnil
;
2514 Vwindow_system_version
= Qnil
;