1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985, 86, 87, 88, 93, 94 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
30 #include "termhooks.h"
32 #include "dispextern.h"
39 #include "intervals.h"
46 #endif /* HAVE_X_WINDOWS */
48 #define max(a, b) ((a) > (b) ? (a) : (b))
49 #define min(a, b) ((a) < (b) ? (a) : (b))
51 /* Get number of chars of output now in the buffer of a stdio stream.
52 This ought to be built in in stdio, but it isn't.
53 Some s- files override this because their stdio internals differ. */
54 #ifdef __GNU_LIBRARY__
55 /* The s- file might have overridden the definition with one that works for
56 the system's C library. But we are using the GNU C library, so this is
57 the right definition for every system. */
58 #undef PENDING_OUTPUT_COUNT
59 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
61 #ifndef PENDING_OUTPUT_COUNT
62 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
66 /* Nonzero upon entry to redisplay means do not assume anything about
67 current contents of actual terminal frame; clear and redraw it. */
71 /* Nonzero means last display completed. Zero means it was preempted. */
73 int display_completed
;
75 /* Lisp variable visible-bell; enables use of screen-flash
76 instead of audible bell. */
80 /* Invert the color of the whole frame, at a low level. */
84 /* Line speed of the terminal. */
88 /* nil or a symbol naming the window system under which emacs is
89 running ('x is the only current possibility). */
91 Lisp_Object Vwindow_system
;
93 /* Version number of X windows: 10, 11 or nil. */
94 Lisp_Object Vwindow_system_version
;
96 /* Vector of glyph definitions. Indexed by glyph number,
97 the contents are a string which is how to output the glyph.
99 If Vglyph_table is nil, a glyph is output by using its low 8 bits
100 as a character code. */
102 Lisp_Object Vglyph_table
;
104 /* Display table to use for vectors that don't specify their own. */
106 Lisp_Object Vstandard_display_table
;
108 /* Nonzero means reading single-character input with prompt
109 so put cursor on minibuffer after the prompt.
110 positive means at end of text in echo area;
111 negative means at beginning of line. */
112 int cursor_in_echo_area
;
114 /* The currently selected frame.
115 In a single-frame version, this variable always remains 0. */
117 FRAME_PTR selected_frame
;
119 /* A frame which is not just a minibuffer, or 0 if there are no such
120 frames. This is usually the most recent such frame that was
121 selected. In a single-frame version, this variable always remains 0. */
122 FRAME_PTR last_nonminibuf_frame
;
124 /* In a single-frame version, the information that would otherwise
125 exist inside frame objects lives in the following structure instead.
127 NOTE: the_only_frame is not checked for garbage collection; don't
128 store collectible objects in any of its fields!
130 You're not/The only frame in town/... */
133 struct frame the_only_frame
;
136 /* This is a vector, made larger whenever it isn't large enough,
137 which is used inside `update_frame' to hold the old contents
138 of the FRAME_PHYS_LINES of the frame being updated. */
139 struct frame_glyphs
**ophys_lines
;
140 /* Length of vector currently allocated. */
141 int ophys_lines_length
;
143 FILE *termscript
; /* Stdio stream being used for copy of all output. */
145 struct cm Wcm
; /* Structure for info on cursor positioning */
147 extern short ospeed
; /* Output speed (from sg_ospeed) */
149 int delayed_size_change
; /* 1 means SIGWINCH happened when not safe. */
153 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
154 "Clear frame FRAME and output again what is supposed to appear on it.")
160 CHECK_LIVE_FRAME (frame
, 0);
163 /* set_terminal_modes (); */
165 clear_frame_records (f
);
168 windows_or_buffers_changed
++;
169 /* Mark all windows as INaccurate,
170 so that every window will have its redisplay done. */
171 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
180 XSET (frame
, Lisp_Frame
, f
);
181 Fredraw_frame (frame
);
186 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
187 "Clear frame FRAME and output again what is supposed to appear on it.")
192 set_terminal_modes ();
196 clear_frame_records (0);
197 windows_or_buffers_changed
++;
198 /* Mark all windows as INaccurate,
199 so that every window will have its redisplay done. */
200 mark_window_display_accurate (FRAME_ROOT_WINDOW (0), 0);
206 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
207 "Clear and redisplay all visible frames.")
210 Lisp_Object tail
, frame
;
212 FOR_EACH_FRAME (tail
, frame
)
213 if (FRAME_VISIBLE_P (XFRAME (frame
)))
214 Fredraw_frame (frame
);
219 /* This is used when frame_garbaged is set.
220 Redraw the individual frames marked as garbaged. */
223 redraw_garbaged_frames ()
225 Lisp_Object tail
, frame
;
227 FOR_EACH_FRAME (tail
, frame
)
228 if (FRAME_VISIBLE_P (XFRAME (frame
))
229 && FRAME_GARBAGED_P (XFRAME (frame
)))
230 Fredraw_frame (frame
);
234 static struct frame_glyphs
*
235 make_frame_glyphs (frame
, empty
)
236 register FRAME_PTR frame
;
240 register width
= FRAME_WIDTH (frame
);
241 register height
= FRAME_HEIGHT (frame
);
242 register struct frame_glyphs
*new
243 = (struct frame_glyphs
*) xmalloc (sizeof (struct frame_glyphs
));
245 SET_GLYPHS_FRAME (new, frame
);
246 new->height
= height
;
248 new->used
= (int *) xmalloc (height
* sizeof (int));
249 new->glyphs
= (GLYPH
**) xmalloc (height
* sizeof (GLYPH
*));
250 new->charstarts
= (int **) xmalloc (height
* sizeof (int *));
251 new->highlight
= (char *) xmalloc (height
* sizeof (char));
252 new->enable
= (char *) xmalloc (height
* sizeof (char));
253 bzero (new->enable
, height
* sizeof (char));
254 new->bufp
= (int *) xmalloc (height
* sizeof (int));
256 #ifdef HAVE_X_WINDOWS
257 if (FRAME_X_P (frame
))
259 new->top_left_x
= (short *) xmalloc (height
* sizeof (short));
260 new->top_left_y
= (short *) xmalloc (height
* sizeof (short));
261 new->pix_width
= (short *) xmalloc (height
* sizeof (short));
262 new->pix_height
= (short *) xmalloc (height
* sizeof (short));
263 new->max_ascent
= (short *) xmalloc (height
* sizeof (short));
269 /* Make the buffer used by decode_mode_spec. This buffer is also
270 used as temporary storage when updating the frame. See scroll.c. */
271 unsigned int total_glyphs
= (width
+ 2) * sizeof (GLYPH
);
272 unsigned int total_charstarts
= (width
+ 2) * sizeof (int);
274 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
275 bzero (new->total_contents
, total_glyphs
);
277 new->total_charstarts
= (int *) xmalloc (total_charstarts
);
278 bzero (new->total_charstarts
, total_glyphs
);
282 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (GLYPH
);
284 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
285 bzero (new->total_contents
, total_glyphs
);
286 for (i
= 0; i
< height
; i
++)
287 new->glyphs
[i
] = new->total_contents
+ i
* (width
+ 2) + 1;
289 if (!FRAME_TERMCAP_P (frame
))
291 unsigned int total_charstarts
= height
* (width
+ 2) * sizeof (int);
293 new->total_charstarts
= (int *) xmalloc (total_charstarts
);
294 bzero (new->total_charstarts
, total_charstarts
);
295 for (i
= 0; i
< height
; i
++)
296 new->charstarts
[i
] = new->total_charstarts
+ i
* (width
+ 2) + 1;
300 /* Without a window system, we don't really need charstarts.
301 So use a small amount of space to make enough data structure
302 to prevent crashes in display_text_line. */
303 new->total_charstarts
= (int *) xmalloc ((width
+ 2) * sizeof (int));
304 for (i
= 0; i
< height
; i
++)
305 new->charstarts
[i
] = new->total_charstarts
;
313 free_frame_glyphs (frame
, glyphs
)
315 struct frame_glyphs
*glyphs
;
317 if (glyphs
->total_contents
)
318 xfree (glyphs
->total_contents
);
319 if (glyphs
->total_charstarts
)
320 xfree (glyphs
->total_charstarts
);
322 xfree (glyphs
->used
);
323 xfree (glyphs
->glyphs
);
324 xfree (glyphs
->highlight
);
325 xfree (glyphs
->enable
);
326 xfree (glyphs
->bufp
);
327 if (glyphs
->charstarts
)
328 xfree (glyphs
->charstarts
);
330 #ifdef HAVE_X_WINDOWS
331 if (FRAME_X_P (frame
))
333 xfree (glyphs
->top_left_x
);
334 xfree (glyphs
->top_left_y
);
335 xfree (glyphs
->pix_width
);
336 xfree (glyphs
->pix_height
);
337 xfree (glyphs
->max_ascent
);
345 remake_frame_glyphs (frame
)
348 if (FRAME_CURRENT_GLYPHS (frame
))
349 free_frame_glyphs (frame
, FRAME_CURRENT_GLYPHS (frame
));
350 if (FRAME_DESIRED_GLYPHS (frame
))
351 free_frame_glyphs (frame
, FRAME_DESIRED_GLYPHS (frame
));
352 if (FRAME_TEMP_GLYPHS (frame
))
353 free_frame_glyphs (frame
, FRAME_TEMP_GLYPHS (frame
));
355 if (FRAME_MESSAGE_BUF (frame
))
357 /* Reallocate the frame's message buffer; remember that
358 echo_area_glyphs may be pointing here. */
359 char *old_message_buf
= FRAME_MESSAGE_BUF (frame
);
361 FRAME_MESSAGE_BUF (frame
)
362 = (char *) xrealloc (FRAME_MESSAGE_BUF (frame
),
363 FRAME_WIDTH (frame
) + 1);
365 if (echo_area_glyphs
== old_message_buf
)
366 echo_area_glyphs
= FRAME_MESSAGE_BUF (frame
);
367 if (previous_echo_glyphs
== old_message_buf
)
368 previous_echo_glyphs
= FRAME_MESSAGE_BUF (frame
);
371 FRAME_MESSAGE_BUF (frame
)
372 = (char *) xmalloc (FRAME_WIDTH (frame
) + 1);
374 FRAME_CURRENT_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
375 FRAME_DESIRED_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
376 FRAME_TEMP_GLYPHS (frame
) = make_frame_glyphs (frame
, 1);
377 SET_FRAME_GARBAGED (frame
);
380 /* Return the hash code of contents of line VPOS in frame-matrix M. */
383 line_hash_code (m
, vpos
)
384 register struct frame_glyphs
*m
;
387 register GLYPH
*body
, *end
;
390 if (!m
->enable
[vpos
])
393 /* Give all highlighted lines the same hash code
394 so as to encourage scrolling to leave them in place. */
395 if (m
->highlight
[vpos
])
398 body
= m
->glyphs
[vpos
];
400 if (must_write_spaces
)
407 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
- SPACEGLYPH
;
416 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
;
424 /* Return number of characters in line in M at vpos VPOS,
425 except don't count leading and trailing spaces
426 unless the terminal requires those to be explicitly output. */
429 line_draw_cost (m
, vpos
)
430 struct frame_glyphs
*m
;
433 register GLYPH
*beg
= m
->glyphs
[vpos
];
434 register GLYPH
*end
= m
->glyphs
[vpos
] + m
->used
[vpos
];
436 register int tlen
= GLYPH_TABLE_LENGTH
;
437 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
439 /* Ignore trailing and leading spaces if we can. */
440 if (!must_write_spaces
)
442 while ((end
!= beg
) && (*end
== SPACEGLYPH
))
445 return (0); /* All blank line. */
447 while (*beg
== SPACEGLYPH
)
451 /* If we don't have a glyph-table, each glyph is one character,
452 so return the number of glyphs. */
456 /* Otherwise, scan the glyphs and accumulate their total size in I. */
458 while ((beg
<= end
) && *beg
)
460 register GLYPH g
= *beg
++;
462 if (GLYPH_SIMPLE_P (tbase
, tlen
, g
))
465 i
+= GLYPH_LENGTH (tbase
, g
);
470 /* The functions on this page are the interface from xdisp.c to redisplay.
472 The only other interface into redisplay is through setting
473 FRAME_CURSOR_X (frame) and FRAME_CURSOR_Y (frame)
474 and SET_FRAME_GARBAGED (frame). */
476 /* cancel_line eliminates any request to display a line at position `vpos' */
478 cancel_line (vpos
, frame
)
480 register FRAME_PTR frame
;
482 FRAME_DESIRED_GLYPHS (frame
)->enable
[vpos
] = 0;
485 clear_frame_records (frame
)
486 register FRAME_PTR frame
;
488 bzero (FRAME_CURRENT_GLYPHS (frame
)->enable
, FRAME_HEIGHT (frame
));
491 /* Prepare to display on line VPOS starting at HPOS within it. */
494 get_display_line (frame
, vpos
, hpos
)
495 register FRAME_PTR frame
;
499 register struct frame_glyphs
*glyphs
;
500 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (frame
);
506 if ((desired_glyphs
->enable
[vpos
]) && desired_glyphs
->used
[vpos
] > hpos
)
509 if (! desired_glyphs
->enable
[vpos
])
511 desired_glyphs
->used
[vpos
] = 0;
512 desired_glyphs
->highlight
[vpos
] = 0;
513 desired_glyphs
->enable
[vpos
] = 1;
516 if (hpos
> desired_glyphs
->used
[vpos
])
518 GLYPH
*g
= desired_glyphs
->glyphs
[vpos
] + desired_glyphs
->used
[vpos
];
519 GLYPH
*end
= desired_glyphs
->glyphs
[vpos
] + hpos
;
521 desired_glyphs
->used
[vpos
] = hpos
;
527 /* Like bcopy except never gets confused by overlap. */
530 safe_bcopy (from
, to
, size
)
534 if (size
<= 0 || from
== to
)
537 /* If the source and destination don't overlap, then bcopy can
538 handle it. If they do overlap, but the destination is lower in
539 memory than the source, we'll assume bcopy can handle that. */
540 if (to
< from
|| from
+ size
<= to
)
541 bcopy (from
, to
, size
);
543 /* Otherwise, we'll copy from the end. */
546 register char *endf
= from
+ size
;
547 register char *endt
= to
+ size
;
549 /* If TO - FROM is large, then we should break the copy into
550 nonoverlapping chunks of TO - FROM bytes each. However, if
551 TO - FROM is small, then the bcopy function call overhead
552 makes this not worth it. The crossover point could be about
553 anywhere. Since I don't think the obvious copy loop is too
554 bad, I'm trying to err in its favor. */
559 while (endf
!= from
);
571 bcopy (endf
, endt
, to
- from
);
574 /* If SIZE wasn't a multiple of TO - FROM, there will be a
575 little left over. The amount left over is
576 (endt + (to - from)) - to, which is endt - from. */
577 bcopy (from
, to
, endt
- from
);
582 /* Rotate a vector of SIZE bytes right, by DISTANCE bytes.
583 DISTANCE may be negative. */
586 rotate_vector (vector
, size
, distance
)
591 char *temp
= (char *) alloca (size
);
596 bcopy (vector
, temp
+ distance
, size
- distance
);
597 bcopy (vector
+ size
- distance
, temp
, distance
);
598 bcopy (temp
, vector
, size
);
601 /* Scroll lines from vpos FROM up to but not including vpos END
602 down by AMOUNT lines (AMOUNT may be negative).
603 Returns nonzero if done, zero if terminal cannot scroll them. */
606 scroll_frame_lines (frame
, from
, end
, amount
, newpos
)
607 register FRAME_PTR frame
;
608 int from
, end
, amount
, newpos
;
611 register struct frame_glyphs
*current_frame
612 = FRAME_CURRENT_GLYPHS (frame
);
614 int width
= FRAME_WIDTH (frame
);
616 if (!line_ins_del_ok
)
624 update_begin (frame
);
625 set_terminal_window (end
+ amount
);
626 if (!scroll_region_ok
)
627 ins_del_lines (end
, -amount
);
628 ins_del_lines (from
, amount
);
629 set_terminal_window (0);
631 rotate_vector (current_frame
->glyphs
+ from
,
632 sizeof (GLYPH
*) * (end
+ amount
- from
),
633 amount
* sizeof (GLYPH
*));
635 rotate_vector (current_frame
->charstarts
+ from
,
636 sizeof (int *) * (end
+ amount
- from
),
637 amount
* sizeof (int *));
639 safe_bcopy (current_frame
->used
+ from
,
640 current_frame
->used
+ from
+ amount
,
641 (end
- from
) * sizeof current_frame
->used
[0]);
643 safe_bcopy (current_frame
->highlight
+ from
,
644 current_frame
->highlight
+ from
+ amount
,
645 (end
- from
) * sizeof current_frame
->highlight
[0]);
647 safe_bcopy (current_frame
->enable
+ from
,
648 current_frame
->enable
+ from
+ amount
,
649 (end
- from
) * sizeof current_frame
->enable
[0]);
651 /* Adjust the lines by an amount
652 that puts the first of them at NEWPOS. */
653 pos_adjust
= newpos
- current_frame
->charstarts
[from
+ amount
][0];
655 /* Offset each char position in the charstarts lines we moved
657 for (i
= from
+ amount
; i
< end
+ amount
; i
++)
659 int *line
= current_frame
->charstarts
[i
];
661 for (col
= 0; col
< width
; col
++)
663 line
[col
] += pos_adjust
;
665 for (i
= from
; i
< from
+ amount
; i
++)
667 int *line
= current_frame
->charstarts
[i
];
670 for (col
= 0; col
< width
; col
++)
674 /* Mark the lines made empty by scrolling as enabled, empty and
676 bzero (current_frame
->used
+ from
,
677 amount
* sizeof current_frame
->used
[0]);
678 bzero (current_frame
->highlight
+ from
,
679 amount
* sizeof current_frame
->highlight
[0]);
680 for (i
= from
; i
< from
+ amount
; i
++)
682 current_frame
->glyphs
[i
][0] = '\0';
683 current_frame
->charstarts
[i
][0] = -1;
684 current_frame
->enable
[i
] = 1;
687 safe_bcopy (current_frame
->bufp
+ from
,
688 current_frame
->bufp
+ from
+ amount
,
689 (end
- from
) * sizeof current_frame
->bufp
[0]);
691 #ifdef HAVE_X_WINDOWS
692 if (FRAME_X_P (frame
))
694 safe_bcopy (current_frame
->top_left_x
+ from
,
695 current_frame
->top_left_x
+ from
+ amount
,
696 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
698 safe_bcopy (current_frame
->top_left_y
+ from
,
699 current_frame
->top_left_y
+ from
+ amount
,
700 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
702 safe_bcopy (current_frame
->pix_width
+ from
,
703 current_frame
->pix_width
+ from
+ amount
,
704 (end
- from
) * sizeof current_frame
->pix_width
[0]);
706 safe_bcopy (current_frame
->pix_height
+ from
,
707 current_frame
->pix_height
+ from
+ amount
,
708 (end
- from
) * sizeof current_frame
->pix_height
[0]);
710 safe_bcopy (current_frame
->max_ascent
+ from
,
711 current_frame
->max_ascent
+ from
+ amount
,
712 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
714 #endif /* HAVE_X_WINDOWS */
720 update_begin (frame
);
721 set_terminal_window (end
);
722 ins_del_lines (from
+ amount
, amount
);
723 if (!scroll_region_ok
)
724 ins_del_lines (end
+ amount
, -amount
);
725 set_terminal_window (0);
727 rotate_vector (current_frame
->glyphs
+ from
+ amount
,
728 sizeof (GLYPH
*) * (end
- from
- amount
),
729 amount
* sizeof (GLYPH
*));
731 rotate_vector (current_frame
->charstarts
+ from
+ amount
,
732 sizeof (int *) * (end
- from
- amount
),
733 amount
* sizeof (int *));
735 safe_bcopy (current_frame
->used
+ from
,
736 current_frame
->used
+ from
+ amount
,
737 (end
- from
) * sizeof current_frame
->used
[0]);
739 safe_bcopy (current_frame
->highlight
+ from
,
740 current_frame
->highlight
+ from
+ amount
,
741 (end
- from
) * sizeof current_frame
->highlight
[0]);
743 safe_bcopy (current_frame
->enable
+ from
,
744 current_frame
->enable
+ from
+ amount
,
745 (end
- from
) * sizeof current_frame
->enable
[0]);
747 /* Adjust the lines by an amount
748 that puts the first of them at NEWPOS. */
749 pos_adjust
= newpos
- current_frame
->charstarts
[from
+ amount
][0];
751 /* Offset each char position in the charstarts lines we moved
753 for (i
= from
+ amount
; i
< end
+ amount
; i
++)
755 int *line
= current_frame
->charstarts
[i
];
757 for (col
= 0; col
< width
; col
++)
759 line
[col
] += pos_adjust
;
761 for (i
= end
+ amount
; i
< end
; i
++)
763 int *line
= current_frame
->charstarts
[i
];
766 for (col
= 0; col
< width
; col
++)
770 /* Mark the lines made empty by scrolling as enabled, empty and
772 bzero (current_frame
->used
+ end
+ amount
,
773 - amount
* sizeof current_frame
->used
[0]);
774 bzero (current_frame
->highlight
+ end
+ amount
,
775 - amount
* sizeof current_frame
->highlight
[0]);
776 for (i
= end
+ amount
; i
< end
; i
++)
778 current_frame
->glyphs
[i
][0] = '\0';
779 current_frame
->charstarts
[i
][0] = 0;
780 current_frame
->enable
[i
] = 1;
783 safe_bcopy (current_frame
->bufp
+ from
,
784 current_frame
->bufp
+ from
+ amount
,
785 (end
- from
) * sizeof current_frame
->bufp
[0]);
787 #ifdef HAVE_X_WINDOWS
788 if (FRAME_X_P (frame
))
790 safe_bcopy (current_frame
->top_left_x
+ from
,
791 current_frame
->top_left_x
+ from
+ amount
,
792 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
794 safe_bcopy (current_frame
->top_left_y
+ from
,
795 current_frame
->top_left_y
+ from
+ amount
,
796 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
798 safe_bcopy (current_frame
->pix_width
+ from
,
799 current_frame
->pix_width
+ from
+ amount
,
800 (end
- from
) * sizeof current_frame
->pix_width
[0]);
802 safe_bcopy (current_frame
->pix_height
+ from
,
803 current_frame
->pix_height
+ from
+ amount
,
804 (end
- from
) * sizeof current_frame
->pix_height
[0]);
806 safe_bcopy (current_frame
->max_ascent
+ from
,
807 current_frame
->max_ascent
+ from
+ amount
,
808 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
810 #endif /* HAVE_X_WINDOWS */
817 /* After updating a window W that isn't the full frame wide,
818 copy all the columns that W does not occupy
819 into the FRAME_DESIRED_GLYPHS (frame) from the FRAME_PHYS_GLYPHS (frame)
820 so that update_frame will not change those columns. */
822 preserve_other_columns (w
)
826 register struct frame_glyphs
*current_frame
, *desired_frame
;
827 register FRAME_PTR frame
= XFRAME (w
->frame
);
828 int start
= XFASTINT (w
->left
);
829 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
830 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
832 current_frame
= FRAME_CURRENT_GLYPHS (frame
);
833 desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
835 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
837 if (current_frame
->enable
[vpos
] && desired_frame
->enable
[vpos
])
843 bcopy (current_frame
->glyphs
[vpos
],
844 desired_frame
->glyphs
[vpos
],
845 start
* sizeof (current_frame
->glyphs
[vpos
]));
846 bcopy (current_frame
->charstarts
[vpos
],
847 desired_frame
->charstarts
[vpos
],
848 start
* sizeof (current_frame
->charstarts
[vpos
]));
849 len
= min (start
, current_frame
->used
[vpos
]);
850 if (desired_frame
->used
[vpos
] < len
)
851 desired_frame
->used
[vpos
] = len
;
853 if (current_frame
->used
[vpos
] > end
854 && desired_frame
->used
[vpos
] < current_frame
->used
[vpos
])
856 while (desired_frame
->used
[vpos
] < end
)
858 int used
= desired_frame
->used
[vpos
]++;
859 desired_frame
->glyphs
[vpos
][used
] = SPACEGLYPH
;
860 desired_frame
->glyphs
[vpos
][used
] = 0;
862 bcopy (current_frame
->glyphs
[vpos
] + end
,
863 desired_frame
->glyphs
[vpos
] + end
,
864 ((current_frame
->used
[vpos
] - end
)
865 * sizeof (current_frame
->glyphs
[vpos
])));
866 bcopy (current_frame
->charstarts
[vpos
] + end
,
867 desired_frame
->charstarts
[vpos
] + end
,
868 ((current_frame
->used
[vpos
] - end
)
869 * sizeof (current_frame
->charstarts
[vpos
])));
870 desired_frame
->used
[vpos
] = current_frame
->used
[vpos
];
878 /* If window w does not need to be updated and isn't the full frame wide,
879 copy all the columns that w does occupy
880 into the FRAME_DESIRED_LINES (frame) from the FRAME_PHYS_LINES (frame)
881 so that update_frame will not change those columns.
883 Have not been able to figure out how to use this correctly. */
885 preserve_my_columns (w
)
888 register int vpos
, fin
;
889 register struct frame_glyphs
*l1
, *l2
;
890 register FRAME_PTR frame
= XFRAME (w
->frame
);
891 int start
= XFASTINT (w
->left
);
892 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
893 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
895 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
897 if ((l1
= FRAME_DESIRED_GLYPHS (frame
)->glyphs
[vpos
+ 1])
898 && (l2
= FRAME_PHYS_GLYPHS (frame
)->glyphs
[vpos
+ 1]))
900 if (l2
->length
> start
&& l1
->length
< l2
->length
)
903 if (fin
> end
) fin
= end
;
904 while (l1
->length
< start
)
905 l1
->body
[l1
->length
++] = ' ';
906 bcopy (l2
->body
+ start
, l1
->body
+ start
, fin
- start
);
915 /* Adjust by ADJUST the charstart values in window W
916 after vpos VPOS, which counts relative to the frame
917 (not relative to W itself). */
920 adjust_window_charstarts (w
, vpos
, adjust
)
925 int left
= XFASTINT (w
->left
);
926 int top
= XFASTINT (w
->top
);
927 int right
= left
+ window_internal_width (w
);
928 int bottom
= top
+ window_internal_height (w
);
931 for (i
= vpos
+ 1; i
< bottom
; i
++)
934 = FRAME_CURRENT_GLYPHS (XFRAME (WINDOW_FRAME (w
)))->charstarts
[i
];
936 for (j
= left
; j
< right
; j
++)
937 if (charstart
[j
] > 0)
938 charstart
[j
] += adjust
;
942 /* Check the charstarts values in the area of window W
943 for internal consistency. We cannot check that they are "right";
944 we can only look for something nonsensical. */
946 verify_charstarts (w
)
949 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
951 int top
= XFASTINT (w
->top
);
952 int bottom
= top
+ window_internal_height (w
);
953 int left
= XFASTINT (w
->left
);
954 int right
= left
+ window_internal_width (w
);
956 int truncate
= (XINT (w
->hscroll
)
957 || (truncate_partial_width_windows
958 && (XFASTINT (w
->width
) < FRAME_WIDTH (f
)))
959 || !NILP (XBUFFER (w
->buffer
)->truncate_lines
));
961 for (i
= top
; i
< bottom
; i
++)
965 int *charstart
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[i
];
971 /* If we are truncating lines, allow a jump
972 in charstarts from one line to the next. */
973 if (charstart
[left
] < next_line
)
978 if (charstart
[left
] != next_line
)
983 for (j
= left
; j
< right
; j
++)
984 if (charstart
[j
] > 0)
986 /* Record where the next line should start. */
988 if (BUF_ZV (XBUFFER (w
->buffer
)) != last
)
990 /* If there's a newline between the two lines, count that. */
991 int endchar
= *BUF_CHAR_ADDRESS (XBUFFER (w
->buffer
), last
);
998 /* On discovering that the redisplay for a window was no good,
999 cancel the columns of that window, so that when the window is
1000 displayed over again get_display_line will not complain. */
1002 cancel_my_columns (w
)
1006 register struct frame_glyphs
*desired_glyphs
1007 = FRAME_DESIRED_GLYPHS (XFRAME (w
->frame
));
1008 register int start
= XFASTINT (w
->left
);
1009 register int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
1011 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
1012 if (desired_glyphs
->enable
[vpos
]
1013 && desired_glyphs
->used
[vpos
] >= start
)
1014 desired_glyphs
->used
[vpos
] = start
;
1017 /* These functions try to perform directly and immediately on the frame
1018 the necessary output for one change in the buffer.
1019 They may return 0 meaning nothing was done if anything is difficult,
1020 or 1 meaning the output was performed properly.
1021 They assume that the frame was up to date before the buffer
1022 change being displayed. They make various other assumptions too;
1023 see command_loop_1 where these are called. */
1026 direct_output_for_insert (g
)
1029 register FRAME_PTR frame
= selected_frame
;
1030 register struct frame_glyphs
*current_frame
1031 = FRAME_CURRENT_GLYPHS (frame
);
1033 #ifndef COMPILER_REGISTER_BUG
1035 #endif /* COMPILER_REGISTER_BUG */
1036 struct window
*w
= XWINDOW (selected_window
);
1037 #ifndef COMPILER_REGISTER_BUG
1039 #endif /* COMPILER_REGISTER_BUG */
1040 int hpos
= FRAME_CURSOR_X (frame
);
1041 #ifndef COMPILER_REGISTER_BUG
1043 #endif /* COMPILER_REGISTER_BUG */
1044 int vpos
= FRAME_CURSOR_Y (frame
);
1046 /* Give up if about to continue line. */
1047 if (hpos
>= XFASTINT (w
->left
) + window_internal_width (w
) - 1
1049 /* Avoid losing if cursor is in invisible text off left margin */
1050 || (XINT (w
->hscroll
) && hpos
== XFASTINT (w
->left
))
1052 /* Give up if cursor outside window (in minibuf, probably) */
1053 || cursor_in_echo_area
1054 || FRAME_CURSOR_Y (frame
) < XFASTINT (w
->top
)
1055 || FRAME_CURSOR_Y (frame
) >= XFASTINT (w
->top
) + XFASTINT (w
->height
)
1057 /* Give up if cursor not really at FRAME_CURSOR_X, FRAME_CURSOR_Y */
1058 || !display_completed
1060 /* Give up if buffer appears in two places. */
1061 || buffer_shared
> 1
1063 #ifdef USE_TEXT_PROPERTIES
1064 /* Intervals have already been adjusted, point is after the
1065 character that was just inserted. */
1066 /* Give up if character is invisible. */
1067 /* Give up if character has a face property.
1068 At the moment we only lose at end of line or end of buffer
1069 and only with faces that have some background */
1070 /* Instead of wasting time, give up if character has any text properties */
1071 || ! NILP (Ftext_properties_at (XFASTINT (point
- 1), Qnil
))
1074 /* Give up if w is minibuffer and a message is being displayed there */
1075 || (MINI_WINDOW_P (w
) && echo_area_glyphs
))
1079 #ifdef HAVE_X_WINDOWS
1081 int face
= compute_char_face (frame
, w
, point
- 1, -1, -1, &dummy
, point
);
1083 current_frame
->glyphs
[vpos
][hpos
] = MAKE_GLYPH (frame
, g
, face
);
1084 current_frame
->charstarts
[vpos
][hpos
] = point
- 1;
1085 /* Record the entry for after the newly inserted character. */
1086 current_frame
->charstarts
[vpos
][hpos
+ 1] = point
;
1087 adjust_window_charstarts (w
, vpos
, 1);
1089 unchanged_modified
= MODIFF
;
1090 beg_unchanged
= GPT
- BEG
;
1091 XFASTINT (w
->last_point
) = point
;
1092 XFASTINT (w
->last_point_x
) = hpos
;
1093 XFASTINT (w
->last_modified
) = MODIFF
;
1095 reassert_line_highlight (0, vpos
);
1096 write_glyphs (¤t_frame
->glyphs
[vpos
][hpos
], 1);
1098 ++FRAME_CURSOR_X (frame
);
1099 if (hpos
== current_frame
->used
[vpos
])
1101 current_frame
->used
[vpos
] = hpos
+ 1;
1102 current_frame
->glyphs
[vpos
][hpos
+ 1] = 0;
1109 direct_output_forward_char (n
)
1112 register FRAME_PTR frame
= selected_frame
;
1113 register struct window
*w
= XWINDOW (selected_window
);
1115 int hpos
= FRAME_CURSOR_X (frame
);
1117 /* Give up if in truncated text at end of line. */
1118 if (hpos
>= XFASTINT (w
->left
) + window_internal_width (w
) - 1)
1121 /* Avoid losing if cursor is in invisible text off left margin
1122 or about to go off either side of window. */
1123 if ((FRAME_CURSOR_X (frame
) == XFASTINT (w
->left
)
1124 && (XINT (w
->hscroll
) || n
< 0))
1126 && (FRAME_CURSOR_X (frame
) + 1 >= window_internal_width (w
) - 1))
1127 || cursor_in_echo_area
)
1130 /* Can't use direct output if highlighting a region. */
1131 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
1134 #ifdef USE_TEXT_PROPERTIES
1135 /* Don't use direct output next to an invisible character
1136 since we might need to do something special. */
1138 XFASTINT (position
) = point
;
1139 if (XFASTINT (position
) < ZV
1140 && ! NILP (Fget_char_property (position
,
1145 XFASTINT (position
) = point
- 1;
1146 if (XFASTINT (position
) >= BEGV
1147 && ! NILP (Fget_char_property (position
,
1153 FRAME_CURSOR_X (frame
) += n
;
1154 XFASTINT (w
->last_point_x
) = FRAME_CURSOR_X (frame
);
1155 XFASTINT (w
->last_point
) = point
;
1156 cursor_to (FRAME_CURSOR_Y (frame
), FRAME_CURSOR_X (frame
));
1162 static void update_line ();
1164 /* Update frame F based on the data in FRAME_DESIRED_GLYPHS.
1165 Value is nonzero if redisplay stopped due to pending input.
1166 FORCE nonzero means do not stop for pending input. */
1169 update_frame (f
, force
, inhibit_hairy_id
)
1172 int inhibit_hairy_id
;
1174 register struct frame_glyphs
*current_frame
;
1175 register struct frame_glyphs
*desired_frame
= 0;
1178 int preempt_count
= baud_rate
/ 2400 + 1;
1179 extern input_pending
;
1180 #ifdef HAVE_X_WINDOWS
1181 register int downto
, leftmost
;
1184 if (preempt_count
<= 0)
1187 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1189 detect_input_pending ();
1190 if (input_pending
&& !force
)
1198 if (!line_ins_del_ok
)
1199 inhibit_hairy_id
= 1;
1201 /* These are separate to avoid a possible bug in the AIX C compiler. */
1202 current_frame
= FRAME_CURRENT_GLYPHS (f
);
1203 desired_frame
= FRAME_DESIRED_GLYPHS (f
);
1205 /* See if any of the desired lines are enabled; don't compute for
1206 i/d line if just want cursor motion. */
1207 for (i
= 0; i
< FRAME_HEIGHT (f
); i
++)
1208 if (desired_frame
->enable
[i
])
1211 /* Try doing i/d line, if not yet inhibited. */
1212 if (!inhibit_hairy_id
&& i
< FRAME_HEIGHT (f
))
1213 force
|= scrolling (f
);
1215 /* Update the individual lines as needed. Do bottom line first. */
1217 if (desired_frame
->enable
[FRAME_HEIGHT (f
) - 1])
1218 update_line (f
, FRAME_HEIGHT (f
) - 1);
1220 #ifdef HAVE_X_WINDOWS
1223 leftmost
= downto
= f
->display
.x
->internal_border_width
;
1224 if (desired_frame
->enable
[0])
1226 current_frame
->top_left_x
[FRAME_HEIGHT (f
) - 1] = leftmost
;
1227 current_frame
->top_left_y
[FRAME_HEIGHT (f
) - 1]
1228 = PIXEL_HEIGHT (f
) - f
->display
.x
->internal_border_width
1229 - current_frame
->pix_height
[FRAME_HEIGHT (f
) - 1];
1230 current_frame
->top_left_x
[0] = leftmost
;
1231 current_frame
->top_left_y
[0] = downto
;
1234 #endif /* HAVE_X_WINDOWS */
1236 /* Now update the rest of the lines. */
1237 for (i
= 0; i
< FRAME_HEIGHT (f
) - 1 && (force
|| !input_pending
); i
++)
1239 if (desired_frame
->enable
[i
])
1241 if (FRAME_TERMCAP_P (f
))
1243 /* Flush out every so many lines.
1244 Also flush out if likely to have more than 1k buffered
1245 otherwise. I'm told that some telnet connections get
1246 really screwed by more than 1k output at once. */
1247 int outq
= PENDING_OUTPUT_COUNT (stdout
);
1249 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
1252 if (preempt_count
== 1)
1254 #ifdef EMACS_OUTQSIZE
1255 if (EMACS_OUTQSIZE (0, &outq
) < 0)
1256 /* Probably not a tty. Ignore the error and reset
1257 * the outq count. */
1258 outq
= PENDING_OUTPUT_COUNT (stdout
);
1261 if (baud_rate
>= outq
)
1262 sleep (outq
/ baud_rate
);
1265 if ((i
- 1) % preempt_count
== 0)
1266 detect_input_pending ();
1270 #ifdef HAVE_X_WINDOWS
1273 current_frame
->top_left_y
[i
] = downto
;
1274 current_frame
->top_left_x
[i
] = leftmost
;
1276 #endif /* HAVE_X_WINDOWS */
1279 #ifdef HAVE_X_WINDOWS
1281 downto
+= current_frame
->pix_height
[i
];
1284 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
1286 /* Now just clean up termcap drivers and set cursor, etc. */
1289 if (cursor_in_echo_area
1290 && FRAME_HAS_MINIBUF_P (f
))
1292 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
1295 if (cursor_in_echo_area
< 0)
1302 /* If the minibuffer is several lines high, find the last
1303 line that has any text on it. */
1304 row
= FRAME_HEIGHT (f
);
1308 if (current_frame
->enable
[row
])
1309 col
= current_frame
->used
[row
];
1313 while (row
> top
&& col
== 0);
1315 if (col
>= FRAME_WIDTH (f
))
1318 if (row
< FRAME_HEIGHT (f
) - 1)
1323 cursor_to (row
, col
);
1326 cursor_to (FRAME_CURSOR_Y (f
), max (min (FRAME_CURSOR_X (f
),
1327 FRAME_WIDTH (f
) - 1), 0));
1333 fflush (termscript
);
1336 /* Here if output is preempted because input is detected. */
1339 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1340 display_completed
= !pause
;
1342 bzero (FRAME_DESIRED_GLYPHS (f
)->enable
, FRAME_HEIGHT (f
));
1346 /* Called when about to quit, to check for doing so
1347 at an improper time. */
1352 if (FRAME_DESIRED_GLYPHS (selected_frame
) == 0)
1354 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[0])
1356 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[FRAME_HEIGHT (selected_frame
) - 1])
1360 /* Decide what insert/delete line to do, and do it */
1362 extern void scrolling_1 ();
1367 int unchanged_at_top
, unchanged_at_bottom
;
1370 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1371 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1372 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1374 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
1375 register struct frame_glyphs
*current_frame
= FRAME_CURRENT_GLYPHS (frame
);
1376 register struct frame_glyphs
*desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
1378 /* Compute hash codes of all the lines.
1379 Also calculate number of changed lines,
1380 number of unchanged lines at the beginning,
1381 and number of unchanged lines at the end. */
1384 unchanged_at_top
= 0;
1385 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
1386 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
1388 /* Give up on this scrolling if some old lines are not enabled. */
1389 if (!current_frame
->enable
[i
])
1391 old_hash
[i
] = line_hash_code (current_frame
, i
);
1392 if (! desired_frame
->enable
[i
])
1393 new_hash
[i
] = old_hash
[i
];
1395 new_hash
[i
] = line_hash_code (desired_frame
, i
);
1397 if (old_hash
[i
] != new_hash
[i
])
1400 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
1402 else if (i
== unchanged_at_top
)
1404 draw_cost
[i
] = line_draw_cost (desired_frame
, i
);
1407 /* If changed lines are few, don't allow preemption, don't scroll. */
1408 if (changed_lines
< baud_rate
/ 2400
1409 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
1412 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
1413 - unchanged_at_bottom
);
1415 if (scroll_region_ok
)
1416 free_at_end_vpos
-= unchanged_at_bottom
;
1417 else if (memory_below_frame
)
1418 free_at_end_vpos
= -1;
1420 /* If large window, fast terminal and few lines in common between
1421 current frame and desired frame, don't bother with i/d calc. */
1422 if (window_size
>= 18 && baud_rate
> 2400
1424 10 * scrolling_max_lines_saved (unchanged_at_top
,
1425 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
1426 old_hash
, new_hash
, draw_cost
)))
1429 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
1430 draw_cost
+ unchanged_at_top
- 1,
1431 old_hash
+ unchanged_at_top
- 1,
1432 new_hash
+ unchanged_at_top
- 1,
1433 free_at_end_vpos
- unchanged_at_top
);
1438 /* Return the offset in its buffer of the character at location col, line
1439 in the given window. */
1441 buffer_posn_from_coords (window
, col
, line
)
1442 struct window
*window
;
1445 int hscroll
= XINT (window
->hscroll
);
1446 int window_left
= XFASTINT (window
->left
);
1448 /* The actual width of the window is window->width less one for the
1449 DISP_CONTINUE_GLYPH, and less one if it's not the rightmost
1451 int window_width
= window_internal_width (window
) - 1;
1453 int startp
= marker_position (window
->start
);
1455 /* Since compute_motion will only operate on the current buffer,
1456 we need to save the old one and restore it when we're done. */
1457 struct buffer
*old_current_buffer
= current_buffer
;
1458 struct position
*posn
;
1460 current_buffer
= XBUFFER (window
->buffer
);
1462 /* It would be nice if we could use FRAME_CURRENT_GLYPHS (XFRAME
1463 (window->frame))->bufp to avoid scanning from the very top of
1464 the window, but it isn't maintained correctly, and I'm not even
1465 sure I will keep it. */
1466 posn
= compute_motion (startp
, 0,
1467 (window
== XWINDOW (minibuf_window
) && startp
== 1
1468 ? minibuf_prompt_width
: 0)
1469 + (hscroll
? 1 - hscroll
: 0),
1471 window_width
, hscroll
, 0, window
);
1473 current_buffer
= old_current_buffer
;
1475 /* compute_motion considers frame points past the end of a line
1476 to be *after* the newline, i.e. at the start of the next line.
1477 This is reasonable, but not really what we want. So if the
1478 result is on a line below LINE, back it up one character. */
1479 if (posn
->vpos
> line
)
1480 return posn
->bufpos
- 1;
1482 return posn
->bufpos
;
1489 register GLYPH
*p
= r
;
1490 while (*p
++ == SPACEGLYPH
);
1495 count_match (str1
, str2
)
1498 register GLYPH
*p1
= str1
;
1499 register GLYPH
*p2
= str2
;
1500 while (*p1
++ == *p2
++);
1501 return p1
- str1
- 1;
1504 /* Char insertion/deletion cost vector, from term.c */
1505 extern int *char_ins_del_vector
;
1507 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WIDTH((f))])
1510 update_line (frame
, vpos
)
1511 register FRAME_PTR frame
;
1514 register GLYPH
*obody
, *nbody
, *op1
, *op2
, *np1
, *temp
;
1517 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
1519 register struct frame_glyphs
*current_frame
1520 = FRAME_CURRENT_GLYPHS (frame
);
1521 register struct frame_glyphs
*desired_frame
1522 = FRAME_DESIRED_GLYPHS (frame
);
1524 if (desired_frame
->highlight
[vpos
]
1525 != (current_frame
->enable
[vpos
] && current_frame
->highlight
[vpos
]))
1527 change_line_highlight (desired_frame
->highlight
[vpos
], vpos
,
1528 (current_frame
->enable
[vpos
] ?
1529 current_frame
->used
[vpos
] : 0));
1530 current_frame
->enable
[vpos
] = 0;
1533 reassert_line_highlight (desired_frame
->highlight
[vpos
], vpos
);
1535 if (! current_frame
->enable
[vpos
])
1541 obody
= current_frame
->glyphs
[vpos
];
1542 olen
= current_frame
->used
[vpos
];
1543 if (! current_frame
->highlight
[vpos
])
1545 if (!must_write_spaces
)
1546 while (obody
[olen
- 1] == SPACEGLYPH
&& olen
> 0)
1551 /* For an inverse-video line, remember we gave it
1552 spaces all the way to the frame edge
1553 so that the reverse video extends all the way across. */
1555 while (olen
< FRAME_WIDTH (frame
) - 1)
1556 obody
[olen
++] = SPACEGLYPH
;
1560 /* One way or another, this will enable the line being updated. */
1561 current_frame
->enable
[vpos
] = 1;
1562 current_frame
->used
[vpos
] = desired_frame
->used
[vpos
];
1563 current_frame
->highlight
[vpos
] = desired_frame
->highlight
[vpos
];
1564 current_frame
->bufp
[vpos
] = desired_frame
->bufp
[vpos
];
1566 #ifdef HAVE_X_WINDOWS
1567 if (FRAME_X_P (frame
))
1569 current_frame
->pix_width
[vpos
]
1570 = current_frame
->used
[vpos
]
1571 * FONT_WIDTH (frame
->display
.x
->font
);
1572 current_frame
->pix_height
[vpos
]
1573 = frame
->display
.x
->line_height
;
1575 #endif /* HAVE_X_WINDOWS */
1577 if (!desired_frame
->enable
[vpos
])
1583 nbody
= desired_frame
->glyphs
[vpos
];
1584 nlen
= desired_frame
->used
[vpos
];
1586 /* Pretend trailing spaces are not there at all,
1587 unless for one reason or another we must write all spaces. */
1588 if (! desired_frame
->highlight
[vpos
])
1590 if (!must_write_spaces
)
1591 /* We know that the previous character byte contains 0. */
1592 while (nbody
[nlen
- 1] == SPACEGLYPH
)
1597 /* For an inverse-video line, give it extra trailing spaces
1598 all the way to the frame edge
1599 so that the reverse video extends all the way across. */
1601 while (nlen
< FRAME_WIDTH (frame
) - 1)
1602 nbody
[nlen
++] = SPACEGLYPH
;
1605 /* If there's no i/d char, quickly do the best we can without it. */
1606 if (!char_ins_del_ok
)
1611 if (FRAME_X_P (frame
))
1613 /* Under X, erase everything we are going to rewrite,
1614 and rewrite everything from the first char that's changed.
1615 This is part of supporting fonts like Courier
1616 whose chars can overlap outside the char width. */
1617 for (i
= 0; i
< nlen
; i
++)
1618 if (i
>= olen
|| nbody
[i
] != obody
[i
])
1621 cursor_to (vpos
, i
);
1623 clear_end_of_line (olen
);
1624 write_glyphs (nbody
+ i
, nlen
- i
);
1629 for (i
= 0; i
< nlen
; i
++)
1631 if (i
>= olen
|| nbody
[i
] != obody
[i
]) /* A non-matching char. */
1633 cursor_to (vpos
, i
);
1634 for (j
= 1; (i
+ j
< nlen
&&
1635 (i
+ j
>= olen
|| nbody
[i
+j
] != obody
[i
+j
]));
1638 /* Output this run of non-matching chars. */
1639 write_glyphs (nbody
+ i
, j
);
1642 /* Now find the next non-match. */
1646 /* Clear the rest of the line, or the non-clear part of it. */
1649 cursor_to (vpos
, nlen
);
1650 clear_end_of_line (olen
);
1653 /* Exchange contents between current_frame and new_frame. */
1654 temp
= desired_frame
->glyphs
[vpos
];
1655 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1656 current_frame
->glyphs
[vpos
] = temp
;
1658 /* Exchange charstarts between current_frame and new_frame. */
1659 temp1
= desired_frame
->charstarts
[vpos
];
1660 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1661 current_frame
->charstarts
[vpos
] = temp1
;
1668 nsp
= (must_write_spaces
|| desired_frame
->highlight
[vpos
])
1669 ? 0 : count_blanks (nbody
);
1672 cursor_to (vpos
, nsp
);
1673 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
1676 /* Exchange contents between current_frame and new_frame. */
1677 temp
= desired_frame
->glyphs
[vpos
];
1678 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1679 current_frame
->glyphs
[vpos
] = temp
;
1681 /* Exchange charstarts between current_frame and new_frame. */
1682 temp1
= desired_frame
->charstarts
[vpos
];
1683 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1684 current_frame
->charstarts
[vpos
] = temp1
;
1693 /* Compute number of leading blanks in old and new contents. */
1694 osp
= count_blanks (obody
);
1695 if (!desired_frame
->highlight
[vpos
])
1696 nsp
= count_blanks (nbody
);
1700 /* Compute number of matching chars starting with first nonblank. */
1701 begmatch
= count_match (obody
+ osp
, nbody
+ nsp
);
1703 /* Spaces in new match implicit space past the end of old. */
1704 /* A bug causing this to be a no-op was fixed in 18.29. */
1705 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
1708 while (np1
[begmatch
] == SPACEGLYPH
)
1712 /* Avoid doing insert/delete char
1713 just cause number of leading spaces differs
1714 when the following text does not match. */
1715 if (begmatch
== 0 && osp
!= nsp
)
1716 osp
= nsp
= min (osp
, nsp
);
1718 /* Find matching characters at end of line */
1721 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
1722 while (op1
> op2
&& op1
[-1] == np1
[-1])
1727 endmatch
= obody
+ olen
- op1
;
1729 /* Put correct value back in nbody[nlen].
1730 This is important because direct_output_for_insert
1731 can write into the line at a later point.
1732 If this screws up the zero at the end of the line, re-establish it. */
1736 /* tem gets the distance to insert or delete.
1737 endmatch is how many characters we save by doing so.
1740 tem
= (nlen
- nsp
) - (olen
- osp
);
1742 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
1745 /* nsp - osp is the distance to insert or delete.
1746 If that is nonzero, begmatch is known to be nonzero also.
1747 begmatch + endmatch is how much we save by doing the ins/del.
1751 && (!char_ins_del_ok
1752 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
1756 osp
= nsp
= min (osp
, nsp
);
1759 /* Now go through the line, inserting, writing and
1760 deleting as appropriate. */
1764 cursor_to (vpos
, nsp
);
1765 delete_glyphs (osp
- nsp
);
1769 /* If going to delete chars later in line
1770 and insert earlier in the line,
1771 must delete first to avoid losing data in the insert */
1772 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
1774 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
1775 delete_glyphs (olen
+ nsp
- osp
- nlen
);
1776 olen
= nlen
- (nsp
- osp
);
1778 cursor_to (vpos
, osp
);
1779 insert_glyphs ((char *)0, nsp
- osp
);
1783 tem
= nsp
+ begmatch
+ endmatch
;
1784 if (nlen
!= tem
|| olen
!= tem
)
1786 cursor_to (vpos
, nsp
+ begmatch
);
1787 if (!endmatch
|| nlen
== olen
)
1789 /* If new text being written reaches right margin,
1790 there is no need to do clear-to-eol at the end.
1791 (and it would not be safe, since cursor is not
1792 going to be "at the margin" after the text is done) */
1793 if (nlen
== FRAME_WIDTH (frame
))
1795 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1799 /* the following code loses disastrously if tem == nlen.
1800 Rather than trying to fix that case, I am trying the simpler
1801 solution found above. */
1803 /* If the text reaches to the right margin,
1804 it will lose one way or another (depending on AutoWrap)
1805 to clear to end of line after outputting all the text.
1806 So pause with one character to go and clear the line then. */
1807 if (nlen
== FRAME_WIDTH (frame
) && fast_clear_end_of_line
&& olen
> nlen
)
1809 /* endmatch must be zero, and tem must equal nsp + begmatch */
1810 write_glyphs (nbody
+ tem
, nlen
- tem
- 1);
1811 clear_end_of_line (olen
);
1812 olen
= 0; /* Don't let it be cleared again later */
1813 write_glyphs (nbody
+ nlen
- 1, 1);
1816 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1817 #endif /* OBSOLETE */
1820 else if (nlen
> olen
)
1822 write_glyphs (nbody
+ nsp
+ begmatch
, olen
- tem
);
1823 insert_glyphs (nbody
+ nsp
+ begmatch
+ olen
- tem
, nlen
- olen
);
1826 else if (olen
> nlen
)
1828 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1829 delete_glyphs (olen
- nlen
);
1835 /* If any unerased characters remain after the new line, erase them. */
1838 cursor_to (vpos
, nlen
);
1839 clear_end_of_line (olen
);
1842 /* Exchange contents between current_frame and new_frame. */
1843 temp
= desired_frame
->glyphs
[vpos
];
1844 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1845 current_frame
->glyphs
[vpos
] = temp
;
1847 /* Exchange charstarts between current_frame and new_frame. */
1848 temp1
= desired_frame
->charstarts
[vpos
];
1849 desired_frame
->charstarts
[vpos
] = current_frame
->charstarts
[vpos
];
1850 current_frame
->charstarts
[vpos
] = temp1
;
1853 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
1854 1, 1, "FOpen termscript file: ",
1855 "Start writing all terminal output to FILE as well as the terminal.\n\
1856 FILE = nil means just close any termscript file currently open.")
1860 if (termscript
!= 0) fclose (termscript
);
1865 file
= Fexpand_file_name (file
, Qnil
);
1866 termscript
= fopen (XSTRING (file
)->data
, "w");
1867 if (termscript
== 0)
1868 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
1876 window_change_signal ()
1880 int old_errno
= errno
;
1882 get_frame_size (&width
, &height
);
1884 /* The frame size change obviously applies to a termcap-controlled
1885 frame. Find such a frame in the list, and assume it's the only
1886 one (since the redisplay code always writes to stdout, not a
1887 FILE * specified in the frame structure). Record the new size,
1888 but don't reallocate the data structures now. Let that be done
1889 later outside of the signal handler. */
1892 Lisp_Object tail
, frame
;
1894 FOR_EACH_FRAME (tail
, frame
)
1896 if (FRAME_TERMCAP_P (XFRAME (frame
)))
1898 change_frame_size (XFRAME (frame
), height
, width
, 0, 1);
1904 signal (SIGWINCH
, window_change_signal
);
1907 #endif /* SIGWINCH */
1910 /* Do any change in frame size that was requested by a signal. */
1912 do_pending_window_change ()
1914 /* If window_change_signal should have run before, run it now. */
1915 while (delayed_size_change
)
1917 Lisp_Object tail
, frame
;
1919 delayed_size_change
= 0;
1921 FOR_EACH_FRAME (tail
, frame
)
1923 FRAME_PTR f
= XFRAME (frame
);
1925 int height
= FRAME_NEW_HEIGHT (f
);
1926 int width
= FRAME_NEW_WIDTH (f
);
1928 if (height
!= 0 || width
!= 0)
1929 change_frame_size (f
, height
, width
, 0, 0);
1935 /* Change the frame height and/or width. Values may be given as zero to
1936 indicate no change is to take place.
1938 If DELAY is non-zero, then assume we're being called from a signal
1939 handler, and queue the change for later - perhaps the next
1940 redisplay. Since this tries to resize windows, we can't call it
1941 from a signal handler. */
1943 change_frame_size (frame
, newheight
, newwidth
, pretend
, delay
)
1944 register FRAME_PTR frame
;
1945 int newheight
, newwidth
, pretend
;
1947 /* If we can't deal with the change now, queue it for later. */
1950 FRAME_NEW_HEIGHT (frame
) = newheight
;
1951 FRAME_NEW_WIDTH (frame
) = newwidth
;
1952 delayed_size_change
= 1;
1956 /* This size-change overrides any pending one for this frame. */
1957 FRAME_NEW_HEIGHT (frame
) = 0;
1958 FRAME_NEW_WIDTH (frame
) = 0;
1960 /* If an argument is zero, set it to the current value. */
1961 newheight
|| (newheight
= FRAME_HEIGHT (frame
));
1962 newwidth
|| (newwidth
= FRAME_WIDTH (frame
));
1964 /* Round up to the smallest acceptable size. */
1965 check_frame_size (frame
, &newheight
, &newwidth
);
1967 /* If we're not changing the frame size, quit now. */
1968 if (newheight
== FRAME_HEIGHT (frame
)
1969 && newwidth
== FRAME_WIDTH (frame
))
1972 if (newheight
!= FRAME_HEIGHT (frame
))
1974 if (FRAME_HAS_MINIBUF_P (frame
)
1975 && ! FRAME_MINIBUF_ONLY_P (frame
))
1977 /* Frame has both root and minibuffer. */
1978 set_window_height (FRAME_ROOT_WINDOW (frame
),
1979 newheight
- 1 - FRAME_MENU_BAR_LINES (frame
), 0);
1980 XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (frame
))->top
)
1982 set_window_height (FRAME_MINIBUF_WINDOW (frame
), 1, 0);
1985 /* Frame has just one top-level window. */
1986 set_window_height (FRAME_ROOT_WINDOW (frame
),
1987 newheight
- FRAME_MENU_BAR_LINES (frame
), 0);
1989 if (FRAME_TERMCAP_P (frame
) && !pretend
)
1990 FrameRows
= newheight
;
1993 if (frame
->output_method
== output_termcap
)
1995 frame_height
= newheight
;
1997 FrameRows
= newheight
;
2002 if (newwidth
!= FRAME_WIDTH (frame
))
2004 set_window_width (FRAME_ROOT_WINDOW (frame
), newwidth
, 0);
2005 if (FRAME_HAS_MINIBUF_P (frame
))
2006 set_window_width (FRAME_MINIBUF_WINDOW (frame
), newwidth
, 0);
2008 if (FRAME_TERMCAP_P (frame
) && !pretend
)
2009 FrameCols
= newwidth
;
2011 if (frame
->output_method
== output_termcap
)
2013 frame_width
= newwidth
;
2015 FrameCols
= newwidth
;
2020 FRAME_HEIGHT (frame
) = newheight
;
2021 FRAME_WIDTH (frame
) = newwidth
;
2023 remake_frame_glyphs (frame
);
2024 calculate_costs (frame
);
2027 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
2028 Ssend_string_to_terminal
, 1, 1, 0,
2029 "Send STRING to the terminal without alteration.\n\
2030 Control characters in STRING will have terminal-dependent effects.")
2034 CHECK_STRING (str
, 0);
2035 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, stdout
);
2039 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, termscript
);
2040 fflush (termscript
);
2045 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
2046 "Beep, or flash the screen.\n\
2047 Also, unless an argument is given,\n\
2048 terminate any keyboard macro currently executing.")
2070 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
2071 error ("Keyboard macro terminated by a command ringing the bell");
2077 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
2078 "Pause, without updating display, for SECONDS seconds.\n\
2079 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2080 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2081 additional wait period, in milliseconds; this may be useful if your\n\
2082 Emacs was built without floating point support.\n\
2083 \(Not all operating systems support waiting for a fraction of a second.)")
2084 (seconds
, milliseconds
)
2085 Lisp_Object seconds
, milliseconds
;
2089 if (NILP (milliseconds
))
2090 XSET (milliseconds
, Lisp_Int
, 0);
2092 CHECK_NUMBER (milliseconds
, 1);
2093 usec
= XINT (milliseconds
) * 1000;
2095 #ifdef LISP_FLOAT_TYPE
2097 double duration
= extract_float (seconds
);
2098 sec
= (int) duration
;
2099 usec
+= (duration
- sec
) * 1000000;
2102 CHECK_NUMBER (seconds
, 0);
2103 sec
= XINT (seconds
);
2106 #ifndef EMACS_HAS_USECS
2107 if (sec
== 0 && usec
!= 0)
2108 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
2111 /* Assure that 0 <= usec < 1000000. */
2114 /* We can't rely on the rounding being correct if user is negative. */
2115 if (-1000000 < usec
)
2116 sec
--, usec
+= 1000000;
2118 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
2121 sec
+= usec
/ 1000000, usec
%= 1000000;
2129 XFASTINT (zero
) = 0;
2130 wait_reading_process_input (sec
, usec
, zero
, 0);
2133 /* We should always have wait_reading_process_input; we have a dummy
2134 implementation for systems which don't support subprocesses. */
2136 /* No wait_reading_process_input */
2143 /* The reason this is done this way
2144 (rather than defined (H_S) && defined (H_T))
2145 is because the VMS preprocessor doesn't grok `defined' */
2147 EMACS_GET_TIME (end_time
);
2148 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
2149 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
2153 EMACS_GET_TIME (timeout
);
2154 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
2155 if (EMACS_TIME_NEG_P (timeout
)
2156 || !select (1, 0, 0, 0, &timeout
))
2159 #else /* not HAVE_SELECT */
2161 #endif /* HAVE_SELECT */
2162 #endif /* not VMS */
2165 #endif /* no subprocesses */
2170 /* This is just like wait_reading_process_input, except that
2171 it does the redisplay.
2173 It's also much like Fsit_for, except that it can be used for
2174 waiting for input as well. One differnce is that sit_for
2175 does not call prepare_menu_bars; Fsit_for does call that. */
2178 sit_for (sec
, usec
, reading
, display
)
2179 int sec
, usec
, reading
, display
;
2181 Lisp_Object read_kbd
;
2183 if (detect_input_pending ())
2187 redisplay_preserve_echo_area ();
2189 if (sec
== 0 && usec
== 0)
2196 XSET (read_kbd
, Lisp_Int
, reading
? -1 : 1);
2197 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
2200 /* wait_reading_process_input should always be available now; it is
2201 simulated in a simple way on systems that don't support
2204 /* No wait_reading_process_input available. */
2210 input_wait_timeout (XINT (arg
));
2212 #ifndef HAVE_TIMEVAL
2214 select (1, &waitchannels
, 0, 0, &timeout_sec
);
2215 #else /* HAVE_TIMEVAL */
2216 timeout
.tv_sec
= sec
;
2217 timeout
.tv_usec
= usec
;
2218 select (1, &waitchannels
, 0, 0, &timeout
);
2219 #endif /* HAVE_TIMEVAL */
2220 #endif /* not VMS */
2225 return detect_input_pending () ? Qnil
: Qt
;
2228 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
2229 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
2230 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2231 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2232 additional wait period, in milliseconds; this may be useful if your\n\
2233 Emacs was built without floating point support.\n\
2234 \(Not all operating systems support waiting for a fraction of a second.)\n\
2235 Optional third arg non-nil means don't redisplay, just wait for input.\n\
2236 Redisplay is preempted as always if input arrives, and does not happen\n\
2237 if input is available before it starts.\n\
2238 Value is t if waited the full time with no input arriving.")
2239 (seconds
, milliseconds
, nodisp
)
2240 Lisp_Object seconds
, milliseconds
, nodisp
;
2244 if (NILP (milliseconds
))
2245 XSET (milliseconds
, Lisp_Int
, 0);
2247 CHECK_NUMBER (milliseconds
, 1);
2248 usec
= XINT (milliseconds
) * 1000;
2250 #ifdef LISP_FLOAT_TYPE
2252 double duration
= extract_float (seconds
);
2253 sec
= (int) duration
;
2254 usec
+= (duration
- sec
) * 1000000;
2257 CHECK_NUMBER (seconds
, 0);
2258 sec
= XINT (seconds
);
2261 #ifndef EMACS_HAS_USECS
2262 if (usec
!= 0 && sec
== 0)
2263 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
2267 prepare_menu_bars ();
2268 return sit_for (sec
, usec
, 0, NILP (nodisp
));
2271 char *terminal_type
;
2273 /* Initialization done when Emacs fork is started, before doing stty. */
2274 /* Determine terminal type and set terminal_driver */
2275 /* Then invoke its decoding routine to set up variables
2276 in the terminal package */
2280 #ifdef HAVE_X_WINDOWS
2281 extern int display_arg
;
2286 cursor_in_echo_area
= 0;
2287 terminal_type
= (char *) 0;
2289 /* Now is the time to initialize this; it's used by init_sys_modes
2291 Vwindow_system
= Qnil
;
2293 /* If the user wants to use a window system, we shouldn't bother
2294 initializing the terminal. This is especially important when the
2295 terminal is so dumb that emacs gives up before and doesn't bother
2296 using the window system.
2298 If the DISPLAY environment variable is set, try to use X, and die
2299 with an error message if that doesn't work. */
2301 #ifdef HAVE_X_WINDOWS
2305 display_arg
= (getenv ("DECW$DISPLAY") != 0);
2307 display_arg
= (getenv ("DISPLAY") != 0);
2311 if (!inhibit_window_system
&& display_arg
)
2313 Vwindow_system
= intern ("x");
2315 Vwindow_system_version
= make_number (11);
2317 Vwindow_system_version
= make_number (10);
2321 #endif /* HAVE_X_WINDOWS */
2323 /* If no window system has been specified, try to use the terminal. */
2326 fprintf (stderr
, "emacs: standard input is not a tty\n");
2330 /* Look at the TERM variable */
2331 terminal_type
= (char *) getenv ("TERM");
2335 fprintf (stderr
, "Please specify your terminal type.\n\
2336 For types defined in VMS, use set term /device=TYPE.\n\
2337 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
2338 \(The quotation marks are necessary since terminal types are lower case.)\n");
2340 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
2346 /* VMS DCL tends to upcase things, so downcase term type.
2347 Hardly any uppercase letters in terminal types; should be none. */
2349 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
2352 strcpy (new, terminal_type
);
2354 for (p
= new; *p
; p
++)
2358 terminal_type
= new;
2362 term_init (terminal_type
);
2364 remake_frame_glyphs (selected_frame
);
2365 calculate_costs (selected_frame
);
2367 /* X and Y coordinates of the cursor between updates. */
2368 FRAME_CURSOR_X (selected_frame
) = 0;
2369 FRAME_CURSOR_Y (selected_frame
) = 0;
2374 #endif /* CANNOT_DUMP */
2375 signal (SIGWINCH
, window_change_signal
);
2376 #endif /* SIGWINCH */
2382 defsubr (&Sredraw_frame
);
2384 defsubr (&Sredraw_display
);
2385 defsubr (&Sopen_termscript
);
2387 defsubr (&Ssit_for
);
2388 defsubr (&Ssleep_for
);
2389 defsubr (&Ssend_string_to_terminal
);
2391 DEFVAR_INT ("baud-rate", &baud_rate
,
2392 "The output baud rate of the terminal.\n\
2393 On most systems, changing this value will affect the amount of padding\n\
2394 and the other strategic decisions made during redisplay.");
2395 DEFVAR_BOOL ("inverse-video", &inverse_video
,
2396 "*Non-nil means invert the entire frame display.\n\
2397 This means everything is in inverse video which otherwise would not be.");
2398 DEFVAR_BOOL ("visible-bell", &visible_bell
,
2399 "*Non-nil means try to flash the frame to represent a bell.");
2400 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
2401 "*Non-nil means no need to redraw entire frame after suspending.\n\
2402 A non-nil value is useful if the terminal can automatically preserve\n\
2403 Emacs's frame display when you reenter Emacs.\n\
2404 It is up to you to set this variable if your terminal can do that.");
2405 DEFVAR_LISP ("window-system", &Vwindow_system
,
2406 "A symbol naming the window-system under which Emacs is running\n\
2407 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
2408 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
2409 "The version number of the window system in use.\n\
2410 For X windows, this is 10 or 11.");
2411 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
2412 "Non-nil means put cursor in minibuffer, at end of any message there.");
2413 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
2414 "Table defining how to output a glyph code to the frame.\n\
2415 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
2416 Each element can be:\n\
2417 integer: a glyph code which this glyph is an alias for.\n\
2418 string: output this glyph using that string (not impl. in X windows).\n\
2419 nil: this glyph mod 256 is char code to output,\n\
2420 and this glyph / 256 is face code for X windows (see `face-id').");
2421 Vglyph_table
= Qnil
;
2423 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
2424 "Display table to use for buffers that specify none.\n\
2425 See `buffer-display-table' for more information.");
2426 Vstandard_display_table
= Qnil
;
2428 /* Initialize `window-system', unless init_display already decided it. */
2433 Vwindow_system
= Qnil
;
2434 Vwindow_system_version
= Qnil
;