314
|
1 /* Updating of data structures for redisplay.
|
6617
|
2 Copyright (C) 1985, 86, 87, 88, 93, 94 Free Software Foundation, Inc.
|
314
|
3
|
|
4 This file is part of GNU Emacs.
|
|
5
|
|
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
|
1777
|
8 the Free Software Foundation; either version 2, or (at your option)
|
314
|
9 any later version.
|
|
10
|
|
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.
|
|
15
|
|
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. */
|
|
19
|
|
20
|
|
21 #include <signal.h>
|
|
22
|
4696
|
23 #include <config.h>
|
7900
|
24
|
|
25 #include <stdio.h>
|
314
|
26 #include <ctype.h>
|
|
27
|
3525
|
28 #include "lisp.h"
|
314
|
29 #include "termchar.h"
|
|
30 #include "termopts.h"
|
2198
|
31 #include "termhooks.h"
|
314
|
32 #include "cm.h"
|
|
33 #include "dispextern.h"
|
|
34 #include "buffer.h"
|
764
|
35 #include "frame.h"
|
314
|
36 #include "window.h"
|
|
37 #include "commands.h"
|
|
38 #include "disptab.h"
|
|
39 #include "indent.h"
|
4384
|
40 #include "intervals.h"
|
314
|
41
|
1042
|
42 #include "systty.h"
|
554
|
43
|
314
|
44 #ifdef HAVE_X_WINDOWS
|
|
45 #include "xterm.h"
|
|
46 #endif /* HAVE_X_WINDOWS */
|
|
47
|
7808
|
48 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
|
|
49 #include "systime.h"
|
|
50
|
7558
|
51 #include <errno.h>
|
|
52
|
314
|
53 #define max(a, b) ((a) > (b) ? (a) : (b))
|
|
54 #define min(a, b) ((a) < (b) ? (a) : (b))
|
|
55
|
|
56 /* Get number of chars of output now in the buffer of a stdio stream.
|
|
57 This ought to be built in in stdio, but it isn't.
|
|
58 Some s- files override this because their stdio internals differ. */
|
5214
c4bf07b226be
(PENDING_OUTPUT_COUNT) [__GNU_LIBRARY__]: Alternate definition for the GNU
Roland McGrath <roland@gnu.org>
diff
changeset
|
59 #ifdef __GNU_LIBRARY__
|
7444
|
60 /* The s- file might have overridden the definition with one that works for
|
|
61 the system's C library. But we are using the GNU C library, so this is
|
|
62 the right definition for every system. */
|
7558
|
63 #ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT
|
|
64 #define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT
|
|
65 #else
|
7443
a9cb818e5316
[__GNU_LIBRARY__]: Redefine PENDING_OUTPUT_COUNT even if already defined.
Roland McGrath <roland@gnu.org>
diff
changeset
|
66 #undef PENDING_OUTPUT_COUNT
|
5214
c4bf07b226be
(PENDING_OUTPUT_COUNT) [__GNU_LIBRARY__]: Alternate definition for the GNU
Roland McGrath <roland@gnu.org>
diff
changeset
|
67 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer)
|
7558
|
68 #endif
|
|
69 #else /* not __GNU_LIBRARY__ */
|
7443
a9cb818e5316
[__GNU_LIBRARY__]: Redefine PENDING_OUTPUT_COUNT even if already defined.
Roland McGrath <roland@gnu.org>
diff
changeset
|
70 #ifndef PENDING_OUTPUT_COUNT
|
314
|
71 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base)
|
|
72 #endif
|
5214
c4bf07b226be
(PENDING_OUTPUT_COUNT) [__GNU_LIBRARY__]: Alternate definition for the GNU
Roland McGrath <roland@gnu.org>
diff
changeset
|
73 #endif
|
314
|
74
|
554
|
75 /* Nonzero upon entry to redisplay means do not assume anything about
|
764
|
76 current contents of actual terminal frame; clear and redraw it. */
|
314
|
77
|
764
|
78 int frame_garbaged;
|
314
|
79
|
|
80 /* Nonzero means last display completed. Zero means it was preempted. */
|
|
81
|
|
82 int display_completed;
|
|
83
|
|
84 /* Lisp variable visible-bell; enables use of screen-flash
|
|
85 instead of audible bell. */
|
|
86
|
|
87 int visible_bell;
|
|
88
|
764
|
89 /* Invert the color of the whole frame, at a low level. */
|
314
|
90
|
|
91 int inverse_video;
|
|
92
|
|
93 /* Line speed of the terminal. */
|
|
94
|
|
95 int baud_rate;
|
|
96
|
|
97 /* nil or a symbol naming the window system under which emacs is
|
|
98 running ('x is the only current possibility). */
|
|
99
|
|
100 Lisp_Object Vwindow_system;
|
|
101
|
|
102 /* Version number of X windows: 10, 11 or nil. */
|
|
103 Lisp_Object Vwindow_system_version;
|
|
104
|
|
105 /* Vector of glyph definitions. Indexed by glyph number,
|
|
106 the contents are a string which is how to output the glyph.
|
|
107
|
|
108 If Vglyph_table is nil, a glyph is output by using its low 8 bits
|
|
109 as a character code. */
|
|
110
|
|
111 Lisp_Object Vglyph_table;
|
|
112
|
|
113 /* Display table to use for vectors that don't specify their own. */
|
|
114
|
|
115 Lisp_Object Vstandard_display_table;
|
|
116
|
|
117 /* Nonzero means reading single-character input with prompt
|
708
|
118 so put cursor on minibuffer after the prompt.
|
|
119 positive means at end of text in echo area;
|
|
120 negative means at beginning of line. */
|
314
|
121 int cursor_in_echo_area;
|
|
122
|
764
|
123 /* The currently selected frame.
|
|
124 In a single-frame version, this variable always remains 0. */
|
314
|
125
|
764
|
126 FRAME_PTR selected_frame;
|
314
|
127
|
764
|
128 /* A frame which is not just a minibuffer, or 0 if there are no such
|
|
129 frames. This is usually the most recent such frame that was
|
|
130 selected. In a single-frame version, this variable always remains 0. */
|
|
131 FRAME_PTR last_nonminibuf_frame;
|
732
|
132
|
764
|
133 /* In a single-frame version, the information that would otherwise
|
986
|
134 exist inside frame objects lives in the following structure instead.
|
|
135
|
|
136 NOTE: the_only_frame is not checked for garbage collection; don't
|
3591
|
137 store collectible objects in any of its fields!
|
986
|
138
|
|
139 You're not/The only frame in town/... */
|
314
|
140
|
764
|
141 #ifndef MULTI_FRAME
|
|
142 struct frame the_only_frame;
|
732
|
143 #endif
|
314
|
144
|
|
145 /* This is a vector, made larger whenever it isn't large enough,
|
764
|
146 which is used inside `update_frame' to hold the old contents
|
|
147 of the FRAME_PHYS_LINES of the frame being updated. */
|
|
148 struct frame_glyphs **ophys_lines;
|
314
|
149 /* Length of vector currently allocated. */
|
|
150 int ophys_lines_length;
|
|
151
|
|
152 FILE *termscript; /* Stdio stream being used for copy of all output. */
|
|
153
|
|
154 struct cm Wcm; /* Structure for info on cursor positioning */
|
|
155
|
|
156 extern short ospeed; /* Output speed (from sg_ospeed) */
|
|
157
|
|
158 int delayed_size_change; /* 1 means SIGWINCH happened when not safe. */
|
|
159
|
764
|
160 #ifdef MULTI_FRAME
|
314
|
161
|
764
|
162 DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 1, 1, 0,
|
|
163 "Clear frame FRAME and output again what is supposed to appear on it.")
|
|
164 (frame)
|
|
165 Lisp_Object frame;
|
314
|
166 {
|
764
|
167 FRAME_PTR f;
|
314
|
168
|
764
|
169 CHECK_LIVE_FRAME (frame, 0);
|
|
170 f = XFRAME (frame);
|
|
171 update_begin (f);
|
314
|
172 /* set_terminal_modes (); */
|
764
|
173 clear_frame ();
|
960
|
174 clear_frame_records (f);
|
764
|
175 update_end (f);
|
314
|
176 fflush (stdout);
|
|
177 windows_or_buffers_changed++;
|
|
178 /* Mark all windows as INaccurate,
|
|
179 so that every window will have its redisplay done. */
|
764
|
180 mark_window_display_accurate (FRAME_ROOT_WINDOW (f), 0);
|
|
181 f->garbaged = 0;
|
314
|
182 return Qnil;
|
|
183 }
|
|
184
|
764
|
185 redraw_frame (f)
|
|
186 FRAME_PTR f;
|
314
|
187 {
|
764
|
188 Lisp_Object frame;
|
|
189 XSET (frame, Lisp_Frame, f);
|
|
190 Fredraw_frame (frame);
|
314
|
191 }
|
|
192
|
2252
|
193 #else
|
314
|
194
|
6349
c88bce6b48f0
(Fredraw_frame) [! MULTI_FRAME]: Make noninteractive, to be consistent with
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
195 DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 1, 1, 0,
|
2252
|
196 "Clear frame FRAME and output again what is supposed to appear on it.")
|
|
197 (frame)
|
|
198 Lisp_Object frame;
|
314
|
199 {
|
|
200 update_begin (0);
|
|
201 set_terminal_modes ();
|
764
|
202 clear_frame ();
|
314
|
203 update_end (0);
|
|
204 fflush (stdout);
|
764
|
205 clear_frame_records (0);
|
314
|
206 windows_or_buffers_changed++;
|
|
207 /* Mark all windows as INaccurate,
|
|
208 so that every window will have its redisplay done. */
|
1588
|
209 mark_window_display_accurate (FRAME_ROOT_WINDOW (0), 0);
|
314
|
210 return Qnil;
|
|
211 }
|
|
212
|
2252
|
213 #endif
|
|
214
|
|
215 DEFUN ("redraw-display", Fredraw_display, Sredraw_display, 0, 0, "",
|
|
216 "Clear and redisplay all visible frames.")
|
|
217 ()
|
|
218 {
|
|
219 Lisp_Object tail, frame;
|
|
220
|
|
221 FOR_EACH_FRAME (tail, frame)
|
3517
|
222 if (FRAME_VISIBLE_P (XFRAME (frame)))
|
|
223 Fredraw_frame (frame);
|
|
224
|
|
225 return Qnil;
|
|
226 }
|
|
227
|
|
228 /* This is used when frame_garbaged is set.
|
|
229 Redraw the individual frames marked as garbaged. */
|
|
230
|
|
231 void
|
|
232 redraw_garbaged_frames ()
|
|
233 {
|
|
234 Lisp_Object tail, frame;
|
|
235
|
|
236 FOR_EACH_FRAME (tail, frame)
|
2252
|
237 if (FRAME_VISIBLE_P (XFRAME (frame))
|
|
238 && FRAME_GARBAGED_P (XFRAME (frame)))
|
|
239 Fredraw_frame (frame);
|
|
240 }
|
|
241
|
314
|
242
|
764
|
243 static struct frame_glyphs *
|
|
244 make_frame_glyphs (frame, empty)
|
|
245 register FRAME_PTR frame;
|
314
|
246 int empty;
|
|
247 {
|
|
248 register int i;
|
764
|
249 register width = FRAME_WIDTH (frame);
|
|
250 register height = FRAME_HEIGHT (frame);
|
6617
|
251 register struct frame_glyphs *new
|
|
252 = (struct frame_glyphs *) xmalloc (sizeof (struct frame_glyphs));
|
314
|
253
|
764
|
254 SET_GLYPHS_FRAME (new, frame);
|
314
|
255 new->height = height;
|
|
256 new->width = width;
|
|
257 new->used = (int *) xmalloc (height * sizeof (int));
|
|
258 new->glyphs = (GLYPH **) xmalloc (height * sizeof (GLYPH *));
|
6617
|
259 new->charstarts = (int **) xmalloc (height * sizeof (int *));
|
314
|
260 new->highlight = (char *) xmalloc (height * sizeof (char));
|
|
261 new->enable = (char *) xmalloc (height * sizeof (char));
|
|
262 bzero (new->enable, height * sizeof (char));
|
|
263 new->bufp = (int *) xmalloc (height * sizeof (int));
|
|
264
|
|
265 #ifdef HAVE_X_WINDOWS
|
960
|
266 if (FRAME_X_P (frame))
|
314
|
267 {
|
|
268 new->top_left_x = (short *) xmalloc (height * sizeof (short));
|
|
269 new->top_left_y = (short *) xmalloc (height * sizeof (short));
|
|
270 new->pix_width = (short *) xmalloc (height * sizeof (short));
|
|
271 new->pix_height = (short *) xmalloc (height * sizeof (short));
|
1407
0f214040f708
* dispnew.c (scroll_frame_lines): All references to frame elements
Joseph Arceneaux <jla@gnu.org>
diff
changeset
|
272 new->max_ascent = (short *) xmalloc (height * sizeof (short));
|
314
|
273 }
|
|
274 #endif
|
|
275
|
|
276 if (empty)
|
|
277 {
|
|
278 /* Make the buffer used by decode_mode_spec. This buffer is also
|
764
|
279 used as temporary storage when updating the frame. See scroll.c. */
|
314
|
280 unsigned int total_glyphs = (width + 2) * sizeof (GLYPH);
|
6627
f8471ecf787b
(make_frame_glyphs): If EMPTY, don't leave junk in ->total_charstarts.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
281 unsigned int total_charstarts = (width + 2) * sizeof (int);
|
314
|
282
|
|
283 new->total_contents = (GLYPH *) xmalloc (total_glyphs);
|
|
284 bzero (new->total_contents, total_glyphs);
|
6627
f8471ecf787b
(make_frame_glyphs): If EMPTY, don't leave junk in ->total_charstarts.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
285
|
f8471ecf787b
(make_frame_glyphs): If EMPTY, don't leave junk in ->total_charstarts.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
286 new->total_charstarts = (int *) xmalloc (total_charstarts);
|
f8471ecf787b
(make_frame_glyphs): If EMPTY, don't leave junk in ->total_charstarts.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
287 bzero (new->total_charstarts, total_glyphs);
|
314
|
288 }
|
|
289 else
|
|
290 {
|
|
291 unsigned int total_glyphs = height * (width + 2) * sizeof (GLYPH);
|
|
292
|
|
293 new->total_contents = (GLYPH *) xmalloc (total_glyphs);
|
|
294 bzero (new->total_contents, total_glyphs);
|
|
295 for (i = 0; i < height; i++)
|
|
296 new->glyphs[i] = new->total_contents + i * (width + 2) + 1;
|
6617
|
297
|
|
298 if (!FRAME_TERMCAP_P (frame))
|
|
299 {
|
|
300 unsigned int total_charstarts = height * (width + 2) * sizeof (int);
|
|
301
|
|
302 new->total_charstarts = (int *) xmalloc (total_charstarts);
|
|
303 bzero (new->total_charstarts, total_charstarts);
|
|
304 for (i = 0; i < height; i++)
|
|
305 new->charstarts[i] = new->total_charstarts + i * (width + 2) + 1;
|
|
306 }
|
|
307 else
|
|
308 {
|
|
309 /* Without a window system, we don't really need charstarts.
|
|
310 So use a small amount of space to make enough data structure
|
|
311 to prevent crashes in display_text_line. */
|
|
312 new->total_charstarts = (int *) xmalloc ((width + 2) * sizeof (int));
|
|
313 for (i = 0; i < height; i++)
|
|
314 new->charstarts[i] = new->total_charstarts;
|
|
315 }
|
314
|
316 }
|
|
317
|
|
318 return new;
|
|
319 }
|
|
320
|
|
321 static void
|
764
|
322 free_frame_glyphs (frame, glyphs)
|
|
323 FRAME_PTR frame;
|
|
324 struct frame_glyphs *glyphs;
|
314
|
325 {
|
|
326 if (glyphs->total_contents)
|
2439
|
327 xfree (glyphs->total_contents);
|
6617
|
328 if (glyphs->total_charstarts)
|
|
329 xfree (glyphs->total_charstarts);
|
314
|
330
|
2439
|
331 xfree (glyphs->used);
|
|
332 xfree (glyphs->glyphs);
|
|
333 xfree (glyphs->highlight);
|
|
334 xfree (glyphs->enable);
|
|
335 xfree (glyphs->bufp);
|
6617
|
336 if (glyphs->charstarts)
|
|
337 xfree (glyphs->charstarts);
|
314
|
338
|
|
339 #ifdef HAVE_X_WINDOWS
|
960
|
340 if (FRAME_X_P (frame))
|
314
|
341 {
|
2439
|
342 xfree (glyphs->top_left_x);
|
|
343 xfree (glyphs->top_left_y);
|
|
344 xfree (glyphs->pix_width);
|
|
345 xfree (glyphs->pix_height);
|
|
346 xfree (glyphs->max_ascent);
|
314
|
347 }
|
|
348 #endif
|
|
349
|
2439
|
350 xfree (glyphs);
|
314
|
351 }
|
|
352
|
|
353 static void
|
764
|
354 remake_frame_glyphs (frame)
|
|
355 FRAME_PTR frame;
|
314
|
356 {
|
764
|
357 if (FRAME_CURRENT_GLYPHS (frame))
|
|
358 free_frame_glyphs (frame, FRAME_CURRENT_GLYPHS (frame));
|
|
359 if (FRAME_DESIRED_GLYPHS (frame))
|
|
360 free_frame_glyphs (frame, FRAME_DESIRED_GLYPHS (frame));
|
|
361 if (FRAME_TEMP_GLYPHS (frame))
|
|
362 free_frame_glyphs (frame, FRAME_TEMP_GLYPHS (frame));
|
314
|
363
|
764
|
364 if (FRAME_MESSAGE_BUF (frame))
|
1872
|
365 {
|
|
366 /* Reallocate the frame's message buffer; remember that
|
|
367 echo_area_glyphs may be pointing here. */
|
|
368 char *old_message_buf = FRAME_MESSAGE_BUF (frame);
|
|
369
|
|
370 FRAME_MESSAGE_BUF (frame)
|
|
371 = (char *) xrealloc (FRAME_MESSAGE_BUF (frame),
|
|
372 FRAME_WIDTH (frame) + 1);
|
|
373
|
|
374 if (echo_area_glyphs == old_message_buf)
|
|
375 echo_area_glyphs = FRAME_MESSAGE_BUF (frame);
|
|
376 if (previous_echo_glyphs == old_message_buf)
|
|
377 previous_echo_glyphs = FRAME_MESSAGE_BUF (frame);
|
|
378 }
|
314
|
379 else
|
764
|
380 FRAME_MESSAGE_BUF (frame)
|
|
381 = (char *) xmalloc (FRAME_WIDTH (frame) + 1);
|
314
|
382
|
764
|
383 FRAME_CURRENT_GLYPHS (frame) = make_frame_glyphs (frame, 0);
|
|
384 FRAME_DESIRED_GLYPHS (frame) = make_frame_glyphs (frame, 0);
|
|
385 FRAME_TEMP_GLYPHS (frame) = make_frame_glyphs (frame, 1);
|
|
386 SET_FRAME_GARBAGED (frame);
|
314
|
387 }
|
|
388
|
764
|
389 /* Return the hash code of contents of line VPOS in frame-matrix M. */
|
314
|
390
|
|
391 static int
|
|
392 line_hash_code (m, vpos)
|
764
|
393 register struct frame_glyphs *m;
|
314
|
394 int vpos;
|
|
395 {
|
|
396 register GLYPH *body, *end;
|
|
397 register int h = 0;
|
|
398
|
|
399 if (!m->enable[vpos])
|
|
400 return 0;
|
|
401
|
1495
|
402 /* Give all highlighted lines the same hash code
|
314
|
403 so as to encourage scrolling to leave them in place. */
|
|
404 if (m->highlight[vpos])
|
|
405 return -1;
|
|
406
|
|
407 body = m->glyphs[vpos];
|
|
408
|
|
409 if (must_write_spaces)
|
|
410 while (1)
|
|
411 {
|
|
412 GLYPH g = *body++;
|
|
413
|
|
414 if (g == 0)
|
|
415 break;
|
|
416 h = (((h << 4) + (h >> 24)) & 0x0fffffff) + g - SPACEGLYPH;
|
|
417 }
|
|
418 else
|
|
419 while (1)
|
|
420 {
|
|
421 GLYPH g = *body++;
|
|
422
|
|
423 if (g == 0)
|
|
424 break;
|
|
425 h = (((h << 4) + (h >> 24)) & 0x0fffffff) + g;
|
|
426 }
|
|
427
|
|
428 if (h)
|
|
429 return h;
|
|
430 return 1;
|
|
431 }
|
|
432
|
|
433 /* Return number of characters in line in M at vpos VPOS,
|
|
434 except don't count leading and trailing spaces
|
|
435 unless the terminal requires those to be explicitly output. */
|
|
436
|
|
437 static unsigned int
|
|
438 line_draw_cost (m, vpos)
|
764
|
439 struct frame_glyphs *m;
|
314
|
440 int vpos;
|
|
441 {
|
|
442 register GLYPH *beg = m->glyphs[vpos];
|
|
443 register GLYPH *end = m->glyphs[vpos] + m->used[vpos];
|
|
444 register int i;
|
|
445 register int tlen = GLYPH_TABLE_LENGTH;
|
|
446 register Lisp_Object *tbase = GLYPH_TABLE_BASE;
|
|
447
|
|
448 /* Ignore trailing and leading spaces if we can. */
|
|
449 if (!must_write_spaces)
|
|
450 {
|
|
451 while ((end != beg) && (*end == SPACEGLYPH))
|
|
452 --end;
|
|
453 if (end == beg)
|
|
454 return (0); /* All blank line. */
|
|
455
|
|
456 while (*beg == SPACEGLYPH)
|
|
457 ++beg;
|
|
458 }
|
|
459
|
|
460 /* If we don't have a glyph-table, each glyph is one character,
|
|
461 so return the number of glyphs. */
|
|
462 if (tbase == 0)
|
|
463 return end - beg;
|
|
464
|
|
465 /* Otherwise, scan the glyphs and accumulate their total size in I. */
|
|
466 i = 0;
|
|
467 while ((beg <= end) && *beg)
|
|
468 {
|
|
469 register GLYPH g = *beg++;
|
|
470
|
|
471 if (GLYPH_SIMPLE_P (tbase, tlen, g))
|
|
472 i += 1;
|
|
473 else
|
|
474 i += GLYPH_LENGTH (tbase, g);
|
|
475 }
|
|
476 return i;
|
|
477 }
|
|
478
|
|
479 /* The functions on this page are the interface from xdisp.c to redisplay.
|
|
480
|
|
481 The only other interface into redisplay is through setting
|
764
|
482 FRAME_CURSOR_X (frame) and FRAME_CURSOR_Y (frame)
|
|
483 and SET_FRAME_GARBAGED (frame). */
|
314
|
484
|
|
485 /* cancel_line eliminates any request to display a line at position `vpos' */
|
|
486
|
764
|
487 cancel_line (vpos, frame)
|
314
|
488 int vpos;
|
764
|
489 register FRAME_PTR frame;
|
314
|
490 {
|
764
|
491 FRAME_DESIRED_GLYPHS (frame)->enable[vpos] = 0;
|
314
|
492 }
|
|
493
|
764
|
494 clear_frame_records (frame)
|
|
495 register FRAME_PTR frame;
|
314
|
496 {
|
764
|
497 bzero (FRAME_CURRENT_GLYPHS (frame)->enable, FRAME_HEIGHT (frame));
|
314
|
498 }
|
|
499
|
|
500 /* Prepare to display on line VPOS starting at HPOS within it. */
|
|
501
|
|
502 void
|
764
|
503 get_display_line (frame, vpos, hpos)
|
|
504 register FRAME_PTR frame;
|
314
|
505 int vpos;
|
|
506 register int hpos;
|
|
507 {
|
764
|
508 register struct frame_glyphs *glyphs;
|
|
509 register struct frame_glyphs *desired_glyphs = FRAME_DESIRED_GLYPHS (frame);
|
314
|
510 register GLYPH *p;
|
|
511
|
1192
|
512 if (vpos < 0)
|
314
|
513 abort ();
|
|
514
|
|
515 if ((desired_glyphs->enable[vpos]) && desired_glyphs->used[vpos] > hpos)
|
|
516 abort ();
|
|
517
|
|
518 if (! desired_glyphs->enable[vpos])
|
|
519 {
|
|
520 desired_glyphs->used[vpos] = 0;
|
|
521 desired_glyphs->highlight[vpos] = 0;
|
|
522 desired_glyphs->enable[vpos] = 1;
|
|
523 }
|
|
524
|
|
525 if (hpos > desired_glyphs->used[vpos])
|
|
526 {
|
|
527 GLYPH *g = desired_glyphs->glyphs[vpos] + desired_glyphs->used[vpos];
|
|
528 GLYPH *end = desired_glyphs->glyphs[vpos] + hpos;
|
|
529
|
|
530 desired_glyphs->used[vpos] = hpos;
|
|
531 while (g != end)
|
|
532 *g++ = SPACEGLYPH;
|
|
533 }
|
|
534 }
|
|
535
|
|
536 /* Like bcopy except never gets confused by overlap. */
|
|
537
|
|
538 void
|
|
539 safe_bcopy (from, to, size)
|
|
540 char *from, *to;
|
|
541 int size;
|
|
542 {
|
1588
|
543 if (size <= 0 || from == to)
|
314
|
544 return;
|
|
545
|
1588
|
546 /* If the source and destination don't overlap, then bcopy can
|
|
547 handle it. If they do overlap, but the destination is lower in
|
|
548 memory than the source, we'll assume bcopy can handle that. */
|
|
549 if (to < from || from + size <= to)
|
|
550 bcopy (from, to, size);
|
|
551
|
|
552 /* Otherwise, we'll copy from the end. */
|
|
553 else
|
314
|
554 {
|
1588
|
555 register char *endf = from + size;
|
|
556 register char *endt = to + size;
|
314
|
557
|
|
558 /* If TO - FROM is large, then we should break the copy into
|
|
559 nonoverlapping chunks of TO - FROM bytes each. However, if
|
|
560 TO - FROM is small, then the bcopy function call overhead
|
|
561 makes this not worth it. The crossover point could be about
|
1588
|
562 anywhere. Since I don't think the obvious copy loop is too
|
|
563 bad, I'm trying to err in its favor. */
|
314
|
564 if (to - from < 64)
|
|
565 {
|
|
566 do
|
|
567 *--endt = *--endf;
|
|
568 while (endf != from);
|
|
569 }
|
|
570 else
|
|
571 {
|
1588
|
572 for (;;)
|
314
|
573 {
|
|
574 endt -= (to - from);
|
|
575 endf -= (to - from);
|
|
576
|
1588
|
577 if (endt < to)
|
|
578 break;
|
|
579
|
314
|
580 bcopy (endf, endt, to - from);
|
|
581 }
|
1588
|
582
|
|
583 /* If SIZE wasn't a multiple of TO - FROM, there will be a
|
314
|
584 little left over. The amount left over is
|
|
585 (endt + (to - from)) - to, which is endt - from. */
|
|
586 bcopy (from, to, endt - from);
|
|
587 }
|
|
588 }
|
|
589 }
|
|
590
|
352
|
591 /* Rotate a vector of SIZE bytes right, by DISTANCE bytes.
|
314
|
592 DISTANCE may be negative. */
|
|
593
|
|
594 static void
|
|
595 rotate_vector (vector, size, distance)
|
|
596 char *vector;
|
|
597 int size;
|
|
598 int distance;
|
|
599 {
|
|
600 char *temp = (char *) alloca (size);
|
|
601
|
|
602 if (distance < 0)
|
|
603 distance += size;
|
|
604
|
|
605 bcopy (vector, temp + distance, size - distance);
|
|
606 bcopy (vector + size - distance, temp, distance);
|
|
607 bcopy (temp, vector, size);
|
|
608 }
|
|
609
|
|
610 /* Scroll lines from vpos FROM up to but not including vpos END
|
|
611 down by AMOUNT lines (AMOUNT may be negative).
|
|
612 Returns nonzero if done, zero if terminal cannot scroll them. */
|
|
613
|
|
614 int
|
6627
f8471ecf787b
(make_frame_glyphs): If EMPTY, don't leave junk in ->total_charstarts.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
615 scroll_frame_lines (frame, from, end, amount, newpos)
|
764
|
616 register FRAME_PTR frame;
|
6627
f8471ecf787b
(make_frame_glyphs): If EMPTY, don't leave junk in ->total_charstarts.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
617 int from, end, amount, newpos;
|
314
|
618 {
|
|
619 register int i;
|
764
|
620 register struct frame_glyphs *current_frame
|
|
621 = FRAME_CURRENT_GLYPHS (frame);
|
6627
f8471ecf787b
(make_frame_glyphs): If EMPTY, don't leave junk in ->total_charstarts.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
622 int pos_adjust;
|
6642
|
623 int width = FRAME_WIDTH (frame);
|
314
|
624
|
|
625 if (!line_ins_del_ok)
|
|
626 return 0;
|
|
627
|
|
628 if (amount == 0)
|
|
629 return 1;
|
|
630
|
|
631 if (amount > 0)
|
|
632 {
|
764
|
633 update_begin (frame);
|
314
|
634 set_terminal_window (end + amount);
|
|
635 if (!scroll_region_ok)
|
|
636 ins_del_lines (end, -amount);
|
|
637 ins_del_lines (from, amount);
|
|
638 set_terminal_window (0);
|
|
639
|
764
|
640 rotate_vector (current_frame->glyphs + from,
|
314
|
641 sizeof (GLYPH *) * (end + amount - from),
|
|
642 amount * sizeof (GLYPH *));
|
|
643
|
6617
|
644 rotate_vector (current_frame->charstarts + from,
|
6627
f8471ecf787b
(make_frame_glyphs): If EMPTY, don't leave junk in ->total_charstarts.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
645 sizeof (int *) * (end + amount - from),
|
f8471ecf787b
(make_frame_glyphs): If EMPTY, don't leave junk in ->total_charstarts.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
646 amount * sizeof (int *));
|
f8471ecf787b
(make_frame_glyphs): If EMPTY, don't leave junk in ->total_charstarts.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
647
|
764
|
648 safe_bcopy (current_frame->used + from,
|
|
649 current_frame->used + from + amount,
|
|
650 (end - from) * sizeof current_frame->used[0]);
|
314
|
651
|
764
|
652 safe_bcopy (current_frame->highlight + from,
|
|
653 current_frame->highlight + from + amount,
|
|
654 (end - from) * sizeof current_frame->highlight[0]);
|
314
|
655
|
764
|
656 safe_bcopy (current_frame->enable + from,
|
|
657 current_frame->enable + from + amount,
|
|
658 (end - from) * sizeof current_frame->enable[0]);
|
314
|
659
|
6642
|
660 /* Adjust the lines by an amount
|
|
661 that puts the first of them at NEWPOS. */
|
|
662 pos_adjust = newpos - current_frame->charstarts[from + amount][0];
|
|
663
|
|
664 /* Offset each char position in the charstarts lines we moved
|
|
665 by pos_adjust. */
|
|
666 for (i = from + amount; i < end + amount; i++)
|
|
667 {
|
|
668 int *line = current_frame->charstarts[i];
|
|
669 int col;
|
|
670 for (col = 0; col < width; col++)
|
|
671 if (line[col] > 0)
|
|
672 line[col] += pos_adjust;
|
|
673 }
|
|
674 for (i = from; i < from + amount; i++)
|
|
675 {
|
|
676 int *line = current_frame->charstarts[i];
|
|
677 int col;
|
|
678 line[0] = -1;
|
|
679 for (col = 0; col < width; col++)
|
|
680 line[col] = 0;
|
|
681 }
|
|
682
|
314
|
683 /* Mark the lines made empty by scrolling as enabled, empty and
|
|
684 normal video. */
|
764
|
685 bzero (current_frame->used + from,
|
|
686 amount * sizeof current_frame->used[0]);
|
|
687 bzero (current_frame->highlight + from,
|
|
688 amount * sizeof current_frame->highlight[0]);
|
314
|
689 for (i = from; i < from + amount; i++)
|
|
690 {
|
764
|
691 current_frame->glyphs[i][0] = '\0';
|
6617
|
692 current_frame->charstarts[i][0] = -1;
|
764
|
693 current_frame->enable[i] = 1;
|
314
|
694 }
|
|
695
|
764
|
696 safe_bcopy (current_frame->bufp + from,
|
|
697 current_frame->bufp + from + amount,
|
|
698 (end - from) * sizeof current_frame->bufp[0]);
|
314
|
699
|
|
700 #ifdef HAVE_X_WINDOWS
|
960
|
701 if (FRAME_X_P (frame))
|
314
|
702 {
|
764
|
703 safe_bcopy (current_frame->top_left_x + from,
|
|
704 current_frame->top_left_x + from + amount,
|
|
705 (end - from) * sizeof current_frame->top_left_x[0]);
|
314
|
706
|
764
|
707 safe_bcopy (current_frame->top_left_y + from,
|
|
708 current_frame->top_left_y + from + amount,
|
|
709 (end - from) * sizeof current_frame->top_left_y[0]);
|
314
|
710
|
764
|
711 safe_bcopy (current_frame->pix_width + from,
|
|
712 current_frame->pix_width + from + amount,
|
|
713 (end - from) * sizeof current_frame->pix_width[0]);
|
314
|
714
|
764
|
715 safe_bcopy (current_frame->pix_height + from,
|
|
716 current_frame->pix_height + from + amount,
|
|
717 (end - from) * sizeof current_frame->pix_height[0]);
|
1407
0f214040f708
* dispnew.c (scroll_frame_lines): All references to frame elements
Joseph Arceneaux <jla@gnu.org>
diff
changeset
|
718
|
0f214040f708
* dispnew.c (scroll_frame_lines): All references to frame elements
Joseph Arceneaux <jla@gnu.org>
diff
changeset
|
719 safe_bcopy (current_frame->max_ascent + from,
|
0f214040f708
* dispnew.c (scroll_frame_lines): All references to frame elements
Joseph Arceneaux <jla@gnu.org>
diff
changeset
|
720 current_frame->max_ascent + from + amount,
|
0f214040f708
* dispnew.c (scroll_frame_lines): All references to frame elements
Joseph Arceneaux <jla@gnu.org>
diff
changeset
|
721 (end - from) * sizeof current_frame->max_ascent[0]);
|
314
|
722 }
|
|
723 #endif /* HAVE_X_WINDOWS */
|
|
724
|
764
|
725 update_end (frame);
|
314
|
726 }
|
|
727 if (amount < 0)
|
|
728 {
|
764
|
729 update_begin (frame);
|
314
|
730 set_terminal_window (end);
|
|
731 ins_del_lines (from + amount, amount);
|
|
732 if (!scroll_region_ok)
|
|
733 ins_del_lines (end + amount, -amount);
|
|
734 set_terminal_window (0);
|
|
735
|
764
|
736 rotate_vector (current_frame->glyphs + from + amount,
|
314
|
737 sizeof (GLYPH *) * (end - from - amount),
|
|
738 amount * sizeof (GLYPH *));
|
|
739
|
6617
|
740 rotate_vector (current_frame->charstarts + from + amount,
|
6627
f8471ecf787b
(make_frame_glyphs): If EMPTY, don't leave junk in ->total_charstarts.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
741 sizeof (int *) * (end - from - amount),
|
f8471ecf787b
(make_frame_glyphs): If EMPTY, don't leave junk in ->total_charstarts.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
742 amount * sizeof (int *));
|
f8471ecf787b
(make_frame_glyphs): If EMPTY, don't leave junk in ->total_charstarts.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
743
|
764
|
744 safe_bcopy (current_frame->used + from,
|
|
745 current_frame->used + from + amount,
|
|
746 (end - from) * sizeof current_frame->used[0]);
|
314
|
747
|
764
|
748 safe_bcopy (current_frame->highlight + from,
|
|
749 current_frame->highlight + from + amount,
|
|
750 (end - from) * sizeof current_frame->highlight[0]);
|
314
|
751
|
764
|
752 safe_bcopy (current_frame->enable + from,
|
|
753 current_frame->enable + from + amount,
|
|
754 (end - from) * sizeof current_frame->enable[0]);
|
314
|
755
|
6642
|
756 /* Adjust the lines by an amount
|
|
757 that puts the first of them at NEWPOS. */
|
|
758 pos_adjust = newpos - current_frame->charstarts[from + amount][0];
|
|
759
|
|
760 /* Offset each char position in the charstarts lines we moved
|
|
761 by pos_adjust. */
|
|
762 for (i = from + amount; i < end + amount; i++)
|
|
763 {
|
|
764 int *line = current_frame->charstarts[i];
|
|
765 int col;
|
|
766 for (col = 0; col < width; col++)
|
|
767 if (line[col] > 0)
|
|
768 line[col] += pos_adjust;
|
|
769 }
|
|
770 for (i = end + amount; i < end; i++)
|
|
771 {
|
|
772 int *line = current_frame->charstarts[i];
|
|
773 int col;
|
|
774 line[0] = -1;
|
|
775 for (col = 0; col < width; col++)
|
|
776 line[col] = 0;
|
|
777 }
|
|
778
|
314
|
779 /* Mark the lines made empty by scrolling as enabled, empty and
|
|
780 normal video. */
|
764
|
781 bzero (current_frame->used + end + amount,
|
|
782 - amount * sizeof current_frame->used[0]);
|
|
783 bzero (current_frame->highlight + end + amount,
|
|
784 - amount * sizeof current_frame->highlight[0]);
|
314
|
785 for (i = end + amount; i < end; i++)
|
|
786 {
|
764
|
787 current_frame->glyphs[i][0] = '\0';
|
6617
|
788 current_frame->charstarts[i][0] = 0;
|
764
|
789 current_frame->enable[i] = 1;
|
314
|
790 }
|
|
791
|
764
|
792 safe_bcopy (current_frame->bufp + from,
|
|
793 current_frame->bufp + from + amount,
|
|
794 (end - from) * sizeof current_frame->bufp[0]);
|
314
|
795
|
|
796 #ifdef HAVE_X_WINDOWS
|
960
|
797 if (FRAME_X_P (frame))
|
314
|
798 {
|
764
|
799 safe_bcopy (current_frame->top_left_x + from,
|
|
800 current_frame->top_left_x + from + amount,
|
|
801 (end - from) * sizeof current_frame->top_left_x[0]);
|
314
|
802
|
764
|
803 safe_bcopy (current_frame->top_left_y + from,
|
|
804 current_frame->top_left_y + from + amount,
|
|
805 (end - from) * sizeof current_frame->top_left_y[0]);
|
314
|
806
|
764
|
807 safe_bcopy (current_frame->pix_width + from,
|
|
808 current_frame->pix_width + from + amount,
|
|
809 (end - from) * sizeof current_frame->pix_width[0]);
|
314
|
810
|
764
|
811 safe_bcopy (current_frame->pix_height + from,
|
|
812 current_frame->pix_height + from + amount,
|
|
813 (end - from) * sizeof current_frame->pix_height[0]);
|
1407
0f214040f708
* dispnew.c (scroll_frame_lines): All references to frame elements
Joseph Arceneaux <jla@gnu.org>
diff
changeset
|
814
|
0f214040f708
* dispnew.c (scroll_frame_lines): All references to frame elements
Joseph Arceneaux <jla@gnu.org>
diff
changeset
|
815 safe_bcopy (current_frame->max_ascent + from,
|
0f214040f708
* dispnew.c (scroll_frame_lines): All references to frame elements
Joseph Arceneaux <jla@gnu.org>
diff
changeset
|
816 current_frame->max_ascent + from + amount,
|
0f214040f708
* dispnew.c (scroll_frame_lines): All references to frame elements
Joseph Arceneaux <jla@gnu.org>
diff
changeset
|
817 (end - from) * sizeof current_frame->max_ascent[0]);
|
314
|
818 }
|
|
819 #endif /* HAVE_X_WINDOWS */
|
|
820
|
764
|
821 update_end (frame);
|
314
|
822 }
|
|
823 return 1;
|
|
824 }
|
|
825
|
764
|
826 /* After updating a window W that isn't the full frame wide,
|
314
|
827 copy all the columns that W does not occupy
|
764
|
828 into the FRAME_DESIRED_GLYPHS (frame) from the FRAME_PHYS_GLYPHS (frame)
|
|
829 so that update_frame will not change those columns. */
|
314
|
830
|
|
831 preserve_other_columns (w)
|
|
832 struct window *w;
|
|
833 {
|
|
834 register int vpos;
|
764
|
835 register struct frame_glyphs *current_frame, *desired_frame;
|
|
836 register FRAME_PTR frame = XFRAME (w->frame);
|
314
|
837 int start = XFASTINT (w->left);
|
|
838 int end = XFASTINT (w->left) + XFASTINT (w->width);
|
|
839 int bot = XFASTINT (w->top) + XFASTINT (w->height);
|
|
840
|
764
|
841 current_frame = FRAME_CURRENT_GLYPHS (frame);
|
|
842 desired_frame = FRAME_DESIRED_GLYPHS (frame);
|
314
|
843
|
|
844 for (vpos = XFASTINT (w->top); vpos < bot; vpos++)
|
|
845 {
|
764
|
846 if (current_frame->enable[vpos] && desired_frame->enable[vpos])
|
314
|
847 {
|
|
848 if (start > 0)
|
|
849 {
|
|
850 int len;
|
|
851
|
764
|
852 bcopy (current_frame->glyphs[vpos],
|
2930
|
853 desired_frame->glyphs[vpos],
|
|
854 start * sizeof (current_frame->glyphs[vpos]));
|
6617
|
855 bcopy (current_frame->charstarts[vpos],
|
|
856 desired_frame->charstarts[vpos],
|
|
857 start * sizeof (current_frame->charstarts[vpos]));
|
764
|
858 len = min (start, current_frame->used[vpos]);
|
|
859 if (desired_frame->used[vpos] < len)
|
|
860 desired_frame->used[vpos] = len;
|
314
|
861 }
|
764
|
862 if (current_frame->used[vpos] > end
|
|
863 && desired_frame->used[vpos] < current_frame->used[vpos])
|
314
|
864 {
|
764
|
865 while (desired_frame->used[vpos] < end)
|
6617
|
866 {
|
|
867 int used = desired_frame->used[vpos]++;
|
|
868 desired_frame->glyphs[vpos][used] = SPACEGLYPH;
|
|
869 desired_frame->glyphs[vpos][used] = 0;
|
|
870 }
|
764
|
871 bcopy (current_frame->glyphs[vpos] + end,
|
|
872 desired_frame->glyphs[vpos] + end,
|
2930
|
873 ((current_frame->used[vpos] - end)
|
|
874 * sizeof (current_frame->glyphs[vpos])));
|
6617
|
875 bcopy (current_frame->charstarts[vpos] + end,
|
|
876 desired_frame->charstarts[vpos] + end,
|
|
877 ((current_frame->used[vpos] - end)
|
|
878 * sizeof (current_frame->charstarts[vpos])));
|
764
|
879 desired_frame->used[vpos] = current_frame->used[vpos];
|
314
|
880 }
|
|
881 }
|
|
882 }
|
|
883 }
|
|
884
|
|
885 #if 0
|
|
886
|
764
|
887 /* If window w does not need to be updated and isn't the full frame wide,
|
314
|
888 copy all the columns that w does occupy
|
764
|
889 into the FRAME_DESIRED_LINES (frame) from the FRAME_PHYS_LINES (frame)
|
|
890 so that update_frame will not change those columns.
|
314
|
891
|
|
892 Have not been able to figure out how to use this correctly. */
|
|
893
|
|
894 preserve_my_columns (w)
|
|
895 struct window *w;
|
|
896 {
|
|
897 register int vpos, fin;
|
764
|
898 register struct frame_glyphs *l1, *l2;
|
|
899 register FRAME_PTR frame = XFRAME (w->frame);
|
314
|
900 int start = XFASTINT (w->left);
|
|
901 int end = XFASTINT (w->left) + XFASTINT (w->width);
|
|
902 int bot = XFASTINT (w->top) + XFASTINT (w->height);
|
|
903
|
|
904 for (vpos = XFASTINT (w->top); vpos < bot; vpos++)
|
|
905 {
|
764
|
906 if ((l1 = FRAME_DESIRED_GLYPHS (frame)->glyphs[vpos + 1])
|
|
907 && (l2 = FRAME_PHYS_GLYPHS (frame)->glyphs[vpos + 1]))
|
314
|
908 {
|
|
909 if (l2->length > start && l1->length < l2->length)
|
|
910 {
|
|
911 fin = l2->length;
|
|
912 if (fin > end) fin = end;
|
|
913 while (l1->length < start)
|
|
914 l1->body[l1->length++] = ' ';
|
|
915 bcopy (l2->body + start, l1->body + start, fin - start);
|
|
916 l1->length = fin;
|
|
917 }
|
|
918 }
|
|
919 }
|
|
920 }
|
|
921
|
|
922 #endif
|
|
923
|
6620
|
924 /* Adjust by ADJUST the charstart values in window W
|
6642
|
925 after vpos VPOS, which counts relative to the frame
|
6620
|
926 (not relative to W itself). */
|
|
927
|
|
928 void
|
|
929 adjust_window_charstarts (w, vpos, adjust)
|
|
930 struct window *w;
|
|
931 int vpos;
|
|
932 int adjust;
|
|
933 {
|
|
934 int left = XFASTINT (w->left);
|
|
935 int top = XFASTINT (w->top);
|
6642
|
936 int right = left + window_internal_width (w);
|
|
937 int bottom = top + window_internal_height (w);
|
6620
|
938 int i;
|
|
939
|
6642
|
940 for (i = vpos + 1; i < bottom; i++)
|
6620
|
941 {
|
|
942 int *charstart
|
|
943 = FRAME_CURRENT_GLYPHS (XFRAME (WINDOW_FRAME (w)))->charstarts[i];
|
|
944 int j;
|
|
945 for (j = left; j < right; j++)
|
|
946 if (charstart[j] > 0)
|
|
947 charstart[j] += adjust;
|
|
948 }
|
|
949 }
|
6642
|
950
|
6682
|
951 /* Check the charstarts values in the area of window W
|
|
952 for internal consistency. We cannot check that they are "right";
|
|
953 we can only look for something nonsensical. */
|
|
954
|
6642
|
955 verify_charstarts (w)
|
|
956 struct window *w;
|
|
957 {
|
|
958 FRAME_PTR f = XFRAME (WINDOW_FRAME (w));
|
|
959 int i;
|
|
960 int top = XFASTINT (w->top);
|
|
961 int bottom = top + window_internal_height (w);
|
|
962 int left = XFASTINT (w->left);
|
|
963 int right = left + window_internal_width (w);
|
|
964 int next_line;
|
6682
|
965 int truncate = (XINT (w->hscroll)
|
|
966 || (truncate_partial_width_windows
|
|
967 && (XFASTINT (w->width) < FRAME_WIDTH (f)))
|
|
968 || !NILP (XBUFFER (w->buffer)->truncate_lines));
|
6642
|
969
|
|
970 for (i = top; i < bottom; i++)
|
|
971 {
|
|
972 int j;
|
|
973 int last;
|
6682
|
974 int *charstart = FRAME_CURRENT_GLYPHS (f)->charstarts[i];
|
6642
|
975
|
|
976 if (i != top)
|
6682
|
977 {
|
|
978 if (truncate)
|
|
979 {
|
|
980 /* If we are truncating lines, allow a jump
|
|
981 in charstarts from one line to the next. */
|
|
982 if (charstart[left] < next_line)
|
|
983 abort ();
|
|
984 }
|
|
985 else
|
|
986 {
|
|
987 if (charstart[left] != next_line)
|
|
988 abort ();
|
|
989 }
|
|
990 }
|
6642
|
991
|
|
992 for (j = left; j < right; j++)
|
|
993 if (charstart[j] > 0)
|
|
994 last = charstart[j];
|
6645
|
995 /* Record where the next line should start. */
|
|
996 next_line = last;
|
|
997 if (BUF_ZV (XBUFFER (w->buffer)) != last)
|
|
998 {
|
|
999 /* If there's a newline between the two lines, count that. */
|
|
1000 int endchar = *BUF_CHAR_ADDRESS (XBUFFER (w->buffer), last);
|
|
1001 if (endchar == '\n')
|
|
1002 next_line++;
|
|
1003 }
|
6642
|
1004 }
|
|
1005 }
|
6620
|
1006
|
314
|
1007 /* On discovering that the redisplay for a window was no good,
|
|
1008 cancel the columns of that window, so that when the window is
|
|
1009 displayed over again get_display_line will not complain. */
|
|
1010
|
|
1011 cancel_my_columns (w)
|
|
1012 struct window *w;
|
|
1013 {
|
|
1014 register int vpos;
|
6617
|
1015 register struct frame_glyphs *desired_glyphs
|
|
1016 = FRAME_DESIRED_GLYPHS (XFRAME (w->frame));
|
314
|
1017 register int start = XFASTINT (w->left);
|
|
1018 register int bot = XFASTINT (w->top) + XFASTINT (w->height);
|
|
1019
|
|
1020 for (vpos = XFASTINT (w->top); vpos < bot; vpos++)
|
|
1021 if (desired_glyphs->enable[vpos]
|
|
1022 && desired_glyphs->used[vpos] >= start)
|
|
1023 desired_glyphs->used[vpos] = start;
|
|
1024 }
|
|
1025
|
764
|
1026 /* These functions try to perform directly and immediately on the frame
|
314
|
1027 the necessary output for one change in the buffer.
|
|
1028 They may return 0 meaning nothing was done if anything is difficult,
|
|
1029 or 1 meaning the output was performed properly.
|
764
|
1030 They assume that the frame was up to date before the buffer
|
1495
|
1031 change being displayed. They make various other assumptions too;
|
314
|
1032 see command_loop_1 where these are called. */
|
|
1033
|
|
1034 int
|
|
1035 direct_output_for_insert (g)
|
|
1036 int g;
|
|
1037 {
|
764
|
1038 register FRAME_PTR frame = selected_frame;
|
|
1039 register struct frame_glyphs *current_frame
|
|
1040 = FRAME_CURRENT_GLYPHS (frame);
|
314
|
1041
|
|
1042 #ifndef COMPILER_REGISTER_BUG
|
|
1043 register
|
|
1044 #endif /* COMPILER_REGISTER_BUG */
|
|
1045 struct window *w = XWINDOW (selected_window);
|
|
1046 #ifndef COMPILER_REGISTER_BUG
|
|
1047 register
|
|
1048 #endif /* COMPILER_REGISTER_BUG */
|
764
|
1049 int hpos = FRAME_CURSOR_X (frame);
|
314
|
1050 #ifndef COMPILER_REGISTER_BUG
|
|
1051 register
|
|
1052 #endif /* COMPILER_REGISTER_BUG */
|
764
|
1053 int vpos = FRAME_CURSOR_Y (frame);
|
314
|
1054
|
1777
|
1055 /* Give up if about to continue line. */
|
|
1056 if (hpos >= XFASTINT (w->left) + window_internal_width (w) - 1
|
|
1057
|
314
|
1058 /* Avoid losing if cursor is in invisible text off left margin */
|
|
1059 || (XINT (w->hscroll) && hpos == XFASTINT (w->left))
|
|
1060
|
|
1061 /* Give up if cursor outside window (in minibuf, probably) */
|
1042
|
1062 || cursor_in_echo_area
|
764
|
1063 || FRAME_CURSOR_Y (frame) < XFASTINT (w->top)
|
|
1064 || FRAME_CURSOR_Y (frame) >= XFASTINT (w->top) + XFASTINT (w->height)
|
314
|
1065
|
764
|
1066 /* Give up if cursor not really at FRAME_CURSOR_X, FRAME_CURSOR_Y */
|
314
|
1067 || !display_completed
|
|
1068
|
|
1069 /* Give up if buffer appears in two places. */
|
|
1070 || buffer_shared > 1
|
|
1071
|
4384
|
1072 #ifdef USE_TEXT_PROPERTIES
|
|
1073 /* Intervals have already been adjusted, point is after the
|
|
1074 character that was just inserted. */
|
6068
|
1075 /* Give up if character is invisible. */
|
4384
|
1076 /* Give up if character has a face property.
|
|
1077 At the moment we only lose at end of line or end of buffer
|
|
1078 and only with faces that have some background */
|
|
1079 /* Instead of wasting time, give up if character has any text properties */
|
|
1080 || ! NILP (Ftext_properties_at (XFASTINT (point - 1), Qnil))
|
|
1081 #endif
|
|
1082
|
314
|
1083 /* Give up if w is minibuffer and a message is being displayed there */
|
|
1084 || (MINI_WINDOW_P (w) && echo_area_glyphs))
|
|
1085 return 0;
|
|
1086
|
2778
|
1087 {
|
|
1088 #ifdef HAVE_X_WINDOWS
|
|
1089 int dummy;
|
5083
|
1090 int face = compute_char_face (frame, w, point - 1, -1, -1, &dummy, point);
|
2778
|
1091 #endif
|
6414
|
1092 current_frame->glyphs[vpos][hpos] = MAKE_GLYPH (frame, g, face);
|
6648
c7eefaee311c
(direct_output_for_insert): Add charstarts entry after the new char.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1093 current_frame->charstarts[vpos][hpos] = point - 1;
|
c7eefaee311c
(direct_output_for_insert): Add charstarts entry after the new char.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1094 /* Record the entry for after the newly inserted character. */
|
c7eefaee311c
(direct_output_for_insert): Add charstarts entry after the new char.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1095 current_frame->charstarts[vpos][hpos + 1] = point;
|
6620
|
1096 adjust_window_charstarts (w, vpos, 1);
|
2778
|
1097 }
|
314
|
1098 unchanged_modified = MODIFF;
|
|
1099 beg_unchanged = GPT - BEG;
|
|
1100 XFASTINT (w->last_point) = point;
|
|
1101 XFASTINT (w->last_point_x) = hpos;
|
|
1102 XFASTINT (w->last_modified) = MODIFF;
|
|
1103
|
|
1104 reassert_line_highlight (0, vpos);
|
764
|
1105 write_glyphs (¤t_frame->glyphs[vpos][hpos], 1);
|
314
|
1106 fflush (stdout);
|
764
|
1107 ++FRAME_CURSOR_X (frame);
|
|
1108 if (hpos == current_frame->used[vpos])
|
314
|
1109 {
|
764
|
1110 current_frame->used[vpos] = hpos + 1;
|
|
1111 current_frame->glyphs[vpos][hpos + 1] = 0;
|
314
|
1112 }
|
|
1113
|
|
1114 return 1;
|
|
1115 }
|
|
1116
|
|
1117 int
|
|
1118 direct_output_forward_char (n)
|
|
1119 int n;
|
|
1120 {
|
764
|
1121 register FRAME_PTR frame = selected_frame;
|
314
|
1122 register struct window *w = XWINDOW (selected_window);
|
4384
|
1123 int position;
|
5223
|
1124 int hpos = FRAME_CURSOR_X (frame);
|
|
1125
|
|
1126 /* Give up if in truncated text at end of line. */
|
|
1127 if (hpos >= XFASTINT (w->left) + window_internal_width (w) - 1)
|
|
1128 return 0;
|
|
1129
|
543
|
1130 /* Avoid losing if cursor is in invisible text off left margin
|
|
1131 or about to go off either side of window. */
|
764
|
1132 if ((FRAME_CURSOR_X (frame) == XFASTINT (w->left)
|
543
|
1133 && (XINT (w->hscroll) || n < 0))
|
|
1134 || (n > 0
|
1777
|
1135 && (FRAME_CURSOR_X (frame) + 1 >= window_internal_width (w) - 1))
|
1042
|
1136 || cursor_in_echo_area)
|
314
|
1137 return 0;
|
4384
|
1138
|
2794
|
1139 /* Can't use direct output if highlighting a region. */
|
|
1140 if (!NILP (Vtransient_mark_mode) && !NILP (current_buffer->mark_active))
|
|
1141 return 0;
|
|
1142
|
4384
|
1143 #ifdef USE_TEXT_PROPERTIES
|
|
1144 /* Don't use direct output next to an invisible character
|
|
1145 since we might need to do something special. */
|
|
1146
|
4551
|
1147 XFASTINT (position) = point;
|
|
1148 if (XFASTINT (position) < ZV
|
6069
07045ca8ff19
(direct_output_forward_char): Use Fget_char_property to test for invisibility.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1149 && ! NILP (Fget_char_property (position,
|
4551
|
1150 Qinvisible,
|
6069
07045ca8ff19
(direct_output_forward_char): Use Fget_char_property to test for invisibility.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1151 selected_window)))
|
07045ca8ff19
(direct_output_forward_char): Use Fget_char_property to test for invisibility.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1152 return 0;
|
4384
|
1153
|
4551
|
1154 XFASTINT (position) = point - 1;
|
|
1155 if (XFASTINT (position) >= BEGV
|
6069
07045ca8ff19
(direct_output_forward_char): Use Fget_char_property to test for invisibility.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1156 && ! NILP (Fget_char_property (position,
|
4551
|
1157 Qinvisible,
|
6069
07045ca8ff19
(direct_output_forward_char): Use Fget_char_property to test for invisibility.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1158 selected_window)))
|
07045ca8ff19
(direct_output_forward_char): Use Fget_char_property to test for invisibility.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1159 return 0;
|
4384
|
1160 #endif
|
|
1161
|
764
|
1162 FRAME_CURSOR_X (frame) += n;
|
|
1163 XFASTINT (w->last_point_x) = FRAME_CURSOR_X (frame);
|
314
|
1164 XFASTINT (w->last_point) = point;
|
764
|
1165 cursor_to (FRAME_CURSOR_Y (frame), FRAME_CURSOR_X (frame));
|
314
|
1166 fflush (stdout);
|
4384
|
1167
|
314
|
1168 return 1;
|
|
1169 }
|
|
1170
|
|
1171 static void update_line ();
|
|
1172
|
764
|
1173 /* Update frame F based on the data in FRAME_DESIRED_GLYPHS.
|
314
|
1174 Value is nonzero if redisplay stopped due to pending input.
|
|
1175 FORCE nonzero means do not stop for pending input. */
|
|
1176
|
|
1177 int
|
764
|
1178 update_frame (f, force, inhibit_hairy_id)
|
|
1179 FRAME_PTR f;
|
314
|
1180 int force;
|
|
1181 int inhibit_hairy_id;
|
|
1182 {
|
7179
cb958b7d5fe1
(update_frame): Move assignments to current_frame and desired_frame.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1183 register struct frame_glyphs *current_frame;
|
7188
|
1184 register struct frame_glyphs *desired_frame = 0;
|
314
|
1185 register int i;
|
|
1186 int pause;
|
|
1187 int preempt_count = baud_rate / 2400 + 1;
|
|
1188 extern input_pending;
|
|
1189 #ifdef HAVE_X_WINDOWS
|
|
1190 register int downto, leftmost;
|
|
1191 #endif
|
|
1192
|
3357
|
1193 if (preempt_count <= 0)
|
|
1194 preempt_count = 1;
|
|
1195
|
764
|
1196 if (FRAME_HEIGHT (f) == 0) abort (); /* Some bug zeros some core */
|
314
|
1197
|
|
1198 detect_input_pending ();
|
|
1199 if (input_pending && !force)
|
|
1200 {
|
|
1201 pause = 1;
|
|
1202 goto do_pause;
|
|
1203 }
|
|
1204
|
764
|
1205 update_begin (f);
|
314
|
1206
|
|
1207 if (!line_ins_del_ok)
|
|
1208 inhibit_hairy_id = 1;
|
|
1209
|
7188
|
1210 /* These are separate to avoid a possible bug in the AIX C compiler. */
|
|
1211 current_frame = FRAME_CURRENT_GLYPHS (f);
|
|
1212 desired_frame = FRAME_DESIRED_GLYPHS (f);
|
|
1213
|
493
|
1214 /* See if any of the desired lines are enabled; don't compute for
|
|
1215 i/d line if just want cursor motion. */
|
764
|
1216 for (i = 0; i < FRAME_HEIGHT (f); i++)
|
|
1217 if (desired_frame->enable[i])
|
314
|
1218 break;
|
|
1219
|
|
1220 /* Try doing i/d line, if not yet inhibited. */
|
764
|
1221 if (!inhibit_hairy_id && i < FRAME_HEIGHT (f))
|
|
1222 force |= scrolling (f);
|
314
|
1223
|
|
1224 /* Update the individual lines as needed. Do bottom line first. */
|
|
1225
|
764
|
1226 if (desired_frame->enable[FRAME_HEIGHT (f) - 1])
|
|
1227 update_line (f, FRAME_HEIGHT (f) - 1);
|
314
|
1228
|
|
1229 #ifdef HAVE_X_WINDOWS
|
960
|
1230 if (FRAME_X_P (f))
|
314
|
1231 {
|
764
|
1232 leftmost = downto = f->display.x->internal_border_width;
|
|
1233 if (desired_frame->enable[0])
|
314
|
1234 {
|
764
|
1235 current_frame->top_left_x[FRAME_HEIGHT (f) - 1] = leftmost;
|
|
1236 current_frame->top_left_y[FRAME_HEIGHT (f) - 1]
|
|
1237 = PIXEL_HEIGHT (f) - f->display.x->internal_border_width
|
1407
0f214040f708
* dispnew.c (scroll_frame_lines): All references to frame elements
Joseph Arceneaux <jla@gnu.org>
diff
changeset
|
1238 - current_frame->pix_height[FRAME_HEIGHT (f) - 1];
|
764
|
1239 current_frame->top_left_x[0] = leftmost;
|
|
1240 current_frame->top_left_y[0] = downto;
|
314
|
1241 }
|
|
1242 }
|
|
1243 #endif /* HAVE_X_WINDOWS */
|
|
1244
|
|
1245 /* Now update the rest of the lines. */
|
764
|
1246 for (i = 0; i < FRAME_HEIGHT (f) - 1 && (force || !input_pending); i++)
|
314
|
1247 {
|
764
|
1248 if (desired_frame->enable[i])
|
314
|
1249 {
|
960
|
1250 if (FRAME_TERMCAP_P (f))
|
314
|
1251 {
|
|
1252 /* Flush out every so many lines.
|
|
1253 Also flush out if likely to have more than 1k buffered
|
|
1254 otherwise. I'm told that some telnet connections get
|
|
1255 really screwed by more than 1k output at once. */
|
|
1256 int outq = PENDING_OUTPUT_COUNT (stdout);
|
|
1257 if (outq > 900
|
|
1258 || (outq > 20 && ((i - 1) % preempt_count == 0)))
|
|
1259 {
|
|
1260 fflush (stdout);
|
|
1261 if (preempt_count == 1)
|
|
1262 {
|
554
|
1263 #ifdef EMACS_OUTQSIZE
|
|
1264 if (EMACS_OUTQSIZE (0, &outq) < 0)
|
314
|
1265 /* Probably not a tty. Ignore the error and reset
|
|
1266 * the outq count. */
|
|
1267 outq = PENDING_OUTPUT_COUNT (stdout);
|
|
1268 #endif
|
|
1269 outq *= 10;
|
7530
|
1270 if (baud_rate <= outq && baud_rate > 0)
|
3357
|
1271 sleep (outq / baud_rate);
|
314
|
1272 }
|
|
1273 }
|
|
1274 if ((i - 1) % preempt_count == 0)
|
|
1275 detect_input_pending ();
|
|
1276 }
|
|
1277
|
764
|
1278 update_line (f, i);
|
314
|
1279 #ifdef HAVE_X_WINDOWS
|
960
|
1280 if (FRAME_X_P (f))
|
314
|
1281 {
|
764
|
1282 current_frame->top_left_y[i] = downto;
|
|
1283 current_frame->top_left_x[i] = leftmost;
|
314
|
1284 }
|
|
1285 #endif /* HAVE_X_WINDOWS */
|
|
1286 }
|
|
1287
|
732
|
1288 #ifdef HAVE_X_WINDOWS
|
960
|
1289 if (FRAME_X_P (f))
|
1407
0f214040f708
* dispnew.c (scroll_frame_lines): All references to frame elements
Joseph Arceneaux <jla@gnu.org>
diff
changeset
|
1290 downto += current_frame->pix_height[i];
|
732
|
1291 #endif
|
314
|
1292 }
|
764
|
1293 pause = (i < FRAME_HEIGHT (f) - 1) ? i : 0;
|
314
|
1294
|
|
1295 /* Now just clean up termcap drivers and set cursor, etc. */
|
|
1296 if (!pause)
|
|
1297 {
|
1042
|
1298 if (cursor_in_echo_area
|
|
1299 && FRAME_HAS_MINIBUF_P (f))
|
708
|
1300 {
|
1042
|
1301 int top = XINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top);
|
|
1302 int row, col;
|
|
1303
|
|
1304 if (cursor_in_echo_area < 0)
|
|
1305 {
|
|
1306 row = top;
|
|
1307 col = 0;
|
|
1308 }
|
708
|
1309 else
|
1042
|
1310 {
|
|
1311 /* If the minibuffer is several lines high, find the last
|
|
1312 line that has any text on it. */
|
|
1313 row = FRAME_HEIGHT (f);
|
|
1314 do
|
|
1315 {
|
|
1316 row--;
|
|
1317 if (current_frame->enable[row])
|
|
1318 col = current_frame->used[row];
|
|
1319 else
|
|
1320 col = 0;
|
|
1321 }
|
|
1322 while (row > top && col == 0);
|
|
1323
|
|
1324 if (col >= FRAME_WIDTH (f))
|
|
1325 {
|
|
1326 col = 0;
|
|
1327 if (row < FRAME_HEIGHT (f) - 1)
|
|
1328 row++;
|
|
1329 }
|
|
1330 }
|
|
1331
|
|
1332 cursor_to (row, col);
|
708
|
1333 }
|
314
|
1334 else
|
764
|
1335 cursor_to (FRAME_CURSOR_Y (f), max (min (FRAME_CURSOR_X (f),
|
|
1336 FRAME_WIDTH (f) - 1), 0));
|
314
|
1337 }
|
|
1338
|
764
|
1339 update_end (f);
|
314
|
1340
|
|
1341 if (termscript)
|
|
1342 fflush (termscript);
|
|
1343 fflush (stdout);
|
|
1344
|
|
1345 /* Here if output is preempted because input is detected. */
|
|
1346 do_pause:
|
|
1347
|
764
|
1348 if (FRAME_HEIGHT (f) == 0) abort (); /* Some bug zeros some core */
|
314
|
1349 display_completed = !pause;
|
|
1350
|
7247
bead6db0bbf2
(update_frame): Fix previous change: unconditionally bzero at the end.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1351 bzero (FRAME_DESIRED_GLYPHS (f)->enable, FRAME_HEIGHT (f));
|
314
|
1352 return pause;
|
|
1353 }
|
|
1354
|
|
1355 /* Called when about to quit, to check for doing so
|
|
1356 at an improper time. */
|
|
1357
|
|
1358 void
|
|
1359 quit_error_check ()
|
|
1360 {
|
764
|
1361 if (FRAME_DESIRED_GLYPHS (selected_frame) == 0)
|
314
|
1362 return;
|
764
|
1363 if (FRAME_DESIRED_GLYPHS (selected_frame)->enable[0])
|
314
|
1364 abort ();
|
764
|
1365 if (FRAME_DESIRED_GLYPHS (selected_frame)->enable[FRAME_HEIGHT (selected_frame) - 1])
|
314
|
1366 abort ();
|
|
1367 }
|
|
1368
|
|
1369 /* Decide what insert/delete line to do, and do it */
|
|
1370
|
|
1371 extern void scrolling_1 ();
|
|
1372
|
764
|
1373 scrolling (frame)
|
|
1374 FRAME_PTR frame;
|
314
|
1375 {
|
|
1376 int unchanged_at_top, unchanged_at_bottom;
|
|
1377 int window_size;
|
|
1378 int changed_lines;
|
764
|
1379 int *old_hash = (int *) alloca (FRAME_HEIGHT (frame) * sizeof (int));
|
|
1380 int *new_hash = (int *) alloca (FRAME_HEIGHT (frame) * sizeof (int));
|
|
1381 int *draw_cost = (int *) alloca (FRAME_HEIGHT (frame) * sizeof (int));
|
314
|
1382 register int i;
|
764
|
1383 int free_at_end_vpos = FRAME_HEIGHT (frame);
|
|
1384 register struct frame_glyphs *current_frame = FRAME_CURRENT_GLYPHS (frame);
|
|
1385 register struct frame_glyphs *desired_frame = FRAME_DESIRED_GLYPHS (frame);
|
314
|
1386
|
|
1387 /* Compute hash codes of all the lines.
|
|
1388 Also calculate number of changed lines,
|
|
1389 number of unchanged lines at the beginning,
|
|
1390 and number of unchanged lines at the end. */
|
|
1391
|
|
1392 changed_lines = 0;
|
|
1393 unchanged_at_top = 0;
|
764
|
1394 unchanged_at_bottom = FRAME_HEIGHT (frame);
|
|
1395 for (i = 0; i < FRAME_HEIGHT (frame); i++)
|
314
|
1396 {
|
|
1397 /* Give up on this scrolling if some old lines are not enabled. */
|
764
|
1398 if (!current_frame->enable[i])
|
314
|
1399 return 0;
|
764
|
1400 old_hash[i] = line_hash_code (current_frame, i);
|
|
1401 if (! desired_frame->enable[i])
|
314
|
1402 new_hash[i] = old_hash[i];
|
|
1403 else
|
764
|
1404 new_hash[i] = line_hash_code (desired_frame, i);
|
314
|
1405
|
|
1406 if (old_hash[i] != new_hash[i])
|
|
1407 {
|
|
1408 changed_lines++;
|
764
|
1409 unchanged_at_bottom = FRAME_HEIGHT (frame) - i - 1;
|
314
|
1410 }
|
|
1411 else if (i == unchanged_at_top)
|
|
1412 unchanged_at_top++;
|
764
|
1413 draw_cost[i] = line_draw_cost (desired_frame, i);
|
314
|
1414 }
|
|
1415
|
|
1416 /* If changed lines are few, don't allow preemption, don't scroll. */
|
|
1417 if (changed_lines < baud_rate / 2400
|
764
|
1418 || unchanged_at_bottom == FRAME_HEIGHT (frame))
|
314
|
1419 return 1;
|
|
1420
|
764
|
1421 window_size = (FRAME_HEIGHT (frame) - unchanged_at_top
|
314
|
1422 - unchanged_at_bottom);
|
|
1423
|
|
1424 if (scroll_region_ok)
|
|
1425 free_at_end_vpos -= unchanged_at_bottom;
|
764
|
1426 else if (memory_below_frame)
|
314
|
1427 free_at_end_vpos = -1;
|
|
1428
|
|
1429 /* If large window, fast terminal and few lines in common between
|
764
|
1430 current frame and desired frame, don't bother with i/d calc. */
|
314
|
1431 if (window_size >= 18 && baud_rate > 2400
|
|
1432 && (window_size >=
|
|
1433 10 * scrolling_max_lines_saved (unchanged_at_top,
|
764
|
1434 FRAME_HEIGHT (frame) - unchanged_at_bottom,
|
314
|
1435 old_hash, new_hash, draw_cost)))
|
|
1436 return 0;
|
|
1437
|
764
|
1438 scrolling_1 (frame, window_size, unchanged_at_top, unchanged_at_bottom,
|
314
|
1439 draw_cost + unchanged_at_top - 1,
|
|
1440 old_hash + unchanged_at_top - 1,
|
|
1441 new_hash + unchanged_at_top - 1,
|
|
1442 free_at_end_vpos - unchanged_at_top);
|
|
1443
|
|
1444 return 0;
|
|
1445 }
|
|
1446
|
|
1447 /* Return the offset in its buffer of the character at location col, line
|
|
1448 in the given window. */
|
|
1449 int
|
|
1450 buffer_posn_from_coords (window, col, line)
|
|
1451 struct window *window;
|
|
1452 int col, line;
|
|
1453 {
|
5885
|
1454 int hscroll = XINT (window->hscroll);
|
314
|
1455 int window_left = XFASTINT (window->left);
|
|
1456
|
|
1457 /* The actual width of the window is window->width less one for the
|
493
|
1458 DISP_CONTINUE_GLYPH, and less one if it's not the rightmost
|
|
1459 window. */
|
1777
|
1460 int window_width = window_internal_width (window) - 1;
|
314
|
1461
|
493
|
1462 int startp = marker_position (window->start);
|
314
|
1463
|
|
1464 /* Since compute_motion will only operate on the current buffer,
|
|
1465 we need to save the old one and restore it when we're done. */
|
|
1466 struct buffer *old_current_buffer = current_buffer;
|
493
|
1467 struct position *posn;
|
314
|
1468
|
|
1469 current_buffer = XBUFFER (window->buffer);
|
|
1470
|
764
|
1471 /* It would be nice if we could use FRAME_CURRENT_GLYPHS (XFRAME
|
|
1472 (window->frame))->bufp to avoid scanning from the very top of
|
493
|
1473 the window, but it isn't maintained correctly, and I'm not even
|
|
1474 sure I will keep it. */
|
|
1475 posn = compute_motion (startp, 0,
|
|
1476 (window == XWINDOW (minibuf_window) && startp == 1
|
5885
|
1477 ? minibuf_prompt_width : 0)
|
|
1478 + (hscroll ? 1 - hscroll : 0),
|
3317
|
1479 ZV, line, col,
|
6692
|
1480 window_width, hscroll, 0, window);
|
314
|
1481
|
|
1482 current_buffer = old_current_buffer;
|
|
1483
|
764
|
1484 /* compute_motion considers frame points past the end of a line
|
493
|
1485 to be *after* the newline, i.e. at the start of the next line.
|
|
1486 This is reasonable, but not really what we want. So if the
|
|
1487 result is on a line below LINE, back it up one character. */
|
|
1488 if (posn->vpos > line)
|
|
1489 return posn->bufpos - 1;
|
|
1490 else
|
|
1491 return posn->bufpos;
|
314
|
1492 }
|
|
1493
|
|
1494 static int
|
|
1495 count_blanks (r)
|
|
1496 register GLYPH *r;
|
|
1497 {
|
|
1498 register GLYPH *p = r;
|
1495
|
1499 while (*p++ == SPACEGLYPH);
|
|
1500 return p - r - 1;
|
314
|
1501 }
|
|
1502
|
|
1503 static int
|
|
1504 count_match (str1, str2)
|
|
1505 GLYPH *str1, *str2;
|
|
1506 {
|
|
1507 register GLYPH *p1 = str1;
|
|
1508 register GLYPH *p2 = str2;
|
|
1509 while (*p1++ == *p2++);
|
|
1510 return p1 - str1 - 1;
|
|
1511 }
|
|
1512
|
|
1513 /* Char insertion/deletion cost vector, from term.c */
|
|
1514 extern int *char_ins_del_vector;
|
|
1515
|
1849
|
1516 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WIDTH((f))])
|
314
|
1517
|
|
1518 static void
|
764
|
1519 update_line (frame, vpos)
|
|
1520 register FRAME_PTR frame;
|
314
|
1521 int vpos;
|
|
1522 {
|
|
1523 register GLYPH *obody, *nbody, *op1, *op2, *np1, *temp;
|
6617
|
1524 int *temp1;
|
314
|
1525 int tem;
|
|
1526 int osp, nsp, begmatch, endmatch, olen, nlen;
|
|
1527 int save;
|
764
|
1528 register struct frame_glyphs *current_frame
|
|
1529 = FRAME_CURRENT_GLYPHS (frame);
|
|
1530 register struct frame_glyphs *desired_frame
|
|
1531 = FRAME_DESIRED_GLYPHS (frame);
|
314
|
1532
|
764
|
1533 if (desired_frame->highlight[vpos]
|
|
1534 != (current_frame->enable[vpos] && current_frame->highlight[vpos]))
|
314
|
1535 {
|
764
|
1536 change_line_highlight (desired_frame->highlight[vpos], vpos,
|
|
1537 (current_frame->enable[vpos] ?
|
|
1538 current_frame->used[vpos] : 0));
|
|
1539 current_frame->enable[vpos] = 0;
|
314
|
1540 }
|
|
1541 else
|
764
|
1542 reassert_line_highlight (desired_frame->highlight[vpos], vpos);
|
314
|
1543
|
764
|
1544 if (! current_frame->enable[vpos])
|
314
|
1545 {
|
|
1546 olen = 0;
|
|
1547 }
|
|
1548 else
|
|
1549 {
|
764
|
1550 obody = current_frame->glyphs[vpos];
|
|
1551 olen = current_frame->used[vpos];
|
|
1552 if (! current_frame->highlight[vpos])
|
314
|
1553 {
|
|
1554 if (!must_write_spaces)
|
|
1555 while (obody[olen - 1] == SPACEGLYPH && olen > 0)
|
|
1556 olen--;
|
|
1557 }
|
|
1558 else
|
|
1559 {
|
|
1560 /* For an inverse-video line, remember we gave it
|
764
|
1561 spaces all the way to the frame edge
|
314
|
1562 so that the reverse video extends all the way across. */
|
|
1563
|
764
|
1564 while (olen < FRAME_WIDTH (frame) - 1)
|
314
|
1565 obody[olen++] = SPACEGLYPH;
|
|
1566 }
|
|
1567 }
|
|
1568
|
|
1569 /* One way or another, this will enable the line being updated. */
|
764
|
1570 current_frame->enable[vpos] = 1;
|
|
1571 current_frame->used[vpos] = desired_frame->used[vpos];
|
|
1572 current_frame->highlight[vpos] = desired_frame->highlight[vpos];
|
|
1573 current_frame->bufp[vpos] = desired_frame->bufp[vpos];
|
314
|
1574
|
|
1575 #ifdef HAVE_X_WINDOWS
|
960
|
1576 if (FRAME_X_P (frame))
|
314
|
1577 {
|
764
|
1578 current_frame->pix_width[vpos]
|
|
1579 = current_frame->used[vpos]
|
|
1580 * FONT_WIDTH (frame->display.x->font);
|
|
1581 current_frame->pix_height[vpos]
|
6765
|
1582 = frame->display.x->line_height;
|
314
|
1583 }
|
|
1584 #endif /* HAVE_X_WINDOWS */
|
|
1585
|
764
|
1586 if (!desired_frame->enable[vpos])
|
314
|
1587 {
|
|
1588 nlen = 0;
|
|
1589 goto just_erase;
|
|
1590 }
|
|
1591
|
764
|
1592 nbody = desired_frame->glyphs[vpos];
|
|
1593 nlen = desired_frame->used[vpos];
|
314
|
1594
|
|
1595 /* Pretend trailing spaces are not there at all,
|
|
1596 unless for one reason or another we must write all spaces. */
|
764
|
1597 if (! desired_frame->highlight[vpos])
|
314
|
1598 {
|
|
1599 if (!must_write_spaces)
|
|
1600 /* We know that the previous character byte contains 0. */
|
|
1601 while (nbody[nlen - 1] == SPACEGLYPH)
|
|
1602 nlen--;
|
|
1603 }
|
|
1604 else
|
|
1605 {
|
|
1606 /* For an inverse-video line, give it extra trailing spaces
|
764
|
1607 all the way to the frame edge
|
314
|
1608 so that the reverse video extends all the way across. */
|
|
1609
|
764
|
1610 while (nlen < FRAME_WIDTH (frame) - 1)
|
314
|
1611 nbody[nlen++] = SPACEGLYPH;
|
|
1612 }
|
|
1613
|
|
1614 /* If there's no i/d char, quickly do the best we can without it. */
|
|
1615 if (!char_ins_del_ok)
|
|
1616 {
|
|
1617 int i,j;
|
|
1618
|
4276
|
1619 #if 0
|
|
1620 if (FRAME_X_P (frame))
|
|
1621 {
|
|
1622 /* Under X, erase everything we are going to rewrite,
|
|
1623 and rewrite everything from the first char that's changed.
|
|
1624 This is part of supporting fonts like Courier
|
|
1625 whose chars can overlap outside the char width. */
|
|
1626 for (i = 0; i < nlen; i++)
|
|
1627 if (i >= olen || nbody[i] != obody[i])
|
|
1628 break;
|
|
1629
|
|
1630 cursor_to (vpos, i);
|
|
1631 if (i != olen)
|
|
1632 clear_end_of_line (olen);
|
|
1633 write_glyphs (nbody + i, nlen - i);
|
|
1634 }
|
|
1635 else
|
|
1636 {}
|
|
1637 #endif /* 0 */
|
314
|
1638 for (i = 0; i < nlen; i++)
|
|
1639 {
|
|
1640 if (i >= olen || nbody[i] != obody[i]) /* A non-matching char. */
|
|
1641 {
|
|
1642 cursor_to (vpos, i);
|
|
1643 for (j = 1; (i + j < nlen &&
|
|
1644 (i + j >= olen || nbody[i+j] != obody[i+j]));
|
|
1645 j++);
|
|
1646
|
|
1647 /* Output this run of non-matching chars. */
|
|
1648 write_glyphs (nbody + i, j);
|
|
1649 i += j - 1;
|
|
1650
|
|
1651 /* Now find the next non-match. */
|
|
1652 }
|
|
1653 }
|
|
1654
|
|
1655 /* Clear the rest of the line, or the non-clear part of it. */
|
|
1656 if (olen > nlen)
|
|
1657 {
|
|
1658 cursor_to (vpos, nlen);
|
|
1659 clear_end_of_line (olen);
|
|
1660 }
|
|
1661
|
764
|
1662 /* Exchange contents between current_frame and new_frame. */
|
|
1663 temp = desired_frame->glyphs[vpos];
|
|
1664 desired_frame->glyphs[vpos] = current_frame->glyphs[vpos];
|
|
1665 current_frame->glyphs[vpos] = temp;
|
314
|
1666
|
6617
|
1667 /* Exchange charstarts between current_frame and new_frame. */
|
|
1668 temp1 = desired_frame->charstarts[vpos];
|
|
1669 desired_frame->charstarts[vpos] = current_frame->charstarts[vpos];
|
|
1670 current_frame->charstarts[vpos] = temp1;
|
|
1671
|
314
|
1672 return;
|
|
1673 }
|
|
1674
|
|
1675 if (!olen)
|
|
1676 {
|
764
|
1677 nsp = (must_write_spaces || desired_frame->highlight[vpos])
|
314
|
1678 ? 0 : count_blanks (nbody);
|
|
1679 if (nlen > nsp)
|
|
1680 {
|
|
1681 cursor_to (vpos, nsp);
|
|
1682 write_glyphs (nbody + nsp, nlen - nsp);
|
|
1683 }
|
|
1684
|
764
|
1685 /* Exchange contents between current_frame and new_frame. */
|
|
1686 temp = desired_frame->glyphs[vpos];
|
|
1687 desired_frame->glyphs[vpos] = current_frame->glyphs[vpos];
|
|
1688 current_frame->glyphs[vpos] = temp;
|
314
|
1689
|
6617
|
1690 /* Exchange charstarts between current_frame and new_frame. */
|
|
1691 temp1 = desired_frame->charstarts[vpos];
|
|
1692 desired_frame->charstarts[vpos] = current_frame->charstarts[vpos];
|
|
1693 current_frame->charstarts[vpos] = temp1;
|
|
1694
|
314
|
1695 return;
|
|
1696 }
|
|
1697
|
|
1698 obody[olen] = 1;
|
|
1699 save = nbody[nlen];
|
|
1700 nbody[nlen] = 0;
|
|
1701
|
|
1702 /* Compute number of leading blanks in old and new contents. */
|
|
1703 osp = count_blanks (obody);
|
764
|
1704 if (!desired_frame->highlight[vpos])
|
314
|
1705 nsp = count_blanks (nbody);
|
|
1706 else
|
|
1707 nsp = 0;
|
|
1708
|
|
1709 /* Compute number of matching chars starting with first nonblank. */
|
|
1710 begmatch = count_match (obody + osp, nbody + nsp);
|
|
1711
|
|
1712 /* Spaces in new match implicit space past the end of old. */
|
|
1713 /* A bug causing this to be a no-op was fixed in 18.29. */
|
|
1714 if (!must_write_spaces && osp + begmatch == olen)
|
|
1715 {
|
|
1716 np1 = nbody + nsp;
|
|
1717 while (np1[begmatch] == SPACEGLYPH)
|
|
1718 begmatch++;
|
|
1719 }
|
|
1720
|
|
1721 /* Avoid doing insert/delete char
|
|
1722 just cause number of leading spaces differs
|
|
1723 when the following text does not match. */
|
|
1724 if (begmatch == 0 && osp != nsp)
|
|
1725 osp = nsp = min (osp, nsp);
|
|
1726
|
|
1727 /* Find matching characters at end of line */
|
|
1728 op1 = obody + olen;
|
|
1729 np1 = nbody + nlen;
|
|
1730 op2 = op1 + begmatch - min (olen - osp, nlen - nsp);
|
|
1731 while (op1 > op2 && op1[-1] == np1[-1])
|
|
1732 {
|
|
1733 op1--;
|
|
1734 np1--;
|
|
1735 }
|
|
1736 endmatch = obody + olen - op1;
|
|
1737
|
|
1738 /* Put correct value back in nbody[nlen].
|
|
1739 This is important because direct_output_for_insert
|
|
1740 can write into the line at a later point.
|
|
1741 If this screws up the zero at the end of the line, re-establish it. */
|
|
1742 nbody[nlen] = save;
|
|
1743 obody[olen] = 0;
|
|
1744
|
|
1745 /* tem gets the distance to insert or delete.
|
|
1746 endmatch is how many characters we save by doing so.
|
|
1747 Is it worth it? */
|
|
1748
|
|
1749 tem = (nlen - nsp) - (olen - osp);
|
|
1750 if (endmatch && tem
|
764
|
1751 && (!char_ins_del_ok || endmatch <= char_ins_del_cost (frame)[tem]))
|
314
|
1752 endmatch = 0;
|
|
1753
|
|
1754 /* nsp - osp is the distance to insert or delete.
|
|
1755 If that is nonzero, begmatch is known to be nonzero also.
|
|
1756 begmatch + endmatch is how much we save by doing the ins/del.
|
|
1757 Is it worth it? */
|
|
1758
|
|
1759 if (nsp != osp
|
|
1760 && (!char_ins_del_ok
|
764
|
1761 || begmatch + endmatch <= char_ins_del_cost (frame)[nsp - osp]))
|
314
|
1762 {
|
|
1763 begmatch = 0;
|
|
1764 endmatch = 0;
|
|
1765 osp = nsp = min (osp, nsp);
|
|
1766 }
|
|
1767
|
|
1768 /* Now go through the line, inserting, writing and
|
|
1769 deleting as appropriate. */
|
|
1770
|
|
1771 if (osp > nsp)
|
|
1772 {
|
|
1773 cursor_to (vpos, nsp);
|
|
1774 delete_glyphs (osp - nsp);
|
|
1775 }
|
|
1776 else if (nsp > osp)
|
|
1777 {
|
|
1778 /* If going to delete chars later in line
|
|
1779 and insert earlier in the line,
|
|
1780 must delete first to avoid losing data in the insert */
|
|
1781 if (endmatch && nlen < olen + nsp - osp)
|
|
1782 {
|
|
1783 cursor_to (vpos, nlen - endmatch + osp - nsp);
|
|
1784 delete_glyphs (olen + nsp - osp - nlen);
|
|
1785 olen = nlen - (nsp - osp);
|
|
1786 }
|
|
1787 cursor_to (vpos, osp);
|
|
1788 insert_glyphs ((char *)0, nsp - osp);
|
|
1789 }
|
|
1790 olen += nsp - osp;
|
|
1791
|
|
1792 tem = nsp + begmatch + endmatch;
|
|
1793 if (nlen != tem || olen != tem)
|
|
1794 {
|
|
1795 cursor_to (vpos, nsp + begmatch);
|
|
1796 if (!endmatch || nlen == olen)
|
|
1797 {
|
|
1798 /* If new text being written reaches right margin,
|
|
1799 there is no need to do clear-to-eol at the end.
|
|
1800 (and it would not be safe, since cursor is not
|
|
1801 going to be "at the margin" after the text is done) */
|
764
|
1802 if (nlen == FRAME_WIDTH (frame))
|
314
|
1803 olen = 0;
|
|
1804 write_glyphs (nbody + nsp + begmatch, nlen - tem);
|
|
1805
|
|
1806 #ifdef obsolete
|
|
1807
|
|
1808 /* the following code loses disastrously if tem == nlen.
|
|
1809 Rather than trying to fix that case, I am trying the simpler
|
|
1810 solution found above. */
|
|
1811
|
|
1812 /* If the text reaches to the right margin,
|
|
1813 it will lose one way or another (depending on AutoWrap)
|
|
1814 to clear to end of line after outputting all the text.
|
|
1815 So pause with one character to go and clear the line then. */
|
764
|
1816 if (nlen == FRAME_WIDTH (frame) && fast_clear_end_of_line && olen > nlen)
|
314
|
1817 {
|
|
1818 /* endmatch must be zero, and tem must equal nsp + begmatch */
|
|
1819 write_glyphs (nbody + tem, nlen - tem - 1);
|
|
1820 clear_end_of_line (olen);
|
|
1821 olen = 0; /* Don't let it be cleared again later */
|
|
1822 write_glyphs (nbody + nlen - 1, 1);
|
|
1823 }
|
|
1824 else
|
|
1825 write_glyphs (nbody + nsp + begmatch, nlen - tem);
|
|
1826 #endif /* OBSOLETE */
|
|
1827
|
|
1828 }
|
|
1829 else if (nlen > olen)
|
|
1830 {
|
|
1831 write_glyphs (nbody + nsp + begmatch, olen - tem);
|
|
1832 insert_glyphs (nbody + nsp + begmatch + olen - tem, nlen - olen);
|
|
1833 olen = nlen;
|
|
1834 }
|
|
1835 else if (olen > nlen)
|
|
1836 {
|
|
1837 write_glyphs (nbody + nsp + begmatch, nlen - tem);
|
|
1838 delete_glyphs (olen - nlen);
|
|
1839 olen = nlen;
|
|
1840 }
|
|
1841 }
|
|
1842
|
|
1843 just_erase:
|
|
1844 /* If any unerased characters remain after the new line, erase them. */
|
|
1845 if (olen > nlen)
|
|
1846 {
|
|
1847 cursor_to (vpos, nlen);
|
|
1848 clear_end_of_line (olen);
|
|
1849 }
|
|
1850
|
764
|
1851 /* Exchange contents between current_frame and new_frame. */
|
|
1852 temp = desired_frame->glyphs[vpos];
|
|
1853 desired_frame->glyphs[vpos] = current_frame->glyphs[vpos];
|
|
1854 current_frame->glyphs[vpos] = temp;
|
6617
|
1855
|
|
1856 /* Exchange charstarts between current_frame and new_frame. */
|
|
1857 temp1 = desired_frame->charstarts[vpos];
|
|
1858 desired_frame->charstarts[vpos] = current_frame->charstarts[vpos];
|
|
1859 current_frame->charstarts[vpos] = temp1;
|
314
|
1860 }
|
|
1861
|
7814
|
1862 /* A vector of size >= NFRAMES + 3 * NBUFFERS + 1, containing the session's
|
7810
|
1863 frames, buffers, buffer-read-only flags, and buffer-modified-flags,
|
|
1864 and a trailing sentinel (so we don't need to add length checks). */
|
|
1865 static Lisp_Object frame_and_buffer_state;
|
|
1866
|
|
1867 DEFUN ("frame-or-buffer-changed-p", Fframe_or_buffer_changed_p,
|
|
1868 Sframe_or_buffer_changed_p, 0, 0, 0,
|
|
1869 "Return non-nil if the frame and buffer state appears to have changed.\n\
|
|
1870 The state variable is an internal vector containing all frames and buffers,\n\
|
|
1871 along with the buffers' read-only and modified flags, which allows a fast\n\
|
|
1872 check to see whether the menu bars might need to be recomputed.\n\
|
|
1873 If this function returns non-nil, it updates the internal vector to reflect\n\
|
|
1874 the current state.\n")
|
|
1875 ()
|
|
1876 {
|
|
1877 Lisp_Object tail, frame, buf;
|
|
1878 Lisp_Object *vecp;
|
|
1879 int n;
|
|
1880 vecp = XVECTOR (frame_and_buffer_state)->contents;
|
|
1881 FOR_EACH_FRAME (tail, frame)
|
|
1882 if (!EQ (*vecp++, frame))
|
|
1883 goto changed;
|
|
1884 for (tail = Vbuffer_alist; CONSP (tail); tail = XCONS (tail)->cdr)
|
|
1885 {
|
|
1886 buf = XCONS (XCONS (tail)->car)->cdr;
|
|
1887 if (!EQ (*vecp++, buf))
|
|
1888 goto changed;
|
|
1889 if (!EQ (*vecp++, XBUFFER (buf)->read_only))
|
|
1890 goto changed;
|
|
1891 if (!EQ (*vecp++, Fbuffer_modified_p (buf)))
|
|
1892 goto changed;
|
|
1893 }
|
|
1894 return Qnil;
|
|
1895 changed:
|
|
1896 n = 1;
|
|
1897 FOR_EACH_FRAME (tail, frame)
|
|
1898 n++;
|
|
1899 for (tail = Vbuffer_alist; CONSP (tail); tail = XCONS (tail)->cdr)
|
|
1900 n += 3;
|
7814
|
1901 /* Reallocate the vector if it's grown, or if it's shrunk a lot. */
|
|
1902 if (n > XVECTOR (frame_and_buffer_state)->size
|
|
1903 || n < XVECTOR (frame_and_buffer_state)->size / 2)
|
|
1904 frame_and_buffer_state = Fmake_vector (make_number (n), Qlambda);
|
7810
|
1905 vecp = XVECTOR (frame_and_buffer_state)->contents;
|
|
1906 FOR_EACH_FRAME (tail, frame)
|
|
1907 *vecp++ = frame;
|
|
1908 for (tail = Vbuffer_alist; CONSP (tail); tail = XCONS (tail)->cdr)
|
|
1909 {
|
|
1910 buf = XCONS (XCONS (tail)->car)->cdr;
|
|
1911 *vecp++ = buf;
|
|
1912 *vecp++ = XBUFFER (buf)->read_only;
|
|
1913 *vecp++ = Fbuffer_modified_p (buf);
|
|
1914 }
|
7814
|
1915 /* If we left any slack in the vector, fill it up now. */
|
|
1916 for (; n < XVECTOR (frame_and_buffer_state)->size; ++n)
|
|
1917 *vecp++ = Qlambda;
|
7810
|
1918 return Qt;
|
|
1919 }
|
|
1920
|
314
|
1921 DEFUN ("open-termscript", Fopen_termscript, Sopen_termscript,
|
|
1922 1, 1, "FOpen termscript file: ",
|
|
1923 "Start writing all terminal output to FILE as well as the terminal.\n\
|
|
1924 FILE = nil means just close any termscript file currently open.")
|
|
1925 (file)
|
|
1926 Lisp_Object file;
|
|
1927 {
|
|
1928 if (termscript != 0) fclose (termscript);
|
|
1929 termscript = 0;
|
|
1930
|
493
|
1931 if (! NILP (file))
|
314
|
1932 {
|
|
1933 file = Fexpand_file_name (file, Qnil);
|
|
1934 termscript = fopen (XSTRING (file)->data, "w");
|
|
1935 if (termscript == 0)
|
|
1936 report_file_error ("Opening termscript", Fcons (file, Qnil));
|
|
1937 }
|
|
1938 return Qnil;
|
|
1939 }
|
|
1940
|
|
1941
|
|
1942 #ifdef SIGWINCH
|
493
|
1943 SIGTYPE
|
314
|
1944 window_change_signal ()
|
|
1945 {
|
|
1946 int width, height;
|
|
1947 extern int errno;
|
|
1948 int old_errno = errno;
|
|
1949
|
764
|
1950 get_frame_size (&width, &height);
|
314
|
1951
|
764
|
1952 /* The frame size change obviously applies to a termcap-controlled
|
|
1953 frame. Find such a frame in the list, and assume it's the only
|
314
|
1954 one (since the redisplay code always writes to stdout, not a
|
764
|
1955 FILE * specified in the frame structure). Record the new size,
|
314
|
1956 but don't reallocate the data structures now. Let that be done
|
|
1957 later outside of the signal handler. */
|
|
1958
|
|
1959 {
|
2252
|
1960 Lisp_Object tail, frame;
|
314
|
1961
|
2252
|
1962 FOR_EACH_FRAME (tail, frame)
|
314
|
1963 {
|
2252
|
1964 if (FRAME_TERMCAP_P (XFRAME (frame)))
|
314
|
1965 {
|
2252
|
1966 change_frame_size (XFRAME (frame), height, width, 0, 1);
|
314
|
1967 break;
|
|
1968 }
|
|
1969 }
|
|
1970 }
|
|
1971
|
|
1972 signal (SIGWINCH, window_change_signal);
|
|
1973 errno = old_errno;
|
|
1974 }
|
|
1975 #endif /* SIGWINCH */
|
|
1976
|
|
1977
|
764
|
1978 /* Do any change in frame size that was requested by a signal. */
|
314
|
1979
|
|
1980 do_pending_window_change ()
|
|
1981 {
|
|
1982 /* If window_change_signal should have run before, run it now. */
|
|
1983 while (delayed_size_change)
|
|
1984 {
|
2252
|
1985 Lisp_Object tail, frame;
|
314
|
1986
|
|
1987 delayed_size_change = 0;
|
|
1988
|
2252
|
1989 FOR_EACH_FRAME (tail, frame)
|
314
|
1990 {
|
2252
|
1991 FRAME_PTR f = XFRAME (frame);
|
|
1992
|
764
|
1993 int height = FRAME_NEW_HEIGHT (f);
|
|
1994 int width = FRAME_NEW_WIDTH (f);
|
314
|
1995
|
3449
|
1996 if (height != 0 || width != 0)
|
960
|
1997 change_frame_size (f, height, width, 0, 0);
|
314
|
1998 }
|
|
1999 }
|
|
2000 }
|
|
2001
|
|
2002
|
764
|
2003 /* Change the frame height and/or width. Values may be given as zero to
|
960
|
2004 indicate no change is to take place.
|
314
|
2005
|
960
|
2006 If DELAY is non-zero, then assume we're being called from a signal
|
|
2007 handler, and queue the change for later - perhaps the next
|
|
2008 redisplay. Since this tries to resize windows, we can't call it
|
|
2009 from a signal handler. */
|
|
2010
|
|
2011 change_frame_size (frame, newheight, newwidth, pretend, delay)
|
764
|
2012 register FRAME_PTR frame;
|
960
|
2013 int newheight, newwidth, pretend;
|
314
|
2014 {
|
|
2015 /* If we can't deal with the change now, queue it for later. */
|
960
|
2016 if (delay)
|
314
|
2017 {
|
960
|
2018 FRAME_NEW_HEIGHT (frame) = newheight;
|
764
|
2019 FRAME_NEW_WIDTH (frame) = newwidth;
|
314
|
2020 delayed_size_change = 1;
|
|
2021 return;
|
|
2022 }
|
|
2023
|
764
|
2024 /* This size-change overrides any pending one for this frame. */
|
|
2025 FRAME_NEW_HEIGHT (frame) = 0;
|
960
|
2026 FRAME_NEW_WIDTH (frame) = 0;
|
|
2027
|
3449
|
2028 /* If an argument is zero, set it to the current value. */
|
960
|
2029 newheight || (newheight = FRAME_HEIGHT (frame));
|
|
2030 newwidth || (newwidth = FRAME_WIDTH (frame));
|
314
|
2031
|
960
|
2032 /* Round up to the smallest acceptable size. */
|
|
2033 check_frame_size (frame, &newheight, &newwidth);
|
|
2034
|
|
2035 /* If we're not changing the frame size, quit now. */
|
|
2036 if (newheight == FRAME_HEIGHT (frame)
|
|
2037 && newwidth == FRAME_WIDTH (frame))
|
314
|
2038 return;
|
|
2039
|
960
|
2040 if (newheight != FRAME_HEIGHT (frame))
|
314
|
2041 {
|
960
|
2042 if (FRAME_HAS_MINIBUF_P (frame)
|
764
|
2043 && ! FRAME_MINIBUF_ONLY_P (frame))
|
314
|
2044 {
|
764
|
2045 /* Frame has both root and minibuffer. */
|
|
2046 set_window_height (FRAME_ROOT_WINDOW (frame),
|
2132
|
2047 newheight - 1 - FRAME_MENU_BAR_LINES (frame), 0);
|
764
|
2048 XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (frame))->top)
|
960
|
2049 = newheight - 1;
|
764
|
2050 set_window_height (FRAME_MINIBUF_WINDOW (frame), 1, 0);
|
314
|
2051 }
|
|
2052 else
|
764
|
2053 /* Frame has just one top-level window. */
|
2132
|
2054 set_window_height (FRAME_ROOT_WINDOW (frame),
|
|
2055 newheight - FRAME_MENU_BAR_LINES (frame), 0);
|
960
|
2056
|
|
2057 if (FRAME_TERMCAP_P (frame) && !pretend)
|
|
2058 FrameRows = newheight;
|
314
|
2059
|
|
2060 #if 0
|
764
|
2061 if (frame->output_method == output_termcap)
|
314
|
2062 {
|
960
|
2063 frame_height = newheight;
|
314
|
2064 if (!pretend)
|
960
|
2065 FrameRows = newheight;
|
314
|
2066 }
|
|
2067 #endif
|
|
2068 }
|
|
2069
|
960
|
2070 if (newwidth != FRAME_WIDTH (frame))
|
314
|
2071 {
|
764
|
2072 set_window_width (FRAME_ROOT_WINDOW (frame), newwidth, 0);
|
960
|
2073 if (FRAME_HAS_MINIBUF_P (frame))
|
764
|
2074 set_window_width (FRAME_MINIBUF_WINDOW (frame), newwidth, 0);
|
314
|
2075
|
960
|
2076 if (FRAME_TERMCAP_P (frame) && !pretend)
|
764
|
2077 FrameCols = newwidth;
|
314
|
2078 #if 0
|
764
|
2079 if (frame->output_method == output_termcap)
|
314
|
2080 {
|
764
|
2081 frame_width = newwidth;
|
314
|
2082 if (!pretend)
|
764
|
2083 FrameCols = newwidth;
|
314
|
2084 }
|
|
2085 #endif
|
|
2086 }
|
|
2087
|
960
|
2088 FRAME_HEIGHT (frame) = newheight;
|
|
2089 FRAME_WIDTH (frame) = newwidth;
|
7648
|
2090
|
|
2091 if (FRAME_CURSOR_X (frame) >= FRAME_WIDTH (frame))
|
|
2092 FRAME_CURSOR_X (frame) = FRAME_WIDTH (frame) - 1;
|
|
2093 if (FRAME_CURSOR_Y (frame) >= FRAME_HEIGHT (frame))
|
|
2094 FRAME_CURSOR_Y (frame) = FRAME_HEIGHT (frame) - 1;
|
|
2095
|
764
|
2096 remake_frame_glyphs (frame);
|
|
2097 calculate_costs (frame);
|
314
|
2098 }
|
|
2099
|
|
2100 DEFUN ("send-string-to-terminal", Fsend_string_to_terminal,
|
|
2101 Ssend_string_to_terminal, 1, 1, 0,
|
|
2102 "Send STRING to the terminal without alteration.\n\
|
|
2103 Control characters in STRING will have terminal-dependent effects.")
|
|
2104 (str)
|
|
2105 Lisp_Object str;
|
|
2106 {
|
|
2107 CHECK_STRING (str, 0);
|
|
2108 fwrite (XSTRING (str)->data, 1, XSTRING (str)->size, stdout);
|
|
2109 fflush (stdout);
|
|
2110 if (termscript)
|
|
2111 {
|
|
2112 fwrite (XSTRING (str)->data, 1, XSTRING (str)->size, termscript);
|
|
2113 fflush (termscript);
|
|
2114 }
|
|
2115 return Qnil;
|
|
2116 }
|
|
2117
|
|
2118 DEFUN ("ding", Fding, Sding, 0, 1, 0,
|
|
2119 "Beep, or flash the screen.\n\
|
|
2120 Also, unless an argument is given,\n\
|
|
2121 terminate any keyboard macro currently executing.")
|
|
2122 (arg)
|
|
2123 Lisp_Object arg;
|
|
2124 {
|
493
|
2125 if (!NILP (arg))
|
314
|
2126 {
|
649
|
2127 if (noninteractive)
|
|
2128 putchar (07);
|
|
2129 else
|
|
2130 ring_bell ();
|
314
|
2131 fflush (stdout);
|
|
2132 }
|
|
2133 else
|
|
2134 bitch_at_user ();
|
|
2135
|
|
2136 return Qnil;
|
|
2137 }
|
|
2138
|
|
2139 bitch_at_user ()
|
|
2140 {
|
|
2141 if (noninteractive)
|
|
2142 putchar (07);
|
|
2143 else if (!INTERACTIVE) /* Stop executing a keyboard macro. */
|
|
2144 error ("Keyboard macro terminated by a command ringing the bell");
|
|
2145 else
|
|
2146 ring_bell ();
|
|
2147 fflush (stdout);
|
|
2148 }
|
|
2149
|
|
2150 DEFUN ("sleep-for", Fsleep_for, Ssleep_for, 1, 2, 0,
|
2291
|
2151 "Pause, without updating display, for SECONDS seconds.\n\
|
2648
|
2152 SECONDS may be a floating-point value, meaning that you can wait for a\n\
|
|
2153 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
|
|
2154 additional wait period, in milliseconds; this may be useful if your\n\
|
|
2155 Emacs was built without floating point support.\n\
|
|
2156 \(Not all operating systems support waiting for a fraction of a second.)")
|
2291
|
2157 (seconds, milliseconds)
|
|
2158 Lisp_Object seconds, milliseconds;
|
314
|
2159 {
|
2291
|
2160 int sec, usec;
|
|
2161
|
|
2162 if (NILP (milliseconds))
|
|
2163 XSET (milliseconds, Lisp_Int, 0);
|
|
2164 else
|
|
2165 CHECK_NUMBER (milliseconds, 1);
|
2648
|
2166 usec = XINT (milliseconds) * 1000;
|
|
2167
|
|
2168 #ifdef LISP_FLOAT_TYPE
|
|
2169 {
|
|
2170 double duration = extract_float (seconds);
|
|
2171 sec = (int) duration;
|
|
2172 usec += (duration - sec) * 1000000;
|
|
2173 }
|
|
2174 #else
|
|
2175 CHECK_NUMBER (seconds, 0);
|
|
2176 sec = XINT (seconds);
|
|
2177 #endif
|
314
|
2178
|
2291
|
2179 #ifndef EMACS_HAS_USECS
|
|
2180 if (sec == 0 && usec != 0)
|
|
2181 error ("millisecond `sleep-for' not supported on %s", SYSTEM_TYPE);
|
|
2182 #endif
|
|
2183
|
|
2184 /* Assure that 0 <= usec < 1000000. */
|
|
2185 if (usec < 0)
|
|
2186 {
|
|
2187 /* We can't rely on the rounding being correct if user is negative. */
|
|
2188 if (-1000000 < usec)
|
|
2189 sec--, usec += 1000000;
|
|
2190 else
|
|
2191 sec -= -usec / 1000000, usec = 1000000 - (-usec % 1000000);
|
|
2192 }
|
|
2193 else
|
|
2194 sec += usec / 1000000, usec %= 1000000;
|
|
2195
|
4290
|
2196 if (sec <= 0)
|
314
|
2197 return Qnil;
|
|
2198
|
650
|
2199 {
|
|
2200 Lisp_Object zero;
|
|
2201
|
|
2202 XFASTINT (zero) = 0;
|
|
2203 wait_reading_process_input (sec, usec, zero, 0);
|
|
2204 }
|
587
|
2205
|
2291
|
2206 /* We should always have wait_reading_process_input; we have a dummy
|
|
2207 implementation for systems which don't support subprocesses. */
|
|
2208 #if 0
|
|
2209 /* No wait_reading_process_input */
|
314
|
2210 immediate_quit = 1;
|
|
2211 QUIT;
|
|
2212
|
|
2213 #ifdef VMS
|
|
2214 sys_sleep (sec);
|
|
2215 #else /* not VMS */
|
|
2216 /* The reason this is done this way
|
|
2217 (rather than defined (H_S) && defined (H_T))
|
|
2218 is because the VMS preprocessor doesn't grok `defined' */
|
|
2219 #ifdef HAVE_SELECT
|
554
|
2220 EMACS_GET_TIME (end_time);
|
|
2221 EMACS_SET_SECS_USECS (timeout, sec, usec);
|
587
|
2222 EMACS_ADD_TIME (end_time, end_time, timeout);
|
554
|
2223
|
314
|
2224 while (1)
|
|
2225 {
|
554
|
2226 EMACS_GET_TIME (timeout);
|
|
2227 EMACS_SUB_TIME (timeout, end_time, timeout);
|
|
2228 if (EMACS_TIME_NEG_P (timeout)
|
|
2229 || !select (1, 0, 0, 0, &timeout))
|
314
|
2230 break;
|
|
2231 }
|
|
2232 #else /* not HAVE_SELECT */
|
|
2233 sleep (sec);
|
|
2234 #endif /* HAVE_SELECT */
|
|
2235 #endif /* not VMS */
|
|
2236
|
|
2237 immediate_quit = 0;
|
|
2238 #endif /* no subprocesses */
|
|
2239
|
|
2240 return Qnil;
|
|
2241 }
|
|
2242
|
650
|
2243 /* This is just like wait_reading_process_input, except that
|
|
2244 it does the redisplay.
|
|
2245
|
5223
|
2246 It's also much like Fsit_for, except that it can be used for
|
|
2247 waiting for input as well. One differnce is that sit_for
|
|
2248 does not call prepare_menu_bars; Fsit_for does call that. */
|
650
|
2249
|
|
2250 Lisp_Object
|
|
2251 sit_for (sec, usec, reading, display)
|
|
2252 int sec, usec, reading, display;
|
314
|
2253 {
|
650
|
2254 Lisp_Object read_kbd;
|
314
|
2255
|
|
2256 if (detect_input_pending ())
|
|
2257 return Qnil;
|
650
|
2258
|
|
2259 if (display)
|
314
|
2260 redisplay_preserve_echo_area ();
|
|
2261
|
673
|
2262 if (sec == 0 && usec == 0)
|
|
2263 return Qt;
|
|
2264
|
314
|
2265 #ifdef SIGIO
|
1915
|
2266 gobble_input (0);
|
650
|
2267 #endif
|
|
2268
|
|
2269 XSET (read_kbd, Lisp_Int, reading ? -1 : 1);
|
|
2270 wait_reading_process_input (sec, usec, read_kbd, display);
|
|
2271
|
587
|
2272
|
2288
|
2273 /* wait_reading_process_input should always be available now; it is
|
|
2274 simulated in a simple way on systems that don't support
|
|
2275 subprocesses. */
|
|
2276 #if 0
|
|
2277 /* No wait_reading_process_input available. */
|
314
|
2278 immediate_quit = 1;
|
|
2279 QUIT;
|
|
2280
|
|
2281 waitchannels = 1;
|
|
2282 #ifdef VMS
|
650
|
2283 input_wait_timeout (XINT (arg));
|
314
|
2284 #else /* not VMS */
|
587
|
2285 #ifndef HAVE_TIMEVAL
|
|
2286 timeout_sec = sec;
|
|
2287 select (1, &waitchannels, 0, 0, &timeout_sec);
|
|
2288 #else /* HAVE_TIMEVAL */
|
|
2289 timeout.tv_sec = sec;
|
|
2290 timeout.tv_usec = usec;
|
314
|
2291 select (1, &waitchannels, 0, 0, &timeout);
|
587
|
2292 #endif /* HAVE_TIMEVAL */
|
314
|
2293 #endif /* not VMS */
|
|
2294
|
|
2295 immediate_quit = 0;
|
587
|
2296 #endif
|
314
|
2297
|
|
2298 return detect_input_pending () ? Qnil : Qt;
|
|
2299 }
|
|
2300
|
650
|
2301 DEFUN ("sit-for", Fsit_for, Ssit_for, 1, 3, 0,
|
2291
|
2302 "Perform redisplay, then wait for SECONDS seconds or until input is available.\n\
|
2648
|
2303 SECONDS may be a floating-point value, meaning that you can wait for a\n\
|
|
2304 fraction of a second. Optional second arg MILLISECONDS specifies an\n\
|
|
2305 additional wait period, in milliseconds; this may be useful if your\n\
|
|
2306 Emacs was built without floating point support.\n\
|
|
2307 \(Not all operating systems support waiting for a fraction of a second.)\n\
|
650
|
2308 Optional third arg non-nil means don't redisplay, just wait for input.\n\
|
|
2309 Redisplay is preempted as always if input arrives, and does not happen\n\
|
|
2310 if input is available before it starts.\n\
|
|
2311 Value is t if waited the full time with no input arriving.")
|
2291
|
2312 (seconds, milliseconds, nodisp)
|
|
2313 Lisp_Object seconds, milliseconds, nodisp;
|
650
|
2314 {
|
2291
|
2315 int sec, usec;
|
650
|
2316
|
2291
|
2317 if (NILP (milliseconds))
|
|
2318 XSET (milliseconds, Lisp_Int, 0);
|
|
2319 else
|
|
2320 CHECK_NUMBER (milliseconds, 1);
|
2648
|
2321 usec = XINT (milliseconds) * 1000;
|
|
2322
|
|
2323 #ifdef LISP_FLOAT_TYPE
|
|
2324 {
|
|
2325 double duration = extract_float (seconds);
|
|
2326 sec = (int) duration;
|
|
2327 usec += (duration - sec) * 1000000;
|
|
2328 }
|
|
2329 #else
|
|
2330 CHECK_NUMBER (seconds, 0);
|
|
2331 sec = XINT (seconds);
|
|
2332 #endif
|
2291
|
2333
|
650
|
2334 #ifndef EMACS_HAS_USECS
|
2291
|
2335 if (usec != 0 && sec == 0)
|
|
2336 error ("millisecond `sit-for' not supported on %s", SYSTEM_TYPE);
|
650
|
2337 #endif
|
|
2338
|
5223
|
2339 if (NILP (nodisp))
|
|
2340 prepare_menu_bars ();
|
650
|
2341 return sit_for (sec, usec, 0, NILP (nodisp));
|
|
2342 }
|
314
|
2343
|
|
2344 char *terminal_type;
|
|
2345
|
|
2346 /* Initialization done when Emacs fork is started, before doing stty. */
|
|
2347 /* Determine terminal type and set terminal_driver */
|
|
2348 /* Then invoke its decoding routine to set up variables
|
|
2349 in the terminal package */
|
|
2350
|
|
2351 init_display ()
|
|
2352 {
|
|
2353 #ifdef HAVE_X_WINDOWS
|
|
2354 extern int display_arg;
|
|
2355 #endif
|
|
2356
|
|
2357 meta_key = 0;
|
|
2358 inverse_video = 0;
|
|
2359 cursor_in_echo_area = 0;
|
|
2360 terminal_type = (char *) 0;
|
|
2361
|
2339
|
2362 /* Now is the time to initialize this; it's used by init_sys_modes
|
|
2363 during startup. */
|
|
2364 Vwindow_system = Qnil;
|
314
|
2365
|
2339
|
2366 /* If the user wants to use a window system, we shouldn't bother
|
|
2367 initializing the terminal. This is especially important when the
|
|
2368 terminal is so dumb that emacs gives up before and doesn't bother
|
|
2369 using the window system.
|
|
2370
|
|
2371 If the DISPLAY environment variable is set, try to use X, and die
|
|
2372 with an error message if that doesn't work. */
|
314
|
2373
|
|
2374 #ifdef HAVE_X_WINDOWS
|
2359
|
2375 if (! display_arg)
|
|
2376 {
|
|
2377 #ifdef VMS
|
2511
|
2378 display_arg = (getenv ("DECW$DISPLAY") != 0);
|
2359
|
2379 #else
|
2511
|
2380 display_arg = (getenv ("DISPLAY") != 0);
|
2359
|
2381 #endif
|
2364
|
2382 }
|
2359
|
2383
|
|
2384 if (!inhibit_window_system && display_arg)
|
314
|
2385 {
|
|
2386 Vwindow_system = intern ("x");
|
|
2387 #ifdef HAVE_X11
|
|
2388 Vwindow_system_version = make_number (11);
|
|
2389 #else
|
|
2390 Vwindow_system_version = make_number (10);
|
|
2391 #endif
|
|
2392 return;
|
|
2393 }
|
|
2394 #endif /* HAVE_X_WINDOWS */
|
|
2395
|
|
2396 /* If no window system has been specified, try to use the terminal. */
|
|
2397 if (! isatty (0))
|
|
2398 {
|
|
2399 fprintf (stderr, "emacs: standard input is not a tty\n");
|
|
2400 exit (1);
|
|
2401 }
|
|
2402
|
|
2403 /* Look at the TERM variable */
|
|
2404 terminal_type = (char *) getenv ("TERM");
|
|
2405 if (!terminal_type)
|
|
2406 {
|
|
2407 #ifdef VMS
|
|
2408 fprintf (stderr, "Please specify your terminal type.\n\
|
|
2409 For types defined in VMS, use set term /device=TYPE.\n\
|
|
2410 For types not defined in VMS, use define emacs_term \"TYPE\".\n\
|
|
2411 \(The quotation marks are necessary since terminal types are lower case.)\n");
|
|
2412 #else
|
|
2413 fprintf (stderr, "Please set the environment variable TERM; see tset(1).\n");
|
|
2414 #endif
|
|
2415 exit (1);
|
|
2416 }
|
|
2417
|
|
2418 #ifdef VMS
|
|
2419 /* VMS DCL tends to upcase things, so downcase term type.
|
|
2420 Hardly any uppercase letters in terminal types; should be none. */
|
|
2421 {
|
|
2422 char *new = (char *) xmalloc (strlen (terminal_type) + 1);
|
|
2423 char *p;
|
|
2424
|
|
2425 strcpy (new, terminal_type);
|
|
2426
|
|
2427 for (p = new; *p; p++)
|
|
2428 if (isupper (*p))
|
|
2429 *p = tolower (*p);
|
|
2430
|
|
2431 terminal_type = new;
|
|
2432 }
|
|
2433 #endif
|
|
2434
|
|
2435 term_init (terminal_type);
|
|
2436
|
764
|
2437 remake_frame_glyphs (selected_frame);
|
|
2438 calculate_costs (selected_frame);
|
314
|
2439
|
|
2440 /* X and Y coordinates of the cursor between updates. */
|
764
|
2441 FRAME_CURSOR_X (selected_frame) = 0;
|
|
2442 FRAME_CURSOR_Y (selected_frame) = 0;
|
314
|
2443
|
|
2444 #ifdef SIGWINCH
|
|
2445 #ifndef CANNOT_DUMP
|
|
2446 if (initialized)
|
|
2447 #endif /* CANNOT_DUMP */
|
|
2448 signal (SIGWINCH, window_change_signal);
|
|
2449 #endif /* SIGWINCH */
|
|
2450 }
|
|
2451
|
|
2452 syms_of_display ()
|
|
2453 {
|
764
|
2454 #ifdef MULTI_FRAME
|
|
2455 defsubr (&Sredraw_frame);
|
314
|
2456 #endif
|
|
2457 defsubr (&Sredraw_display);
|
7810
|
2458 defsubr (&Sframe_or_buffer_changed_p);
|
314
|
2459 defsubr (&Sopen_termscript);
|
|
2460 defsubr (&Sding);
|
|
2461 defsubr (&Ssit_for);
|
|
2462 defsubr (&Ssleep_for);
|
|
2463 defsubr (&Ssend_string_to_terminal);
|
|
2464
|
7810
|
2465 frame_and_buffer_state = Fmake_vector (make_number (1), Qlambda);
|
|
2466 staticpro (&frame_and_buffer_state);
|
|
2467
|
314
|
2468 DEFVAR_INT ("baud-rate", &baud_rate,
|
7926
|
2469 "*The output baud rate of the terminal.\n\
|
314
|
2470 On most systems, changing this value will affect the amount of padding\n\
|
|
2471 and the other strategic decisions made during redisplay.");
|
|
2472 DEFVAR_BOOL ("inverse-video", &inverse_video,
|
764
|
2473 "*Non-nil means invert the entire frame display.\n\
|
314
|
2474 This means everything is in inverse video which otherwise would not be.");
|
|
2475 DEFVAR_BOOL ("visible-bell", &visible_bell,
|
764
|
2476 "*Non-nil means try to flash the frame to represent a bell.");
|
314
|
2477 DEFVAR_BOOL ("no-redraw-on-reenter", &no_redraw_on_reenter,
|
764
|
2478 "*Non-nil means no need to redraw entire frame after suspending.\n\
|
314
|
2479 A non-nil value is useful if the terminal can automatically preserve\n\
|
764
|
2480 Emacs's frame display when you reenter Emacs.\n\
|
314
|
2481 It is up to you to set this variable if your terminal can do that.");
|
|
2482 DEFVAR_LISP ("window-system", &Vwindow_system,
|
|
2483 "A symbol naming the window-system under which Emacs is running\n\
|
|
2484 \(such as `x'), or nil if emacs is running on an ordinary terminal.");
|
|
2485 DEFVAR_LISP ("window-system-version", &Vwindow_system_version,
|
|
2486 "The version number of the window system in use.\n\
|
|
2487 For X windows, this is 10 or 11.");
|
|
2488 DEFVAR_BOOL ("cursor-in-echo-area", &cursor_in_echo_area,
|
|
2489 "Non-nil means put cursor in minibuffer, at end of any message there.");
|
|
2490 DEFVAR_LISP ("glyph-table", &Vglyph_table,
|
764
|
2491 "Table defining how to output a glyph code to the frame.\n\
|
314
|
2492 If not nil, this is a vector indexed by glyph code to define the glyph.\n\
|
|
2493 Each element can be:\n\
|
|
2494 integer: a glyph code which this glyph is an alias for.\n\
|
|
2495 string: output this glyph using that string (not impl. in X windows).\n\
|
|
2496 nil: this glyph mod 256 is char code to output,\n\
|
6857
|
2497 and this glyph / 256 is face code for X windows (see `face-id').");
|
314
|
2498 Vglyph_table = Qnil;
|
|
2499
|
|
2500 DEFVAR_LISP ("standard-display-table", &Vstandard_display_table,
|
|
2501 "Display table to use for buffers that specify none.\n\
|
|
2502 See `buffer-display-table' for more information.");
|
|
2503 Vstandard_display_table = Qnil;
|
|
2504
|
|
2505 /* Initialize `window-system', unless init_display already decided it. */
|
|
2506 #ifdef CANNOT_DUMP
|
|
2507 if (noninteractive)
|
|
2508 #endif
|
|
2509 {
|
|
2510 Vwindow_system = Qnil;
|
|
2511 Vwindow_system_version = Qnil;
|
|
2512 }
|
|
2513 }
|