1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95 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 static void change_frame_size_1 ();
77 /* Nonzero upon entry to redisplay means do not assume anything about
78 current contents of actual terminal frame; clear and redraw it. */
82 /* Nonzero means last display completed. Zero means it was preempted. */
84 int display_completed
;
86 /* Lisp variable visible-bell; enables use of screen-flash
87 instead of audible bell. */
91 /* Invert the color of the whole frame, at a low level. */
95 /* Line speed of the terminal. */
99 /* nil or a symbol naming the window system under which emacs is
100 running ('x is the only current possibility). */
102 Lisp_Object Vwindow_system
;
104 /* Version number of X windows: 10, 11 or nil. */
105 Lisp_Object Vwindow_system_version
;
107 /* Vector of glyph definitions. Indexed by glyph number,
108 the contents are a string which is how to output the glyph.
110 If Vglyph_table is nil, a glyph is output by using its low 8 bits
111 as a character code. */
113 Lisp_Object Vglyph_table
;
115 /* Display table to use for vectors that don't specify their own. */
117 Lisp_Object Vstandard_display_table
;
119 /* Nonzero means reading single-character input with prompt
120 so put cursor on minibuffer after the prompt.
121 positive means at end of text in echo area;
122 negative means at beginning of line. */
123 int cursor_in_echo_area
;
125 /* The currently selected frame.
126 In a single-frame version, this variable always holds the address of
129 FRAME_PTR selected_frame
;
131 /* A frame which is not just a minibuffer, or 0 if there are no such
132 frames. This is usually the most recent such frame that was
133 selected. In a single-frame version, this variable always holds
134 the address of the_only_frame. */
135 FRAME_PTR last_nonminibuf_frame
;
137 /* In a single-frame version, the information that would otherwise
138 exist inside frame objects lives in the following structure instead.
140 NOTE: the_only_frame is not checked for garbage collection; don't
141 store collectible objects in any of its fields!
143 You're not/The only frame in town/... */
146 struct frame the_only_frame
;
149 /* This is a vector, made larger whenever it isn't large enough,
150 which is used inside `update_frame' to hold the old contents
151 of the FRAME_PHYS_LINES of the frame being updated. */
152 struct frame_glyphs
**ophys_lines
;
153 /* Length of vector currently allocated. */
154 int ophys_lines_length
;
156 FILE *termscript
; /* Stdio stream being used for copy of all output. */
158 struct cm Wcm
; /* Structure for info on cursor positioning */
160 extern short ospeed
; /* Output speed (from sg_ospeed) */
162 int delayed_size_change
; /* 1 means SIGWINCH happened when not safe. */
166 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
167 "Clear frame FRAME and output again what is supposed to appear on it.")
173 CHECK_LIVE_FRAME (frame
, 0);
176 /* set_terminal_modes (); */
178 clear_frame_records (f
);
181 windows_or_buffers_changed
++;
182 /* Mark all windows as INaccurate,
183 so that every window will have its redisplay done. */
184 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
193 XSETFRAME (frame
, f
);
194 Fredraw_frame (frame
);
199 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
200 /* Don't confuse make-docfile by having two doc strings for this function.
201 make-docfile does not pay attention to #if, for good reason! */
207 set_terminal_modes ();
211 clear_frame_records (0);
212 windows_or_buffers_changed
++;
213 /* Mark all windows as INaccurate,
214 so that every window will have its redisplay done. */
215 mark_window_display_accurate (FRAME_ROOT_WINDOW (0), 0);
221 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
222 "Clear and redisplay all visible frames.")
225 Lisp_Object tail
, frame
;
227 FOR_EACH_FRAME (tail
, frame
)
228 if (FRAME_VISIBLE_P (XFRAME (frame
)))
229 Fredraw_frame (frame
);
234 /* This is used when frame_garbaged is set.
235 Redraw the individual frames marked as garbaged. */
238 redraw_garbaged_frames ()
240 Lisp_Object tail
, frame
;
242 FOR_EACH_FRAME (tail
, frame
)
243 if (FRAME_VISIBLE_P (XFRAME (frame
))
244 && FRAME_GARBAGED_P (XFRAME (frame
)))
245 Fredraw_frame (frame
);
249 static struct frame_glyphs
*
250 make_frame_glyphs (frame
, empty
)
251 register FRAME_PTR frame
;
255 register width
= FRAME_WIDTH (frame
);
256 register height
= FRAME_HEIGHT (frame
);
257 register struct frame_glyphs
*new
258 = (struct frame_glyphs
*) xmalloc (sizeof (struct frame_glyphs
));
260 SET_GLYPHS_FRAME (new, frame
);
261 new->height
= height
;
263 new->used
= (int *) xmalloc (height
* sizeof (int));
264 new->glyphs
= (GLYPH
**) xmalloc (height
* sizeof (GLYPH
*));
265 new->charstarts
= (int **) xmalloc (height
* sizeof (int *));
266 new->highlight
= (char *) xmalloc (height
* sizeof (char));
267 new->enable
= (char *) xmalloc (height
* sizeof (char));
268 bzero (new->enable
, height
* sizeof (char));
269 new->bufp
= (int *) xmalloc (height
* sizeof (int));
271 #ifdef HAVE_X_WINDOWS
272 if (FRAME_X_P (frame
))
274 new->top_left_x
= (short *) xmalloc (height
* sizeof (short));
275 new->top_left_y
= (short *) xmalloc (height
* sizeof (short));
276 new->pix_width
= (short *) xmalloc (height
* sizeof (short));
277 new->pix_height
= (short *) xmalloc (height
* sizeof (short));
278 new->max_ascent
= (short *) xmalloc (height
* sizeof (short));
284 /* Make the buffer used by decode_mode_spec. This buffer is also
285 used as temporary storage when updating the frame. See scroll.c. */
286 unsigned int total_glyphs
= (width
+ 2) * sizeof (GLYPH
);
287 unsigned int total_charstarts
= (width
+ 2) * sizeof (int);
289 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
290 bzero (new->total_contents
, total_glyphs
);
292 new->total_charstarts
= (int *) xmalloc (total_charstarts
);
293 bzero (new->total_charstarts
, total_glyphs
);
297 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (GLYPH
);
299 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
300 bzero (new->total_contents
, total_glyphs
);
301 for (i
= 0; i
< height
; i
++)
302 new->glyphs
[i
] = new->total_contents
+ i
* (width
+ 2) + 1;
304 if (!FRAME_TERMCAP_P (frame
))
306 unsigned int total_charstarts
= height
* (width
+ 2) * sizeof (int);
308 new->total_charstarts
= (int *) xmalloc (total_charstarts
);
309 bzero (new->total_charstarts
, total_charstarts
);
310 for (i
= 0; i
< height
; i
++)
311 new->charstarts
[i
] = new->total_charstarts
+ i
* (width
+ 2) + 1;
315 /* Without a window system, we don't really need charstarts.
316 So use a small amount of space to make enough data structure
317 to prevent crashes in display_text_line. */
318 new->total_charstarts
= (int *) xmalloc ((width
+ 2) * sizeof (int));
319 for (i
= 0; i
< height
; i
++)
320 new->charstarts
[i
] = new->total_charstarts
;
328 free_frame_glyphs (frame
, glyphs
)
330 struct frame_glyphs
*glyphs
;
332 if (glyphs
->total_contents
)
333 xfree (glyphs
->total_contents
);
334 if (glyphs
->total_charstarts
)
335 xfree (glyphs
->total_charstarts
);
337 xfree (glyphs
->used
);
338 xfree (glyphs
->glyphs
);
339 xfree (glyphs
->highlight
);
340 xfree (glyphs
->enable
);
341 xfree (glyphs
->bufp
);
342 if (glyphs
->charstarts
)
343 xfree (glyphs
->charstarts
);
345 #ifdef HAVE_X_WINDOWS
346 if (FRAME_X_P (frame
))
348 xfree (glyphs
->top_left_x
);
349 xfree (glyphs
->top_left_y
);
350 xfree (glyphs
->pix_width
);
351 xfree (glyphs
->pix_height
);
352 xfree (glyphs
->max_ascent
);
360 remake_frame_glyphs (frame
)
363 if (FRAME_CURRENT_GLYPHS (frame
))
364 free_frame_glyphs (frame
, FRAME_CURRENT_GLYPHS (frame
));
365 if (FRAME_DESIRED_GLYPHS (frame
))
366 free_frame_glyphs (frame
, FRAME_DESIRED_GLYPHS (frame
));
367 if (FRAME_TEMP_GLYPHS (frame
))
368 free_frame_glyphs (frame
, FRAME_TEMP_GLYPHS (frame
));
370 if (FRAME_MESSAGE_BUF (frame
))
372 /* Reallocate the frame's message buffer; remember that
373 echo_area_glyphs may be pointing here. */
374 char *old_message_buf
= FRAME_MESSAGE_BUF (frame
);
376 FRAME_MESSAGE_BUF (frame
)
377 = (char *) xrealloc (FRAME_MESSAGE_BUF (frame
),
378 FRAME_WIDTH (frame
) + 1);
380 if (echo_area_glyphs
== old_message_buf
)
381 echo_area_glyphs
= FRAME_MESSAGE_BUF (frame
);
382 if (previous_echo_glyphs
== old_message_buf
)
383 previous_echo_glyphs
= FRAME_MESSAGE_BUF (frame
);
386 FRAME_MESSAGE_BUF (frame
)
387 = (char *) xmalloc (FRAME_WIDTH (frame
) + 1);
389 FRAME_CURRENT_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
390 FRAME_DESIRED_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
391 FRAME_TEMP_GLYPHS (frame
) = make_frame_glyphs (frame
, 1);
392 if (! FRAME_TERMCAP_P (frame
) || frame
== selected_frame
)
393 SET_FRAME_GARBAGED (frame
);
396 /* Return the hash code of contents of line VPOS in frame-matrix M. */
399 line_hash_code (m
, vpos
)
400 register struct frame_glyphs
*m
;
403 register GLYPH
*body
, *end
;
406 if (!m
->enable
[vpos
])
409 /* Give all highlighted lines the same hash code
410 so as to encourage scrolling to leave them in place. */
411 if (m
->highlight
[vpos
])
414 body
= m
->glyphs
[vpos
];
416 if (must_write_spaces
)
423 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
- SPACEGLYPH
;
432 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
;
440 /* Return number of characters in line in M at vpos VPOS,
441 except don't count leading and trailing spaces
442 unless the terminal requires those to be explicitly output. */
445 line_draw_cost (m
, vpos
)
446 struct frame_glyphs
*m
;
449 register GLYPH
*beg
= m
->glyphs
[vpos
];
450 register GLYPH
*end
= m
->glyphs
[vpos
] + m
->used
[vpos
];
452 register int tlen
= GLYPH_TABLE_LENGTH
;
453 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
455 /* Ignore trailing and leading spaces if we can. */
456 if (!must_write_spaces
)
458 while ((end
!= beg
) && (*end
== SPACEGLYPH
))
461 return (0); /* All blank line. */
463 while (*beg
== SPACEGLYPH
)
467 /* If we don't have a glyph-table, each glyph is one character,
468 so return the number of glyphs. */
472 /* Otherwise, scan the glyphs and accumulate their total size in I. */
474 while ((beg
<= end
) && *beg
)
476 register GLYPH g
= *beg
++;
478 if (GLYPH_SIMPLE_P (tbase
, tlen
, g
))
481 i
+= GLYPH_LENGTH (tbase
, g
);
486 /* The functions on this page are the interface from xdisp.c to redisplay.
488 The only other interface into redisplay is through setting
489 FRAME_CURSOR_X (frame) and FRAME_CURSOR_Y (frame)
490 and SET_FRAME_GARBAGED (frame). */
492 /* cancel_line eliminates any request to display a line at position `vpos' */
494 cancel_line (vpos
, frame
)
496 register FRAME_PTR frame
;
498 FRAME_DESIRED_GLYPHS (frame
)->enable
[vpos
] = 0;
501 clear_frame_records (frame
)
502 register FRAME_PTR frame
;
504 bzero (FRAME_CURRENT_GLYPHS (frame
)->enable
, FRAME_HEIGHT (frame
));
507 /* Clear out all display lines for a coming redisplay. */
510 init_desired_glyphs (frame
)
511 register FRAME_PTR frame
;
513 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (frame
);
515 int height
= FRAME_HEIGHT (frame
);
517 for (vpos
= 0; vpos
< height
; vpos
++)
518 desired_glyphs
->enable
[vpos
] = 0;
521 /* Prepare to display on line VPOS starting at HPOS within it. */
524 get_display_line (frame
, vpos
, hpos
)
525 register FRAME_PTR frame
;
529 register struct frame_glyphs
*glyphs
;
530 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (frame
);
536 if ((desired_glyphs
->enable
[vpos
]) && desired_glyphs
->used
[vpos
] > hpos
)
539 if (! desired_glyphs
->enable
[vpos
])
541 desired_glyphs
->used
[vpos
] = 0;
542 desired_glyphs
->highlight
[vpos
] = 0;
543 desired_glyphs
->enable
[vpos
] = 1;
546 if (hpos
> desired_glyphs
->used
[vpos
])
548 GLYPH
*g
= desired_glyphs
->glyphs
[vpos
] + desired_glyphs
->used
[vpos
];
549 GLYPH
*end
= desired_glyphs
->glyphs
[vpos
] + hpos
;
551 desired_glyphs
->used
[vpos
] = hpos
;
557 /* Like bcopy except never gets confused by overlap. */
560 safe_bcopy (from
, to
, size
)
564 if (size
<= 0 || from
== to
)
567 /* If the source and destination don't overlap, then bcopy can
568 handle it. If they do overlap, but the destination is lower in
569 memory than the source, we'll assume bcopy can handle that. */
570 if (to
< from
|| from
+ size
<= to
)
571 bcopy (from
, to
, size
);
573 /* Otherwise, we'll copy from the end. */
576 register char *endf
= from
+ size
;
577 register char *endt
= to
+ size
;
579 /* If TO - FROM is large, then we should break the copy into
580 nonoverlapping chunks of TO - FROM bytes each. However, if
581 TO - FROM is small, then the bcopy function call overhead
582 makes this not worth it. The crossover point could be about
583 anywhere. Since I don't think the obvious copy loop is too
584 bad, I'm trying to err in its favor. */
589 while (endf
!= from
);
601 bcopy (endf
, endt
, to
- from
);
604 /* If SIZE wasn't a multiple of TO - FROM, there will be a
605 little left over. The amount left over is
606 (endt + (to - from)) - to, which is endt - from. */
607 bcopy (from
, to
, endt
- from
);
612 /* Rotate a vector of SIZE bytes right, by DISTANCE bytes.
613 DISTANCE may be negative. */
616 rotate_vector (vector
, size
, distance
)
621 char *temp
= (char *) alloca (size
);
626 bcopy (vector
, temp
+ distance
, size
- distance
);
627 bcopy (vector
+ size
- distance
, temp
, distance
);
628 bcopy (temp
, vector
, size
);
631 /* Scroll lines from vpos FROM up to but not including vpos END
632 down by AMOUNT lines (AMOUNT may be negative).
633 Returns nonzero if done, zero if terminal cannot scroll them. */
636 scroll_frame_lines (frame
, from
, end
, amount
, newpos
)
637 register FRAME_PTR frame
;
638 int from
, end
, amount
, newpos
;
641 register struct frame_glyphs
*current_frame
642 = FRAME_CURRENT_GLYPHS (frame
);
644 int width
= FRAME_WIDTH (frame
);
646 if (!line_ins_del_ok
)
654 update_begin (frame
);
655 set_terminal_window (end
+ amount
);
656 if (!scroll_region_ok
)
657 ins_del_lines (end
, -amount
);
658 ins_del_lines (from
, amount
);
659 set_terminal_window (0);
661 rotate_vector (current_frame
->glyphs
+ from
,
662 sizeof (GLYPH
*) * (end
+ amount
- from
),
663 amount
* sizeof (GLYPH
*));
665 rotate_vector (current_frame
->charstarts
+ from
,
666 sizeof (int *) * (end
+ amount
- from
),
667 amount
* sizeof (int *));
669 safe_bcopy (current_frame
->used
+ from
,
670 current_frame
->used
+ from
+ amount
,
671 (end
- from
) * sizeof current_frame
->used
[0]);
673 safe_bcopy (current_frame
->highlight
+ from
,
674 current_frame
->highlight
+ from
+ amount
,
675 (end
- from
) * sizeof current_frame
->highlight
[0]);
677 safe_bcopy (current_frame
->enable
+ from
,
678 current_frame
->enable
+ from
+ amount
,
679 (end
- from
) * sizeof current_frame
->enable
[0]);
681 /* Adjust the lines by an amount
682 that puts the first of them at NEWPOS. */
683 pos_adjust
= newpos
- current_frame
->charstarts
[from
+ amount
][0];
685 /* Offset each char position in the charstarts lines we moved
687 for (i
= from
+ amount
; i
< end
+ amount
; i
++)
689 int *line
= current_frame
->charstarts
[i
];
691 for (col
= 0; col
< width
; col
++)
693 line
[col
] += pos_adjust
;
695 for (i
= from
; i
< from
+ amount
; i
++)
697 int *line
= current_frame
->charstarts
[i
];
700 for (col
= 0; col
< width
; col
++)
704 /* Mark the lines made empty by scrolling as enabled, empty and
706 bzero (current_frame
->used
+ from
,
707 amount
* sizeof current_frame
->used
[0]);
708 bzero (current_frame
->highlight
+ from
,
709 amount
* sizeof current_frame
->highlight
[0]);
710 for (i
= from
; i
< from
+ amount
; i
++)
712 current_frame
->glyphs
[i
][0] = '\0';
713 current_frame
->charstarts
[i
][0] = -1;
714 current_frame
->enable
[i
] = 1;
717 safe_bcopy (current_frame
->bufp
+ from
,
718 current_frame
->bufp
+ from
+ amount
,
719 (end
- from
) * sizeof current_frame
->bufp
[0]);
721 #ifdef HAVE_X_WINDOWS
722 if (FRAME_X_P (frame
))
724 safe_bcopy (current_frame
->top_left_x
+ from
,
725 current_frame
->top_left_x
+ from
+ amount
,
726 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
728 safe_bcopy (current_frame
->top_left_y
+ from
,
729 current_frame
->top_left_y
+ from
+ amount
,
730 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
732 safe_bcopy (current_frame
->pix_width
+ from
,
733 current_frame
->pix_width
+ from
+ amount
,
734 (end
- from
) * sizeof current_frame
->pix_width
[0]);
736 safe_bcopy (current_frame
->pix_height
+ from
,
737 current_frame
->pix_height
+ from
+ amount
,
738 (end
- from
) * sizeof current_frame
->pix_height
[0]);
740 safe_bcopy (current_frame
->max_ascent
+ from
,
741 current_frame
->max_ascent
+ from
+ amount
,
742 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
744 #endif /* HAVE_X_WINDOWS */
750 update_begin (frame
);
751 set_terminal_window (end
);
752 ins_del_lines (from
+ amount
, amount
);
753 if (!scroll_region_ok
)
754 ins_del_lines (end
+ amount
, -amount
);
755 set_terminal_window (0);
757 rotate_vector (current_frame
->glyphs
+ from
+ amount
,
758 sizeof (GLYPH
*) * (end
- from
- amount
),
759 amount
* sizeof (GLYPH
*));
761 rotate_vector (current_frame
->charstarts
+ from
+ amount
,
762 sizeof (int *) * (end
- from
- amount
),
763 amount
* sizeof (int *));
765 safe_bcopy (current_frame
->used
+ from
,
766 current_frame
->used
+ from
+ amount
,
767 (end
- from
) * sizeof current_frame
->used
[0]);
769 safe_bcopy (current_frame
->highlight
+ from
,
770 current_frame
->highlight
+ from
+ amount
,
771 (end
- from
) * sizeof current_frame
->highlight
[0]);
773 safe_bcopy (current_frame
->enable
+ from
,
774 current_frame
->enable
+ from
+ amount
,
775 (end
- from
) * sizeof current_frame
->enable
[0]);
777 /* Adjust the lines by an amount
778 that puts the first of them at NEWPOS. */
779 pos_adjust
= newpos
- current_frame
->charstarts
[from
+ amount
][0];
781 /* Offset each char position in the charstarts lines we moved
783 for (i
= from
+ amount
; i
< end
+ amount
; i
++)
785 int *line
= current_frame
->charstarts
[i
];
787 for (col
= 0; col
< width
; col
++)
789 line
[col
] += pos_adjust
;
791 for (i
= end
+ amount
; i
< end
; i
++)
793 int *line
= current_frame
->charstarts
[i
];
796 for (col
= 0; col
< width
; col
++)
800 /* Mark the lines made empty by scrolling as enabled, empty and
802 bzero (current_frame
->used
+ end
+ amount
,
803 - amount
* sizeof current_frame
->used
[0]);
804 bzero (current_frame
->highlight
+ end
+ amount
,
805 - amount
* sizeof current_frame
->highlight
[0]);
806 for (i
= end
+ amount
; i
< end
; i
++)
808 current_frame
->glyphs
[i
][0] = '\0';
809 current_frame
->charstarts
[i
][0] = 0;
810 current_frame
->enable
[i
] = 1;
813 safe_bcopy (current_frame
->bufp
+ from
,
814 current_frame
->bufp
+ from
+ amount
,
815 (end
- from
) * sizeof current_frame
->bufp
[0]);
817 #ifdef HAVE_X_WINDOWS
818 if (FRAME_X_P (frame
))
820 safe_bcopy (current_frame
->top_left_x
+ from
,
821 current_frame
->top_left_x
+ from
+ amount
,
822 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
824 safe_bcopy (current_frame
->top_left_y
+ from
,
825 current_frame
->top_left_y
+ from
+ amount
,
826 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
828 safe_bcopy (current_frame
->pix_width
+ from
,
829 current_frame
->pix_width
+ from
+ amount
,
830 (end
- from
) * sizeof current_frame
->pix_width
[0]);
832 safe_bcopy (current_frame
->pix_height
+ from
,
833 current_frame
->pix_height
+ from
+ amount
,
834 (end
- from
) * sizeof current_frame
->pix_height
[0]);
836 safe_bcopy (current_frame
->max_ascent
+ from
,
837 current_frame
->max_ascent
+ from
+ amount
,
838 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
840 #endif /* HAVE_X_WINDOWS */
847 /* After updating a window W that isn't the full frame wide,
848 copy all the columns that W does not occupy
849 into the FRAME_DESIRED_GLYPHS (frame) from the FRAME_PHYS_GLYPHS (frame)
850 so that update_frame will not change those columns. */
852 preserve_other_columns (w
)
856 register struct frame_glyphs
*current_frame
, *desired_frame
;
857 register FRAME_PTR frame
= XFRAME (w
->frame
);
858 int start
= XFASTINT (w
->left
);
859 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
860 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
862 current_frame
= FRAME_CURRENT_GLYPHS (frame
);
863 desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
865 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
867 if (current_frame
->enable
[vpos
] && desired_frame
->enable
[vpos
])
873 bcopy (current_frame
->glyphs
[vpos
],
874 desired_frame
->glyphs
[vpos
],
875 start
* sizeof (current_frame
->glyphs
[vpos
][0]));
876 bcopy (current_frame
->charstarts
[vpos
],
877 desired_frame
->charstarts
[vpos
],
878 start
* sizeof (current_frame
->charstarts
[vpos
][0]));
879 len
= min (start
, current_frame
->used
[vpos
]);
880 if (desired_frame
->used
[vpos
] < len
)
881 desired_frame
->used
[vpos
] = len
;
883 if (current_frame
->used
[vpos
] > end
884 && desired_frame
->used
[vpos
] < current_frame
->used
[vpos
])
886 while (desired_frame
->used
[vpos
] < end
)
888 int used
= desired_frame
->used
[vpos
]++;
889 desired_frame
->glyphs
[vpos
][used
] = SPACEGLYPH
;
890 desired_frame
->glyphs
[vpos
][used
] = 0;
892 bcopy (current_frame
->glyphs
[vpos
] + end
,
893 desired_frame
->glyphs
[vpos
] + end
,
894 ((current_frame
->used
[vpos
] - end
)
895 * sizeof (current_frame
->glyphs
[vpos
][0])));
896 bcopy (current_frame
->charstarts
[vpos
] + end
,
897 desired_frame
->charstarts
[vpos
] + end
,
898 ((current_frame
->used
[vpos
] - end
)
899 * sizeof (current_frame
->charstarts
[vpos
][0])));
900 desired_frame
->used
[vpos
] = current_frame
->used
[vpos
];
908 /* If window w does not need to be updated and isn't the full frame wide,
909 copy all the columns that w does occupy
910 into the FRAME_DESIRED_LINES (frame) from the FRAME_PHYS_LINES (frame)
911 so that update_frame will not change those columns.
913 Have not been able to figure out how to use this correctly. */
915 preserve_my_columns (w
)
918 register int vpos
, fin
;
919 register struct frame_glyphs
*l1
, *l2
;
920 register FRAME_PTR frame
= XFRAME (w
->frame
);
921 int start
= XFASTINT (w
->left
);
922 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
923 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
925 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
927 if ((l1
= FRAME_DESIRED_GLYPHS (frame
)->glyphs
[vpos
+ 1])
928 && (l2
= FRAME_PHYS_GLYPHS (frame
)->glyphs
[vpos
+ 1]))
930 if (l2
->length
> start
&& l1
->length
< l2
->length
)
933 if (fin
> end
) fin
= end
;
934 while (l1
->length
< start
)
935 l1
->body
[l1
->length
++] = ' ';
936 bcopy (l2
->body
+ start
, l1
->body
+ start
, fin
- start
);
945 /* Adjust by ADJUST the charstart values in window W
946 after vpos VPOS, which counts relative to the frame
947 (not relative to W itself). */
950 adjust_window_charstarts (w
, vpos
, adjust
)
955 int left
= XFASTINT (w
->left
);
956 int top
= XFASTINT (w
->top
);
957 int right
= left
+ window_internal_width (w
);
958 int bottom
= top
+ window_internal_height (w
);
961 for (i
= vpos
+ 1; i
< bottom
; i
++)
964 = FRAME_CURRENT_GLYPHS (XFRAME (WINDOW_FRAME (w
)))->charstarts
[i
];
966 for (j
= left
; j
< right
; j
++)
967 if (charstart
[j
] > 0)
968 charstart
[j
] += adjust
;
972 /* Check the charstarts values in the area of window W
973 for internal consistency. We cannot check that they are "right";
974 we can only look for something nonsensical. */
976 verify_charstarts (w
)
979 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
981 int top
= XFASTINT (w
->top
);
982 int bottom
= top
+ window_internal_height (w
);
983 int left
= XFASTINT (w
->left
);
984 int right
= left
+ window_internal_width (w
);
986 int truncate
= (XINT (w
->hscroll
)
987 || (truncate_partial_width_windows
988 && (XFASTINT (w
->width
) < FRAME_WIDTH (f
)))
989 || !NILP (XBUFFER (w
->buffer
)->truncate_lines
));
991 for (i
= top
; i
< bottom
; i
++)
995 int *charstart
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[i
];
1001 /* If we are truncating lines, allow a jump
1002 in charstarts from one line to the next. */
1003 if (charstart
[left
] < next_line
)
1008 if (charstart
[left
] != next_line
)
1013 for (j
= left
; j
< right
; j
++)
1014 if (charstart
[j
] > 0)
1015 last
= charstart
[j
];
1016 /* Record where the next line should start. */
1018 if (BUF_ZV (XBUFFER (w
->buffer
)) != last
)
1020 /* If there's a newline between the two lines, count that. */
1021 int endchar
= *BUF_CHAR_ADDRESS (XBUFFER (w
->buffer
), last
);
1022 if (endchar
== '\n')
1028 /* On discovering that the redisplay for a window was no good,
1029 cancel the columns of that window, so that when the window is
1030 displayed over again get_display_line will not complain. */
1032 cancel_my_columns (w
)
1036 register struct frame_glyphs
*desired_glyphs
1037 = FRAME_DESIRED_GLYPHS (XFRAME (w
->frame
));
1038 register int start
= XFASTINT (w
->left
);
1039 register int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
1041 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
1042 if (desired_glyphs
->enable
[vpos
]
1043 && desired_glyphs
->used
[vpos
] >= start
)
1044 desired_glyphs
->used
[vpos
] = start
;
1047 /* These functions try to perform directly and immediately on the frame
1048 the necessary output for one change in the buffer.
1049 They may return 0 meaning nothing was done if anything is difficult,
1050 or 1 meaning the output was performed properly.
1051 They assume that the frame was up to date before the buffer
1052 change being displayed. They make various other assumptions too;
1053 see command_loop_1 where these are called. */
1056 direct_output_for_insert (g
)
1059 register FRAME_PTR frame
= selected_frame
;
1060 register struct frame_glyphs
*current_frame
1061 = FRAME_CURRENT_GLYPHS (frame
);
1063 #ifndef COMPILER_REGISTER_BUG
1065 #endif /* COMPILER_REGISTER_BUG */
1066 struct window
*w
= XWINDOW (selected_window
);
1067 #ifndef COMPILER_REGISTER_BUG
1069 #endif /* COMPILER_REGISTER_BUG */
1070 int hpos
= FRAME_CURSOR_X (frame
);
1071 #ifndef COMPILER_REGISTER_BUG
1073 #endif /* COMPILER_REGISTER_BUG */
1074 int vpos
= FRAME_CURSOR_Y (frame
);
1076 /* Give up if about to continue line. */
1077 if (hpos
>= XFASTINT (w
->left
) + window_internal_width (w
) - 1
1079 /* Avoid losing if cursor is in invisible text off left margin */
1080 || (XINT (w
->hscroll
) && hpos
== XFASTINT (w
->left
))
1082 /* Give up if cursor outside window (in minibuf, probably) */
1083 || cursor_in_echo_area
1084 || FRAME_CURSOR_Y (frame
) < XFASTINT (w
->top
)
1085 || FRAME_CURSOR_Y (frame
) >= XFASTINT (w
->top
) + XFASTINT (w
->height
)
1087 /* Give up if cursor not really at FRAME_CURSOR_X, FRAME_CURSOR_Y */
1088 || !display_completed
1090 /* Give up if buffer appears in two places. */
1091 || buffer_shared
> 1
1093 #ifdef USE_TEXT_PROPERTIES
1094 /* Intervals have already been adjusted, point is after the
1095 character that was just inserted. */
1096 /* Give up if character is invisible. */
1097 /* Give up if character has a face property.
1098 At the moment we only lose at end of line or end of buffer
1099 and only with faces that have some background */
1100 /* Instead of wasting time, give up if character has any text properties */
1101 || ! NILP (Ftext_properties_at (make_number (point
- 1), Qnil
))
1104 /* Give up if w is minibuffer and a message is being displayed there */
1105 || (MINI_WINDOW_P (w
) && echo_area_glyphs
))
1113 if (FRAME_X_P (frame
))
1114 face
= compute_char_face (frame
, w
, point
- 1, -1, -1, &dummy
, point
, 0);
1116 current_frame
->glyphs
[vpos
][hpos
] = MAKE_GLYPH (frame
, g
, face
);
1117 current_frame
->charstarts
[vpos
][hpos
] = point
- 1;
1118 /* Record the entry for after the newly inserted character. */
1119 current_frame
->charstarts
[vpos
][hpos
+ 1] = point
;
1120 adjust_window_charstarts (w
, vpos
, 1);
1122 unchanged_modified
= MODIFF
;
1123 beg_unchanged
= GPT
- BEG
;
1124 XSETFASTINT (w
->last_point
, point
);
1125 XSETFASTINT (w
->last_point_x
, hpos
);
1126 XSETFASTINT (w
->last_modified
, MODIFF
);
1128 reassert_line_highlight (0, vpos
);
1129 write_glyphs (¤t_frame
->glyphs
[vpos
][hpos
], 1);
1131 ++FRAME_CURSOR_X (frame
);
1132 if (hpos
== current_frame
->used
[vpos
])
1134 current_frame
->used
[vpos
] = hpos
+ 1;
1135 current_frame
->glyphs
[vpos
][hpos
+ 1] = 0;
1142 direct_output_forward_char (n
)
1145 register FRAME_PTR frame
= selected_frame
;
1146 register struct window
*w
= XWINDOW (selected_window
);
1147 Lisp_Object position
;
1148 int hpos
= FRAME_CURSOR_X (frame
);
1150 /* Give up if in truncated text at end of line. */
1151 if (hpos
>= XFASTINT (w
->left
) + window_internal_width (w
) - 1)
1154 /* Avoid losing if cursor is in invisible text off left margin
1155 or about to go off either side of window. */
1156 if ((FRAME_CURSOR_X (frame
) == XFASTINT (w
->left
)
1157 && (XINT (w
->hscroll
) || n
< 0))
1159 && (FRAME_CURSOR_X (frame
) + 1 >= window_internal_width (w
) - 1))
1160 || cursor_in_echo_area
)
1163 /* Can't use direct output if highlighting a region. */
1164 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
1167 /* Can't use direct output at an overlay boundary; it might have
1168 before-string or after-string properties. */
1169 if (overlay_touches_p (PT
) || overlay_touches_p (PT
- n
))
1172 #ifdef USE_TEXT_PROPERTIES
1173 /* Don't use direct output next to an invisible character
1174 since we might need to do something special. */
1176 XSETFASTINT (position
, point
);
1177 if (XFASTINT (position
) < ZV
1178 && ! NILP (Fget_char_property (position
,
1183 XSETFASTINT (position
, point
- 1);
1184 if (XFASTINT (position
) >= BEGV
1185 && ! NILP (Fget_char_property (position
,
1191 FRAME_CURSOR_X (frame
) += n
;
1192 XSETFASTINT (w
->last_point_x
, FRAME_CURSOR_X (frame
));
1193 XSETFASTINT (w
->last_point
, point
);
1194 cursor_to (FRAME_CURSOR_Y (frame
), FRAME_CURSOR_X (frame
));
1200 static void update_line ();
1202 /* Update frame F based on the data in FRAME_DESIRED_GLYPHS.
1203 Value is nonzero if redisplay stopped due to pending input.
1204 FORCE nonzero means do not stop for pending input. */
1207 update_frame (f
, force
, inhibit_hairy_id
)
1210 int inhibit_hairy_id
;
1212 register struct frame_glyphs
*current_frame
;
1213 register struct frame_glyphs
*desired_frame
= 0;
1216 int preempt_count
= baud_rate
/ 2400 + 1;
1217 extern input_pending
;
1218 #ifdef HAVE_X_WINDOWS
1219 register int downto
, leftmost
;
1222 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
1223 calculate_costs (f
);
1225 if (preempt_count
<= 0)
1228 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1230 detect_input_pending ();
1231 if (input_pending
&& !force
)
1239 if (!line_ins_del_ok
)
1240 inhibit_hairy_id
= 1;
1242 /* These are separate to avoid a possible bug in the AIX C compiler. */
1243 current_frame
= FRAME_CURRENT_GLYPHS (f
);
1244 desired_frame
= FRAME_DESIRED_GLYPHS (f
);
1246 /* See if any of the desired lines are enabled; don't compute for
1247 i/d line if just want cursor motion. */
1248 for (i
= 0; i
< FRAME_HEIGHT (f
); i
++)
1249 if (desired_frame
->enable
[i
])
1252 /* Try doing i/d line, if not yet inhibited. */
1253 if (!inhibit_hairy_id
&& i
< FRAME_HEIGHT (f
))
1254 force
|= scrolling (f
);
1256 /* Update the individual lines as needed. Do bottom line first. */
1258 if (desired_frame
->enable
[FRAME_HEIGHT (f
) - 1])
1259 update_line (f
, FRAME_HEIGHT (f
) - 1);
1261 #ifdef HAVE_X_WINDOWS
1264 leftmost
= downto
= f
->display
.x
->internal_border_width
;
1265 if (desired_frame
->enable
[0])
1267 current_frame
->top_left_x
[FRAME_HEIGHT (f
) - 1] = leftmost
;
1268 current_frame
->top_left_y
[FRAME_HEIGHT (f
) - 1]
1269 = PIXEL_HEIGHT (f
) - f
->display
.x
->internal_border_width
1270 - current_frame
->pix_height
[FRAME_HEIGHT (f
) - 1];
1271 current_frame
->top_left_x
[0] = leftmost
;
1272 current_frame
->top_left_y
[0] = downto
;
1275 #endif /* HAVE_X_WINDOWS */
1277 /* Now update the rest of the lines. */
1278 for (i
= 0; i
< FRAME_HEIGHT (f
) - 1 && (force
|| !input_pending
); i
++)
1280 if (desired_frame
->enable
[i
])
1282 if (FRAME_TERMCAP_P (f
))
1284 /* Flush out every so many lines.
1285 Also flush out if likely to have more than 1k buffered
1286 otherwise. I'm told that some telnet connections get
1287 really screwed by more than 1k output at once. */
1288 int outq
= PENDING_OUTPUT_COUNT (stdout
);
1290 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
1293 if (preempt_count
== 1)
1295 #ifdef EMACS_OUTQSIZE
1296 if (EMACS_OUTQSIZE (0, &outq
) < 0)
1297 /* Probably not a tty. Ignore the error and reset
1298 * the outq count. */
1299 outq
= PENDING_OUTPUT_COUNT (stdout
);
1302 if (baud_rate
<= outq
&& baud_rate
> 0)
1303 sleep (outq
/ baud_rate
);
1306 if ((i
- 1) % preempt_count
== 0)
1307 detect_input_pending ();
1311 #ifdef HAVE_X_WINDOWS
1314 current_frame
->top_left_y
[i
] = downto
;
1315 current_frame
->top_left_x
[i
] = leftmost
;
1317 #endif /* HAVE_X_WINDOWS */
1320 #ifdef HAVE_X_WINDOWS
1322 downto
+= current_frame
->pix_height
[i
];
1325 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
1327 /* Now just clean up termcap drivers and set cursor, etc. */
1330 if ((cursor_in_echo_area
1331 && FRAME_HAS_MINIBUF_P (f
)
1332 && EQ (FRAME_MINIBUF_WINDOW (f
), minibuf_window
))
1333 /* If we are showing a message instead of the minibuffer,
1334 show the cursor for the message instead of for the
1335 (now hidden) minibuffer contents. */
1336 || (EQ (minibuf_window
, selected_window
)
1337 && echo_area_glyphs
!= 0))
1339 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
1342 if (cursor_in_echo_area
< 0)
1349 /* If the minibuffer is several lines high, find the last
1350 line that has any text on it. */
1351 row
= FRAME_HEIGHT (f
);
1355 if (current_frame
->enable
[row
])
1356 col
= current_frame
->used
[row
];
1360 while (row
> top
&& col
== 0);
1362 if (col
>= FRAME_WIDTH (f
))
1365 if (row
< FRAME_HEIGHT (f
) - 1)
1370 cursor_to (row
, col
);
1373 cursor_to (FRAME_CURSOR_Y (f
), max (min (FRAME_CURSOR_X (f
),
1374 FRAME_WIDTH (f
) - 1), 0));
1380 fflush (termscript
);
1383 /* Here if output is preempted because input is detected. */
1386 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1387 display_completed
= !pause
;
1389 bzero (FRAME_DESIRED_GLYPHS (f
)->enable
, FRAME_HEIGHT (f
));
1393 /* Called when about to quit, to check for doing so
1394 at an improper time. */
1399 if (FRAME_DESIRED_GLYPHS (selected_frame
) == 0)
1401 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[0])
1403 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[FRAME_HEIGHT (selected_frame
) - 1])
1407 /* Decide what insert/delete line to do, and do it */
1409 extern void scrolling_1 ();
1414 int unchanged_at_top
, unchanged_at_bottom
;
1417 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1418 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1419 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1420 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1422 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
1423 register struct frame_glyphs
*current_frame
= FRAME_CURRENT_GLYPHS (frame
);
1424 register struct frame_glyphs
*desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
1426 /* Compute hash codes of all the lines.
1427 Also calculate number of changed lines,
1428 number of unchanged lines at the beginning,
1429 and number of unchanged lines at the end. */
1432 unchanged_at_top
= 0;
1433 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
1434 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
1436 /* Give up on this scrolling if some old lines are not enabled. */
1437 if (!current_frame
->enable
[i
])
1439 old_hash
[i
] = line_hash_code (current_frame
, i
);
1440 if (! desired_frame
->enable
[i
])
1441 new_hash
[i
] = old_hash
[i
];
1443 new_hash
[i
] = line_hash_code (desired_frame
, i
);
1445 if (old_hash
[i
] != new_hash
[i
])
1448 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
1450 else if (i
== unchanged_at_top
)
1452 draw_cost
[i
] = line_draw_cost (desired_frame
, i
);
1453 old_draw_cost
[i
] = line_draw_cost (current_frame
, i
);
1456 /* If changed lines are few, don't allow preemption, don't scroll. */
1457 if (!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400
1458 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
1461 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
1462 - unchanged_at_bottom
);
1464 if (scroll_region_ok
)
1465 free_at_end_vpos
-= unchanged_at_bottom
;
1466 else if (memory_below_frame
)
1467 free_at_end_vpos
= -1;
1469 /* If large window, fast terminal and few lines in common between
1470 current frame and desired frame, don't bother with i/d calc. */
1471 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
1473 10 * scrolling_max_lines_saved (unchanged_at_top
,
1474 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
1475 old_hash
, new_hash
, draw_cost
)))
1478 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
1479 draw_cost
+ unchanged_at_top
- 1,
1480 old_draw_cost
+ unchanged_at_top
- 1,
1481 old_hash
+ unchanged_at_top
- 1,
1482 new_hash
+ unchanged_at_top
- 1,
1483 free_at_end_vpos
- unchanged_at_top
);
1488 /* Return the offset in its buffer of the character at location col, line
1489 in the given window. */
1491 buffer_posn_from_coords (window
, col
, line
)
1492 struct window
*window
;
1495 int hscroll
= XINT (window
->hscroll
);
1496 int window_left
= XFASTINT (window
->left
);
1498 /* The actual width of the window is window->width less one for the
1499 DISP_CONTINUE_GLYPH, and less one if it's not the rightmost
1501 int window_width
= window_internal_width (window
) - 1;
1503 int startp
= marker_position (window
->start
);
1505 /* Since compute_motion will only operate on the current buffer,
1506 we need to save the old one and restore it when we're done. */
1507 struct buffer
*old_current_buffer
= current_buffer
;
1508 struct position
*posn
;
1510 current_buffer
= XBUFFER (window
->buffer
);
1512 /* We can't get a correct result in this case,
1513 but at least prevent compute_motion from crashing. */
1517 /* It would be nice if we could use FRAME_CURRENT_GLYPHS (XFRAME
1518 (window->frame))->bufp to avoid scanning from the very top of
1519 the window, but it isn't maintained correctly, and I'm not even
1520 sure I will keep it. */
1521 posn
= compute_motion (startp
, 0,
1522 ((window
== XWINDOW (minibuf_window
) && startp
== BEG
1523 ? minibuf_prompt_width
: 0)
1524 + (hscroll
? 1 - hscroll
: 0)),
1527 window_width
, hscroll
, 0, window
);
1529 current_buffer
= old_current_buffer
;
1531 /* compute_motion considers frame points past the end of a line
1532 to be *after* the newline, i.e. at the start of the next line.
1533 This is reasonable, but not really what we want. So if the
1534 result is on a line below LINE, back it up one character. */
1535 if (posn
->vpos
> line
)
1536 return posn
->bufpos
- 1;
1538 return posn
->bufpos
;
1545 register GLYPH
*p
= r
;
1546 while (*p
++ == SPACEGLYPH
);
1551 count_match (str1
, str2
)
1554 register GLYPH
*p1
= str1
;
1555 register GLYPH
*p2
= str2
;
1556 while (*p1
++ == *p2
++);
1557 return p1
- str1
- 1;
1560 /* Char insertion/deletion cost vector, from term.c */
1561 extern int *char_ins_del_vector
;
1563 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WIDTH((f))])
1566 update_line (frame
, vpos
)
1567 register FRAME_PTR frame
;
1570 register GLYPH
*obody
, *nbody
, *op1
, *op2
, *np1
, *temp
;
1573 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
1575 register struct frame_glyphs
*current_frame
1576 = FRAME_CURRENT_GLYPHS (frame
);
1577 register struct frame_glyphs
*desired_frame
1578 = FRAME_DESIRED_GLYPHS (frame
);
1580 if (desired_frame
->highlight
[vpos
]
1581 != (current_frame
->enable
[vpos
] && current_frame
->highlight
[vpos
]))
1583 change_line_highlight (desired_frame
->highlight
[vpos
], vpos
,
1584 (current_frame
->enable
[vpos
] ?
1585 current_frame
->used
[vpos
] : 0));
1586 current_frame
->enable
[vpos
] = 0;
1589 reassert_line_highlight (desired_frame
->highlight
[vpos
], vpos
);
1591 if (! current_frame
->enable
[vpos
])
1597 obody
= current_frame
->glyphs
[vpos
];
1598 olen
= current_frame
->used
[vpos
];
1599 if (! current_frame
->highlight
[vpos
])
1601 if (!must_write_spaces
)
1602 while (obody
[olen
- 1] == SPACEGLYPH
&& olen
> 0)
1607 /* For an inverse-video line, remember we gave it
1608 spaces all the way to the frame edge
1609 so that the reverse video extends all the way across. */
1611 while (olen
< FRAME_WIDTH (frame
) - 1)
1612 obody
[olen
++] = SPACEGLYPH
;
1616 /* One way or another, this will enable the line being updated. */
1617 current_frame
->enable
[vpos
] = 1;
1618 current_frame
->used
[vpos
] = desired_frame
->used
[vpos
];
1619 current_frame
->highlight
[vpos
] = desired_frame
->highlight
[vpos
];
1620 current_frame
->bufp
[vpos
] = desired_frame
->bufp
[vpos
];
1622 #ifdef HAVE_X_WINDOWS
1623 if (FRAME_X_P (frame
))
1625 current_frame
->pix_width
[vpos
]
1626 = current_frame
->used
[vpos
]
1627 * FONT_WIDTH (frame
->display
.x
->font
);
1628 current_frame
->pix_height
[vpos
]
1629 = frame
->display
.x
->line_height
;
1631 #endif /* HAVE_X_WINDOWS */
1633 if (!desired_frame
->enable
[vpos
])
1639 nbody
= desired_frame
->glyphs
[vpos
];
1640 nlen
= desired_frame
->used
[vpos
];
1642 /* Pretend trailing spaces are not there at all,
1643 unless for one reason or another we must write all spaces. */
1644 if (! desired_frame
->highlight
[vpos
])
1646 if (!must_write_spaces
)
1647 /* We know that the previous character byte contains 0. */
1648 while (nbody
[nlen
- 1] == SPACEGLYPH
)
1653 /* For an inverse-video line, give it extra trailing spaces
1654 all the way to the frame edge
1655 so that the reverse video extends all the way across. */
1657 while (nlen
< FRAME_WIDTH (frame
) - 1)
1658 nbody
[nlen
++] = SPACEGLYPH
;
1661 /* If there's no i/d char, quickly do the best we can without it. */
1662 if (!char_ins_del_ok
)
1667 if (FRAME_X_P (frame
))
1669 /* Under X, erase everything we are going to rewrite,
1670 and rewrite everything from the first char that's changed.
1671 This is part of supporting fonts like Courier
1672 whose chars can overlap outside the char width. */
1673 for (i
= 0; i
< nlen
; i
++)
1674 if (i
>= olen
|| nbody
[i
] != obody
[i
])
1677 cursor_to (vpos
, i
);
1679 clear_end_of_line (olen
);
1680 write_glyphs (nbody
+ i
, nlen
- i
);
1685 for (i
= 0; i
< nlen
; i
++)
1687 if (i
>= olen
|| nbody
[i
] != obody
[i
]) /* A non-matching char. */
1689 cursor_to (vpos
, i
);
1690 for (j
= 1; (i
+ j
< nlen
&&
1691 (i
+ j
>= olen
|| nbody
[i
+j
] != obody
[i
+j
]));
1694 /* Output this run of non-matching chars. */
1695 write_glyphs (nbody
+ i
, j
);
1698 /* Now find the next non-match. */
1702 /* Clear the rest of the line, or the non-clear part of it. */
1705 cursor_to (vpos
, nlen
);
1706 clear_end_of_line (olen
);
1709 /* Exchange contents between current_frame and new_frame. */
1710 temp
= desired_frame
->glyphs
[vpos
];
1711 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1712 current_frame
->glyphs
[vpos
] = temp
;
1714 /* Exchange charstarts between current_frame and new_frame. */
1715 temp1
= desired_frame
->charstarts
[vpos
];
1716 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1717 current_frame
->charstarts
[vpos
] = temp1
;
1724 nsp
= (must_write_spaces
|| desired_frame
->highlight
[vpos
])
1725 ? 0 : count_blanks (nbody
);
1728 cursor_to (vpos
, nsp
);
1729 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
1732 /* Exchange contents between current_frame and new_frame. */
1733 temp
= desired_frame
->glyphs
[vpos
];
1734 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1735 current_frame
->glyphs
[vpos
] = temp
;
1737 /* Exchange charstarts between current_frame and new_frame. */
1738 temp1
= desired_frame
->charstarts
[vpos
];
1739 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1740 current_frame
->charstarts
[vpos
] = temp1
;
1749 /* Compute number of leading blanks in old and new contents. */
1750 osp
= count_blanks (obody
);
1751 if (!desired_frame
->highlight
[vpos
])
1752 nsp
= count_blanks (nbody
);
1756 /* Compute number of matching chars starting with first nonblank. */
1757 begmatch
= count_match (obody
+ osp
, nbody
+ nsp
);
1759 /* Spaces in new match implicit space past the end of old. */
1760 /* A bug causing this to be a no-op was fixed in 18.29. */
1761 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
1764 while (np1
[begmatch
] == SPACEGLYPH
)
1768 /* Avoid doing insert/delete char
1769 just cause number of leading spaces differs
1770 when the following text does not match. */
1771 if (begmatch
== 0 && osp
!= nsp
)
1772 osp
= nsp
= min (osp
, nsp
);
1774 /* Find matching characters at end of line */
1777 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
1778 while (op1
> op2
&& op1
[-1] == np1
[-1])
1783 endmatch
= obody
+ olen
- op1
;
1785 /* Put correct value back in nbody[nlen].
1786 This is important because direct_output_for_insert
1787 can write into the line at a later point.
1788 If this screws up the zero at the end of the line, re-establish it. */
1792 /* tem gets the distance to insert or delete.
1793 endmatch is how many characters we save by doing so.
1796 tem
= (nlen
- nsp
) - (olen
- osp
);
1798 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
1801 /* nsp - osp is the distance to insert or delete.
1802 If that is nonzero, begmatch is known to be nonzero also.
1803 begmatch + endmatch is how much we save by doing the ins/del.
1807 && (!char_ins_del_ok
1808 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
1812 osp
= nsp
= min (osp
, nsp
);
1815 /* Now go through the line, inserting, writing and
1816 deleting as appropriate. */
1820 cursor_to (vpos
, nsp
);
1821 delete_glyphs (osp
- nsp
);
1825 /* If going to delete chars later in line
1826 and insert earlier in the line,
1827 must delete first to avoid losing data in the insert */
1828 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
1830 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
1831 delete_glyphs (olen
+ nsp
- osp
- nlen
);
1832 olen
= nlen
- (nsp
- osp
);
1834 cursor_to (vpos
, osp
);
1835 insert_glyphs ((char *)0, nsp
- osp
);
1839 tem
= nsp
+ begmatch
+ endmatch
;
1840 if (nlen
!= tem
|| olen
!= tem
)
1842 cursor_to (vpos
, nsp
+ begmatch
);
1843 if (!endmatch
|| nlen
== olen
)
1845 /* If new text being written reaches right margin,
1846 there is no need to do clear-to-eol at the end.
1847 (and it would not be safe, since cursor is not
1848 going to be "at the margin" after the text is done) */
1849 if (nlen
== FRAME_WIDTH (frame
))
1851 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1855 /* the following code loses disastrously if tem == nlen.
1856 Rather than trying to fix that case, I am trying the simpler
1857 solution found above. */
1859 /* If the text reaches to the right margin,
1860 it will lose one way or another (depending on AutoWrap)
1861 to clear to end of line after outputting all the text.
1862 So pause with one character to go and clear the line then. */
1863 if (nlen
== FRAME_WIDTH (frame
) && fast_clear_end_of_line
&& olen
> nlen
)
1865 /* endmatch must be zero, and tem must equal nsp + begmatch */
1866 write_glyphs (nbody
+ tem
, nlen
- tem
- 1);
1867 clear_end_of_line (olen
);
1868 olen
= 0; /* Don't let it be cleared again later */
1869 write_glyphs (nbody
+ nlen
- 1, 1);
1872 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1873 #endif /* OBSOLETE */
1876 else if (nlen
> olen
)
1878 write_glyphs (nbody
+ nsp
+ begmatch
, olen
- tem
);
1879 insert_glyphs (nbody
+ nsp
+ begmatch
+ olen
- tem
, nlen
- olen
);
1882 else if (olen
> nlen
)
1884 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1885 delete_glyphs (olen
- nlen
);
1891 /* If any unerased characters remain after the new line, erase them. */
1894 cursor_to (vpos
, nlen
);
1895 clear_end_of_line (olen
);
1898 /* Exchange contents between current_frame and new_frame. */
1899 temp
= desired_frame
->glyphs
[vpos
];
1900 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1901 current_frame
->glyphs
[vpos
] = temp
;
1903 /* Exchange charstarts between current_frame and new_frame. */
1904 temp1
= desired_frame
->charstarts
[vpos
];
1905 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1906 current_frame
->charstarts
[vpos
] = temp1
;
1909 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
1910 session's frames, frame names, buffers, buffer-read-only flags, and
1911 buffer-modified-flags, and a trailing sentinel (so we don't need to
1912 add length checks). */
1913 static Lisp_Object frame_and_buffer_state
;
1915 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
1916 Sframe_or_buffer_changed_p
, 0, 0, 0,
1917 "Return non-nil if the frame and buffer state appears to have changed.\n\
1918 The state variable is an internal vector containing all frames and buffers,\n\
1919 aside from buffers whose names start with space,\n\
1920 along with the buffers' read-only and modified flags, which allows a fast\n\
1921 check to see whether the menu bars might need to be recomputed.\n\
1922 If this function returns non-nil, it updates the internal vector to reflect\n\
1923 the current state.\n")
1926 Lisp_Object tail
, frame
, buf
;
1930 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
1931 FOR_EACH_FRAME (tail
, frame
)
1933 if (!EQ (*vecp
++, frame
))
1935 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
1938 /* Check that the buffer info matches.
1939 No need to test for the end of the vector
1940 because the last element of the vector is lambda
1941 and that will always cause a mismatch. */
1942 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1944 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
1945 /* Ignore buffers that aren't included in buffer lists. */
1946 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
1948 if (!EQ (*vecp
++, buf
))
1950 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
1952 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
1955 /* Detect deletion of a buffer at the end of the list. */
1956 if (*vecp
== Qlambda
)
1959 /* Start with 1 so there is room for at least one lambda at the end. */
1961 FOR_EACH_FRAME (tail
, frame
)
1963 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1965 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
1966 if (n
> XVECTOR (frame_and_buffer_state
)->size
1967 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
1968 /* Add 20 extra so we grow it less often. */
1969 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
1970 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
1971 FOR_EACH_FRAME (tail
, frame
)
1974 *vecp
++ = XFRAME (frame
)->name
;
1976 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1978 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
1979 /* Ignore buffers that aren't included in buffer lists. */
1980 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
1983 *vecp
++ = XBUFFER (buf
)->read_only
;
1984 *vecp
++ = Fbuffer_modified_p (buf
);
1986 /* Fill up the vector with lambdas (always at least one). */
1988 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
1989 < XVECTOR (frame_and_buffer_state
)->size
)
1991 /* Make sure we didn't overflow the vector. */
1992 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
1993 > XVECTOR (frame_and_buffer_state
)->size
)
1998 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
1999 1, 1, "FOpen termscript file: ",
2000 "Start writing all terminal output to FILE as well as the terminal.\n\
2001 FILE = nil means just close any termscript file currently open.")
2005 if (termscript
!= 0) fclose (termscript
);
2010 file
= Fexpand_file_name (file
, Qnil
);
2011 termscript
= fopen (XSTRING (file
)->data
, "w");
2012 if (termscript
== 0)
2013 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
2021 window_change_signal (signalnum
) /* If we don't have an argument, */
2022 int signalnum
; /* some compilers complain in signal calls. */
2026 int old_errno
= errno
;
2028 get_frame_size (&width
, &height
);
2030 /* The frame size change obviously applies to a termcap-controlled
2031 frame. Find such a frame in the list, and assume it's the only
2032 one (since the redisplay code always writes to stdout, not a
2033 FILE * specified in the frame structure). Record the new size,
2034 but don't reallocate the data structures now. Let that be done
2035 later outside of the signal handler. */
2038 Lisp_Object tail
, frame
;
2040 FOR_EACH_FRAME (tail
, frame
)
2042 if (FRAME_TERMCAP_P (XFRAME (frame
)))
2044 change_frame_size (XFRAME (frame
), height
, width
, 0, 1);
2050 signal (SIGWINCH
, window_change_signal
);
2053 #endif /* SIGWINCH */
2056 /* Do any change in frame size that was requested by a signal. */
2058 do_pending_window_change ()
2060 /* If window_change_signal should have run before, run it now. */
2061 while (delayed_size_change
)
2063 Lisp_Object tail
, frame
;
2065 delayed_size_change
= 0;
2067 FOR_EACH_FRAME (tail
, frame
)
2069 FRAME_PTR f
= XFRAME (frame
);
2071 int height
= FRAME_NEW_HEIGHT (f
);
2072 int width
= FRAME_NEW_WIDTH (f
);
2074 if (height
!= 0 || width
!= 0)
2075 change_frame_size (f
, height
, width
, 0, 0);
2081 /* Change the frame height and/or width. Values may be given as zero to
2082 indicate no change is to take place.
2084 If DELAY is non-zero, then assume we're being called from a signal
2085 handler, and queue the change for later - perhaps the next
2086 redisplay. Since this tries to resize windows, we can't call it
2087 from a signal handler. */
2089 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
)
2090 register FRAME_PTR f
;
2091 int newheight
, newwidth
, pretend
;
2093 Lisp_Object tail
, frame
;
2094 if (FRAME_TERMCAP_P (f
))
2096 /* When using termcap, all frames use the same screen,
2097 so a change in size affects all termcap frames. */
2098 FOR_EACH_FRAME (tail
, frame
)
2099 if (FRAME_TERMCAP_P (XFRAME (frame
)))
2100 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
2104 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
);
2108 change_frame_size_1 (frame
, newheight
, newwidth
, pretend
, delay
)
2109 register FRAME_PTR frame
;
2110 int newheight
, newwidth
, pretend
, delay
;
2112 /* If we can't deal with the change now, queue it for later. */
2115 FRAME_NEW_HEIGHT (frame
) = newheight
;
2116 FRAME_NEW_WIDTH (frame
) = newwidth
;
2117 delayed_size_change
= 1;
2121 /* This size-change overrides any pending one for this frame. */
2122 FRAME_NEW_HEIGHT (frame
) = 0;
2123 FRAME_NEW_WIDTH (frame
) = 0;
2125 /* If an argument is zero, set it to the current value. */
2126 newheight
|| (newheight
= FRAME_HEIGHT (frame
));
2127 newwidth
|| (newwidth
= FRAME_WIDTH (frame
));
2129 /* Round up to the smallest acceptable size. */
2130 check_frame_size (frame
, &newheight
, &newwidth
);
2132 /* If we're not changing the frame size, quit now. */
2133 if (newheight
== FRAME_HEIGHT (frame
)
2134 && newwidth
== FRAME_WIDTH (frame
))
2137 if (newheight
!= FRAME_HEIGHT (frame
))
2139 if (FRAME_HAS_MINIBUF_P (frame
)
2140 && ! FRAME_MINIBUF_ONLY_P (frame
))
2142 /* Frame has both root and minibuffer. */
2143 set_window_height (FRAME_ROOT_WINDOW (frame
),
2144 newheight
- 1 - FRAME_MENU_BAR_LINES (frame
), 0);
2145 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (frame
))->top
,
2147 set_window_height (FRAME_MINIBUF_WINDOW (frame
), 1, 0);
2150 /* Frame has just one top-level window. */
2151 set_window_height (FRAME_ROOT_WINDOW (frame
),
2152 newheight
- FRAME_MENU_BAR_LINES (frame
), 0);
2154 if (FRAME_TERMCAP_P (frame
) && !pretend
)
2155 FrameRows
= newheight
;
2158 if (frame
->output_method
== output_termcap
)
2160 frame_height
= newheight
;
2162 FrameRows
= newheight
;
2167 if (newwidth
!= FRAME_WIDTH (frame
))
2169 set_window_width (FRAME_ROOT_WINDOW (frame
), newwidth
, 0);
2170 if (FRAME_HAS_MINIBUF_P (frame
))
2171 set_window_width (FRAME_MINIBUF_WINDOW (frame
), newwidth
, 0);
2173 if (FRAME_TERMCAP_P (frame
) && !pretend
)
2174 FrameCols
= newwidth
;
2176 if (frame
->output_method
== output_termcap
)
2178 frame_width
= newwidth
;
2180 FrameCols
= newwidth
;
2185 FRAME_HEIGHT (frame
) = newheight
;
2186 FRAME_WIDTH (frame
) = newwidth
;
2188 if (FRAME_CURSOR_X (frame
) >= FRAME_WIDTH (frame
))
2189 FRAME_CURSOR_X (frame
) = FRAME_WIDTH (frame
) - 1;
2190 if (FRAME_CURSOR_Y (frame
) >= FRAME_HEIGHT (frame
))
2191 FRAME_CURSOR_Y (frame
) = FRAME_HEIGHT (frame
) - 1;
2193 remake_frame_glyphs (frame
);
2194 calculate_costs (frame
);
2197 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
2198 Ssend_string_to_terminal
, 1, 1, 0,
2199 "Send STRING to the terminal without alteration.\n\
2200 Control characters in STRING will have terminal-dependent effects.")
2204 CHECK_STRING (str
, 0);
2205 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, stdout
);
2209 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, termscript
);
2210 fflush (termscript
);
2215 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
2216 "Beep, or flash the screen.\n\
2217 Also, unless an argument is given,\n\
2218 terminate any keyboard macro currently executing.")
2240 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
2241 error ("Keyboard macro terminated by a command ringing the bell");
2247 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
2248 "Pause, without updating display, for SECONDS seconds.\n\
2249 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2250 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2251 additional wait period, in milliseconds; this may be useful if your\n\
2252 Emacs was built without floating point support.\n\
2253 \(Not all operating systems support waiting for a fraction of a second.)")
2254 (seconds
, milliseconds
)
2255 Lisp_Object seconds
, milliseconds
;
2259 if (NILP (milliseconds
))
2260 XSETINT (milliseconds
, 0);
2262 CHECK_NUMBER (milliseconds
, 1);
2263 usec
= XINT (milliseconds
) * 1000;
2265 #ifdef LISP_FLOAT_TYPE
2267 double duration
= extract_float (seconds
);
2268 sec
= (int) duration
;
2269 usec
+= (duration
- sec
) * 1000000;
2272 CHECK_NUMBER (seconds
, 0);
2273 sec
= XINT (seconds
);
2276 #ifndef EMACS_HAS_USECS
2277 if (sec
== 0 && usec
!= 0)
2278 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
2281 /* Assure that 0 <= usec < 1000000. */
2284 /* We can't rely on the rounding being correct if user is negative. */
2285 if (-1000000 < usec
)
2286 sec
--, usec
+= 1000000;
2288 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
2291 sec
+= usec
/ 1000000, usec
%= 1000000;
2299 XSETFASTINT (zero
, 0);
2300 wait_reading_process_input (sec
, usec
, zero
, 0);
2303 /* We should always have wait_reading_process_input; we have a dummy
2304 implementation for systems which don't support subprocesses. */
2306 /* No wait_reading_process_input */
2313 /* The reason this is done this way
2314 (rather than defined (H_S) && defined (H_T))
2315 is because the VMS preprocessor doesn't grok `defined' */
2317 EMACS_GET_TIME (end_time
);
2318 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
2319 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
2323 EMACS_GET_TIME (timeout
);
2324 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
2325 if (EMACS_TIME_NEG_P (timeout
)
2326 || !select (1, 0, 0, 0, &timeout
))
2329 #else /* not HAVE_SELECT */
2331 #endif /* HAVE_SELECT */
2332 #endif /* not VMS */
2335 #endif /* no subprocesses */
2340 /* This is just like wait_reading_process_input, except that
2341 it does the redisplay.
2343 It's also much like Fsit_for, except that it can be used for
2344 waiting for input as well. */
2347 sit_for (sec
, usec
, reading
, display
)
2348 int sec
, usec
, reading
, display
;
2350 Lisp_Object read_kbd
;
2352 if (detect_input_pending ())
2356 redisplay_preserve_echo_area ();
2358 if (sec
== 0 && usec
== 0)
2365 XSETINT (read_kbd
, reading
? -1 : 1);
2366 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
2369 /* wait_reading_process_input should always be available now; it is
2370 simulated in a simple way on systems that don't support
2373 /* No wait_reading_process_input available. */
2379 input_wait_timeout (XINT (arg
));
2381 #ifndef HAVE_TIMEVAL
2383 select (1, &waitchannels
, 0, 0, &timeout_sec
);
2384 #else /* HAVE_TIMEVAL */
2385 timeout
.tv_sec
= sec
;
2386 timeout
.tv_usec
= usec
;
2387 select (1, &waitchannels
, 0, 0, &timeout
);
2388 #endif /* HAVE_TIMEVAL */
2389 #endif /* not VMS */
2394 return detect_input_pending () ? Qnil
: Qt
;
2397 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
2398 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
2399 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2400 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2401 additional wait period, in milliseconds; this may be useful if your\n\
2402 Emacs was built without floating point support.\n\
2403 \(Not all operating systems support waiting for a fraction of a second.)\n\
2404 Optional third arg non-nil means don't redisplay, just wait for input.\n\
2405 Redisplay is preempted as always if input arrives, and does not happen\n\
2406 if input is available before it starts.\n\
2407 Value is t if waited the full time with no input arriving.")
2408 (seconds
, milliseconds
, nodisp
)
2409 Lisp_Object seconds
, milliseconds
, nodisp
;
2413 if (NILP (milliseconds
))
2414 XSETINT (milliseconds
, 0);
2416 CHECK_NUMBER (milliseconds
, 1);
2417 usec
= XINT (milliseconds
) * 1000;
2419 #ifdef LISP_FLOAT_TYPE
2421 double duration
= extract_float (seconds
);
2422 sec
= (int) duration
;
2423 usec
+= (duration
- sec
) * 1000000;
2426 CHECK_NUMBER (seconds
, 0);
2427 sec
= XINT (seconds
);
2430 #ifndef EMACS_HAS_USECS
2431 if (usec
!= 0 && sec
== 0)
2432 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
2436 prepare_menu_bars ();
2437 return sit_for (sec
, usec
, 0, NILP (nodisp
));
2440 char *terminal_type
;
2442 /* Initialization done when Emacs fork is started, before doing stty. */
2443 /* Determine terminal type and set terminal_driver */
2444 /* Then invoke its decoding routine to set up variables
2445 in the terminal package */
2449 #ifdef HAVE_X_WINDOWS
2450 extern int display_arg
;
2455 cursor_in_echo_area
= 0;
2456 terminal_type
= (char *) 0;
2458 /* Now is the time to initialize this; it's used by init_sys_modes
2460 Vwindow_system
= Qnil
;
2462 /* If the user wants to use a window system, we shouldn't bother
2463 initializing the terminal. This is especially important when the
2464 terminal is so dumb that emacs gives up before and doesn't bother
2465 using the window system.
2467 If the DISPLAY environment variable is set, try to use X, and die
2468 with an error message if that doesn't work. */
2470 #ifdef HAVE_X_WINDOWS
2474 display_arg
= (getenv ("DECW$DISPLAY") != 0);
2476 display_arg
= (getenv ("DISPLAY") != 0);
2480 if (!inhibit_window_system
&& display_arg
)
2482 Vwindow_system
= intern ("x");
2484 Vwindow_system_version
= make_number (11);
2486 Vwindow_system_version
= make_number (10);
2490 #endif /* HAVE_X_WINDOWS */
2492 /* If no window system has been specified, try to use the terminal. */
2495 fprintf (stderr
, "emacs: standard input is not a tty\n");
2499 /* Look at the TERM variable */
2500 terminal_type
= (char *) getenv ("TERM");
2504 fprintf (stderr
, "Please specify your terminal type.\n\
2505 For types defined in VMS, use set term /device=TYPE.\n\
2506 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
2507 \(The quotation marks are necessary since terminal types are lower case.)\n");
2509 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
2515 /* VMS DCL tends to upcase things, so downcase term type.
2516 Hardly any uppercase letters in terminal types; should be none. */
2518 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
2521 strcpy (new, terminal_type
);
2523 for (p
= new; *p
; p
++)
2527 terminal_type
= new;
2531 term_init (terminal_type
);
2533 remake_frame_glyphs (selected_frame
);
2534 calculate_costs (selected_frame
);
2536 /* X and Y coordinates of the cursor between updates. */
2537 FRAME_CURSOR_X (selected_frame
) = 0;
2538 FRAME_CURSOR_Y (selected_frame
) = 0;
2543 #endif /* CANNOT_DUMP */
2544 signal (SIGWINCH
, window_change_signal
);
2545 #endif /* SIGWINCH */
2551 defsubr (&Sredraw_frame
);
2553 defsubr (&Sredraw_display
);
2554 defsubr (&Sframe_or_buffer_changed_p
);
2555 defsubr (&Sopen_termscript
);
2557 defsubr (&Ssit_for
);
2558 defsubr (&Ssleep_for
);
2559 defsubr (&Ssend_string_to_terminal
);
2561 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
2562 staticpro (&frame_and_buffer_state
);
2564 DEFVAR_INT ("baud-rate", &baud_rate
,
2565 "*The output baud rate of the terminal.\n\
2566 On most systems, changing this value will affect the amount of padding\n\
2567 and the other strategic decisions made during redisplay.");
2568 DEFVAR_BOOL ("inverse-video", &inverse_video
,
2569 "*Non-nil means invert the entire frame display.\n\
2570 This means everything is in inverse video which otherwise would not be.");
2571 DEFVAR_BOOL ("visible-bell", &visible_bell
,
2572 "*Non-nil means try to flash the frame to represent a bell.");
2573 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
2574 "*Non-nil means no need to redraw entire frame after suspending.\n\
2575 A non-nil value is useful if the terminal can automatically preserve\n\
2576 Emacs's frame display when you reenter Emacs.\n\
2577 It is up to you to set this variable if your terminal can do that.");
2578 DEFVAR_LISP ("window-system", &Vwindow_system
,
2579 "A symbol naming the window-system under which Emacs is running\n\
2580 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
2581 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
2582 "The version number of the window system in use.\n\
2583 For X windows, this is 10 or 11.");
2584 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
2585 "Non-nil means put cursor in minibuffer, at end of any message there.");
2586 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
2587 "Table defining how to output a glyph code to the frame.\n\
2588 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
2589 Each element can be:\n\
2590 integer: a glyph code which this glyph is an alias for.\n\
2591 string: output this glyph using that string (not impl. in X windows).\n\
2592 nil: this glyph mod 256 is char code to output,\n\
2593 and this glyph / 256 is face code for X windows (see `face-id').");
2594 Vglyph_table
= Qnil
;
2596 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
2597 "Display table to use for buffers that specify none.\n\
2598 See `buffer-display-table' for more information.");
2599 Vstandard_display_table
= Qnil
;
2601 /* Initialize `window-system', unless init_display already decided it. */
2606 Vwindow_system
= Qnil
;
2607 Vwindow_system_version
= Qnil
;