|
0
|
1 /* Redisplay data structures.
|
|
|
2 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
|
|
|
3 Copyright (C) 1996 Chuck Thompson.
|
|
|
4 Copyright (C) 1995, 1996 Ben Wing.
|
|
|
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
|
|
|
25 #ifndef _XEMACS_REDISPLAY_H_
|
|
|
26 #define _XEMACS_REDISPLAY_H_
|
|
|
27
|
|
|
28 /* Redisplay DASSERT types */
|
|
2
|
29 #define DB_DISP_POS 1
|
|
|
30 #define DB_DISP_TEXT_LAYOUT 2
|
|
|
31 #define DB_DISP_REDISPLAY 4
|
|
0
|
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
|
|
|
41 #define NO_BLOCK -1
|
|
|
42
|
|
|
43 /* Imagine that the text in the buffer is displayed on a piece of paper
|
|
|
44 the width of the frame and very very tall. The line start cache is
|
|
|
45 an array of struct line_start_cache's, describing the start and
|
|
|
46 end buffer positions for a contiguous set of lines on that piece
|
|
|
47 of paper. */
|
|
|
48
|
|
185
|
49 typedef struct line_start_cache line_start_cache;
|
|
0
|
50 struct line_start_cache
|
|
|
51 {
|
|
|
52 Bufpos start, end;
|
|
|
53 int height;
|
|
|
54 };
|
|
|
55
|
|
185
|
56 typedef struct
|
|
0
|
57 {
|
|
185
|
58 Dynarr_declare (line_start_cache);
|
|
0
|
59 } line_start_cache_dynarr;
|
|
|
60
|
|
|
61 /* The possible types of runes.
|
|
|
62
|
|
|
63 #### The Lisp_Glyph type is broken. There should instead be a pixmap
|
|
|
64 type. Currently the device-specific output routines have to worry
|
|
|
65 about whether the glyph is textual or not, etc. For Mule this is
|
|
|
66 a big problem because you might need multiple fonts to display the
|
|
|
67 text. It also eliminates optimizations that could come from glumping
|
|
|
68 the text of multiple text glyphs together -- this makes displaying
|
|
|
69 binary files (with lots of control chars, etc.) very very slow. */
|
|
|
70
|
|
|
71 #define RUNE_BLANK 0
|
|
|
72 #define RUNE_CHAR 1
|
|
|
73 #define RUNE_DGLYPH 2
|
|
|
74 #define RUNE_HLINE 3
|
|
|
75 #define RUNE_VLINE 4
|
|
|
76
|
|
|
77 #define CURSOR_ON 0
|
|
|
78 #define CURSOR_OFF 1
|
|
|
79 #define NO_CURSOR 2
|
|
|
80 #define NEXT_CURSOR 3
|
|
|
81 #define IGNORE_CURSOR 4
|
|
|
82
|
|
|
83 #define DEFAULT_INDEX (face_index) 0
|
|
|
84 #define MODELINE_INDEX (face_index) 1
|
|
|
85
|
|
|
86 /* A rune is a single display element, such as a printable character
|
|
|
87 or pixmap. Any single character in a buffer has one or more runes
|
|
|
88 (or zero, if the character is invisible) corresponding to it.
|
|
|
89 (Printable characters typically have one rune associated with them,
|
|
|
90 but control characters have two -- a ^ and a letter -- and other
|
|
|
91 non-printing characters (those displayed in octal) have four. */
|
|
185
|
92
|
|
|
93 typedef struct rune rune;
|
|
0
|
94 struct rune
|
|
|
95 {
|
|
|
96 face_index findex; /* face rune is displayed with. The
|
|
|
97 face_index is an index into a
|
|
|
98 window-specific array of face cache
|
|
|
99 elements. Each face cache element
|
|
|
100 corresponds to one "merged face"
|
|
|
101 (the result of merging all the
|
|
|
102 faces that overlap the rune) and
|
|
|
103 contains the instance values for
|
|
|
104 each of the face properties in this
|
|
|
105 particular window. */
|
|
|
106
|
|
|
107 short xpos; /* horizontal starting position in pixels */
|
|
|
108 short width; /* pixel width of rune */
|
|
|
109
|
|
|
110
|
|
|
111 Bufpos bufpos; /* buffer position this rune is displaying;
|
|
|
112 for the modeline, the value here is a
|
|
|
113 Charcount, but who's looking? */
|
|
|
114 Bufpos endpos; /* if set this rune covers a range of pos */
|
|
|
115 /* #### Chuck, what does it mean for a rune
|
|
|
116 to cover a range of pos? I don't get
|
|
|
117 this. */
|
|
|
118 unsigned int cursor_type :3; /* is this rune covered by the cursor? */
|
|
|
119 unsigned int type :3; /* type of rune object */
|
|
|
120
|
|
|
121 union /* Information specific to the type of rune */
|
|
|
122 {
|
|
|
123 /* DGLYPH */
|
|
|
124 struct
|
|
|
125 {
|
|
|
126 Lisp_Object glyph;
|
|
|
127 Lisp_Object extent; /* extent rune is attached to, if any.
|
|
|
128 If this is a rune in the modeline
|
|
|
129 then this might be nil. */
|
|
|
130
|
|
|
131 int xoffset; /* Number of pixels that need to be
|
|
|
132 chopped off the left of the glyph.
|
|
|
133 This has the effect of shifting the
|
|
|
134 glyph to the left while still clipping
|
|
|
135 at XPOS. */
|
|
|
136 } dglyph;
|
|
185
|
137
|
|
0
|
138 /* CHAR */
|
|
|
139 struct
|
|
|
140 {
|
|
|
141 Emchar ch; /* Cbaracter of this rune. */
|
|
|
142 } chr;
|
|
185
|
143
|
|
0
|
144 /* HLINE */
|
|
|
145 struct
|
|
|
146 {
|
|
|
147 int thickness; /* how thick to make hline */
|
|
|
148 int yoffset; /* how far down from top of line to put top */
|
|
|
149 } hline;
|
|
|
150 } object; /* actual rune object */
|
|
|
151 };
|
|
|
152
|
|
185
|
153 typedef struct
|
|
0
|
154 {
|
|
185
|
155 Dynarr_declare (rune);
|
|
0
|
156 } rune_dynarr;
|
|
|
157
|
|
|
158 /* These must have distinct values. Note that the ordering actually
|
|
|
159 represents priority levels. TEXT has the lowest priority level. */
|
|
|
160 enum display_type
|
|
|
161 {
|
|
|
162 TEXT,
|
|
|
163 LEFT_OUTSIDE_MARGIN,
|
|
|
164 LEFT_INSIDE_MARGIN,
|
|
|
165 RIGHT_INSIDE_MARGIN,
|
|
|
166 RIGHT_OUTSIDE_MARGIN,
|
|
|
167 OVERWRITE
|
|
|
168 };
|
|
|
169
|
|
|
170 /* A display block represents a run of text on a single line.
|
|
|
171 Apparently there is only one display block per line for each
|
|
|
172 of the types listed in `enum display_type'.
|
|
|
173
|
|
|
174 A display block consists mostly of an array of runes, one per
|
|
|
175 atomic display element (printable character, pixmap, etc.). */
|
|
|
176
|
|
|
177 /* #### Yuckity yuckity yuck yuck yuck yuck yuck!!
|
|
|
178
|
|
|
179 Chuck, I think you should redo this. It should not be the
|
|
|
180 responsibility of the device-specific code to worry about
|
|
|
181 the different faces. The generic stuff in redisplay-output.c
|
|
|
182 should glump things up into sub-blocks, each of which
|
|
|
183 corresponds to a single pixmap or a single run of text in
|
|
|
184 the same font.
|
|
|
185
|
|
|
186 It might still make sense for the device-specific output routine
|
|
|
187 to get passed an entire display line. That way, it can make
|
|
|
188 calls to XDrawText() (which draws multiple runs of single-font
|
|
|
189 data) instead of XDrawString(). The reason for this is to
|
|
|
190 reduce the amount of X traffic, which will help things significantly
|
|
|
191 on a slow line. */
|
|
|
192
|
|
185
|
193 typedef struct display_block display_block;
|
|
0
|
194 struct display_block
|
|
|
195 {
|
|
|
196 enum display_type type; /* type of display block */
|
|
|
197
|
|
|
198 int start_pos; /* starting pixel position of block */
|
|
|
199 int end_pos; /* ending pixel position of block */
|
|
|
200
|
|
|
201 rune_dynarr *runes; /* Dynamic array of runes */
|
|
|
202 };
|
|
|
203
|
|
185
|
204 typedef struct
|
|
0
|
205 {
|
|
185
|
206 Dynarr_declare (display_block);
|
|
0
|
207 } display_block_dynarr;
|
|
|
208
|
|
|
209 typedef struct layout_bounds_type
|
|
|
210 {
|
|
|
211 int left_out;
|
|
|
212 int left_in;
|
|
|
213 int left_white;
|
|
|
214 int right_white;
|
|
|
215 int right_in;
|
|
|
216 int right_out;
|
|
|
217 } layout_bounds;
|
|
|
218
|
|
185
|
219 typedef struct glyph_block glyph_block;
|
|
0
|
220 struct glyph_block
|
|
|
221 {
|
|
|
222 Lisp_Object glyph;
|
|
|
223 Lisp_Object extent;
|
|
|
224 /* The rest are only used by margin routines. */
|
|
|
225 face_index findex;
|
|
|
226 int active;
|
|
|
227 int width;
|
|
|
228 };
|
|
|
229
|
|
185
|
230 typedef struct
|
|
0
|
231 {
|
|
185
|
232 Dynarr_declare (glyph_block);
|
|
0
|
233 } glyph_block_dynarr;
|
|
|
234
|
|
185
|
235 typedef struct display_line display_line;
|
|
0
|
236 struct display_line
|
|
|
237 {
|
|
|
238 short ypos; /* vertical position in pixels
|
|
|
239 of the baseline for this line. */
|
|
|
240 unsigned short ascent, descent; /* maximum values for this line.
|
|
|
241 The ascent is the number of
|
|
|
242 pixels above the baseline, and
|
|
|
243 the descent is the number of
|
|
|
244 pixels below the baseline.
|
|
|
245 The descent includes the baseline
|
|
|
246 pixel-row itself, I think. */
|
|
|
247 unsigned short clip; /* amount of bottom of line to clip
|
|
|
248 in pixels.*/
|
|
|
249 Bufpos bufpos; /* first buffer position on line */
|
|
|
250 Bufpos end_bufpos; /* last buffer position on line */
|
|
|
251 Charcount offset; /* adjustment to bufpos vals */
|
|
|
252 Charcount num_chars; /* # of chars on line
|
|
|
253 including expansion of tabs
|
|
|
254 and control chars */
|
|
|
255 int cursor_elt; /* rune block of TEXT display
|
|
|
256 block cursor is at or -1 */
|
|
2
|
257 char used_prop_data; /* can't incrementally update if line
|
|
0
|
258 used propogation data */
|
|
|
259
|
|
|
260 layout_bounds bounds; /* line boundary positions */
|
|
|
261
|
|
|
262 char modeline; /* t if this line is a modeline */
|
|
|
263
|
|
|
264 /* Dynamic array of display blocks */
|
|
|
265 display_block_dynarr *display_blocks;
|
|
|
266
|
|
|
267 /* Dynamic arrays of left and right glyph blocks */
|
|
|
268 glyph_block_dynarr *left_glyphs;
|
|
|
269 glyph_block_dynarr *right_glyphs;
|
|
|
270 };
|
|
|
271
|
|
185
|
272 typedef struct
|
|
0
|
273 {
|
|
185
|
274 Dynarr_declare (display_line);
|
|
0
|
275 } display_line_dynarr;
|
|
|
276
|
|
|
277 /* It could be argued that the following two structs belong in
|
|
|
278 extents.h, but they're only used by redisplay and it simplifies
|
|
|
279 the header files to put them here. */
|
|
|
280
|
|
185
|
281 typedef struct
|
|
0
|
282 {
|
|
185
|
283 Dynarr_declare (EXTENT);
|
|
|
284 } EXTENT_dynarr;
|
|
0
|
285
|
|
|
286 struct font_metric_info
|
|
|
287 {
|
|
|
288 int width;
|
|
|
289 int height; /* always ascent + descent; for convenience */
|
|
|
290 int ascent;
|
|
|
291 int descent;
|
|
|
292
|
|
183
|
293 int proportional_p;
|
|
0
|
294 };
|
|
|
295
|
|
|
296 /* NOTE NOTE NOTE: Currently the positions in an extent fragment
|
|
|
297 structure are Bytind's, not Bufpos's. This could change. */
|
|
|
298
|
|
|
299 struct extent_fragment
|
|
|
300 {
|
|
|
301 Lisp_Object object; /* buffer or string */
|
|
|
302 struct frame *frm;
|
|
|
303 Bytind pos, end;
|
|
185
|
304 EXTENT_dynarr *extents;
|
|
0
|
305 glyph_block_dynarr *begin_glyphs, *end_glyphs;
|
|
2
|
306 unsigned int invisible:1;
|
|
|
307 unsigned int invisible_ellipses:1;
|
|
|
308 unsigned int previously_invisible:1;
|
|
|
309 unsigned int invisible_ellipses_already_displayed:1;
|
|
0
|
310 };
|
|
|
311
|
|
|
312
|
|
|
313 /*************************************************************************/
|
|
|
314 /* change flags */
|
|
|
315 /*************************************************************************/
|
|
|
316
|
|
|
317 /* Quick flags to signal redisplay. redisplay() sets them all to 0
|
|
|
318 when it finishes. If none of them are set when it starts, it
|
|
|
319 assumes that nothing needs to be done. Functions that make a change
|
|
|
320 that is (potentially) visible on the screen should set the
|
|
|
321 appropriate flag.
|
|
|
322
|
|
|
323 If any of these flags are set, redisplay will look more carefully
|
|
|
324 to see if anything has really changed. */
|
|
|
325
|
|
|
326 /* non-nil if the contents of a buffer have changed since the last time
|
|
|
327 redisplay completed */
|
|
|
328 extern int buffers_changed;
|
|
|
329 extern int buffers_changed_set;
|
|
|
330
|
|
|
331 /* Nonzero if head_clip or tail_clip of a buffer has changed
|
|
|
332 since last redisplay that finished */
|
|
|
333 extern int clip_changed;
|
|
|
334 extern int clip_changed_set;
|
|
|
335
|
|
|
336 /* non-nil if any extent has changed since the last time redisplay completed */
|
|
|
337 extern int extents_changed;
|
|
|
338 extern int extents_changed_set;
|
|
|
339
|
|
|
340 /* non-nil if any face has changed since the last time redisplay completed */
|
|
|
341 extern int faces_changed;
|
|
|
342
|
|
|
343 /* Nonzero means one or more frames have been marked as garbaged */
|
|
|
344 extern int frame_changed;
|
|
|
345
|
|
269
|
346 /* True if any of the builtin display glyphs (continuation,
|
|
|
347 hscroll, control-arrow, etc) is in need of updating
|
|
|
348 somewhere. */
|
|
|
349 extern int glyphs_changed;
|
|
|
350 extern int glyphs_changed_set;
|
|
|
351
|
|
0
|
352 /* True if an icon is in need of updating somewhere. */
|
|
|
353 extern int icon_changed;
|
|
|
354 extern int icon_changed_set;
|
|
|
355
|
|
|
356 /* True if a menubar is in need of updating somewhere. */
|
|
|
357 extern int menubar_changed;
|
|
|
358 extern int menubar_changed_set;
|
|
|
359
|
|
|
360 /* true iff we should redraw the modelines on the next redisplay */
|
|
|
361 extern int modeline_changed;
|
|
|
362 extern int modeline_changed_set;
|
|
|
363
|
|
|
364 /* non-nil if point has changed in some buffer since the last time
|
|
|
365 redisplay completed */
|
|
|
366 extern int point_changed;
|
|
|
367 extern int point_changed_set;
|
|
|
368
|
|
|
369 /* non-nil if some frame has changed its size */
|
|
|
370 extern int size_changed;
|
|
|
371
|
|
|
372 /* non-nil if some device has signaled that it wants to change size */
|
|
|
373 extern int asynch_device_change_pending;
|
|
|
374
|
|
|
375 /* non-nil if any toolbar has changed */
|
|
|
376 extern int toolbar_changed;
|
|
|
377 extern int toolbar_changed_set;
|
|
|
378
|
|
|
379 /* non-nil if any window has changed since the last time redisplay completed */
|
|
|
380 extern int windows_changed;
|
|
|
381
|
|
|
382 /* non-nil if any frame's window structure has changed since the last
|
|
|
383 time redisplay completed */
|
|
|
384 extern int windows_structure_changed;
|
|
|
385
|
|
|
386 /* These macros can be relatively expensive. Since they are often
|
|
|
387 called numerous times between each call to redisplay, we keep track
|
|
|
388 if each has already been called and don't bother doing most of the
|
|
|
389 work if it is currently set. */
|
|
|
390
|
|
|
391 #define MARK_TYPE_CHANGED(object) do { \
|
|
|
392 if (!object##_changed_set) { \
|
|
|
393 Lisp_Object _devcons_, _concons_; \
|
|
|
394 DEVICE_LOOP_NO_BREAK (_devcons_, _concons_) \
|
|
|
395 { \
|
|
|
396 Lisp_Object _frmcons_; \
|
|
|
397 struct device *_d_ = XDEVICE (XCONS (_devcons_)->car); \
|
|
|
398 DEVICE_FRAME_LOOP (_frmcons_, _d_) \
|
|
|
399 { \
|
|
|
400 struct frame *_f_ = XFRAME (XCONS (_frmcons_)->car); \
|
|
|
401 _f_->object##_changed = 1; \
|
|
|
402 _f_->modiff++; \
|
|
|
403 } \
|
|
|
404 _d_->object##_changed = 1; \
|
|
|
405 } \
|
|
|
406 object##_changed = 1; \
|
|
|
407 object##_changed_set = 1; } \
|
|
|
408 } while (0)
|
|
|
409
|
|
|
410 #define MARK_BUFFERS_CHANGED MARK_TYPE_CHANGED (buffers)
|
|
|
411 #define MARK_CLIP_CHANGED MARK_TYPE_CHANGED (clip)
|
|
|
412 #define MARK_EXTENTS_CHANGED MARK_TYPE_CHANGED (extents)
|
|
|
413 #define MARK_ICON_CHANGED MARK_TYPE_CHANGED (icon)
|
|
|
414 #define MARK_MENUBAR_CHANGED MARK_TYPE_CHANGED (menubar)
|
|
|
415 #define MARK_MODELINE_CHANGED MARK_TYPE_CHANGED (modeline)
|
|
|
416 #define MARK_POINT_CHANGED MARK_TYPE_CHANGED (point)
|
|
|
417 #define MARK_TOOLBAR_CHANGED MARK_TYPE_CHANGED (toolbar)
|
|
269
|
418 #define MARK_GLYPHS_CHANGED MARK_TYPE_CHANGED (glyphs)
|
|
0
|
419
|
|
|
420 /* Anytime a console, device or frame is added or deleted we need to reset
|
|
|
421 these flags. */
|
|
|
422 #define RESET_CHANGED_SET_FLAGS \
|
|
|
423 do { \
|
|
|
424 buffers_changed_set = 0; \
|
|
|
425 clip_changed_set = 0; \
|
|
|
426 extents_changed_set = 0; \
|
|
|
427 icon_changed_set = 0; \
|
|
|
428 menubar_changed_set = 0; \
|
|
|
429 modeline_changed_set = 0; \
|
|
|
430 point_changed_set = 0; \
|
|
|
431 toolbar_changed_set = 0; \
|
|
269
|
432 glyphs_changed_set = 0; \
|
|
0
|
433 } while (0)
|
|
|
434
|
|
|
435
|
|
|
436 /*************************************************************************/
|
|
|
437 /* redisplay global variables */
|
|
|
438 /*************************************************************************/
|
|
|
439
|
|
|
440 /* redisplay structre used by various utility routines. */
|
|
|
441 extern display_line_dynarr *cmotion_display_lines;
|
|
|
442
|
|
|
443 /* nil or a symbol naming the window system
|
|
|
444 under which emacs is running
|
|
|
445 ('x is the only current possibility) */
|
|
|
446 extern Lisp_Object Vwindow_system;
|
|
|
447
|
|
|
448 /* Nonzero means truncate lines in all windows less wide than the frame. */
|
|
|
449 extern int truncate_partial_width_windows;
|
|
|
450
|
|
|
451 /* Nonzero if we're in a display critical section. */
|
|
|
452 extern int in_display;
|
|
|
453
|
|
|
454 /* Nonzero means no need to redraw the entire frame on resuming
|
|
|
455 a suspended Emacs. This is useful on terminals with multiple pages,
|
|
|
456 where one page is used for Emacs and another for all else. */
|
|
|
457 extern int no_redraw_on_reenter;
|
|
|
458
|
|
|
459 /* Nonzero means flash the frame instead of ringing the bell. */
|
|
|
460 extern int visible_bell;
|
|
|
461
|
|
|
462 /* Thickness of shadow border around 3D modelines. */
|
|
|
463 extern Lisp_Object Vmodeline_shadow_thickness;
|
|
|
464
|
|
|
465 /* Scroll if point lands on the bottom line and that line is partially
|
|
|
466 clipped. */
|
|
|
467 extern int scroll_on_clipped_lines;
|
|
|
468
|
|
|
469 extern Lisp_Object Vglobal_mode_string;
|
|
|
470
|
|
2
|
471 /* The following two variables are defined in emacs.c and are used
|
|
0
|
472 to convey information discovered on the command line way early
|
|
|
473 (before *anything* is initialized). */
|
|
|
474
|
|
|
475 /* If non-zero, a window-system was specified on the command line.
|
|
|
476 Defined in emacs.c. */
|
|
|
477 extern int display_arg;
|
|
|
478
|
|
|
479 /* Type of display specified. Defined in emacs.c. */
|
|
|
480 extern char *display_use;
|
|
|
481
|
|
|
482
|
|
|
483 /*************************************************************************/
|
|
|
484 /* redisplay exported functions */
|
|
|
485 /*************************************************************************/
|
|
|
486
|
|
|
487 int redisplay_text_width_string (struct window *w, int findex,
|
|
|
488 Bufbyte *nonreloc, Lisp_Object reloc,
|
|
|
489 Bytecount offset, Bytecount len);
|
|
|
490 int redisplay_frame_text_width_string (struct frame *f,
|
|
|
491 Lisp_Object face,
|
|
|
492 Bufbyte *nonreloc,
|
|
|
493 Lisp_Object reloc,
|
|
|
494 Bytecount offset, Bytecount len);
|
|
|
495 void redisplay (void);
|
|
|
496 struct display_block *get_display_block_from_line (struct display_line *dl,
|
|
|
497 enum display_type type);
|
|
|
498 layout_bounds calculate_display_line_boundaries (struct window *w,
|
|
|
499 int modeline);
|
|
|
500 Bufpos point_at_center (struct window *w, int type, Bufpos start,
|
|
|
501 Bufpos point);
|
|
|
502 int line_at_center (struct window *w, int type, Bufpos start, Bufpos point);
|
|
|
503 int window_half_pixpos (struct window *w);
|
|
|
504 void redisplay_echo_area (void);
|
|
|
505 void free_display_structs (struct window_mirror *mir);
|
|
2
|
506 Bufbyte *generate_formatted_string (struct window *w, Lisp_Object format_str,
|
|
|
507 Lisp_Object result_str, face_index findex,
|
|
|
508 int type);
|
|
0
|
509 int real_current_modeline_height (struct window *w);
|
|
|
510 int pixel_to_glyph_translation (struct frame *f, int x_coord,
|
|
|
511 int y_coord, int *col, int *row,
|
|
|
512 int *obj_x, int *obj_y,
|
|
|
513 struct window **w, Bufpos *bufpos,
|
|
|
514 Bufpos *closest, Charcount *modeline_closest,
|
|
|
515 Lisp_Object *obj1, Lisp_Object *obj2);
|
|
|
516 void glyph_to_pixel_translation (struct window *w, int char_x,
|
|
|
517 int char_y, int *pix_x, int *pix_y);
|
|
|
518 void mark_redisplay (void (*) (Lisp_Object));
|
|
|
519 int point_in_line_start_cache (struct window *w, Bufpos point,
|
|
|
520 int min_past);
|
|
|
521 int point_would_be_visible (struct window *w, Bufpos startp,
|
|
|
522 Bufpos point);
|
|
|
523 Bufpos start_of_last_line (struct window *w, Bufpos startp);
|
|
|
524 Bufpos end_of_last_line (struct window *w, Bufpos startp);
|
|
|
525 Bufpos start_with_line_at_pixpos (struct window *w, Bufpos point,
|
|
|
526 int pixpos);
|
|
|
527 Bufpos start_with_point_on_display_line (struct window *w, Bufpos point,
|
|
|
528 int line);
|
|
|
529 int redisplay_variable_changed (Lisp_Object sym, Lisp_Object *val,
|
|
|
530 Lisp_Object in_object, int flags);
|
|
|
531 void redisplay_glyph_changed (Lisp_Object glyph, Lisp_Object property,
|
|
|
532 Lisp_Object locale);
|
|
|
533
|
|
|
534 #ifdef MEMORY_USAGE_STATS
|
|
|
535 int compute_display_line_dynarr_usage (display_line_dynarr *dyn,
|
|
|
536 struct overhead_stats *ovstats);
|
|
|
537 int compute_line_start_cache_dynarr_usage (line_start_cache_dynarr *dyn,
|
|
|
538 struct overhead_stats *ovstats);
|
|
|
539 #endif
|
|
|
540
|
|
|
541
|
|
|
542 /* defined in redisplay-output.c */
|
|
|
543 int get_next_display_block (layout_bounds bounds,
|
|
|
544 display_block_dynarr *dba, int start_pos,
|
|
|
545 int *next_start);
|
|
|
546 void redisplay_clear_bottom_of_window (struct window *w,
|
|
|
547 display_line_dynarr *ddla,
|
|
|
548 int min_start, int max_end);
|
|
|
549 void redisplay_update_line (struct window *w, int first_line,
|
|
|
550 int last_line, int update_values);
|
|
|
551 void redisplay_output_window (struct window *w);
|
|
|
552 int redisplay_move_cursor (struct window *w, Bufpos new_point,
|
|
|
553 int no_output_end);
|
|
|
554 void redisplay_redraw_cursor (struct frame *f, int run_begin_end_meths);
|
|
|
555 void output_display_line (struct window *w, display_line_dynarr *cdla,
|
|
|
556 display_line_dynarr *ddla, int line,
|
|
|
557 int force_start, int force_end);
|
|
|
558
|
|
|
559 #endif /* _XEMACS_REDISPLAY_H_ */
|
