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"
43 #include "syssignal.h"
47 #endif /* HAVE_X_WINDOWS */
49 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
54 #define max(a, b) ((a) > (b) ? (a) : (b))
55 #define min(a, b) ((a) < (b) ? (a) : (b))
57 /* Get number of chars of output now in the buffer of a stdio stream.
58 This ought to be built in in stdio, but it isn't.
59 Some s- files override this because their stdio internals differ. */
60 #ifdef __GNU_LIBRARY__
61 /* The s- file might have overridden the definition with one that works for
62 the system's C library. But we are using the GNU C library, so this is
63 the right definition for every system. */
64 #ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT
65 #define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT
67 #undef PENDING_OUTPUT_COUNT
68 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
70 #else /* not __GNU_LIBRARY__ */
71 #ifndef PENDING_OUTPUT_COUNT
72 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
76 static void change_frame_size_1 ();
78 /* Nonzero upon entry to redisplay means do not assume anything about
79 current contents of actual terminal frame; clear and redraw it. */
83 /* Nonzero means last display completed. Zero means it was preempted. */
85 int display_completed
;
87 /* Lisp variable visible-bell; enables use of screen-flash
88 instead of audible bell. */
92 /* Invert the color of the whole frame, at a low level. */
96 /* Line speed of the terminal. */
100 /* nil or a symbol naming the window system under which emacs is
101 running ('x is the only current possibility). */
103 Lisp_Object Vwindow_system
;
105 /* Version number of X windows: 10, 11 or nil. */
106 Lisp_Object Vwindow_system_version
;
108 /* Vector of glyph definitions. Indexed by glyph number,
109 the contents are a string which is how to output the glyph.
111 If Vglyph_table is nil, a glyph is output by using its low 8 bits
112 as a character code. */
114 Lisp_Object Vglyph_table
;
116 /* Display table to use for vectors that don't specify their own. */
118 Lisp_Object Vstandard_display_table
;
120 /* Nonzero means reading single-character input with prompt
121 so put cursor on minibuffer after the prompt.
122 positive means at end of text in echo area;
123 negative means at beginning of line. */
124 int cursor_in_echo_area
;
126 /* The currently selected frame.
127 In a single-frame version, this variable always holds the address of
130 FRAME_PTR selected_frame
;
132 /* A frame which is not just a minibuffer, or 0 if there are no such
133 frames. This is usually the most recent such frame that was
134 selected. In a single-frame version, this variable always holds
135 the address of the_only_frame. */
136 FRAME_PTR last_nonminibuf_frame
;
138 /* In a single-frame version, the information that would otherwise
139 exist inside frame objects lives in the following structure instead.
141 NOTE: the_only_frame is not checked for garbage collection; don't
142 store collectible objects in any of its fields!
144 You're not/The only frame in town/... */
147 struct frame the_only_frame
;
150 /* This is a vector, made larger whenever it isn't large enough,
151 which is used inside `update_frame' to hold the old contents
152 of the FRAME_PHYS_LINES of the frame being updated. */
153 struct frame_glyphs
**ophys_lines
;
154 /* Length of vector currently allocated. */
155 int ophys_lines_length
;
157 FILE *termscript
; /* Stdio stream being used for copy of all output. */
159 struct cm Wcm
; /* Structure for info on cursor positioning */
161 extern short ospeed
; /* Output speed (from sg_ospeed) */
163 int delayed_size_change
; /* 1 means SIGWINCH happened when not safe. */
167 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
168 "Clear frame FRAME and output again what is supposed to appear on it.")
174 CHECK_LIVE_FRAME (frame
, 0);
177 /* set_terminal_modes (); */
179 clear_frame_records (f
);
182 windows_or_buffers_changed
++;
183 /* Mark all windows as INaccurate,
184 so that every window will have its redisplay done. */
185 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
194 XSETFRAME (frame
, f
);
195 Fredraw_frame (frame
);
200 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
201 /* Don't confuse make-docfile by having two doc strings for this function.
202 make-docfile does not pay attention to #if, for good reason! */
208 set_terminal_modes ();
212 clear_frame_records (0);
213 windows_or_buffers_changed
++;
214 /* Mark all windows as INaccurate,
215 so that every window will have its redisplay done. */
216 mark_window_display_accurate (FRAME_ROOT_WINDOW (0), 0);
222 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
223 "Clear and redisplay all visible frames.")
226 Lisp_Object tail
, frame
;
228 FOR_EACH_FRAME (tail
, frame
)
229 if (FRAME_VISIBLE_P (XFRAME (frame
)))
230 Fredraw_frame (frame
);
235 /* This is used when frame_garbaged is set.
236 Redraw the individual frames marked as garbaged. */
239 redraw_garbaged_frames ()
241 Lisp_Object tail
, frame
;
243 FOR_EACH_FRAME (tail
, frame
)
244 if (FRAME_VISIBLE_P (XFRAME (frame
))
245 && FRAME_GARBAGED_P (XFRAME (frame
)))
246 Fredraw_frame (frame
);
250 static struct frame_glyphs
*
251 make_frame_glyphs (frame
, empty
)
252 register FRAME_PTR frame
;
256 register width
= FRAME_WIDTH (frame
);
257 register height
= FRAME_HEIGHT (frame
);
258 register struct frame_glyphs
*new
259 = (struct frame_glyphs
*) xmalloc (sizeof (struct frame_glyphs
));
261 SET_GLYPHS_FRAME (new, frame
);
262 new->height
= height
;
264 new->used
= (int *) xmalloc (height
* sizeof (int));
265 new->glyphs
= (GLYPH
**) xmalloc (height
* sizeof (GLYPH
*));
266 new->charstarts
= (int **) xmalloc (height
* sizeof (int *));
267 new->highlight
= (char *) xmalloc (height
* sizeof (char));
268 new->enable
= (char *) xmalloc (height
* sizeof (char));
269 bzero (new->enable
, height
* sizeof (char));
270 new->bufp
= (int *) xmalloc (height
* sizeof (int));
272 #ifdef HAVE_X_WINDOWS
273 if (FRAME_X_P (frame
))
275 new->top_left_x
= (short *) xmalloc (height
* sizeof (short));
276 new->top_left_y
= (short *) xmalloc (height
* sizeof (short));
277 new->pix_width
= (short *) xmalloc (height
* sizeof (short));
278 new->pix_height
= (short *) xmalloc (height
* sizeof (short));
279 new->max_ascent
= (short *) xmalloc (height
* sizeof (short));
285 /* Make the buffer used by decode_mode_spec. This buffer is also
286 used as temporary storage when updating the frame. See scroll.c. */
287 unsigned int total_glyphs
= (width
+ 2) * sizeof (GLYPH
);
288 unsigned int total_charstarts
= (width
+ 2) * sizeof (int);
290 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
291 bzero (new->total_contents
, total_glyphs
);
293 new->total_charstarts
= (int *) xmalloc (total_charstarts
);
294 bzero (new->total_charstarts
, total_glyphs
);
298 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (GLYPH
);
300 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
301 bzero (new->total_contents
, total_glyphs
);
302 for (i
= 0; i
< height
; i
++)
303 new->glyphs
[i
] = new->total_contents
+ i
* (width
+ 2) + 1;
305 if (!FRAME_TERMCAP_P (frame
))
307 unsigned int total_charstarts
= height
* (width
+ 2) * sizeof (int);
309 new->total_charstarts
= (int *) xmalloc (total_charstarts
);
310 bzero (new->total_charstarts
, total_charstarts
);
311 for (i
= 0; i
< height
; i
++)
312 new->charstarts
[i
] = new->total_charstarts
+ i
* (width
+ 2) + 1;
316 /* Without a window system, we don't really need charstarts.
317 So use a small amount of space to make enough data structure
318 to prevent crashes in display_text_line. */
319 new->total_charstarts
= (int *) xmalloc ((width
+ 2) * sizeof (int));
320 for (i
= 0; i
< height
; i
++)
321 new->charstarts
[i
] = new->total_charstarts
;
329 free_frame_glyphs (frame
, glyphs
)
331 struct frame_glyphs
*glyphs
;
333 if (glyphs
->total_contents
)
334 xfree (glyphs
->total_contents
);
335 if (glyphs
->total_charstarts
)
336 xfree (glyphs
->total_charstarts
);
338 xfree (glyphs
->used
);
339 xfree (glyphs
->glyphs
);
340 xfree (glyphs
->highlight
);
341 xfree (glyphs
->enable
);
342 xfree (glyphs
->bufp
);
343 if (glyphs
->charstarts
)
344 xfree (glyphs
->charstarts
);
346 #ifdef HAVE_X_WINDOWS
347 if (FRAME_X_P (frame
))
349 xfree (glyphs
->top_left_x
);
350 xfree (glyphs
->top_left_y
);
351 xfree (glyphs
->pix_width
);
352 xfree (glyphs
->pix_height
);
353 xfree (glyphs
->max_ascent
);
361 remake_frame_glyphs (frame
)
364 if (FRAME_CURRENT_GLYPHS (frame
))
365 free_frame_glyphs (frame
, FRAME_CURRENT_GLYPHS (frame
));
366 if (FRAME_DESIRED_GLYPHS (frame
))
367 free_frame_glyphs (frame
, FRAME_DESIRED_GLYPHS (frame
));
368 if (FRAME_TEMP_GLYPHS (frame
))
369 free_frame_glyphs (frame
, FRAME_TEMP_GLYPHS (frame
));
371 if (FRAME_MESSAGE_BUF (frame
))
373 /* Reallocate the frame's message buffer; remember that
374 echo_area_glyphs may be pointing here. */
375 char *old_message_buf
= FRAME_MESSAGE_BUF (frame
);
377 FRAME_MESSAGE_BUF (frame
)
378 = (char *) xrealloc (FRAME_MESSAGE_BUF (frame
),
379 FRAME_WIDTH (frame
) + 1);
381 if (echo_area_glyphs
== old_message_buf
)
382 echo_area_glyphs
= FRAME_MESSAGE_BUF (frame
);
383 if (previous_echo_glyphs
== old_message_buf
)
384 previous_echo_glyphs
= FRAME_MESSAGE_BUF (frame
);
387 FRAME_MESSAGE_BUF (frame
)
388 = (char *) xmalloc (FRAME_WIDTH (frame
) + 1);
390 FRAME_CURRENT_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
391 FRAME_DESIRED_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
392 FRAME_TEMP_GLYPHS (frame
) = make_frame_glyphs (frame
, 1);
393 if (! FRAME_TERMCAP_P (frame
) || frame
== selected_frame
)
394 SET_FRAME_GARBAGED (frame
);
397 /* Return the hash code of contents of line VPOS in frame-matrix M. */
400 line_hash_code (m
, vpos
)
401 register struct frame_glyphs
*m
;
404 register GLYPH
*body
, *end
;
407 if (!m
->enable
[vpos
])
410 /* Give all highlighted lines the same hash code
411 so as to encourage scrolling to leave them in place. */
412 if (m
->highlight
[vpos
])
415 body
= m
->glyphs
[vpos
];
417 if (must_write_spaces
)
424 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
- SPACEGLYPH
;
433 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
;
441 /* Return number of characters in line in M at vpos VPOS,
442 except don't count leading and trailing spaces
443 unless the terminal requires those to be explicitly output. */
446 line_draw_cost (m
, vpos
)
447 struct frame_glyphs
*m
;
450 register GLYPH
*beg
= m
->glyphs
[vpos
];
451 register GLYPH
*end
= m
->glyphs
[vpos
] + m
->used
[vpos
];
453 register int tlen
= GLYPH_TABLE_LENGTH
;
454 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
456 /* Ignore trailing and leading spaces if we can. */
457 if (!must_write_spaces
)
459 while ((end
!= beg
) && (*end
== SPACEGLYPH
))
462 return (0); /* All blank line. */
464 while (*beg
== SPACEGLYPH
)
468 /* If we don't have a glyph-table, each glyph is one character,
469 so return the number of glyphs. */
473 /* Otherwise, scan the glyphs and accumulate their total size in I. */
475 while ((beg
<= end
) && *beg
)
477 register GLYPH g
= *beg
++;
479 if (GLYPH_SIMPLE_P (tbase
, tlen
, g
))
482 i
+= GLYPH_LENGTH (tbase
, g
);
487 /* The functions on this page are the interface from xdisp.c to redisplay.
489 The only other interface into redisplay is through setting
490 FRAME_CURSOR_X (frame) and FRAME_CURSOR_Y (frame)
491 and SET_FRAME_GARBAGED (frame). */
493 /* cancel_line eliminates any request to display a line at position `vpos' */
495 cancel_line (vpos
, frame
)
497 register FRAME_PTR frame
;
499 FRAME_DESIRED_GLYPHS (frame
)->enable
[vpos
] = 0;
502 clear_frame_records (frame
)
503 register FRAME_PTR frame
;
505 bzero (FRAME_CURRENT_GLYPHS (frame
)->enable
, FRAME_HEIGHT (frame
));
508 /* Clear out all display lines for a coming redisplay. */
511 init_desired_glyphs (frame
)
512 register FRAME_PTR frame
;
514 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (frame
);
516 int height
= FRAME_HEIGHT (frame
);
518 for (vpos
= 0; vpos
< height
; vpos
++)
519 desired_glyphs
->enable
[vpos
] = 0;
522 /* Prepare to display on line VPOS starting at HPOS within it. */
525 get_display_line (frame
, vpos
, hpos
)
526 register FRAME_PTR frame
;
530 register struct frame_glyphs
*glyphs
;
531 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (frame
);
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
->output_data
.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
->output_data
.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 /* If we are showing a message instead of the minibuffer,
1330 show the cursor for the message instead of for the
1331 (now hidden) minibuffer contents. */
1332 || (EQ (minibuf_window
, selected_window
)
1333 && EQ (minibuf_window
, echo_area_window
)
1334 && echo_area_glyphs
!= 0))
1335 /* These cases apply only to the frame that contains
1336 the active minibuffer window. */
1337 && FRAME_HAS_MINIBUF_P (f
)
1338 && EQ (FRAME_MINIBUF_WINDOW (f
), minibuf_window
))
1340 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
1343 if (cursor_in_echo_area
< 0)
1350 /* If the minibuffer is several lines high, find the last
1351 line that has any text on it. */
1352 row
= FRAME_HEIGHT (f
);
1356 if (current_frame
->enable
[row
])
1357 col
= current_frame
->used
[row
];
1361 while (row
> top
&& col
== 0);
1363 if (col
>= FRAME_WIDTH (f
))
1366 if (row
< FRAME_HEIGHT (f
) - 1)
1371 cursor_to (row
, col
);
1374 cursor_to (FRAME_CURSOR_Y (f
), max (min (FRAME_CURSOR_X (f
),
1375 FRAME_WIDTH (f
) - 1), 0));
1381 fflush (termscript
);
1384 /* Here if output is preempted because input is detected. */
1387 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1388 display_completed
= !pause
;
1390 bzero (FRAME_DESIRED_GLYPHS (f
)->enable
, FRAME_HEIGHT (f
));
1394 /* Called when about to quit, to check for doing so
1395 at an improper time. */
1401 if (FRAME_DESIRED_GLYPHS (selected_frame
) == 0)
1403 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[0])
1405 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[FRAME_HEIGHT (selected_frame
) - 1])
1410 /* Decide what insert/delete line to do, and do it */
1412 extern void scrolling_1 ();
1417 int unchanged_at_top
, unchanged_at_bottom
;
1420 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1421 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1422 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1423 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1425 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
1426 register struct frame_glyphs
*current_frame
= FRAME_CURRENT_GLYPHS (frame
);
1427 register struct frame_glyphs
*desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
1429 /* Compute hash codes of all the lines.
1430 Also calculate number of changed lines,
1431 number of unchanged lines at the beginning,
1432 and number of unchanged lines at the end. */
1435 unchanged_at_top
= 0;
1436 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
1437 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
1439 /* Give up on this scrolling if some old lines are not enabled. */
1440 if (!current_frame
->enable
[i
])
1442 old_hash
[i
] = line_hash_code (current_frame
, i
);
1443 if (! desired_frame
->enable
[i
])
1444 new_hash
[i
] = old_hash
[i
];
1446 new_hash
[i
] = line_hash_code (desired_frame
, i
);
1448 if (old_hash
[i
] != new_hash
[i
])
1451 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
1453 else if (i
== unchanged_at_top
)
1455 draw_cost
[i
] = line_draw_cost (desired_frame
, i
);
1456 old_draw_cost
[i
] = line_draw_cost (current_frame
, i
);
1459 /* If changed lines are few, don't allow preemption, don't scroll. */
1460 if (!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400
1461 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
1464 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
1465 - unchanged_at_bottom
);
1467 if (scroll_region_ok
)
1468 free_at_end_vpos
-= unchanged_at_bottom
;
1469 else if (memory_below_frame
)
1470 free_at_end_vpos
= -1;
1472 /* If large window, fast terminal and few lines in common between
1473 current frame and desired frame, don't bother with i/d calc. */
1474 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
1476 10 * scrolling_max_lines_saved (unchanged_at_top
,
1477 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
1478 old_hash
, new_hash
, draw_cost
)))
1481 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
1482 draw_cost
+ unchanged_at_top
- 1,
1483 old_draw_cost
+ unchanged_at_top
- 1,
1484 old_hash
+ unchanged_at_top
- 1,
1485 new_hash
+ unchanged_at_top
- 1,
1486 free_at_end_vpos
- unchanged_at_top
);
1491 /* Return the offset in its buffer of the character at location col, line
1492 in the given window. */
1494 buffer_posn_from_coords (window
, col
, line
)
1495 struct window
*window
;
1498 int hscroll
= XINT (window
->hscroll
);
1499 int window_left
= XFASTINT (window
->left
);
1501 /* The actual width of the window is window->width less one for the
1502 DISP_CONTINUE_GLYPH, and less one if it's not the rightmost
1504 int window_width
= window_internal_width (window
) - 1;
1506 int startp
= marker_position (window
->start
);
1508 /* Since compute_motion will only operate on the current buffer,
1509 we need to save the old one and restore it when we're done. */
1510 struct buffer
*old_current_buffer
= current_buffer
;
1511 struct position
*posn
;
1513 current_buffer
= XBUFFER (window
->buffer
);
1515 /* We can't get a correct result in this case,
1516 but at least prevent compute_motion from crashing. */
1520 /* It would be nice if we could use FRAME_CURRENT_GLYPHS (XFRAME
1521 (window->frame))->bufp to avoid scanning from the very top of
1522 the window, but it isn't maintained correctly, and I'm not even
1523 sure I will keep it. */
1524 posn
= compute_motion (startp
, 0,
1525 ((window
== XWINDOW (minibuf_window
) && startp
== BEG
1526 ? minibuf_prompt_width
: 0)
1527 + (hscroll
? 1 - hscroll
: 0)),
1530 window_width
, hscroll
, 0, window
);
1532 current_buffer
= old_current_buffer
;
1534 /* compute_motion considers frame points past the end of a line
1535 to be *after* the newline, i.e. at the start of the next line.
1536 This is reasonable, but not really what we want. So if the
1537 result is on a line below LINE, back it up one character. */
1538 if (posn
->vpos
> line
)
1539 return posn
->bufpos
- 1;
1541 return posn
->bufpos
;
1548 register GLYPH
*p
= r
;
1549 while (*p
++ == SPACEGLYPH
);
1554 count_match (str1
, str2
)
1557 register GLYPH
*p1
= str1
;
1558 register GLYPH
*p2
= str2
;
1559 while (*p1
++ == *p2
++);
1560 return p1
- str1
- 1;
1563 /* Char insertion/deletion cost vector, from term.c */
1564 extern int *char_ins_del_vector
;
1566 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WIDTH((f))])
1569 update_line (frame
, vpos
)
1570 register FRAME_PTR frame
;
1573 register GLYPH
*obody
, *nbody
, *op1
, *op2
, *np1
, *temp
;
1576 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
1578 register struct frame_glyphs
*current_frame
1579 = FRAME_CURRENT_GLYPHS (frame
);
1580 register struct frame_glyphs
*desired_frame
1581 = FRAME_DESIRED_GLYPHS (frame
);
1583 if (desired_frame
->highlight
[vpos
]
1584 != (current_frame
->enable
[vpos
] && current_frame
->highlight
[vpos
]))
1586 change_line_highlight (desired_frame
->highlight
[vpos
], vpos
,
1587 (current_frame
->enable
[vpos
] ?
1588 current_frame
->used
[vpos
] : 0));
1589 current_frame
->enable
[vpos
] = 0;
1592 reassert_line_highlight (desired_frame
->highlight
[vpos
], vpos
);
1594 if (! current_frame
->enable
[vpos
])
1600 obody
= current_frame
->glyphs
[vpos
];
1601 olen
= current_frame
->used
[vpos
];
1602 if (! current_frame
->highlight
[vpos
])
1604 if (!must_write_spaces
)
1605 while (obody
[olen
- 1] == SPACEGLYPH
&& olen
> 0)
1610 /* For an inverse-video line, remember we gave it
1611 spaces all the way to the frame edge
1612 so that the reverse video extends all the way across. */
1614 while (olen
< FRAME_WIDTH (frame
) - 1)
1615 obody
[olen
++] = SPACEGLYPH
;
1619 /* One way or another, this will enable the line being updated. */
1620 current_frame
->enable
[vpos
] = 1;
1621 current_frame
->used
[vpos
] = desired_frame
->used
[vpos
];
1622 current_frame
->highlight
[vpos
] = desired_frame
->highlight
[vpos
];
1623 current_frame
->bufp
[vpos
] = desired_frame
->bufp
[vpos
];
1625 #ifdef HAVE_X_WINDOWS
1626 if (FRAME_X_P (frame
))
1628 current_frame
->pix_width
[vpos
]
1629 = current_frame
->used
[vpos
]
1630 * FONT_WIDTH (frame
->output_data
.x
->font
);
1631 current_frame
->pix_height
[vpos
]
1632 = frame
->output_data
.x
->line_height
;
1634 #endif /* HAVE_X_WINDOWS */
1636 if (!desired_frame
->enable
[vpos
])
1642 nbody
= desired_frame
->glyphs
[vpos
];
1643 nlen
= desired_frame
->used
[vpos
];
1645 /* Pretend trailing spaces are not there at all,
1646 unless for one reason or another we must write all spaces. */
1647 if (! desired_frame
->highlight
[vpos
])
1649 if (!must_write_spaces
)
1650 /* We know that the previous character byte contains 0. */
1651 while (nbody
[nlen
- 1] == SPACEGLYPH
)
1656 /* For an inverse-video line, give it extra trailing spaces
1657 all the way to the frame edge
1658 so that the reverse video extends all the way across. */
1660 while (nlen
< FRAME_WIDTH (frame
) - 1)
1661 nbody
[nlen
++] = SPACEGLYPH
;
1664 /* If there's no i/d char, quickly do the best we can without it. */
1665 if (!char_ins_del_ok
)
1670 if (FRAME_X_P (frame
))
1672 /* Under X, erase everything we are going to rewrite,
1673 and rewrite everything from the first char that's changed.
1674 This is part of supporting fonts like Courier
1675 whose chars can overlap outside the char width. */
1676 for (i
= 0; i
< nlen
; i
++)
1677 if (i
>= olen
|| nbody
[i
] != obody
[i
])
1680 cursor_to (vpos
, i
);
1682 clear_end_of_line (olen
);
1683 write_glyphs (nbody
+ i
, nlen
- i
);
1688 for (i
= 0; i
< nlen
; i
++)
1690 if (i
>= olen
|| nbody
[i
] != obody
[i
]) /* A non-matching char. */
1692 cursor_to (vpos
, i
);
1693 for (j
= 1; (i
+ j
< nlen
&&
1694 (i
+ j
>= olen
|| nbody
[i
+j
] != obody
[i
+j
]));
1697 /* Output this run of non-matching chars. */
1698 write_glyphs (nbody
+ i
, j
);
1701 /* Now find the next non-match. */
1705 /* Clear the rest of the line, or the non-clear part of it. */
1708 cursor_to (vpos
, nlen
);
1709 clear_end_of_line (olen
);
1712 /* Exchange contents between current_frame and new_frame. */
1713 temp
= desired_frame
->glyphs
[vpos
];
1714 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1715 current_frame
->glyphs
[vpos
] = temp
;
1717 /* Exchange charstarts between current_frame and new_frame. */
1718 temp1
= desired_frame
->charstarts
[vpos
];
1719 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1720 current_frame
->charstarts
[vpos
] = temp1
;
1727 nsp
= (must_write_spaces
|| desired_frame
->highlight
[vpos
])
1728 ? 0 : count_blanks (nbody
);
1731 cursor_to (vpos
, nsp
);
1732 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
1735 /* Exchange contents between current_frame and new_frame. */
1736 temp
= desired_frame
->glyphs
[vpos
];
1737 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1738 current_frame
->glyphs
[vpos
] = temp
;
1740 /* Exchange charstarts between current_frame and new_frame. */
1741 temp1
= desired_frame
->charstarts
[vpos
];
1742 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1743 current_frame
->charstarts
[vpos
] = temp1
;
1752 /* Compute number of leading blanks in old and new contents. */
1753 osp
= count_blanks (obody
);
1754 if (!desired_frame
->highlight
[vpos
])
1755 nsp
= count_blanks (nbody
);
1759 /* Compute number of matching chars starting with first nonblank. */
1760 begmatch
= count_match (obody
+ osp
, nbody
+ nsp
);
1762 /* Spaces in new match implicit space past the end of old. */
1763 /* A bug causing this to be a no-op was fixed in 18.29. */
1764 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
1767 while (np1
[begmatch
] == SPACEGLYPH
)
1771 /* Avoid doing insert/delete char
1772 just cause number of leading spaces differs
1773 when the following text does not match. */
1774 if (begmatch
== 0 && osp
!= nsp
)
1775 osp
= nsp
= min (osp
, nsp
);
1777 /* Find matching characters at end of line */
1780 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
1781 while (op1
> op2
&& op1
[-1] == np1
[-1])
1786 endmatch
= obody
+ olen
- op1
;
1788 /* Put correct value back in nbody[nlen].
1789 This is important because direct_output_for_insert
1790 can write into the line at a later point.
1791 If this screws up the zero at the end of the line, re-establish it. */
1795 /* tem gets the distance to insert or delete.
1796 endmatch is how many characters we save by doing so.
1799 tem
= (nlen
- nsp
) - (olen
- osp
);
1801 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
1804 /* nsp - osp is the distance to insert or delete.
1805 If that is nonzero, begmatch is known to be nonzero also.
1806 begmatch + endmatch is how much we save by doing the ins/del.
1810 && (!char_ins_del_ok
1811 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
1815 osp
= nsp
= min (osp
, nsp
);
1818 /* Now go through the line, inserting, writing and
1819 deleting as appropriate. */
1823 cursor_to (vpos
, nsp
);
1824 delete_glyphs (osp
- nsp
);
1828 /* If going to delete chars later in line
1829 and insert earlier in the line,
1830 must delete first to avoid losing data in the insert */
1831 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
1833 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
1834 delete_glyphs (olen
+ nsp
- osp
- nlen
);
1835 olen
= nlen
- (nsp
- osp
);
1837 cursor_to (vpos
, osp
);
1838 insert_glyphs ((char *)0, nsp
- osp
);
1842 tem
= nsp
+ begmatch
+ endmatch
;
1843 if (nlen
!= tem
|| olen
!= tem
)
1845 cursor_to (vpos
, nsp
+ begmatch
);
1846 if (!endmatch
|| nlen
== olen
)
1848 /* If new text being written reaches right margin,
1849 there is no need to do clear-to-eol at the end.
1850 (and it would not be safe, since cursor is not
1851 going to be "at the margin" after the text is done) */
1852 if (nlen
== FRAME_WIDTH (frame
))
1854 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1858 /* the following code loses disastrously if tem == nlen.
1859 Rather than trying to fix that case, I am trying the simpler
1860 solution found above. */
1862 /* If the text reaches to the right margin,
1863 it will lose one way or another (depending on AutoWrap)
1864 to clear to end of line after outputting all the text.
1865 So pause with one character to go and clear the line then. */
1866 if (nlen
== FRAME_WIDTH (frame
) && fast_clear_end_of_line
&& olen
> nlen
)
1868 /* endmatch must be zero, and tem must equal nsp + begmatch */
1869 write_glyphs (nbody
+ tem
, nlen
- tem
- 1);
1870 clear_end_of_line (olen
);
1871 olen
= 0; /* Don't let it be cleared again later */
1872 write_glyphs (nbody
+ nlen
- 1, 1);
1875 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1876 #endif /* OBSOLETE */
1879 else if (nlen
> olen
)
1881 write_glyphs (nbody
+ nsp
+ begmatch
, olen
- tem
);
1882 insert_glyphs (nbody
+ nsp
+ begmatch
+ olen
- tem
, nlen
- olen
);
1885 else if (olen
> nlen
)
1887 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1888 delete_glyphs (olen
- nlen
);
1894 /* If any unerased characters remain after the new line, erase them. */
1897 cursor_to (vpos
, nlen
);
1898 clear_end_of_line (olen
);
1901 /* Exchange contents between current_frame and new_frame. */
1902 temp
= desired_frame
->glyphs
[vpos
];
1903 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1904 current_frame
->glyphs
[vpos
] = temp
;
1906 /* Exchange charstarts between current_frame and new_frame. */
1907 temp1
= desired_frame
->charstarts
[vpos
];
1908 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1909 current_frame
->charstarts
[vpos
] = temp1
;
1912 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
1913 session's frames, frame names, buffers, buffer-read-only flags, and
1914 buffer-modified-flags, and a trailing sentinel (so we don't need to
1915 add length checks). */
1916 static Lisp_Object frame_and_buffer_state
;
1918 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
1919 Sframe_or_buffer_changed_p
, 0, 0, 0,
1920 "Return non-nil if the frame and buffer state appears to have changed.\n\
1921 The state variable is an internal vector containing all frames and buffers,\n\
1922 aside from buffers whose names start with space,\n\
1923 along with the buffers' read-only and modified flags, which allows a fast\n\
1924 check to see whether the menu bars might need to be recomputed.\n\
1925 If this function returns non-nil, it updates the internal vector to reflect\n\
1926 the current state.\n")
1929 Lisp_Object tail
, frame
, buf
;
1933 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
1934 FOR_EACH_FRAME (tail
, frame
)
1936 if (!EQ (*vecp
++, frame
))
1938 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
1941 /* Check that the buffer info matches.
1942 No need to test for the end of the vector
1943 because the last element of the vector is lambda
1944 and that will always cause a mismatch. */
1945 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1947 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
1948 /* Ignore buffers that aren't included in buffer lists. */
1949 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
1951 if (!EQ (*vecp
++, buf
))
1953 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
1955 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
1958 /* Detect deletion of a buffer at the end of the list. */
1959 if (*vecp
== Qlambda
)
1962 /* Start with 1 so there is room for at least one lambda at the end. */
1964 FOR_EACH_FRAME (tail
, frame
)
1966 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1968 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
1969 if (n
> XVECTOR (frame_and_buffer_state
)->size
1970 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
1971 /* Add 20 extra so we grow it less often. */
1972 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
1973 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
1974 FOR_EACH_FRAME (tail
, frame
)
1977 *vecp
++ = XFRAME (frame
)->name
;
1979 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1981 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
1982 /* Ignore buffers that aren't included in buffer lists. */
1983 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
1986 *vecp
++ = XBUFFER (buf
)->read_only
;
1987 *vecp
++ = Fbuffer_modified_p (buf
);
1989 /* Fill up the vector with lambdas (always at least one). */
1991 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
1992 < XVECTOR (frame_and_buffer_state
)->size
)
1994 /* Make sure we didn't overflow the vector. */
1995 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
1996 > XVECTOR (frame_and_buffer_state
)->size
)
2001 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
2002 1, 1, "FOpen termscript file: ",
2003 "Start writing all terminal output to FILE as well as the terminal.\n\
2004 FILE = nil means just close any termscript file currently open.")
2008 if (termscript
!= 0) fclose (termscript
);
2013 file
= Fexpand_file_name (file
, Qnil
);
2014 termscript
= fopen (XSTRING (file
)->data
, "w");
2015 if (termscript
== 0)
2016 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
2024 window_change_signal (signalnum
) /* If we don't have an argument, */
2025 int signalnum
; /* some compilers complain in signal calls. */
2029 int old_errno
= errno
;
2031 get_frame_size (&width
, &height
);
2033 /* The frame size change obviously applies to a termcap-controlled
2034 frame. Find such a frame in the list, and assume it's the only
2035 one (since the redisplay code always writes to stdout, not a
2036 FILE * specified in the frame structure). Record the new size,
2037 but don't reallocate the data structures now. Let that be done
2038 later outside of the signal handler. */
2041 Lisp_Object tail
, frame
;
2043 FOR_EACH_FRAME (tail
, frame
)
2045 if (FRAME_TERMCAP_P (XFRAME (frame
)))
2047 change_frame_size (XFRAME (frame
), height
, width
, 0, 1);
2053 signal (SIGWINCH
, window_change_signal
);
2056 #endif /* SIGWINCH */
2059 /* Do any change in frame size that was requested by a signal. */
2061 do_pending_window_change ()
2063 /* If window_change_signal should have run before, run it now. */
2064 while (delayed_size_change
)
2066 Lisp_Object tail
, frame
;
2068 delayed_size_change
= 0;
2070 FOR_EACH_FRAME (tail
, frame
)
2072 FRAME_PTR f
= XFRAME (frame
);
2074 int height
= FRAME_NEW_HEIGHT (f
);
2075 int width
= FRAME_NEW_WIDTH (f
);
2077 if (height
!= 0 || width
!= 0)
2078 change_frame_size (f
, height
, width
, 0, 0);
2084 /* Change the frame height and/or width. Values may be given as zero to
2085 indicate no change is to take place.
2087 If DELAY is non-zero, then assume we're being called from a signal
2088 handler, and queue the change for later - perhaps the next
2089 redisplay. Since this tries to resize windows, we can't call it
2090 from a signal handler. */
2092 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
)
2093 register FRAME_PTR f
;
2094 int newheight
, newwidth
, pretend
;
2096 Lisp_Object tail
, frame
;
2097 if (FRAME_TERMCAP_P (f
))
2099 /* When using termcap, all frames use the same screen,
2100 so a change in size affects all termcap frames. */
2101 FOR_EACH_FRAME (tail
, frame
)
2102 if (FRAME_TERMCAP_P (XFRAME (frame
)))
2103 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
2107 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
);
2111 change_frame_size_1 (frame
, newheight
, newwidth
, pretend
, delay
)
2112 register FRAME_PTR frame
;
2113 int newheight
, newwidth
, pretend
, delay
;
2115 /* If we can't deal with the change now, queue it for later. */
2118 FRAME_NEW_HEIGHT (frame
) = newheight
;
2119 FRAME_NEW_WIDTH (frame
) = newwidth
;
2120 delayed_size_change
= 1;
2124 /* This size-change overrides any pending one for this frame. */
2125 FRAME_NEW_HEIGHT (frame
) = 0;
2126 FRAME_NEW_WIDTH (frame
) = 0;
2128 /* If an argument is zero, set it to the current value. */
2129 newheight
|| (newheight
= FRAME_HEIGHT (frame
));
2130 newwidth
|| (newwidth
= FRAME_WIDTH (frame
));
2132 /* Round up to the smallest acceptable size. */
2133 check_frame_size (frame
, &newheight
, &newwidth
);
2135 /* If we're not changing the frame size, quit now. */
2136 if (newheight
== FRAME_HEIGHT (frame
)
2137 && newwidth
== FRAME_WIDTH (frame
))
2140 if (newheight
!= FRAME_HEIGHT (frame
))
2142 if (FRAME_HAS_MINIBUF_P (frame
)
2143 && ! FRAME_MINIBUF_ONLY_P (frame
))
2145 /* Frame has both root and minibuffer. */
2146 set_window_height (FRAME_ROOT_WINDOW (frame
),
2147 newheight
- 1 - FRAME_MENU_BAR_LINES (frame
), 0);
2148 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (frame
))->top
,
2150 set_window_height (FRAME_MINIBUF_WINDOW (frame
), 1, 0);
2153 /* Frame has just one top-level window. */
2154 set_window_height (FRAME_ROOT_WINDOW (frame
),
2155 newheight
- FRAME_MENU_BAR_LINES (frame
), 0);
2157 if (FRAME_TERMCAP_P (frame
) && !pretend
)
2158 FrameRows
= newheight
;
2161 if (frame
->output_method
== output_termcap
)
2163 frame_height
= newheight
;
2165 FrameRows
= newheight
;
2170 if (newwidth
!= FRAME_WIDTH (frame
))
2172 set_window_width (FRAME_ROOT_WINDOW (frame
), newwidth
, 0);
2173 if (FRAME_HAS_MINIBUF_P (frame
))
2174 set_window_width (FRAME_MINIBUF_WINDOW (frame
), newwidth
, 0);
2176 if (FRAME_TERMCAP_P (frame
) && !pretend
)
2177 FrameCols
= newwidth
;
2179 if (frame
->output_method
== output_termcap
)
2181 frame_width
= newwidth
;
2183 FrameCols
= newwidth
;
2188 FRAME_HEIGHT (frame
) = newheight
;
2189 FRAME_WIDTH (frame
) = newwidth
;
2191 if (FRAME_CURSOR_X (frame
) >= FRAME_WIDTH (frame
))
2192 FRAME_CURSOR_X (frame
) = FRAME_WIDTH (frame
) - 1;
2193 if (FRAME_CURSOR_Y (frame
) >= FRAME_HEIGHT (frame
))
2194 FRAME_CURSOR_Y (frame
) = FRAME_HEIGHT (frame
) - 1;
2196 remake_frame_glyphs (frame
);
2197 calculate_costs (frame
);
2200 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
2201 Ssend_string_to_terminal
, 1, 1, 0,
2202 "Send STRING to the terminal without alteration.\n\
2203 Control characters in STRING will have terminal-dependent effects.")
2207 CHECK_STRING (str
, 0);
2208 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, stdout
);
2212 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, termscript
);
2213 fflush (termscript
);
2218 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
2219 "Beep, or flash the screen.\n\
2220 Also, unless an argument is given,\n\
2221 terminate any keyboard macro currently executing.")
2243 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
2244 error ("Keyboard macro terminated by a command ringing the bell");
2250 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
2251 "Pause, without updating display, for SECONDS seconds.\n\
2252 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2253 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2254 additional wait period, in milliseconds; this may be useful if your\n\
2255 Emacs was built without floating point support.\n\
2256 \(Not all operating systems support waiting for a fraction of a second.)")
2257 (seconds
, milliseconds
)
2258 Lisp_Object seconds
, milliseconds
;
2262 if (NILP (milliseconds
))
2263 XSETINT (milliseconds
, 0);
2265 CHECK_NUMBER (milliseconds
, 1);
2266 usec
= XINT (milliseconds
) * 1000;
2268 #ifdef LISP_FLOAT_TYPE
2270 double duration
= extract_float (seconds
);
2271 sec
= (int) duration
;
2272 usec
+= (duration
- sec
) * 1000000;
2275 CHECK_NUMBER (seconds
, 0);
2276 sec
= XINT (seconds
);
2279 #ifndef EMACS_HAS_USECS
2280 if (sec
== 0 && usec
!= 0)
2281 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
2284 /* Assure that 0 <= usec < 1000000. */
2287 /* We can't rely on the rounding being correct if user is negative. */
2288 if (-1000000 < usec
)
2289 sec
--, usec
+= 1000000;
2291 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
2294 sec
+= usec
/ 1000000, usec
%= 1000000;
2302 XSETFASTINT (zero
, 0);
2303 wait_reading_process_input (sec
, usec
, zero
, 0);
2306 /* We should always have wait_reading_process_input; we have a dummy
2307 implementation for systems which don't support subprocesses. */
2309 /* No wait_reading_process_input */
2316 /* The reason this is done this way
2317 (rather than defined (H_S) && defined (H_T))
2318 is because the VMS preprocessor doesn't grok `defined' */
2320 EMACS_GET_TIME (end_time
);
2321 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
2322 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
2326 EMACS_GET_TIME (timeout
);
2327 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
2328 if (EMACS_TIME_NEG_P (timeout
)
2329 || !select (1, 0, 0, 0, &timeout
))
2332 #else /* not HAVE_SELECT */
2334 #endif /* HAVE_SELECT */
2335 #endif /* not VMS */
2338 #endif /* no subprocesses */
2343 /* This is just like wait_reading_process_input, except that
2344 it does the redisplay.
2346 It's also much like Fsit_for, except that it can be used for
2347 waiting for input as well. */
2350 sit_for (sec
, usec
, reading
, display
)
2351 int sec
, usec
, reading
, display
;
2353 Lisp_Object read_kbd
;
2355 if (detect_input_pending ())
2359 redisplay_preserve_echo_area ();
2361 if (sec
== 0 && usec
== 0)
2368 XSETINT (read_kbd
, reading
? -1 : 1);
2369 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
2372 /* wait_reading_process_input should always be available now; it is
2373 simulated in a simple way on systems that don't support
2376 /* No wait_reading_process_input available. */
2382 input_wait_timeout (XINT (arg
));
2384 #ifndef HAVE_TIMEVAL
2386 select (1, &waitchannels
, 0, 0, &timeout_sec
);
2387 #else /* HAVE_TIMEVAL */
2388 timeout
.tv_sec
= sec
;
2389 timeout
.tv_usec
= usec
;
2390 select (1, &waitchannels
, 0, 0, &timeout
);
2391 #endif /* HAVE_TIMEVAL */
2392 #endif /* not VMS */
2397 return detect_input_pending () ? Qnil
: Qt
;
2400 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
2401 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
2402 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2403 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2404 additional wait period, in milliseconds; this may be useful if your\n\
2405 Emacs was built without floating point support.\n\
2406 \(Not all operating systems support waiting for a fraction of a second.)\n\
2407 Optional third arg non-nil means don't redisplay, just wait for input.\n\
2408 Redisplay is preempted as always if input arrives, and does not happen\n\
2409 if input is available before it starts.\n\
2410 Value is t if waited the full time with no input arriving.")
2411 (seconds
, milliseconds
, nodisp
)
2412 Lisp_Object seconds
, milliseconds
, nodisp
;
2416 if (NILP (milliseconds
))
2417 XSETINT (milliseconds
, 0);
2419 CHECK_NUMBER (milliseconds
, 1);
2420 usec
= XINT (milliseconds
) * 1000;
2422 #ifdef LISP_FLOAT_TYPE
2424 double duration
= extract_float (seconds
);
2425 sec
= (int) duration
;
2426 usec
+= (duration
- sec
) * 1000000;
2429 CHECK_NUMBER (seconds
, 0);
2430 sec
= XINT (seconds
);
2433 #ifndef EMACS_HAS_USECS
2434 if (usec
!= 0 && sec
== 0)
2435 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
2438 return sit_for (sec
, usec
, 0, NILP (nodisp
));
2441 char *terminal_type
;
2443 /* Initialization done when Emacs fork is started, before doing stty. */
2444 /* Determine terminal type and set terminal_driver */
2445 /* Then invoke its decoding routine to set up variables
2446 in the terminal package */
2450 #ifdef HAVE_X_WINDOWS
2451 extern int display_arg
;
2456 cursor_in_echo_area
= 0;
2457 terminal_type
= (char *) 0;
2459 /* Now is the time to initialize this; it's used by init_sys_modes
2461 Vwindow_system
= Qnil
;
2463 /* If the user wants to use a window system, we shouldn't bother
2464 initializing the terminal. This is especially important when the
2465 terminal is so dumb that emacs gives up before and doesn't bother
2466 using the window system.
2468 If the DISPLAY environment variable is set, try to use X, and die
2469 with an error message if that doesn't work. */
2471 #ifdef HAVE_X_WINDOWS
2475 display_arg
= (getenv ("DECW$DISPLAY") != 0);
2477 display_arg
= (getenv ("DISPLAY") != 0);
2481 if (!inhibit_window_system
&& display_arg
)
2483 Vwindow_system
= intern ("x");
2485 Vwindow_system_version
= make_number (11);
2487 Vwindow_system_version
= make_number (10);
2491 #endif /* HAVE_X_WINDOWS */
2493 /* If no window system has been specified, try to use the terminal. */
2496 fprintf (stderr
, "emacs: standard input is not a tty\n");
2500 /* Look at the TERM variable */
2501 terminal_type
= (char *) getenv ("TERM");
2505 fprintf (stderr
, "Please specify your terminal type.\n\
2506 For types defined in VMS, use set term /device=TYPE.\n\
2507 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
2508 \(The quotation marks are necessary since terminal types are lower case.)\n");
2510 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
2516 /* VMS DCL tends to upcase things, so downcase term type.
2517 Hardly any uppercase letters in terminal types; should be none. */
2519 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
2522 strcpy (new, terminal_type
);
2524 for (p
= new; *p
; p
++)
2528 terminal_type
= new;
2532 term_init (terminal_type
);
2534 remake_frame_glyphs (selected_frame
);
2535 calculate_costs (selected_frame
);
2537 /* X and Y coordinates of the cursor between updates. */
2538 FRAME_CURSOR_X (selected_frame
) = 0;
2539 FRAME_CURSOR_Y (selected_frame
) = 0;
2544 #endif /* CANNOT_DUMP */
2545 signal (SIGWINCH
, window_change_signal
);
2546 #endif /* SIGWINCH */
2552 defsubr (&Sredraw_frame
);
2554 defsubr (&Sredraw_display
);
2555 defsubr (&Sframe_or_buffer_changed_p
);
2556 defsubr (&Sopen_termscript
);
2558 defsubr (&Ssit_for
);
2559 defsubr (&Ssleep_for
);
2560 defsubr (&Ssend_string_to_terminal
);
2562 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
2563 staticpro (&frame_and_buffer_state
);
2565 DEFVAR_INT ("baud-rate", &baud_rate
,
2566 "*The output baud rate of the terminal.\n\
2567 On most systems, changing this value will affect the amount of padding\n\
2568 and the other strategic decisions made during redisplay.");
2569 DEFVAR_BOOL ("inverse-video", &inverse_video
,
2570 "*Non-nil means invert the entire frame display.\n\
2571 This means everything is in inverse video which otherwise would not be.");
2572 DEFVAR_BOOL ("visible-bell", &visible_bell
,
2573 "*Non-nil means try to flash the frame to represent a bell.");
2574 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
2575 "*Non-nil means no need to redraw entire frame after suspending.\n\
2576 A non-nil value is useful if the terminal can automatically preserve\n\
2577 Emacs's frame display when you reenter Emacs.\n\
2578 It is up to you to set this variable if your terminal can do that.");
2579 DEFVAR_LISP ("window-system", &Vwindow_system
,
2580 "A symbol naming the window-system under which Emacs is running\n\
2581 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
2582 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
2583 "The version number of the window system in use.\n\
2584 For X windows, this is 10 or 11.");
2585 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
2586 "Non-nil means put cursor in minibuffer, at end of any message there.");
2587 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
2588 "Table defining how to output a glyph code to the frame.\n\
2589 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
2590 Each element can be:\n\
2591 integer: a glyph code which this glyph is an alias for.\n\
2592 string: output this glyph using that string (not impl. in X windows).\n\
2593 nil: this glyph mod 256 is char code to output,\n\
2594 and this glyph / 256 is face code for X windows (see `face-id').");
2595 Vglyph_table
= Qnil
;
2597 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
2598 "Display table to use for buffers that specify none.\n\
2599 See `buffer-display-table' for more information.");
2600 Vstandard_display_table
= Qnil
;
2602 /* Initialize `window-system', unless init_display already decided it. */
2607 Vwindow_system
= Qnil
;
2608 Vwindow_system_version
= Qnil
;