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, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
32 #include "termhooks.h"
33 /* cm.h must come after dispextern.h on Windows. */
34 #include "dispextern.h"
42 #include "intervals.h"
43 #include "blockinput.h"
46 #include "syssignal.h"
50 #endif /* HAVE_X_WINDOWS */
54 #endif /* HAVE_NTGUI */
56 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
61 #define max(a, b) ((a) > (b) ? (a) : (b))
62 #define min(a, b) ((a) < (b) ? (a) : (b))
64 /* Get number of chars of output now in the buffer of a stdio stream.
65 This ought to be built in in stdio, but it isn't.
66 Some s- files override this because their stdio internals differ. */
67 #ifdef __GNU_LIBRARY__
68 /* The s- file might have overridden the definition with one that works for
69 the system's C library. But we are using the GNU C library, so this is
70 the right definition for every system. */
71 #ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT
72 #define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT
74 #undef PENDING_OUTPUT_COUNT
75 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
77 #else /* not __GNU_LIBRARY__ */
78 #ifndef PENDING_OUTPUT_COUNT
79 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
83 static void change_frame_size_1 ();
85 /* Nonzero upon entry to redisplay means do not assume anything about
86 current contents of actual terminal frame; clear and redraw it. */
90 /* Nonzero means last display completed. Zero means it was preempted. */
92 int display_completed
;
94 /* Lisp variable visible-bell; enables use of screen-flash
95 instead of audible bell. */
99 /* Invert the color of the whole frame, at a low level. */
103 /* Line speed of the terminal. */
107 /* nil or a symbol naming the window system under which emacs is
108 running ('x is the only current possibility). */
110 Lisp_Object Vwindow_system
;
112 /* Version number of X windows: 10, 11 or nil. */
113 Lisp_Object Vwindow_system_version
;
115 /* Vector of glyph definitions. Indexed by glyph number,
116 the contents are a string which is how to output the glyph.
118 If Vglyph_table is nil, a glyph is output by using its low 8 bits
119 as a character code. */
121 Lisp_Object Vglyph_table
;
123 /* Display table to use for vectors that don't specify their own. */
125 Lisp_Object Vstandard_display_table
;
127 /* Nonzero means reading single-character input with prompt
128 so put cursor on minibuffer after the prompt.
129 positive means at end of text in echo area;
130 negative means at beginning of line. */
131 int cursor_in_echo_area
;
133 Lisp_Object Qdisplay_table
;
135 /* The currently selected frame.
136 In a single-frame version, this variable always holds the address of
139 FRAME_PTR selected_frame
;
141 /* A frame which is not just a minibuffer, or 0 if there are no such
142 frames. This is usually the most recent such frame that was
143 selected. In a single-frame version, this variable always holds
144 the address of the_only_frame. */
145 FRAME_PTR last_nonminibuf_frame
;
147 /* In a single-frame version, the information that would otherwise
148 exist inside frame objects lives in the following structure instead.
150 NOTE: the_only_frame is not checked for garbage collection; don't
151 store collectible objects in any of its fields!
153 You're not/The only frame in town/... */
156 struct frame the_only_frame
;
159 /* This is a vector, made larger whenever it isn't large enough,
160 which is used inside `update_frame' to hold the old contents
161 of the FRAME_PHYS_LINES of the frame being updated. */
162 struct frame_glyphs
**ophys_lines
;
163 /* Length of vector currently allocated. */
164 int ophys_lines_length
;
166 FILE *termscript
; /* Stdio stream being used for copy of all output. */
168 struct cm Wcm
; /* Structure for info on cursor positioning */
170 extern short ospeed
; /* Output speed (from sg_ospeed) */
172 int delayed_size_change
; /* 1 means SIGWINCH happened when not safe. */
176 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
177 "Clear frame FRAME and output again what is supposed to appear on it.")
183 CHECK_LIVE_FRAME (frame
, 0);
186 if (FRAME_MSDOS_P (f
))
187 set_terminal_modes ();
189 clear_frame_records (f
);
192 windows_or_buffers_changed
++;
193 /* Mark all windows as INaccurate,
194 so that every window will have its redisplay done. */
195 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
204 XSETFRAME (frame
, f
);
205 Fredraw_frame (frame
);
210 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
211 /* Don't confuse make-docfile by having two doc strings for this function.
212 make-docfile does not pay attention to #if, for good reason! */
218 set_terminal_modes ();
222 clear_frame_records (0);
223 windows_or_buffers_changed
++;
224 /* Mark all windows as INaccurate,
225 so that every window will have its redisplay done. */
226 mark_window_display_accurate (FRAME_ROOT_WINDOW (0), 0);
232 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
233 "Clear and redisplay all visible frames.")
236 Lisp_Object tail
, frame
;
238 FOR_EACH_FRAME (tail
, frame
)
239 if (FRAME_VISIBLE_P (XFRAME (frame
)))
240 Fredraw_frame (frame
);
245 /* This is used when frame_garbaged is set.
246 Redraw the individual frames marked as garbaged. */
249 redraw_garbaged_frames ()
251 Lisp_Object tail
, frame
;
253 FOR_EACH_FRAME (tail
, frame
)
254 if (FRAME_VISIBLE_P (XFRAME (frame
))
255 && FRAME_GARBAGED_P (XFRAME (frame
)))
256 Fredraw_frame (frame
);
260 static struct frame_glyphs
*
261 make_frame_glyphs (frame
, empty
)
262 register FRAME_PTR frame
;
266 register width
= FRAME_WIDTH (frame
);
267 register height
= FRAME_HEIGHT (frame
);
268 register struct frame_glyphs
*new
269 = (struct frame_glyphs
*) xmalloc (sizeof (struct frame_glyphs
));
271 SET_GLYPHS_FRAME (new, frame
);
272 new->height
= height
;
274 new->used
= (int *) xmalloc (height
* sizeof (int));
275 new->glyphs
= (GLYPH
**) xmalloc (height
* sizeof (GLYPH
*));
276 new->charstarts
= (int **) xmalloc (height
* sizeof (int *));
277 new->highlight
= (char *) xmalloc (height
* sizeof (char));
278 new->enable
= (char *) xmalloc (height
* sizeof (char));
279 bzero (new->enable
, height
* sizeof (char));
280 new->bufp
= (int *) xmalloc (height
* sizeof (int));
282 #ifdef HAVE_WINDOW_SYSTEM
283 if (FRAME_WINDOW_P (frame
))
285 new->top_left_x
= (short *) xmalloc (height
* sizeof (short));
286 new->top_left_y
= (short *) xmalloc (height
* sizeof (short));
287 new->pix_width
= (short *) xmalloc (height
* sizeof (short));
288 new->pix_height
= (short *) xmalloc (height
* sizeof (short));
289 new->max_ascent
= (short *) xmalloc (height
* sizeof (short));
291 #endif /* HAVE_WINDOW_SYSTEM */
295 /* Make the buffer used by decode_mode_spec. This buffer is also
296 used as temporary storage when updating the frame. See scroll.c. */
297 unsigned int total_glyphs
= (width
+ 2) * sizeof (GLYPH
);
298 unsigned int total_charstarts
= (width
+ 2) * sizeof (int);
300 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
301 bzero (new->total_contents
, total_glyphs
);
303 new->total_charstarts
= (int *) xmalloc (total_charstarts
);
304 bzero (new->total_charstarts
, total_charstarts
);
308 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (GLYPH
);
310 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
311 bzero (new->total_contents
, total_glyphs
);
312 for (i
= 0; i
< height
; i
++)
313 new->glyphs
[i
] = new->total_contents
+ i
* (width
+ 2) + 1;
315 if (!FRAME_TERMCAP_P (frame
))
317 unsigned int total_charstarts
= height
* (width
+ 2) * sizeof (int);
319 new->total_charstarts
= (int *) xmalloc (total_charstarts
);
320 bzero (new->total_charstarts
, total_charstarts
);
321 for (i
= 0; i
< height
; i
++)
322 new->charstarts
[i
] = new->total_charstarts
+ i
* (width
+ 2) + 1;
326 /* Without a window system, we don't really need charstarts.
327 So use a small amount of space to make enough data structure
328 to prevent crashes in display_text_line. */
329 new->total_charstarts
= (int *) xmalloc ((width
+ 2) * sizeof (int));
330 for (i
= 0; i
< height
; i
++)
331 new->charstarts
[i
] = new->total_charstarts
;
339 free_frame_glyphs (frame
, glyphs
)
341 struct frame_glyphs
*glyphs
;
343 if (glyphs
->total_contents
)
344 xfree (glyphs
->total_contents
);
345 if (glyphs
->total_charstarts
)
346 xfree (glyphs
->total_charstarts
);
348 xfree (glyphs
->used
);
349 xfree (glyphs
->glyphs
);
350 xfree (glyphs
->highlight
);
351 xfree (glyphs
->enable
);
352 xfree (glyphs
->bufp
);
353 if (glyphs
->charstarts
)
354 xfree (glyphs
->charstarts
);
356 #ifdef HAVE_WINDOW_SYSTEM
357 if (FRAME_WINDOW_P (frame
))
359 xfree (glyphs
->top_left_x
);
360 xfree (glyphs
->top_left_y
);
361 xfree (glyphs
->pix_width
);
362 xfree (glyphs
->pix_height
);
363 xfree (glyphs
->max_ascent
);
365 #endif /* HAVE_WINDOW_SYSTEM */
371 remake_frame_glyphs (frame
)
374 if (FRAME_CURRENT_GLYPHS (frame
))
375 free_frame_glyphs (frame
, FRAME_CURRENT_GLYPHS (frame
));
376 if (FRAME_DESIRED_GLYPHS (frame
))
377 free_frame_glyphs (frame
, FRAME_DESIRED_GLYPHS (frame
));
378 if (FRAME_TEMP_GLYPHS (frame
))
379 free_frame_glyphs (frame
, FRAME_TEMP_GLYPHS (frame
));
381 if (FRAME_MESSAGE_BUF (frame
))
383 /* Reallocate the frame's message buffer; remember that
384 echo_area_glyphs may be pointing here. */
385 char *old_message_buf
= FRAME_MESSAGE_BUF (frame
);
387 FRAME_MESSAGE_BUF (frame
)
388 = (char *) xrealloc (FRAME_MESSAGE_BUF (frame
),
389 FRAME_WIDTH (frame
) + 1);
391 if (echo_area_glyphs
== old_message_buf
)
392 echo_area_glyphs
= FRAME_MESSAGE_BUF (frame
);
393 if (previous_echo_glyphs
== old_message_buf
)
394 previous_echo_glyphs
= FRAME_MESSAGE_BUF (frame
);
397 FRAME_MESSAGE_BUF (frame
)
398 = (char *) xmalloc (FRAME_WIDTH (frame
) + 1);
400 FRAME_CURRENT_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
401 FRAME_DESIRED_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
402 FRAME_TEMP_GLYPHS (frame
) = make_frame_glyphs (frame
, 1);
403 if (FRAME_WINDOW_P (frame
) || frame
== selected_frame
)
404 SET_FRAME_GARBAGED (frame
);
407 /* Return the hash code of contents of line VPOS in frame-matrix M. */
410 line_hash_code (m
, vpos
)
411 register struct frame_glyphs
*m
;
414 register GLYPH
*body
, *end
;
417 if (!m
->enable
[vpos
])
420 /* Give all highlighted lines the same hash code
421 so as to encourage scrolling to leave them in place. */
422 if (m
->highlight
[vpos
])
425 body
= m
->glyphs
[vpos
];
427 if (must_write_spaces
)
434 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
- SPACEGLYPH
;
443 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
;
451 /* Return number of characters in line in M at vpos VPOS,
452 except don't count leading and trailing spaces
453 unless the terminal requires those to be explicitly output. */
456 line_draw_cost (m
, vpos
)
457 struct frame_glyphs
*m
;
460 register GLYPH
*beg
= m
->glyphs
[vpos
];
461 register GLYPH
*end
= m
->glyphs
[vpos
] + m
->used
[vpos
];
463 register int tlen
= GLYPH_TABLE_LENGTH
;
464 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
466 /* Ignore trailing and leading spaces if we can. */
467 if (!must_write_spaces
)
469 while ((end
!= beg
) && (*end
== SPACEGLYPH
))
472 return (0); /* All blank line. */
474 while (*beg
== SPACEGLYPH
)
478 /* If we don't have a glyph-table, each glyph is one character,
479 so return the number of glyphs. */
483 /* Otherwise, scan the glyphs and accumulate their total size in I. */
485 while ((beg
<= end
) && *beg
)
487 register GLYPH g
= *beg
++;
489 if (GLYPH_SIMPLE_P (tbase
, tlen
, g
))
492 i
+= GLYPH_LENGTH (tbase
, g
);
497 /* The functions on this page are the interface from xdisp.c to redisplay.
499 The only other interface into redisplay is through setting
500 FRAME_CURSOR_X (frame) and FRAME_CURSOR_Y (frame)
501 and SET_FRAME_GARBAGED (frame). */
503 /* cancel_line eliminates any request to display a line at position `vpos' */
505 cancel_line (vpos
, frame
)
507 register FRAME_PTR frame
;
509 FRAME_DESIRED_GLYPHS (frame
)->enable
[vpos
] = 0;
512 clear_frame_records (frame
)
513 register FRAME_PTR frame
;
515 bzero (FRAME_CURRENT_GLYPHS (frame
)->enable
, FRAME_HEIGHT (frame
));
518 /* Clear out all display lines for a coming redisplay. */
521 init_desired_glyphs (frame
)
522 register FRAME_PTR frame
;
524 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (frame
);
526 int height
= FRAME_HEIGHT (frame
);
528 for (vpos
= 0; vpos
< height
; vpos
++)
529 desired_glyphs
->enable
[vpos
] = 0;
532 /* Prepare to display on line VPOS starting at HPOS within it. */
535 get_display_line (frame
, vpos
, hpos
)
536 register FRAME_PTR frame
;
540 register struct frame_glyphs
*glyphs
;
541 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (frame
);
547 if (! desired_glyphs
->enable
[vpos
])
549 desired_glyphs
->used
[vpos
] = 0;
550 desired_glyphs
->highlight
[vpos
] = 0;
551 desired_glyphs
->enable
[vpos
] = 1;
554 if (hpos
> desired_glyphs
->used
[vpos
])
556 GLYPH
*g
= desired_glyphs
->glyphs
[vpos
] + desired_glyphs
->used
[vpos
];
557 GLYPH
*end
= desired_glyphs
->glyphs
[vpos
] + hpos
;
559 desired_glyphs
->used
[vpos
] = hpos
;
565 /* Like bcopy except never gets confused by overlap. */
568 safe_bcopy (from
, to
, size
)
572 if (size
<= 0 || from
== to
)
575 /* If the source and destination don't overlap, then bcopy can
576 handle it. If they do overlap, but the destination is lower in
577 memory than the source, we'll assume bcopy can handle that. */
578 if (to
< from
|| from
+ size
<= to
)
579 bcopy (from
, to
, size
);
581 /* Otherwise, we'll copy from the end. */
584 register char *endf
= from
+ size
;
585 register char *endt
= to
+ size
;
587 /* If TO - FROM is large, then we should break the copy into
588 nonoverlapping chunks of TO - FROM bytes each. However, if
589 TO - FROM is small, then the bcopy function call overhead
590 makes this not worth it. The crossover point could be about
591 anywhere. Since I don't think the obvious copy loop is too
592 bad, I'm trying to err in its favor. */
597 while (endf
!= from
);
609 bcopy (endf
, endt
, to
- from
);
612 /* If SIZE wasn't a multiple of TO - FROM, there will be a
613 little left over. The amount left over is
614 (endt + (to - from)) - to, which is endt - from. */
615 bcopy (from
, to
, endt
- from
);
620 /* Rotate a vector of SIZE bytes right, by DISTANCE bytes.
621 DISTANCE may be negative. */
624 rotate_vector (vector
, size
, distance
)
629 char *temp
= (char *) alloca (size
);
634 bcopy (vector
, temp
+ distance
, size
- distance
);
635 bcopy (vector
+ size
- distance
, temp
, distance
);
636 bcopy (temp
, vector
, size
);
639 /* Scroll lines from vpos FROM up to but not including vpos END
640 down by AMOUNT lines (AMOUNT may be negative).
641 Returns nonzero if done, zero if terminal cannot scroll them. */
644 scroll_frame_lines (frame
, from
, end
, amount
, newpos
)
645 register FRAME_PTR frame
;
646 int from
, end
, amount
, newpos
;
649 register struct frame_glyphs
*current_frame
650 = FRAME_CURRENT_GLYPHS (frame
);
652 int width
= FRAME_WIDTH (frame
);
654 if (!line_ins_del_ok
)
662 update_begin (frame
);
663 set_terminal_window (end
+ amount
);
664 if (!scroll_region_ok
)
665 ins_del_lines (end
, -amount
);
666 ins_del_lines (from
, amount
);
667 set_terminal_window (0);
669 rotate_vector (current_frame
->glyphs
+ from
,
670 sizeof (GLYPH
*) * (end
+ amount
- from
),
671 amount
* sizeof (GLYPH
*));
673 rotate_vector (current_frame
->charstarts
+ from
,
674 sizeof (int *) * (end
+ amount
- from
),
675 amount
* sizeof (int *));
677 safe_bcopy (current_frame
->used
+ from
,
678 current_frame
->used
+ from
+ amount
,
679 (end
- from
) * sizeof current_frame
->used
[0]);
681 safe_bcopy (current_frame
->highlight
+ from
,
682 current_frame
->highlight
+ from
+ amount
,
683 (end
- from
) * sizeof current_frame
->highlight
[0]);
685 safe_bcopy (current_frame
->enable
+ from
,
686 current_frame
->enable
+ from
+ amount
,
687 (end
- from
) * sizeof current_frame
->enable
[0]);
689 /* Adjust the lines by an amount
690 that puts the first of them at NEWPOS. */
691 pos_adjust
= newpos
- current_frame
->charstarts
[from
+ amount
][0];
693 /* Offset each char position in the charstarts lines we moved
695 for (i
= from
+ amount
; i
< end
+ amount
; i
++)
697 int *line
= current_frame
->charstarts
[i
];
699 for (col
= 0; col
< width
; col
++)
701 line
[col
] += pos_adjust
;
703 for (i
= from
; i
< from
+ amount
; i
++)
705 int *line
= current_frame
->charstarts
[i
];
708 for (col
= 0; col
< width
; col
++)
712 /* Mark the lines made empty by scrolling as enabled, empty and
714 bzero (current_frame
->used
+ from
,
715 amount
* sizeof current_frame
->used
[0]);
716 bzero (current_frame
->highlight
+ from
,
717 amount
* sizeof current_frame
->highlight
[0]);
718 for (i
= from
; i
< from
+ amount
; i
++)
720 current_frame
->glyphs
[i
][0] = '\0';
721 current_frame
->charstarts
[i
][0] = -1;
722 current_frame
->enable
[i
] = 1;
725 safe_bcopy (current_frame
->bufp
+ from
,
726 current_frame
->bufp
+ from
+ amount
,
727 (end
- from
) * sizeof current_frame
->bufp
[0]);
729 #ifdef HAVE_WINDOW_SYSTEM
730 if (FRAME_WINDOW_P (frame
))
732 safe_bcopy (current_frame
->top_left_x
+ from
,
733 current_frame
->top_left_x
+ from
+ amount
,
734 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
736 safe_bcopy (current_frame
->top_left_y
+ from
,
737 current_frame
->top_left_y
+ from
+ amount
,
738 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
740 safe_bcopy (current_frame
->pix_width
+ from
,
741 current_frame
->pix_width
+ from
+ amount
,
742 (end
- from
) * sizeof current_frame
->pix_width
[0]);
744 safe_bcopy (current_frame
->pix_height
+ from
,
745 current_frame
->pix_height
+ from
+ amount
,
746 (end
- from
) * sizeof current_frame
->pix_height
[0]);
748 safe_bcopy (current_frame
->max_ascent
+ from
,
749 current_frame
->max_ascent
+ from
+ amount
,
750 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
752 #endif /* HAVE_WINDOW_SYSTEM */
758 update_begin (frame
);
759 set_terminal_window (end
);
760 ins_del_lines (from
+ amount
, amount
);
761 if (!scroll_region_ok
)
762 ins_del_lines (end
+ amount
, -amount
);
763 set_terminal_window (0);
765 rotate_vector (current_frame
->glyphs
+ from
+ amount
,
766 sizeof (GLYPH
*) * (end
- from
- amount
),
767 amount
* sizeof (GLYPH
*));
769 rotate_vector (current_frame
->charstarts
+ from
+ amount
,
770 sizeof (int *) * (end
- from
- amount
),
771 amount
* sizeof (int *));
773 safe_bcopy (current_frame
->used
+ from
,
774 current_frame
->used
+ from
+ amount
,
775 (end
- from
) * sizeof current_frame
->used
[0]);
777 safe_bcopy (current_frame
->highlight
+ from
,
778 current_frame
->highlight
+ from
+ amount
,
779 (end
- from
) * sizeof current_frame
->highlight
[0]);
781 safe_bcopy (current_frame
->enable
+ from
,
782 current_frame
->enable
+ from
+ amount
,
783 (end
- from
) * sizeof current_frame
->enable
[0]);
785 /* Adjust the lines by an amount
786 that puts the first of them at NEWPOS. */
787 pos_adjust
= newpos
- current_frame
->charstarts
[from
+ amount
][0];
789 /* Offset each char position in the charstarts lines we moved
791 for (i
= from
+ amount
; i
< end
+ amount
; i
++)
793 int *line
= current_frame
->charstarts
[i
];
795 for (col
= 0; col
< width
; col
++)
797 line
[col
] += pos_adjust
;
799 for (i
= end
+ amount
; i
< end
; i
++)
801 int *line
= current_frame
->charstarts
[i
];
804 for (col
= 0; col
< width
; col
++)
808 /* Mark the lines made empty by scrolling as enabled, empty and
810 bzero (current_frame
->used
+ end
+ amount
,
811 - amount
* sizeof current_frame
->used
[0]);
812 bzero (current_frame
->highlight
+ end
+ amount
,
813 - amount
* sizeof current_frame
->highlight
[0]);
814 for (i
= end
+ amount
; i
< end
; i
++)
816 current_frame
->glyphs
[i
][0] = '\0';
817 current_frame
->charstarts
[i
][0] = 0;
818 current_frame
->enable
[i
] = 1;
821 safe_bcopy (current_frame
->bufp
+ from
,
822 current_frame
->bufp
+ from
+ amount
,
823 (end
- from
) * sizeof current_frame
->bufp
[0]);
825 #ifdef HAVE_WINDOW_SYSTEM
826 if (FRAME_WINDOW_P (frame
))
828 safe_bcopy (current_frame
->top_left_x
+ from
,
829 current_frame
->top_left_x
+ from
+ amount
,
830 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
832 safe_bcopy (current_frame
->top_left_y
+ from
,
833 current_frame
->top_left_y
+ from
+ amount
,
834 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
836 safe_bcopy (current_frame
->pix_width
+ from
,
837 current_frame
->pix_width
+ from
+ amount
,
838 (end
- from
) * sizeof current_frame
->pix_width
[0]);
840 safe_bcopy (current_frame
->pix_height
+ from
,
841 current_frame
->pix_height
+ from
+ amount
,
842 (end
- from
) * sizeof current_frame
->pix_height
[0]);
844 safe_bcopy (current_frame
->max_ascent
+ from
,
845 current_frame
->max_ascent
+ from
+ amount
,
846 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
848 #endif /* HAVE_WINDOW_SYSTEM */
855 /* After updating a window W that isn't the full frame wide,
856 copy all the columns that W does not occupy
857 into the FRAME_DESIRED_GLYPHS (frame) from the FRAME_PHYS_GLYPHS (frame)
858 so that update_frame will not change those columns. */
860 preserve_other_columns (w
)
864 register struct frame_glyphs
*current_frame
, *desired_frame
;
865 register FRAME_PTR frame
= XFRAME (w
->frame
);
866 int start
= XFASTINT (w
->left
);
867 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
868 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
870 current_frame
= FRAME_CURRENT_GLYPHS (frame
);
871 desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
873 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
875 if (current_frame
->enable
[vpos
] && desired_frame
->enable
[vpos
])
881 bcopy (current_frame
->glyphs
[vpos
],
882 desired_frame
->glyphs
[vpos
],
883 start
* sizeof (current_frame
->glyphs
[vpos
][0]));
884 bcopy (current_frame
->charstarts
[vpos
],
885 desired_frame
->charstarts
[vpos
],
886 start
* sizeof (current_frame
->charstarts
[vpos
][0]));
887 len
= min (start
, current_frame
->used
[vpos
]);
888 if (desired_frame
->used
[vpos
] < len
)
889 desired_frame
->used
[vpos
] = len
;
891 if (current_frame
->used
[vpos
] > end
892 && desired_frame
->used
[vpos
] < current_frame
->used
[vpos
])
894 while (desired_frame
->used
[vpos
] < end
)
896 int used
= desired_frame
->used
[vpos
]++;
897 desired_frame
->glyphs
[vpos
][used
] = SPACEGLYPH
;
898 desired_frame
->glyphs
[vpos
][used
] = 0;
900 bcopy (current_frame
->glyphs
[vpos
] + end
,
901 desired_frame
->glyphs
[vpos
] + end
,
902 ((current_frame
->used
[vpos
] - end
)
903 * sizeof (current_frame
->glyphs
[vpos
][0])));
904 bcopy (current_frame
->charstarts
[vpos
] + end
,
905 desired_frame
->charstarts
[vpos
] + end
,
906 ((current_frame
->used
[vpos
] - end
)
907 * sizeof (current_frame
->charstarts
[vpos
][0])));
908 desired_frame
->used
[vpos
] = current_frame
->used
[vpos
];
916 /* If window w does not need to be updated and isn't the full frame wide,
917 copy all the columns that w does occupy
918 into the FRAME_DESIRED_LINES (frame) from the FRAME_PHYS_LINES (frame)
919 so that update_frame will not change those columns.
921 Have not been able to figure out how to use this correctly. */
923 preserve_my_columns (w
)
926 register int vpos
, fin
;
927 register struct frame_glyphs
*l1
, *l2
;
928 register FRAME_PTR frame
= XFRAME (w
->frame
);
929 int start
= XFASTINT (w
->left
);
930 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
931 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
933 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
935 if ((l1
= FRAME_DESIRED_GLYPHS (frame
)->glyphs
[vpos
+ 1])
936 && (l2
= FRAME_PHYS_GLYPHS (frame
)->glyphs
[vpos
+ 1]))
938 if (l2
->length
> start
&& l1
->length
< l2
->length
)
941 if (fin
> end
) fin
= end
;
942 while (l1
->length
< start
)
943 l1
->body
[l1
->length
++] = ' ';
944 bcopy (l2
->body
+ start
, l1
->body
+ start
, fin
- start
);
953 /* Adjust by ADJUST the charstart values in window W
954 after vpos VPOS, which counts relative to the frame
955 (not relative to W itself). */
958 adjust_window_charstarts (w
, vpos
, adjust
)
963 int left
= XFASTINT (w
->left
);
964 int top
= XFASTINT (w
->top
);
965 int right
= left
+ window_internal_width (w
);
966 int bottom
= top
+ window_internal_height (w
);
969 for (i
= vpos
+ 1; i
< bottom
; i
++)
972 = FRAME_CURRENT_GLYPHS (XFRAME (WINDOW_FRAME (w
)))->charstarts
[i
];
974 for (j
= left
; j
< right
; j
++)
975 if (charstart
[j
] > 0)
976 charstart
[j
] += adjust
;
980 /* Check the charstarts values in the area of window W
981 for internal consistency. We cannot check that they are "right";
982 we can only look for something nonsensical. */
984 verify_charstarts (w
)
987 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
989 int top
= XFASTINT (w
->top
);
990 int bottom
= top
+ window_internal_height (w
);
991 int left
= XFASTINT (w
->left
);
992 int right
= left
+ window_internal_width (w
);
994 int truncate
= (XINT (w
->hscroll
)
995 || (truncate_partial_width_windows
996 && (XFASTINT (w
->width
) < FRAME_WIDTH (f
)))
997 || !NILP (XBUFFER (w
->buffer
)->truncate_lines
));
999 for (i
= top
; i
< bottom
; i
++)
1003 int *charstart
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[i
];
1009 /* If we are truncating lines, allow a jump
1010 in charstarts from one line to the next. */
1011 if (charstart
[left
] < next_line
)
1016 if (charstart
[left
] != next_line
)
1021 for (j
= left
; j
< right
; j
++)
1022 if (charstart
[j
] > 0)
1023 last
= charstart
[j
];
1024 /* Record where the next line should start. */
1026 if (BUF_ZV (XBUFFER (w
->buffer
)) != last
)
1028 /* If there's a newline between the two lines, count that. */
1029 int endchar
= *BUF_CHAR_ADDRESS (XBUFFER (w
->buffer
), last
);
1030 if (endchar
== '\n')
1036 /* On discovering that the redisplay for a window was no good,
1037 cancel the columns of that window, so that when the window is
1038 displayed over again get_display_line will not complain. */
1040 cancel_my_columns (w
)
1044 register struct frame_glyphs
*desired_glyphs
1045 = FRAME_DESIRED_GLYPHS (XFRAME (w
->frame
));
1046 register int start
= XFASTINT (w
->left
);
1047 register int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
1049 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
1050 if (desired_glyphs
->enable
[vpos
]
1051 && desired_glyphs
->used
[vpos
] >= start
)
1052 desired_glyphs
->used
[vpos
] = start
;
1055 /* These functions try to perform directly and immediately on the frame
1056 the necessary output for one change in the buffer.
1057 They may return 0 meaning nothing was done if anything is difficult,
1058 or 1 meaning the output was performed properly.
1059 They assume that the frame was up to date before the buffer
1060 change being displayed. They make various other assumptions too;
1061 see command_loop_1 where these are called. */
1064 direct_output_for_insert (g
)
1067 register FRAME_PTR frame
= selected_frame
;
1068 register struct frame_glyphs
*current_frame
1069 = FRAME_CURRENT_GLYPHS (frame
);
1071 #ifndef COMPILER_REGISTER_BUG
1073 #endif /* COMPILER_REGISTER_BUG */
1074 struct window
*w
= XWINDOW (selected_window
);
1075 #ifndef COMPILER_REGISTER_BUG
1077 #endif /* COMPILER_REGISTER_BUG */
1078 int hpos
= FRAME_CURSOR_X (frame
);
1079 #ifndef COMPILER_REGISTER_BUG
1081 #endif /* COMPILER_REGISTER_BUG */
1082 int vpos
= FRAME_CURSOR_Y (frame
);
1084 /* Give up if about to continue line. */
1085 if (hpos
>= XFASTINT (w
->left
) + window_internal_width (w
) - 1
1087 /* Avoid losing if cursor is in invisible text off left margin */
1088 || (XINT (w
->hscroll
) && hpos
== XFASTINT (w
->left
))
1090 /* Give up if cursor outside window (in minibuf, probably) */
1091 || cursor_in_echo_area
1092 || FRAME_CURSOR_Y (frame
) < XFASTINT (w
->top
)
1093 || FRAME_CURSOR_Y (frame
) >= XFASTINT (w
->top
) + XFASTINT (w
->height
)
1095 /* Give up if cursor not really at FRAME_CURSOR_X, FRAME_CURSOR_Y */
1096 || !display_completed
1098 /* Give up if buffer appears in two places. */
1099 || buffer_shared
> 1
1101 #ifdef USE_TEXT_PROPERTIES
1102 /* Intervals have already been adjusted, point is after the
1103 character that was just inserted. */
1104 /* Give up if character is invisible. */
1105 /* Give up if character has a face property.
1106 At the moment we only lose at end of line or end of buffer
1107 and only with faces that have some background */
1108 /* Instead of wasting time, give up if character has any text properties */
1109 || ! NILP (Ftext_properties_at (make_number (point
- 1), Qnil
))
1112 /* Give up if w is minibuffer and a message is being displayed there */
1113 || (MINI_WINDOW_P (w
) && echo_area_glyphs
))
1121 if (FRAME_WINDOW_P (frame
) || FRAME_MSDOS_P (frame
))
1122 face
= compute_char_face (frame
, w
, point
- 1, -1, -1, &dummy
, point
, 0);
1124 current_frame
->glyphs
[vpos
][hpos
] = MAKE_GLYPH (frame
, g
, face
);
1125 current_frame
->charstarts
[vpos
][hpos
] = point
- 1;
1126 /* Record the entry for after the newly inserted character. */
1127 current_frame
->charstarts
[vpos
][hpos
+ 1] = point
;
1128 adjust_window_charstarts (w
, vpos
, 1);
1130 unchanged_modified
= MODIFF
;
1131 beg_unchanged
= GPT
- BEG
;
1132 XSETFASTINT (w
->last_point
, point
);
1133 XSETFASTINT (w
->last_point_x
, hpos
);
1134 XSETFASTINT (w
->last_modified
, MODIFF
);
1136 reassert_line_highlight (0, vpos
);
1137 write_glyphs (¤t_frame
->glyphs
[vpos
][hpos
], 1);
1139 ++FRAME_CURSOR_X (frame
);
1140 if (hpos
== current_frame
->used
[vpos
])
1142 current_frame
->used
[vpos
] = hpos
+ 1;
1143 current_frame
->glyphs
[vpos
][hpos
+ 1] = 0;
1150 direct_output_forward_char (n
)
1153 register FRAME_PTR frame
= selected_frame
;
1154 register struct window
*w
= XWINDOW (selected_window
);
1155 Lisp_Object position
;
1156 int hpos
= FRAME_CURSOR_X (frame
);
1158 /* Give up if in truncated text at end of line. */
1159 if (hpos
>= XFASTINT (w
->left
) + window_internal_width (w
) - 1)
1162 /* Avoid losing if cursor is in invisible text off left margin
1163 or about to go off either side of window. */
1164 if ((FRAME_CURSOR_X (frame
) == XFASTINT (w
->left
)
1165 && (XINT (w
->hscroll
) || n
< 0))
1167 && (FRAME_CURSOR_X (frame
) + 1 >= window_internal_width (w
) - 1))
1168 || cursor_in_echo_area
)
1171 /* Can't use direct output if highlighting a region. */
1172 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
1175 /* Can't use direct output at an overlay boundary; it might have
1176 before-string or after-string properties. */
1177 if (overlay_touches_p (PT
) || overlay_touches_p (PT
- n
))
1180 #ifdef USE_TEXT_PROPERTIES
1181 /* Don't use direct output next to an invisible character
1182 since we might need to do something special. */
1184 XSETFASTINT (position
, point
);
1185 if (XFASTINT (position
) < ZV
1186 && ! NILP (Fget_char_property (position
,
1191 XSETFASTINT (position
, point
- 1);
1192 if (XFASTINT (position
) >= BEGV
1193 && ! NILP (Fget_char_property (position
,
1199 FRAME_CURSOR_X (frame
) += n
;
1200 XSETFASTINT (w
->last_point_x
, FRAME_CURSOR_X (frame
));
1201 XSETFASTINT (w
->last_point
, point
);
1202 cursor_to (FRAME_CURSOR_Y (frame
), FRAME_CURSOR_X (frame
));
1208 static void update_line ();
1210 /* Update frame F based on the data in FRAME_DESIRED_GLYPHS.
1211 Value is nonzero if redisplay stopped due to pending input.
1212 FORCE nonzero means do not stop for pending input. */
1215 update_frame (f
, force
, inhibit_hairy_id
)
1218 int inhibit_hairy_id
;
1220 register struct frame_glyphs
*current_frame
;
1221 register struct frame_glyphs
*desired_frame
= 0;
1224 int preempt_count
= baud_rate
/ 2400 + 1;
1225 extern input_pending
;
1226 #ifdef HAVE_WINDOW_SYSTEM
1227 register int downto
, leftmost
;
1230 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
1231 calculate_costs (f
);
1233 if (preempt_count
<= 0)
1236 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1238 detect_input_pending ();
1239 if (input_pending
&& !force
)
1247 if (!line_ins_del_ok
)
1248 inhibit_hairy_id
= 1;
1250 /* These are separate to avoid a possible bug in the AIX C compiler. */
1251 current_frame
= FRAME_CURRENT_GLYPHS (f
);
1252 desired_frame
= FRAME_DESIRED_GLYPHS (f
);
1254 /* See if any of the desired lines are enabled; don't compute for
1255 i/d line if just want cursor motion. */
1256 for (i
= 0; i
< FRAME_HEIGHT (f
); i
++)
1257 if (desired_frame
->enable
[i
])
1260 /* Try doing i/d line, if not yet inhibited. */
1261 if (!inhibit_hairy_id
&& i
< FRAME_HEIGHT (f
))
1262 force
|= scrolling (f
);
1264 /* Update the individual lines as needed. Do bottom line first. */
1266 if (desired_frame
->enable
[FRAME_HEIGHT (f
) - 1])
1267 update_line (f
, FRAME_HEIGHT (f
) - 1);
1269 #ifdef HAVE_WINDOW_SYSTEM
1270 if (FRAME_WINDOW_P (f
))
1272 leftmost
= downto
= FRAME_INTERNAL_BORDER_WIDTH (f
);
1273 if (desired_frame
->enable
[0])
1275 current_frame
->top_left_x
[FRAME_HEIGHT (f
) - 1] = leftmost
;
1276 current_frame
->top_left_y
[FRAME_HEIGHT (f
) - 1]
1277 = PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
)
1278 - current_frame
->pix_height
[FRAME_HEIGHT (f
) - 1];
1279 current_frame
->top_left_x
[0] = leftmost
;
1280 current_frame
->top_left_y
[0] = downto
;
1283 #endif /* HAVE_WINDOW_SYSTEM */
1285 /* Now update the rest of the lines. */
1286 for (i
= 0; i
< FRAME_HEIGHT (f
) - 1 && (force
|| !input_pending
); i
++)
1288 if (desired_frame
->enable
[i
])
1290 if (FRAME_TERMCAP_P (f
))
1292 /* Flush out every so many lines.
1293 Also flush out if likely to have more than 1k buffered
1294 otherwise. I'm told that some telnet connections get
1295 really screwed by more than 1k output at once. */
1296 int outq
= PENDING_OUTPUT_COUNT (stdout
);
1298 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
1301 if (preempt_count
== 1)
1303 #ifdef EMACS_OUTQSIZE
1304 if (EMACS_OUTQSIZE (0, &outq
) < 0)
1305 /* Probably not a tty. Ignore the error and reset
1306 * the outq count. */
1307 outq
= PENDING_OUTPUT_COUNT (stdout
);
1310 if (baud_rate
<= outq
&& baud_rate
> 0)
1311 sleep (outq
/ baud_rate
);
1314 if ((i
- 1) % preempt_count
== 0)
1315 detect_input_pending ();
1319 #ifdef HAVE_WINDOW_SYSTEM
1320 if (FRAME_WINDOW_P (f
))
1322 current_frame
->top_left_y
[i
] = downto
;
1323 current_frame
->top_left_x
[i
] = leftmost
;
1325 #endif /* HAVE_WINDOW_SYSTEM */
1328 #ifdef HAVE_WINDOW_SYSTEM
1329 if (FRAME_WINDOW_P (f
))
1330 downto
+= current_frame
->pix_height
[i
];
1331 #endif /* HAVE_WINDOW_SYSTEM */
1333 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
1335 /* Now just clean up termcap drivers and set cursor, etc. */
1338 if ((cursor_in_echo_area
1339 /* If we are showing a message instead of the minibuffer,
1340 show the cursor for the message instead of for the
1341 (now hidden) minibuffer contents. */
1342 || (EQ (minibuf_window
, selected_window
)
1343 && EQ (minibuf_window
, echo_area_window
)
1344 && echo_area_glyphs
!= 0))
1345 /* These cases apply only to the frame that contains
1346 the active minibuffer window. */
1347 && FRAME_HAS_MINIBUF_P (f
)
1348 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
1350 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
1353 if (cursor_in_echo_area
< 0)
1360 /* If the minibuffer is several lines high, find the last
1361 line that has any text on it. */
1362 row
= FRAME_HEIGHT (f
);
1366 if (current_frame
->enable
[row
])
1367 col
= current_frame
->used
[row
];
1371 while (row
> top
&& col
== 0);
1373 if (col
>= FRAME_WIDTH (f
))
1376 if (row
< FRAME_HEIGHT (f
) - 1)
1381 cursor_to (row
, col
);
1384 cursor_to (FRAME_CURSOR_Y (f
), max (min (FRAME_CURSOR_X (f
),
1385 FRAME_WIDTH (f
) - 1), 0));
1391 fflush (termscript
);
1394 /* Here if output is preempted because input is detected. */
1397 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1398 display_completed
= !pause
;
1400 bzero (FRAME_DESIRED_GLYPHS (f
)->enable
, FRAME_HEIGHT (f
));
1404 /* Called when about to quit, to check for doing so
1405 at an improper time. */
1411 if (FRAME_DESIRED_GLYPHS (selected_frame
) == 0)
1413 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[0])
1415 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[FRAME_HEIGHT (selected_frame
) - 1])
1420 /* Decide what insert/delete line to do, and do it */
1422 extern void scrolling_1 ();
1427 int unchanged_at_top
, unchanged_at_bottom
;
1430 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1431 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1432 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1433 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1435 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
1436 register struct frame_glyphs
*current_frame
= FRAME_CURRENT_GLYPHS (frame
);
1437 register struct frame_glyphs
*desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
1439 /* Compute hash codes of all the lines.
1440 Also calculate number of changed lines,
1441 number of unchanged lines at the beginning,
1442 and number of unchanged lines at the end. */
1445 unchanged_at_top
= 0;
1446 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
1447 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
1449 /* Give up on this scrolling if some old lines are not enabled. */
1450 if (!current_frame
->enable
[i
])
1452 old_hash
[i
] = line_hash_code (current_frame
, i
);
1453 if (! desired_frame
->enable
[i
])
1454 new_hash
[i
] = old_hash
[i
];
1456 new_hash
[i
] = line_hash_code (desired_frame
, i
);
1458 if (old_hash
[i
] != new_hash
[i
])
1461 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
1463 else if (i
== unchanged_at_top
)
1465 draw_cost
[i
] = line_draw_cost (desired_frame
, i
);
1466 old_draw_cost
[i
] = line_draw_cost (current_frame
, i
);
1469 /* If changed lines are few, don't allow preemption, don't scroll. */
1470 if (!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400
1471 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
1474 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
1475 - unchanged_at_bottom
);
1477 if (scroll_region_ok
)
1478 free_at_end_vpos
-= unchanged_at_bottom
;
1479 else if (memory_below_frame
)
1480 free_at_end_vpos
= -1;
1482 /* If large window, fast terminal and few lines in common between
1483 current frame and desired frame, don't bother with i/d calc. */
1484 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
1486 10 * scrolling_max_lines_saved (unchanged_at_top
,
1487 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
1488 old_hash
, new_hash
, draw_cost
)))
1491 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
1492 draw_cost
+ unchanged_at_top
- 1,
1493 old_draw_cost
+ unchanged_at_top
- 1,
1494 old_hash
+ unchanged_at_top
- 1,
1495 new_hash
+ unchanged_at_top
- 1,
1496 free_at_end_vpos
- unchanged_at_top
);
1501 /* Return the offset in its buffer of the character at location col, line
1502 in the given window. */
1504 buffer_posn_from_coords (window
, col
, line
)
1505 struct window
*window
;
1508 int hscroll
= XINT (window
->hscroll
);
1509 int window_left
= XFASTINT (window
->left
);
1511 /* The actual width of the window is window->width less one for the
1512 DISP_CONTINUE_GLYPH, and less one if it's not the rightmost
1514 int window_width
= window_internal_width (window
) - 1;
1516 int startp
= marker_position (window
->start
);
1518 /* Since compute_motion will only operate on the current buffer,
1519 we need to save the old one and restore it when we're done. */
1520 struct buffer
*old_current_buffer
= current_buffer
;
1521 struct position
*posn
;
1523 current_buffer
= XBUFFER (window
->buffer
);
1525 /* We can't get a correct result in this case,
1526 but at least prevent compute_motion from crashing. */
1530 /* It would be nice if we could use FRAME_CURRENT_GLYPHS (XFRAME
1531 (window->frame))->bufp to avoid scanning from the very top of
1532 the window, but it isn't maintained correctly, and I'm not even
1533 sure I will keep it. */
1534 posn
= compute_motion (startp
, 0,
1535 ((window
== XWINDOW (minibuf_window
) && startp
== BEG
1536 ? minibuf_prompt_width
: 0)
1537 + (hscroll
? 1 - hscroll
: 0)),
1540 window_width
, hscroll
, 0, window
);
1542 current_buffer
= old_current_buffer
;
1544 /* compute_motion considers frame points past the end of a line
1545 to be *after* the newline, i.e. at the start of the next line.
1546 This is reasonable, but not really what we want. So if the
1547 result is on a line below LINE, back it up one character. */
1548 if (posn
->vpos
> line
)
1549 return posn
->bufpos
- 1;
1551 return posn
->bufpos
;
1558 register GLYPH
*p
= r
;
1559 while (*p
++ == SPACEGLYPH
);
1564 count_match (str1
, str2
)
1567 register GLYPH
*p1
= str1
;
1568 register GLYPH
*p2
= str2
;
1569 while (*p1
++ == *p2
++);
1570 return p1
- str1
- 1;
1573 /* Char insertion/deletion cost vector, from term.c */
1574 extern int *char_ins_del_vector
;
1576 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WIDTH((f))])
1579 update_line (frame
, vpos
)
1580 register FRAME_PTR frame
;
1583 register GLYPH
*obody
, *nbody
, *op1
, *op2
, *np1
, *temp
;
1586 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
1588 register struct frame_glyphs
*current_frame
1589 = FRAME_CURRENT_GLYPHS (frame
);
1590 register struct frame_glyphs
*desired_frame
1591 = FRAME_DESIRED_GLYPHS (frame
);
1593 if (desired_frame
->highlight
[vpos
]
1594 != (current_frame
->enable
[vpos
] && current_frame
->highlight
[vpos
]))
1596 change_line_highlight (desired_frame
->highlight
[vpos
], vpos
,
1597 (current_frame
->enable
[vpos
] ?
1598 current_frame
->used
[vpos
] : 0));
1599 current_frame
->enable
[vpos
] = 0;
1602 reassert_line_highlight (desired_frame
->highlight
[vpos
], vpos
);
1604 if (! current_frame
->enable
[vpos
])
1610 obody
= current_frame
->glyphs
[vpos
];
1611 olen
= current_frame
->used
[vpos
];
1612 if (! current_frame
->highlight
[vpos
])
1614 if (!must_write_spaces
)
1615 while (olen
> 0 && obody
[olen
- 1] == SPACEGLYPH
)
1620 /* For an inverse-video line, remember we gave it
1621 spaces all the way to the frame edge
1622 so that the reverse video extends all the way across. */
1624 while (olen
< FRAME_WIDTH (frame
) - 1)
1625 obody
[olen
++] = SPACEGLYPH
;
1629 /* One way or another, this will enable the line being updated. */
1630 current_frame
->enable
[vpos
] = 1;
1631 current_frame
->used
[vpos
] = desired_frame
->used
[vpos
];
1632 current_frame
->highlight
[vpos
] = desired_frame
->highlight
[vpos
];
1633 current_frame
->bufp
[vpos
] = desired_frame
->bufp
[vpos
];
1635 #ifdef HAVE_WINDOW_SYSTEM
1636 if (FRAME_WINDOW_P (frame
))
1638 current_frame
->pix_width
[vpos
]
1639 = current_frame
->used
[vpos
]
1640 * FONT_WIDTH (FRAME_FONT (frame
));
1641 current_frame
->pix_height
[vpos
]
1642 = FRAME_LINE_HEIGHT (frame
);
1644 #endif /* HAVE_WINDOW_SYSTEM */
1646 if (!desired_frame
->enable
[vpos
])
1652 nbody
= desired_frame
->glyphs
[vpos
];
1653 nlen
= desired_frame
->used
[vpos
];
1655 /* Pretend trailing spaces are not there at all,
1656 unless for one reason or another we must write all spaces. */
1657 if (! desired_frame
->highlight
[vpos
])
1659 if (!must_write_spaces
)
1660 /* We know that the previous character byte contains 0. */
1661 while (nbody
[nlen
- 1] == SPACEGLYPH
)
1666 /* For an inverse-video line, give it extra trailing spaces
1667 all the way to the frame edge
1668 so that the reverse video extends all the way across. */
1670 while (nlen
< FRAME_WIDTH (frame
) - 1)
1671 nbody
[nlen
++] = SPACEGLYPH
;
1674 /* If there's no i/d char, quickly do the best we can without it. */
1675 if (!char_ins_del_ok
)
1680 if (FRAME_X_P (frame
))
1682 /* Under X, erase everything we are going to rewrite,
1683 and rewrite everything from the first char that's changed.
1684 This is part of supporting fonts like Courier
1685 whose chars can overlap outside the char width. */
1686 for (i
= 0; i
< nlen
; i
++)
1687 if (i
>= olen
|| nbody
[i
] != obody
[i
])
1690 cursor_to (vpos
, i
);
1692 clear_end_of_line (olen
);
1693 write_glyphs (nbody
+ i
, nlen
- i
);
1698 for (i
= 0; i
< nlen
; i
++)
1700 if (i
>= olen
|| nbody
[i
] != obody
[i
]) /* A non-matching char. */
1702 cursor_to (vpos
, i
);
1703 for (j
= 1; (i
+ j
< nlen
&&
1704 (i
+ j
>= olen
|| nbody
[i
+j
] != obody
[i
+j
]));
1707 /* Output this run of non-matching chars. */
1708 write_glyphs (nbody
+ i
, j
);
1711 /* Now find the next non-match. */
1715 /* Clear the rest of the line, or the non-clear part of it. */
1718 cursor_to (vpos
, nlen
);
1719 clear_end_of_line (olen
);
1722 /* Exchange contents between current_frame and new_frame. */
1723 temp
= desired_frame
->glyphs
[vpos
];
1724 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1725 current_frame
->glyphs
[vpos
] = temp
;
1727 /* Exchange charstarts between current_frame and new_frame. */
1728 temp1
= desired_frame
->charstarts
[vpos
];
1729 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1730 current_frame
->charstarts
[vpos
] = temp1
;
1737 nsp
= (must_write_spaces
|| desired_frame
->highlight
[vpos
])
1738 ? 0 : count_blanks (nbody
);
1741 cursor_to (vpos
, nsp
);
1742 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
1745 /* Exchange contents between current_frame and new_frame. */
1746 temp
= desired_frame
->glyphs
[vpos
];
1747 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1748 current_frame
->glyphs
[vpos
] = temp
;
1750 /* Exchange charstarts between current_frame and new_frame. */
1751 temp1
= desired_frame
->charstarts
[vpos
];
1752 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1753 current_frame
->charstarts
[vpos
] = temp1
;
1762 /* Compute number of leading blanks in old and new contents. */
1763 osp
= count_blanks (obody
);
1764 if (!desired_frame
->highlight
[vpos
])
1765 nsp
= count_blanks (nbody
);
1769 /* Compute number of matching chars starting with first nonblank. */
1770 begmatch
= count_match (obody
+ osp
, nbody
+ nsp
);
1772 /* Spaces in new match implicit space past the end of old. */
1773 /* A bug causing this to be a no-op was fixed in 18.29. */
1774 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
1777 while (np1
[begmatch
] == SPACEGLYPH
)
1781 /* Avoid doing insert/delete char
1782 just cause number of leading spaces differs
1783 when the following text does not match. */
1784 if (begmatch
== 0 && osp
!= nsp
)
1785 osp
= nsp
= min (osp
, nsp
);
1787 /* Find matching characters at end of line */
1790 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
1791 while (op1
> op2
&& op1
[-1] == np1
[-1])
1796 endmatch
= obody
+ olen
- op1
;
1798 /* Put correct value back in nbody[nlen].
1799 This is important because direct_output_for_insert
1800 can write into the line at a later point.
1801 If this screws up the zero at the end of the line, re-establish it. */
1805 /* tem gets the distance to insert or delete.
1806 endmatch is how many characters we save by doing so.
1809 tem
= (nlen
- nsp
) - (olen
- osp
);
1811 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
1814 /* nsp - osp is the distance to insert or delete.
1815 If that is nonzero, begmatch is known to be nonzero also.
1816 begmatch + endmatch is how much we save by doing the ins/del.
1820 && (!char_ins_del_ok
1821 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
1825 osp
= nsp
= min (osp
, nsp
);
1828 /* Now go through the line, inserting, writing and
1829 deleting as appropriate. */
1833 cursor_to (vpos
, nsp
);
1834 delete_glyphs (osp
- nsp
);
1838 /* If going to delete chars later in line
1839 and insert earlier in the line,
1840 must delete first to avoid losing data in the insert */
1841 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
1843 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
1844 delete_glyphs (olen
+ nsp
- osp
- nlen
);
1845 olen
= nlen
- (nsp
- osp
);
1847 cursor_to (vpos
, osp
);
1848 insert_glyphs ((char *)0, nsp
- osp
);
1852 tem
= nsp
+ begmatch
+ endmatch
;
1853 if (nlen
!= tem
|| olen
!= tem
)
1855 cursor_to (vpos
, nsp
+ begmatch
);
1856 if (!endmatch
|| nlen
== olen
)
1858 /* If new text being written reaches right margin,
1859 there is no need to do clear-to-eol at the end.
1860 (and it would not be safe, since cursor is not
1861 going to be "at the margin" after the text is done) */
1862 if (nlen
== FRAME_WIDTH (frame
))
1864 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1868 /* the following code loses disastrously if tem == nlen.
1869 Rather than trying to fix that case, I am trying the simpler
1870 solution found above. */
1872 /* If the text reaches to the right margin,
1873 it will lose one way or another (depending on AutoWrap)
1874 to clear to end of line after outputting all the text.
1875 So pause with one character to go and clear the line then. */
1876 if (nlen
== FRAME_WIDTH (frame
) && fast_clear_end_of_line
&& olen
> nlen
)
1878 /* endmatch must be zero, and tem must equal nsp + begmatch */
1879 write_glyphs (nbody
+ tem
, nlen
- tem
- 1);
1880 clear_end_of_line (olen
);
1881 olen
= 0; /* Don't let it be cleared again later */
1882 write_glyphs (nbody
+ nlen
- 1, 1);
1885 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1886 #endif /* OBSOLETE */
1889 else if (nlen
> olen
)
1891 write_glyphs (nbody
+ nsp
+ begmatch
, olen
- tem
);
1892 insert_glyphs (nbody
+ nsp
+ begmatch
+ olen
- tem
, nlen
- olen
);
1895 else if (olen
> nlen
)
1897 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1898 delete_glyphs (olen
- nlen
);
1904 /* If any unerased characters remain after the new line, erase them. */
1907 cursor_to (vpos
, nlen
);
1908 clear_end_of_line (olen
);
1911 /* Exchange contents between current_frame and new_frame. */
1912 temp
= desired_frame
->glyphs
[vpos
];
1913 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1914 current_frame
->glyphs
[vpos
] = temp
;
1916 /* Exchange charstarts between current_frame and new_frame. */
1917 temp1
= desired_frame
->charstarts
[vpos
];
1918 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1919 current_frame
->charstarts
[vpos
] = temp1
;
1922 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
1923 session's frames, frame names, buffers, buffer-read-only flags, and
1924 buffer-modified-flags, and a trailing sentinel (so we don't need to
1925 add length checks). */
1926 static Lisp_Object frame_and_buffer_state
;
1928 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
1929 Sframe_or_buffer_changed_p
, 0, 0, 0,
1930 "Return non-nil if the frame and buffer state appears to have changed.\n\
1931 The state variable is an internal vector containing all frames and buffers,\n\
1932 aside from buffers whose names start with space,\n\
1933 along with the buffers' read-only and modified flags, which allows a fast\n\
1934 check to see whether the menu bars might need to be recomputed.\n\
1935 If this function returns non-nil, it updates the internal vector to reflect\n\
1936 the current state.\n")
1939 Lisp_Object tail
, frame
, buf
;
1943 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
1944 FOR_EACH_FRAME (tail
, frame
)
1946 if (!EQ (*vecp
++, frame
))
1948 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
1951 /* Check that the buffer info matches.
1952 No need to test for the end of the vector
1953 because the last element of the vector is lambda
1954 and that will always cause a mismatch. */
1955 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1957 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
1958 /* Ignore buffers that aren't included in buffer lists. */
1959 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
1961 if (!EQ (*vecp
++, buf
))
1963 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
1965 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
1968 /* Detect deletion of a buffer at the end of the list. */
1969 if (*vecp
== Qlambda
)
1972 /* Start with 1 so there is room for at least one lambda at the end. */
1974 FOR_EACH_FRAME (tail
, frame
)
1976 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1978 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
1979 if (n
> XVECTOR (frame_and_buffer_state
)->size
1980 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
1981 /* Add 20 extra so we grow it less often. */
1982 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
1983 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
1984 FOR_EACH_FRAME (tail
, frame
)
1987 *vecp
++ = XFRAME (frame
)->name
;
1989 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1991 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
1992 /* Ignore buffers that aren't included in buffer lists. */
1993 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
1996 *vecp
++ = XBUFFER (buf
)->read_only
;
1997 *vecp
++ = Fbuffer_modified_p (buf
);
1999 /* Fill up the vector with lambdas (always at least one). */
2001 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
2002 < XVECTOR (frame_and_buffer_state
)->size
)
2004 /* Make sure we didn't overflow the vector. */
2005 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
2006 > XVECTOR (frame_and_buffer_state
)->size
)
2011 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
2012 1, 1, "FOpen termscript file: ",
2013 "Start writing all terminal output to FILE as well as the terminal.\n\
2014 FILE = nil means just close any termscript file currently open.")
2018 if (termscript
!= 0) fclose (termscript
);
2023 file
= Fexpand_file_name (file
, Qnil
);
2024 termscript
= fopen (XSTRING (file
)->data
, "w");
2025 if (termscript
== 0)
2026 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
2034 window_change_signal (signalnum
) /* If we don't have an argument, */
2035 int signalnum
; /* some compilers complain in signal calls. */
2039 int old_errno
= errno
;
2041 get_frame_size (&width
, &height
);
2043 /* The frame size change obviously applies to a termcap-controlled
2044 frame. Find such a frame in the list, and assume it's the only
2045 one (since the redisplay code always writes to stdout, not a
2046 FILE * specified in the frame structure). Record the new size,
2047 but don't reallocate the data structures now. Let that be done
2048 later outside of the signal handler. */
2051 Lisp_Object tail
, frame
;
2053 FOR_EACH_FRAME (tail
, frame
)
2055 if (FRAME_TERMCAP_P (XFRAME (frame
)))
2057 change_frame_size (XFRAME (frame
), height
, width
, 0, 1);
2063 signal (SIGWINCH
, window_change_signal
);
2066 #endif /* SIGWINCH */
2069 /* Do any change in frame size that was requested by a signal. */
2071 do_pending_window_change ()
2073 /* If window_change_signal should have run before, run it now. */
2074 while (delayed_size_change
)
2076 Lisp_Object tail
, frame
;
2078 delayed_size_change
= 0;
2080 FOR_EACH_FRAME (tail
, frame
)
2082 FRAME_PTR f
= XFRAME (frame
);
2084 int height
= FRAME_NEW_HEIGHT (f
);
2085 int width
= FRAME_NEW_WIDTH (f
);
2087 if (height
!= 0 || width
!= 0)
2088 change_frame_size (f
, height
, width
, 0, 0);
2094 /* Change the frame height and/or width. Values may be given as zero to
2095 indicate no change is to take place.
2097 If DELAY is non-zero, then assume we're being called from a signal
2098 handler, and queue the change for later - perhaps the next
2099 redisplay. Since this tries to resize windows, we can't call it
2100 from a signal handler. */
2102 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
)
2103 register FRAME_PTR f
;
2104 int newheight
, newwidth
, pretend
;
2106 Lisp_Object tail
, frame
;
2107 if (! FRAME_WINDOW_P (f
))
2109 /* When using termcap, or on MS-DOS, all frames use
2110 the same screen, so a change in size affects all frames. */
2111 FOR_EACH_FRAME (tail
, frame
)
2112 if (! FRAME_WINDOW_P (XFRAME (frame
)))
2113 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
2117 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
);
2121 change_frame_size_1 (frame
, newheight
, newwidth
, pretend
, delay
)
2122 register FRAME_PTR frame
;
2123 int newheight
, newwidth
, pretend
, delay
;
2125 /* If we can't deal with the change now, queue it for later. */
2128 FRAME_NEW_HEIGHT (frame
) = newheight
;
2129 FRAME_NEW_WIDTH (frame
) = newwidth
;
2130 delayed_size_change
= 1;
2134 /* This size-change overrides any pending one for this frame. */
2135 FRAME_NEW_HEIGHT (frame
) = 0;
2136 FRAME_NEW_WIDTH (frame
) = 0;
2138 /* If an argument is zero, set it to the current value. */
2139 newheight
|| (newheight
= FRAME_HEIGHT (frame
));
2140 newwidth
|| (newwidth
= FRAME_WIDTH (frame
));
2142 /* Round up to the smallest acceptable size. */
2143 check_frame_size (frame
, &newheight
, &newwidth
);
2145 /* If we're not changing the frame size, quit now. */
2146 if (newheight
== FRAME_HEIGHT (frame
)
2147 && newwidth
== FRAME_WIDTH (frame
))
2153 /* We only can set screen dimensions to certain values supported
2154 by our video hardware. Try to find the smallest size greater
2155 or equal to the requested dimensions. */
2156 dos_set_window_size (&newheight
, &newwidth
);
2159 if (newheight
!= FRAME_HEIGHT (frame
))
2161 if (FRAME_HAS_MINIBUF_P (frame
)
2162 && ! FRAME_MINIBUF_ONLY_P (frame
))
2164 /* Frame has both root and minibuffer. */
2165 set_window_height (FRAME_ROOT_WINDOW (frame
),
2166 newheight
- 1 - FRAME_MENU_BAR_LINES (frame
), 0);
2167 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (frame
))->top
,
2169 set_window_height (FRAME_MINIBUF_WINDOW (frame
), 1, 0);
2172 /* Frame has just one top-level window. */
2173 set_window_height (FRAME_ROOT_WINDOW (frame
),
2174 newheight
- FRAME_MENU_BAR_LINES (frame
), 0);
2176 if (FRAME_TERMCAP_P (frame
) && !pretend
)
2177 FrameRows
= newheight
;
2180 if (frame
->output_method
== output_termcap
)
2182 frame_height
= newheight
;
2184 FrameRows
= newheight
;
2189 if (newwidth
!= FRAME_WIDTH (frame
))
2191 set_window_width (FRAME_ROOT_WINDOW (frame
), newwidth
, 0);
2192 if (FRAME_HAS_MINIBUF_P (frame
))
2193 set_window_width (FRAME_MINIBUF_WINDOW (frame
), newwidth
, 0);
2195 if (FRAME_TERMCAP_P (frame
) && !pretend
)
2196 FrameCols
= newwidth
;
2198 if (frame
->output_method
== output_termcap
)
2200 frame_width
= newwidth
;
2202 FrameCols
= newwidth
;
2207 FRAME_HEIGHT (frame
) = newheight
;
2208 FRAME_WIDTH (frame
) = newwidth
;
2210 if (FRAME_CURSOR_X (frame
) >= FRAME_WIDTH (frame
))
2211 FRAME_CURSOR_X (frame
) = FRAME_WIDTH (frame
) - 1;
2212 if (FRAME_CURSOR_Y (frame
) >= FRAME_HEIGHT (frame
))
2213 FRAME_CURSOR_Y (frame
) = FRAME_HEIGHT (frame
) - 1;
2215 remake_frame_glyphs (frame
);
2216 calculate_costs (frame
);
2221 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
2222 Ssend_string_to_terminal
, 1, 1, 0,
2223 "Send STRING to the terminal without alteration.\n\
2224 Control characters in STRING will have terminal-dependent effects.")
2228 CHECK_STRING (string
, 0);
2229 fwrite (XSTRING (string
)->data
, 1, XSTRING (string
)->size
, stdout
);
2233 fwrite (XSTRING (string
)->data
, 1, XSTRING (string
)->size
, termscript
);
2234 fflush (termscript
);
2239 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
2240 "Beep, or flash the screen.\n\
2241 Also, unless an argument is given,\n\
2242 terminate any keyboard macro currently executing.")
2264 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
2265 error ("Keyboard macro terminated by a command ringing the bell");
2271 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
2272 "Pause, without updating display, for SECONDS seconds.\n\
2273 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2274 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2275 additional wait period, in milliseconds; this may be useful if your\n\
2276 Emacs was built without floating point support.\n\
2277 \(Not all operating systems support waiting for a fraction of a second.)")
2278 (seconds
, milliseconds
)
2279 Lisp_Object seconds
, milliseconds
;
2283 if (NILP (milliseconds
))
2284 XSETINT (milliseconds
, 0);
2286 CHECK_NUMBER (milliseconds
, 1);
2287 usec
= XINT (milliseconds
) * 1000;
2289 #ifdef LISP_FLOAT_TYPE
2291 double duration
= extract_float (seconds
);
2292 sec
= (int) duration
;
2293 usec
+= (duration
- sec
) * 1000000;
2296 CHECK_NUMBER (seconds
, 0);
2297 sec
= XINT (seconds
);
2300 #ifndef EMACS_HAS_USECS
2301 if (sec
== 0 && usec
!= 0)
2302 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
2305 /* Assure that 0 <= usec < 1000000. */
2308 /* We can't rely on the rounding being correct if user is negative. */
2309 if (-1000000 < usec
)
2310 sec
--, usec
+= 1000000;
2312 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
2315 sec
+= usec
/ 1000000, usec
%= 1000000;
2317 if (sec
< 0 || (sec
== 0 && usec
== 0))
2323 XSETFASTINT (zero
, 0);
2324 wait_reading_process_input (sec
, usec
, zero
, 0);
2327 /* We should always have wait_reading_process_input; we have a dummy
2328 implementation for systems which don't support subprocesses. */
2330 /* No wait_reading_process_input */
2337 /* The reason this is done this way
2338 (rather than defined (H_S) && defined (H_T))
2339 is because the VMS preprocessor doesn't grok `defined' */
2341 EMACS_GET_TIME (end_time
);
2342 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
2343 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
2347 EMACS_GET_TIME (timeout
);
2348 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
2349 if (EMACS_TIME_NEG_P (timeout
)
2350 || !select (1, 0, 0, 0, &timeout
))
2353 #else /* not HAVE_SELECT */
2355 #endif /* HAVE_SELECT */
2356 #endif /* not VMS */
2359 #endif /* no subprocesses */
2364 /* This is just like wait_reading_process_input, except that
2365 it does the redisplay.
2367 It's also much like Fsit_for, except that it can be used for
2368 waiting for input as well. */
2371 sit_for (sec
, usec
, reading
, display
)
2372 int sec
, usec
, reading
, display
;
2374 Lisp_Object read_kbd
;
2376 swallow_events (display
);
2378 if (detect_input_pending_run_timers (display
))
2382 redisplay_preserve_echo_area ();
2384 if (sec
== 0 && usec
== 0)
2391 XSETINT (read_kbd
, reading
? -1 : 1);
2392 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
2395 /* wait_reading_process_input should always be available now; it is
2396 simulated in a simple way on systems that don't support
2399 /* No wait_reading_process_input available. */
2405 input_wait_timeout (XINT (arg
));
2407 #ifndef HAVE_TIMEVAL
2409 select (1, &waitchannels
, 0, 0, &timeout_sec
);
2410 #else /* HAVE_TIMEVAL */
2411 timeout
.tv_sec
= sec
;
2412 timeout
.tv_usec
= usec
;
2413 select (1, &waitchannels
, 0, 0, &timeout
);
2414 #endif /* HAVE_TIMEVAL */
2415 #endif /* not VMS */
2420 return detect_input_pending () ? Qnil
: Qt
;
2423 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
2424 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
2425 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2426 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2427 additional wait period, in milliseconds; this may be useful if your\n\
2428 Emacs was built without floating point support.\n\
2429 \(Not all operating systems support waiting for a fraction of a second.)\n\
2430 Optional third arg NODISP non-nil means don't redisplay, just wait for input.\n\
2431 Redisplay is preempted as always if input arrives, and does not happen\n\
2432 if input is available before it starts.\n\
2433 Value is t if waited the full time with no input arriving.")
2434 (seconds
, milliseconds
, nodisp
)
2435 Lisp_Object seconds
, milliseconds
, nodisp
;
2439 if (NILP (milliseconds
))
2440 XSETINT (milliseconds
, 0);
2442 CHECK_NUMBER (milliseconds
, 1);
2443 usec
= XINT (milliseconds
) * 1000;
2445 #ifdef LISP_FLOAT_TYPE
2447 double duration
= extract_float (seconds
);
2448 sec
= (int) duration
;
2449 usec
+= (duration
- sec
) * 1000000;
2452 CHECK_NUMBER (seconds
, 0);
2453 sec
= XINT (seconds
);
2456 #ifndef EMACS_HAS_USECS
2457 if (usec
!= 0 && sec
== 0)
2458 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
2461 return sit_for (sec
, usec
, 0, NILP (nodisp
));
2464 char *terminal_type
;
2466 /* Initialization done when Emacs fork is started, before doing stty. */
2467 /* Determine terminal type and set terminal_driver */
2468 /* Then invoke its decoding routine to set up variables
2469 in the terminal package */
2473 #ifdef HAVE_X_WINDOWS
2474 extern int display_arg
;
2479 cursor_in_echo_area
= 0;
2480 terminal_type
= (char *) 0;
2482 /* Now is the time to initialize this; it's used by init_sys_modes
2484 Vwindow_system
= Qnil
;
2486 /* If the user wants to use a window system, we shouldn't bother
2487 initializing the terminal. This is especially important when the
2488 terminal is so dumb that emacs gives up before and doesn't bother
2489 using the window system.
2491 If the DISPLAY environment variable is set and nonempty,
2492 try to use X, and die with an error message if that doesn't work. */
2494 #ifdef HAVE_X_WINDOWS
2499 display
= getenv ("DECW$DISPLAY");
2501 display
= getenv ("DISPLAY");
2504 display_arg
= (display
!= 0 && *display
!= 0);
2507 if (!inhibit_window_system
&& display_arg
)
2509 Vwindow_system
= intern ("x");
2511 Vwindow_system_version
= make_number (11);
2513 Vwindow_system_version
= make_number (10);
2515 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
2516 /* In some versions of ncurses,
2517 tputs crashes if we have not called tgetent.
2519 { char b
[2044]; tgetent (b
, "xterm");}
2523 #endif /* HAVE_X_WINDOWS */
2526 if (!inhibit_window_system
)
2528 Vwindow_system
= intern ("win32");
2529 Vwindow_system_version
= make_number (1);
2532 #endif /* HAVE_NTGUI */
2534 /* If no window system has been specified, try to use the terminal. */
2537 fprintf (stderr
, "emacs: standard input is not a tty\n");
2541 /* Look at the TERM variable */
2542 terminal_type
= (char *) getenv ("TERM");
2546 fprintf (stderr
, "Please specify your terminal type.\n\
2547 For types defined in VMS, use set term /device=TYPE.\n\
2548 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
2549 \(The quotation marks are necessary since terminal types are lower case.)\n");
2551 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
2557 /* VMS DCL tends to upcase things, so downcase term type.
2558 Hardly any uppercase letters in terminal types; should be none. */
2560 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
2563 strcpy (new, terminal_type
);
2565 for (p
= new; *p
; p
++)
2569 terminal_type
= new;
2573 term_init (terminal_type
);
2575 remake_frame_glyphs (selected_frame
);
2576 calculate_costs (selected_frame
);
2578 /* X and Y coordinates of the cursor between updates. */
2579 FRAME_CURSOR_X (selected_frame
) = 0;
2580 FRAME_CURSOR_Y (selected_frame
) = 0;
2585 #endif /* CANNOT_DUMP */
2586 signal (SIGWINCH
, window_change_signal
);
2587 #endif /* SIGWINCH */
2593 defsubr (&Sredraw_frame
);
2595 defsubr (&Sredraw_display
);
2596 defsubr (&Sframe_or_buffer_changed_p
);
2597 defsubr (&Sopen_termscript
);
2599 defsubr (&Ssit_for
);
2600 defsubr (&Ssleep_for
);
2601 defsubr (&Ssend_string_to_terminal
);
2603 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
2604 staticpro (&frame_and_buffer_state
);
2606 Qdisplay_table
= intern ("display-table");
2607 staticpro (&Qdisplay_table
);
2609 DEFVAR_INT ("baud-rate", &baud_rate
,
2610 "*The output baud rate of the terminal.\n\
2611 On most systems, changing this value will affect the amount of padding\n\
2612 and the other strategic decisions made during redisplay.");
2613 DEFVAR_BOOL ("inverse-video", &inverse_video
,
2614 "*Non-nil means invert the entire frame display.\n\
2615 This means everything is in inverse video which otherwise would not be.");
2616 DEFVAR_BOOL ("visible-bell", &visible_bell
,
2617 "*Non-nil means try to flash the frame to represent a bell.");
2618 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
2619 "*Non-nil means no need to redraw entire frame after suspending.\n\
2620 A non-nil value is useful if the terminal can automatically preserve\n\
2621 Emacs's frame display when you reenter Emacs.\n\
2622 It is up to you to set this variable if your terminal can do that.");
2623 DEFVAR_LISP ("window-system", &Vwindow_system
,
2624 "A symbol naming the window-system under which Emacs is running\n\
2625 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
2626 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
2627 "The version number of the window system in use.\n\
2628 For X windows, this is 10 or 11.");
2629 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
2630 "Non-nil means put cursor in minibuffer, at end of any message there.");
2631 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
2632 "Table defining how to output a glyph code to the frame.\n\
2633 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
2634 Each element can be:\n\
2635 integer: a glyph code which this glyph is an alias for.\n\
2636 string: output this glyph using that string (not impl. in X windows).\n\
2637 nil: this glyph mod 256 is char code to output,\n\
2638 and this glyph / 256 is face code for X windows (see `face-id').");
2639 Vglyph_table
= Qnil
;
2641 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
2642 "Display table to use for buffers that specify none.\n\
2643 See `buffer-display-table' for more information.");
2644 Vstandard_display_table
= Qnil
;
2646 /* Initialize `window-system', unless init_display already decided it. */
2651 Vwindow_system
= Qnil
;
2652 Vwindow_system_version
= Qnil
;