Mercurial > hg > xemacs-beta

comparison src/redisplay.h @ 0:376386a54a3c r19-14

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