1 /* Updating of data structures for redisplay.
2 Copyright (C) 1985, 1986, 1987, 1988, 1993 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 #ifndef PENDING_OUTPUT_COUNT
52 /* Get number of chars of output now in the buffer of a stdio stream.
53 This ought to be built in in stdio, but it isn't.
54 Some s- files override this because their stdio internals differ. */
55 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
58 /* Nonzero upon entry to redisplay means do not assume anything about
59 current contents of actual terminal frame; clear and redraw it. */
63 /* Nonzero means last display completed. Zero means it was preempted. */
65 int display_completed
;
67 /* Lisp variable visible-bell; enables use of screen-flash
68 instead of audible bell. */
72 /* Invert the color of the whole frame, at a low level. */
76 /* Line speed of the terminal. */
80 /* nil or a symbol naming the window system under which emacs is
81 running ('x is the only current possibility). */
83 Lisp_Object Vwindow_system
;
85 /* Version number of X windows: 10, 11 or nil. */
86 Lisp_Object Vwindow_system_version
;
88 /* Vector of glyph definitions. Indexed by glyph number,
89 the contents are a string which is how to output the glyph.
91 If Vglyph_table is nil, a glyph is output by using its low 8 bits
92 as a character code. */
94 Lisp_Object Vglyph_table
;
96 /* Display table to use for vectors that don't specify their own. */
98 Lisp_Object Vstandard_display_table
;
100 /* Nonzero means reading single-character input with prompt
101 so put cursor on minibuffer after the prompt.
102 positive means at end of text in echo area;
103 negative means at beginning of line. */
104 int cursor_in_echo_area
;
106 /* The currently selected frame.
107 In a single-frame version, this variable always remains 0. */
109 FRAME_PTR selected_frame
;
111 /* A frame which is not just a minibuffer, or 0 if there are no such
112 frames. This is usually the most recent such frame that was
113 selected. In a single-frame version, this variable always remains 0. */
114 FRAME_PTR last_nonminibuf_frame
;
116 /* In a single-frame version, the information that would otherwise
117 exist inside frame objects lives in the following structure instead.
119 NOTE: the_only_frame is not checked for garbage collection; don't
120 store collectible objects in any of its fields!
122 You're not/The only frame in town/... */
125 struct frame the_only_frame
;
128 /* This is a vector, made larger whenever it isn't large enough,
129 which is used inside `update_frame' to hold the old contents
130 of the FRAME_PHYS_LINES of the frame being updated. */
131 struct frame_glyphs
**ophys_lines
;
132 /* Length of vector currently allocated. */
133 int ophys_lines_length
;
135 FILE *termscript
; /* Stdio stream being used for copy of all output. */
137 struct cm Wcm
; /* Structure for info on cursor positioning */
139 extern short ospeed
; /* Output speed (from sg_ospeed) */
141 int delayed_size_change
; /* 1 means SIGWINCH happened when not safe. */
145 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, 0,
146 "Clear frame FRAME and output again what is supposed to appear on it.")
152 CHECK_LIVE_FRAME (frame
, 0);
155 /* set_terminal_modes (); */
157 clear_frame_records (f
);
160 windows_or_buffers_changed
++;
161 /* Mark all windows as INaccurate,
162 so that every window will have its redisplay done. */
163 mark_window_display_accurate (FRAME_ROOT_WINDOW (f
), 0);
172 XSET (frame
, Lisp_Frame
, f
);
173 Fredraw_frame (frame
);
178 DEFUN ("redraw-frame", Fredraw_frame
, Sredraw_frame
, 1, 1, "",
179 "Clear frame FRAME and output again what is supposed to appear on it.")
184 set_terminal_modes ();
188 clear_frame_records (0);
189 windows_or_buffers_changed
++;
190 /* Mark all windows as INaccurate,
191 so that every window will have its redisplay done. */
192 mark_window_display_accurate (FRAME_ROOT_WINDOW (0), 0);
198 DEFUN ("redraw-display", Fredraw_display
, Sredraw_display
, 0, 0, "",
199 "Clear and redisplay all visible frames.")
202 Lisp_Object tail
, frame
;
204 FOR_EACH_FRAME (tail
, frame
)
205 if (FRAME_VISIBLE_P (XFRAME (frame
)))
206 Fredraw_frame (frame
);
211 /* This is used when frame_garbaged is set.
212 Redraw the individual frames marked as garbaged. */
215 redraw_garbaged_frames ()
217 Lisp_Object tail
, frame
;
219 FOR_EACH_FRAME (tail
, frame
)
220 if (FRAME_VISIBLE_P (XFRAME (frame
))
221 && FRAME_GARBAGED_P (XFRAME (frame
)))
222 Fredraw_frame (frame
);
226 static struct frame_glyphs
*
227 make_frame_glyphs (frame
, empty
)
228 register FRAME_PTR frame
;
232 register width
= FRAME_WIDTH (frame
);
233 register height
= FRAME_HEIGHT (frame
);
234 register struct frame_glyphs
*new =
235 (struct frame_glyphs
*) xmalloc (sizeof (struct frame_glyphs
));
237 SET_GLYPHS_FRAME (new, frame
);
238 new->height
= height
;
240 new->used
= (int *) xmalloc (height
* sizeof (int));
241 new->glyphs
= (GLYPH
**) xmalloc (height
* sizeof (GLYPH
*));
242 new->highlight
= (char *) xmalloc (height
* sizeof (char));
243 new->enable
= (char *) xmalloc (height
* sizeof (char));
244 bzero (new->enable
, height
* sizeof (char));
245 new->bufp
= (int *) xmalloc (height
* sizeof (int));
247 #ifdef HAVE_X_WINDOWS
248 if (FRAME_X_P (frame
))
250 new->top_left_x
= (short *) xmalloc (height
* sizeof (short));
251 new->top_left_y
= (short *) xmalloc (height
* sizeof (short));
252 new->pix_width
= (short *) xmalloc (height
* sizeof (short));
253 new->pix_height
= (short *) xmalloc (height
* sizeof (short));
254 new->max_ascent
= (short *) xmalloc (height
* sizeof (short));
260 /* Make the buffer used by decode_mode_spec. This buffer is also
261 used as temporary storage when updating the frame. See scroll.c. */
262 unsigned int total_glyphs
= (width
+ 2) * sizeof (GLYPH
);
264 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
265 bzero (new->total_contents
, total_glyphs
);
269 unsigned int total_glyphs
= height
* (width
+ 2) * sizeof (GLYPH
);
271 new->total_contents
= (GLYPH
*) xmalloc (total_glyphs
);
272 bzero (new->total_contents
, total_glyphs
);
273 for (i
= 0; i
< height
; i
++)
274 new->glyphs
[i
] = new->total_contents
+ i
* (width
+ 2) + 1;
281 free_frame_glyphs (frame
, glyphs
)
283 struct frame_glyphs
*glyphs
;
285 if (glyphs
->total_contents
)
286 xfree (glyphs
->total_contents
);
288 xfree (glyphs
->used
);
289 xfree (glyphs
->glyphs
);
290 xfree (glyphs
->highlight
);
291 xfree (glyphs
->enable
);
292 xfree (glyphs
->bufp
);
294 #ifdef HAVE_X_WINDOWS
295 if (FRAME_X_P (frame
))
297 xfree (glyphs
->top_left_x
);
298 xfree (glyphs
->top_left_y
);
299 xfree (glyphs
->pix_width
);
300 xfree (glyphs
->pix_height
);
301 xfree (glyphs
->max_ascent
);
309 remake_frame_glyphs (frame
)
312 if (FRAME_CURRENT_GLYPHS (frame
))
313 free_frame_glyphs (frame
, FRAME_CURRENT_GLYPHS (frame
));
314 if (FRAME_DESIRED_GLYPHS (frame
))
315 free_frame_glyphs (frame
, FRAME_DESIRED_GLYPHS (frame
));
316 if (FRAME_TEMP_GLYPHS (frame
))
317 free_frame_glyphs (frame
, FRAME_TEMP_GLYPHS (frame
));
319 if (FRAME_MESSAGE_BUF (frame
))
321 /* Reallocate the frame's message buffer; remember that
322 echo_area_glyphs may be pointing here. */
323 char *old_message_buf
= FRAME_MESSAGE_BUF (frame
);
325 FRAME_MESSAGE_BUF (frame
)
326 = (char *) xrealloc (FRAME_MESSAGE_BUF (frame
),
327 FRAME_WIDTH (frame
) + 1);
329 if (echo_area_glyphs
== old_message_buf
)
330 echo_area_glyphs
= FRAME_MESSAGE_BUF (frame
);
331 if (previous_echo_glyphs
== old_message_buf
)
332 previous_echo_glyphs
= FRAME_MESSAGE_BUF (frame
);
335 FRAME_MESSAGE_BUF (frame
)
336 = (char *) xmalloc (FRAME_WIDTH (frame
) + 1);
338 FRAME_CURRENT_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
339 FRAME_DESIRED_GLYPHS (frame
) = make_frame_glyphs (frame
, 0);
340 FRAME_TEMP_GLYPHS (frame
) = make_frame_glyphs (frame
, 1);
341 SET_FRAME_GARBAGED (frame
);
344 /* Return the hash code of contents of line VPOS in frame-matrix M. */
347 line_hash_code (m
, vpos
)
348 register struct frame_glyphs
*m
;
351 register GLYPH
*body
, *end
;
354 if (!m
->enable
[vpos
])
357 /* Give all highlighted lines the same hash code
358 so as to encourage scrolling to leave them in place. */
359 if (m
->highlight
[vpos
])
362 body
= m
->glyphs
[vpos
];
364 if (must_write_spaces
)
371 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
- SPACEGLYPH
;
380 h
= (((h
<< 4) + (h
>> 24)) & 0x0fffffff) + g
;
388 /* Return number of characters in line in M at vpos VPOS,
389 except don't count leading and trailing spaces
390 unless the terminal requires those to be explicitly output. */
393 line_draw_cost (m
, vpos
)
394 struct frame_glyphs
*m
;
397 register GLYPH
*beg
= m
->glyphs
[vpos
];
398 register GLYPH
*end
= m
->glyphs
[vpos
] + m
->used
[vpos
];
400 register int tlen
= GLYPH_TABLE_LENGTH
;
401 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
403 /* Ignore trailing and leading spaces if we can. */
404 if (!must_write_spaces
)
406 while ((end
!= beg
) && (*end
== SPACEGLYPH
))
409 return (0); /* All blank line. */
411 while (*beg
== SPACEGLYPH
)
415 /* If we don't have a glyph-table, each glyph is one character,
416 so return the number of glyphs. */
420 /* Otherwise, scan the glyphs and accumulate their total size in I. */
422 while ((beg
<= end
) && *beg
)
424 register GLYPH g
= *beg
++;
426 if (GLYPH_SIMPLE_P (tbase
, tlen
, g
))
429 i
+= GLYPH_LENGTH (tbase
, g
);
434 /* The functions on this page are the interface from xdisp.c to redisplay.
436 The only other interface into redisplay is through setting
437 FRAME_CURSOR_X (frame) and FRAME_CURSOR_Y (frame)
438 and SET_FRAME_GARBAGED (frame). */
440 /* cancel_line eliminates any request to display a line at position `vpos' */
442 cancel_line (vpos
, frame
)
444 register FRAME_PTR frame
;
446 FRAME_DESIRED_GLYPHS (frame
)->enable
[vpos
] = 0;
449 clear_frame_records (frame
)
450 register FRAME_PTR frame
;
452 bzero (FRAME_CURRENT_GLYPHS (frame
)->enable
, FRAME_HEIGHT (frame
));
455 /* Prepare to display on line VPOS starting at HPOS within it. */
458 get_display_line (frame
, vpos
, hpos
)
459 register FRAME_PTR frame
;
463 register struct frame_glyphs
*glyphs
;
464 register struct frame_glyphs
*desired_glyphs
= FRAME_DESIRED_GLYPHS (frame
);
470 if ((desired_glyphs
->enable
[vpos
]) && desired_glyphs
->used
[vpos
] > hpos
)
473 if (! desired_glyphs
->enable
[vpos
])
475 desired_glyphs
->used
[vpos
] = 0;
476 desired_glyphs
->highlight
[vpos
] = 0;
477 desired_glyphs
->enable
[vpos
] = 1;
480 if (hpos
> desired_glyphs
->used
[vpos
])
482 GLYPH
*g
= desired_glyphs
->glyphs
[vpos
] + desired_glyphs
->used
[vpos
];
483 GLYPH
*end
= desired_glyphs
->glyphs
[vpos
] + hpos
;
485 desired_glyphs
->used
[vpos
] = hpos
;
491 /* Like bcopy except never gets confused by overlap. */
494 safe_bcopy (from
, to
, size
)
498 if (size
<= 0 || from
== to
)
501 /* If the source and destination don't overlap, then bcopy can
502 handle it. If they do overlap, but the destination is lower in
503 memory than the source, we'll assume bcopy can handle that. */
504 if (to
< from
|| from
+ size
<= to
)
505 bcopy (from
, to
, size
);
507 /* Otherwise, we'll copy from the end. */
510 register char *endf
= from
+ size
;
511 register char *endt
= to
+ size
;
513 /* If TO - FROM is large, then we should break the copy into
514 nonoverlapping chunks of TO - FROM bytes each. However, if
515 TO - FROM is small, then the bcopy function call overhead
516 makes this not worth it. The crossover point could be about
517 anywhere. Since I don't think the obvious copy loop is too
518 bad, I'm trying to err in its favor. */
523 while (endf
!= from
);
535 bcopy (endf
, endt
, to
- from
);
538 /* If SIZE wasn't a multiple of TO - FROM, there will be a
539 little left over. The amount left over is
540 (endt + (to - from)) - to, which is endt - from. */
541 bcopy (from
, to
, endt
- from
);
546 /* Rotate a vector of SIZE bytes right, by DISTANCE bytes.
547 DISTANCE may be negative. */
550 rotate_vector (vector
, size
, distance
)
555 char *temp
= (char *) alloca (size
);
560 bcopy (vector
, temp
+ distance
, size
- distance
);
561 bcopy (vector
+ size
- distance
, temp
, distance
);
562 bcopy (temp
, vector
, size
);
565 /* Scroll lines from vpos FROM up to but not including vpos END
566 down by AMOUNT lines (AMOUNT may be negative).
567 Returns nonzero if done, zero if terminal cannot scroll them. */
570 scroll_frame_lines (frame
, from
, end
, amount
)
571 register FRAME_PTR frame
;
572 int from
, end
, amount
;
575 register struct frame_glyphs
*current_frame
576 = FRAME_CURRENT_GLYPHS (frame
);
578 if (!line_ins_del_ok
)
586 update_begin (frame
);
587 set_terminal_window (end
+ amount
);
588 if (!scroll_region_ok
)
589 ins_del_lines (end
, -amount
);
590 ins_del_lines (from
, amount
);
591 set_terminal_window (0);
593 rotate_vector (current_frame
->glyphs
+ from
,
594 sizeof (GLYPH
*) * (end
+ amount
- from
),
595 amount
* sizeof (GLYPH
*));
597 safe_bcopy (current_frame
->used
+ from
,
598 current_frame
->used
+ from
+ amount
,
599 (end
- from
) * sizeof current_frame
->used
[0]);
601 safe_bcopy (current_frame
->highlight
+ from
,
602 current_frame
->highlight
+ from
+ amount
,
603 (end
- from
) * sizeof current_frame
->highlight
[0]);
605 safe_bcopy (current_frame
->enable
+ from
,
606 current_frame
->enable
+ from
+ amount
,
607 (end
- from
) * sizeof current_frame
->enable
[0]);
609 /* Mark the lines made empty by scrolling as enabled, empty and
611 bzero (current_frame
->used
+ from
,
612 amount
* sizeof current_frame
->used
[0]);
613 bzero (current_frame
->highlight
+ from
,
614 amount
* sizeof current_frame
->highlight
[0]);
615 for (i
= from
; i
< from
+ amount
; i
++)
617 current_frame
->glyphs
[i
][0] = '\0';
618 current_frame
->enable
[i
] = 1;
621 safe_bcopy (current_frame
->bufp
+ from
,
622 current_frame
->bufp
+ from
+ amount
,
623 (end
- from
) * sizeof current_frame
->bufp
[0]);
625 #ifdef HAVE_X_WINDOWS
626 if (FRAME_X_P (frame
))
628 safe_bcopy (current_frame
->top_left_x
+ from
,
629 current_frame
->top_left_x
+ from
+ amount
,
630 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
632 safe_bcopy (current_frame
->top_left_y
+ from
,
633 current_frame
->top_left_y
+ from
+ amount
,
634 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
636 safe_bcopy (current_frame
->pix_width
+ from
,
637 current_frame
->pix_width
+ from
+ amount
,
638 (end
- from
) * sizeof current_frame
->pix_width
[0]);
640 safe_bcopy (current_frame
->pix_height
+ from
,
641 current_frame
->pix_height
+ from
+ amount
,
642 (end
- from
) * sizeof current_frame
->pix_height
[0]);
644 safe_bcopy (current_frame
->max_ascent
+ from
,
645 current_frame
->max_ascent
+ from
+ amount
,
646 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
648 #endif /* HAVE_X_WINDOWS */
654 update_begin (frame
);
655 set_terminal_window (end
);
656 ins_del_lines (from
+ amount
, amount
);
657 if (!scroll_region_ok
)
658 ins_del_lines (end
+ amount
, -amount
);
659 set_terminal_window (0);
661 rotate_vector (current_frame
->glyphs
+ from
+ amount
,
662 sizeof (GLYPH
*) * (end
- from
- amount
),
663 amount
* sizeof (GLYPH
*));
665 safe_bcopy (current_frame
->used
+ from
,
666 current_frame
->used
+ from
+ amount
,
667 (end
- from
) * sizeof current_frame
->used
[0]);
669 safe_bcopy (current_frame
->highlight
+ from
,
670 current_frame
->highlight
+ from
+ amount
,
671 (end
- from
) * sizeof current_frame
->highlight
[0]);
673 safe_bcopy (current_frame
->enable
+ from
,
674 current_frame
->enable
+ from
+ amount
,
675 (end
- from
) * sizeof current_frame
->enable
[0]);
677 /* Mark the lines made empty by scrolling as enabled, empty and
679 bzero (current_frame
->used
+ end
+ amount
,
680 - amount
* sizeof current_frame
->used
[0]);
681 bzero (current_frame
->highlight
+ end
+ amount
,
682 - amount
* sizeof current_frame
->highlight
[0]);
683 for (i
= end
+ amount
; i
< end
; i
++)
685 current_frame
->glyphs
[i
][0] = '\0';
686 current_frame
->enable
[i
] = 1;
689 safe_bcopy (current_frame
->bufp
+ from
,
690 current_frame
->bufp
+ from
+ amount
,
691 (end
- from
) * sizeof current_frame
->bufp
[0]);
693 #ifdef HAVE_X_WINDOWS
694 if (FRAME_X_P (frame
))
696 safe_bcopy (current_frame
->top_left_x
+ from
,
697 current_frame
->top_left_x
+ from
+ amount
,
698 (end
- from
) * sizeof current_frame
->top_left_x
[0]);
700 safe_bcopy (current_frame
->top_left_y
+ from
,
701 current_frame
->top_left_y
+ from
+ amount
,
702 (end
- from
) * sizeof current_frame
->top_left_y
[0]);
704 safe_bcopy (current_frame
->pix_width
+ from
,
705 current_frame
->pix_width
+ from
+ amount
,
706 (end
- from
) * sizeof current_frame
->pix_width
[0]);
708 safe_bcopy (current_frame
->pix_height
+ from
,
709 current_frame
->pix_height
+ from
+ amount
,
710 (end
- from
) * sizeof current_frame
->pix_height
[0]);
712 safe_bcopy (current_frame
->max_ascent
+ from
,
713 current_frame
->max_ascent
+ from
+ amount
,
714 (end
- from
) * sizeof current_frame
->max_ascent
[0]);
716 #endif /* HAVE_X_WINDOWS */
723 /* After updating a window W that isn't the full frame wide,
724 copy all the columns that W does not occupy
725 into the FRAME_DESIRED_GLYPHS (frame) from the FRAME_PHYS_GLYPHS (frame)
726 so that update_frame will not change those columns. */
728 preserve_other_columns (w
)
732 register struct frame_glyphs
*current_frame
, *desired_frame
;
733 register FRAME_PTR frame
= XFRAME (w
->frame
);
734 int start
= XFASTINT (w
->left
);
735 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
736 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
738 current_frame
= FRAME_CURRENT_GLYPHS (frame
);
739 desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
741 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
743 if (current_frame
->enable
[vpos
] && desired_frame
->enable
[vpos
])
749 bcopy (current_frame
->glyphs
[vpos
],
750 desired_frame
->glyphs
[vpos
],
751 start
* sizeof (current_frame
->glyphs
[vpos
]));
752 len
= min (start
, current_frame
->used
[vpos
]);
753 if (desired_frame
->used
[vpos
] < len
)
754 desired_frame
->used
[vpos
] = len
;
756 if (current_frame
->used
[vpos
] > end
757 && desired_frame
->used
[vpos
] < current_frame
->used
[vpos
])
759 while (desired_frame
->used
[vpos
] < end
)
760 desired_frame
->glyphs
[vpos
][desired_frame
->used
[vpos
]++]
762 bcopy (current_frame
->glyphs
[vpos
] + end
,
763 desired_frame
->glyphs
[vpos
] + end
,
764 ((current_frame
->used
[vpos
] - end
)
765 * sizeof (current_frame
->glyphs
[vpos
])));
766 desired_frame
->used
[vpos
] = current_frame
->used
[vpos
];
774 /* If window w does not need to be updated and isn't the full frame wide,
775 copy all the columns that w does occupy
776 into the FRAME_DESIRED_LINES (frame) from the FRAME_PHYS_LINES (frame)
777 so that update_frame will not change those columns.
779 Have not been able to figure out how to use this correctly. */
781 preserve_my_columns (w
)
784 register int vpos
, fin
;
785 register struct frame_glyphs
*l1
, *l2
;
786 register FRAME_PTR frame
= XFRAME (w
->frame
);
787 int start
= XFASTINT (w
->left
);
788 int end
= XFASTINT (w
->left
) + XFASTINT (w
->width
);
789 int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
791 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
793 if ((l1
= FRAME_DESIRED_GLYPHS (frame
)->glyphs
[vpos
+ 1])
794 && (l2
= FRAME_PHYS_GLYPHS (frame
)->glyphs
[vpos
+ 1]))
796 if (l2
->length
> start
&& l1
->length
< l2
->length
)
799 if (fin
> end
) fin
= end
;
800 while (l1
->length
< start
)
801 l1
->body
[l1
->length
++] = ' ';
802 bcopy (l2
->body
+ start
, l1
->body
+ start
, fin
- start
);
811 /* On discovering that the redisplay for a window was no good,
812 cancel the columns of that window, so that when the window is
813 displayed over again get_display_line will not complain. */
815 cancel_my_columns (w
)
819 register struct frame_glyphs
*desired_glyphs
=
820 FRAME_DESIRED_GLYPHS (XFRAME (w
->frame
));
821 register int start
= XFASTINT (w
->left
);
822 register int bot
= XFASTINT (w
->top
) + XFASTINT (w
->height
);
824 for (vpos
= XFASTINT (w
->top
); vpos
< bot
; vpos
++)
825 if (desired_glyphs
->enable
[vpos
]
826 && desired_glyphs
->used
[vpos
] >= start
)
827 desired_glyphs
->used
[vpos
] = start
;
830 /* These functions try to perform directly and immediately on the frame
831 the necessary output for one change in the buffer.
832 They may return 0 meaning nothing was done if anything is difficult,
833 or 1 meaning the output was performed properly.
834 They assume that the frame was up to date before the buffer
835 change being displayed. They make various other assumptions too;
836 see command_loop_1 where these are called. */
839 direct_output_for_insert (g
)
842 register FRAME_PTR frame
= selected_frame
;
843 register struct frame_glyphs
*current_frame
844 = FRAME_CURRENT_GLYPHS (frame
);
846 #ifndef COMPILER_REGISTER_BUG
848 #endif /* COMPILER_REGISTER_BUG */
849 struct window
*w
= XWINDOW (selected_window
);
850 #ifndef COMPILER_REGISTER_BUG
852 #endif /* COMPILER_REGISTER_BUG */
853 int hpos
= FRAME_CURSOR_X (frame
);
854 #ifndef COMPILER_REGISTER_BUG
856 #endif /* COMPILER_REGISTER_BUG */
857 int vpos
= FRAME_CURSOR_Y (frame
);
859 /* Give up if about to continue line. */
860 if (hpos
>= XFASTINT (w
->left
) + window_internal_width (w
) - 1
862 /* Avoid losing if cursor is in invisible text off left margin */
863 || (XINT (w
->hscroll
) && hpos
== XFASTINT (w
->left
))
865 /* Give up if cursor outside window (in minibuf, probably) */
866 || cursor_in_echo_area
867 || FRAME_CURSOR_Y (frame
) < XFASTINT (w
->top
)
868 || FRAME_CURSOR_Y (frame
) >= XFASTINT (w
->top
) + XFASTINT (w
->height
)
870 /* Give up if cursor not really at FRAME_CURSOR_X, FRAME_CURSOR_Y */
871 || !display_completed
873 /* Give up if buffer appears in two places. */
876 #ifdef USE_TEXT_PROPERTIES
877 /* Intervals have already been adjusted, point is after the
878 character that was just inserted. */
879 /* Give up if character has is invisible. */
880 /* Give up if character has a face property.
881 At the moment we only lose at end of line or end of buffer
882 and only with faces that have some background */
883 /* Instead of wasting time, give up if character has any text properties */
884 || ! NILP (Ftext_properties_at (XFASTINT (point
- 1), Qnil
))
887 /* Give up if w is minibuffer and a message is being displayed there */
888 || (MINI_WINDOW_P (w
) && echo_area_glyphs
))
892 #ifdef HAVE_X_WINDOWS
894 int face
= compute_char_face (frame
, w
, point
- 1, -1, -1, &dummy
);
899 current_frame
->glyphs
[vpos
][hpos
] = MAKE_GLYPH (g
, face
);
901 unchanged_modified
= MODIFF
;
902 beg_unchanged
= GPT
- BEG
;
903 XFASTINT (w
->last_point
) = point
;
904 XFASTINT (w
->last_point_x
) = hpos
;
905 XFASTINT (w
->last_modified
) = MODIFF
;
907 reassert_line_highlight (0, vpos
);
908 write_glyphs (¤t_frame
->glyphs
[vpos
][hpos
], 1);
910 ++FRAME_CURSOR_X (frame
);
911 if (hpos
== current_frame
->used
[vpos
])
913 current_frame
->used
[vpos
] = hpos
+ 1;
914 current_frame
->glyphs
[vpos
][hpos
+ 1] = 0;
921 direct_output_forward_char (n
)
924 register FRAME_PTR frame
= selected_frame
;
925 register struct window
*w
= XWINDOW (selected_window
);
928 /* Avoid losing if cursor is in invisible text off left margin
929 or about to go off either side of window. */
930 if ((FRAME_CURSOR_X (frame
) == XFASTINT (w
->left
)
931 && (XINT (w
->hscroll
) || n
< 0))
933 && (FRAME_CURSOR_X (frame
) + 1 >= window_internal_width (w
) - 1))
934 || cursor_in_echo_area
)
937 /* Can't use direct output if highlighting a region. */
938 if (!NILP (Vtransient_mark_mode
) && !NILP (current_buffer
->mark_active
))
941 #ifdef USE_TEXT_PROPERTIES
942 /* Don't use direct output next to an invisible character
943 since we might need to do something special. */
945 XFASTINT (position
) = point
+ n
;
946 if (! NILP (Fget_text_property (position
,
948 Fcurrent_buffer ())))
951 XFASTINT (position
) = point
+ n
- 1;
952 if (! NILP (Fget_text_property (position
,
954 Fcurrent_buffer ())))
958 FRAME_CURSOR_X (frame
) += n
;
959 XFASTINT (w
->last_point_x
) = FRAME_CURSOR_X (frame
);
960 XFASTINT (w
->last_point
) = point
;
961 cursor_to (FRAME_CURSOR_Y (frame
), FRAME_CURSOR_X (frame
));
967 static void update_line ();
969 /* Update frame F based on the data in FRAME_DESIRED_GLYPHS.
970 Value is nonzero if redisplay stopped due to pending input.
971 FORCE nonzero means do not stop for pending input. */
974 update_frame (f
, force
, inhibit_hairy_id
)
977 int inhibit_hairy_id
;
979 register struct frame_glyphs
*current_frame
= FRAME_CURRENT_GLYPHS (f
);
980 register struct frame_glyphs
*desired_frame
= FRAME_DESIRED_GLYPHS (f
);
983 int preempt_count
= baud_rate
/ 2400 + 1;
984 extern input_pending
;
985 #ifdef HAVE_X_WINDOWS
986 register int downto
, leftmost
;
989 if (preempt_count
<= 0)
992 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
994 detect_input_pending ();
995 if (input_pending
&& !force
)
1003 if (!line_ins_del_ok
)
1004 inhibit_hairy_id
= 1;
1006 /* See if any of the desired lines are enabled; don't compute for
1007 i/d line if just want cursor motion. */
1008 for (i
= 0; i
< FRAME_HEIGHT (f
); i
++)
1009 if (desired_frame
->enable
[i
])
1012 /* Try doing i/d line, if not yet inhibited. */
1013 if (!inhibit_hairy_id
&& i
< FRAME_HEIGHT (f
))
1014 force
|= scrolling (f
);
1016 /* Update the individual lines as needed. Do bottom line first. */
1018 if (desired_frame
->enable
[FRAME_HEIGHT (f
) - 1])
1019 update_line (f
, FRAME_HEIGHT (f
) - 1);
1021 #ifdef HAVE_X_WINDOWS
1024 leftmost
= downto
= f
->display
.x
->internal_border_width
;
1025 if (desired_frame
->enable
[0])
1027 current_frame
->top_left_x
[FRAME_HEIGHT (f
) - 1] = leftmost
;
1028 current_frame
->top_left_y
[FRAME_HEIGHT (f
) - 1]
1029 = PIXEL_HEIGHT (f
) - f
->display
.x
->internal_border_width
1030 - current_frame
->pix_height
[FRAME_HEIGHT (f
) - 1];
1031 current_frame
->top_left_x
[0] = leftmost
;
1032 current_frame
->top_left_y
[0] = downto
;
1035 #endif /* HAVE_X_WINDOWS */
1037 /* Now update the rest of the lines. */
1038 for (i
= 0; i
< FRAME_HEIGHT (f
) - 1 && (force
|| !input_pending
); i
++)
1040 if (desired_frame
->enable
[i
])
1042 if (FRAME_TERMCAP_P (f
))
1044 /* Flush out every so many lines.
1045 Also flush out if likely to have more than 1k buffered
1046 otherwise. I'm told that some telnet connections get
1047 really screwed by more than 1k output at once. */
1048 int outq
= PENDING_OUTPUT_COUNT (stdout
);
1050 || (outq
> 20 && ((i
- 1) % preempt_count
== 0)))
1053 if (preempt_count
== 1)
1055 #ifdef EMACS_OUTQSIZE
1056 if (EMACS_OUTQSIZE (0, &outq
) < 0)
1057 /* Probably not a tty. Ignore the error and reset
1058 * the outq count. */
1059 outq
= PENDING_OUTPUT_COUNT (stdout
);
1063 sleep (outq
/ baud_rate
);
1066 if ((i
- 1) % preempt_count
== 0)
1067 detect_input_pending ();
1071 #ifdef HAVE_X_WINDOWS
1074 current_frame
->top_left_y
[i
] = downto
;
1075 current_frame
->top_left_x
[i
] = leftmost
;
1077 #endif /* HAVE_X_WINDOWS */
1080 #ifdef HAVE_X_WINDOWS
1082 downto
+= current_frame
->pix_height
[i
];
1085 pause
= (i
< FRAME_HEIGHT (f
) - 1) ? i
: 0;
1087 /* Now just clean up termcap drivers and set cursor, etc. */
1090 if (cursor_in_echo_area
1091 && FRAME_HAS_MINIBUF_P (f
))
1093 int top
= XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
);
1096 if (cursor_in_echo_area
< 0)
1103 /* If the minibuffer is several lines high, find the last
1104 line that has any text on it. */
1105 row
= FRAME_HEIGHT (f
);
1109 if (current_frame
->enable
[row
])
1110 col
= current_frame
->used
[row
];
1114 while (row
> top
&& col
== 0);
1116 if (col
>= FRAME_WIDTH (f
))
1119 if (row
< FRAME_HEIGHT (f
) - 1)
1124 cursor_to (row
, col
);
1127 cursor_to (FRAME_CURSOR_Y (f
), max (min (FRAME_CURSOR_X (f
),
1128 FRAME_WIDTH (f
) - 1), 0));
1134 fflush (termscript
);
1137 /* Here if output is preempted because input is detected. */
1140 if (FRAME_HEIGHT (f
) == 0) abort (); /* Some bug zeros some core */
1141 display_completed
= !pause
;
1143 bzero (desired_frame
->enable
, FRAME_HEIGHT (f
));
1147 /* Called when about to quit, to check for doing so
1148 at an improper time. */
1153 if (FRAME_DESIRED_GLYPHS (selected_frame
) == 0)
1155 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[0])
1157 if (FRAME_DESIRED_GLYPHS (selected_frame
)->enable
[FRAME_HEIGHT (selected_frame
) - 1])
1161 /* Decide what insert/delete line to do, and do it */
1163 extern void scrolling_1 ();
1168 int unchanged_at_top
, unchanged_at_bottom
;
1171 int *old_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1172 int *new_hash
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1173 int *draw_cost
= (int *) alloca (FRAME_HEIGHT (frame
) * sizeof (int));
1175 int free_at_end_vpos
= FRAME_HEIGHT (frame
);
1176 register struct frame_glyphs
*current_frame
= FRAME_CURRENT_GLYPHS (frame
);
1177 register struct frame_glyphs
*desired_frame
= FRAME_DESIRED_GLYPHS (frame
);
1179 /* Compute hash codes of all the lines.
1180 Also calculate number of changed lines,
1181 number of unchanged lines at the beginning,
1182 and number of unchanged lines at the end. */
1185 unchanged_at_top
= 0;
1186 unchanged_at_bottom
= FRAME_HEIGHT (frame
);
1187 for (i
= 0; i
< FRAME_HEIGHT (frame
); i
++)
1189 /* Give up on this scrolling if some old lines are not enabled. */
1190 if (!current_frame
->enable
[i
])
1192 old_hash
[i
] = line_hash_code (current_frame
, i
);
1193 if (! desired_frame
->enable
[i
])
1194 new_hash
[i
] = old_hash
[i
];
1196 new_hash
[i
] = line_hash_code (desired_frame
, i
);
1198 if (old_hash
[i
] != new_hash
[i
])
1201 unchanged_at_bottom
= FRAME_HEIGHT (frame
) - i
- 1;
1203 else if (i
== unchanged_at_top
)
1205 draw_cost
[i
] = line_draw_cost (desired_frame
, i
);
1208 /* If changed lines are few, don't allow preemption, don't scroll. */
1209 if (changed_lines
< baud_rate
/ 2400
1210 || unchanged_at_bottom
== FRAME_HEIGHT (frame
))
1213 window_size
= (FRAME_HEIGHT (frame
) - unchanged_at_top
1214 - unchanged_at_bottom
);
1216 if (scroll_region_ok
)
1217 free_at_end_vpos
-= unchanged_at_bottom
;
1218 else if (memory_below_frame
)
1219 free_at_end_vpos
= -1;
1221 /* If large window, fast terminal and few lines in common between
1222 current frame and desired frame, don't bother with i/d calc. */
1223 if (window_size
>= 18 && baud_rate
> 2400
1225 10 * scrolling_max_lines_saved (unchanged_at_top
,
1226 FRAME_HEIGHT (frame
) - unchanged_at_bottom
,
1227 old_hash
, new_hash
, draw_cost
)))
1230 scrolling_1 (frame
, window_size
, unchanged_at_top
, unchanged_at_bottom
,
1231 draw_cost
+ unchanged_at_top
- 1,
1232 old_hash
+ unchanged_at_top
- 1,
1233 new_hash
+ unchanged_at_top
- 1,
1234 free_at_end_vpos
- unchanged_at_top
);
1239 /* Return the offset in its buffer of the character at location col, line
1240 in the given window. */
1242 buffer_posn_from_coords (window
, col
, line
)
1243 struct window
*window
;
1246 int window_left
= XFASTINT (window
->left
);
1248 /* The actual width of the window is window->width less one for the
1249 DISP_CONTINUE_GLYPH, and less one if it's not the rightmost
1251 int window_width
= window_internal_width (window
) - 1;
1253 int startp
= marker_position (window
->start
);
1255 /* Since compute_motion will only operate on the current buffer,
1256 we need to save the old one and restore it when we're done. */
1257 struct buffer
*old_current_buffer
= current_buffer
;
1258 struct position
*posn
;
1260 current_buffer
= XBUFFER (window
->buffer
);
1262 /* It would be nice if we could use FRAME_CURRENT_GLYPHS (XFRAME
1263 (window->frame))->bufp to avoid scanning from the very top of
1264 the window, but it isn't maintained correctly, and I'm not even
1265 sure I will keep it. */
1266 posn
= compute_motion (startp
, 0,
1267 (window
== XWINDOW (minibuf_window
) && startp
== 1
1268 ? minibuf_prompt_width
: 0),
1270 window_width
, XINT (window
->hscroll
), 0);
1272 current_buffer
= old_current_buffer
;
1274 /* compute_motion considers frame points past the end of a line
1275 to be *after* the newline, i.e. at the start of the next line.
1276 This is reasonable, but not really what we want. So if the
1277 result is on a line below LINE, back it up one character. */
1278 if (posn
->vpos
> line
)
1279 return posn
->bufpos
- 1;
1281 return posn
->bufpos
;
1288 register GLYPH
*p
= r
;
1289 while (*p
++ == SPACEGLYPH
);
1294 count_match (str1
, str2
)
1297 register GLYPH
*p1
= str1
;
1298 register GLYPH
*p2
= str2
;
1299 while (*p1
++ == *p2
++);
1300 return p1
- str1
- 1;
1303 /* Char insertion/deletion cost vector, from term.c */
1304 extern int *char_ins_del_vector
;
1306 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WIDTH((f))])
1309 update_line (frame
, vpos
)
1310 register FRAME_PTR frame
;
1313 register GLYPH
*obody
, *nbody
, *op1
, *op2
, *np1
, *temp
;
1315 int osp
, nsp
, begmatch
, endmatch
, olen
, nlen
;
1317 register struct frame_glyphs
*current_frame
1318 = FRAME_CURRENT_GLYPHS (frame
);
1319 register struct frame_glyphs
*desired_frame
1320 = FRAME_DESIRED_GLYPHS (frame
);
1322 if (desired_frame
->highlight
[vpos
]
1323 != (current_frame
->enable
[vpos
] && current_frame
->highlight
[vpos
]))
1325 change_line_highlight (desired_frame
->highlight
[vpos
], vpos
,
1326 (current_frame
->enable
[vpos
] ?
1327 current_frame
->used
[vpos
] : 0));
1328 current_frame
->enable
[vpos
] = 0;
1331 reassert_line_highlight (desired_frame
->highlight
[vpos
], vpos
);
1333 if (! current_frame
->enable
[vpos
])
1339 obody
= current_frame
->glyphs
[vpos
];
1340 olen
= current_frame
->used
[vpos
];
1341 if (! current_frame
->highlight
[vpos
])
1343 if (!must_write_spaces
)
1344 while (obody
[olen
- 1] == SPACEGLYPH
&& olen
> 0)
1349 /* For an inverse-video line, remember we gave it
1350 spaces all the way to the frame edge
1351 so that the reverse video extends all the way across. */
1353 while (olen
< FRAME_WIDTH (frame
) - 1)
1354 obody
[olen
++] = SPACEGLYPH
;
1358 /* One way or another, this will enable the line being updated. */
1359 current_frame
->enable
[vpos
] = 1;
1360 current_frame
->used
[vpos
] = desired_frame
->used
[vpos
];
1361 current_frame
->highlight
[vpos
] = desired_frame
->highlight
[vpos
];
1362 current_frame
->bufp
[vpos
] = desired_frame
->bufp
[vpos
];
1364 #ifdef HAVE_X_WINDOWS
1365 if (FRAME_X_P (frame
))
1367 current_frame
->pix_width
[vpos
]
1368 = current_frame
->used
[vpos
]
1369 * FONT_WIDTH (frame
->display
.x
->font
);
1370 current_frame
->pix_height
[vpos
]
1371 = FONT_HEIGHT (frame
->display
.x
->font
);
1373 #endif /* HAVE_X_WINDOWS */
1375 if (!desired_frame
->enable
[vpos
])
1381 nbody
= desired_frame
->glyphs
[vpos
];
1382 nlen
= desired_frame
->used
[vpos
];
1384 /* Pretend trailing spaces are not there at all,
1385 unless for one reason or another we must write all spaces. */
1386 if (! desired_frame
->highlight
[vpos
])
1388 if (!must_write_spaces
)
1389 /* We know that the previous character byte contains 0. */
1390 while (nbody
[nlen
- 1] == SPACEGLYPH
)
1395 /* For an inverse-video line, give it extra trailing spaces
1396 all the way to the frame edge
1397 so that the reverse video extends all the way across. */
1399 while (nlen
< FRAME_WIDTH (frame
) - 1)
1400 nbody
[nlen
++] = SPACEGLYPH
;
1403 /* If there's no i/d char, quickly do the best we can without it. */
1404 if (!char_ins_del_ok
)
1409 if (FRAME_X_P (frame
))
1411 /* Under X, erase everything we are going to rewrite,
1412 and rewrite everything from the first char that's changed.
1413 This is part of supporting fonts like Courier
1414 whose chars can overlap outside the char width. */
1415 for (i
= 0; i
< nlen
; i
++)
1416 if (i
>= olen
|| nbody
[i
] != obody
[i
])
1419 cursor_to (vpos
, i
);
1421 clear_end_of_line (olen
);
1422 write_glyphs (nbody
+ i
, nlen
- i
);
1427 for (i
= 0; i
< nlen
; i
++)
1429 if (i
>= olen
|| nbody
[i
] != obody
[i
]) /* A non-matching char. */
1431 cursor_to (vpos
, i
);
1432 for (j
= 1; (i
+ j
< nlen
&&
1433 (i
+ j
>= olen
|| nbody
[i
+j
] != obody
[i
+j
]));
1436 /* Output this run of non-matching chars. */
1437 write_glyphs (nbody
+ i
, j
);
1440 /* Now find the next non-match. */
1444 /* Clear the rest of the line, or the non-clear part of it. */
1447 cursor_to (vpos
, nlen
);
1448 clear_end_of_line (olen
);
1451 /* Exchange contents between current_frame and new_frame. */
1452 temp
= desired_frame
->glyphs
[vpos
];
1453 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1454 current_frame
->glyphs
[vpos
] = temp
;
1461 nsp
= (must_write_spaces
|| desired_frame
->highlight
[vpos
])
1462 ? 0 : count_blanks (nbody
);
1465 cursor_to (vpos
, nsp
);
1466 write_glyphs (nbody
+ nsp
, nlen
- nsp
);
1469 /* Exchange contents between current_frame and new_frame. */
1470 temp
= desired_frame
->glyphs
[vpos
];
1471 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1472 current_frame
->glyphs
[vpos
] = temp
;
1481 /* Compute number of leading blanks in old and new contents. */
1482 osp
= count_blanks (obody
);
1483 if (!desired_frame
->highlight
[vpos
])
1484 nsp
= count_blanks (nbody
);
1488 /* Compute number of matching chars starting with first nonblank. */
1489 begmatch
= count_match (obody
+ osp
, nbody
+ nsp
);
1491 /* Spaces in new match implicit space past the end of old. */
1492 /* A bug causing this to be a no-op was fixed in 18.29. */
1493 if (!must_write_spaces
&& osp
+ begmatch
== olen
)
1496 while (np1
[begmatch
] == SPACEGLYPH
)
1500 /* Avoid doing insert/delete char
1501 just cause number of leading spaces differs
1502 when the following text does not match. */
1503 if (begmatch
== 0 && osp
!= nsp
)
1504 osp
= nsp
= min (osp
, nsp
);
1506 /* Find matching characters at end of line */
1509 op2
= op1
+ begmatch
- min (olen
- osp
, nlen
- nsp
);
1510 while (op1
> op2
&& op1
[-1] == np1
[-1])
1515 endmatch
= obody
+ olen
- op1
;
1517 /* Put correct value back in nbody[nlen].
1518 This is important because direct_output_for_insert
1519 can write into the line at a later point.
1520 If this screws up the zero at the end of the line, re-establish it. */
1524 /* tem gets the distance to insert or delete.
1525 endmatch is how many characters we save by doing so.
1528 tem
= (nlen
- nsp
) - (olen
- osp
);
1530 && (!char_ins_del_ok
|| endmatch
<= char_ins_del_cost (frame
)[tem
]))
1533 /* nsp - osp is the distance to insert or delete.
1534 If that is nonzero, begmatch is known to be nonzero also.
1535 begmatch + endmatch is how much we save by doing the ins/del.
1539 && (!char_ins_del_ok
1540 || begmatch
+ endmatch
<= char_ins_del_cost (frame
)[nsp
- osp
]))
1544 osp
= nsp
= min (osp
, nsp
);
1547 /* Now go through the line, inserting, writing and
1548 deleting as appropriate. */
1552 cursor_to (vpos
, nsp
);
1553 delete_glyphs (osp
- nsp
);
1557 /* If going to delete chars later in line
1558 and insert earlier in the line,
1559 must delete first to avoid losing data in the insert */
1560 if (endmatch
&& nlen
< olen
+ nsp
- osp
)
1562 cursor_to (vpos
, nlen
- endmatch
+ osp
- nsp
);
1563 delete_glyphs (olen
+ nsp
- osp
- nlen
);
1564 olen
= nlen
- (nsp
- osp
);
1566 cursor_to (vpos
, osp
);
1567 insert_glyphs ((char *)0, nsp
- osp
);
1571 tem
= nsp
+ begmatch
+ endmatch
;
1572 if (nlen
!= tem
|| olen
!= tem
)
1574 cursor_to (vpos
, nsp
+ begmatch
);
1575 if (!endmatch
|| nlen
== olen
)
1577 /* If new text being written reaches right margin,
1578 there is no need to do clear-to-eol at the end.
1579 (and it would not be safe, since cursor is not
1580 going to be "at the margin" after the text is done) */
1581 if (nlen
== FRAME_WIDTH (frame
))
1583 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1587 /* the following code loses disastrously if tem == nlen.
1588 Rather than trying to fix that case, I am trying the simpler
1589 solution found above. */
1591 /* If the text reaches to the right margin,
1592 it will lose one way or another (depending on AutoWrap)
1593 to clear to end of line after outputting all the text.
1594 So pause with one character to go and clear the line then. */
1595 if (nlen
== FRAME_WIDTH (frame
) && fast_clear_end_of_line
&& olen
> nlen
)
1597 /* endmatch must be zero, and tem must equal nsp + begmatch */
1598 write_glyphs (nbody
+ tem
, nlen
- tem
- 1);
1599 clear_end_of_line (olen
);
1600 olen
= 0; /* Don't let it be cleared again later */
1601 write_glyphs (nbody
+ nlen
- 1, 1);
1604 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1605 #endif /* OBSOLETE */
1608 else if (nlen
> olen
)
1610 write_glyphs (nbody
+ nsp
+ begmatch
, olen
- tem
);
1611 insert_glyphs (nbody
+ nsp
+ begmatch
+ olen
- tem
, nlen
- olen
);
1614 else if (olen
> nlen
)
1616 write_glyphs (nbody
+ nsp
+ begmatch
, nlen
- tem
);
1617 delete_glyphs (olen
- nlen
);
1623 /* If any unerased characters remain after the new line, erase them. */
1626 cursor_to (vpos
, nlen
);
1627 clear_end_of_line (olen
);
1630 /* Exchange contents between current_frame and new_frame. */
1631 temp
= desired_frame
->glyphs
[vpos
];
1632 desired_frame
->glyphs
[vpos
] = current_frame
->glyphs
[vpos
];
1633 current_frame
->glyphs
[vpos
] = temp
;
1636 DEFUN ("open-termscript", Fopen_termscript
, Sopen_termscript
,
1637 1, 1, "FOpen termscript file: ",
1638 "Start writing all terminal output to FILE as well as the terminal.\n\
1639 FILE = nil means just close any termscript file currently open.")
1643 if (termscript
!= 0) fclose (termscript
);
1648 file
= Fexpand_file_name (file
, Qnil
);
1649 termscript
= fopen (XSTRING (file
)->data
, "w");
1650 if (termscript
== 0)
1651 report_file_error ("Opening termscript", Fcons (file
, Qnil
));
1659 window_change_signal ()
1663 int old_errno
= errno
;
1665 get_frame_size (&width
, &height
);
1667 /* The frame size change obviously applies to a termcap-controlled
1668 frame. Find such a frame in the list, and assume it's the only
1669 one (since the redisplay code always writes to stdout, not a
1670 FILE * specified in the frame structure). Record the new size,
1671 but don't reallocate the data structures now. Let that be done
1672 later outside of the signal handler. */
1675 Lisp_Object tail
, frame
;
1677 FOR_EACH_FRAME (tail
, frame
)
1679 if (FRAME_TERMCAP_P (XFRAME (frame
)))
1681 change_frame_size (XFRAME (frame
), height
, width
, 0, 1);
1687 signal (SIGWINCH
, window_change_signal
);
1690 #endif /* SIGWINCH */
1693 /* Do any change in frame size that was requested by a signal. */
1695 do_pending_window_change ()
1697 /* If window_change_signal should have run before, run it now. */
1698 while (delayed_size_change
)
1700 Lisp_Object tail
, frame
;
1702 delayed_size_change
= 0;
1704 FOR_EACH_FRAME (tail
, frame
)
1706 FRAME_PTR f
= XFRAME (frame
);
1708 int height
= FRAME_NEW_HEIGHT (f
);
1709 int width
= FRAME_NEW_WIDTH (f
);
1711 if (height
!= 0 || width
!= 0)
1712 change_frame_size (f
, height
, width
, 0, 0);
1718 /* Change the frame height and/or width. Values may be given as zero to
1719 indicate no change is to take place.
1721 If DELAY is non-zero, then assume we're being called from a signal
1722 handler, and queue the change for later - perhaps the next
1723 redisplay. Since this tries to resize windows, we can't call it
1724 from a signal handler. */
1726 change_frame_size (frame
, newheight
, newwidth
, pretend
, delay
)
1727 register FRAME_PTR frame
;
1728 int newheight
, newwidth
, pretend
;
1730 /* If we can't deal with the change now, queue it for later. */
1733 FRAME_NEW_HEIGHT (frame
) = newheight
;
1734 FRAME_NEW_WIDTH (frame
) = newwidth
;
1735 delayed_size_change
= 1;
1739 /* This size-change overrides any pending one for this frame. */
1740 FRAME_NEW_HEIGHT (frame
) = 0;
1741 FRAME_NEW_WIDTH (frame
) = 0;
1743 /* If an argument is zero, set it to the current value. */
1744 newheight
|| (newheight
= FRAME_HEIGHT (frame
));
1745 newwidth
|| (newwidth
= FRAME_WIDTH (frame
));
1747 /* Round up to the smallest acceptable size. */
1748 check_frame_size (frame
, &newheight
, &newwidth
);
1750 /* If we're not changing the frame size, quit now. */
1751 if (newheight
== FRAME_HEIGHT (frame
)
1752 && newwidth
== FRAME_WIDTH (frame
))
1755 if (newheight
!= FRAME_HEIGHT (frame
))
1757 if (FRAME_HAS_MINIBUF_P (frame
)
1758 && ! FRAME_MINIBUF_ONLY_P (frame
))
1760 /* Frame has both root and minibuffer. */
1761 set_window_height (FRAME_ROOT_WINDOW (frame
),
1762 newheight
- 1 - FRAME_MENU_BAR_LINES (frame
), 0);
1763 XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (frame
))->top
)
1765 set_window_height (FRAME_MINIBUF_WINDOW (frame
), 1, 0);
1768 /* Frame has just one top-level window. */
1769 set_window_height (FRAME_ROOT_WINDOW (frame
),
1770 newheight
- FRAME_MENU_BAR_LINES (frame
), 0);
1772 if (FRAME_TERMCAP_P (frame
) && !pretend
)
1773 FrameRows
= newheight
;
1776 if (frame
->output_method
== output_termcap
)
1778 frame_height
= newheight
;
1780 FrameRows
= newheight
;
1785 if (newwidth
!= FRAME_WIDTH (frame
))
1787 set_window_width (FRAME_ROOT_WINDOW (frame
), newwidth
, 0);
1788 if (FRAME_HAS_MINIBUF_P (frame
))
1789 set_window_width (FRAME_MINIBUF_WINDOW (frame
), newwidth
, 0);
1791 if (FRAME_TERMCAP_P (frame
) && !pretend
)
1792 FrameCols
= newwidth
;
1794 if (frame
->output_method
== output_termcap
)
1796 frame_width
= newwidth
;
1798 FrameCols
= newwidth
;
1803 FRAME_HEIGHT (frame
) = newheight
;
1804 FRAME_WIDTH (frame
) = newwidth
;
1806 remake_frame_glyphs (frame
);
1807 calculate_costs (frame
);
1810 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal
,
1811 Ssend_string_to_terminal
, 1, 1, 0,
1812 "Send STRING to the terminal without alteration.\n\
1813 Control characters in STRING will have terminal-dependent effects.")
1817 CHECK_STRING (str
, 0);
1818 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, stdout
);
1822 fwrite (XSTRING (str
)->data
, 1, XSTRING (str
)->size
, termscript
);
1823 fflush (termscript
);
1828 DEFUN ("ding", Fding
, Sding
, 0, 1, 0,
1829 "Beep, or flash the screen.\n\
1830 Also, unless an argument is given,\n\
1831 terminate any keyboard macro currently executing.")
1853 else if (!INTERACTIVE
) /* Stop executing a keyboard macro. */
1854 error ("Keyboard macro terminated by a command ringing the bell");
1860 DEFUN ("sleep-for", Fsleep_for
, Ssleep_for
, 1, 2, 0,
1861 "Pause, without updating display, for SECONDS seconds.\n\
1862 SECONDS may be a floating-point value, meaning that you can wait for a\n\
1863 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
1864 additional wait period, in milliseconds; this may be useful if your\n\
1865 Emacs was built without floating point support.\n\
1866 \(Not all operating systems support waiting for a fraction of a second.)")
1867 (seconds
, milliseconds
)
1868 Lisp_Object seconds
, milliseconds
;
1872 if (NILP (milliseconds
))
1873 XSET (milliseconds
, Lisp_Int
, 0);
1875 CHECK_NUMBER (milliseconds
, 1);
1876 usec
= XINT (milliseconds
) * 1000;
1878 #ifdef LISP_FLOAT_TYPE
1880 double duration
= extract_float (seconds
);
1881 sec
= (int) duration
;
1882 usec
+= (duration
- sec
) * 1000000;
1885 CHECK_NUMBER (seconds
, 0);
1886 sec
= XINT (seconds
);
1889 #ifndef EMACS_HAS_USECS
1890 if (sec
== 0 && usec
!= 0)
1891 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE
);
1894 /* Assure that 0 <= usec < 1000000. */
1897 /* We can't rely on the rounding being correct if user is negative. */
1898 if (-1000000 < usec
)
1899 sec
--, usec
+= 1000000;
1901 sec
-= -usec
/ 1000000, usec
= 1000000 - (-usec
% 1000000);
1904 sec
+= usec
/ 1000000, usec
%= 1000000;
1912 XFASTINT (zero
) = 0;
1913 wait_reading_process_input (sec
, usec
, zero
, 0);
1916 /* We should always have wait_reading_process_input; we have a dummy
1917 implementation for systems which don't support subprocesses. */
1919 /* No wait_reading_process_input */
1926 /* The reason this is done this way
1927 (rather than defined (H_S) && defined (H_T))
1928 is because the VMS preprocessor doesn't grok `defined' */
1930 EMACS_GET_TIME (end_time
);
1931 EMACS_SET_SECS_USECS (timeout
, sec
, usec
);
1932 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
1936 EMACS_GET_TIME (timeout
);
1937 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
1938 if (EMACS_TIME_NEG_P (timeout
)
1939 || !select (1, 0, 0, 0, &timeout
))
1942 #else /* not HAVE_SELECT */
1944 #endif /* HAVE_SELECT */
1945 #endif /* not VMS */
1948 #endif /* no subprocesses */
1953 /* This is just like wait_reading_process_input, except that
1954 it does the redisplay.
1956 It's also just like Fsit_for, except that it can be used for
1957 waiting for input as well. */
1960 sit_for (sec
, usec
, reading
, display
)
1961 int sec
, usec
, reading
, display
;
1963 Lisp_Object read_kbd
;
1965 if (detect_input_pending ())
1969 redisplay_preserve_echo_area ();
1971 if (sec
== 0 && usec
== 0)
1978 XSET (read_kbd
, Lisp_Int
, reading
? -1 : 1);
1979 wait_reading_process_input (sec
, usec
, read_kbd
, display
);
1982 /* wait_reading_process_input should always be available now; it is
1983 simulated in a simple way on systems that don't support
1986 /* No wait_reading_process_input available. */
1992 input_wait_timeout (XINT (arg
));
1994 #ifndef HAVE_TIMEVAL
1996 select (1, &waitchannels
, 0, 0, &timeout_sec
);
1997 #else /* HAVE_TIMEVAL */
1998 timeout
.tv_sec
= sec
;
1999 timeout
.tv_usec
= usec
;
2000 select (1, &waitchannels
, 0, 0, &timeout
);
2001 #endif /* HAVE_TIMEVAL */
2002 #endif /* not VMS */
2007 return detect_input_pending () ? Qnil
: Qt
;
2010 DEFUN ("sit-for", Fsit_for
, Ssit_for
, 1, 3, 0,
2011 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
2012 SECONDS may be a floating-point value, meaning that you can wait for a\n\
2013 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
2014 additional wait period, in milliseconds; this may be useful if your\n\
2015 Emacs was built without floating point support.\n\
2016 \(Not all operating systems support waiting for a fraction of a second.)\n\
2017 Optional third arg non-nil means don't redisplay, just wait for input.\n\
2018 Redisplay is preempted as always if input arrives, and does not happen\n\
2019 if input is available before it starts.\n\
2020 Value is t if waited the full time with no input arriving.")
2021 (seconds
, milliseconds
, nodisp
)
2022 Lisp_Object seconds
, milliseconds
, nodisp
;
2026 if (NILP (milliseconds
))
2027 XSET (milliseconds
, Lisp_Int
, 0);
2029 CHECK_NUMBER (milliseconds
, 1);
2030 usec
= XINT (milliseconds
) * 1000;
2032 #ifdef LISP_FLOAT_TYPE
2034 double duration
= extract_float (seconds
);
2035 sec
= (int) duration
;
2036 usec
+= (duration
- sec
) * 1000000;
2039 CHECK_NUMBER (seconds
, 0);
2040 sec
= XINT (seconds
);
2043 #ifndef EMACS_HAS_USECS
2044 if (usec
!= 0 && sec
== 0)
2045 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE
);
2048 return sit_for (sec
, usec
, 0, NILP (nodisp
));
2051 char *terminal_type
;
2053 /* Initialization done when Emacs fork is started, before doing stty. */
2054 /* Determine terminal type and set terminal_driver */
2055 /* Then invoke its decoding routine to set up variables
2056 in the terminal package */
2060 #ifdef HAVE_X_WINDOWS
2061 extern int display_arg
;
2066 cursor_in_echo_area
= 0;
2067 terminal_type
= (char *) 0;
2069 /* Now is the time to initialize this; it's used by init_sys_modes
2071 Vwindow_system
= Qnil
;
2073 /* If the user wants to use a window system, we shouldn't bother
2074 initializing the terminal. This is especially important when the
2075 terminal is so dumb that emacs gives up before and doesn't bother
2076 using the window system.
2078 If the DISPLAY environment variable is set, try to use X, and die
2079 with an error message if that doesn't work. */
2081 #ifdef HAVE_X_WINDOWS
2085 display_arg
= (getenv ("DECW$DISPLAY") != 0);
2087 display_arg
= (getenv ("DISPLAY") != 0);
2091 if (!inhibit_window_system
&& display_arg
)
2093 Vwindow_system
= intern ("x");
2095 Vwindow_system_version
= make_number (11);
2097 Vwindow_system_version
= make_number (10);
2101 #endif /* HAVE_X_WINDOWS */
2103 /* If no window system has been specified, try to use the terminal. */
2106 fprintf (stderr
, "emacs: standard input is not a tty\n");
2110 /* Look at the TERM variable */
2111 terminal_type
= (char *) getenv ("TERM");
2115 fprintf (stderr
, "Please specify your terminal type.\n\
2116 For types defined in VMS, use set term /device=TYPE.\n\
2117 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
2118 \(The quotation marks are necessary since terminal types are lower case.)\n");
2120 fprintf (stderr
, "Please set the environment variable TERM; see tset(1).\n");
2126 /* VMS DCL tends to upcase things, so downcase term type.
2127 Hardly any uppercase letters in terminal types; should be none. */
2129 char *new = (char *) xmalloc (strlen (terminal_type
) + 1);
2132 strcpy (new, terminal_type
);
2134 for (p
= new; *p
; p
++)
2138 terminal_type
= new;
2142 term_init (terminal_type
);
2144 remake_frame_glyphs (selected_frame
);
2145 calculate_costs (selected_frame
);
2147 /* X and Y coordinates of the cursor between updates. */
2148 FRAME_CURSOR_X (selected_frame
) = 0;
2149 FRAME_CURSOR_Y (selected_frame
) = 0;
2154 #endif /* CANNOT_DUMP */
2155 signal (SIGWINCH
, window_change_signal
);
2156 #endif /* SIGWINCH */
2162 defsubr (&Sredraw_frame
);
2164 defsubr (&Sredraw_display
);
2165 defsubr (&Sopen_termscript
);
2167 defsubr (&Ssit_for
);
2168 defsubr (&Ssleep_for
);
2169 defsubr (&Ssend_string_to_terminal
);
2171 DEFVAR_INT ("baud-rate", &baud_rate
,
2172 "The output baud rate of the terminal.\n\
2173 On most systems, changing this value will affect the amount of padding\n\
2174 and the other strategic decisions made during redisplay.");
2175 DEFVAR_BOOL ("inverse-video", &inverse_video
,
2176 "*Non-nil means invert the entire frame display.\n\
2177 This means everything is in inverse video which otherwise would not be.");
2178 DEFVAR_BOOL ("visible-bell", &visible_bell
,
2179 "*Non-nil means try to flash the frame to represent a bell.");
2180 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter
,
2181 "*Non-nil means no need to redraw entire frame after suspending.\n\
2182 A non-nil value is useful if the terminal can automatically preserve\n\
2183 Emacs's frame display when you reenter Emacs.\n\
2184 It is up to you to set this variable if your terminal can do that.");
2185 DEFVAR_LISP ("window-system", &Vwindow_system
,
2186 "A symbol naming the window-system under which Emacs is running\n\
2187 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
2188 DEFVAR_LISP ("window-system-version", &Vwindow_system_version
,
2189 "The version number of the window system in use.\n\
2190 For X windows, this is 10 or 11.");
2191 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area
,
2192 "Non-nil means put cursor in minibuffer, at end of any message there.");
2193 DEFVAR_LISP ("glyph-table", &Vglyph_table
,
2194 "Table defining how to output a glyph code to the frame.\n\
2195 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
2196 Each element can be:\n\
2197 integer: a glyph code which this glyph is an alias for.\n\
2198 string: output this glyph using that string (not impl. in X windows).\n\
2199 nil: this glyph mod 256 is char code to output,\n\
2200 and this glyph / 256 is face code for X windows (see `x-set-face').");
2201 Vglyph_table
= Qnil
;
2203 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table
,
2204 "Display table to use for buffers that specify none.\n\
2205 See `buffer-display-table' for more information.");
2206 Vstandard_display_table
= Qnil
;
2208 /* Initialize `window-system', unless init_display already decided it. */
2213 Vwindow_system
= Qnil
;
2214 Vwindow_system_version
= Qnil
;