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 /* This is a vector, made larger whenever it isn't large enough,
148 which is used inside `update_frame' to hold the old contents
149 of the FRAME_PHYS_LINES of the frame being updated. */
150 struct frame_glyphs
**ophys_lines
;
151 /* Length of vector currently allocated. */
152 int ophys_lines_length
;
154 FILE *termscript
; /* Stdio stream being used for copy of all output. */
156 struct cm Wcm
; /* Structure for info on cursor positioning */
158 int delayed_size_change
; /* 1 means SIGWINCH happened when not safe. */
160 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
161 "Clear frame FRAME and output again what is supposed to appear on it.")
167 CHECK_LIVE_FRAME (frame
, 0);
170 if (FRAME_MSDOS_P (f
))
171 set_terminal_modes ();
173 clear_frame_records (f
);
176 windows_or_buffers_changed
++;
177 /* Mark all windows as INaccurate,
178 so that every window will have its redisplay done. */
179 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
188 XSETFRAME (frame
, f
);
189 Fredraw_frame (frame
);
192 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
193 "Clear and redisplay all visible frames.")
196 Lisp_Object tail
, frame
;
198 FOR_EACH_FRAME (tail
, frame
)
199 if (FRAME_VISIBLE_P (XFRAME (frame
)))
200 Fredraw_frame (frame
);
205 /* This is used when frame_garbaged is set.
206 Redraw the individual frames marked as garbaged. */
209 redraw_garbaged_frames ()
211 Lisp_Object tail
, frame
;
213 FOR_EACH_FRAME (tail
, frame
)
214 if (FRAME_VISIBLE_P (XFRAME (frame
))
215 && FRAME_GARBAGED_P (XFRAME (frame
)))
216 Fredraw_frame (frame
);
220 static struct frame_glyphs
*
221 make_frame_glyphs (frame
, empty
)
222 register FRAME_PTR frame
;
226 register width
= FRAME_WINDOW_WIDTH (frame
);
227 register height
= FRAME_HEIGHT (frame
);
228 register struct frame_glyphs
*new
229 = (struct frame_glyphs
*) xmalloc (sizeof (struct frame_glyphs
));
231 SET_GLYPHS_FRAME (new, frame
);
232 new->height
= height
;
234 new->used
= (int *) xmalloc (height
* sizeof (int));
235 new->glyphs
= (GLYPH
**) xmalloc (height
* sizeof (GLYPH
*));
236 new->charstarts
= (int **) xmalloc (height
* sizeof (int *));
237 new->highlight
= (char *) xmalloc (height
* sizeof (char));
238 new->enable
= (char *) xmalloc (height
* sizeof (char));
239 bzero (new->enable
, height
* sizeof (char));
240 new->bufp
= (int *) xmalloc (height
* sizeof (int));
242 #ifdef HAVE_WINDOW_SYSTEM
243 if (FRAME_WINDOW_P (frame
))
245 new->top_left_x
= (short *) xmalloc (height
* sizeof (short));
246 new->top_left_y
= (short *) xmalloc (height
* sizeof (short));
247 new->pix_width
= (short *) xmalloc (height
* sizeof (short));
248 new->pix_height
= (short *) xmalloc (height
* sizeof (short));
249 new->max_ascent
= (short *) xmalloc (height
* sizeof (short));
251 #endif /* HAVE_WINDOW_SYSTEM */
255 /* Make the buffer used by decode_mode_spec. This buffer is also
256 used as temporary storage when updating the frame. See scroll.c. */
257 unsigned int total_glyphs
= (width
+ 2) * sizeof (GLYPH
);
258 unsigned int total_charstarts
= (width
+ 2) * sizeof (int);
260 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
261 bzero (new->total_contents
, total_glyphs
);
263 new->total_charstarts
= (int *) xmalloc (total_charstarts
);
264 bzero (new->total_charstarts
, total_charstarts
);
268 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (GLYPH
);
270 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
271 bzero (new->total_contents
, total_glyphs
);
272 for (i
= 0; i
< height
; i
++)
273 new->glyphs
[i
] = new->total_contents
+ i
* (width
+ 2) + 1;
275 if (!FRAME_TERMCAP_P (frame
))
277 unsigned int total_charstarts
= height
* (width
+ 2) * sizeof (int);
279 new->total_charstarts
= (int *) xmalloc (total_charstarts
);
280 bzero (new->total_charstarts
, total_charstarts
);
281 for (i
= 0; i
< height
; i
++)
282 new->charstarts
[i
] = new->total_charstarts
+ i
* (width
+ 2) + 1;
286 /* Without a window system, we don't really need charstarts.
287 So use a small amount of space to make enough data structure
288 to prevent crashes in display_text_line. */
289 new->total_charstarts
= (int *) xmalloc ((width
+ 2) * sizeof (int));
290 for (i
= 0; i
< height
; i
++)
291 new->charstarts
[i
] = new->total_charstarts
;
299 free_frame_glyphs (frame
, glyphs
)
301 struct frame_glyphs
*glyphs
;
303 if (glyphs
->total_contents
)
304 xfree (glyphs
->total_contents
);
305 if (glyphs
->total_charstarts
)
306 xfree (glyphs
->total_charstarts
);
308 xfree (glyphs
->used
);
309 xfree (glyphs
->glyphs
);
310 xfree (glyphs
->highlight
);
311 xfree (glyphs
->enable
);
312 xfree (glyphs
->bufp
);
313 if (glyphs
->charstarts
)
314 xfree (glyphs
->charstarts
);
316 #ifdef HAVE_WINDOW_SYSTEM
317 if (FRAME_WINDOW_P (frame
))
319 xfree (glyphs
->top_left_x
);
320 xfree (glyphs
->top_left_y
);
321 xfree (glyphs
->pix_width
);
322 xfree (glyphs
->pix_height
);
323 xfree (glyphs
->max_ascent
);
325 #endif /* HAVE_WINDOW_SYSTEM */
331 remake_frame_glyphs (frame
)
334 if (FRAME_CURRENT_GLYPHS (frame
))
335 free_frame_glyphs (frame
, FRAME_CURRENT_GLYPHS (frame
));
336 if (FRAME_DESIRED_GLYPHS (frame
))
337 free_frame_glyphs (frame
, FRAME_DESIRED_GLYPHS (frame
));
338 if (FRAME_TEMP_GLYPHS (frame
))
339 free_frame_glyphs (frame
, FRAME_TEMP_GLYPHS (frame
));
341 if (FRAME_MESSAGE_BUF (frame
))
343 /* Reallocate the frame's message buffer; remember that
344 echo_area_glyphs may be pointing here. */
345 char *old_message_buf
= FRAME_MESSAGE_BUF (frame
);
347 FRAME_MESSAGE_BUF (frame
)
348 = (char *) xrealloc (FRAME_MESSAGE_BUF (frame
),
349 FRAME_WIDTH (frame
) + 1);
351 if (echo_area_glyphs
== old_message_buf
)
352 echo_area_glyphs
= FRAME_MESSAGE_BUF (frame
);
353 if (previous_echo_glyphs
== old_message_buf
)
354 previous_echo_glyphs
= FRAME_MESSAGE_BUF (frame
);
357 FRAME_MESSAGE_BUF (frame
)
358 = (char *) xmalloc (FRAME_WIDTH (frame
) + 1);
360 FRAME_CURRENT_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
361 FRAME_DESIRED_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
362 FRAME_TEMP_GLYPHS (frame
) = make_frame_glyphs (frame
, 1);
363 if (FRAME_WINDOW_P (frame
) || frame
== selected_frame
)
364 SET_FRAME_GARBAGED (frame
);
367 /* Return the hash code of contents of line VPOS in frame-matrix M. */
370 line_hash_code (m
, vpos
)
371 register struct frame_glyphs
*m
;
374 register GLYPH
*body
, *end
;
377 if (!m
->enable
[vpos
])
380 /* Give all highlighted lines the same hash code
381 so as to encourage scrolling to leave them in place. */
382 if (m
->highlight
[vpos
])
385 body
= m
->glyphs
[vpos
];
387 if (must_write_spaces
)
394 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
- SPACEGLYPH
;
403 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
;
411 /* Return number of characters in line in M at vpos VPOS,
412 except don't count leading and trailing spaces
413 unless the terminal requires those to be explicitly output. */
416 line_draw_cost (m
, vpos
)
417 struct frame_glyphs
*m
;
420 register GLYPH
*beg
= m
->glyphs
[vpos
];
421 register GLYPH
*end
= m
->glyphs
[vpos
] + m
->used
[vpos
];
423 register int tlen
= GLYPH_TABLE_LENGTH
;
424 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
426 /* Ignore trailing and leading spaces if we can. */
427 if (!must_write_spaces
)
429 while ((end
!= beg
) && (*end
== SPACEGLYPH
))
432 return (0); /* All blank line. */
434 while (*beg
== SPACEGLYPH
)
438 /* If we don't have a glyph-table, each glyph is one character,
439 so return the number of glyphs. */
443 /* Otherwise, scan the glyphs and accumulate their total size in I. */
445 while ((beg
<= end
) && *beg
)
447 register GLYPH g
= *beg
++;
449 if (GLYPH_SIMPLE_P (tbase
, tlen
, g
))
452 i
+= GLYPH_LENGTH (tbase
, g
);
457 /* The functions on this page are the interface from xdisp.c to redisplay.
459 The only other interface into redisplay is through setting
460 FRAME_CURSOR_X (frame) and FRAME_CURSOR_Y (frame)
461 and SET_FRAME_GARBAGED (frame). */
463 /* cancel_line eliminates any request to display a line at position `vpos' */
465 cancel_line (vpos
, frame
)
467 register FRAME_PTR frame
;
469 FRAME_DESIRED_GLYPHS (frame
)->enable
[vpos
] = 0;
472 clear_frame_records (frame
)
473 register FRAME_PTR frame
;
475 bzero (FRAME_CURRENT_GLYPHS (frame
)->enable
, FRAME_HEIGHT (frame
));
478 /* Clear out all display lines for a coming redisplay. */
481 init_desired_glyphs (frame
)
482 register FRAME_PTR frame
;
484 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (frame
);
486 int height
= FRAME_HEIGHT (frame
);
488 for (vpos
= 0; vpos
< height
; vpos
++)
489 desired_glyphs
->enable
[vpos
] = 0;
492 /* Prepare to display on line VPOS starting at HPOS within it. */
495 get_display_line (frame
, vpos
, hpos
)
496 register FRAME_PTR frame
;
500 register struct frame_glyphs
*glyphs
;
501 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (frame
);
507 if (! desired_glyphs
->enable
[vpos
])
509 desired_glyphs
->used
[vpos
] = 0;
510 desired_glyphs
->highlight
[vpos
] = 0;
511 desired_glyphs
->enable
[vpos
] = 1;
514 if (hpos
> desired_glyphs
->used
[vpos
])
516 GLYPH
*g
= desired_glyphs
->glyphs
[vpos
] + desired_glyphs
->used
[vpos
];
517 GLYPH
*end
= desired_glyphs
->glyphs
[vpos
] + hpos
;
519 desired_glyphs
->used
[vpos
] = hpos
;
525 /* Like bcopy except never gets confused by overlap. */
528 safe_bcopy (from
, to
, size
)
532 if (size
<= 0 || from
== to
)
535 /* If the source and destination don't overlap, then bcopy can
536 handle it. If they do overlap, but the destination is lower in
537 memory than the source, we'll assume bcopy can handle that. */
538 if (to
< from
|| from
+ size
<= to
)
539 bcopy (from
, to
, size
);
541 /* Otherwise, we'll copy from the end. */
544 register char *endf
= from
+ size
;
545 register char *endt
= to
+ size
;
547 /* If TO - FROM is large, then we should break the copy into
548 nonoverlapping chunks of TO - FROM bytes each. However, if
549 TO - FROM is small, then the bcopy function call overhead
550 makes this not worth it. The crossover point could be about
551 anywhere. Since I don't think the obvious copy loop is too
552 bad, I'm trying to err in its favor. */
557 while (endf
!= from
);
569 bcopy (endf
, endt
, to
- from
);
572 /* If SIZE wasn't a multiple of TO - FROM, there will be a
573 little left over. The amount left over is
574 (endt + (to - from)) - to, which is endt - from. */
575 bcopy (from
, to
, endt
- from
);
580 /* Rotate a vector of SIZE bytes right, by DISTANCE bytes.
581 DISTANCE may be negative. */
584 rotate_vector (vector
, size
, distance
)
589 char *temp
= (char *) alloca (size
);
594 bcopy (vector
, temp
+ distance
, size
- distance
);
595 bcopy (vector
+ size
- distance
, temp
, distance
);
596 bcopy (temp
, vector
, size
);
599 /* Scroll lines from vpos FROM up to but not including vpos END
600 down by AMOUNT lines (AMOUNT may be negative).
601 Returns nonzero if done, zero if terminal cannot scroll them. */
604 scroll_frame_lines (frame
, from
, end
, amount
, newpos
)
605 register FRAME_PTR frame
;
606 int from
, end
, amount
, newpos
;
609 register struct frame_glyphs
*current_frame
610 = FRAME_CURRENT_GLYPHS (frame
);
612 int width
= FRAME_WINDOW_WIDTH (frame
);
614 if (!line_ins_del_ok
)
622 update_begin (frame
);
623 set_terminal_window (end
+ amount
);
624 if (!scroll_region_ok
)
625 ins_del_lines (end
, -amount
);
626 ins_del_lines (from
, amount
);
627 set_terminal_window (0);
629 rotate_vector (current_frame
->glyphs
+ from
,
630 sizeof (GLYPH
*) * (end
+ amount
- from
),
631 amount
* sizeof (GLYPH
*));
633 rotate_vector (current_frame
->charstarts
+ from
,
634 sizeof (int *) * (end
+ amount
- from
),
635 amount
* sizeof (int *));
637 safe_bcopy (current_frame
->used
+ from
,
638 current_frame
->used
+ from
+ amount
,
639 (end
- from
) * sizeof current_frame
->used
[0]);
641 safe_bcopy (current_frame
->highlight
+ from
,
642 current_frame
->highlight
+ from
+ amount
,
643 (end
- from
) * sizeof current_frame
->highlight
[0]);
645 safe_bcopy (current_frame
->enable
+ from
,
646 current_frame
->enable
+ from
+ amount
,
647 (end
- from
) * sizeof current_frame
->enable
[0]);
649 /* Adjust the lines by an amount
650 that puts the first of them at NEWPOS. */
651 pos_adjust
= newpos
- current_frame
->charstarts
[from
+ amount
][0];
653 /* Offset each char position in the charstarts lines we moved
655 for (i
= from
+ amount
; i
< end
+ amount
; i
++)
657 int *line
= current_frame
->charstarts
[i
];
659 for (col
= 0; col
< width
; col
++)
661 line
[col
] += pos_adjust
;
663 for (i
= from
; i
< from
+ amount
; i
++)
665 int *line
= current_frame
->charstarts
[i
];
668 for (col
= 0; col
< width
; col
++)
672 /* Mark the lines made empty by scrolling as enabled, empty and
674 bzero (current_frame
->used
+ from
,
675 amount
* sizeof current_frame
->used
[0]);
676 bzero (current_frame
->highlight
+ from
,
677 amount
* sizeof current_frame
->highlight
[0]);
678 for (i
= from
; i
< from
+ amount
; i
++)
680 current_frame
->glyphs
[i
][0] = '\0';
681 current_frame
->charstarts
[i
][0] = -1;
682 current_frame
->enable
[i
] = 1;
685 safe_bcopy (current_frame
->bufp
+ from
,
686 current_frame
->bufp
+ from
+ amount
,
687 (end
- from
) * sizeof current_frame
->bufp
[0]);
689 #ifdef HAVE_WINDOW_SYSTEM
690 if (FRAME_WINDOW_P (frame
))
692 safe_bcopy (current_frame
->top_left_x
+ from
,
693 current_frame
->top_left_x
+ from
+ amount
,
694 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
696 safe_bcopy (current_frame
->top_left_y
+ from
,
697 current_frame
->top_left_y
+ from
+ amount
,
698 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
700 safe_bcopy (current_frame
->pix_width
+ from
,
701 current_frame
->pix_width
+ from
+ amount
,
702 (end
- from
) * sizeof current_frame
->pix_width
[0]);
704 safe_bcopy (current_frame
->pix_height
+ from
,
705 current_frame
->pix_height
+ from
+ amount
,
706 (end
- from
) * sizeof current_frame
->pix_height
[0]);
708 safe_bcopy (current_frame
->max_ascent
+ from
,
709 current_frame
->max_ascent
+ from
+ amount
,
710 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
712 #endif /* HAVE_WINDOW_SYSTEM */
718 update_begin (frame
);
719 set_terminal_window (end
);
720 ins_del_lines (from
+ amount
, amount
);
721 if (!scroll_region_ok
)
722 ins_del_lines (end
+ amount
, -amount
);
723 set_terminal_window (0);
725 rotate_vector (current_frame
->glyphs
+ from
+ amount
,
726 sizeof (GLYPH
*) * (end
- from
- amount
),
727 amount
* sizeof (GLYPH
*));
729 rotate_vector (current_frame
->charstarts
+ from
+ amount
,
730 sizeof (int *) * (end
- from
- amount
),
731 amount
* sizeof (int *));
733 safe_bcopy (current_frame
->used
+ from
,
734 current_frame
->used
+ from
+ amount
,
735 (end
- from
) * sizeof current_frame
->used
[0]);
737 safe_bcopy (current_frame
->highlight
+ from
,
738 current_frame
->highlight
+ from
+ amount
,
739 (end
- from
) * sizeof current_frame
->highlight
[0]);
741 safe_bcopy (current_frame
->enable
+ from
,
742 current_frame
->enable
+ from
+ amount
,
743 (end
- from
) * sizeof current_frame
->enable
[0]);
745 /* Adjust the lines by an amount
746 that puts the first of them at NEWPOS. */
747 pos_adjust
= newpos
- current_frame
->charstarts
[from
+ amount
][0];
749 /* Offset each char position in the charstarts lines we moved
751 for (i
= from
+ amount
; i
< end
+ amount
; i
++)
753 int *line
= current_frame
->charstarts
[i
];
755 for (col
= 0; col
< width
; col
++)
757 line
[col
] += pos_adjust
;
759 for (i
= end
+ amount
; i
< end
; i
++)
761 int *line
= current_frame
->charstarts
[i
];
764 for (col
= 0; col
< width
; col
++)
768 /* Mark the lines made empty by scrolling as enabled, empty and
770 bzero (current_frame
->used
+ end
+ amount
,
771 - amount
* sizeof current_frame
->used
[0]);
772 bzero (current_frame
->highlight
+ end
+ amount
,
773 - amount
* sizeof current_frame
->highlight
[0]);
774 for (i
= end
+ amount
; i
< end
; i
++)
776 current_frame
->glyphs
[i
][0] = '\0';
777 current_frame
->charstarts
[i
][0] = 0;
778 current_frame
->enable
[i
] = 1;
781 safe_bcopy (current_frame
->bufp
+ from
,
782 current_frame
->bufp
+ from
+ amount
,
783 (end
- from
) * sizeof current_frame
->bufp
[0]);
785 #ifdef HAVE_WINDOW_SYSTEM
786 if (FRAME_WINDOW_P (frame
))
788 safe_bcopy (current_frame
->top_left_x
+ from
,
789 current_frame
->top_left_x
+ from
+ amount
,
790 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
792 safe_bcopy (current_frame
->top_left_y
+ from
,
793 current_frame
->top_left_y
+ from
+ amount
,
794 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
796 safe_bcopy (current_frame
->pix_width
+ from
,
797 current_frame
->pix_width
+ from
+ amount
,
798 (end
- from
) * sizeof current_frame
->pix_width
[0]);
800 safe_bcopy (current_frame
->pix_height
+ from
,
801 current_frame
->pix_height
+ from
+ amount
,
802 (end
- from
) * sizeof current_frame
->pix_height
[0]);
804 safe_bcopy (current_frame
->max_ascent
+ from
,
805 current_frame
->max_ascent
+ from
+ amount
,
806 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
808 #endif /* HAVE_WINDOW_SYSTEM */
815 /* After updating a window W that isn't the full frame wide,
816 copy all the columns that W does not occupy
817 into the FRAME_DESIRED_GLYPHS (frame) from the FRAME_PHYS_GLYPHS (frame)
818 so that update_frame will not change those columns. */
820 preserve_other_columns (w
)
824 register struct frame_glyphs
*current_frame
, *desired_frame
;
825 register FRAME_PTR frame
= XFRAME (w
->frame
);
826 int start
= WINDOW_LEFT_MARGIN (w
);
827 int end
= WINDOW_RIGHT_EDGE (w
);
828 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
830 current_frame
= FRAME_CURRENT_GLYPHS (frame
);
831 desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
833 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
835 if (current_frame
->enable
[vpos
] && desired_frame
->enable
[vpos
])
841 bcopy (current_frame
->glyphs
[vpos
],
842 desired_frame
->glyphs
[vpos
],
843 start
* sizeof (current_frame
->glyphs
[vpos
][0]));
844 bcopy (current_frame
->charstarts
[vpos
],
845 desired_frame
->charstarts
[vpos
],
846 start
* sizeof (current_frame
->charstarts
[vpos
][0]));
847 len
= min (start
, current_frame
->used
[vpos
]);
848 if (desired_frame
->used
[vpos
] < len
)
849 desired_frame
->used
[vpos
] = len
;
851 if (current_frame
->used
[vpos
] > end
852 && desired_frame
->used
[vpos
] < current_frame
->used
[vpos
])
854 while (desired_frame
->used
[vpos
] < end
)
856 int used
= desired_frame
->used
[vpos
]++;
857 desired_frame
->glyphs
[vpos
][used
] = SPACEGLYPH
;
858 desired_frame
->glyphs
[vpos
][used
] = 0;
860 bcopy (current_frame
->glyphs
[vpos
] + end
,
861 desired_frame
->glyphs
[vpos
] + end
,
862 ((current_frame
->used
[vpos
] - end
)
863 * sizeof (current_frame
->glyphs
[vpos
][0])));
864 bcopy (current_frame
->charstarts
[vpos
] + end
,
865 desired_frame
->charstarts
[vpos
] + end
,
866 ((current_frame
->used
[vpos
] - end
)
867 * sizeof (current_frame
->charstarts
[vpos
][0])));
868 desired_frame
->used
[vpos
] = current_frame
->used
[vpos
];
876 /* If window w does not need to be updated and isn't the full frame wide,
877 copy all the columns that w does occupy
878 into the FRAME_DESIRED_LINES (frame) from the FRAME_PHYS_LINES (frame)
879 so that update_frame will not change those columns.
881 Have not been able to figure out how to use this correctly. */
883 preserve_my_columns (w
)
886 register int vpos
, fin
;
887 register struct frame_glyphs
*l1
, *l2
;
888 register FRAME_PTR frame
= XFRAME (w
->frame
);
889 int start
= WINDOW_LEFT_MARGIN (w
);
890 int end
= WINDOW_RIGHT_EDGE (w
);
891 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
893 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
895 if ((l1
= FRAME_DESIRED_GLYPHS (frame
)->glyphs
[vpos
+ 1])
896 && (l2
= FRAME_PHYS_GLYPHS (frame
)->glyphs
[vpos
+ 1]))
898 if (l2
->length
> start
&& l1
->length
< l2
->length
)
901 if (fin
> end
) fin
= end
;
902 while (l1
->length
< start
)
903 l1
->body
[l1
->length
++] = ' ';
904 bcopy (l2
->body
+ start
, l1
->body
+ start
, fin
- start
);
913 /* Adjust by ADJUST the charstart values in window W
914 after vpos VPOS, which counts relative to the frame
915 (not relative to W itself). */
918 adjust_window_charstarts (w
, vpos
, adjust
)
923 int left
= WINDOW_LEFT_MARGIN (w
);
924 int top
= XFASTINT (w
->top
);
925 int right
= left
+ window_internal_width (w
);
926 int bottom
= top
+ window_internal_height (w
);
929 for (i
= vpos
+ 1; i
< bottom
; i
++)
932 = FRAME_CURRENT_GLYPHS (XFRAME (WINDOW_FRAME (w
)))->charstarts
[i
];
934 for (j
= left
; j
< right
; j
++)
935 if (charstart
[j
] > 0)
936 charstart
[j
] += adjust
;
940 /* Check the charstarts values in the area of window W
941 for internal consistency. We cannot check that they are "right";
942 we can only look for something nonsensical. */
944 verify_charstarts (w
)
947 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
949 int top
= XFASTINT (w
->top
);
950 int bottom
= top
+ window_internal_height (w
);
951 int left
= WINDOW_LEFT_MARGIN (w
);
952 int right
= left
+ window_internal_width (w
);
954 int truncate
= (XINT (w
->hscroll
)
955 || (truncate_partial_width_windows
956 && !WINDOW_FULL_WIDTH_P (w
))
957 || !NILP (XBUFFER (w
->buffer
)->truncate_lines
));
959 for (i
= top
; i
< bottom
; i
++)
963 int *charstart
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[i
];
969 /* If we are truncating lines, allow a jump
970 in charstarts from one line to the next. */
971 if (charstart
[left
] < next_line
)
976 if (charstart
[left
] != next_line
)
981 for (j
= left
; j
< right
; j
++)
982 if (charstart
[j
] > 0)
984 /* Record where the next line should start. */
986 if (BUF_ZV (XBUFFER (w
->buffer
)) != last
)
988 /* If there's a newline between the two lines, count that. */
989 int endchar
= *BUF_CHAR_ADDRESS (XBUFFER (w
->buffer
), last
);
996 /* On discovering that the redisplay for a window was no good,
997 cancel the columns of that window, so that when the window is
998 displayed over again get_display_line will not complain. */
1000 cancel_my_columns (w
)
1004 register struct frame_glyphs
*desired_glyphs
1005 = FRAME_DESIRED_GLYPHS (XFRAME (w
->frame
));
1006 register int start
= WINDOW_LEFT_MARGIN (w
);
1007 register int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
1009 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
1010 if (desired_glyphs
->enable
[vpos
]
1011 && desired_glyphs
->used
[vpos
] >= start
)
1012 desired_glyphs
->used
[vpos
] = start
;
1015 /* These functions try to perform directly and immediately on the frame
1016 the necessary output for one change in the buffer.
1017 They may return 0 meaning nothing was done if anything is difficult,
1018 or 1 meaning the output was performed properly.
1019 They assume that the frame was up to date before the buffer
1020 change being displayed. They make various other assumptions too;
1021 see command_loop_1 where these are called. */
1024 direct_output_for_insert (g
)
1027 register FRAME_PTR frame
= selected_frame
;
1028 register struct frame_glyphs
*current_frame
1029 = FRAME_CURRENT_GLYPHS (frame
);
1031 #ifndef COMPILER_REGISTER_BUG
1033 #endif /* COMPILER_REGISTER_BUG */
1034 struct window
*w
= XWINDOW (selected_window
);
1035 #ifndef COMPILER_REGISTER_BUG
1037 #endif /* COMPILER_REGISTER_BUG */
1038 int hpos
= FRAME_CURSOR_X (frame
);
1039 #ifndef COMPILER_REGISTER_BUG
1041 #endif /* COMPILER_REGISTER_BUG */
1042 int vpos
= FRAME_CURSOR_Y (frame
);
1044 /* Give up if about to continue line. */
1045 if (hpos
>= WINDOW_LEFT_MARGIN (w
) + window_internal_width (w
) - 1
1047 /* Avoid losing if cursor is in invisible text off left margin */
1048 || (XINT (w
->hscroll
) && hpos
== WINDOW_LEFT_MARGIN (w
))
1050 /* Give up if cursor outside window (in minibuf, probably) */
1051 || cursor_in_echo_area
1052 || FRAME_CURSOR_Y (frame
) < XFASTINT (w
->top
)
1053 || FRAME_CURSOR_Y (frame
) >= XFASTINT (w
->top
) + XFASTINT (w
->height
)
1055 /* Give up if cursor not really at FRAME_CURSOR_X, FRAME_CURSOR_Y */
1056 || !display_completed
1058 /* Give up if buffer appears in two places. */
1059 || buffer_shared
> 1
1061 #ifdef USE_TEXT_PROPERTIES
1062 /* Intervals have already been adjusted, point is after the
1063 character that was just inserted. */
1064 /* Give up if character is invisible. */
1065 /* Give up if character has a face property.
1066 At the moment we only lose at end of line or end of buffer
1067 and only with faces that have some background */
1068 /* Instead of wasting time, give up if character has any text properties */
1069 || ! NILP (Ftext_properties_at (make_number (PT
- 1), Qnil
))
1072 /* Give up if w is minibuffer and a message is being displayed there */
1073 || (MINI_WINDOW_P (w
) && echo_area_glyphs
))
1081 if (FRAME_WINDOW_P (frame
) || FRAME_MSDOS_P (frame
))
1082 face
= compute_char_face (frame
, w
, PT
- 1, -1, -1, &dummy
, PT
, 0);
1084 current_frame
->glyphs
[vpos
][hpos
] = MAKE_GLYPH (frame
, g
, face
);
1085 current_frame
->charstarts
[vpos
][hpos
] = PT
- 1;
1086 /* Record the entry for after the newly inserted character. */
1087 current_frame
->charstarts
[vpos
][hpos
+ 1] = PT
;
1088 adjust_window_charstarts (w
, vpos
, 1);
1090 unchanged_modified
= MODIFF
;
1091 beg_unchanged
= GPT
- BEG
;
1092 XSETFASTINT (w
->last_point
, PT
);
1093 XSETFASTINT (w
->last_point_x
, hpos
);
1094 XSETFASTINT (w
->last_modified
, MODIFF
);
1095 XSETFASTINT (w
->last_overlay_modified
, OVERLAY_MODIFF
);
1097 reassert_line_highlight (0, vpos
);
1098 write_glyphs (¤t_frame
->glyphs
[vpos
][hpos
], 1);
1100 ++FRAME_CURSOR_X (frame
);
1101 if (hpos
== current_frame
->used
[vpos
])
1103 current_frame
->used
[vpos
] = hpos
+ 1;
1104 current_frame
->glyphs
[vpos
][hpos
+ 1] = 0;
1111 direct_output_forward_char (n
)
1114 register FRAME_PTR frame
= selected_frame
;
1115 register struct window
*w
= XWINDOW (selected_window
);
1116 Lisp_Object position
;
1117 int hpos
= FRAME_CURSOR_X (frame
);
1119 /* Give up if in truncated text at end of line. */
1120 if (hpos
>= WINDOW_LEFT_MARGIN (w
) + window_internal_width (w
) - 1)
1123 /* Avoid losing if cursor is in invisible text off left margin
1124 or about to go off either side of window. */
1125 if ((FRAME_CURSOR_X (frame
) == WINDOW_LEFT_MARGIN (w
)
1126 && (XINT (w
->hscroll
) || n
< 0))
1128 && (FRAME_CURSOR_X (frame
) + 1 >= window_internal_width (w
) - 1))
1129 || cursor_in_echo_area
)
1132 /* Can't use direct output if highlighting a region. */
1133 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
1136 /* Can't use direct output at an overlay boundary; it might have
1137 before-string or after-string properties. */
1138 if (overlay_touches_p (PT
) || overlay_touches_p (PT
- n
))
1141 #ifdef USE_TEXT_PROPERTIES
1142 /* Don't use direct output next to an invisible character
1143 since we might need to do something special. */
1145 XSETFASTINT (position
, PT
);
1146 if (XFASTINT (position
) < ZV
1147 && ! NILP (Fget_char_property (position
,
1152 XSETFASTINT (position
, PT
- 1);
1153 if (XFASTINT (position
) >= BEGV
1154 && ! NILP (Fget_char_property (position
,
1160 FRAME_CURSOR_X (frame
) += n
;
1161 XSETFASTINT (w
->last_point_x
, FRAME_CURSOR_X (frame
));
1162 XSETFASTINT (w
->last_point
, PT
);
1163 cursor_to (FRAME_CURSOR_Y (frame
), FRAME_CURSOR_X (frame
));
1169 static void update_line ();
1171 /* Update frame F based on the data in FRAME_DESIRED_GLYPHS.
1172 Value is nonzero if redisplay stopped due to pending input.
1173 FORCE nonzero means do not stop for pending input. */
1176 update_frame (f
, force
, inhibit_hairy_id
)
1179 int inhibit_hairy_id
;
1181 register struct frame_glyphs
*current_frame
;
1182 register struct frame_glyphs
*desired_frame
= 0;
1185 int preempt_count
= baud_rate
/ 2400 + 1;
1186 extern input_pending
;
1187 #ifdef HAVE_WINDOW_SYSTEM
1188 register int downto
, leftmost
;
1191 if (baud_rate
!= FRAME_COST_BAUD_RATE (f
))
1192 calculate_costs (f
);
1194 if (preempt_count
<= 0)
1197 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1199 detect_input_pending ();
1200 if (input_pending
&& !force
)
1208 if (!line_ins_del_ok
)
1209 inhibit_hairy_id
= 1;
1211 /* These are separate to avoid a possible bug in the AIX C compiler. */
1212 current_frame
= FRAME_CURRENT_GLYPHS (f
);
1213 desired_frame
= FRAME_DESIRED_GLYPHS (f
);
1215 /* See if any of the desired lines are enabled; don't compute for
1216 i/d line if just want cursor motion. */
1217 for (i
= 0; i
< FRAME_HEIGHT (f
); i
++)
1218 if (desired_frame
->enable
[i
])
1221 /* Try doing i/d line, if not yet inhibited. */
1222 if (!inhibit_hairy_id
&& i
< FRAME_HEIGHT (f
))
1223 force
|= scrolling (f
);
1225 /* Update the individual lines as needed. Do bottom line first. */
1227 if (desired_frame
->enable
[FRAME_HEIGHT (f
) - 1])
1228 update_line (f
, FRAME_HEIGHT (f
) - 1);
1230 #ifdef HAVE_WINDOW_SYSTEM
1231 if (FRAME_WINDOW_P (f
))
1233 leftmost
= downto
= FRAME_INTERNAL_BORDER_WIDTH (f
);
1234 if (desired_frame
->enable
[0])
1236 current_frame
->top_left_x
[FRAME_HEIGHT (f
) - 1] = leftmost
;
1237 current_frame
->top_left_y
[FRAME_HEIGHT (f
) - 1]
1238 = PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
)
1239 - current_frame
->pix_height
[FRAME_HEIGHT (f
) - 1];
1240 current_frame
->top_left_x
[0] = leftmost
;
1241 current_frame
->top_left_y
[0] = downto
;
1244 #endif /* HAVE_WINDOW_SYSTEM */
1246 /* Now update the rest of the lines. */
1247 for (i
= 0; i
< FRAME_HEIGHT (f
) - 1 && (force
|| !input_pending
); i
++)
1249 if (desired_frame
->enable
[i
])
1251 if (FRAME_TERMCAP_P (f
))
1253 /* Flush out every so many lines.
1254 Also flush out if likely to have more than 1k buffered
1255 otherwise. I'm told that some telnet connections get
1256 really screwed by more than 1k output at once. */
1257 int outq
= PENDING_OUTPUT_COUNT (stdout
);
1259 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
1262 if (preempt_count
== 1)
1264 #ifdef EMACS_OUTQSIZE
1265 if (EMACS_OUTQSIZE (0, &outq
) < 0)
1266 /* Probably not a tty. Ignore the error and reset
1267 * the outq count. */
1268 outq
= PENDING_OUTPUT_COUNT (stdout
);
1271 if (baud_rate
<= outq
&& baud_rate
> 0)
1272 sleep (outq
/ baud_rate
);
1277 if ((i
- 1) % preempt_count
== 0)
1278 detect_input_pending ();
1281 #ifdef HAVE_WINDOW_SYSTEM
1282 if (FRAME_WINDOW_P (f
))
1284 current_frame
->top_left_y
[i
] = downto
;
1285 current_frame
->top_left_x
[i
] = leftmost
;
1287 #endif /* HAVE_WINDOW_SYSTEM */
1290 #ifdef HAVE_WINDOW_SYSTEM
1291 if (FRAME_WINDOW_P (f
))
1292 downto
+= current_frame
->pix_height
[i
];
1293 #endif /* HAVE_WINDOW_SYSTEM */
1295 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
1297 /* Now just clean up termcap drivers and set cursor, etc. */
1300 if ((cursor_in_echo_area
1301 /* If we are showing a message instead of the minibuffer,
1302 show the cursor for the message instead of for the
1303 (now hidden) minibuffer contents. */
1304 || (EQ (minibuf_window
, selected_window
)
1305 && EQ (minibuf_window
, echo_area_window
)
1306 && echo_area_glyphs
!= 0))
1307 /* These cases apply only to the frame that contains
1308 the active minibuffer window. */
1309 && FRAME_HAS_MINIBUF_P (f
)
1310 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
1312 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
1315 if (cursor_in_echo_area
< 0)
1322 /* If the minibuffer is several lines high, find the last
1323 line that has any text on it. */
1324 row
= FRAME_HEIGHT (f
);
1328 if (current_frame
->enable
[row
])
1329 col
= current_frame
->used
[row
];
1333 while (row
> top
&& col
== 0);
1335 if (col
>= FRAME_WINDOW_WIDTH (f
))
1338 if (row
< FRAME_HEIGHT (f
) - 1)
1343 cursor_to (row
, col
);
1346 cursor_to (FRAME_CURSOR_Y (f
),
1347 max (min (FRAME_CURSOR_X (f
),
1348 FRAME_WINDOW_WIDTH (f
) - 1), 0));
1354 fflush (termscript
);
1357 /* Here if output is preempted because input is detected. */
1360 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1361 display_completed
= !pause
;
1363 bzero (FRAME_DESIRED_GLYPHS (f
)->enable
, FRAME_HEIGHT (f
));
1367 /* Called when about to quit, to check for doing so
1368 at an improper time. */
1374 if (FRAME_DESIRED_GLYPHS (selected_frame
) == 0)
1376 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[0])
1378 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[FRAME_HEIGHT (selected_frame
) - 1])
1383 /* Decide what insert/delete line to do, and do it */
1385 extern void scrolling_1 ();
1390 int unchanged_at_top
, unchanged_at_bottom
;
1393 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1394 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1395 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1396 int *old_draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1398 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
1399 register struct frame_glyphs
*current_frame
= FRAME_CURRENT_GLYPHS (frame
);
1400 register struct frame_glyphs
*desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
1402 /* Compute hash codes of all the lines.
1403 Also calculate number of changed lines,
1404 number of unchanged lines at the beginning,
1405 and number of unchanged lines at the end. */
1408 unchanged_at_top
= 0;
1409 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
1410 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
1412 /* Give up on this scrolling if some old lines are not enabled. */
1413 if (!current_frame
->enable
[i
])
1415 old_hash
[i
] = line_hash_code (current_frame
, i
);
1416 if (! desired_frame
->enable
[i
])
1417 new_hash
[i
] = old_hash
[i
];
1419 new_hash
[i
] = line_hash_code (desired_frame
, i
);
1421 if (old_hash
[i
] != new_hash
[i
])
1424 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
1426 else if (i
== unchanged_at_top
)
1428 draw_cost
[i
] = line_draw_cost (desired_frame
, i
);
1429 old_draw_cost
[i
] = line_draw_cost (current_frame
, i
);
1432 /* If changed lines are few, don't allow preemption, don't scroll. */
1433 if (!scroll_region_ok
&& changed_lines
< baud_rate
/ 2400
1434 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
1437 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
1438 - unchanged_at_bottom
);
1440 if (scroll_region_ok
)
1441 free_at_end_vpos
-= unchanged_at_bottom
;
1442 else if (memory_below_frame
)
1443 free_at_end_vpos
= -1;
1445 /* If large window, fast terminal and few lines in common between
1446 current frame and desired frame, don't bother with i/d calc. */
1447 if (!scroll_region_ok
&& window_size
>= 18 && baud_rate
> 2400
1449 10 * scrolling_max_lines_saved (unchanged_at_top
,
1450 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
1451 old_hash
, new_hash
, draw_cost
)))
1454 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
1455 draw_cost
+ unchanged_at_top
- 1,
1456 old_draw_cost
+ unchanged_at_top
- 1,
1457 old_hash
+ unchanged_at_top
- 1,
1458 new_hash
+ unchanged_at_top
- 1,
1459 free_at_end_vpos
- unchanged_at_top
);
1464 /* Return the offset in its buffer of the character at location col, line
1465 in the given window. */
1467 buffer_posn_from_coords (window
, col
, line
)
1468 struct window
*window
;
1471 int hscroll
= XINT (window
->hscroll
);
1472 int window_left
= WINDOW_LEFT_MARGIN (window
);
1474 /* The actual width of the window is window->width less one for the
1475 DISP_CONTINUE_GLYPH, and less one if it's not the rightmost
1477 int window_width
= window_internal_width (window
) - 1;
1479 int startp
= marker_position (window
->start
);
1481 /* Since compute_motion will only operate on the current buffer,
1482 we need to save the old one and restore it when we're done. */
1483 struct buffer
*old_current_buffer
= current_buffer
;
1484 struct position
*posn
;
1486 current_buffer
= XBUFFER (window
->buffer
);
1488 /* We can't get a correct result in this case,
1489 but at least prevent compute_motion from crashing. */
1493 /* It would be nice if we could use FRAME_CURRENT_GLYPHS (XFRAME
1494 (window->frame))->bufp to avoid scanning from the very top of
1495 the window, but it isn't maintained correctly, and I'm not even
1496 sure I will keep it. */
1497 posn
= compute_motion (startp
, 0,
1498 ((window
== XWINDOW (minibuf_window
) && startp
== BEG
1499 ? minibuf_prompt_width
: 0)
1500 + (hscroll
? 1 - hscroll
: 0)),
1503 window_width
, hscroll
, 0, window
);
1505 current_buffer
= old_current_buffer
;
1507 /* compute_motion considers frame points past the end of a line
1508 to be *after* the newline, i.e. at the start of the next line.
1509 This is reasonable, but not really what we want. So if the
1510 result is on a line below LINE, back it up one character. */
1511 if (posn
->vpos
> line
)
1512 return posn
->bufpos
- 1;
1514 return posn
->bufpos
;
1521 register GLYPH
*p
= r
;
1522 while (*p
++ == SPACEGLYPH
);
1527 count_match (str1
, str2
)
1530 register GLYPH
*p1
= str1
;
1531 register GLYPH
*p2
= str2
;
1532 while (*p1
++ == *p2
++);
1533 return p1
- str1
- 1;
1536 /* Char insertion/deletion cost vector, from term.c */
1537 extern int *char_ins_del_vector
;
1539 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WINDOW_WIDTH((f))])
1542 update_line (frame
, vpos
)
1543 register FRAME_PTR frame
;
1546 register GLYPH
*obody
, *nbody
, *op1
, *op2
, *np1
, *temp
;
1549 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
1551 register struct frame_glyphs
*current_frame
1552 = FRAME_CURRENT_GLYPHS (frame
);
1553 register struct frame_glyphs
*desired_frame
1554 = FRAME_DESIRED_GLYPHS (frame
);
1556 if (desired_frame
->highlight
[vpos
]
1557 != (current_frame
->enable
[vpos
] && current_frame
->highlight
[vpos
]))
1559 change_line_highlight (desired_frame
->highlight
[vpos
], vpos
,
1560 (current_frame
->enable
[vpos
] ?
1561 current_frame
->used
[vpos
] : 0));
1562 current_frame
->enable
[vpos
] = 0;
1565 reassert_line_highlight (desired_frame
->highlight
[vpos
], vpos
);
1567 if (! current_frame
->enable
[vpos
])
1573 obody
= current_frame
->glyphs
[vpos
];
1574 olen
= current_frame
->used
[vpos
];
1575 if (! current_frame
->highlight
[vpos
])
1577 if (!must_write_spaces
)
1578 while (olen
> 0 && obody
[olen
- 1] == SPACEGLYPH
)
1583 /* For an inverse-video line, remember we gave it
1584 spaces all the way to the frame edge
1585 so that the reverse video extends all the way across. */
1587 while (olen
< FRAME_WINDOW_WIDTH (frame
) - 1)
1588 obody
[olen
++] = SPACEGLYPH
;
1592 /* One way or another, this will enable the line being updated. */
1593 current_frame
->enable
[vpos
] = 1;
1594 current_frame
->used
[vpos
] = desired_frame
->used
[vpos
];
1595 current_frame
->highlight
[vpos
] = desired_frame
->highlight
[vpos
];
1596 current_frame
->bufp
[vpos
] = desired_frame
->bufp
[vpos
];
1598 #ifdef HAVE_WINDOW_SYSTEM
1599 if (FRAME_WINDOW_P (frame
))
1601 current_frame
->pix_width
[vpos
]
1602 = current_frame
->used
[vpos
]
1603 * FONT_WIDTH (FRAME_FONT (frame
));
1604 current_frame
->pix_height
[vpos
]
1605 = FRAME_LINE_HEIGHT (frame
);
1607 #endif /* HAVE_WINDOW_SYSTEM */
1609 if (!desired_frame
->enable
[vpos
])
1615 nbody
= desired_frame
->glyphs
[vpos
];
1616 nlen
= desired_frame
->used
[vpos
];
1618 /* Pretend trailing spaces are not there at all,
1619 unless for one reason or another we must write all spaces. */
1620 if (! desired_frame
->highlight
[vpos
])
1622 if (!must_write_spaces
)
1623 /* We know that the previous character byte contains 0. */
1624 while (nbody
[nlen
- 1] == SPACEGLYPH
)
1629 /* For an inverse-video line, give it extra trailing spaces
1630 all the way to the frame edge
1631 so that the reverse video extends all the way across. */
1633 while (nlen
< FRAME_WINDOW_WIDTH (frame
) - 1)
1634 nbody
[nlen
++] = SPACEGLYPH
;
1637 /* If there's no i/d char, quickly do the best we can without it. */
1638 if (!char_ins_del_ok
)
1643 if (FRAME_X_P (frame
))
1645 /* Under X, erase everything we are going to rewrite,
1646 and rewrite everything from the first char that's changed.
1647 This is part of supporting fonts like Courier
1648 whose chars can overlap outside the char width. */
1649 for (i
= 0; i
< nlen
; i
++)
1650 if (i
>= olen
|| nbody
[i
] != obody
[i
])
1653 cursor_to (vpos
, i
);
1655 clear_end_of_line (olen
);
1656 write_glyphs (nbody
+ i
, nlen
- i
);
1661 for (i
= 0; i
< nlen
; i
++)
1663 if (i
>= olen
|| nbody
[i
] != obody
[i
]) /* A non-matching char. */
1665 cursor_to (vpos
, i
);
1666 for (j
= 1; (i
+ j
< nlen
&&
1667 (i
+ j
>= olen
|| nbody
[i
+j
] != obody
[i
+j
]));
1670 /* Output this run of non-matching chars. */
1671 write_glyphs (nbody
+ i
, j
);
1674 /* Now find the next non-match. */
1678 /* Clear the rest of the line, or the non-clear part of it. */
1681 cursor_to (vpos
, nlen
);
1682 clear_end_of_line (olen
);
1685 /* Exchange contents between current_frame and new_frame. */
1686 temp
= desired_frame
->glyphs
[vpos
];
1687 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1688 current_frame
->glyphs
[vpos
] = temp
;
1690 /* Exchange charstarts between current_frame and new_frame. */
1691 temp1
= desired_frame
->charstarts
[vpos
];
1692 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1693 current_frame
->charstarts
[vpos
] = temp1
;
1700 nsp
= (must_write_spaces
|| desired_frame
->highlight
[vpos
])
1701 ? 0 : count_blanks (nbody
);
1704 cursor_to (vpos
, nsp
);
1705 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
1708 /* Exchange contents between current_frame and new_frame. */
1709 temp
= desired_frame
->glyphs
[vpos
];
1710 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1711 current_frame
->glyphs
[vpos
] = temp
;
1713 /* Exchange charstarts between current_frame and new_frame. */
1714 temp1
= desired_frame
->charstarts
[vpos
];
1715 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1716 current_frame
->charstarts
[vpos
] = temp1
;
1725 /* Compute number of leading blanks in old and new contents. */
1726 osp
= count_blanks (obody
);
1727 if (!desired_frame
->highlight
[vpos
])
1728 nsp
= count_blanks (nbody
);
1732 /* Compute number of matching chars starting with first nonblank. */
1733 begmatch
= count_match (obody
+ osp
, nbody
+ nsp
);
1735 /* Spaces in new match implicit space past the end of old. */
1736 /* A bug causing this to be a no-op was fixed in 18.29. */
1737 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
1740 while (np1
[begmatch
] == SPACEGLYPH
)
1744 /* Avoid doing insert/delete char
1745 just cause number of leading spaces differs
1746 when the following text does not match. */
1747 if (begmatch
== 0 && osp
!= nsp
)
1748 osp
= nsp
= min (osp
, nsp
);
1750 /* Find matching characters at end of line */
1753 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
1754 while (op1
> op2
&& op1
[-1] == np1
[-1])
1759 endmatch
= obody
+ olen
- op1
;
1761 /* Put correct value back in nbody[nlen].
1762 This is important because direct_output_for_insert
1763 can write into the line at a later point.
1764 If this screws up the zero at the end of the line, re-establish it. */
1768 /* tem gets the distance to insert or delete.
1769 endmatch is how many characters we save by doing so.
1772 tem
= (nlen
- nsp
) - (olen
- osp
);
1774 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
1777 /* nsp - osp is the distance to insert or delete.
1778 If that is nonzero, begmatch is known to be nonzero also.
1779 begmatch + endmatch is how much we save by doing the ins/del.
1783 && (!char_ins_del_ok
1784 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
1788 osp
= nsp
= min (osp
, nsp
);
1791 /* Now go through the line, inserting, writing and
1792 deleting as appropriate. */
1796 cursor_to (vpos
, nsp
);
1797 delete_glyphs (osp
- nsp
);
1801 /* If going to delete chars later in line
1802 and insert earlier in the line,
1803 must delete first to avoid losing data in the insert */
1804 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
1806 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
1807 delete_glyphs (olen
+ nsp
- osp
- nlen
);
1808 olen
= nlen
- (nsp
- osp
);
1810 cursor_to (vpos
, osp
);
1811 insert_glyphs ((char *)0, nsp
- osp
);
1815 tem
= nsp
+ begmatch
+ endmatch
;
1816 if (nlen
!= tem
|| olen
!= tem
)
1818 cursor_to (vpos
, nsp
+ begmatch
);
1819 if (!endmatch
|| nlen
== olen
)
1821 /* If new text being written reaches right margin,
1822 there is no need to do clear-to-eol at the end.
1823 (and it would not be safe, since cursor is not
1824 going to be "at the margin" after the text is done) */
1825 if (nlen
== FRAME_WINDOW_WIDTH (frame
))
1827 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1831 /* the following code loses disastrously if tem == nlen.
1832 Rather than trying to fix that case, I am trying the simpler
1833 solution found above. */
1835 /* If the text reaches to the right margin,
1836 it will lose one way or another (depending on AutoWrap)
1837 to clear to end of line after outputting all the text.
1838 So pause with one character to go and clear the line then. */
1839 if (nlen
== FRAME_WINDOW_WIDTH (frame
) && fast_clear_end_of_line
&& olen
> nlen
)
1841 /* endmatch must be zero, and tem must equal nsp + begmatch */
1842 write_glyphs (nbody
+ tem
, nlen
- tem
- 1);
1843 clear_end_of_line (olen
);
1844 olen
= 0; /* Don't let it be cleared again later */
1845 write_glyphs (nbody
+ nlen
- 1, 1);
1848 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1849 #endif /* OBSOLETE */
1852 else if (nlen
> olen
)
1854 write_glyphs (nbody
+ nsp
+ begmatch
, olen
- tem
);
1855 insert_glyphs (nbody
+ nsp
+ begmatch
+ olen
- tem
, nlen
- olen
);
1858 else if (olen
> nlen
)
1860 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1861 delete_glyphs (olen
- nlen
);
1867 /* If any unerased characters remain after the new line, erase them. */
1870 cursor_to (vpos
, nlen
);
1871 clear_end_of_line (olen
);
1874 /* Exchange contents between current_frame and new_frame. */
1875 temp
= desired_frame
->glyphs
[vpos
];
1876 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1877 current_frame
->glyphs
[vpos
] = temp
;
1879 /* Exchange charstarts between current_frame and new_frame. */
1880 temp1
= desired_frame
->charstarts
[vpos
];
1881 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1882 current_frame
->charstarts
[vpos
] = temp1
;
1885 /* A vector of size >= 2 * NFRAMES + 3 * NBUFFERS + 1, containing the
1886 session's frames, frame names, buffers, buffer-read-only flags, and
1887 buffer-modified-flags, and a trailing sentinel (so we don't need to
1888 add length checks). */
1889 static Lisp_Object frame_and_buffer_state
;
1891 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p
,
1892 Sframe_or_buffer_changed_p
, 0, 0, 0,
1893 "Return non-nil if the frame and buffer state appears to have changed.\n\
1894 The state variable is an internal vector containing all frames and buffers,\n\
1895 aside from buffers whose names start with space,\n\
1896 along with the buffers' read-only and modified flags, which allows a fast\n\
1897 check to see whether the menu bars might need to be recomputed.\n\
1898 If this function returns non-nil, it updates the internal vector to reflect\n\
1899 the current state.\n")
1902 Lisp_Object tail
, frame
, buf
;
1906 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
1907 FOR_EACH_FRAME (tail
, frame
)
1909 if (!EQ (*vecp
++, frame
))
1911 if (!EQ (*vecp
++, XFRAME (frame
)->name
))
1914 /* Check that the buffer info matches.
1915 No need to test for the end of the vector
1916 because the last element of the vector is lambda
1917 and that will always cause a mismatch. */
1918 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1920 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
1921 /* Ignore buffers that aren't included in buffer lists. */
1922 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
1924 if (!EQ (*vecp
++, buf
))
1926 if (!EQ (*vecp
++, XBUFFER (buf
)->read_only
))
1928 if (!EQ (*vecp
++, Fbuffer_modified_p (buf
)))
1931 /* Detect deletion of a buffer at the end of the list. */
1932 if (*vecp
== Qlambda
)
1935 /* Start with 1 so there is room for at least one lambda at the end. */
1937 FOR_EACH_FRAME (tail
, frame
)
1939 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1941 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
1942 if (n
> XVECTOR (frame_and_buffer_state
)->size
1943 || n
+ 20 < XVECTOR (frame_and_buffer_state
)->size
/ 2)
1944 /* Add 20 extra so we grow it less often. */
1945 frame_and_buffer_state
= Fmake_vector (make_number (n
+ 20), Qlambda
);
1946 vecp
= XVECTOR (frame_and_buffer_state
)->contents
;
1947 FOR_EACH_FRAME (tail
, frame
)
1950 *vecp
++ = XFRAME (frame
)->name
;
1952 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1954 buf
= XCONS (XCONS (tail
)->car
)->cdr
;
1955 /* Ignore buffers that aren't included in buffer lists. */
1956 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
1959 *vecp
++ = XBUFFER (buf
)->read_only
;
1960 *vecp
++ = Fbuffer_modified_p (buf
);
1962 /* Fill up the vector with lambdas (always at least one). */
1964 while (vecp
- XVECTOR (frame_and_buffer_state
)->contents
1965 < XVECTOR (frame_and_buffer_state
)->size
)
1967 /* Make sure we didn't overflow the vector. */
1968 if (vecp
- XVECTOR (frame_and_buffer_state
)->contents
1969 > XVECTOR (frame_and_buffer_state
)->size
)
1974 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
1975 1, 1, "FOpen termscript file: ",
1976 "Start writing all terminal output to FILE as well as the terminal.\n\
1977 FILE = nil means just close any termscript file currently open.")
1981 if (termscript
!= 0) fclose (termscript
);
1986 file
= Fexpand_file_name (file
, Qnil
);
1987 termscript
= fopen (XSTRING (file
)->data
, "w");
1988 if (termscript
== 0)
1989 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
1997 window_change_signal (signalnum
) /* If we don't have an argument, */
1998 int signalnum
; /* some compilers complain in signal calls. */
2002 int old_errno
= errno
;
2004 get_frame_size (&width
, &height
);
2006 /* The frame size change obviously applies to a termcap-controlled
2007 frame. Find such a frame in the list, and assume it's the only
2008 one (since the redisplay code always writes to stdout, not a
2009 FILE * specified in the frame structure). Record the new size,
2010 but don't reallocate the data structures now. Let that be done
2011 later outside of the signal handler. */
2014 Lisp_Object tail
, frame
;
2016 FOR_EACH_FRAME (tail
, frame
)
2018 if (FRAME_TERMCAP_P (XFRAME (frame
)))
2020 change_frame_size (XFRAME (frame
), height
, width
, 0, 1);
2026 signal (SIGWINCH
, window_change_signal
);
2029 #endif /* SIGWINCH */
2032 /* Do any change in frame size that was requested by a signal. */
2034 do_pending_window_change ()
2036 /* If window_change_signal should have run before, run it now. */
2037 while (delayed_size_change
)
2039 Lisp_Object tail
, frame
;
2041 delayed_size_change
= 0;
2043 FOR_EACH_FRAME (tail
, frame
)
2045 FRAME_PTR f
= XFRAME (frame
);
2047 int height
= FRAME_NEW_HEIGHT (f
);
2048 int width
= FRAME_NEW_WIDTH (f
);
2050 if (height
!= 0 || width
!= 0)
2051 change_frame_size (f
, height
, width
, 0, 0);
2057 /* Change the frame height and/or width. Values may be given as zero to
2058 indicate no change is to take place.
2060 If DELAY is non-zero, then assume we're being called from a signal
2061 handler, and queue the change for later - perhaps the next
2062 redisplay. Since this tries to resize windows, we can't call it
2063 from a signal handler. */
2065 change_frame_size (f
, newheight
, newwidth
, pretend
, delay
)
2066 register FRAME_PTR f
;
2067 int newheight
, newwidth
, pretend
;
2069 Lisp_Object tail
, frame
;
2071 if (! FRAME_WINDOW_P (f
))
2073 /* When using termcap, or on MS-DOS, all frames use
2074 the same screen, so a change in size affects all frames. */
2075 FOR_EACH_FRAME (tail
, frame
)
2076 if (! FRAME_WINDOW_P (XFRAME (frame
)))
2077 change_frame_size_1 (XFRAME (frame
), newheight
, newwidth
,
2081 change_frame_size_1 (f
, newheight
, newwidth
, pretend
, delay
);
2085 change_frame_size_1 (frame
, newheight
, newwidth
, pretend
, delay
)
2086 register FRAME_PTR frame
;
2087 int newheight
, newwidth
, pretend
, delay
;
2089 int new_frame_window_width
;
2090 unsigned int total_glyphs
;
2092 /* If we can't deal with the change now, queue it for later. */
2095 FRAME_NEW_HEIGHT (frame
) = newheight
;
2096 FRAME_NEW_WIDTH (frame
) = newwidth
;
2097 delayed_size_change
= 1;
2101 /* This size-change overrides any pending one for this frame. */
2102 FRAME_NEW_HEIGHT (frame
) = 0;
2103 FRAME_NEW_WIDTH (frame
) = 0;
2105 /* If an argument is zero, set it to the current value. */
2107 newheight
= FRAME_HEIGHT (frame
);
2109 newwidth
= FRAME_WIDTH (frame
);
2110 new_frame_window_width
= FRAME_WINDOW_WIDTH_ARG (frame
, newwidth
);
2112 total_glyphs
= newheight
* (newwidth
+ 2) * sizeof (GLYPH
);
2114 /* If these sizes are so big they cause overflow,
2115 just ignore the change. It's not clear what better we could do. */
2116 if (total_glyphs
/ sizeof (GLYPH
) / newheight
!= newwidth
+ 2)
2119 /* Round up to the smallest acceptable size. */
2120 check_frame_size (frame
, &newheight
, &newwidth
);
2122 /* If we're not changing the frame size, quit now. */
2123 if (newheight
== FRAME_HEIGHT (frame
)
2124 && new_frame_window_width
== FRAME_WINDOW_WIDTH (frame
))
2130 /* We only can set screen dimensions to certain values supported
2131 by our video hardware. Try to find the smallest size greater
2132 or equal to the requested dimensions. */
2133 dos_set_window_size (&newheight
, &newwidth
);
2136 if (newheight
!= FRAME_HEIGHT (frame
))
2138 if (FRAME_HAS_MINIBUF_P (frame
)
2139 && ! FRAME_MINIBUF_ONLY_P (frame
))
2141 /* Frame has both root and minibuffer. */
2142 set_window_height (FRAME_ROOT_WINDOW (frame
),
2143 newheight
- 1 - FRAME_MENU_BAR_LINES (frame
), 0);
2144 XSETFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (frame
))->top
,
2146 set_window_height (FRAME_MINIBUF_WINDOW (frame
), 1, 0);
2149 /* Frame has just one top-level window. */
2150 set_window_height (FRAME_ROOT_WINDOW (frame
),
2151 newheight
- FRAME_MENU_BAR_LINES (frame
), 0);
2153 if (FRAME_TERMCAP_P (frame
) && !pretend
)
2154 FrameRows
= newheight
;
2157 if (frame
->output_method
== output_termcap
)
2159 frame_height
= newheight
;
2161 FrameRows
= newheight
;
2166 if (new_frame_window_width
!= FRAME_WINDOW_WIDTH (frame
))
2168 set_window_width (FRAME_ROOT_WINDOW (frame
), new_frame_window_width
, 0);
2169 if (FRAME_HAS_MINIBUF_P (frame
))
2170 set_window_width (FRAME_MINIBUF_WINDOW (frame
), new_frame_window_width
, 0);
2172 if (FRAME_TERMCAP_P (frame
) && !pretend
)
2173 FrameCols
= newwidth
;
2175 if (frame
->output_method
== output_termcap
)
2177 frame_width
= newwidth
;
2179 FrameCols
= newwidth
;
2184 FRAME_HEIGHT (frame
) = newheight
;
2185 SET_FRAME_WIDTH (frame
, newwidth
);
2187 if (FRAME_CURSOR_X (frame
) >= FRAME_WINDOW_WIDTH (frame
))
2188 FRAME_CURSOR_X (frame
) = FRAME_WINDOW_WIDTH (frame
) - 1;
2189 if (FRAME_CURSOR_Y (frame
) >= FRAME_HEIGHT (frame
))
2190 FRAME_CURSOR_Y (frame
) = FRAME_HEIGHT (frame
) - 1;
2192 remake_frame_glyphs (frame
);
2193 calculate_costs (frame
);
2198 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
2199 Ssend_string_to_terminal
, 1, 1, 0,
2200 "Send STRING to the terminal without alteration.\n\
2201 Control characters in STRING will have terminal-dependent effects.")
2205 CHECK_STRING (string
, 0);
2206 fwrite (XSTRING (string
)->data
, 1, XSTRING (string
)->size
, stdout
);
2210 fwrite (XSTRING (string
)->data
, 1, XSTRING (string
)->size
, termscript
);
2211 fflush (termscript
);
2216 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
2217 "Beep, or flash the screen.\n\
2218 Also, unless an argument is given,\n\
2219 terminate any keyboard macro currently executing.")
2241 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
2242 error ("Keyboard macro terminated by a command ringing the bell");
2248 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
2249 "Pause, without updating display, for SECONDS seconds.\n\
2250 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2251 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2252 additional wait period, in milliseconds; this may be useful if your\n\
2253 Emacs was built without floating point support.\n\
2254 \(Not all operating systems support waiting for a fraction of a second.)")
2255 (seconds
, milliseconds
)
2256 Lisp_Object seconds
, milliseconds
;
2260 if (NILP (milliseconds
))
2261 XSETINT (milliseconds
, 0);
2263 CHECK_NUMBER (milliseconds
, 1);
2264 usec
= XINT (milliseconds
) * 1000;
2266 #ifdef LISP_FLOAT_TYPE
2268 double duration
= extract_float (seconds
);
2269 sec
= (int) duration
;
2270 usec
+= (duration
- sec
) * 1000000;
2273 CHECK_NUMBER (seconds
, 0);
2274 sec
= XINT (seconds
);
2277 #ifndef EMACS_HAS_USECS
2278 if (sec
== 0 && usec
!= 0)
2279 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
2282 /* Assure that 0 <= usec < 1000000. */
2285 /* We can't rely on the rounding being correct if user is negative. */
2286 if (-1000000 < usec
)
2287 sec
--, usec
+= 1000000;
2289 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
2292 sec
+= usec
/ 1000000, usec
%= 1000000;
2294 if (sec
< 0 || (sec
== 0 && usec
== 0))
2300 XSETFASTINT (zero
, 0);
2301 wait_reading_process_input (sec
, usec
, zero
, 0);
2304 /* We should always have wait_reading_process_input; we have a dummy
2305 implementation for systems which don't support subprocesses. */
2307 /* No wait_reading_process_input */
2314 /* The reason this is done this way
2315 (rather than defined (H_S) && defined (H_T))
2316 is because the VMS preprocessor doesn't grok `defined' */
2318 EMACS_GET_TIME (end_time
);
2319 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
2320 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
2324 EMACS_GET_TIME (timeout
);
2325 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
2326 if (EMACS_TIME_NEG_P (timeout
)
2327 || !select (1, 0, 0, 0, &timeout
))
2330 #else /* not HAVE_SELECT */
2332 #endif /* HAVE_SELECT */
2333 #endif /* not VMS */
2336 #endif /* no subprocesses */
2341 /* This is just like wait_reading_process_input, except that
2342 it does the redisplay.
2344 It's also much like Fsit_for, except that it can be used for
2345 waiting for input as well. */
2348 sit_for (sec
, usec
, reading
, display
)
2349 int sec
, usec
, reading
, display
;
2351 Lisp_Object read_kbd
;
2353 swallow_events (display
);
2355 if (detect_input_pending_run_timers (display
))
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 NODISP 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 and nonempty,
2469 try to use X, and die with an error message if that doesn't work. */
2471 #ifdef HAVE_X_WINDOWS
2476 display
= getenv ("DECW$DISPLAY");
2478 display
= getenv ("DISPLAY");
2481 display_arg
= (display
!= 0 && *display
!= 0);
2484 if (!inhibit_window_system
&& display_arg
&& initialized
)
2486 Vwindow_system
= intern ("x");
2488 Vwindow_system_version
= make_number (11);
2490 Vwindow_system_version
= make_number (10);
2492 #if defined (LINUX) && defined (HAVE_LIBNCURSES)
2493 /* In some versions of ncurses,
2494 tputs crashes if we have not called tgetent.
2496 { char b
[2044]; tgetent (b
, "xterm");}
2500 #endif /* HAVE_X_WINDOWS */
2503 if (!inhibit_window_system
)
2505 Vwindow_system
= intern ("w32");
2506 Vwindow_system_version
= make_number (1);
2509 #endif /* HAVE_NTGUI */
2511 /* If no window system has been specified, try to use the terminal. */
2514 fprintf (stderr
, "emacs: standard input is not a tty\n");
2518 /* Look at the TERM variable */
2519 terminal_type
= (char *) getenv ("TERM");
2523 fprintf (stderr
, "Please specify your terminal type.\n\
2524 For types defined in VMS, use set term /device=TYPE.\n\
2525 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
2526 \(The quotation marks are necessary since terminal types are lower case.)\n");
2528 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
2534 /* VMS DCL tends to upcase things, so downcase term type.
2535 Hardly any uppercase letters in terminal types; should be none. */
2537 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
2540 strcpy (new, terminal_type
);
2542 for (p
= new; *p
; p
++)
2546 terminal_type
= new;
2550 term_init (terminal_type
);
2553 int width
= FRAME_WINDOW_WIDTH (selected_frame
);
2554 int height
= FRAME_HEIGHT (selected_frame
);
2556 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (GLYPH
);
2558 /* If these sizes are so big they cause overflow,
2559 just ignore the change. It's not clear what better we could do. */
2560 if (total_glyphs
/ sizeof (GLYPH
) / height
!= width
+ 2)
2562 fprintf (stderr
, "emacs: screen size %dx%d too big\n,",
2568 remake_frame_glyphs (selected_frame
);
2569 calculate_costs (selected_frame
);
2571 /* X and Y coordinates of the cursor between updates. */
2572 FRAME_CURSOR_X (selected_frame
) = 0;
2573 FRAME_CURSOR_Y (selected_frame
) = 0;
2578 #endif /* CANNOT_DUMP */
2579 signal (SIGWINCH
, window_change_signal
);
2580 #endif /* SIGWINCH */
2585 defsubr (&Sredraw_frame
);
2586 defsubr (&Sredraw_display
);
2587 defsubr (&Sframe_or_buffer_changed_p
);
2588 defsubr (&Sopen_termscript
);
2590 defsubr (&Ssit_for
);
2591 defsubr (&Ssleep_for
);
2592 defsubr (&Ssend_string_to_terminal
);
2594 frame_and_buffer_state
= Fmake_vector (make_number (20), Qlambda
);
2595 staticpro (&frame_and_buffer_state
);
2597 Qdisplay_table
= intern ("display-table");
2598 staticpro (&Qdisplay_table
);
2600 DEFVAR_INT ("baud-rate", &baud_rate
,
2601 "*The output baud rate of the terminal.\n\
2602 On most systems, changing this value will affect the amount of padding\n\
2603 and the other strategic decisions made during redisplay.");
2604 DEFVAR_BOOL ("inverse-video", &inverse_video
,
2605 "*Non-nil means invert the entire frame display.\n\
2606 This means everything is in inverse video which otherwise would not be.");
2607 DEFVAR_BOOL ("visible-bell", &visible_bell
,
2608 "*Non-nil means try to flash the frame to represent a bell.");
2609 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
2610 "*Non-nil means no need to redraw entire frame after suspending.\n\
2611 A non-nil value is useful if the terminal can automatically preserve\n\
2612 Emacs's frame display when you reenter Emacs.\n\
2613 It is up to you to set this variable if your terminal can do that.");
2614 DEFVAR_LISP ("window-system", &Vwindow_system
,
2615 "A symbol naming the window-system under which Emacs is running\n\
2616 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
2617 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
2618 "The version number of the window system in use.\n\
2619 For X windows, this is 10 or 11.");
2620 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
2621 "Non-nil means put cursor in minibuffer, at end of any message there.");
2622 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
2623 "Table defining how to output a glyph code to the frame.\n\
2624 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
2625 Each element can be:\n\
2626 integer: a glyph code which this glyph is an alias for.\n\
2627 string: output this glyph using that string (not impl. in X windows).\n\
2628 nil: this glyph mod 256 is char code to output,\n\
2629 and this glyph / 256 is face code for X windows (see `face-id').");
2630 Vglyph_table
= Qnil
;
2632 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
2633 "Display table to use for buffers that specify none.\n\
2634 See `buffer-display-table' for more information.");
2635 Vstandard_display_table
= Qnil
;
2637 /* Initialize `window-system', unless init_display already decided it. */
2642 Vwindow_system
= Qnil
;
2643 Vwindow_system_version
= Qnil
;