Mercurial > hg > xemacs-beta
annotate src/redisplay.h @ 5533:11da5b828d10
shell-command and shell-command-on-region API compliant with FSF 23.3.1
| author | Mats Lidell <mats.lidell@cag.se> |
|---|---|
| date | Sun, 31 Jul 2011 01:29:09 +0200 |
| parents | 0af042a0c116 |
| children | b0d712bbc2a6 |
| rev | line source |
|---|---|
| 428 | 1 /* Redisplay data structures. |
| 2 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois. | |
| 3 Copyright (C) 1996 Chuck Thompson. | |
| 2518 | 4 Copyright (C) 1995, 1996, 2002, 2003, 2004 Ben Wing. |
| 428 | 5 |
| 6 This file is part of XEmacs. | |
| 7 | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5157
diff
changeset
|
8 XEmacs is free software: you can redistribute it and/or modify it |
| 428 | 9 under the terms of the GNU General Public License as published by the |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5157
diff
changeset
|
10 Free Software Foundation, either version 3 of the License, or (at your |
|
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5157
diff
changeset
|
11 option) any later version. |
| 428 | 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 | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5157
diff
changeset
|
19 along with XEmacs. If not, see <http://www.gnu.org/licenses/>. */ |
| 428 | 20 |
| 21 /* Synched up with: Not in FSF. */ | |
| 22 | |
| 440 | 23 #ifndef INCLUDED_redisplay_h_ |
| 24 #define INCLUDED_redisplay_h_ | |
| 428 | 25 |
| 26 /* Redisplay DASSERT types */ | |
| 27 #define DB_DISP_POS 1 | |
| 28 #define DB_DISP_TEXT_LAYOUT 2 | |
| 29 #define DB_DISP_REDISPLAY 4 | |
| 30 | |
| 31 /* These are the possible return values from pixel_to_glyph_translation. */ | |
| 32 #define OVER_MODELINE 0 | |
| 33 #define OVER_TEXT 1 | |
| 34 #define OVER_OUTSIDE 2 | |
| 35 #define OVER_NOTHING 3 | |
| 36 #define OVER_BORDER 4 | |
| 37 #define OVER_TOOLBAR 5 | |
| 38 #define OVER_V_DIVIDER 6 | |
| 39 | |
| 40 #define NO_BLOCK -1 | |
| 41 | |
| 42 /* Imagine that the text in the buffer is displayed on a piece of paper | |
| 43 the width of the frame and very very tall. The line start cache is | |
| 44 an array of struct line_start_cache's, describing the start and | |
| 45 end buffer positions for a contiguous set of lines on that piece | |
| 46 of paper. */ | |
| 47 | |
| 48 typedef struct line_start_cache line_start_cache; | |
| 49 struct line_start_cache | |
| 50 { | |
| 665 | 51 Charbpos start, end; |
| 428 | 52 int height; |
| 53 }; | |
| 54 | |
| 55 typedef struct | |
| 56 { | |
| 57 Dynarr_declare (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 | |
| 4187 | 82 /* #### NOTE: these indexes depend on the order in which the faces are added |
| 83 to the cache in the function reset_face_cachels. */ | |
| 428 | 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(). */ | |
| 4187 | 137 /* #### Chuck, what does it mean for a rune |
| 428 | 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? */ |
| 2642 | 147 unsigned int type; /* type of rune object */ |
| 4187 | 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 */ | |
| 428 | 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 |
| 4187 | 316 next display line. */ |
| 442 | 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 | |
| 4207 | 330 #define DISPLAY_LINE_INIT(dl) \ |
| 331 do \ | |
| 332 { \ | |
| 333 xzero (dl); \ | |
| 334 dl.default_findex = DEFAULT_INDEX; \ | |
| 335 } \ | |
| 336 while (0) | |
| 337 | |
| 428 | 338 #define DISPLAY_LINE_HEIGHT(dl) \ |
| 339 (dl->ascent + dl->descent - (dl->clip + dl->top_clip)) | |
| 340 #define DISPLAY_LINE_YPOS(dl) \ | |
| 341 (dl->ypos - (dl->ascent - dl->top_clip)) | |
| 342 #define DISPLAY_LINE_YEND(dl) \ | |
| 343 ((dl->ypos + dl->descent) - dl->clip) | |
| 344 | |
| 345 typedef struct | |
| 346 { | |
| 347 Dynarr_declare (display_line); | |
| 348 } display_line_dynarr; | |
| 349 | |
| 350 /* The following two structures are used to represent an area to | |
| 351 displayed and where to display it. Using these two structures all | |
| 352 combinations of clipping and position can be accommodated. */ | |
| 353 | |
| 354 /* This represents an area to be displayed into. */ | |
| 355 typedef struct display_box display_box; | |
| 356 struct display_box | |
| 357 { | |
| 358 int xpos; /* absolute horizontal position of area */ | |
| 359 int ypos; /* absolute vertical position of area */ | |
| 360 int width, height; | |
| 361 }; | |
| 362 | |
| 363 /* This represents the area from a glyph to be displayed. */ | |
| 364 typedef struct display_glyph_area display_glyph_area; | |
| 365 struct display_glyph_area | |
| 366 { | |
| 367 int xoffset; /* horizontal offset of the glyph, +ve means | |
| 368 display the glyph with x offset by xoffset, | |
| 369 -ve means display starting xoffset into the | |
| 370 glyph. */ | |
| 371 int yoffset; /* vertical offset of the glyph, +ve means | |
| 372 display the glyph with y offset by yoffset, | |
| 373 -ve means display starting xoffset into the | |
| 374 glyph. */ | |
| 375 int width, height; /* width and height of glyph to display. */ | |
| 376 }; | |
| 377 | |
| 378 /* It could be argued that the following two structs belong in | |
| 379 extents.h, but they're only used by redisplay and it simplifies | |
| 380 the header files to put them here. */ | |
| 381 | |
| 382 typedef struct | |
| 383 { | |
| 384 Dynarr_declare (EXTENT); | |
| 385 } EXTENT_dynarr; | |
| 386 | |
| 387 struct font_metric_info | |
| 388 { | |
| 389 int width; | |
| 390 int height; /* always ascent + descent; for convenience */ | |
| 391 int ascent; | |
| 392 int descent; | |
| 393 | |
| 394 int proportional_p; | |
| 395 }; | |
| 396 | |
| 397 /* NOTE NOTE NOTE: Currently the positions in an extent fragment | |
| 826 | 398 structure are Bytexpos's, not Charxpos's. This could change. */ |
| 428 | 399 |
| 400 struct extent_fragment | |
| 401 { | |
| 402 Lisp_Object object; /* buffer or string */ | |
| 403 struct frame *frm; | |
| 826 | 404 Bytexpos pos, end; |
| 428 | 405 EXTENT_dynarr *extents; |
| 406 glyph_block_dynarr *begin_glyphs, *end_glyphs; | |
| 407 unsigned int invisible:1; | |
| 408 unsigned int invisible_ellipses:1; | |
| 409 unsigned int previously_invisible:1; | |
| 410 unsigned int invisible_ellipses_already_displayed:1; | |
| 411 }; | |
| 412 | |
| 413 #define EDGE_TOP 1 | |
| 414 #define EDGE_LEFT 2 | |
| 415 #define EDGE_BOTTOM 4 | |
| 416 #define EDGE_RIGHT 8 | |
| 417 #define EDGE_ALL (EDGE_TOP | EDGE_LEFT | EDGE_BOTTOM | EDGE_RIGHT) | |
| 418 | |
| 419 | |
| 420 /*************************************************************************/ | |
| 421 /* change flags */ | |
| 422 /*************************************************************************/ | |
| 423 | |
| 424 /* Quick flags to signal redisplay. redisplay() sets them all to 0 | |
| 425 when it finishes. If none of them are set when it starts, it | |
| 426 assumes that nothing needs to be done. Functions that make a change | |
| 427 that is (potentially) visible on the screen should set the | |
| 428 appropriate flag. | |
| 429 | |
| 430 If any of these flags are set, redisplay will look more carefully | |
| 431 to see if anything has really changed. */ | |
| 432 | |
| 442 | 433 /* Nonzero if the contents of a buffer have changed since the last time |
| 434 redisplay completed. */ | |
| 428 | 435 extern int buffers_changed; |
| 436 extern int buffers_changed_set; | |
| 437 | |
| 438 /* Nonzero if head_clip or tail_clip of a buffer has changed | |
| 442 | 439 since last redisplay that finished. */ |
| 428 | 440 extern int clip_changed; |
| 441 extern int clip_changed_set; | |
| 442 | |
| 442 | 443 /* Nonzero if any extent has changed since the last time redisplay completed. */ |
| 428 | 444 extern int extents_changed; |
| 445 extern int extents_changed_set; | |
| 446 | |
| 442 | 447 /* Nonzero if any face has changed since the last time redisplay completed. */ |
| 428 | 448 extern int faces_changed; |
| 449 | |
| 442 | 450 /* Nonzero means one or more frames have been marked as garbaged. */ |
| 428 | 451 extern int frame_changed; |
| 452 | |
| 453 /* True if any of the builtin display glyphs (continuation, | |
| 454 hscroll, control-arrow, etc) is in need of updating | |
| 455 somewhere. */ | |
| 456 extern int glyphs_changed; | |
| 457 extern int glyphs_changed_set; | |
| 458 | |
| 459 /* True if any displayed subwindow is in need of updating | |
| 460 somewhere. */ | |
| 461 extern int subwindows_changed; | |
| 462 extern int subwindows_changed_set; | |
| 463 | |
| 464 /* True if any displayed subwindow is in need of updating | |
| 465 somewhere. */ | |
| 466 extern int subwindows_state_changed; | |
| 467 extern int subwindows_state_changed_set; | |
| 468 | |
| 469 /* True if an icon is in need of updating somewhere. */ | |
| 470 extern int icon_changed; | |
| 471 extern int icon_changed_set; | |
| 472 | |
| 473 /* True if a menubar is in need of updating somewhere. */ | |
| 474 extern int menubar_changed; | |
| 475 extern int menubar_changed_set; | |
| 476 | |
| 442 | 477 /* True iff we should redraw the modelines on the next redisplay. */ |
| 428 | 478 extern int modeline_changed; |
| 479 extern int modeline_changed_set; | |
| 480 | |
| 442 | 481 /* Nonzero if point has changed in some buffer since the last time |
| 482 redisplay completed. */ | |
| 428 | 483 extern int point_changed; |
| 484 extern int point_changed_set; | |
| 485 | |
| 442 | 486 /* Nonzero if some frame has changed its size. */ |
| 428 | 487 extern int size_changed; |
| 488 | |
| 442 | 489 /* Nonzero if some device has signaled that it wants to change size. */ |
| 428 | 490 extern int asynch_device_change_pending; |
| 491 | |
| 905 | 492 /* Nonzero if some frame has changed the layout of internal elements |
| 493 (gutters or toolbars). */ | |
| 494 extern int frame_layout_changed; | |
| 495 | |
| 442 | 496 /* Nonzero if any toolbar has changed. */ |
| 428 | 497 extern int toolbar_changed; |
| 498 extern int toolbar_changed_set; | |
| 499 | |
| 442 | 500 /* Nonzero if any gutter has changed. */ |
| 428 | 501 extern int gutter_changed; |
| 502 extern int gutter_changed_set; | |
| 503 | |
| 442 | 504 /* Nonzero if any window has changed since the last time redisplay completed */ |
| 428 | 505 extern int windows_changed; |
| 506 | |
| 442 | 507 /* Nonzero if any frame's window structure has changed since the last |
| 508 time redisplay completed. */ | |
| 428 | 509 extern int windows_structure_changed; |
| 510 | |
| 511 /* These macros can be relatively expensive. Since they are often | |
| 512 called numerous times between each call to redisplay, we keep track | |
| 513 if each has already been called and don't bother doing most of the | |
| 514 work if it is currently set. */ | |
| 515 | |
| 516 #define MARK_TYPE_CHANGED(object) do { \ | |
| 517 if (!object##_changed_set) { \ | |
| 518 Lisp_Object MTC_devcons, MTC_concons; \ | |
| 519 DEVICE_LOOP_NO_BREAK (MTC_devcons, MTC_concons) \ | |
| 520 { \ | |
| 4187 | 521 Lisp_Object MTC_frmcons; \ |
| 522 struct device *MTC_d = XDEVICE (XCAR (MTC_devcons)); \ | |
| 523 DEVICE_FRAME_LOOP (MTC_frmcons, MTC_d) \ | |
| 428 | 524 { \ |
| 525 struct frame *MTC_f = XFRAME (XCAR (MTC_frmcons)); \ | |
| 4187 | 526 MTC_f->object##_changed = 1; \ |
| 428 | 527 MTC_f->modiff++; \ |
| 528 } \ | |
| 4187 | 529 MTC_d->object##_changed = 1; \ |
| 428 | 530 } \ |
| 531 object##_changed = 1; \ | |
| 532 object##_changed_set = 1; } \ | |
| 533 } while (0) | |
| 534 | |
| 872 | 535 void mark_buffers_changed (void); |
| 536 #define MARK_BUFFERS_CHANGED mark_buffers_changed () | |
| 537 void mark_clip_changed (void); | |
| 538 #define MARK_CLIP_CHANGED mark_clip_changed () | |
| 539 void mark_extents_changed (void); | |
| 540 #define MARK_EXTENTS_CHANGED mark_extents_changed () | |
| 541 void mark_icon_changed (void); | |
| 542 #define MARK_ICON_CHANGED mark_icon_changed () | |
| 543 void mark_menubar_changed (void); | |
| 544 #define MARK_MENUBAR_CHANGED mark_menubar_changed () | |
| 545 void mark_modeline_changed (void); | |
| 546 #define MARK_MODELINE_CHANGED mark_modeline_changed () | |
| 547 void mark_point_changed (void); | |
| 548 #define MARK_POINT_CHANGED mark_point_changed () | |
| 549 void mark_toolbar_changed (void); | |
| 550 #define MARK_TOOLBAR_CHANGED mark_toolbar_changed () | |
| 551 void mark_gutter_changed (void); | |
| 552 #define MARK_GUTTER_CHANGED mark_gutter_changed () | |
| 553 void mark_glyphs_changed (void); | |
| 554 #define MARK_GLYPHS_CHANGED mark_glyphs_changed () | |
| 555 void mark_subwindows_changed (void); | |
| 556 #define MARK_SUBWINDOWS_CHANGED mark_subwindows_changed () | |
| 557 void mark_subwindows_state_changed (void); | |
| 558 #define MARK_SUBWINDOWS_STATE_CHANGED mark_subwindows_state_changed () | |
| 428 | 559 |
| 560 #define CLASS_RESET_CHANGED_FLAGS(p) do { \ | |
| 561 (p)->buffers_changed = 0; \ | |
| 562 (p)->clip_changed = 0; \ | |
| 563 (p)->extents_changed = 0; \ | |
| 564 (p)->faces_changed = 0; \ | |
| 565 (p)->frame_changed = 0; \ | |
| 905 | 566 (p)->frame_layout_changed = 0; \ |
| 428 | 567 (p)->icon_changed = 0; \ |
| 568 (p)->menubar_changed = 0; \ | |
| 569 (p)->modeline_changed = 0; \ | |
| 570 (p)->point_changed = 0; \ | |
| 571 (p)->toolbar_changed = 0; \ | |
| 572 (p)->gutter_changed = 0; \ | |
| 573 (p)->glyphs_changed = 0; \ | |
| 574 (p)->subwindows_changed = 0; \ | |
| 575 (p)->subwindows_state_changed = 0; \ | |
| 576 (p)->windows_changed = 0; \ | |
| 577 (p)->windows_structure_changed = 0; \ | |
| 578 } while (0) | |
| 579 | |
| 580 #define GLOBAL_RESET_CHANGED_FLAGS do { \ | |
| 581 buffers_changed = 0; \ | |
| 582 clip_changed = 0; \ | |
| 583 extents_changed = 0; \ | |
| 584 frame_changed = 0; \ | |
| 905 | 585 frame_layout_changed = 0; \ |
| 428 | 586 icon_changed = 0; \ |
| 587 menubar_changed = 0; \ | |
| 588 modeline_changed = 0; \ | |
| 589 point_changed = 0; \ | |
| 590 toolbar_changed = 0; \ | |
| 591 gutter_changed = 0; \ | |
| 592 glyphs_changed = 0; \ | |
| 593 subwindows_changed = 0; \ | |
| 442 | 594 subwindows_state_changed = 0; \ |
| 428 | 595 windows_changed = 0; \ |
| 596 windows_structure_changed = 0; \ | |
| 597 } while (0) | |
| 598 | |
| 599 #define CLASS_REDISPLAY_FLAGS_CHANGEDP(p) \ | |
| 600 ( (p)->buffers_changed || \ | |
| 601 (p)->clip_changed || \ | |
| 602 (p)->extents_changed || \ | |
| 603 (p)->faces_changed || \ | |
| 604 (p)->frame_changed || \ | |
| 905 | 605 (p)->frame_layout_changed || \ |
| 428 | 606 (p)->icon_changed || \ |
| 607 (p)->menubar_changed || \ | |
| 608 (p)->modeline_changed || \ | |
| 609 (p)->point_changed || \ | |
| 610 (p)->toolbar_changed || \ | |
| 611 (p)->gutter_changed || \ | |
| 612 (p)->glyphs_changed || \ | |
| 442 | 613 (p)->size_changed || \ |
| 428 | 614 (p)->subwindows_changed || \ |
| 615 (p)->subwindows_state_changed || \ | |
| 616 (p)->windows_changed || \ | |
| 617 (p)->windows_structure_changed ) | |
| 618 | |
| 619 #define GLOBAL_REDISPLAY_FLAGS_CHANGEDP \ | |
| 620 ( buffers_changed || \ | |
| 621 clip_changed || \ | |
| 622 extents_changed || \ | |
| 623 faces_changed || \ | |
| 624 frame_changed || \ | |
| 905 | 625 frame_layout_changed || \ |
| 428 | 626 icon_changed || \ |
| 627 menubar_changed || \ | |
| 628 modeline_changed || \ | |
| 629 point_changed || \ | |
| 630 toolbar_changed || \ | |
| 631 gutter_changed || \ | |
| 632 glyphs_changed || \ | |
| 430 | 633 size_changed || \ |
| 428 | 634 subwindows_changed || \ |
| 635 subwindows_state_changed || \ | |
| 636 windows_changed || \ | |
| 637 windows_structure_changed ) | |
| 638 | |
| 639 | |
| 640 /* Anytime a console, device or frame is added or deleted we need to reset | |
| 641 these flags. */ | |
| 642 #define RESET_CHANGED_SET_FLAGS do { \ | |
| 643 buffers_changed_set = 0; \ | |
| 644 clip_changed_set = 0; \ | |
| 645 extents_changed_set = 0; \ | |
| 646 icon_changed_set = 0; \ | |
| 647 menubar_changed_set = 0; \ | |
| 648 modeline_changed_set = 0; \ | |
| 649 point_changed_set = 0; \ | |
| 650 toolbar_changed_set = 0; \ | |
| 651 gutter_changed_set = 0; \ | |
| 652 glyphs_changed_set = 0; \ | |
| 653 subwindows_changed_set = 0; \ | |
| 654 subwindows_state_changed_set = 0; \ | |
| 655 } while (0) | |
| 656 | |
| 657 | |
| 658 /*************************************************************************/ | |
| 659 /* redisplay global variables */ | |
| 660 /*************************************************************************/ | |
| 661 | |
| 1204 | 662 extern const struct sized_memory_description display_line_dynarr_description; |
| 663 | |
| 428 | 664 /* redisplay structure used by various utility routines. */ |
| 665 extern display_line_dynarr *cmotion_display_lines; | |
| 666 | |
| 667 /* Nonzero means truncate lines in all windows less wide than the frame. */ | |
| 668 extern int truncate_partial_width_windows; | |
| 669 | |
| 670 /* Nonzero if we're in a display critical section. */ | |
| 671 extern int in_display; | |
| 672 | |
| 1318 | 673 /* Whether we should delay size changes. Broken out of |
| 674 enter_redisplay_critical_section(). */ | |
| 675 extern int hold_frame_size_changes; | |
| 676 | |
| 428 | 677 /* Nonzero means no need to redraw the entire frame on resuming |
| 678 a suspended Emacs. This is useful on terminals with multiple pages, | |
| 679 where one page is used for Emacs and another for all else. */ | |
| 680 extern int no_redraw_on_reenter; | |
| 681 | |
| 442 | 682 /* Non-nil means flash the frame instead of ringing the bell. */ |
| 683 extern Lisp_Object Vvisible_bell; | |
| 428 | 684 |
| 685 /* Thickness of shadow border around 3D modelines. */ | |
| 686 extern Lisp_Object Vmodeline_shadow_thickness; | |
| 687 | |
| 688 /* Scroll if point lands on the bottom line and that line is partially | |
| 689 clipped. */ | |
| 690 extern int scroll_on_clipped_lines; | |
| 691 | |
| 692 extern Lisp_Object Vglobal_mode_string; | |
| 693 | |
| 694 /* The following two variables are defined in emacs.c and are used | |
| 695 to convey information discovered on the command line way early | |
| 696 (before *anything* is initialized). */ | |
| 697 | |
| 698 /* If non-zero, a window-system was specified on the command line. | |
| 699 Defined in emacs.c. */ | |
| 700 extern int display_arg; | |
| 701 | |
| 702 /* Type of display specified. Defined in emacs.c. */ | |
| 2367 | 703 extern const Ascbyte *display_use; |
| 428 | 704 |
| 705 /* Nonzero means reading single-character input with prompt | |
| 706 so put cursor on minibuffer after the prompt. */ | |
| 707 | |
| 708 extern int cursor_in_echo_area; | |
| 709 | |
| 710 extern Lisp_Object Qbar_cursor, Qcursor_in_echo_area, Vwindow_system; | |
| 711 | |
| 442 | 712 extern Lisp_Object Qtop_bottom; |
| 713 | |
| 428 | 714 |
| 715 /*************************************************************************/ | |
| 716 /* redisplay exported functions */ | |
| 717 /*************************************************************************/ | |
| 718 EXFUN (Fredraw_frame, 2); | |
| 719 | |
|
4815
6540302eedf5
Fix query_string_geometry lookup domain
Didier Verna <didier@lrde.epita.fr>
parents:
4207
diff
changeset
|
720 int redisplay_text_width_string (Lisp_Object domain, Lisp_Object face, |
| 867 | 721 Ibyte *nonreloc, Lisp_Object reloc, |
| 428 | 722 Bytecount offset, Bytecount len); |
| 442 | 723 int redisplay_frame (struct frame *f, int preemption_check); |
| 853 | 724 void redisplay_no_pre_idle_hook (void); |
| 428 | 725 void redisplay (void); |
| 853 | 726 Lisp_Object eval_within_redisplay (Lisp_Object dont_trust_this_damn_sucker); |
| 428 | 727 struct display_block *get_display_block_from_line (struct display_line *dl, |
| 728 enum display_type type); | |
| 729 layout_bounds calculate_display_line_boundaries (struct window *w, | |
| 730 int modeline); | |
| 665 | 731 Charbpos point_at_center (struct window *w, int type, Charbpos start, |
| 826 | 732 Charbpos point); |
| 733 int line_at_center (struct window *w, int type, Charbpos start, | |
| 734 Charbpos point); | |
| 428 | 735 int window_half_pixpos (struct window *w); |
| 736 void redisplay_echo_area (void); | |
| 737 void free_display_structs (struct window_mirror *mir); | |
| 738 void free_display_lines (display_line_dynarr *dla); | |
| 442 | 739 void mark_redisplay_structs (display_line_dynarr *dla); |
| 428 | 740 void generate_displayable_area (struct window *w, Lisp_Object disp_string, |
| 741 int xpos, int ypos, int width, int height, | |
| 742 display_line_dynarr* dl, | |
| 665 | 743 Charbpos start_pos, face_index default_face); |
| 438 | 744 /* `generate_title_string' in frame.c needs this */ |
| 745 void generate_formatted_string_db (Lisp_Object format_str, | |
| 746 Lisp_Object result_str, | |
| 747 struct window *w, | |
| 748 struct display_line *dl, | |
| 749 struct display_block *db, | |
| 750 face_index findex, | |
| 751 int min_pixpos, int max_pixpos, int type); | |
| 428 | 752 int real_current_modeline_height (struct window *w); |
| 753 int pixel_to_glyph_translation (struct frame *f, int x_coord, | |
| 754 int y_coord, int *col, int *row, | |
| 755 int *obj_x, int *obj_y, | |
| 665 | 756 struct window **w, Charbpos *charbpos, |
| 757 Charbpos *closest, Charcount *modeline_closest, | |
| 428 | 758 Lisp_Object *obj1, Lisp_Object *obj2); |
| 759 void glyph_to_pixel_translation (struct window *w, int char_x, | |
| 760 int char_y, int *pix_x, int *pix_y); | |
| 665 | 761 int point_in_line_start_cache (struct window *w, Charbpos point, |
| 428 | 762 int min_past); |
| 665 | 763 int point_would_be_visible (struct window *w, Charbpos startp, |
| 1708 | 764 Charbpos point, int partially); |
| 665 | 765 Charbpos start_of_last_line (struct window *w, Charbpos startp); |
| 766 Charbpos end_of_last_line (struct window *w, Charbpos startp); | |
| 767 Charbpos start_with_line_at_pixpos (struct window *w, Charbpos point, | |
| 826 | 768 int pixpos); |
| 665 | 769 Charbpos start_with_point_on_display_line (struct window *w, Charbpos point, |
| 826 | 770 int line); |
| 428 | 771 int redisplay_variable_changed (Lisp_Object sym, Lisp_Object *val, |
| 772 Lisp_Object in_object, int flags); | |
| 773 void redisplay_glyph_changed (Lisp_Object glyph, Lisp_Object property, | |
| 774 Lisp_Object locale); | |
| 775 | |
| 776 #ifdef MEMORY_USAGE_STATS | |
| 777 int compute_display_line_dynarr_usage (display_line_dynarr *dyn, | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
4815
diff
changeset
|
778 struct usage_stats *ustats); |
| 428 | 779 int compute_line_start_cache_dynarr_usage (line_start_cache_dynarr *dyn, |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
4815
diff
changeset
|
780 struct usage_stats *ustats); |
| 428 | 781 #endif |
| 782 | |
| 783 | |
| 784 /* defined in redisplay-output.c */ | |
| 785 int get_next_display_block (layout_bounds bounds, | |
| 786 display_block_dynarr *dba, int start_pos, | |
| 787 int *next_start); | |
| 442 | 788 void redisplay_output_layout (Lisp_Object domain, |
| 428 | 789 Lisp_Object image_instance, |
| 617 | 790 struct display_box* db, |
| 791 struct display_glyph_area* dga, | |
| 792 face_index findex, int cursor_start, | |
| 793 int cursor_width, | |
| 428 | 794 int cursor_height); |
| 795 void redisplay_output_subwindow (struct window *w, | |
| 796 Lisp_Object image_instance, | |
| 617 | 797 struct display_box* db, |
| 798 struct display_glyph_area* dga, | |
| 799 face_index findex, int cursor_start, | |
| 800 int cursor_width, | |
| 428 | 801 int cursor_height); |
| 617 | 802 void redisplay_unmap_subwindows_maybe (struct frame* f, int x, int y, |
| 803 int width, int height); | |
| 428 | 804 void redisplay_output_pixmap (struct window *w, |
| 805 Lisp_Object image_instance, | |
| 617 | 806 struct display_box* db, |
| 807 struct display_glyph_area* dga, | |
| 808 face_index findex, int cursor_start, | |
| 809 int cursor_width, | |
| 428 | 810 int cursor_height, int offset_bitmap); |
| 811 int redisplay_calculate_display_boxes (struct display_line *dl, int xpos, | |
| 819 | 812 int xoffset, int yoffset, int start_pixpos, |
| 4187 | 813 int width, struct display_box* dest, |
| 428 | 814 struct display_glyph_area* src); |
| 815 int redisplay_normalize_glyph_area (struct display_box* dest, | |
| 816 struct display_glyph_area* glyphsrc); | |
| 817 void redisplay_clear_to_window_end (struct window *w, int ypos1, int ypos2); | |
| 818 void redisplay_clear_region (Lisp_Object window, face_index findex, int x, | |
| 819 int y, int width, int height); | |
| 448 | 820 void redisplay_clear_top_of_window (struct window *w); |
| 428 | 821 void redisplay_clear_bottom_of_window (struct window *w, |
| 822 display_line_dynarr *ddla, | |
| 823 int min_start, int max_end); | |
| 824 void redisplay_update_line (struct window *w, int first_line, | |
| 825 int last_line, int update_values); | |
| 826 void redisplay_output_window (struct window *w); | |
| 827 void bevel_modeline (struct window *w, struct display_line *dl); | |
| 665 | 828 int redisplay_move_cursor (struct window *w, Charbpos new_point, |
| 428 | 829 int no_output_end); |
| 830 void redisplay_redraw_cursor (struct frame *f, int run_begin_end_meths); | |
| 831 void output_display_line (struct window *w, display_line_dynarr *cdla, | |
| 832 display_line_dynarr *ddla, int line, | |
| 833 int force_start, int force_end); | |
| 442 | 834 void sync_display_line_structs (struct window *w, int line, int do_blocks, |
| 835 display_line_dynarr *cdla, | |
| 836 display_line_dynarr *ddla); | |
| 1318 | 837 void redisplay_redraw_exposed_area (struct frame *f, int x, int y, int width, |
| 838 int height); | |
| 839 void register_post_redisplay_action (void (*fun) (Lisp_Object), | |
| 840 Lisp_Object arg); | |
| 841 int begin_hold_frame_size_changes (void); | |
| 842 int enter_redisplay_critical_section (void); | |
| 843 void exit_redisplay_critical_section (int); | |
| 844 int enter_redisplay_critical_section_maybe (void); | |
| 845 void exit_redisplay_critical_section_maybe (int depth); | |
| 2518 | 846 int enter_redisplay_critical_section_if (Boolint from_outside); |
| 847 void exit_redisplay_critical_section_if (Boolint from_outside, int depth); | |
| 428 | 848 |
|
5348
39304a35b6b3
Don't commit suicide when an X device dies.
Mike Sperber <sperber@deinprogramm.de>
parents:
5157
diff
changeset
|
849 void redisplay_cancel_ritual_suicide(void); |
|
39304a35b6b3
Don't commit suicide when an X device dies.
Mike Sperber <sperber@deinprogramm.de>
parents:
5157
diff
changeset
|
850 |
| 440 | 851 #endif /* INCLUDED_redisplay_h_ */ |