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 "Clear frame FRAME and output again what is supposed to appear on it.")
205 set_terminal_modes ();
209 clear_frame_records (0);
210 windows_or_buffers_changed
++;
211 /* Mark all windows as INaccurate,
212 so that every window will have its redisplay done. */
213 mark_window_display_accurate (FRAME_ROOT_WINDOW (0), 0);
219 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
220 "Clear and redisplay all visible frames.")
223 Lisp_Object tail
, frame
;
225 FOR_EACH_FRAME (tail
, frame
)
226 if (FRAME_VISIBLE_P (XFRAME (frame
)))
227 Fredraw_frame (frame
);
232 /* This is used when frame_garbaged is set.
233 Redraw the individual frames marked as garbaged. */
236 redraw_garbaged_frames ()
238 Lisp_Object tail
, frame
;
240 FOR_EACH_FRAME (tail
, frame
)
241 if (FRAME_VISIBLE_P (XFRAME (frame
))
242 && FRAME_GARBAGED_P (XFRAME (frame
)))
243 Fredraw_frame (frame
);
247 static struct frame_glyphs
*
248 make_frame_glyphs (frame
, empty
)
249 register FRAME_PTR frame
;
253 register width
= FRAME_WIDTH (frame
);
254 register height
= FRAME_HEIGHT (frame
);
255 register struct frame_glyphs
*new
256 = (struct frame_glyphs
*) xmalloc (sizeof (struct frame_glyphs
));
258 SET_GLYPHS_FRAME (new, frame
);
259 new->height
= height
;
261 new->used
= (int *) xmalloc (height
* sizeof (int));
262 new->glyphs
= (GLYPH
**) xmalloc (height
* sizeof (GLYPH
*));
263 new->charstarts
= (int **) xmalloc (height
* sizeof (int *));
264 new->highlight
= (char *) xmalloc (height
* sizeof (char));
265 new->enable
= (char *) xmalloc (height
* sizeof (char));
266 bzero (new->enable
, height
* sizeof (char));
267 new->bufp
= (int *) xmalloc (height
* sizeof (int));
269 #ifdef HAVE_X_WINDOWS
270 if (FRAME_X_P (frame
))
272 new->top_left_x
= (short *) xmalloc (height
* sizeof (short));
273 new->top_left_y
= (short *) xmalloc (height
* sizeof (short));
274 new->pix_width
= (short *) xmalloc (height
* sizeof (short));
275 new->pix_height
= (short *) xmalloc (height
* sizeof (short));
276 new->max_ascent
= (short *) xmalloc (height
* sizeof (short));
282 /* Make the buffer used by decode_mode_spec. This buffer is also
283 used as temporary storage when updating the frame. See scroll.c. */
284 unsigned int total_glyphs
= (width
+ 2) * sizeof (GLYPH
);
285 unsigned int total_charstarts
= (width
+ 2) * sizeof (int);
287 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
288 bzero (new->total_contents
, total_glyphs
);
290 new->total_charstarts
= (int *) xmalloc (total_charstarts
);
291 bzero (new->total_charstarts
, total_glyphs
);
295 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (GLYPH
);
297 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
298 bzero (new->total_contents
, total_glyphs
);
299 for (i
= 0; i
< height
; i
++)
300 new->glyphs
[i
] = new->total_contents
+ i
* (width
+ 2) + 1;
302 if (!FRAME_TERMCAP_P (frame
))
304 unsigned int total_charstarts
= height
* (width
+ 2) * sizeof (int);
306 new->total_charstarts
= (int *) xmalloc (total_charstarts
);
307 bzero (new->total_charstarts
, total_charstarts
);
308 for (i
= 0; i
< height
; i
++)
309 new->charstarts
[i
] = new->total_charstarts
+ i
* (width
+ 2) + 1;
313 /* Without a window system, we don't really need charstarts.
314 So use a small amount of space to make enough data structure
315 to prevent crashes in display_text_line. */
316 new->total_charstarts
= (int *) xmalloc ((width
+ 2) * sizeof (int));
317 for (i
= 0; i
< height
; i
++)
318 new->charstarts
[i
] = new->total_charstarts
;
326 free_frame_glyphs (frame
, glyphs
)
328 struct frame_glyphs
*glyphs
;
330 if (glyphs
->total_contents
)
331 xfree (glyphs
->total_contents
);
332 if (glyphs
->total_charstarts
)
333 xfree (glyphs
->total_charstarts
);
335 xfree (glyphs
->used
);
336 xfree (glyphs
->glyphs
);
337 xfree (glyphs
->highlight
);
338 xfree (glyphs
->enable
);
339 xfree (glyphs
->bufp
);
340 if (glyphs
->charstarts
)
341 xfree (glyphs
->charstarts
);
343 #ifdef HAVE_X_WINDOWS
344 if (FRAME_X_P (frame
))
346 xfree (glyphs
->top_left_x
);
347 xfree (glyphs
->top_left_y
);
348 xfree (glyphs
->pix_width
);
349 xfree (glyphs
->pix_height
);
350 xfree (glyphs
->max_ascent
);
358 remake_frame_glyphs (frame
)
361 if (FRAME_CURRENT_GLYPHS (frame
))
362 free_frame_glyphs (frame
, FRAME_CURRENT_GLYPHS (frame
));
363 if (FRAME_DESIRED_GLYPHS (frame
))
364 free_frame_glyphs (frame
, FRAME_DESIRED_GLYPHS (frame
));
365 if (FRAME_TEMP_GLYPHS (frame
))
366 free_frame_glyphs (frame
, FRAME_TEMP_GLYPHS (frame
));
368 if (FRAME_MESSAGE_BUF (frame
))
370 /* Reallocate the frame's message buffer; remember that
371 echo_area_glyphs may be pointing here. */
372 char *old_message_buf
= FRAME_MESSAGE_BUF (frame
);
374 FRAME_MESSAGE_BUF (frame
)
375 = (char *) xrealloc (FRAME_MESSAGE_BUF (frame
),
376 FRAME_WIDTH (frame
) + 1);
378 if (echo_area_glyphs
== old_message_buf
)
379 echo_area_glyphs
= FRAME_MESSAGE_BUF (frame
);
380 if (previous_echo_glyphs
== old_message_buf
)
381 previous_echo_glyphs
= FRAME_MESSAGE_BUF (frame
);
384 FRAME_MESSAGE_BUF (frame
)
385 = (char *) xmalloc (FRAME_WIDTH (frame
) + 1);
387 FRAME_CURRENT_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
388 FRAME_DESIRED_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
389 FRAME_TEMP_GLYPHS (frame
) = make_frame_glyphs (frame
, 1);
390 if (! FRAME_TERMCAP_P (frame
) || frame
== selected_frame
)
391 SET_FRAME_GARBAGED (frame
);
394 /* Return the hash code of contents of line VPOS in frame-matrix M. */
397 line_hash_code (m
, vpos
)
398 register struct frame_glyphs
*m
;
401 register GLYPH
*body
, *end
;
404 if (!m
->enable
[vpos
])
407 /* Give all highlighted lines the same hash code
408 so as to encourage scrolling to leave them in place. */
409 if (m
->highlight
[vpos
])
412 body
= m
->glyphs
[vpos
];
414 if (must_write_spaces
)
421 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
- SPACEGLYPH
;
430 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
;
438 /* Return number of characters in line in M at vpos VPOS,
439 except don't count leading and trailing spaces
440 unless the terminal requires those to be explicitly output. */
443 line_draw_cost (m
, vpos
)
444 struct frame_glyphs
*m
;
447 register GLYPH
*beg
= m
->glyphs
[vpos
];
448 register GLYPH
*end
= m
->glyphs
[vpos
] + m
->used
[vpos
];
450 register int tlen
= GLYPH_TABLE_LENGTH
;
451 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
453 /* Ignore trailing and leading spaces if we can. */
454 if (!must_write_spaces
)
456 while ((end
!= beg
) && (*end
== SPACEGLYPH
))
459 return (0); /* All blank line. */
461 while (*beg
== SPACEGLYPH
)
465 /* If we don't have a glyph-table, each glyph is one character,
466 so return the number of glyphs. */
470 /* Otherwise, scan the glyphs and accumulate their total size in I. */
472 while ((beg
<= end
) && *beg
)
474 register GLYPH g
= *beg
++;
476 if (GLYPH_SIMPLE_P (tbase
, tlen
, g
))
479 i
+= GLYPH_LENGTH (tbase
, g
);
484 /* The functions on this page are the interface from xdisp.c to redisplay.
486 The only other interface into redisplay is through setting
487 FRAME_CURSOR_X (frame) and FRAME_CURSOR_Y (frame)
488 and SET_FRAME_GARBAGED (frame). */
490 /* cancel_line eliminates any request to display a line at position `vpos' */
492 cancel_line (vpos
, frame
)
494 register FRAME_PTR frame
;
496 FRAME_DESIRED_GLYPHS (frame
)->enable
[vpos
] = 0;
499 clear_frame_records (frame
)
500 register FRAME_PTR frame
;
502 bzero (FRAME_CURRENT_GLYPHS (frame
)->enable
, FRAME_HEIGHT (frame
));
505 /* Clear out all display lines for a coming redisplay. */
508 init_desired_glyphs (frame
)
509 register FRAME_PTR frame
;
511 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (frame
);
513 int height
= FRAME_HEIGHT (frame
);
515 for (vpos
= 0; vpos
< height
; vpos
++)
516 desired_glyphs
->enable
[vpos
] = 0;
519 /* Prepare to display on line VPOS starting at HPOS within it. */
522 get_display_line (frame
, vpos
, hpos
)
523 register FRAME_PTR frame
;
527 register struct frame_glyphs
*glyphs
;
528 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (frame
);
534 if ((desired_glyphs
->enable
[vpos
]) && desired_glyphs
->used
[vpos
] > hpos
)
537 if (! desired_glyphs
->enable
[vpos
])
539 desired_glyphs
->used
[vpos
] = 0;
540 desired_glyphs
->highlight
[vpos
] = 0;
541 desired_glyphs
->enable
[vpos
] = 1;
544 if (hpos
> desired_glyphs
->used
[vpos
])
546 GLYPH
*g
= desired_glyphs
->glyphs
[vpos
] + desired_glyphs
->used
[vpos
];
547 GLYPH
*end
= desired_glyphs
->glyphs
[vpos
] + hpos
;
549 desired_glyphs
->used
[vpos
] = hpos
;
555 /* Like bcopy except never gets confused by overlap. */
558 safe_bcopy (from
, to
, size
)
562 if (size
<= 0 || from
== to
)
565 /* If the source and destination don't overlap, then bcopy can
566 handle it. If they do overlap, but the destination is lower in
567 memory than the source, we'll assume bcopy can handle that. */
568 if (to
< from
|| from
+ size
<= to
)
569 bcopy (from
, to
, size
);
571 /* Otherwise, we'll copy from the end. */
574 register char *endf
= from
+ size
;
575 register char *endt
= to
+ size
;
577 /* If TO - FROM is large, then we should break the copy into
578 nonoverlapping chunks of TO - FROM bytes each. However, if
579 TO - FROM is small, then the bcopy function call overhead
580 makes this not worth it. The crossover point could be about
581 anywhere. Since I don't think the obvious copy loop is too
582 bad, I'm trying to err in its favor. */
587 while (endf
!= from
);
599 bcopy (endf
, endt
, to
- from
);
602 /* If SIZE wasn't a multiple of TO - FROM, there will be a
603 little left over. The amount left over is
604 (endt + (to - from)) - to, which is endt - from. */
605 bcopy (from
, to
, endt
- from
);
610 /* Rotate a vector of SIZE bytes right, by DISTANCE bytes.
611 DISTANCE may be negative. */
614 rotate_vector (vector
, size
, distance
)
619 char *temp
= (char *) alloca (size
);
624 bcopy (vector
, temp
+ distance
, size
- distance
);
625 bcopy (vector
+ size
- distance
, temp
, distance
);
626 bcopy (temp
, vector
, size
);
629 /* Scroll lines from vpos FROM up to but not including vpos END
630 down by AMOUNT lines (AMOUNT may be negative).
631 Returns nonzero if done, zero if terminal cannot scroll them. */
634 scroll_frame_lines (frame
, from
, end
, amount
, newpos
)
635 register FRAME_PTR frame
;
636 int from
, end
, amount
, newpos
;
639 register struct frame_glyphs
*current_frame
640 = FRAME_CURRENT_GLYPHS (frame
);
642 int width
= FRAME_WIDTH (frame
);
644 if (!line_ins_del_ok
)
652 update_begin (frame
);
653 set_terminal_window (end
+ amount
);
654 if (!scroll_region_ok
)
655 ins_del_lines (end
, -amount
);
656 ins_del_lines (from
, amount
);
657 set_terminal_window (0);
659 rotate_vector (current_frame
->glyphs
+ from
,
660 sizeof (GLYPH
*) * (end
+ amount
- from
),
661 amount
* sizeof (GLYPH
*));
663 rotate_vector (current_frame
->charstarts
+ from
,
664 sizeof (int *) * (end
+ amount
- from
),
665 amount
* sizeof (int *));
667 safe_bcopy (current_frame
->used
+ from
,
668 current_frame
->used
+ from
+ amount
,
669 (end
- from
) * sizeof current_frame
->used
[0]);
671 safe_bcopy (current_frame
->highlight
+ from
,
672 current_frame
->highlight
+ from
+ amount
,
673 (end
- from
) * sizeof current_frame
->highlight
[0]);
675 safe_bcopy (current_frame
->enable
+ from
,
676 current_frame
->enable
+ from
+ amount
,
677 (end
- from
) * sizeof current_frame
->enable
[0]);
679 /* Adjust the lines by an amount
680 that puts the first of them at NEWPOS. */
681 pos_adjust
= newpos
- current_frame
->charstarts
[from
+ amount
][0];
683 /* Offset each char position in the charstarts lines we moved
685 for (i
= from
+ amount
; i
< end
+ amount
; i
++)
687 int *line
= current_frame
->charstarts
[i
];
689 for (col
= 0; col
< width
; col
++)
691 line
[col
] += pos_adjust
;
693 for (i
= from
; i
< from
+ amount
; i
++)
695 int *line
= current_frame
->charstarts
[i
];
698 for (col
= 0; col
< width
; col
++)
702 /* Mark the lines made empty by scrolling as enabled, empty and
704 bzero (current_frame
->used
+ from
,
705 amount
* sizeof current_frame
->used
[0]);
706 bzero (current_frame
->highlight
+ from
,
707 amount
* sizeof current_frame
->highlight
[0]);
708 for (i
= from
; i
< from
+ amount
; i
++)
710 current_frame
->glyphs
[i
][0] = '\0';
711 current_frame
->charstarts
[i
][0] = -1;
712 current_frame
->enable
[i
] = 1;
715 safe_bcopy (current_frame
->bufp
+ from
,
716 current_frame
->bufp
+ from
+ amount
,
717 (end
- from
) * sizeof current_frame
->bufp
[0]);
719 #ifdef HAVE_X_WINDOWS
720 if (FRAME_X_P (frame
))
722 safe_bcopy (current_frame
->top_left_x
+ from
,
723 current_frame
->top_left_x
+ from
+ amount
,
724 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
726 safe_bcopy (current_frame
->top_left_y
+ from
,
727 current_frame
->top_left_y
+ from
+ amount
,
728 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
730 safe_bcopy (current_frame
->pix_width
+ from
,
731 current_frame
->pix_width
+ from
+ amount
,
732 (end
- from
) * sizeof current_frame
->pix_width
[0]);
734 safe_bcopy (current_frame
->pix_height
+ from
,
735 current_frame
->pix_height
+ from
+ amount
,
736 (end
- from
) * sizeof current_frame
->pix_height
[0]);
738 safe_bcopy (current_frame
->max_ascent
+ from
,
739 current_frame
->max_ascent
+ from
+ amount
,
740 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
742 #endif /* HAVE_X_WINDOWS */
748 update_begin (frame
);
749 set_terminal_window (end
);
750 ins_del_lines (from
+ amount
, amount
);
751 if (!scroll_region_ok
)
752 ins_del_lines (end
+ amount
, -amount
);
753 set_terminal_window (0);
755 rotate_vector (current_frame
->glyphs
+ from
+ amount
,
756 sizeof (GLYPH
*) * (end
- from
- amount
),
757 amount
* sizeof (GLYPH
*));
759 rotate_vector (current_frame
->charstarts
+ from
+ amount
,
760 sizeof (int *) * (end
- from
- amount
),
761 amount
* sizeof (int *));
763 safe_bcopy (current_frame
->used
+ from
,
764 current_frame
->used
+ from
+ amount
,
765 (end
- from
) * sizeof current_frame
->used
[0]);
767 safe_bcopy (current_frame
->highlight
+ from
,
768 current_frame
->highlight
+ from
+ amount
,
769 (end
- from
) * sizeof current_frame
->highlight
[0]);
771 safe_bcopy (current_frame
->enable
+ from
,
772 current_frame
->enable
+ from
+ amount
,
773 (end
- from
) * sizeof current_frame
->enable
[0]);
775 /* Adjust the lines by an amount
776 that puts the first of them at NEWPOS. */
777 pos_adjust
= newpos
- current_frame
->charstarts
[from
+ amount
][0];
779 /* Offset each char position in the charstarts lines we moved
781 for (i
= from
+ amount
; i
< end
+ amount
; i
++)
783 int *line
= current_frame
->charstarts
[i
];
785 for (col
= 0; col
< width
; col
++)
787 line
[col
] += pos_adjust
;
789 for (i
= end
+ amount
; i
< end
; i
++)
791 int *line
= current_frame
->charstarts
[i
];
794 for (col
= 0; col
< width
; col
++)
798 /* Mark the lines made empty by scrolling as enabled, empty and
800 bzero (current_frame
->used
+ end
+ amount
,
801 - amount
* sizeof current_frame
->used
[0]);
802 bzero (current_frame
->highlight
+ end
+ amount
,
803 - amount
* sizeof current_frame
->highlight
[0]);
804 for (i
= end
+ amount
; i
< end
; i
++)
806 current_frame
->glyphs
[i
][0] = '\0';
807 current_frame
->charstarts
[i
][0] = 0;
808 current_frame
->enable
[i
] = 1;
811 safe_bcopy (current_frame
->bufp
+ from
,
812 current_frame
->bufp
+ from
+ amount
,
813 (end
- from
) * sizeof current_frame
->bufp
[0]);
815 #ifdef HAVE_X_WINDOWS
816 if (FRAME_X_P (frame
))
818 safe_bcopy (current_frame
->top_left_x
+ from
,
819 current_frame
->top_left_x
+ from
+ amount
,
820 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
822 safe_bcopy (current_frame
->top_left_y
+ from
,
823 current_frame
->top_left_y
+ from
+ amount
,
824 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
826 safe_bcopy (current_frame
->pix_width
+ from
,
827 current_frame
->pix_width
+ from
+ amount
,
828 (end
- from
) * sizeof current_frame
->pix_width
[0]);
830 safe_bcopy (current_frame
->pix_height
+ from
,
831 current_frame
->pix_height
+ from
+ amount
,
832 (end
- from
) * sizeof current_frame
->pix_height
[0]);
834 safe_bcopy (current_frame
->max_ascent
+ from
,
835 current_frame
->max_ascent
+ from
+ amount
,
836 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
838 #endif /* HAVE_X_WINDOWS */
845 /* After updating a window W that isn't the full frame wide,
846 copy all the columns that W does not occupy
847 into the FRAME_DESIRED_GLYPHS (frame) from the FRAME_PHYS_GLYPHS (frame)
848 so that update_frame will not change those columns. */
850 preserve_other_columns (w
)
854 register struct frame_glyphs
*current_frame
, *desired_frame
;
855 register FRAME_PTR frame
= XFRAME (w
->frame
);
856 int start
= XFASTINT (w
->left
);
857 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
858 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
860 current_frame
= FRAME_CURRENT_GLYPHS (frame
);
861 desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
863 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
865 if (current_frame
->enable
[vpos
] && desired_frame
->enable
[vpos
])
871 bcopy (current_frame
->glyphs
[vpos
],
872 desired_frame
->glyphs
[vpos
],
873 start
* sizeof (current_frame
->glyphs
[vpos
][0]));
874 bcopy (current_frame
->charstarts
[vpos
],
875 desired_frame
->charstarts
[vpos
],
876 start
* sizeof (current_frame
->charstarts
[vpos
][0]));
877 len
= min (start
, current_frame
->used
[vpos
]);
878 if (desired_frame
->used
[vpos
] < len
)
879 desired_frame
->used
[vpos
] = len
;
881 if (current_frame
->used
[vpos
] > end
882 && desired_frame
->used
[vpos
] < current_frame
->used
[vpos
])
884 while (desired_frame
->used
[vpos
] < end
)
886 int used
= desired_frame
->used
[vpos
]++;
887 desired_frame
->glyphs
[vpos
][used
] = SPACEGLYPH
;
888 desired_frame
->glyphs
[vpos
][used
] = 0;
890 bcopy (current_frame
->glyphs
[vpos
] + end
,
891 desired_frame
->glyphs
[vpos
] + end
,
892 ((current_frame
->used
[vpos
] - end
)
893 * sizeof (current_frame
->glyphs
[vpos
][0])));
894 bcopy (current_frame
->charstarts
[vpos
] + end
,
895 desired_frame
->charstarts
[vpos
] + end
,
896 ((current_frame
->used
[vpos
] - end
)
897 * sizeof (current_frame
->charstarts
[vpos
][0])));
898 desired_frame
->used
[vpos
] = current_frame
->used
[vpos
];
906 /* If window w does not need to be updated and isn't the full frame wide,
907 copy all the columns that w does occupy
908 into the FRAME_DESIRED_LINES (frame) from the FRAME_PHYS_LINES (frame)
909 so that update_frame will not change those columns.
911 Have not been able to figure out how to use this correctly. */
913 preserve_my_columns (w
)
916 register int vpos
, fin
;
917 register struct frame_glyphs
*l1
, *l2
;
918 register FRAME_PTR frame
= XFRAME (w
->frame
);
919 int start
= XFASTINT (w
->left
);
920 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
921 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
923 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
925 if ((l1
= FRAME_DESIRED_GLYPHS (frame
)->glyphs
[vpos
+ 1])
926 && (l2
= FRAME_PHYS_GLYPHS (frame
)->glyphs
[vpos
+ 1]))
928 if (l2
->length
> start
&& l1
->length
< l2
->length
)
931 if (fin
> end
) fin
= end
;
932 while (l1
->length
< start
)
933 l1
->body
[l1
->length
++] = ' ';
934 bcopy (l2
->body
+ start
, l1
->body
+ start
, fin
- start
);
943 /* Adjust by ADJUST the charstart values in window W
944 after vpos VPOS, which counts relative to the frame
945 (not relative to W itself). */
948 adjust_window_charstarts (w
, vpos
, adjust
)
953 int left
= XFASTINT (w
->left
);
954 int top
= XFASTINT (w
->top
);
955 int right
= left
+ window_internal_width (w
);
956 int bottom
= top
+ window_internal_height (w
);
959 for (i
= vpos
+ 1; i
< bottom
; i
++)
962 = FRAME_CURRENT_GLYPHS (XFRAME (WINDOW_FRAME (w
)))->charstarts
[i
];
964 for (j
= left
; j
< right
; j
++)
965 if (charstart
[j
] > 0)
966 charstart
[j
] += adjust
;
970 /* Check the charstarts values in the area of window W
971 for internal consistency. We cannot check that they are "right";
972 we can only look for something nonsensical. */
974 verify_charstarts (w
)
977 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
979 int top
= XFASTINT (w
->top
);
980 int bottom
= top
+ window_internal_height (w
);
981 int left
= XFASTINT (w
->left
);
982 int right
= left
+ window_internal_width (w
);
984 int truncate
= (XINT (w
->hscroll
)
985 || (truncate_partial_width_windows
986 && (XFASTINT (w
->width
) < FRAME_WIDTH (f
)))
987 || !NILP (XBUFFER (w
->buffer
)->truncate_lines
));
989 for (i
= top
; i
< bottom
; i
++)
993 int *charstart
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[i
];
999 /* If we are truncating lines, allow a jump
1000 in charstarts from one line to the next. */
1001 if (charstart
[left
] < next_line
)
1006 if (charstart
[left
] != next_line
)
1011 for (j
= left
; j
< right
; j
++)
1012 if (charstart
[j
] > 0)
1013 last
= charstart
[j
];
1014 /* Record where the next line should start. */
1016 if (BUF_ZV (XBUFFER (w
->buffer
)) != last
)
1018 /* If there's a newline between the two lines, count that. */
1019 int endchar
= *BUF_CHAR_ADDRESS (XBUFFER (w
->buffer
), last
);
1020 if (endchar
== '\n')
1026 /* On discovering that the redisplay for a window was no good,
1027 cancel the columns of that window, so that when the window is
1028 displayed over again get_display_line will not complain. */
1030 cancel_my_columns (w
)
1034 register struct frame_glyphs
*desired_glyphs
1035 = FRAME_DESIRED_GLYPHS (XFRAME (w
->frame
));
1036 register int start
= XFASTINT (w
->left
);
1037 register int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
1039 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
1040 if (desired_glyphs
->enable
[vpos
]
1041 && desired_glyphs
->used
[vpos
] >= start
)
1042 desired_glyphs
->used
[vpos
] = start
;
1045 /* These functions try to perform directly and immediately on the frame
1046 the necessary output for one change in the buffer.
1047 They may return 0 meaning nothing was done if anything is difficult,
1048 or 1 meaning the output was performed properly.
1049 They assume that the frame was up to date before the buffer
1050 change being displayed. They make various other assumptions too;
1051 see command_loop_1 where these are called. */
1054 direct_output_for_insert (g
)
1057 register FRAME_PTR frame
= selected_frame
;
1058 register struct frame_glyphs
*current_frame
1059 = FRAME_CURRENT_GLYPHS (frame
);
1061 #ifndef COMPILER_REGISTER_BUG
1063 #endif /* COMPILER_REGISTER_BUG */
1064 struct window
*w
= XWINDOW (selected_window
);
1065 #ifndef COMPILER_REGISTER_BUG
1067 #endif /* COMPILER_REGISTER_BUG */
1068 int hpos
= FRAME_CURSOR_X (frame
);
1069 #ifndef COMPILER_REGISTER_BUG
1071 #endif /* COMPILER_REGISTER_BUG */
1072 int vpos
= FRAME_CURSOR_Y (frame
);
1074 /* Give up if about to continue line. */
1075 if (hpos
>= XFASTINT (w
->left
) + window_internal_width (w
) - 1
1077 /* Avoid losing if cursor is in invisible text off left margin */
1078 || (XINT (w
->hscroll
) && hpos
== XFASTINT (w
->left
))
1080 /* Give up if cursor outside window (in minibuf, probably) */
1081 || cursor_in_echo_area
1082 || FRAME_CURSOR_Y (frame
) < XFASTINT (w
->top
)
1083 || FRAME_CURSOR_Y (frame
) >= XFASTINT (w
->top
) + XFASTINT (w
->height
)
1085 /* Give up if cursor not really at FRAME_CURSOR_X, FRAME_CURSOR_Y */
1086 || !display_completed
1088 /* Give up if buffer appears in two places. */
1089 || buffer_shared
> 1
1091 #ifdef USE_TEXT_PROPERTIES
1092 /* Intervals have already been adjusted, point is after the
1093 character that was just inserted. */
1094 /* Give up if character is invisible. */
1095 /* Give up if character has a face property.
1096 At the moment we only lose at end of line or end of buffer
1097 and only with faces that have some background */
1098 /* Instead of wasting time, give up if character has any text properties */
1099 || ! NILP (Ftext_properties_at (make_number (point
- 1), Qnil
))
1102 /* Give up if w is minibuffer and a message is being displayed there */
1103 || (MINI_WINDOW_P (w
) && echo_area_glyphs
))
1111 if (FRAME_X_P (frame
))
1112 face
= compute_char_face (frame
, w
, point
- 1, -1, -1, &dummy
, point
, 0);
1114 current_frame
->glyphs
[vpos
][hpos
] = MAKE_GLYPH (frame
, g
, face
);
1115 current_frame
->charstarts
[vpos
][hpos
] = point
- 1;
1116 /* Record the entry for after the newly inserted character. */
1117 current_frame
->charstarts
[vpos
][hpos
+ 1] = point
;
1118 adjust_window_charstarts (w
, vpos
, 1);
1120 unchanged_modified
= MODIFF
;
1121 beg_unchanged
= GPT
- BEG
;
1122 XSETFASTINT (w
->last_point
, point
);
1123 XSETFASTINT (w
->last_point_x
, hpos
);
1124 XSETFASTINT (w
->last_modified
, MODIFF
);
1126 reassert_line_highlight (0, vpos
);
1127 write_glyphs (¤t_frame
->glyphs
[vpos
][hpos
], 1);
1129 ++FRAME_CURSOR_X (frame
);
1130 if (hpos
== current_frame
->used
[vpos
])
1132 current_frame
->used
[vpos
] = hpos
+ 1;
1133 current_frame
->glyphs
[vpos
][hpos
+ 1] = 0;
1140 direct_output_forward_char (n
)
1143 register FRAME_PTR frame
= selected_frame
;
1144 register struct window
*w
= XWINDOW (selected_window
);
1145 Lisp_Object position
;
1146 int hpos
= FRAME_CURSOR_X (frame
);
1148 /* Give up if in truncated text at end of line. */
1149 if (hpos
>= XFASTINT (w
->left
) + window_internal_width (w
) - 1)
1152 /* Avoid losing if cursor is in invisible text off left margin
1153 or about to go off either side of window. */
1154 if ((FRAME_CURSOR_X (frame
) == XFASTINT (w
->left
)
1155 && (XINT (w
->hscroll
) || n
< 0))
1157 && (FRAME_CURSOR_X (frame
) + 1 >= window_internal_width (w
) - 1))
1158 || cursor_in_echo_area
)
1161 /* Can't use direct output if highlighting a region. */
1162 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
1165 /* Can't use direct output at an overlay boundary; it might have
1166 before-string or after-string properties. */
1167 if (overlay_touches_p (PT
) || overlay_touches_p (PT
- n
))
1170 #ifdef USE_TEXT_PROPERTIES
1171 /* Don't use direct output next to an invisible character
1172 since we might need to do something special. */
1174 XSETFASTINT (position
, point
);
1175 if (XFASTINT (position
) < ZV
1176 && ! NILP (Fget_char_property (position
,
1181 XSETFASTINT (position
, point
- 1);
1182 if (XFASTINT (position
) >= BEGV
1183 && ! NILP (Fget_char_property (position
,
1189 FRAME_CURSOR_X (frame
) += n
;
1190 XSETFASTINT (w
->last_point_x
, FRAME_CURSOR_X (frame
));
1191 XSETFASTINT (w
->last_point
, point
);
1192 cursor_to (FRAME_CURSOR_Y (frame
), FRAME_CURSOR_X (frame
));
1198 static void update_line ();
1200 /* Update frame F based on the data in FRAME_DESIRED_GLYPHS.
1201 Value is nonzero if redisplay stopped due to pending input.
1202 FORCE nonzero means do not stop for pending input. */
1205 update_frame (f
, force
, inhibit_hairy_id
)
1208 int inhibit_hairy_id
;
1210 register struct frame_glyphs
*current_frame
;
1211 register struct frame_glyphs
*desired_frame
= 0;
1214 int preempt_count
= baud_rate
/ 2400 + 1;
1215 extern input_pending
;
1216 #ifdef HAVE_X_WINDOWS
1217 register int downto
, leftmost
;
1220 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
1221 calculate_costs (f
);
1223 if (preempt_count
<= 0)
1226 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1228 detect_input_pending ();
1229 if (input_pending
&& !force
)
1237 if (!line_ins_del_ok
)
1238 inhibit_hairy_id
= 1;
1240 /* These are separate to avoid a possible bug in the AIX C compiler. */
1241 current_frame
= FRAME_CURRENT_GLYPHS (f
);
1242 desired_frame
= FRAME_DESIRED_GLYPHS (f
);
1244 /* See if any of the desired lines are enabled; don't compute for
1245 i/d line if just want cursor motion. */
1246 for (i
= 0; i
< FRAME_HEIGHT (f
); i
++)
1247 if (desired_frame
->enable
[i
])
1250 /* Try doing i/d line, if not yet inhibited. */
1251 if (!inhibit_hairy_id
&& i
< FRAME_HEIGHT (f
))
1252 force
|= scrolling (f
);
1254 /* Update the individual lines as needed. Do bottom line first. */
1256 if (desired_frame
->enable
[FRAME_HEIGHT (f
) - 1])
1257 update_line (f
, FRAME_HEIGHT (f
) - 1);
1259 #ifdef HAVE_X_WINDOWS
1262 leftmost
= downto
= f
->display
.x
->internal_border_width
;
1263 if (desired_frame
->enable
[0])
1265 current_frame
->top_left_x
[FRAME_HEIGHT (f
) - 1] = leftmost
;
1266 current_frame
->top_left_y
[FRAME_HEIGHT (f
) - 1]
1267 = PIXEL_HEIGHT (f
) - f
->display
.x
->internal_border_width
1268 - current_frame
->pix_height
[FRAME_HEIGHT (f
) - 1];
1269 current_frame
->top_left_x
[0] = leftmost
;
1270 current_frame
->top_left_y
[0] = downto
;
1273 #endif /* HAVE_X_WINDOWS */
1275 /* Now update the rest of the lines. */
1276 for (i
= 0; i
< FRAME_HEIGHT (f
) - 1 && (force
|| !input_pending
); i
++)
1278 if (desired_frame
->enable
[i
])
1280 if (FRAME_TERMCAP_P (f
))
1282 /* Flush out every so many lines.
1283 Also flush out if likely to have more than 1k buffered
1284 otherwise. I'm told that some telnet connections get
1285 really screwed by more than 1k output at once. */
1286 int outq
= PENDING_OUTPUT_COUNT (stdout
);
1288 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
1291 if (preempt_count
== 1)
1293 #ifdef EMACS_OUTQSIZE
1294 if (EMACS_OUTQSIZE (0, &outq
) < 0)
1295 /* Probably not a tty. Ignore the error and reset
1296 * the outq count. */
1297 outq
= PENDING_OUTPUT_COUNT (stdout
);
1300 if (baud_rate
<= outq
&& baud_rate
> 0)
1301 sleep (outq
/ baud_rate
);
1304 if ((i
- 1) % preempt_count
== 0)
1305 detect_input_pending ();
1309 #ifdef HAVE_X_WINDOWS
1312 current_frame
->top_left_y
[i
] = downto
;
1313 current_frame
->top_left_x
[i
] = leftmost
;
1315 #endif /* HAVE_X_WINDOWS */
1318 #ifdef HAVE_X_WINDOWS
1320 downto
+= current_frame
->pix_height
[i
];
1323 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
1325 /* Now just clean up termcap drivers and set cursor, etc. */
1328 if (cursor_in_echo_area
1329 && FRAME_HAS_MINIBUF_P (f
)
1330 && EQ (FRAME_MINIBUF_WINDOW (f
), minibuf_window
))
1332 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
1335 if (cursor_in_echo_area
< 0)
1342 /* If the minibuffer is several lines high, find the last
1343 line that has any text on it. */
1344 row
= FRAME_HEIGHT (f
);
1348 if (current_frame
->enable
[row
])
1349 col
= current_frame
->used
[row
];
1353 while (row
> top
&& col
== 0);
1355 if (col
>= FRAME_WIDTH (f
))
1358 if (row
< FRAME_HEIGHT (f
) - 1)
1363 cursor_to (row
, col
);
1366 cursor_to (FRAME_CURSOR_Y (f
), max (min (FRAME_CURSOR_X (f
),
1367 FRAME_WIDTH (f
) - 1), 0));
1373 fflush (termscript
);
1376 /* Here if output is preempted because input is detected. */
1379 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1380 display_completed
= !pause
;
1382 bzero (FRAME_DESIRED_GLYPHS (f
)->enable
, FRAME_HEIGHT (f
));
1386 /* Called when about to quit, to check for doing so
1387 at an improper time. */
1392 if (FRAME_DESIRED_GLYPHS (selected_frame
) == 0)
1394 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[0])
1396 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[FRAME_HEIGHT (selected_frame
) - 1])
1400 /* Decide what insert/delete line to do, and do it */
1402 extern void scrolling_1 ();
1407 int unchanged_at_top
, unchanged_at_bottom
;
1410 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1411 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1412 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1413 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1415 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
1416 register struct frame_glyphs
*current_frame
= FRAME_CURRENT_GLYPHS (frame
);
1417 register struct frame_glyphs
*desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
1419 /* Compute hash codes of all the lines.
1420 Also calculate number of changed lines,
1421 number of unchanged lines at the beginning,
1422 and number of unchanged lines at the end. */
1425 unchanged_at_top
= 0;
1426 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
1427 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
1429 /* Give up on this scrolling if some old lines are not enabled. */
1430 if (!current_frame
->enable
[i
])
1432 old_hash
[i
] = line_hash_code (current_frame
, i
);
1433 if (! desired_frame
->enable
[i
])
1434 new_hash
[i
] = old_hash
[i
];
1436 new_hash
[i
] = line_hash_code (desired_frame
, i
);
1438 if (old_hash
[i
] != new_hash
[i
])
1441 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
1443 else if (i
== unchanged_at_top
)
1445 draw_cost
[i
] = line_draw_cost (desired_frame
, i
);
1446 old_draw_cost
[i
] = line_draw_cost (current_frame
, i
);
1449 /* If changed lines are few, don't allow preemption, don't scroll. */
1450 if (!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400
1451 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
1454 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
1455 - unchanged_at_bottom
);
1457 if (scroll_region_ok
)
1458 free_at_end_vpos
-= unchanged_at_bottom
;
1459 else if (memory_below_frame
)
1460 free_at_end_vpos
= -1;
1462 /* If large window, fast terminal and few lines in common between
1463 current frame and desired frame, don't bother with i/d calc. */
1464 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
1466 10 * scrolling_max_lines_saved (unchanged_at_top
,
1467 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
1468 old_hash
, new_hash
, draw_cost
)))
1471 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
1472 draw_cost
+ unchanged_at_top
- 1,
1473 old_draw_cost
+ unchanged_at_top
- 1,
1474 old_hash
+ unchanged_at_top
- 1,
1475 new_hash
+ unchanged_at_top
- 1,
1476 free_at_end_vpos
- unchanged_at_top
);
1481 /* Return the offset in its buffer of the character at location col, line
1482 in the given window. */
1484 buffer_posn_from_coords (window
, col
, line
)
1485 struct window
*window
;
1488 int hscroll
= XINT (window
->hscroll
);
1489 int window_left
= XFASTINT (window
->left
);
1491 /* The actual width of the window is window->width less one for the
1492 DISP_CONTINUE_GLYPH, and less one if it's not the rightmost
1494 int window_width
= window_internal_width (window
) - 1;
1496 int startp
= marker_position (window
->start
);
1498 /* Since compute_motion will only operate on the current buffer,
1499 we need to save the old one and restore it when we're done. */
1500 struct buffer
*old_current_buffer
= current_buffer
;
1501 struct position
*posn
;
1503 current_buffer
= XBUFFER (window
->buffer
);
1505 /* It would be nice if we could use FRAME_CURRENT_GLYPHS (XFRAME
1506 (window->frame))->bufp to avoid scanning from the very top of
1507 the window, but it isn't maintained correctly, and I'm not even
1508 sure I will keep it. */
1509 posn
= compute_motion (startp
, 0,
1510 (window
== XWINDOW (minibuf_window
) && startp
== 1
1511 ? minibuf_prompt_width
: 0)
1512 + (hscroll
? 1 - hscroll
: 0),
1514 window_width
, hscroll
, 0, window
);
1516 current_buffer
= old_current_buffer
;
1518 /* compute_motion considers frame points past the end of a line
1519 to be *after* the newline, i.e. at the start of the next line.
1520 This is reasonable, but not really what we want. So if the
1521 result is on a line below LINE, back it up one character. */
1522 if (posn
->vpos
> line
)
1523 return posn
->bufpos
- 1;
1525 return posn
->bufpos
;
1532 register GLYPH
*p
= r
;
1533 while (*p
++ == SPACEGLYPH
);
1538 count_match (str1
, str2
)
1541 register GLYPH
*p1
= str1
;
1542 register GLYPH
*p2
= str2
;
1543 while (*p1
++ == *p2
++);
1544 return p1
- str1
- 1;
1547 /* Char insertion/deletion cost vector, from term.c */
1548 extern int *char_ins_del_vector
;
1550 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WIDTH((f))])
1553 update_line (frame
, vpos
)
1554 register FRAME_PTR frame
;
1557 register GLYPH
*obody
, *nbody
, *op1
, *op2
, *np1
, *temp
;
1560 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
1562 register struct frame_glyphs
*current_frame
1563 = FRAME_CURRENT_GLYPHS (frame
);
1564 register struct frame_glyphs
*desired_frame
1565 = FRAME_DESIRED_GLYPHS (frame
);
1567 if (desired_frame
->highlight
[vpos
]
1568 != (current_frame
->enable
[vpos
] && current_frame
->highlight
[vpos
]))
1570 change_line_highlight (desired_frame
->highlight
[vpos
], vpos
,
1571 (current_frame
->enable
[vpos
] ?
1572 current_frame
->used
[vpos
] : 0));
1573 current_frame
->enable
[vpos
] = 0;
1576 reassert_line_highlight (desired_frame
->highlight
[vpos
], vpos
);
1578 if (! current_frame
->enable
[vpos
])
1584 obody
= current_frame
->glyphs
[vpos
];
1585 olen
= current_frame
->used
[vpos
];
1586 if (! current_frame
->highlight
[vpos
])
1588 if (!must_write_spaces
)
1589 while (obody
[olen
- 1] == SPACEGLYPH
&& olen
> 0)
1594 /* For an inverse-video line, remember we gave it
1595 spaces all the way to the frame edge
1596 so that the reverse video extends all the way across. */
1598 while (olen
< FRAME_WIDTH (frame
) - 1)
1599 obody
[olen
++] = SPACEGLYPH
;
1603 /* One way or another, this will enable the line being updated. */
1604 current_frame
->enable
[vpos
] = 1;
1605 current_frame
->used
[vpos
] = desired_frame
->used
[vpos
];
1606 current_frame
->highlight
[vpos
] = desired_frame
->highlight
[vpos
];
1607 current_frame
->bufp
[vpos
] = desired_frame
->bufp
[vpos
];
1609 #ifdef HAVE_X_WINDOWS
1610 if (FRAME_X_P (frame
))
1612 current_frame
->pix_width
[vpos
]
1613 = current_frame
->used
[vpos
]
1614 * FONT_WIDTH (frame
->display
.x
->font
);
1615 current_frame
->pix_height
[vpos
]
1616 = frame
->display
.x
->line_height
;
1618 #endif /* HAVE_X_WINDOWS */
1620 if (!desired_frame
->enable
[vpos
])
1626 nbody
= desired_frame
->glyphs
[vpos
];
1627 nlen
= desired_frame
->used
[vpos
];
1629 /* Pretend trailing spaces are not there at all,
1630 unless for one reason or another we must write all spaces. */
1631 if (! desired_frame
->highlight
[vpos
])
1633 if (!must_write_spaces
)
1634 /* We know that the previous character byte contains 0. */
1635 while (nbody
[nlen
- 1] == SPACEGLYPH
)
1640 /* For an inverse-video line, give it extra trailing spaces
1641 all the way to the frame edge
1642 so that the reverse video extends all the way across. */
1644 while (nlen
< FRAME_WIDTH (frame
) - 1)
1645 nbody
[nlen
++] = SPACEGLYPH
;
1648 /* If there's no i/d char, quickly do the best we can without it. */
1649 if (!char_ins_del_ok
)
1654 if (FRAME_X_P (frame
))
1656 /* Under X, erase everything we are going to rewrite,
1657 and rewrite everything from the first char that's changed.
1658 This is part of supporting fonts like Courier
1659 whose chars can overlap outside the char width. */
1660 for (i
= 0; i
< nlen
; i
++)
1661 if (i
>= olen
|| nbody
[i
] != obody
[i
])
1664 cursor_to (vpos
, i
);
1666 clear_end_of_line (olen
);
1667 write_glyphs (nbody
+ i
, nlen
- i
);
1672 for (i
= 0; i
< nlen
; i
++)
1674 if (i
>= olen
|| nbody
[i
] != obody
[i
]) /* A non-matching char. */
1676 cursor_to (vpos
, i
);
1677 for (j
= 1; (i
+ j
< nlen
&&
1678 (i
+ j
>= olen
|| nbody
[i
+j
] != obody
[i
+j
]));
1681 /* Output this run of non-matching chars. */
1682 write_glyphs (nbody
+ i
, j
);
1685 /* Now find the next non-match. */
1689 /* Clear the rest of the line, or the non-clear part of it. */
1692 cursor_to (vpos
, nlen
);
1693 clear_end_of_line (olen
);
1696 /* Exchange contents between current_frame and new_frame. */
1697 temp
= desired_frame
->glyphs
[vpos
];
1698 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1699 current_frame
->glyphs
[vpos
] = temp
;
1701 /* Exchange charstarts between current_frame and new_frame. */
1702 temp1
= desired_frame
->charstarts
[vpos
];
1703 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1704 current_frame
->charstarts
[vpos
] = temp1
;
1711 nsp
= (must_write_spaces
|| desired_frame
->highlight
[vpos
])
1712 ? 0 : count_blanks (nbody
);
1715 cursor_to (vpos
, nsp
);
1716 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
1719 /* Exchange contents between current_frame and new_frame. */
1720 temp
= desired_frame
->glyphs
[vpos
];
1721 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1722 current_frame
->glyphs
[vpos
] = temp
;
1724 /* Exchange charstarts between current_frame and new_frame. */
1725 temp1
= desired_frame
->charstarts
[vpos
];
1726 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1727 current_frame
->charstarts
[vpos
] = temp1
;
1736 /* Compute number of leading blanks in old and new contents. */
1737 osp
= count_blanks (obody
);
1738 if (!desired_frame
->highlight
[vpos
])
1739 nsp
= count_blanks (nbody
);
1743 /* Compute number of matching chars starting with first nonblank. */
1744 begmatch
= count_match (obody
+ osp
, nbody
+ nsp
);
1746 /* Spaces in new match implicit space past the end of old. */
1747 /* A bug causing this to be a no-op was fixed in 18.29. */
1748 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
1751 while (np1
[begmatch
] == SPACEGLYPH
)
1755 /* Avoid doing insert/delete char
1756 just cause number of leading spaces differs
1757 when the following text does not match. */
1758 if (begmatch
== 0 && osp
!= nsp
)
1759 osp
= nsp
= min (osp
, nsp
);
1761 /* Find matching characters at end of line */
1764 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
1765 while (op1
> op2
&& op1
[-1] == np1
[-1])
1770 endmatch
= obody
+ olen
- op1
;
1772 /* Put correct value back in nbody[nlen].
1773 This is important because direct_output_for_insert
1774 can write into the line at a later point.
1775 If this screws up the zero at the end of the line, re-establish it. */
1779 /* tem gets the distance to insert or delete.
1780 endmatch is how many characters we save by doing so.
1783 tem
= (nlen
- nsp
) - (olen
- osp
);
1785 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
1788 /* nsp - osp is the distance to insert or delete.
1789 If that is nonzero, begmatch is known to be nonzero also.
1790 begmatch + endmatch is how much we save by doing the ins/del.
1794 && (!char_ins_del_ok
1795 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
1799 osp
= nsp
= min (osp
, nsp
);
1802 /* Now go through the line, inserting, writing and
1803 deleting as appropriate. */
1807 cursor_to (vpos
, nsp
);
1808 delete_glyphs (osp
- nsp
);
1812 /* If going to delete chars later in line
1813 and insert earlier in the line,
1814 must delete first to avoid losing data in the insert */
1815 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
1817 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
1818 delete_glyphs (olen
+ nsp
- osp
- nlen
);
1819 olen
= nlen
- (nsp
- osp
);
1821 cursor_to (vpos
, osp
);
1822 insert_glyphs ((char *)0, nsp
- osp
);
1826 tem
= nsp
+ begmatch
+ endmatch
;
1827 if (nlen
!= tem
|| olen
!= tem
)
1829 cursor_to (vpos
, nsp
+ begmatch
);
1830 if (!endmatch
|| nlen
== olen
)
1832 /* If new text being written reaches right margin,
1833 there is no need to do clear-to-eol at the end.
1834 (and it would not be safe, since cursor is not
1835 going to be "at the margin" after the text is done) */
1836 if (nlen
== FRAME_WIDTH (frame
))
1838 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1842 /* the following code loses disastrously if tem == nlen.
1843 Rather than trying to fix that case, I am trying the simpler
1844 solution found above. */
1846 /* If the text reaches to the right margin,
1847 it will lose one way or another (depending on AutoWrap)
1848 to clear to end of line after outputting all the text.
1849 So pause with one character to go and clear the line then. */
1850 if (nlen
== FRAME_WIDTH (frame
) && fast_clear_end_of_line
&& olen
> nlen
)
1852 /* endmatch must be zero, and tem must equal nsp + begmatch */
1853 write_glyphs (nbody
+ tem
, nlen
- tem
- 1);
1854 clear_end_of_line (olen
);
1855 olen
= 0; /* Don't let it be cleared again later */
1856 write_glyphs (nbody
+ nlen
- 1, 1);
1859 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1860 #endif /* OBSOLETE */
1863 else if (nlen
> olen
)
1865 write_glyphs (nbody
+ nsp
+ begmatch
, olen
- tem
);
1866 insert_glyphs (nbody
+ nsp
+ begmatch
+ olen
- tem
, nlen
- olen
);
1869 else if (olen
> nlen
)
1871 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1872 delete_glyphs (olen
- nlen
);
1878 /* If any unerased characters remain after the new line, erase them. */
1881 cursor_to (vpos
, nlen
);
1882 clear_end_of_line (olen
);
1885 /* Exchange contents between current_frame and new_frame. */
1886 temp
= desired_frame
->glyphs
[vpos
];
1887 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1888 current_frame
->glyphs
[vpos
] = temp
;
1890 /* Exchange charstarts between current_frame and new_frame. */
1891 temp1
= desired_frame
->charstarts
[vpos
];
1892 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1893 current_frame
->charstarts
[vpos
] = temp1
;
1896 /* A vector of size >= NFRAMES + 3 * NBUFFERS + 1, containing the session's
1897 frames, buffers, buffer-read-only flags, and buffer-modified-flags,
1898 and a trailing sentinel (so we don't need to add length checks). */
1899 static Lisp_Object frame_and_buffer_state
;
1901 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
1902 Sframe_or_buffer_changed_p
, 0, 0, 0,
1903 "Return non-nil if the frame and buffer state appears to have changed.\n\
1904 The state variable is an internal vector containing all frames and buffers,\n\
1905 aside from buffers whose names start with space,\n\
1906 along with the buffers' read-only and modified flags, which allows a fast\n\
1907 check to see whether the menu bars might need to be recomputed.\n\
1908 If this function returns non-nil, it updates the internal vector to reflect\n\
1909 the current state.\n")
1912 Lisp_Object tail
, frame
, buf
;
1915 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
1916 FOR_EACH_FRAME (tail
, frame
)
1917 if (!EQ (*vecp
++, frame
))
1919 /* Check that the buffer info matches.
1920 No need to test for the end of the vector
1921 because the last element of the vector is lambda
1922 and that will always cause a mismatch. */
1923 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1925 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
1926 /* Ignore buffers that aren't included in buffer lists. */
1927 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
1929 if (!EQ (*vecp
++, buf
))
1931 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
1933 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
1936 /* Detect deletion of a buffer at the end of the list. */
1937 if (*vecp
== Qlambda
)
1940 /* Start with 1 so there is room for at least one lambda at the end. */
1942 FOR_EACH_FRAME (tail
, frame
)
1944 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1946 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
1947 if (n
> XVECTOR (frame_and_buffer_state
)->size
1948 || n
< XVECTOR (frame_and_buffer_state
)->size
/ 2)
1949 frame_and_buffer_state
= Fmake_vector (make_number (n
), Qlambda
);
1950 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
1951 FOR_EACH_FRAME (tail
, frame
)
1953 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1955 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
1956 /* Ignore buffers that aren't included in buffer lists. */
1957 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
1960 *vecp
++ = XBUFFER (buf
)->read_only
;
1961 *vecp
++ = Fbuffer_modified_p (buf
);
1963 /* If we left any slack in the vector, fill it up now. */
1964 for (; n
< XVECTOR (frame_and_buffer_state
)->size
; ++n
)
1969 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
1970 1, 1, "FOpen termscript file: ",
1971 "Start writing all terminal output to FILE as well as the terminal.\n\
1972 FILE = nil means just close any termscript file currently open.")
1976 if (termscript
!= 0) fclose (termscript
);
1981 file
= Fexpand_file_name (file
, Qnil
);
1982 termscript
= fopen (XSTRING (file
)->data
, "w");
1983 if (termscript
== 0)
1984 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
1992 window_change_signal (signalnum
) /* If we don't have an argument, */
1993 int signalnum
; /* some compilers complain in signal calls. */
1997 int old_errno
= errno
;
1999 get_frame_size (&width
, &height
);
2001 /* The frame size change obviously applies to a termcap-controlled
2002 frame. Find such a frame in the list, and assume it's the only
2003 one (since the redisplay code always writes to stdout, not a
2004 FILE * specified in the frame structure). Record the new size,
2005 but don't reallocate the data structures now. Let that be done
2006 later outside of the signal handler. */
2009 Lisp_Object tail
, frame
;
2011 FOR_EACH_FRAME (tail
, frame
)
2013 if (FRAME_TERMCAP_P (XFRAME (frame
)))
2015 change_frame_size (XFRAME (frame
), height
, width
, 0, 1);
2021 signal (SIGWINCH
, window_change_signal
);
2024 #endif /* SIGWINCH */
2027 /* Do any change in frame size that was requested by a signal. */
2029 do_pending_window_change ()
2031 /* If window_change_signal should have run before, run it now. */
2032 while (delayed_size_change
)
2034 Lisp_Object tail
, frame
;
2036 delayed_size_change
= 0;
2038 FOR_EACH_FRAME (tail
, frame
)
2040 FRAME_PTR f
= XFRAME (frame
);
2042 int height
= FRAME_NEW_HEIGHT (f
);
2043 int width
= FRAME_NEW_WIDTH (f
);
2045 if (height
!= 0 || width
!= 0)
2046 change_frame_size (f
, height
, width
, 0, 0);
2052 /* Change the frame height and/or width. Values may be given as zero to
2053 indicate no change is to take place.
2055 If DELAY is non-zero, then assume we're being called from a signal
2056 handler, and queue the change for later - perhaps the next
2057 redisplay. Since this tries to resize windows, we can't call it
2058 from a signal handler. */
2060 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
)
2061 register FRAME_PTR f
;
2062 int newheight
, newwidth
, pretend
;
2064 Lisp_Object tail
, frame
;
2065 if (FRAME_TERMCAP_P (f
))
2067 /* When using termcap, all frames use the same screen,
2068 so a change in size affects all termcap frames. */
2069 FOR_EACH_FRAME (tail
, frame
)
2070 if (FRAME_TERMCAP_P (XFRAME (frame
)))
2071 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
2075 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
);
2079 change_frame_size_1 (frame
, newheight
, newwidth
, pretend
, delay
)
2080 register FRAME_PTR frame
;
2081 int newheight
, newwidth
, pretend
;
2083 /* If we can't deal with the change now, queue it for later. */
2086 FRAME_NEW_HEIGHT (frame
) = newheight
;
2087 FRAME_NEW_WIDTH (frame
) = newwidth
;
2088 delayed_size_change
= 1;
2092 /* This size-change overrides any pending one for this frame. */
2093 FRAME_NEW_HEIGHT (frame
) = 0;
2094 FRAME_NEW_WIDTH (frame
) = 0;
2096 /* If an argument is zero, set it to the current value. */
2097 newheight
|| (newheight
= FRAME_HEIGHT (frame
));
2098 newwidth
|| (newwidth
= FRAME_WIDTH (frame
));
2100 /* Round up to the smallest acceptable size. */
2101 check_frame_size (frame
, &newheight
, &newwidth
);
2103 /* If we're not changing the frame size, quit now. */
2104 if (newheight
== FRAME_HEIGHT (frame
)
2105 && newwidth
== FRAME_WIDTH (frame
))
2108 if (newheight
!= FRAME_HEIGHT (frame
))
2110 if (FRAME_HAS_MINIBUF_P (frame
)
2111 && ! FRAME_MINIBUF_ONLY_P (frame
))
2113 /* Frame has both root and minibuffer. */
2114 set_window_height (FRAME_ROOT_WINDOW (frame
),
2115 newheight
- 1 - FRAME_MENU_BAR_LINES (frame
), 0);
2116 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (frame
))->top
,
2118 set_window_height (FRAME_MINIBUF_WINDOW (frame
), 1, 0);
2121 /* Frame has just one top-level window. */
2122 set_window_height (FRAME_ROOT_WINDOW (frame
),
2123 newheight
- FRAME_MENU_BAR_LINES (frame
), 0);
2125 if (FRAME_TERMCAP_P (frame
) && !pretend
)
2126 FrameRows
= newheight
;
2129 if (frame
->output_method
== output_termcap
)
2131 frame_height
= newheight
;
2133 FrameRows
= newheight
;
2138 if (newwidth
!= FRAME_WIDTH (frame
))
2140 set_window_width (FRAME_ROOT_WINDOW (frame
), newwidth
, 0);
2141 if (FRAME_HAS_MINIBUF_P (frame
))
2142 set_window_width (FRAME_MINIBUF_WINDOW (frame
), newwidth
, 0);
2144 if (FRAME_TERMCAP_P (frame
) && !pretend
)
2145 FrameCols
= newwidth
;
2147 if (frame
->output_method
== output_termcap
)
2149 frame_width
= newwidth
;
2151 FrameCols
= newwidth
;
2156 FRAME_HEIGHT (frame
) = newheight
;
2157 FRAME_WIDTH (frame
) = newwidth
;
2159 if (FRAME_CURSOR_X (frame
) >= FRAME_WIDTH (frame
))
2160 FRAME_CURSOR_X (frame
) = FRAME_WIDTH (frame
) - 1;
2161 if (FRAME_CURSOR_Y (frame
) >= FRAME_HEIGHT (frame
))
2162 FRAME_CURSOR_Y (frame
) = FRAME_HEIGHT (frame
) - 1;
2164 remake_frame_glyphs (frame
);
2165 calculate_costs (frame
);
2168 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
2169 Ssend_string_to_terminal
, 1, 1, 0,
2170 "Send STRING to the terminal without alteration.\n\
2171 Control characters in STRING will have terminal-dependent effects.")
2175 CHECK_STRING (str
, 0);
2176 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, stdout
);
2180 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, termscript
);
2181 fflush (termscript
);
2186 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
2187 "Beep, or flash the screen.\n\
2188 Also, unless an argument is given,\n\
2189 terminate any keyboard macro currently executing.")
2211 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
2212 error ("Keyboard macro terminated by a command ringing the bell");
2218 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
2219 "Pause, without updating display, for SECONDS seconds.\n\
2220 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2221 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2222 additional wait period, in milliseconds; this may be useful if your\n\
2223 Emacs was built without floating point support.\n\
2224 \(Not all operating systems support waiting for a fraction of a second.)")
2225 (seconds
, milliseconds
)
2226 Lisp_Object seconds
, milliseconds
;
2230 if (NILP (milliseconds
))
2231 XSETINT (milliseconds
, 0);
2233 CHECK_NUMBER (milliseconds
, 1);
2234 usec
= XINT (milliseconds
) * 1000;
2236 #ifdef LISP_FLOAT_TYPE
2238 double duration
= extract_float (seconds
);
2239 sec
= (int) duration
;
2240 usec
+= (duration
- sec
) * 1000000;
2243 CHECK_NUMBER (seconds
, 0);
2244 sec
= XINT (seconds
);
2247 #ifndef EMACS_HAS_USECS
2248 if (sec
== 0 && usec
!= 0)
2249 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
2252 /* Assure that 0 <= usec < 1000000. */
2255 /* We can't rely on the rounding being correct if user is negative. */
2256 if (-1000000 < usec
)
2257 sec
--, usec
+= 1000000;
2259 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
2262 sec
+= usec
/ 1000000, usec
%= 1000000;
2270 XSETFASTINT (zero
, 0);
2271 wait_reading_process_input (sec
, usec
, zero
, 0);
2274 /* We should always have wait_reading_process_input; we have a dummy
2275 implementation for systems which don't support subprocesses. */
2277 /* No wait_reading_process_input */
2284 /* The reason this is done this way
2285 (rather than defined (H_S) && defined (H_T))
2286 is because the VMS preprocessor doesn't grok `defined' */
2288 EMACS_GET_TIME (end_time
);
2289 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
2290 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
2294 EMACS_GET_TIME (timeout
);
2295 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
2296 if (EMACS_TIME_NEG_P (timeout
)
2297 || !select (1, 0, 0, 0, &timeout
))
2300 #else /* not HAVE_SELECT */
2302 #endif /* HAVE_SELECT */
2303 #endif /* not VMS */
2306 #endif /* no subprocesses */
2311 /* This is just like wait_reading_process_input, except that
2312 it does the redisplay.
2314 It's also much like Fsit_for, except that it can be used for
2315 waiting for input as well. */
2318 sit_for (sec
, usec
, reading
, display
)
2319 int sec
, usec
, reading
, display
;
2321 Lisp_Object read_kbd
;
2323 if (detect_input_pending ())
2327 redisplay_preserve_echo_area ();
2329 if (sec
== 0 && usec
== 0)
2336 XSETINT (read_kbd
, reading
? -1 : 1);
2337 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
2340 /* wait_reading_process_input should always be available now; it is
2341 simulated in a simple way on systems that don't support
2344 /* No wait_reading_process_input available. */
2350 input_wait_timeout (XINT (arg
));
2352 #ifndef HAVE_TIMEVAL
2354 select (1, &waitchannels
, 0, 0, &timeout_sec
);
2355 #else /* HAVE_TIMEVAL */
2356 timeout
.tv_sec
= sec
;
2357 timeout
.tv_usec
= usec
;
2358 select (1, &waitchannels
, 0, 0, &timeout
);
2359 #endif /* HAVE_TIMEVAL */
2360 #endif /* not VMS */
2365 return detect_input_pending () ? Qnil
: Qt
;
2368 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
2369 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
2370 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2371 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2372 additional wait period, in milliseconds; this may be useful if your\n\
2373 Emacs was built without floating point support.\n\
2374 \(Not all operating systems support waiting for a fraction of a second.)\n\
2375 Optional third arg non-nil means don't redisplay, just wait for input.\n\
2376 Redisplay is preempted as always if input arrives, and does not happen\n\
2377 if input is available before it starts.\n\
2378 Value is t if waited the full time with no input arriving.")
2379 (seconds
, milliseconds
, nodisp
)
2380 Lisp_Object seconds
, milliseconds
, nodisp
;
2384 if (NILP (milliseconds
))
2385 XSETINT (milliseconds
, 0);
2387 CHECK_NUMBER (milliseconds
, 1);
2388 usec
= XINT (milliseconds
) * 1000;
2390 #ifdef LISP_FLOAT_TYPE
2392 double duration
= extract_float (seconds
);
2393 sec
= (int) duration
;
2394 usec
+= (duration
- sec
) * 1000000;
2397 CHECK_NUMBER (seconds
, 0);
2398 sec
= XINT (seconds
);
2401 #ifndef EMACS_HAS_USECS
2402 if (usec
!= 0 && sec
== 0)
2403 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
2407 prepare_menu_bars ();
2408 return sit_for (sec
, usec
, 0, NILP (nodisp
));
2411 char *terminal_type
;
2413 /* Initialization done when Emacs fork is started, before doing stty. */
2414 /* Determine terminal type and set terminal_driver */
2415 /* Then invoke its decoding routine to set up variables
2416 in the terminal package */
2420 #ifdef HAVE_X_WINDOWS
2421 extern int display_arg
;
2426 cursor_in_echo_area
= 0;
2427 terminal_type
= (char *) 0;
2429 /* Now is the time to initialize this; it's used by init_sys_modes
2431 Vwindow_system
= Qnil
;
2433 /* If the user wants to use a window system, we shouldn't bother
2434 initializing the terminal. This is especially important when the
2435 terminal is so dumb that emacs gives up before and doesn't bother
2436 using the window system.
2438 If the DISPLAY environment variable is set, try to use X, and die
2439 with an error message if that doesn't work. */
2441 #ifdef HAVE_X_WINDOWS
2445 display_arg
= (getenv ("DECW$DISPLAY") != 0);
2447 display_arg
= (getenv ("DISPLAY") != 0);
2451 if (!inhibit_window_system
&& display_arg
)
2453 Vwindow_system
= intern ("x");
2455 Vwindow_system_version
= make_number (11);
2457 Vwindow_system_version
= make_number (10);
2461 #endif /* HAVE_X_WINDOWS */
2463 /* If no window system has been specified, try to use the terminal. */
2466 fprintf (stderr
, "emacs: standard input is not a tty\n");
2470 /* Look at the TERM variable */
2471 terminal_type
= (char *) getenv ("TERM");
2475 fprintf (stderr
, "Please specify your terminal type.\n\
2476 For types defined in VMS, use set term /device=TYPE.\n\
2477 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
2478 \(The quotation marks are necessary since terminal types are lower case.)\n");
2480 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
2486 /* VMS DCL tends to upcase things, so downcase term type.
2487 Hardly any uppercase letters in terminal types; should be none. */
2489 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
2492 strcpy (new, terminal_type
);
2494 for (p
= new; *p
; p
++)
2498 terminal_type
= new;
2502 term_init (terminal_type
);
2504 remake_frame_glyphs (selected_frame
);
2505 calculate_costs (selected_frame
);
2507 /* X and Y coordinates of the cursor between updates. */
2508 FRAME_CURSOR_X (selected_frame
) = 0;
2509 FRAME_CURSOR_Y (selected_frame
) = 0;
2514 #endif /* CANNOT_DUMP */
2515 signal (SIGWINCH
, window_change_signal
);
2516 #endif /* SIGWINCH */
2522 defsubr (&Sredraw_frame
);
2524 defsubr (&Sredraw_display
);
2525 defsubr (&Sframe_or_buffer_changed_p
);
2526 defsubr (&Sopen_termscript
);
2528 defsubr (&Ssit_for
);
2529 defsubr (&Ssleep_for
);
2530 defsubr (&Ssend_string_to_terminal
);
2532 frame_and_buffer_state
= Fmake_vector (make_number (1), Qlambda
);
2533 staticpro (&frame_and_buffer_state
);
2535 DEFVAR_INT ("baud-rate", &baud_rate
,
2536 "*The output baud rate of the terminal.\n\
2537 On most systems, changing this value will affect the amount of padding\n\
2538 and the other strategic decisions made during redisplay.");
2539 DEFVAR_BOOL ("inverse-video", &inverse_video
,
2540 "*Non-nil means invert the entire frame display.\n\
2541 This means everything is in inverse video which otherwise would not be.");
2542 DEFVAR_BOOL ("visible-bell", &visible_bell
,
2543 "*Non-nil means try to flash the frame to represent a bell.");
2544 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
2545 "*Non-nil means no need to redraw entire frame after suspending.\n\
2546 A non-nil value is useful if the terminal can automatically preserve\n\
2547 Emacs's frame display when you reenter Emacs.\n\
2548 It is up to you to set this variable if your terminal can do that.");
2549 DEFVAR_LISP ("window-system", &Vwindow_system
,
2550 "A symbol naming the window-system under which Emacs is running\n\
2551 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
2552 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
2553 "The version number of the window system in use.\n\
2554 For X windows, this is 10 or 11.");
2555 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
2556 "Non-nil means put cursor in minibuffer, at end of any message there.");
2557 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
2558 "Table defining how to output a glyph code to the frame.\n\
2559 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
2560 Each element can be:\n\
2561 integer: a glyph code which this glyph is an alias for.\n\
2562 string: output this glyph using that string (not impl. in X windows).\n\
2563 nil: this glyph mod 256 is char code to output,\n\
2564 and this glyph / 256 is face code for X windows (see `face-id').");
2565 Vglyph_table
= Qnil
;
2567 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
2568 "Display table to use for buffers that specify none.\n\
2569 See `buffer-display-table' for more information.");
2570 Vstandard_display_table
= Qnil
;
2572 /* Initialize `window-system', unless init_display already decided it. */
2577 Vwindow_system
= Qnil
;
2578 Vwindow_system_version
= Qnil
;