|
428
|
1 /* Redisplay data structures.
|
|
|
2 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
|
|
|
3 Copyright (C) 1996 Chuck Thompson.
|
|
1318
|
4 Copyright (C) 1995, 1996, 2002, 2003 Ben Wing.
|
|
428
|
5
|
|
|
6 This file is part of XEmacs.
|
|
|
7
|
|
|
8 XEmacs is free software; you can redistribute it and/or modify it
|
|
|
9 under the terms of the GNU General Public License as published by the
|
|
|
10 Free Software Foundation; either version 2, or (at your option) any
|
|
|
11 later version.
|
|
|
12
|
|
|
13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
|
|
|
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
16 for more details.
|
|
|
17
|
|
|
18 You should have received a copy of the GNU General Public License
|
|
|
19 along with XEmacs; see the file COPYING. If not, write to
|
|
|
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
21 Boston, MA 02111-1307, USA. */
|
|
|
22
|
|
|
23 /* Synched up with: Not in FSF. */
|
|
|
24
|
|
440
|
25 #ifndef INCLUDED_redisplay_h_
|
|
|
26 #define INCLUDED_redisplay_h_
|
|
428
|
27
|
|
|
28 /* Redisplay DASSERT types */
|
|
|
29 #define DB_DISP_POS 1
|
|
|
30 #define DB_DISP_TEXT_LAYOUT 2
|
|
|
31 #define DB_DISP_REDISPLAY 4
|
|
|
32
|
|
|
33 /* These are the possible return values from pixel_to_glyph_translation. */
|
|
|
34 #define OVER_MODELINE 0
|
|
|
35 #define OVER_TEXT 1
|
|
|
36 #define OVER_OUTSIDE 2
|
|
|
37 #define OVER_NOTHING 3
|
|
|
38 #define OVER_BORDER 4
|
|
|
39 #define OVER_TOOLBAR 5
|
|
|
40 #define OVER_V_DIVIDER 6
|
|
|
41
|
|
|
42 #define NO_BLOCK -1
|
|
|
43
|
|
|
44 /* Imagine that the text in the buffer is displayed on a piece of paper
|
|
|
45 the width of the frame and very very tall. The line start cache is
|
|
|
46 an array of struct line_start_cache's, describing the start and
|
|
|
47 end buffer positions for a contiguous set of lines on that piece
|
|
|
48 of paper. */
|
|
|
49
|
|
|
50 typedef struct line_start_cache line_start_cache;
|
|
|
51 struct line_start_cache
|
|
|
52 {
|
|
665
|
53 Charbpos start, end;
|
|
428
|
54 int height;
|
|
|
55 };
|
|
|
56
|
|
|
57 typedef struct
|
|
|
58 {
|
|
|
59 Dynarr_declare (line_start_cache);
|
|
|
60 } line_start_cache_dynarr;
|
|
|
61
|
|
|
62 /* The possible types of runes.
|
|
|
63
|
|
|
64 #### The Lisp_Glyph type is broken. There should instead be a pixmap
|
|
|
65 type. Currently the device-specific output routines have to worry
|
|
|
66 about whether the glyph is textual or not, etc. For Mule this is
|
|
|
67 a big problem because you might need multiple fonts to display the
|
|
|
68 text. It also eliminates optimizations that could come from glumping
|
|
|
69 the text of multiple text glyphs together -- this makes displaying
|
|
|
70 binary files (with lots of control chars, etc.) very very slow. */
|
|
|
71
|
|
|
72 #define RUNE_BLANK 0
|
|
|
73 #define RUNE_CHAR 1
|
|
|
74 #define RUNE_DGLYPH 2
|
|
|
75 #define RUNE_HLINE 3
|
|
|
76 #define RUNE_VLINE 4
|
|
|
77
|
|
|
78 #define CURSOR_ON 0
|
|
|
79 #define CURSOR_OFF 1
|
|
|
80 #define NO_CURSOR 2
|
|
|
81 #define NEXT_CURSOR 3
|
|
|
82 #define IGNORE_CURSOR 4
|
|
|
83
|
|
|
84 #define DEFAULT_INDEX (face_index) 0
|
|
|
85 #define MODELINE_INDEX (face_index) 1
|
|
|
86
|
|
|
87 /* A rune is a single display element, such as a printable character
|
|
|
88 or pixmap. Any single character in a buffer has one or more runes
|
|
|
89 (or zero, if the character is invisible) corresponding to it.
|
|
|
90 (Printable characters typically have one rune associated with them,
|
|
|
91 but control characters have two -- a ^ and a letter -- and other
|
|
|
92 non-printing characters (those displayed in octal) have four. */
|
|
|
93
|
|
|
94 /* WARNING! In compare_runes (one of the most heavily used functions)
|
|
|
95 two runes are compared. So please be careful with changes to this
|
|
|
96 structure. See comments in compare_runes.
|
|
|
97
|
|
|
98 #### This should really be made smaller.
|
|
|
99 */
|
|
432
|
100
|
|
1204
|
101 struct rune_dglyph
|
|
|
102 {
|
|
|
103 Lisp_Object glyph;
|
|
|
104 Lisp_Object extent; /* extent rune is attached to, if any.
|
|
|
105 If this is a rune in the modeline
|
|
|
106 then this might be nil. */
|
|
|
107
|
|
|
108 int ascent; /* Ascent of this glyph, in pixels. */
|
|
|
109 int descent; /* Descent of this glyph, in pixels. */
|
|
|
110 int yoffset; /* Offset from line top to reach glyph top */
|
|
|
111 int xoffset; /* Number of pixels that need to be
|
|
|
112 chopped off the left of the glyph.
|
|
|
113 This has the effect of shifting the
|
|
|
114 glyph to the left while still clipping
|
|
|
115 at XPOS. */
|
|
|
116 };
|
|
|
117
|
|
428
|
118 typedef struct rune rune;
|
|
|
119 struct rune
|
|
|
120 {
|
|
|
121 face_index findex; /* face rune is displayed with. The
|
|
|
122 face_index is an index into a
|
|
|
123 window-specific array of face cache
|
|
|
124 elements. Each face cache element
|
|
|
125 corresponds to one "merged face"
|
|
|
126 (the result of merging all the
|
|
|
127 faces that overlap the rune) and
|
|
|
128 contains the instance values for
|
|
|
129 each of the face properties in this
|
|
|
130 particular window. */
|
|
|
131
|
|
826
|
132 Charxpos charpos; /* buffer position this rune is displaying;
|
|
428
|
133 for the modeline, the value here is a
|
|
|
134 Charcount, but who's looking? */
|
|
826
|
135 Charxpos endpos; /* if set this rune covers a range of pos;
|
|
|
136 used in redisplay_move_cursor(). */
|
|
428
|
137 /* #### Chuck, what does it mean for a rune
|
|
|
138 to cover a range of pos? I don't get
|
|
|
139 this. */
|
|
432
|
140
|
|
|
141
|
|
428
|
142 short xpos; /* horizontal starting position in pixels */
|
|
|
143 short width; /* pixel width of rune */
|
|
432
|
144
|
|
|
145
|
|
428
|
146 unsigned char cursor_type; /* is this rune covered by the cursor? */
|
|
|
147 unsigned char type; /* type of rune object */
|
|
|
148 /* We used to do bitfields here, but if I
|
|
|
149 (JV) count correctly that doesn't matter
|
|
|
150 for the size of the structure. All the bit
|
|
|
151 fiddling _does_ slow down redisplay by
|
|
|
152 about 10%. So don't do that */
|
|
|
153
|
|
|
154 union /* Information specific to the type of rune */
|
|
|
155 {
|
|
450
|
156 /* #### Glyphs are rare. Is it really necessary to waste 8 bytes on every
|
|
428
|
157 rune for that?! */
|
|
|
158 /* DGLYPH */
|
|
1204
|
159 struct rune_dglyph dglyph;
|
|
428
|
160
|
|
|
161 /* CHAR */
|
|
|
162 struct
|
|
|
163 {
|
|
867
|
164 Ichar ch; /* Character of this rune. */
|
|
428
|
165 } chr;
|
|
|
166
|
|
|
167 /* HLINE */
|
|
|
168 struct
|
|
|
169 {
|
|
|
170 short thickness; /* how thick to make hline */
|
|
|
171 short yoffset; /* how far down from top of line to put top */
|
|
|
172 } hline;
|
|
|
173 } object; /* actual rune object */
|
|
|
174 };
|
|
|
175
|
|
|
176 typedef struct
|
|
|
177 {
|
|
|
178 Dynarr_declare (rune);
|
|
|
179 } rune_dynarr;
|
|
|
180
|
|
|
181 /* These must have distinct values. Note that the ordering actually
|
|
|
182 represents priority levels. TEXT has the lowest priority level. */
|
|
|
183 enum display_type
|
|
|
184 {
|
|
|
185 TEXT,
|
|
|
186 LEFT_OUTSIDE_MARGIN,
|
|
|
187 LEFT_INSIDE_MARGIN,
|
|
|
188 RIGHT_INSIDE_MARGIN,
|
|
|
189 RIGHT_OUTSIDE_MARGIN,
|
|
|
190 OVERWRITE
|
|
|
191 };
|
|
|
192
|
|
|
193 /* A display block represents a run of text on a single line.
|
|
|
194 Apparently there is only one display block per line for each
|
|
|
195 of the types listed in `enum display_type'.
|
|
|
196
|
|
|
197 A display block consists mostly of an array of runes, one per
|
|
|
198 atomic display element (printable character, pixmap, etc.). */
|
|
|
199
|
|
|
200 /* #### Yuckity yuckity yuck yuck yuck yuck yuck!!
|
|
|
201
|
|
|
202 Chuck, I think you should redo this. It should not be the
|
|
|
203 responsibility of the device-specific code to worry about
|
|
|
204 the different faces. The generic stuff in redisplay-output.c
|
|
|
205 should glump things up into sub-blocks, each of which
|
|
|
206 corresponds to a single pixmap or a single run of text in
|
|
|
207 the same font.
|
|
|
208
|
|
|
209 It might still make sense for the device-specific output routine
|
|
|
210 to get passed an entire display line. That way, it can make
|
|
|
211 calls to XDrawText() (which draws multiple runs of single-font
|
|
|
212 data) instead of XDrawString(). The reason for this is to
|
|
|
213 reduce the amount of X traffic, which will help things significantly
|
|
|
214 on a slow line. */
|
|
|
215
|
|
|
216 typedef struct display_block display_block;
|
|
|
217 struct display_block
|
|
|
218 {
|
|
|
219 enum display_type type; /* type of display block */
|
|
|
220
|
|
|
221 int start_pos; /* starting pixel position of block */
|
|
|
222 int end_pos; /* ending pixel position of block */
|
|
|
223
|
|
|
224 rune_dynarr *runes; /* Dynamic array of runes */
|
|
|
225 };
|
|
|
226
|
|
|
227 typedef struct
|
|
|
228 {
|
|
|
229 Dynarr_declare (display_block);
|
|
|
230 } display_block_dynarr;
|
|
|
231
|
|
|
232 typedef struct layout_bounds_type
|
|
|
233 {
|
|
|
234 int left_out;
|
|
|
235 int left_in;
|
|
|
236 int left_white;
|
|
|
237 int right_white;
|
|
|
238 int right_in;
|
|
|
239 int right_out;
|
|
|
240 } layout_bounds;
|
|
|
241
|
|
|
242 typedef struct glyph_block glyph_block;
|
|
|
243 struct glyph_block
|
|
|
244 {
|
|
|
245 Lisp_Object glyph;
|
|
|
246 Lisp_Object extent;
|
|
|
247 /* The rest are only used by margin routines. */
|
|
|
248 face_index findex;
|
|
|
249 int active;
|
|
|
250 int width;
|
|
|
251 };
|
|
|
252
|
|
|
253 typedef struct
|
|
|
254 {
|
|
|
255 Dynarr_declare (glyph_block);
|
|
|
256 } glyph_block_dynarr;
|
|
|
257
|
|
|
258 /*************************************************************************/
|
|
617
|
259 /* display lines */
|
|
428
|
260 /*************************************************************************/
|
|
|
261
|
|
826
|
262 /* Modeline commentary: IMO the modeline is handled very badly, we
|
|
428
|
263 special case virtually *everything* in the redisplay routines for
|
|
826
|
264 the modeline. The fact that dl->charpos can be either a buffer
|
|
428
|
265 position or a char count highlights this. There is no abstraction at
|
|
|
266 all that I can find and it means that the code is made very ugly as
|
|
|
267 a result. Either we should treat the modeline *entirely* separately,
|
|
|
268 or we should abstract to something that applies equally well to the
|
|
|
269 modeline and to buffer text, the things are not enormously different
|
|
|
270 after all and handling them identically at some level would
|
|
|
271 eliminate some bugs that still exist (mainly to do with modeline
|
|
|
272 handling). This problem doesn't help trying to implement gutters
|
|
|
273 which are somewhere in between buffer text and modeline text.
|
|
|
274
|
|
|
275 Redisplay commentary: Everything in redisplay is tied very tightly
|
|
|
276 to the things that are being displayed, and the context,
|
|
|
277 e.g. buffers and windows. According to Chuck this is so that we can
|
|
|
278 get speed, which seems fine to me, however this usage is extended
|
|
442
|
279 too far down the redisplay routines IMO. At some level there should
|
|
428
|
280 be functions that know how to display strings with extents and
|
|
|
281 faces, regardless of buffer etc. After all the window system does
|
|
|
282 not care. <andy@xemacs.org> */
|
|
|
283
|
|
|
284 typedef struct display_line display_line;
|
|
|
285 struct display_line
|
|
|
286 {
|
|
|
287 short ypos; /* vertical position in pixels
|
|
|
288 of the baseline for this line. */
|
|
|
289 unsigned short ascent, descent; /* maximum values for this line.
|
|
|
290 The ascent is the number of
|
|
|
291 pixels above the baseline, and
|
|
|
292 the descent is the number of
|
|
|
293 pixels below the baseline.
|
|
|
294 The descent includes the baseline
|
|
|
295 pixel-row itself, I think. */
|
|
|
296 unsigned short clip; /* amount of bottom of line to clip
|
|
|
297 in pixels.*/
|
|
|
298 unsigned short top_clip; /* amount of top of line to clip
|
|
|
299 in pixels.*/
|
|
826
|
300 Charxpos charpos; /* first buffer position on line */
|
|
|
301 Charxpos end_charpos; /* last buffer position on line */
|
|
|
302 Charcount offset; /* adjustment to charpos vals */
|
|
428
|
303 Charcount num_chars; /* # of chars on line
|
|
|
304 including expansion of tabs
|
|
|
305 and control chars */
|
|
|
306 int cursor_elt; /* rune block of TEXT display
|
|
|
307 block cursor is at or -1 */
|
|
|
308 char used_prop_data; /* can't incrementally update if line
|
|
|
309 used propagation data */
|
|
|
310
|
|
|
311 layout_bounds bounds; /* line boundary positions */
|
|
|
312
|
|
|
313 char modeline; /* t if this line is a modeline */
|
|
|
314
|
|
442
|
315 char line_continuation; /* t if this line continues to
|
|
|
316 next display line. */
|
|
|
317
|
|
428
|
318 /* Dynamic array of display blocks */
|
|
|
319 display_block_dynarr *display_blocks;
|
|
|
320
|
|
|
321 /* Dynamic arrays of left and right glyph blocks */
|
|
|
322 glyph_block_dynarr *left_glyphs;
|
|
|
323 glyph_block_dynarr *right_glyphs;
|
|
|
324
|
|
|
325 face_index left_margin_findex;
|
|
|
326 face_index right_margin_findex;
|
|
|
327 face_index default_findex;
|
|
|
328 };
|
|
|
329
|
|
|
330 #define DISPLAY_LINE_HEIGHT(dl) \
|
|
|
331 (dl->ascent + dl->descent - (dl->clip + dl->top_clip))
|
|
|
332 #define DISPLAY_LINE_YPOS(dl) \
|
|
|
333 (dl->ypos - (dl->ascent - dl->top_clip))
|
|
|
334 #define DISPLAY_LINE_YEND(dl) \
|
|
|
335 ((dl->ypos + dl->descent) - dl->clip)
|
|
|
336
|
|
|
337 typedef struct
|
|
|
338 {
|
|
|
339 Dynarr_declare (display_line);
|
|
|
340 } display_line_dynarr;
|
|
|
341
|
|
|
342 /* The following two structures are used to represent an area to
|
|
|
343 displayed and where to display it. Using these two structures all
|
|
|
344 combinations of clipping and position can be accommodated. */
|
|
|
345
|
|
|
346 /* This represents an area to be displayed into. */
|
|
|
347 typedef struct display_box display_box;
|
|
|
348 struct display_box
|
|
|
349 {
|
|
|
350 int xpos; /* absolute horizontal position of area */
|
|
|
351 int ypos; /* absolute vertical position of area */
|
|
|
352 int width, height;
|
|
|
353 };
|
|
|
354
|
|
|
355 /* This represents the area from a glyph to be displayed. */
|
|
|
356 typedef struct display_glyph_area display_glyph_area;
|
|
|
357 struct display_glyph_area
|
|
|
358 {
|
|
|
359 int xoffset; /* horizontal offset of the glyph, +ve means
|
|
|
360 display the glyph with x offset by xoffset,
|
|
|
361 -ve means display starting xoffset into the
|
|
|
362 glyph. */
|
|
|
363 int yoffset; /* vertical offset of the glyph, +ve means
|
|
|
364 display the glyph with y offset by yoffset,
|
|
|
365 -ve means display starting xoffset into the
|
|
|
366 glyph. */
|
|
|
367 int width, height; /* width and height of glyph to display. */
|
|
|
368 };
|
|
|
369
|
|
|
370 /* It could be argued that the following two structs belong in
|
|
|
371 extents.h, but they're only used by redisplay and it simplifies
|
|
|
372 the header files to put them here. */
|
|
|
373
|
|
|
374 typedef struct
|
|
|
375 {
|
|
|
376 Dynarr_declare (EXTENT);
|
|
|
377 } EXTENT_dynarr;
|
|
|
378
|
|
|
379 struct font_metric_info
|
|
|
380 {
|
|
|
381 int width;
|
|
|
382 int height; /* always ascent + descent; for convenience */
|
|
|
383 int ascent;
|
|
|
384 int descent;
|
|
|
385
|
|
|
386 int proportional_p;
|
|
|
387 };
|
|
|
388
|
|
|
389 /* NOTE NOTE NOTE: Currently the positions in an extent fragment
|
|
826
|
390 structure are Bytexpos's, not Charxpos's. This could change. */
|
|
428
|
391
|
|
|
392 struct extent_fragment
|
|
|
393 {
|
|
|
394 Lisp_Object object; /* buffer or string */
|
|
|
395 struct frame *frm;
|
|
826
|
396 Bytexpos pos, end;
|
|
428
|
397 EXTENT_dynarr *extents;
|
|
|
398 glyph_block_dynarr *begin_glyphs, *end_glyphs;
|
|
|
399 unsigned int invisible:1;
|
|
|
400 unsigned int invisible_ellipses:1;
|
|
|
401 unsigned int previously_invisible:1;
|
|
|
402 unsigned int invisible_ellipses_already_displayed:1;
|
|
|
403 };
|
|
|
404
|
|
|
405 #define EDGE_TOP 1
|
|
|
406 #define EDGE_LEFT 2
|
|
|
407 #define EDGE_BOTTOM 4
|
|
|
408 #define EDGE_RIGHT 8
|
|
|
409 #define EDGE_ALL (EDGE_TOP | EDGE_LEFT | EDGE_BOTTOM | EDGE_RIGHT)
|
|
|
410
|
|
|
411
|
|
|
412 /*************************************************************************/
|
|
|
413 /* change flags */
|
|
|
414 /*************************************************************************/
|
|
|
415
|
|
|
416 /* Quick flags to signal redisplay. redisplay() sets them all to 0
|
|
|
417 when it finishes. If none of them are set when it starts, it
|
|
|
418 assumes that nothing needs to be done. Functions that make a change
|
|
|
419 that is (potentially) visible on the screen should set the
|
|
|
420 appropriate flag.
|
|
|
421
|
|
|
422 If any of these flags are set, redisplay will look more carefully
|
|
|
423 to see if anything has really changed. */
|
|
|
424
|
|
442
|
425 /* Nonzero if the contents of a buffer have changed since the last time
|
|
|
426 redisplay completed. */
|
|
428
|
427 extern int buffers_changed;
|
|
|
428 extern int buffers_changed_set;
|
|
|
429
|
|
|
430 /* Nonzero if head_clip or tail_clip of a buffer has changed
|
|
442
|
431 since last redisplay that finished. */
|
|
428
|
432 extern int clip_changed;
|
|
|
433 extern int clip_changed_set;
|
|
|
434
|
|
442
|
435 /* Nonzero if any extent has changed since the last time redisplay completed. */
|
|
428
|
436 extern int extents_changed;
|
|
|
437 extern int extents_changed_set;
|
|
|
438
|
|
442
|
439 /* Nonzero if any face has changed since the last time redisplay completed. */
|
|
428
|
440 extern int faces_changed;
|
|
|
441
|
|
442
|
442 /* Nonzero means one or more frames have been marked as garbaged. */
|
|
428
|
443 extern int frame_changed;
|
|
|
444
|
|
|
445 /* True if any of the builtin display glyphs (continuation,
|
|
|
446 hscroll, control-arrow, etc) is in need of updating
|
|
|
447 somewhere. */
|
|
|
448 extern int glyphs_changed;
|
|
|
449 extern int glyphs_changed_set;
|
|
|
450
|
|
|
451 /* True if any displayed subwindow is in need of updating
|
|
|
452 somewhere. */
|
|
|
453 extern int subwindows_changed;
|
|
|
454 extern int subwindows_changed_set;
|
|
|
455
|
|
|
456 /* True if any displayed subwindow is in need of updating
|
|
|
457 somewhere. */
|
|
|
458 extern int subwindows_state_changed;
|
|
|
459 extern int subwindows_state_changed_set;
|
|
|
460
|
|
|
461 /* True if an icon is in need of updating somewhere. */
|
|
|
462 extern int icon_changed;
|
|
|
463 extern int icon_changed_set;
|
|
|
464
|
|
|
465 /* True if a menubar is in need of updating somewhere. */
|
|
|
466 extern int menubar_changed;
|
|
|
467 extern int menubar_changed_set;
|
|
|
468
|
|
442
|
469 /* True iff we should redraw the modelines on the next redisplay. */
|
|
428
|
470 extern int modeline_changed;
|
|
|
471 extern int modeline_changed_set;
|
|
|
472
|
|
442
|
473 /* Nonzero if point has changed in some buffer since the last time
|
|
|
474 redisplay completed. */
|
|
428
|
475 extern int point_changed;
|
|
|
476 extern int point_changed_set;
|
|
|
477
|
|
442
|
478 /* Nonzero if some frame has changed its size. */
|
|
428
|
479 extern int size_changed;
|
|
|
480
|
|
442
|
481 /* Nonzero if some device has signaled that it wants to change size. */
|
|
428
|
482 extern int asynch_device_change_pending;
|
|
|
483
|
|
905
|
484 /* Nonzero if some frame has changed the layout of internal elements
|
|
|
485 (gutters or toolbars). */
|
|
|
486 extern int frame_layout_changed;
|
|
|
487
|
|
442
|
488 /* Nonzero if any toolbar has changed. */
|
|
428
|
489 extern int toolbar_changed;
|
|
|
490 extern int toolbar_changed_set;
|
|
|
491
|
|
442
|
492 /* Nonzero if any gutter has changed. */
|
|
428
|
493 extern int gutter_changed;
|
|
|
494 extern int gutter_changed_set;
|
|
|
495
|
|
442
|
496 /* Nonzero if any window has changed since the last time redisplay completed */
|
|
428
|
497 extern int windows_changed;
|
|
|
498
|
|
442
|
499 /* Nonzero if any frame's window structure has changed since the last
|
|
|
500 time redisplay completed. */
|
|
428
|
501 extern int windows_structure_changed;
|
|
|
502
|
|
|
503 /* These macros can be relatively expensive. Since they are often
|
|
|
504 called numerous times between each call to redisplay, we keep track
|
|
|
505 if each has already been called and don't bother doing most of the
|
|
|
506 work if it is currently set. */
|
|
|
507
|
|
|
508 #define MARK_TYPE_CHANGED(object) do { \
|
|
|
509 if (!object##_changed_set) { \
|
|
|
510 Lisp_Object MTC_devcons, MTC_concons; \
|
|
|
511 DEVICE_LOOP_NO_BREAK (MTC_devcons, MTC_concons) \
|
|
|
512 { \
|
|
|
513 Lisp_Object MTC_frmcons; \
|
|
|
514 struct device *MTC_d = XDEVICE (XCAR (MTC_devcons)); \
|
|
|
515 DEVICE_FRAME_LOOP (MTC_frmcons, MTC_d) \
|
|
|
516 { \
|
|
|
517 struct frame *MTC_f = XFRAME (XCAR (MTC_frmcons)); \
|
|
|
518 MTC_f->object##_changed = 1; \
|
|
|
519 MTC_f->modiff++; \
|
|
|
520 } \
|
|
|
521 MTC_d->object##_changed = 1; \
|
|
|
522 } \
|
|
|
523 object##_changed = 1; \
|
|
|
524 object##_changed_set = 1; } \
|
|
|
525 } while (0)
|
|
|
526
|
|
872
|
527 void mark_buffers_changed (void);
|
|
|
528 #define MARK_BUFFERS_CHANGED mark_buffers_changed ()
|
|
|
529 void mark_clip_changed (void);
|
|
|
530 #define MARK_CLIP_CHANGED mark_clip_changed ()
|
|
|
531 void mark_extents_changed (void);
|
|
|
532 #define MARK_EXTENTS_CHANGED mark_extents_changed ()
|
|
|
533 void mark_icon_changed (void);
|
|
|
534 #define MARK_ICON_CHANGED mark_icon_changed ()
|
|
|
535 void mark_menubar_changed (void);
|
|
|
536 #define MARK_MENUBAR_CHANGED mark_menubar_changed ()
|
|
|
537 void mark_modeline_changed (void);
|
|
|
538 #define MARK_MODELINE_CHANGED mark_modeline_changed ()
|
|
|
539 void mark_point_changed (void);
|
|
|
540 #define MARK_POINT_CHANGED mark_point_changed ()
|
|
|
541 void mark_toolbar_changed (void);
|
|
|
542 #define MARK_TOOLBAR_CHANGED mark_toolbar_changed ()
|
|
|
543 void mark_gutter_changed (void);
|
|
|
544 #define MARK_GUTTER_CHANGED mark_gutter_changed ()
|
|
|
545 void mark_glyphs_changed (void);
|
|
|
546 #define MARK_GLYPHS_CHANGED mark_glyphs_changed ()
|
|
|
547 void mark_subwindows_changed (void);
|
|
|
548 #define MARK_SUBWINDOWS_CHANGED mark_subwindows_changed ()
|
|
|
549 void mark_subwindows_state_changed (void);
|
|
|
550 #define MARK_SUBWINDOWS_STATE_CHANGED mark_subwindows_state_changed ()
|
|
428
|
551
|
|
|
552 #define CLASS_RESET_CHANGED_FLAGS(p) do { \
|
|
|
553 (p)->buffers_changed = 0; \
|
|
|
554 (p)->clip_changed = 0; \
|
|
|
555 (p)->extents_changed = 0; \
|
|
|
556 (p)->faces_changed = 0; \
|
|
|
557 (p)->frame_changed = 0; \
|
|
905
|
558 (p)->frame_layout_changed = 0; \
|
|
428
|
559 (p)->icon_changed = 0; \
|
|
|
560 (p)->menubar_changed = 0; \
|
|
|
561 (p)->modeline_changed = 0; \
|
|
|
562 (p)->point_changed = 0; \
|
|
|
563 (p)->toolbar_changed = 0; \
|
|
|
564 (p)->gutter_changed = 0; \
|
|
|
565 (p)->glyphs_changed = 0; \
|
|
|
566 (p)->subwindows_changed = 0; \
|
|
|
567 (p)->subwindows_state_changed = 0; \
|
|
|
568 (p)->windows_changed = 0; \
|
|
|
569 (p)->windows_structure_changed = 0; \
|
|
|
570 } while (0)
|
|
|
571
|
|
|
572 #define GLOBAL_RESET_CHANGED_FLAGS do { \
|
|
|
573 buffers_changed = 0; \
|
|
|
574 clip_changed = 0; \
|
|
|
575 extents_changed = 0; \
|
|
|
576 frame_changed = 0; \
|
|
905
|
577 frame_layout_changed = 0; \
|
|
428
|
578 icon_changed = 0; \
|
|
|
579 menubar_changed = 0; \
|
|
|
580 modeline_changed = 0; \
|
|
|
581 point_changed = 0; \
|
|
|
582 toolbar_changed = 0; \
|
|
|
583 gutter_changed = 0; \
|
|
|
584 glyphs_changed = 0; \
|
|
|
585 subwindows_changed = 0; \
|
|
442
|
586 subwindows_state_changed = 0; \
|
|
428
|
587 windows_changed = 0; \
|
|
|
588 windows_structure_changed = 0; \
|
|
|
589 } while (0)
|
|
|
590
|
|
|
591 #define CLASS_REDISPLAY_FLAGS_CHANGEDP(p) \
|
|
|
592 ( (p)->buffers_changed || \
|
|
|
593 (p)->clip_changed || \
|
|
|
594 (p)->extents_changed || \
|
|
|
595 (p)->faces_changed || \
|
|
|
596 (p)->frame_changed || \
|
|
905
|
597 (p)->frame_layout_changed || \
|
|
428
|
598 (p)->icon_changed || \
|
|
|
599 (p)->menubar_changed || \
|
|
|
600 (p)->modeline_changed || \
|
|
|
601 (p)->point_changed || \
|
|
|
602 (p)->toolbar_changed || \
|
|
|
603 (p)->gutter_changed || \
|
|
|
604 (p)->glyphs_changed || \
|
|
442
|
605 (p)->size_changed || \
|
|
428
|
606 (p)->subwindows_changed || \
|
|
|
607 (p)->subwindows_state_changed || \
|
|
|
608 (p)->windows_changed || \
|
|
|
609 (p)->windows_structure_changed )
|
|
|
610
|
|
|
611 #define GLOBAL_REDISPLAY_FLAGS_CHANGEDP \
|
|
|
612 ( buffers_changed || \
|
|
|
613 clip_changed || \
|
|
|
614 extents_changed || \
|
|
|
615 faces_changed || \
|
|
|
616 frame_changed || \
|
|
905
|
617 frame_layout_changed || \
|
|
428
|
618 icon_changed || \
|
|
|
619 menubar_changed || \
|
|
|
620 modeline_changed || \
|
|
|
621 point_changed || \
|
|
|
622 toolbar_changed || \
|
|
|
623 gutter_changed || \
|
|
|
624 glyphs_changed || \
|
|
430
|
625 size_changed || \
|
|
428
|
626 subwindows_changed || \
|
|
|
627 subwindows_state_changed || \
|
|
|
628 windows_changed || \
|
|
|
629 windows_structure_changed )
|
|
|
630
|
|
|
631
|
|
|
632 /* Anytime a console, device or frame is added or deleted we need to reset
|
|
|
633 these flags. */
|
|
|
634 #define RESET_CHANGED_SET_FLAGS do { \
|
|
|
635 buffers_changed_set = 0; \
|
|
|
636 clip_changed_set = 0; \
|
|
|
637 extents_changed_set = 0; \
|
|
|
638 icon_changed_set = 0; \
|
|
|
639 menubar_changed_set = 0; \
|
|
|
640 modeline_changed_set = 0; \
|
|
|
641 point_changed_set = 0; \
|
|
|
642 toolbar_changed_set = 0; \
|
|
|
643 gutter_changed_set = 0; \
|
|
|
644 glyphs_changed_set = 0; \
|
|
|
645 subwindows_changed_set = 0; \
|
|
|
646 subwindows_state_changed_set = 0; \
|
|
|
647 } while (0)
|
|
|
648
|
|
|
649
|
|
|
650 /*************************************************************************/
|
|
|
651 /* redisplay global variables */
|
|
|
652 /*************************************************************************/
|
|
|
653
|
|
1204
|
654 extern const struct sized_memory_description display_line_dynarr_description;
|
|
|
655
|
|
428
|
656 /* redisplay structure used by various utility routines. */
|
|
|
657 extern display_line_dynarr *cmotion_display_lines;
|
|
|
658
|
|
|
659 /* Nonzero means truncate lines in all windows less wide than the frame. */
|
|
|
660 extern int truncate_partial_width_windows;
|
|
|
661
|
|
|
662 /* Nonzero if we're in a display critical section. */
|
|
|
663 extern int in_display;
|
|
|
664
|
|
1318
|
665 /* Whether we should delay size changes. Broken out of
|
|
|
666 enter_redisplay_critical_section(). */
|
|
|
667 extern int hold_frame_size_changes;
|
|
|
668
|
|
428
|
669 /* Nonzero means no need to redraw the entire frame on resuming
|
|
|
670 a suspended Emacs. This is useful on terminals with multiple pages,
|
|
|
671 where one page is used for Emacs and another for all else. */
|
|
|
672 extern int no_redraw_on_reenter;
|
|
|
673
|
|
442
|
674 /* Non-nil means flash the frame instead of ringing the bell. */
|
|
|
675 extern Lisp_Object Vvisible_bell;
|
|
428
|
676
|
|
|
677 /* Thickness of shadow border around 3D modelines. */
|
|
|
678 extern Lisp_Object Vmodeline_shadow_thickness;
|
|
|
679
|
|
|
680 /* Scroll if point lands on the bottom line and that line is partially
|
|
|
681 clipped. */
|
|
|
682 extern int scroll_on_clipped_lines;
|
|
|
683
|
|
|
684 extern Lisp_Object Vglobal_mode_string;
|
|
|
685
|
|
|
686 /* The following two variables are defined in emacs.c and are used
|
|
|
687 to convey information discovered on the command line way early
|
|
|
688 (before *anything* is initialized). */
|
|
|
689
|
|
|
690 /* If non-zero, a window-system was specified on the command line.
|
|
|
691 Defined in emacs.c. */
|
|
|
692 extern int display_arg;
|
|
|
693
|
|
|
694 /* Type of display specified. Defined in emacs.c. */
|
|
771
|
695 extern const Char_ASCII *display_use;
|
|
428
|
696
|
|
|
697 /* Nonzero means reading single-character input with prompt
|
|
|
698 so put cursor on minibuffer after the prompt. */
|
|
|
699
|
|
|
700 extern int cursor_in_echo_area;
|
|
|
701
|
|
|
702 extern Lisp_Object Qbar_cursor, Qcursor_in_echo_area, Vwindow_system;
|
|
|
703
|
|
442
|
704 extern Lisp_Object Qtop_bottom;
|
|
|
705
|
|
428
|
706
|
|
|
707 /*************************************************************************/
|
|
|
708 /* redisplay exported functions */
|
|
|
709 /*************************************************************************/
|
|
|
710 EXFUN (Fredraw_frame, 2);
|
|
|
711
|
|
|
712 int redisplay_text_width_string (struct window *w, int findex,
|
|
867
|
713 Ibyte *nonreloc, Lisp_Object reloc,
|
|
428
|
714 Bytecount offset, Bytecount len);
|
|
|
715 int redisplay_frame_text_width_string (struct frame *f,
|
|
|
716 Lisp_Object face,
|
|
867
|
717 Ibyte *nonreloc,
|
|
428
|
718 Lisp_Object reloc,
|
|
|
719 Bytecount offset, Bytecount len);
|
|
442
|
720 int redisplay_frame (struct frame *f, int preemption_check);
|
|
853
|
721 void redisplay_no_pre_idle_hook (void);
|
|
428
|
722 void redisplay (void);
|
|
853
|
723 Lisp_Object eval_within_redisplay (Lisp_Object dont_trust_this_damn_sucker);
|
|
428
|
724 struct display_block *get_display_block_from_line (struct display_line *dl,
|
|
|
725 enum display_type type);
|
|
|
726 layout_bounds calculate_display_line_boundaries (struct window *w,
|
|
|
727 int modeline);
|
|
665
|
728 Charbpos point_at_center (struct window *w, int type, Charbpos start,
|
|
826
|
729 Charbpos point);
|
|
|
730 int line_at_center (struct window *w, int type, Charbpos start,
|
|
|
731 Charbpos point);
|
|
428
|
732 int window_half_pixpos (struct window *w);
|
|
|
733 void redisplay_echo_area (void);
|
|
|
734 void free_display_structs (struct window_mirror *mir);
|
|
|
735 void free_display_lines (display_line_dynarr *dla);
|
|
442
|
736 void mark_redisplay_structs (display_line_dynarr *dla);
|
|
428
|
737 void generate_displayable_area (struct window *w, Lisp_Object disp_string,
|
|
|
738 int xpos, int ypos, int width, int height,
|
|
|
739 display_line_dynarr* dl,
|
|
665
|
740 Charbpos start_pos, face_index default_face);
|
|
438
|
741 /* `generate_title_string' in frame.c needs this */
|
|
|
742 void generate_formatted_string_db (Lisp_Object format_str,
|
|
|
743 Lisp_Object result_str,
|
|
|
744 struct window *w,
|
|
|
745 struct display_line *dl,
|
|
|
746 struct display_block *db,
|
|
|
747 face_index findex,
|
|
|
748 int min_pixpos, int max_pixpos, int type);
|
|
428
|
749 int real_current_modeline_height (struct window *w);
|
|
|
750 int pixel_to_glyph_translation (struct frame *f, int x_coord,
|
|
|
751 int y_coord, int *col, int *row,
|
|
|
752 int *obj_x, int *obj_y,
|
|
665
|
753 struct window **w, Charbpos *charbpos,
|
|
|
754 Charbpos *closest, Charcount *modeline_closest,
|
|
428
|
755 Lisp_Object *obj1, Lisp_Object *obj2);
|
|
|
756 void glyph_to_pixel_translation (struct window *w, int char_x,
|
|
|
757 int char_y, int *pix_x, int *pix_y);
|
|
665
|
758 int point_in_line_start_cache (struct window *w, Charbpos point,
|
|
428
|
759 int min_past);
|
|
665
|
760 int point_would_be_visible (struct window *w, Charbpos startp,
|
|
826
|
761 Charbpos point);
|
|
665
|
762 Charbpos start_of_last_line (struct window *w, Charbpos startp);
|
|
|
763 Charbpos end_of_last_line (struct window *w, Charbpos startp);
|
|
|
764 Charbpos start_with_line_at_pixpos (struct window *w, Charbpos point,
|
|
826
|
765 int pixpos);
|
|
665
|
766 Charbpos start_with_point_on_display_line (struct window *w, Charbpos point,
|
|
826
|
767 int line);
|
|
428
|
768 int redisplay_variable_changed (Lisp_Object sym, Lisp_Object *val,
|
|
|
769 Lisp_Object in_object, int flags);
|
|
|
770 void redisplay_glyph_changed (Lisp_Object glyph, Lisp_Object property,
|
|
|
771 Lisp_Object locale);
|
|
|
772
|
|
|
773 #ifdef MEMORY_USAGE_STATS
|
|
|
774 int compute_display_line_dynarr_usage (display_line_dynarr *dyn,
|
|
|
775 struct overhead_stats *ovstats);
|
|
|
776 int compute_line_start_cache_dynarr_usage (line_start_cache_dynarr *dyn,
|
|
|
777 struct overhead_stats *ovstats);
|
|
|
778 #endif
|
|
|
779
|
|
|
780
|
|
|
781 /* defined in redisplay-output.c */
|
|
|
782 int get_next_display_block (layout_bounds bounds,
|
|
|
783 display_block_dynarr *dba, int start_pos,
|
|
|
784 int *next_start);
|
|
442
|
785 void redisplay_output_layout (Lisp_Object domain,
|
|
428
|
786 Lisp_Object image_instance,
|
|
617
|
787 struct display_box* db,
|
|
|
788 struct display_glyph_area* dga,
|
|
|
789 face_index findex, int cursor_start,
|
|
|
790 int cursor_width,
|
|
428
|
791 int cursor_height);
|
|
|
792 void redisplay_output_subwindow (struct window *w,
|
|
|
793 Lisp_Object image_instance,
|
|
617
|
794 struct display_box* db,
|
|
|
795 struct display_glyph_area* dga,
|
|
|
796 face_index findex, int cursor_start,
|
|
|
797 int cursor_width,
|
|
428
|
798 int cursor_height);
|
|
617
|
799 void redisplay_unmap_subwindows_maybe (struct frame* f, int x, int y,
|
|
|
800 int width, int height);
|
|
428
|
801 void redisplay_output_pixmap (struct window *w,
|
|
|
802 Lisp_Object image_instance,
|
|
617
|
803 struct display_box* db,
|
|
|
804 struct display_glyph_area* dga,
|
|
|
805 face_index findex, int cursor_start,
|
|
|
806 int cursor_width,
|
|
428
|
807 int cursor_height, int offset_bitmap);
|
|
|
808 int redisplay_calculate_display_boxes (struct display_line *dl, int xpos,
|
|
819
|
809 int xoffset, int yoffset, int start_pixpos,
|
|
|
810 int width, struct display_box* dest,
|
|
428
|
811 struct display_glyph_area* src);
|
|
|
812 int redisplay_normalize_glyph_area (struct display_box* dest,
|
|
|
813 struct display_glyph_area* glyphsrc);
|
|
|
814 void redisplay_clear_to_window_end (struct window *w, int ypos1, int ypos2);
|
|
|
815 void redisplay_clear_region (Lisp_Object window, face_index findex, int x,
|
|
|
816 int y, int width, int height);
|
|
448
|
817 void redisplay_clear_top_of_window (struct window *w);
|
|
428
|
818 void redisplay_clear_bottom_of_window (struct window *w,
|
|
|
819 display_line_dynarr *ddla,
|
|
|
820 int min_start, int max_end);
|
|
|
821 void redisplay_update_line (struct window *w, int first_line,
|
|
|
822 int last_line, int update_values);
|
|
|
823 void redisplay_output_window (struct window *w);
|
|
|
824 void bevel_modeline (struct window *w, struct display_line *dl);
|
|
665
|
825 int redisplay_move_cursor (struct window *w, Charbpos new_point,
|
|
428
|
826 int no_output_end);
|
|
|
827 void redisplay_redraw_cursor (struct frame *f, int run_begin_end_meths);
|
|
|
828 void output_display_line (struct window *w, display_line_dynarr *cdla,
|
|
|
829 display_line_dynarr *ddla, int line,
|
|
|
830 int force_start, int force_end);
|
|
442
|
831 void sync_display_line_structs (struct window *w, int line, int do_blocks,
|
|
|
832 display_line_dynarr *cdla,
|
|
|
833 display_line_dynarr *ddla);
|
|
1318
|
834 void redisplay_redraw_exposed_area (struct frame *f, int x, int y, int width,
|
|
|
835 int height);
|
|
|
836 void register_post_redisplay_action (void (*fun) (Lisp_Object),
|
|
|
837 Lisp_Object arg);
|
|
|
838 int begin_hold_frame_size_changes (void);
|
|
|
839 int enter_redisplay_critical_section (void);
|
|
|
840 void exit_redisplay_critical_section (int);
|
|
|
841 int enter_redisplay_critical_section_maybe (void);
|
|
|
842 void exit_redisplay_critical_section_maybe (int depth);
|
|
428
|
843
|
|
440
|
844 #endif /* INCLUDED_redisplay_h_ */
|
