1/* Interface definitions for display code. 2 Copyright (C) 1985, 1993, 1994, 1997, 1998, 1999, 2000, 2001, 2002, 3 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. 4 5This file is part of GNU Emacs. 6 7GNU Emacs is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2, or (at your option) 10any later version. 11 12GNU Emacs is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GNU Emacs; see the file COPYING. If not, write to 19the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 20Boston, MA 02110-1301, USA. */ 21 22/* New redisplay written by Gerd Moellmann <gerd@gnu.org>. */ 23 24#ifndef DISPEXTERN_H_INCLUDED 25#define DISPEXTERN_H_INCLUDED 26 27#ifdef HAVE_X_WINDOWS 28 29#include <X11/Xlib.h> 30#ifdef USE_X_TOOLKIT 31#include <X11/Intrinsic.h> 32#endif /* USE_X_TOOLKIT */ 33 34#else /* !HAVE_X_WINDOWS */ 35 36/* X-related stuff used by non-X gui code. */ 37 38typedef struct { 39 unsigned long pixel; 40 unsigned short red, green, blue; 41 char flags; 42 char pad; 43} XColor; 44 45#endif /* HAVE_X_WINDOWS */ 46 47#ifdef MSDOS 48#include "msdos.h" 49#endif 50 51#ifdef HAVE_X_WINDOWS 52typedef struct x_display_info Display_Info; 53typedef XImage * XImagePtr; 54typedef XImagePtr XImagePtr_or_DC; 55#define NativeRectangle XRectangle 56#endif 57 58#ifdef HAVE_NTGUI 59#include "w32gui.h" 60typedef struct w32_display_info Display_Info; 61typedef XImage *XImagePtr; 62typedef HDC XImagePtr_or_DC; 63#endif 64 65#ifdef MAC_OS 66#include "macgui.h" 67typedef struct mac_display_info Display_Info; 68/* Mac equivalent of XImage. */ 69typedef Pixmap XImagePtr; 70typedef XImagePtr XImagePtr_or_DC; 71#endif 72 73#ifndef NativeRectangle 74#define NativeRectangle int 75#endif 76 77/* Structure forward declarations. Some are here because function 78 prototypes below reference structure types before their definition 79 in this file. Some are here because not every file including 80 dispextern.h also includes frame.h and windows.h. */ 81 82struct glyph; 83struct glyph_row; 84struct glyph_matrix; 85struct glyph_pool; 86struct frame; 87struct window; 88 89 90/* Values returned from coordinates_in_window. */ 91 92enum window_part 93{ 94 ON_NOTHING, 95 ON_TEXT, 96 ON_MODE_LINE, 97 ON_VERTICAL_BORDER, 98 ON_HEADER_LINE, 99 ON_LEFT_FRINGE, 100 ON_RIGHT_FRINGE, 101 ON_LEFT_MARGIN, 102 ON_RIGHT_MARGIN, 103 ON_SCROLL_BAR 104}; 105 106/* Number of bits allocated to store fringe bitmap numbers. */ 107#define FRINGE_ID_BITS 16 108 109 110 111/*********************************************************************** 112 Debugging 113 ***********************************************************************/ 114 115/* If GLYPH_DEBUG is non-zero, additional checks are activated. Turn 116 it off by defining the macro GLYPH_DEBUG to zero. */ 117 118#ifndef GLYPH_DEBUG 119#define GLYPH_DEBUG 0 120#endif 121 122/* If XASSERTS is non-zero, additional consistency checks are activated. 123 Turn it off by defining the macro XASSERTS to zero. */ 124 125#ifndef XASSERTS 126#define XASSERTS 0 127#endif 128 129/* Macros to include code only if GLYPH_DEBUG != 0. */ 130 131#if GLYPH_DEBUG 132#define IF_DEBUG(X) X 133#else 134#define IF_DEBUG(X) (void) 0 135#endif 136 137#if XASSERTS 138#define xassert(X) do {if (!(X)) abort ();} while (0) 139#else 140#define xassert(X) (void) 0 141#endif 142 143/* Macro for displaying traces of redisplay. If Emacs was compiled 144 with GLYPH_DEBUG != 0, the variable trace_redisplay_p can be set to 145 a non-zero value in debugging sessions to activate traces. */ 146 147#if GLYPH_DEBUG 148 149extern int trace_redisplay_p; 150#include <stdio.h> 151 152#define TRACE(X) \ 153 if (trace_redisplay_p) \ 154 fprintf X; \ 155 else \ 156 (void) 0 157 158#else /* GLYPH_DEBUG == 0 */ 159 160#define TRACE(X) (void) 0 161 162#endif /* GLYPH_DEBUG == 0 */ 163 164 165 166/*********************************************************************** 167 Text positions 168 ***********************************************************************/ 169 170/* Starting with Emacs 20.3, characters from strings and buffers have 171 both a character and a byte position associated with them. The 172 following structure holds such a pair of positions. */ 173 174struct text_pos 175{ 176 /* Character position. */ 177 int charpos; 178 179 /* Corresponding byte position. */ 180 int bytepos; 181}; 182 183/* Access character and byte position of POS in a functional form. */ 184 185#define BYTEPOS(POS) (POS).bytepos 186#define CHARPOS(POS) (POS).charpos 187 188/* Set character position of POS to CHARPOS, byte position to BYTEPOS. */ 189 190#define SET_TEXT_POS(POS, CHARPOS, BYTEPOS) \ 191 ((POS).charpos = (CHARPOS), (POS).bytepos = BYTEPOS) 192 193/* Increment text position POS. */ 194 195#define INC_TEXT_POS(POS, MULTIBYTE_P) \ 196 do \ 197 { \ 198 ++(POS).charpos; \ 199 if (MULTIBYTE_P) \ 200 INC_POS ((POS).bytepos); \ 201 else \ 202 ++(POS).bytepos; \ 203 } \ 204 while (0) 205 206/* Decrement text position POS. */ 207 208#define DEC_TEXT_POS(POS, MULTIBYTE_P) \ 209 do \ 210 { \ 211 --(POS).charpos; \ 212 if (MULTIBYTE_P) \ 213 DEC_POS ((POS).bytepos); \ 214 else \ 215 --(POS).bytepos; \ 216 } \ 217 while (0) 218 219/* Set text position POS from marker MARKER. */ 220 221#define SET_TEXT_POS_FROM_MARKER(POS, MARKER) \ 222 (CHARPOS (POS) = marker_position ((MARKER)), \ 223 BYTEPOS (POS) = marker_byte_position ((MARKER))) 224 225/* Set marker MARKER from text position POS. */ 226 227#define SET_MARKER_FROM_TEXT_POS(MARKER, POS) \ 228 set_marker_both ((MARKER), Qnil, CHARPOS ((POS)), BYTEPOS ((POS))) 229 230/* Value is non-zero if character and byte positions of POS1 and POS2 231 are equal. */ 232 233#define TEXT_POS_EQUAL_P(POS1, POS2) \ 234 ((POS1).charpos == (POS2).charpos \ 235 && (POS1).bytepos == (POS2).bytepos) 236 237/* When rendering glyphs, redisplay scans string or buffer text, 238 overlay strings in that text, and does display table or control 239 character translations. The following structure captures a 240 position taking all this into account. */ 241 242struct display_pos 243{ 244 /* Buffer or string position. */ 245 struct text_pos pos; 246 247 /* If this is a position in an overlay string, overlay_string_index 248 is the index of that overlay string in the sequence of overlay 249 strings at `pos' in the order redisplay processes them. A value 250 < 0 means that this is not a position in an overlay string. */ 251 int overlay_string_index; 252 253 /* If this is a position in an overlay string, string_pos is the 254 position within that string. */ 255 struct text_pos string_pos; 256 257 /* If the character at the position above is a control character or 258 has a display table entry, dpvec_index is an index in the display 259 table or control character translation of that character. A 260 value < 0 means this is not a position in such a translation. */ 261 int dpvec_index; 262}; 263 264 265 266/*********************************************************************** 267 Glyphs 268 ***********************************************************************/ 269 270/* Enumeration of glyph types. Glyph structures contain a type field 271 containing one of the enumerators defined here. */ 272 273enum glyph_type 274{ 275 /* Glyph describes a character. */ 276 CHAR_GLYPH, 277 278 /* Glyph describes a composition sequence. */ 279 COMPOSITE_GLYPH, 280 281 /* Glyph describes an image. */ 282 IMAGE_GLYPH, 283 284 /* Glyph is a space of fractional width and/or height. */ 285 STRETCH_GLYPH 286}; 287 288 289/* Structure describing how to use partial glyphs (images slicing) */ 290 291struct glyph_slice 292{ 293 unsigned x : 16; 294 unsigned y : 16; 295 unsigned width : 16; 296 unsigned height : 16; 297}; 298 299 300/* Glyphs. 301 302 Be extra careful when changing this structure! Esp. make sure that 303 functions producing glyphs, like append_glyph, fill ALL of the 304 glyph structure, and that GLYPH_EQUAL_P compares all 305 display-relevant members of glyphs (not to imply that these are the 306 only things to check when you add a member). */ 307 308struct glyph 309{ 310 /* Position from which this glyph was drawn. If `object' below is a 311 Lisp string, this is a position in that string. If it is a 312 buffer, this is a position in that buffer. A value of -1 313 together with a null object means glyph is a truncation glyph at 314 the start of a row. */ 315 int charpos; 316 317 /* Lisp object source of this glyph. Currently either a buffer or 318 a string, if the glyph was produced from characters which came from 319 a buffer or a string; or 0 if the glyph was inserted by redisplay 320 for its own purposes such as padding. */ 321 Lisp_Object object; 322 323 /* Width in pixels. */ 324 short pixel_width; 325 326 /* Ascent and descent in pixels. */ 327 short ascent, descent; 328 329 /* Vertical offset. If < 0, the glyph is displayed raised, if > 0 330 the glyph is displayed lowered. */ 331 short voffset; 332 333 /* Which kind of glyph this is---character, image etc. Value 334 should be an enumerator of type enum glyph_type. */ 335 unsigned type : 2; 336 337 /* 1 means this glyph was produced from multibyte text. Zero 338 means it was produced from unibyte text, i.e. charsets aren't 339 applicable, and encoding is not performed. */ 340 unsigned multibyte_p : 1; 341 342 /* Non-zero means draw a box line at the left or right side of this 343 glyph. This is part of the implementation of the face attribute 344 `:box'. */ 345 unsigned left_box_line_p : 1; 346 unsigned right_box_line_p : 1; 347 348 /* Non-zero means this glyph's physical ascent or descent is greater 349 than its logical ascent/descent, i.e. it may potentially overlap 350 glyphs above or below it. */ 351 unsigned overlaps_vertically_p : 1; 352 353 /* 1 means glyph is a padding glyph. Padding glyphs are used for 354 characters whose visual shape consists of more than one glyph 355 (e.g. Asian characters). All but the first glyph of such a glyph 356 sequence have the padding_p flag set. Only used for terminal 357 frames, and there only to minimize code changes. A better way 358 would probably be to use the width field of glyphs to express 359 padding. */ 360 unsigned padding_p : 1; 361 362 /* 1 means the actual glyph is not available, draw a box instead. 363 This can happen when a font couldn't be loaded, or a character 364 doesn't have a glyph in a font. */ 365 unsigned glyph_not_available_p : 1; 366 367#define FACE_ID_BITS 21 368 369 /* Face of the glyph. This is a realized face ID, 370 an index in the face cache of the frame. */ 371 unsigned face_id : FACE_ID_BITS; 372 373 /* Type of font used to display the character glyph. May be used to 374 determine which set of functions to use to obtain font metrics 375 for the glyph. On W32, value should be an enumerator of the type 376 w32_char_font_type. Otherwise it equals FONT_TYPE_UNKNOWN. */ 377 unsigned font_type : 3; 378 379 struct glyph_slice slice; 380 381 /* A union of sub-structures for different glyph types. */ 382 union 383 { 384 /* Character code for character glyphs (type == CHAR_GLYPH). */ 385 unsigned ch; 386 387 /* Composition ID for composition glyphs (type == COMPOSITION_GLYPH) */ 388 unsigned cmp_id; 389 390 /* Image ID for image glyphs (type == IMAGE_GLYPH). */ 391 unsigned img_id; 392 393 /* Sub-structure for type == STRETCH_GLYPH. */ 394 struct 395 { 396 /* The height of the glyph. */ 397 unsigned height : 16; 398 399 /* The ascent of the glyph. */ 400 unsigned ascent : 16; 401 } 402 stretch; 403 404 /* Used to compare all bit-fields above in one step. */ 405 unsigned val; 406 } u; 407}; 408 409 410/* Default value of the glyph font_type field. */ 411 412#define FONT_TYPE_UNKNOWN 0 413 414/* Is GLYPH a space? */ 415 416#define CHAR_GLYPH_SPACE_P(GLYPH) \ 417 (GLYPH_FROM_CHAR_GLYPH ((GLYPH)) == SPACEGLYPH) 418 419/* Are glyph slices of glyphs *X and *Y equal */ 420 421#define GLYPH_SLICE_EQUAL_P(X, Y) \ 422 ((X)->slice.x == (Y)->slice.x \ 423 && (X)->slice.y == (Y)->slice.y \ 424 && (X)->slice.width == (Y)->slice.width \ 425 && (X)->slice.height == (Y)->slice.height) 426 427/* Are glyphs *X and *Y displayed equal? */ 428 429#define GLYPH_EQUAL_P(X, Y) \ 430 ((X)->type == (Y)->type \ 431 && (X)->u.val == (Y)->u.val \ 432 && GLYPH_SLICE_EQUAL_P (X, Y) \ 433 && (X)->face_id == (Y)->face_id \ 434 && (X)->padding_p == (Y)->padding_p \ 435 && (X)->left_box_line_p == (Y)->left_box_line_p \ 436 && (X)->right_box_line_p == (Y)->right_box_line_p \ 437 && (X)->voffset == (Y)->voffset \ 438 && (X)->pixel_width == (Y)->pixel_width) 439 440/* Are character codes, faces, padding_ps of glyphs *X and *Y equal? */ 441 442#define GLYPH_CHAR_AND_FACE_EQUAL_P(X, Y) \ 443 ((X)->u.ch == (Y)->u.ch \ 444 && (X)->face_id == (Y)->face_id \ 445 && (X)->padding_p == (Y)->padding_p) 446 447/* Fill a character glyph GLYPH. CODE, FACE_ID, PADDING_P correspond 448 to the bits defined for the typedef `GLYPH' in lisp.h. */ 449 450#define SET_CHAR_GLYPH(GLYPH, CODE, FACE_ID, PADDING_P) \ 451 do \ 452 { \ 453 (GLYPH).u.ch = (CODE); \ 454 (GLYPH).face_id = (FACE_ID); \ 455 (GLYPH).padding_p = (PADDING_P); \ 456 } \ 457 while (0) 458 459/* Fill a character type glyph GLYPH from a glyph typedef FROM as 460 defined in lisp.h. */ 461 462#define SET_CHAR_GLYPH_FROM_GLYPH(GLYPH, FROM) \ 463 SET_CHAR_GLYPH ((GLYPH), \ 464 FAST_GLYPH_CHAR ((FROM)), \ 465 FAST_GLYPH_FACE ((FROM)), \ 466 0) 467 468/* Construct a glyph code from a character glyph GLYPH. If the 469 character is multibyte, return -1 as we can't use glyph table for a 470 multibyte character. */ 471 472#define GLYPH_FROM_CHAR_GLYPH(GLYPH) \ 473 ((GLYPH).u.ch < 256 \ 474 ? ((GLYPH).u.ch | ((GLYPH).face_id << CHARACTERBITS)) \ 475 : -1) 476 477/* Is GLYPH a padding glyph? */ 478 479#define CHAR_GLYPH_PADDING_P(GLYPH) (GLYPH).padding_p 480 481 482 483 484/*********************************************************************** 485 Glyph Pools 486 ***********************************************************************/ 487 488/* Glyph Pool. 489 490 Glyph memory for frame-based redisplay is allocated from the heap 491 in one vector kept in a glyph pool structure which is stored with 492 the frame. The size of the vector is made large enough to cover 493 all windows on the frame. 494 495 Both frame and window glyph matrices reference memory from a glyph 496 pool in frame-based redisplay. 497 498 In window-based redisplay, no glyphs pools exist; windows allocate 499 and free their glyph memory themselves. */ 500 501struct glyph_pool 502{ 503 /* Vector of glyphs allocated from the heap. */ 504 struct glyph *glyphs; 505 506 /* Allocated size of `glyphs'. */ 507 int nglyphs; 508 509 /* Number of rows and columns in a matrix. */ 510 int nrows, ncolumns; 511}; 512 513 514 515/*********************************************************************** 516 Glyph Matrix 517 ***********************************************************************/ 518 519/* Glyph Matrix. 520 521 Three kinds of glyph matrices exist: 522 523 1. Frame glyph matrices. These are used for terminal frames whose 524 redisplay needs a view of the whole screen due to limited terminal 525 capabilities. Frame matrices are used only in the update phase 526 of redisplay. They are built in update_frame and not used after 527 the update has been performed. 528 529 2. Window glyph matrices on frames having frame glyph matrices. 530 Such matrices are sub-matrices of their corresponding frame matrix, 531 i.e. frame glyph matrices and window glyph matrices share the same 532 glyph memory which is allocated in form of a glyph_pool structure. 533 Glyph rows in such a window matrix are slices of frame matrix rows. 534 535 2. Free-standing window glyph matrices managing their own glyph 536 storage. This form is used in window-based redisplay which 537 includes variable width and height fonts etc. 538 539 The size of a window's row vector depends on the height of fonts 540 defined on its frame. It is chosen so that the vector is large 541 enough to describe all lines in a window when it is displayed in 542 the smallest possible character size. When new fonts are loaded, 543 or window sizes change, the row vector is adjusted accordingly. */ 544 545struct glyph_matrix 546{ 547 /* The pool from which glyph memory is allocated, if any. This is 548 null for frame matrices and for window matrices managing their 549 own storage. */ 550 struct glyph_pool *pool; 551 552 /* Vector of glyph row structures. The row at nrows - 1 is reserved 553 for the mode line. */ 554 struct glyph_row *rows; 555 556 /* Number of elements allocated for the vector rows above. */ 557 int rows_allocated; 558 559 /* The number of rows used by the window if all lines were displayed 560 with the smallest possible character height. */ 561 int nrows; 562 563 /* Origin within the frame matrix if this is a window matrix on a 564 frame having a frame matrix. Both values are zero for 565 window-based redisplay. */ 566 int matrix_x, matrix_y; 567 568 /* Width and height of the matrix in columns and rows. */ 569 int matrix_w, matrix_h; 570 571 /* If this structure describes a window matrix of window W, 572 window_left_col is the value of W->left_col, window_top_line the 573 value of W->top_line, window_height and window_width are width and 574 height of W, as returned by window_box, and window_vscroll is the 575 value of W->vscroll at the time the matrix was last adjusted. 576 Only set for window-based redisplay. */ 577 int window_left_col, window_top_line; 578 int window_height, window_width; 579 int window_vscroll; 580 581 /* Number of glyphs reserved for left and right marginal areas when 582 the matrix was last adjusted. */ 583 int left_margin_glyphs, right_margin_glyphs; 584 585 /* Flag indicating that scrolling should not be tried in 586 update_window. This flag is set by functions like try_window_id 587 which do their own scrolling. */ 588 unsigned no_scrolling_p : 1; 589 590 /* Non-zero means window displayed in this matrix has a top mode 591 line. */ 592 unsigned header_line_p : 1; 593 594#ifdef GLYPH_DEBUG 595 /* A string identifying the method used to display the matrix. */ 596 char method[512]; 597#endif 598 599 /* The buffer this matrix displays. Set in 600 mark_window_display_accurate_1. */ 601 struct buffer *buffer; 602 603 /* Values of BEGV and ZV as of last redisplay. Set in 604 mark_window_display_accurate_1. */ 605 int begv, zv; 606}; 607 608 609/* Check that glyph pointers stored in glyph rows of MATRIX are okay. 610 This aborts if any pointer is found twice. */ 611 612#if GLYPH_DEBUG 613void check_matrix_pointer_lossage P_ ((struct glyph_matrix *)); 614#define CHECK_MATRIX(MATRIX) check_matrix_pointer_lossage ((MATRIX)) 615#else 616#define CHECK_MATRIX(MATRIX) (void) 0 617#endif 618 619 620 621/*********************************************************************** 622 Glyph Rows 623 ***********************************************************************/ 624 625/* Area in window glyph matrix. If values are added or removed, the 626 function mark_object in alloc.c has to be changed. */ 627 628enum glyph_row_area 629{ 630 LEFT_MARGIN_AREA, 631 TEXT_AREA, 632 RIGHT_MARGIN_AREA, 633 LAST_AREA 634}; 635 636 637/* Rows of glyphs in a windows or frame glyph matrix. 638 639 Each row is partitioned into three areas. The start and end of 640 each area is recorded in a pointer as shown below. 641 642 +--------------------+-------------+---------------------+ 643 | left margin area | text area | right margin area | 644 +--------------------+-------------+---------------------+ 645 | | | | 646 glyphs[LEFT_MARGIN_AREA] glyphs[RIGHT_MARGIN_AREA] 647 | | 648 glyphs[TEXT_AREA] | 649 glyphs[LAST_AREA] 650 651 Rows in frame matrices reference glyph memory allocated in a frame 652 glyph pool (see the description of struct glyph_pool). Rows in 653 window matrices on frames having frame matrices reference slices of 654 the glyphs of corresponding rows in the frame matrix. 655 656 Rows in window matrices on frames having no frame matrices point to 657 glyphs allocated from the heap via xmalloc; 658 glyphs[LEFT_MARGIN_AREA] is the start address of the allocated 659 glyph structure array. */ 660 661struct glyph_row 662{ 663 /* Pointers to beginnings of areas. The end of an area A is found at 664 A + 1 in the vector. The last element of the vector is the end 665 of the whole row. 666 667 Kludge alert: Even if used[TEXT_AREA] == 0, glyphs[TEXT_AREA][0]'s 668 position field is used. It is -1 if this row does not correspond 669 to any text; it is some buffer position if the row corresponds to 670 an empty display line that displays a line end. This is what old 671 redisplay used to do. (Except in code for terminal frames, this 672 kludge is no longer used, I believe. --gerd). 673 674 See also start, end, displays_text_p and ends_at_zv_p for cleaner 675 ways to do it. The special meaning of positions 0 and -1 will be 676 removed some day, so don't use it in new code. */ 677 struct glyph *glyphs[1 + LAST_AREA]; 678 679 /* Number of glyphs actually filled in areas. */ 680 short used[LAST_AREA]; 681 682 /* Window-relative x and y-position of the top-left corner of this 683 row. If y < 0, this means that abs (y) pixels of the row are 684 invisible because it is partially visible at the top of a window. 685 If x < 0, this means that abs (x) pixels of the first glyph of 686 the text area of the row are invisible because the glyph is 687 partially visible. */ 688 int x, y; 689 690 /* Width of the row in pixels without taking face extension at the 691 end of the row into account, and without counting truncation 692 and continuation glyphs at the end of a row on ttys. */ 693 int pixel_width; 694 695 /* Logical ascent/height of this line. The value of ascent is zero 696 and height is 1 on terminal frames. */ 697 int ascent, height; 698 699 /* Physical ascent/height of this line. If max_ascent > ascent, 700 this line overlaps the line above it on the display. Otherwise, 701 if max_height > height, this line overlaps the line beneath it. */ 702 int phys_ascent, phys_height; 703 704 /* Portion of row that is visible. Partially visible rows may be 705 found at the top and bottom of a window. This is 1 for tty 706 frames. It may be < 0 in case of completely invisible rows. */ 707 int visible_height; 708 709 /* Extra line spacing added after this row. Do not consider this 710 in last row when checking if row is fully visible. */ 711 int extra_line_spacing; 712 713 /* Hash code. This hash code is available as soon as the row 714 is constructed, i.e. after a call to display_line. */ 715 unsigned hash; 716 717 /* First position in this row. This is the text position, including 718 overlay position information etc, where the display of this row 719 started, and can thus be less the position of the first glyph 720 (e.g. due to invisible text or horizontal scrolling). */ 721 struct display_pos start; 722 723 /* Text position at the end of this row. This is the position after 724 the last glyph on this row. It can be greater than the last 725 glyph position + 1, due to truncation, invisible text etc. In an 726 up-to-date display, this should always be equal to the start 727 position of the next row. */ 728 struct display_pos end; 729 730 /* Non-zero means the overlay arrow bitmap is on this line. 731 -1 means use default overlay arrow bitmap, else 732 it specifies actual fringe bitmap number. */ 733 int overlay_arrow_bitmap; 734 735 /* Left fringe bitmap number (enum fringe_bitmap_type). */ 736 unsigned left_user_fringe_bitmap : FRINGE_ID_BITS; 737 738 /* Right fringe bitmap number (enum fringe_bitmap_type). */ 739 unsigned right_user_fringe_bitmap : FRINGE_ID_BITS; 740 741 /* Left fringe bitmap number (enum fringe_bitmap_type). */ 742 unsigned left_fringe_bitmap : FRINGE_ID_BITS; 743 744 /* Right fringe bitmap number (enum fringe_bitmap_type). */ 745 unsigned right_fringe_bitmap : FRINGE_ID_BITS; 746 747 /* Face of the left fringe glyph. */ 748 unsigned left_user_fringe_face_id : FACE_ID_BITS; 749 750 /* Face of the right fringe glyph. */ 751 unsigned right_user_fringe_face_id : FACE_ID_BITS; 752 753 /* Face of the left fringe glyph. */ 754 unsigned left_fringe_face_id : FACE_ID_BITS; 755 756 /* Face of the right fringe glyph. */ 757 unsigned right_fringe_face_id : FACE_ID_BITS; 758 759 /* 1 means that we must draw the bitmaps of this row. */ 760 unsigned redraw_fringe_bitmaps_p : 1; 761 762 /* In a desired matrix, 1 means that this row must be updated. In a 763 current matrix, 0 means that the row has been invalidated, i.e. 764 the row's contents do not agree with what is visible on the 765 screen. */ 766 unsigned enabled_p : 1; 767 768 /* 1 means row displays a text line that is truncated on the left or 769 right side. */ 770 unsigned truncated_on_left_p : 1; 771 unsigned truncated_on_right_p : 1; 772 773 /* 1 means that this row displays a continued line, i.e. it has a 774 continuation mark at the right side. */ 775 unsigned continued_p : 1; 776 777 /* 0 means that this row does not contain any text, i.e. it is 778 a blank line at the window and buffer end. */ 779 unsigned displays_text_p : 1; 780 781 /* 1 means that this line ends at ZV. */ 782 unsigned ends_at_zv_p : 1; 783 784 /* 1 means the face of the last glyph in the text area is drawn to 785 the right end of the window. This flag is used in 786 update_text_area to optimize clearing to the end of the area. */ 787 unsigned fill_line_p : 1; 788 789 /* Non-zero means display a bitmap on X frames indicating that this 790 line contains no text and ends in ZV. */ 791 unsigned indicate_empty_line_p : 1; 792 793 /* 1 means this row contains glyphs that overlap each other because 794 of lbearing or rbearing. */ 795 unsigned contains_overlapping_glyphs_p : 1; 796 797 /* 1 means this row is as wide as the window it is displayed in, including 798 scroll bars, fringes, and internal borders. This also 799 implies that the row doesn't have marginal areas. */ 800 unsigned full_width_p : 1; 801 802 /* Non-zero means row is a mode or header-line. */ 803 unsigned mode_line_p : 1; 804 805 /* 1 in a current row means this row is overlapped by another row. */ 806 unsigned overlapped_p : 1; 807 808 /* 1 means this line ends in the middle of a character consisting 809 of more than one glyph. Some glyphs have been put in this row, 810 the rest are put in rows below this one. */ 811 unsigned ends_in_middle_of_char_p : 1; 812 813 /* 1 means this line starts in the middle of a character consisting 814 of more than one glyph. Some glyphs have been put in the 815 previous row, the rest are put in this row. */ 816 unsigned starts_in_middle_of_char_p : 1; 817 818 /* 1 in a current row means this row overlaps others. */ 819 unsigned overlapping_p : 1; 820 821 /* 1 means some glyphs in this row are displayed in mouse-face. */ 822 unsigned mouse_face_p : 1; 823 824 /* 1 means this row was ended by a newline from a string. */ 825 unsigned ends_in_newline_from_string_p : 1; 826 827 /* 1 means this row width is exactly the width of the window, and the 828 final newline character is hidden in the right fringe. */ 829 unsigned exact_window_width_line_p : 1; 830 831 /* 1 means this row currently shows the cursor in the right fringe. */ 832 unsigned cursor_in_fringe_p : 1; 833 834 /* 1 means the last glyph in the row is part of an ellipsis. */ 835 unsigned ends_in_ellipsis_p : 1; 836 837 /* Non-zero means display a bitmap on X frames indicating that this 838 the first line of the buffer. */ 839 unsigned indicate_bob_p : 1; 840 841 /* Non-zero means display a bitmap on X frames indicating that this 842 the top line of the window, but not start of the buffer. */ 843 unsigned indicate_top_line_p : 1; 844 845 /* Non-zero means display a bitmap on X frames indicating that this 846 the last line of the buffer. */ 847 unsigned indicate_eob_p : 1; 848 849 /* Non-zero means display a bitmap on X frames indicating that this 850 the bottom line of the window, but not end of the buffer. */ 851 unsigned indicate_bottom_line_p : 1; 852 853 /* Continuation lines width at the start of the row. */ 854 int continuation_lines_width; 855}; 856 857 858/* Get a pointer to row number ROW in matrix MATRIX. If GLYPH_DEBUG 859 is defined to a non-zero value, the function matrix_row checks that 860 we don't try to access rows that are out of bounds. */ 861 862#if GLYPH_DEBUG 863struct glyph_row *matrix_row P_ ((struct glyph_matrix *, int)); 864#define MATRIX_ROW(MATRIX, ROW) matrix_row ((MATRIX), (ROW)) 865#else 866#define MATRIX_ROW(MATRIX, ROW) ((MATRIX)->rows + (ROW)) 867#endif 868 869/* Return a pointer to the row reserved for the mode line in MATRIX. 870 Row MATRIX->nrows - 1 is always reserved for the mode line. */ 871 872#define MATRIX_MODE_LINE_ROW(MATRIX) \ 873 ((MATRIX)->rows + (MATRIX)->nrows - 1) 874 875/* Return a pointer to the row reserved for the header line in MATRIX. 876 This is always the first row in MATRIX because that's the only 877 way that works in frame-based redisplay. */ 878 879#define MATRIX_HEADER_LINE_ROW(MATRIX) (MATRIX)->rows 880 881/* Return a pointer to first row in MATRIX used for text display. */ 882 883#define MATRIX_FIRST_TEXT_ROW(MATRIX) \ 884 ((MATRIX)->rows->mode_line_p ? (MATRIX)->rows + 1 : (MATRIX)->rows) 885 886/* Return a pointer to the first glyph in the text area of a row. 887 MATRIX is the glyph matrix accessed, and ROW is the row index in 888 MATRIX. */ 889 890#define MATRIX_ROW_GLYPH_START(MATRIX, ROW) \ 891 (MATRIX_ROW ((MATRIX), (ROW))->glyphs[TEXT_AREA]) 892 893/* Return the number of used glyphs in the text area of a row. */ 894 895#define MATRIX_ROW_USED(MATRIX, ROW) \ 896 (MATRIX_ROW ((MATRIX), (ROW))->used[TEXT_AREA]) 897 898/* Return the character/ byte position at which the display of ROW 899 starts. */ 900 901#define MATRIX_ROW_START_CHARPOS(ROW) ((ROW)->start.pos.charpos) 902#define MATRIX_ROW_START_BYTEPOS(ROW) ((ROW)->start.pos.bytepos) 903 904/* Return the character/ byte position at which ROW ends. */ 905 906#define MATRIX_ROW_END_CHARPOS(ROW) ((ROW)->end.pos.charpos) 907#define MATRIX_ROW_END_BYTEPOS(ROW) ((ROW)->end.pos.bytepos) 908 909/* Return the vertical position of ROW in MATRIX. */ 910 911#define MATRIX_ROW_VPOS(ROW, MATRIX) ((ROW) - (MATRIX)->rows) 912 913/* Return the last glyph row + 1 in MATRIX on window W reserved for 914 text. If W has a mode line, the last row in the matrix is reserved 915 for it. */ 916 917#define MATRIX_BOTTOM_TEXT_ROW(MATRIX, W) \ 918 ((MATRIX)->rows \ 919 + (MATRIX)->nrows \ 920 - (WINDOW_WANTS_MODELINE_P ((W)) ? 1 : 0)) 921 922/* Non-zero if the face of the last glyph in ROW's text area has 923 to be drawn to the end of the text area. */ 924 925#define MATRIX_ROW_EXTENDS_FACE_P(ROW) ((ROW)->fill_line_p) 926 927/* Set and query the enabled_p flag of glyph row ROW in MATRIX. */ 928 929#define SET_MATRIX_ROW_ENABLED_P(MATRIX, ROW, VALUE) \ 930 (MATRIX_ROW ((MATRIX), (ROW))->enabled_p = (VALUE) != 0) 931 932#define MATRIX_ROW_ENABLED_P(MATRIX, ROW) \ 933 (MATRIX_ROW ((MATRIX), (ROW))->enabled_p) 934 935/* Non-zero if ROW displays text. Value is non-zero if the row is 936 blank but displays a line end. */ 937 938#define MATRIX_ROW_DISPLAYS_TEXT_P(ROW) ((ROW)->displays_text_p) 939 940 941/* Helper macros */ 942 943#define MR_PARTIALLY_VISIBLE(ROW) \ 944 ((ROW)->height != (ROW)->visible_height) 945 946#define MR_PARTIALLY_VISIBLE_AT_TOP(W, ROW) \ 947 ((ROW)->y < WINDOW_HEADER_LINE_HEIGHT ((W))) 948 949#define MR_PARTIALLY_VISIBLE_AT_BOTTOM(W, ROW) \ 950 (((ROW)->y + (ROW)->height - (ROW)->extra_line_spacing) \ 951 > WINDOW_BOX_HEIGHT_NO_MODE_LINE ((W))) 952 953/* Non-zero if ROW is not completely visible in window W. */ 954 955#define MATRIX_ROW_PARTIALLY_VISIBLE_P(W, ROW) \ 956 (MR_PARTIALLY_VISIBLE ((ROW)) \ 957 && (MR_PARTIALLY_VISIBLE_AT_TOP ((W), (ROW)) \ 958 || MR_PARTIALLY_VISIBLE_AT_BOTTOM ((W), (ROW)))) 959 960 961 962/* Non-zero if ROW is partially visible at the top of window W. */ 963 964#define MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P(W, ROW) \ 965 (MR_PARTIALLY_VISIBLE ((ROW)) \ 966 && MR_PARTIALLY_VISIBLE_AT_TOP ((W), (ROW))) 967 968/* Non-zero if ROW is partially visible at the bottom of window W. */ 969 970#define MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P(W, ROW) \ 971 (MR_PARTIALLY_VISIBLE ((ROW)) \ 972 && MR_PARTIALLY_VISIBLE_AT_BOTTOM ((W), (ROW))) 973 974/* Return the bottom Y + 1 of ROW. */ 975 976#define MATRIX_ROW_BOTTOM_Y(ROW) ((ROW)->y + (ROW)->height) 977 978/* Is ROW the last visible one in the display described by the 979 iterator structure pointed to by IT?. */ 980 981#define MATRIX_ROW_LAST_VISIBLE_P(ROW, IT) \ 982 (MATRIX_ROW_BOTTOM_Y ((ROW)) >= (IT)->last_visible_y) 983 984/* Non-zero if ROW displays a continuation line. */ 985 986#define MATRIX_ROW_CONTINUATION_LINE_P(ROW) \ 987 ((ROW)->continuation_lines_width > 0) 988 989/* Non-zero if ROW ends in the middle of a character. This is the 990 case for continued lines showing only part of a display table entry 991 or a control char, or an overlay string. */ 992 993#define MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P(ROW) \ 994 ((ROW)->end.dpvec_index > 0 \ 995 || (ROW)->end.overlay_string_index >= 0 \ 996 || (ROW)->ends_in_middle_of_char_p) 997 998/* Non-zero if ROW ends in the middle of an overlay string. */ 999 1000#define MATRIX_ROW_ENDS_IN_OVERLAY_STRING_P(ROW) \ 1001 ((ROW)->end.overlay_string_index >= 0) 1002 1003/* Non-zero if ROW starts in the middle of a character. See above. */ 1004 1005#define MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P(ROW) \ 1006 ((ROW)->start.dpvec_index > 0 \ 1007 || (ROW)->starts_in_middle_of_char_p \ 1008 || ((ROW)->start.overlay_string_index >= 0 \ 1009 && (ROW)->start.string_pos.charpos > 0)) 1010 1011/* Non-zero means ROW overlaps its predecessor. */ 1012 1013#define MATRIX_ROW_OVERLAPS_PRED_P(ROW) \ 1014 ((ROW)->phys_ascent > (ROW)->ascent) 1015 1016/* Non-zero means ROW overlaps its successor. */ 1017 1018#define MATRIX_ROW_OVERLAPS_SUCC_P(ROW) \ 1019 ((ROW)->phys_height - (ROW)->phys_ascent \ 1020 > (ROW)->height - (ROW)->ascent) 1021 1022/* Non-zero means that fonts have been loaded since the last glyph 1023 matrix adjustments. The function redisplay_internal adjusts glyph 1024 matrices when this flag is non-zero. */ 1025 1026extern int fonts_changed_p; 1027 1028/* A glyph for a space. */ 1029 1030extern struct glyph space_glyph; 1031 1032/* Frame being updated by update_window/update_frame. */ 1033 1034extern struct frame *updating_frame; 1035 1036/* Window being updated by update_window. This is non-null as long as 1037 update_window has not finished, and null otherwise. It's role is 1038 analogous to updating_frame. */ 1039 1040extern struct window *updated_window; 1041 1042/* Glyph row and area updated by update_window_line. */ 1043 1044extern struct glyph_row *updated_row; 1045extern int updated_area; 1046 1047/* Non-zero means reading single-character input with prompt so put 1048 cursor on mini-buffer after the prompt. Positive means at end of 1049 text in echo area; negative means at beginning of line. */ 1050 1051extern int cursor_in_echo_area; 1052 1053/* Non-zero means last display completed. Zero means it was 1054 preempted. */ 1055 1056extern int display_completed; 1057 1058/* Non-zero means redisplay has been performed directly (see also 1059 direct_output_for_insert and direct_output_forward_char), so that 1060 no further updating has to be performed. The function 1061 redisplay_internal checks this flag, and does nothing but reset it 1062 to zero if it is non-zero. */ 1063 1064extern int redisplay_performed_directly_p; 1065 1066/* A temporary storage area, including a row of glyphs. Initialized 1067 in xdisp.c. Used for various purposes, as an example see 1068 direct_output_for_insert. */ 1069 1070extern struct glyph_row scratch_glyph_row; 1071 1072 1073 1074/************************************************************************ 1075 Glyph Strings 1076 ************************************************************************/ 1077 1078/* Enumeration for overriding/changing the face to use for drawing 1079 glyphs in draw_glyphs. */ 1080 1081enum draw_glyphs_face 1082{ 1083 DRAW_NORMAL_TEXT, 1084 DRAW_INVERSE_VIDEO, 1085 DRAW_CURSOR, 1086 DRAW_MOUSE_FACE, 1087 DRAW_IMAGE_RAISED, 1088 DRAW_IMAGE_SUNKEN 1089}; 1090 1091#ifdef HAVE_WINDOW_SYSTEM 1092 1093/* A sequence of glyphs to be drawn in the same face. */ 1094 1095struct glyph_string 1096{ 1097 /* X-origin of the string. */ 1098 int x; 1099 1100 /* Y-origin and y-position of the base line of this string. */ 1101 int y, ybase; 1102 1103 /* The width of the string, not including a face extension. */ 1104 int width; 1105 1106 /* The width of the string, including a face extension. */ 1107 int background_width; 1108 1109 /* The height of this string. This is the height of the line this 1110 string is drawn in, and can be different from the height of the 1111 font the string is drawn in. */ 1112 int height; 1113 1114 /* Number of pixels this string overwrites in front of its x-origin. 1115 This number is zero if the string has an lbearing >= 0; it is 1116 -lbearing, if the string has an lbearing < 0. */ 1117 int left_overhang; 1118 1119 /* Number of pixels this string overwrites past its right-most 1120 nominal x-position, i.e. x + width. Zero if the string's 1121 rbearing is <= its nominal width, rbearing - width otherwise. */ 1122 int right_overhang; 1123 1124 /* The frame on which the glyph string is drawn. */ 1125 struct frame *f; 1126 1127 /* The window on which the glyph string is drawn. */ 1128 struct window *w; 1129 1130 /* X display and window for convenience. */ 1131 Display *display; 1132 Window window; 1133 1134 /* The glyph row for which this string was built. It determines the 1135 y-origin and height of the string. */ 1136 struct glyph_row *row; 1137 1138 /* The area within row. */ 1139 enum glyph_row_area area; 1140 1141 /* Characters to be drawn, and number of characters. */ 1142 XChar2b *char2b; 1143 int nchars; 1144 1145 /* A face-override for drawing cursors, mouse face and similar. */ 1146 enum draw_glyphs_face hl; 1147 1148 /* Face in which this string is to be drawn. */ 1149 struct face *face; 1150 1151 /* Font in which this string is to be drawn. */ 1152 XFontStruct *font; 1153 1154 /* Font info for this string. */ 1155 struct font_info *font_info; 1156 1157 /* Non-null means this string describes (part of) a composition. 1158 All characters from char2b are drawn composed. */ 1159 struct composition *cmp; 1160 1161 /* Index of this glyph string's first character in the glyph 1162 definition of CMP. If this is zero, this glyph string describes 1163 the first character of a composition. */ 1164 int gidx; 1165 1166 /* 1 means this glyph strings face has to be drawn to the right end 1167 of the window's drawing area. */ 1168 unsigned extends_to_end_of_line_p : 1; 1169 1170 /* 1 means the background of this string has been drawn. */ 1171 unsigned background_filled_p : 1; 1172 1173 /* 1 means glyph string must be drawn with 16-bit functions. */ 1174 unsigned two_byte_p : 1; 1175 1176 /* 1 means that the original font determined for drawing this glyph 1177 string could not be loaded. The member `font' has been set to 1178 the frame's default font in this case. */ 1179 unsigned font_not_found_p : 1; 1180 1181 /* 1 means that the face in which this glyph string is drawn has a 1182 stipple pattern. */ 1183 unsigned stippled_p : 1; 1184 1185#define OVERLAPS_PRED (1 << 0) 1186#define OVERLAPS_SUCC (1 << 1) 1187#define OVERLAPS_BOTH (OVERLAPS_PRED | OVERLAPS_SUCC) 1188#define OVERLAPS_ERASED_CURSOR (1 << 2) 1189 /* Non-zero means only the foreground of this glyph string must be 1190 drawn, and we should use the physical height of the line this 1191 glyph string appears in as clip rect. If the value is 1192 OVERLAPS_ERASED_CURSOR, the clip rect is restricted to the rect 1193 of the erased cursor. OVERLAPS_PRED and OVERLAPS_SUCC mean we 1194 draw overlaps with the preceding and the succeeding rows, 1195 respectively. */ 1196 unsigned for_overlaps : 3; 1197 1198 /* The GC to use for drawing this glyph string. */ 1199#if defined(HAVE_X_WINDOWS) || defined(MAC_OS) 1200 GC gc; 1201#endif 1202#if defined(HAVE_NTGUI) 1203 XGCValues *gc; 1204 HDC hdc; 1205#endif 1206 1207 /* A pointer to the first glyph in the string. This glyph 1208 corresponds to char2b[0]. Needed to draw rectangles if 1209 font_not_found_p is 1. */ 1210 struct glyph *first_glyph; 1211 1212 /* Image, if any. */ 1213 struct image *img; 1214 1215 /* Slice */ 1216 struct glyph_slice slice; 1217 1218 /* Non-null means the horizontal clipping region starts from the 1219 left edge of *clip_head, and ends with the right edge of 1220 *clip_tail, not including their overhangs. */ 1221 struct glyph_string *clip_head, *clip_tail; 1222 1223 struct glyph_string *next, *prev; 1224}; 1225 1226#endif /* HAVE_WINDOW_SYSTEM */ 1227 1228 1229/************************************************************************ 1230 Display Dimensions 1231 ************************************************************************/ 1232 1233/* Return the height of the mode line in glyph matrix MATRIX, or zero 1234 if not known. This macro is called under circumstances where 1235 MATRIX might not have been allocated yet. */ 1236 1237#define MATRIX_MODE_LINE_HEIGHT(MATRIX) \ 1238 ((MATRIX) && (MATRIX)->rows \ 1239 ? MATRIX_MODE_LINE_ROW (MATRIX)->height \ 1240 : 0) 1241 1242/* Return the height of the header line in glyph matrix MATRIX, or zero 1243 if not known. This macro is called under circumstances where 1244 MATRIX might not have been allocated yet. */ 1245 1246#define MATRIX_HEADER_LINE_HEIGHT(MATRIX) \ 1247 ((MATRIX) && (MATRIX)->rows \ 1248 ? MATRIX_HEADER_LINE_ROW (MATRIX)->height \ 1249 : 0) 1250 1251/* Return the desired face id for the mode line of a window, depending 1252 on whether the window is selected or not, or if the window is the 1253 scrolling window for the currently active minibuffer window. 1254 1255 Due to the way display_mode_lines manipulates with the contents of 1256 selected_window, this macro needs three arguments: SELW which is 1257 compared against the current value of selected_window, MBW which is 1258 compared against minibuf_window (if SELW doesn't match), and SCRW 1259 which is compared against minibuf_selected_window (if MBW matches). */ 1260 1261#define CURRENT_MODE_LINE_FACE_ID_3(SELW, MBW, SCRW) \ 1262 ((!mode_line_in_non_selected_windows \ 1263 || (SELW) == XWINDOW (selected_window) \ 1264 || (minibuf_level > 0 \ 1265 && !NILP (minibuf_selected_window) \ 1266 && (MBW) == XWINDOW (minibuf_window) \ 1267 && (SCRW) == XWINDOW (minibuf_selected_window))) \ 1268 ? MODE_LINE_FACE_ID \ 1269 : MODE_LINE_INACTIVE_FACE_ID) 1270 1271 1272/* Return the desired face id for the mode line of window W. */ 1273 1274#define CURRENT_MODE_LINE_FACE_ID(W) \ 1275 (CURRENT_MODE_LINE_FACE_ID_3((W), XWINDOW (selected_window), (W))) 1276 1277/* Return the current height of the mode line of window W. If not 1278 known from current_mode_line_height, look at W's current glyph 1279 matrix, or return a default based on the height of the font of the 1280 face `mode-line'. */ 1281 1282#define CURRENT_MODE_LINE_HEIGHT(W) \ 1283 (current_mode_line_height >= 0 \ 1284 ? current_mode_line_height \ 1285 : (MATRIX_MODE_LINE_HEIGHT ((W)->current_matrix) \ 1286 ? MATRIX_MODE_LINE_HEIGHT ((W)->current_matrix) \ 1287 : estimate_mode_line_height (XFRAME ((W)->frame), \ 1288 CURRENT_MODE_LINE_FACE_ID (W)))) 1289 1290/* Return the current height of the header line of window W. If not 1291 known from current_header_line_height, look at W's current glyph 1292 matrix, or return an estimation based on the height of the font of 1293 the face `header-line'. */ 1294 1295#define CURRENT_HEADER_LINE_HEIGHT(W) \ 1296 (current_header_line_height >= 0 \ 1297 ? current_header_line_height \ 1298 : (MATRIX_HEADER_LINE_HEIGHT ((W)->current_matrix) \ 1299 ? MATRIX_HEADER_LINE_HEIGHT ((W)->current_matrix) \ 1300 : estimate_mode_line_height (XFRAME ((W)->frame), \ 1301 HEADER_LINE_FACE_ID))) 1302 1303/* Return the height of the desired mode line of window W. */ 1304 1305#define DESIRED_MODE_LINE_HEIGHT(W) \ 1306 MATRIX_MODE_LINE_HEIGHT ((W)->desired_matrix) 1307 1308/* Return the height of the desired header line of window W. */ 1309 1310#define DESIRED_HEADER_LINE_HEIGHT(W) \ 1311 MATRIX_HEADER_LINE_HEIGHT ((W)->desired_matrix) 1312 1313/* Value is non-zero if window W wants a mode line. */ 1314 1315#define WINDOW_WANTS_MODELINE_P(W) \ 1316 (!MINI_WINDOW_P ((W)) \ 1317 && !(W)->pseudo_window_p \ 1318 && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME ((W)))) \ 1319 && BUFFERP ((W)->buffer) \ 1320 && !NILP (XBUFFER ((W)->buffer)->mode_line_format) \ 1321 && WINDOW_TOTAL_LINES (W) > 1) 1322 1323/* Value is non-zero if window W wants a header line. */ 1324 1325#define WINDOW_WANTS_HEADER_LINE_P(W) \ 1326 (!MINI_WINDOW_P ((W)) \ 1327 && !(W)->pseudo_window_p \ 1328 && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME ((W)))) \ 1329 && BUFFERP ((W)->buffer) \ 1330 && !NILP (XBUFFER ((W)->buffer)->header_line_format) \ 1331 && WINDOW_TOTAL_LINES (W) > 1 + !NILP (XBUFFER ((W)->buffer)->mode_line_format)) 1332 1333 1334/* Return proper value to be used as baseline offset of font that has 1335 ASCENT and DESCENT to draw characters by the font at the vertical 1336 center of the line of frame F. 1337 1338 Here, our task is to find the value of BOFF in the following figure; 1339 1340 -------------------------+-----------+- 1341 -+-+---------+-+ | | 1342 | | | | | | 1343 | | | | F_ASCENT F_HEIGHT 1344 | | | ASCENT | | 1345 HEIGHT | | | | | 1346 | | |-|-+------+-----------|------- baseline 1347 | | | | BOFF | | 1348 | |---------|-+-+ | | 1349 | | | DESCENT | | 1350 -+-+---------+-+ F_DESCENT | 1351 -------------------------+-----------+- 1352 1353 -BOFF + DESCENT + (F_HEIGHT - HEIGHT) / 2 = F_DESCENT 1354 BOFF = DESCENT + (F_HEIGHT - HEIGHT) / 2 - F_DESCENT 1355 DESCENT = FONT->descent 1356 HEIGHT = FONT_HEIGHT (FONT) 1357 F_DESCENT = (FRAME_FONT (F)->descent 1358 - F->output_data.x->baseline_offset) 1359 F_HEIGHT = FRAME_LINE_HEIGHT (F) 1360*/ 1361 1362#define VCENTER_BASELINE_OFFSET(FONT, F) \ 1363 (FONT_DESCENT (FONT) \ 1364 + (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT)) \ 1365 + (FRAME_LINE_HEIGHT ((F)) > FONT_HEIGHT ((FONT)))) / 2 \ 1366 - (FONT_DESCENT (FRAME_FONT (F)) - FRAME_BASELINE_OFFSET (F))) 1367 1368 1369/*********************************************************************** 1370 Faces 1371 ***********************************************************************/ 1372 1373/* Indices of face attributes in Lisp face vectors. Slot zero is the 1374 symbol `face'. */ 1375 1376enum lface_attribute_index 1377{ 1378 LFACE_FAMILY_INDEX = 1, 1379 LFACE_SWIDTH_INDEX, 1380 LFACE_HEIGHT_INDEX, 1381 LFACE_WEIGHT_INDEX, 1382 LFACE_SLANT_INDEX, 1383 LFACE_UNDERLINE_INDEX, 1384 LFACE_INVERSE_INDEX, 1385 LFACE_FOREGROUND_INDEX, 1386 LFACE_BACKGROUND_INDEX, 1387 LFACE_STIPPLE_INDEX, 1388 LFACE_OVERLINE_INDEX, 1389 LFACE_STRIKE_THROUGH_INDEX, 1390 LFACE_BOX_INDEX, 1391 LFACE_FONT_INDEX, 1392 LFACE_INHERIT_INDEX, 1393 LFACE_AVGWIDTH_INDEX, 1394 LFACE_VECTOR_SIZE 1395}; 1396 1397 1398/* Box types of faces. */ 1399 1400enum face_box_type 1401{ 1402 /* No box around text. */ 1403 FACE_NO_BOX, 1404 1405 /* Simple box of specified width and color. Default width is 1, and 1406 default color is the foreground color of the face. */ 1407 FACE_SIMPLE_BOX, 1408 1409 /* Boxes with 3D shadows. Color equals the background color of the 1410 face. Width is specified. */ 1411 FACE_RAISED_BOX, 1412 FACE_SUNKEN_BOX 1413}; 1414 1415 1416/* Structure describing a realized face. 1417 1418 For each Lisp face, 0..N realized faces can exist for different 1419 frames and different charsets. Realized faces are built from Lisp 1420 faces and text properties/overlays by merging faces and adding 1421 unspecified attributes from the `default' face. */ 1422 1423struct face 1424{ 1425 /* The id of this face. The id equals the index of this face in the 1426 vector faces_by_id of its face cache. */ 1427 int id; 1428 1429#ifdef HAVE_WINDOW_SYSTEM 1430 1431 /* If non-zero, this is a GC that we can use without modification for 1432 drawing the characters in this face. */ 1433 GC gc; 1434 1435 /* Font used for this face, or null if the font could not be loaded 1436 for some reason. This points to a `font' slot of a struct 1437 font_info, and we should not call XFreeFont on it because the 1438 font may still be used somewhere else. */ 1439 XFontStruct *font; 1440 1441 /* Background stipple or bitmap used for this face. This is 1442 an id as returned from load_pixmap. */ 1443 int stipple; 1444 1445#else /* not HAVE_WINDOW_SYSTEM */ 1446 1447 /* Dummy. */ 1448 int stipple; 1449 1450#endif /* not HAVE_WINDOW_SYSTEM */ 1451 1452 /* Pixel value of foreground color for X frames. Color index 1453 for tty frames. */ 1454 unsigned long foreground; 1455 1456 /* Pixel value or color index of background color. */ 1457 unsigned long background; 1458 1459 /* Pixel value or color index of underline color. */ 1460 unsigned long underline_color; 1461 1462 /* Pixel value or color index of overlined, strike-through, or box 1463 color. */ 1464 unsigned long overline_color; 1465 unsigned long strike_through_color; 1466 unsigned long box_color; 1467 1468 /* The font's name. This points to a `name' of a font_info, and it 1469 must not be freed. */ 1470 char *font_name; 1471 1472 /* Font info ID for this face's font. An ID is stored here because 1473 pointers to font_info structures may change. The reason is that 1474 they are pointers into a font table vector that is itself 1475 reallocated. */ 1476 int font_info_id; 1477 1478 /* Fontset ID if this face uses a fontset, or -1. This is only >= 0 1479 if the face was realized for a composition sequence. 1480 Otherwise, a specific font is loaded from the set of fonts 1481 specified by the fontset given by the family attribute of the face. */ 1482 int fontset; 1483 1484 /* Pixmap width and height. */ 1485 unsigned int pixmap_w, pixmap_h; 1486 1487 /* Non-zero means characters in this face have a box that thickness 1488 around them. If it is negative, the absolute value indicates the 1489 thickness, and the horizontal lines of box (top and bottom) are 1490 drawn inside of characters glyph area. The vertical lines of box 1491 (left and right) are drawn as the same way as the case that this 1492 value is positive. */ 1493 int box_line_width; 1494 1495 /* Type of box drawn. A value of FACE_NO_BOX means no box is drawn 1496 around text in this face. A value of FACE_SIMPLE_BOX means a box 1497 of width box_line_width is drawn in color box_color. A value of 1498 FACE_RAISED_BOX or FACE_SUNKEN_BOX means a 3D box is drawn with 1499 shadow colors derived from the background color of the face. */ 1500 enum face_box_type box; 1501 1502 /* If `box' above specifies a 3D type, 1 means use box_color for 1503 drawing shadows. */ 1504 unsigned use_box_color_for_shadows_p : 1; 1505 1506 /* The Lisp face attributes this face realizes. All attributes 1507 in this vector are non-nil. */ 1508 Lisp_Object lface[LFACE_VECTOR_SIZE]; 1509 1510 /* The hash value of this face. */ 1511 unsigned hash; 1512 1513 /* The charset for which this face was realized if it was realized 1514 for use in multibyte text. If fontset >= 0, this is the charset 1515 of the first character of the composition sequence. A value of 1516 charset < 0 means the face was realized for use in unibyte text 1517 where the idea of Emacs charsets isn't applicable. */ 1518 int charset; 1519 1520 /* Non-zero if text in this face should be underlined, overlined, 1521 strike-through or have a box drawn around it. */ 1522 unsigned underline_p : 1; 1523 unsigned overline_p : 1; 1524 unsigned strike_through_p : 1; 1525 1526 /* 1 means that the colors specified for this face could not be 1527 loaded, and were replaced by default colors, so they shouldn't be 1528 freed. */ 1529 unsigned foreground_defaulted_p : 1; 1530 unsigned background_defaulted_p : 1; 1531 1532 /* 1 means that either no color is specified for underlining or that 1533 the specified color couldn't be loaded. Use the foreground 1534 color when drawing in that case. */ 1535 unsigned underline_defaulted_p : 1; 1536 1537 /* 1 means that either no color is specified for the corresponding 1538 attribute or that the specified color couldn't be loaded. 1539 Use the foreground color when drawing in that case. */ 1540 unsigned overline_color_defaulted_p : 1; 1541 unsigned strike_through_color_defaulted_p : 1; 1542 unsigned box_color_defaulted_p : 1; 1543 1544 /* TTY appearances. Blinking is not yet implemented. Colors are 1545 found in `lface' with empty color string meaning the default 1546 color of the TTY. */ 1547 unsigned tty_bold_p : 1; 1548 unsigned tty_dim_p : 1; 1549 unsigned tty_underline_p : 1; 1550 unsigned tty_alt_charset_p : 1; 1551 unsigned tty_reverse_p : 1; 1552 unsigned tty_blinking_p : 1; 1553 1554 /* 1 means that colors of this face may not be freed because they 1555 have been copied bitwise from a base face (see 1556 realize_x_face). */ 1557 unsigned colors_copied_bitwise_p : 1; 1558 1559 /* If non-zero, use overstrike (to simulate bold-face). */ 1560 unsigned overstrike : 1; 1561 1562 /* Next and previous face in hash collision list of face cache. */ 1563 struct face *next, *prev; 1564 1565 /* If this face is for ASCII characters, this points this face 1566 itself. Otherwise, this points a face for ASCII characters. */ 1567 struct face *ascii_face; 1568}; 1569 1570 1571/* Color index indicating that face uses a terminal's default color. */ 1572 1573#define FACE_TTY_DEFAULT_COLOR ((unsigned long) -1) 1574 1575/* Color index indicating that face uses an unknown foreground color. */ 1576 1577#define FACE_TTY_DEFAULT_FG_COLOR ((unsigned long) -2) 1578 1579/* Color index indicating that face uses an unknown background color. */ 1580 1581#define FACE_TTY_DEFAULT_BG_COLOR ((unsigned long) -3) 1582 1583/* Non-zero if FACE was realized for unibyte use. */ 1584 1585#define FACE_UNIBYTE_P(FACE) ((FACE)->charset < 0) 1586 1587 1588/* IDs of important faces known by the C face code. These are the IDs 1589 of the faces for CHARSET_ASCII. */ 1590 1591enum face_id 1592{ 1593 DEFAULT_FACE_ID, 1594 MODE_LINE_FACE_ID, 1595 MODE_LINE_INACTIVE_FACE_ID, 1596 TOOL_BAR_FACE_ID, 1597 FRINGE_FACE_ID, 1598 HEADER_LINE_FACE_ID, 1599 SCROLL_BAR_FACE_ID, 1600 BORDER_FACE_ID, 1601 CURSOR_FACE_ID, 1602 MOUSE_FACE_ID, 1603 MENU_FACE_ID, 1604 VERTICAL_BORDER_FACE_ID, 1605 BASIC_FACE_ID_SENTINEL 1606}; 1607 1608#define MAX_FACE_ID ((1 << FACE_ID_BITS) - 1) 1609 1610/* A cache of realized faces. Each frame has its own cache because 1611 Emacs allows different frame-local face definitions. */ 1612 1613struct face_cache 1614{ 1615 /* Hash table of cached realized faces. */ 1616 struct face **buckets; 1617 1618 /* Back-pointer to the frame this cache belongs to. */ 1619 struct frame *f; 1620 1621 /* A vector of faces so that faces can be referenced by an ID. */ 1622 struct face **faces_by_id; 1623 1624 /* The allocated size, and number of used slots of faces_by_id. */ 1625 int size, used; 1626 1627 /* Flag indicating that attributes of the `menu' face have been 1628 changed. */ 1629 unsigned menu_face_changed_p : 1; 1630}; 1631 1632 1633/* Prepare face FACE for use on frame F. This must be called before 1634 using X resources of FACE. */ 1635 1636#define PREPARE_FACE_FOR_DISPLAY(F, FACE) \ 1637 if ((FACE)->gc == 0) \ 1638 prepare_face_for_display ((F), (FACE)); \ 1639 else \ 1640 (void) 0 1641 1642/* Return a pointer to the face with ID on frame F, or null if such a 1643 face doesn't exist. */ 1644 1645#define FACE_FROM_ID(F, ID) \ 1646 (((unsigned) (ID) < FRAME_FACE_CACHE (F)->used) \ 1647 ? FRAME_FACE_CACHE (F)->faces_by_id[ID] \ 1648 : NULL) 1649 1650#ifdef HAVE_WINDOW_SYSTEM 1651 1652/* Non-zero if FACE is suitable for displaying character CHAR. */ 1653 1654#define FACE_SUITABLE_FOR_CHAR_P(FACE, CHAR) \ 1655 (SINGLE_BYTE_CHAR_P (CHAR) \ 1656 ? (FACE) == (FACE)->ascii_face \ 1657 : face_suitable_for_char_p ((FACE), (CHAR))) 1658 1659/* Return the id of the realized face on frame F that is like the face 1660 with id ID but is suitable for displaying character CHAR. 1661 This macro is only meaningful for multibyte character CHAR. */ 1662 1663#define FACE_FOR_CHAR(F, FACE, CHAR) \ 1664 (SINGLE_BYTE_CHAR_P (CHAR) \ 1665 ? (FACE)->ascii_face->id \ 1666 : face_for_char ((F), (FACE), (CHAR))) 1667 1668#else /* not HAVE_WINDOW_SYSTEM */ 1669 1670#define FACE_SUITABLE_FOR_CHAR_P(FACE, CHAR) 1 1671#define FACE_FOR_CHAR(F, FACE, CHAR) ((FACE)->id) 1672 1673#endif /* not HAVE_WINDOW_SYSTEM */ 1674 1675/* Non-zero means face attributes have been changed since the last 1676 redisplay. Used in redisplay_internal. */ 1677 1678extern int face_change_count; 1679 1680 1681 1682 1683/*********************************************************************** 1684 Fringes 1685 ***********************************************************************/ 1686 1687/* Structure used to describe where and how to draw a fringe bitmap. 1688 WHICH is the fringe bitmap to draw. WD and H is the (adjusted) 1689 width and height of the bitmap, DH is the height adjustment (if 1690 bitmap is periodic). X and Y are frame coordinates of the area to 1691 display the bitmap, DY is relative offset of the bitmap into that 1692 area. BX, NX, BY, NY specifies the area to clear if the bitmap 1693 does not fill the entire area. FACE is the fringe face. */ 1694 1695struct draw_fringe_bitmap_params 1696{ 1697 int which; /* enum fringe_bitmap_type */ 1698 unsigned short *bits; 1699 int wd, h, dh; 1700 int x, y; 1701 int bx, nx, by, ny; 1702 unsigned cursor_p : 1; 1703 unsigned overlay_p : 1; 1704 struct face *face; 1705}; 1706 1707#define MAX_FRINGE_BITMAPS (1<<FRINGE_ID_BITS) 1708 1709 1710/*********************************************************************** 1711 Display Iterator 1712 ***********************************************************************/ 1713 1714/* Iteration over things to display in current_buffer or in a string. 1715 1716 The iterator handles: 1717 1718 1. Overlay strings (after-string, before-string). 1719 2. Face properties. 1720 3. Invisible text properties. 1721 4. Selective display. 1722 5. Translation of characters via display tables. 1723 6. Translation of control characters to the forms `\003' or `^C'. 1724 7. `glyph' and `space-width' properties. 1725 1726 Iterators are initialized by calling init_iterator or one of the 1727 equivalent functions below. A call to get_next_display_element 1728 loads the iterator structure with information about what next to 1729 display. A call to set_iterator_to_next increments the iterator's 1730 position. 1731 1732 Characters from overlay strings, display table entries or control 1733 character translations are returned one at a time. For example, if 1734 we have a text of `a\x01' where `a' has a display table definition 1735 of `cd' and the control character is displayed with a leading 1736 arrow, then the iterator will return: 1737 1738 Call Return Source Call next 1739 ----------------------------------------------------------------- 1740 next c display table move 1741 next d display table move 1742 next ^ control char move 1743 next A control char move 1744 1745 The same mechanism is also used to return characters for ellipses 1746 displayed at the end of invisible text. 1747 1748 CAVEAT: Under some circumstances, move_.* functions can be called 1749 asynchronously, e.g. when computing a buffer position from an x and 1750 y pixel position. This means that these functions and functions 1751 called from them SHOULD NOT USE xmalloc and alike. See also the 1752 comment at the start of xdisp.c. */ 1753 1754/* Enumeration describing what kind of display element an iterator is 1755 loaded with after a call to get_next_display_element. */ 1756 1757enum display_element_type 1758{ 1759 /* A normal character. */ 1760 IT_CHARACTER, 1761 1762 /* A composition sequence. */ 1763 IT_COMPOSITION, 1764 1765 /* An image. */ 1766 IT_IMAGE, 1767 1768 /* A flexible width and height space. */ 1769 IT_STRETCH, 1770 1771 /* End of buffer or string. */ 1772 IT_EOB, 1773 1774 /* Truncation glyphs. Never returned by get_next_display_element. 1775 Used to get display information about truncation glyphs via 1776 produce_glyphs. */ 1777 IT_TRUNCATION, 1778 1779 /* Continuation glyphs. See the comment for IT_TRUNCATION. */ 1780 IT_CONTINUATION 1781}; 1782 1783 1784/* An enumerator for each text property that has a meaning for display 1785 purposes. */ 1786 1787enum prop_idx 1788{ 1789 FONTIFIED_PROP_IDX, 1790 FACE_PROP_IDX, 1791 INVISIBLE_PROP_IDX, 1792 DISPLAY_PROP_IDX, 1793 COMPOSITION_PROP_IDX, 1794 1795 /* Not a property. Used to indicate changes in overlays. */ 1796 OVERLAY_PROP_IDX, 1797 1798 /* Sentinel. */ 1799 LAST_PROP_IDX 1800}; 1801 1802 1803struct it_slice 1804{ 1805 Lisp_Object x; 1806 Lisp_Object y; 1807 Lisp_Object width; 1808 Lisp_Object height; 1809}; 1810 1811enum it_method { 1812 GET_FROM_BUFFER = 0, 1813 GET_FROM_DISPLAY_VECTOR, 1814 GET_FROM_COMPOSITION, 1815 GET_FROM_STRING, 1816 GET_FROM_C_STRING, 1817 GET_FROM_IMAGE, 1818 GET_FROM_STRETCH, 1819 NUM_IT_METHODS 1820}; 1821 1822#define IT_STACK_SIZE 4 1823 1824struct it 1825{ 1826 /* The window in which we iterate over current_buffer (or a string). */ 1827 Lisp_Object window; 1828 struct window *w; 1829 1830 /* The window's frame. */ 1831 struct frame *f; 1832 1833 /* Method to use to load this structure with the next display element. */ 1834 enum it_method method; 1835 1836 /* The next position at which to check for face changes, invisible 1837 text, overlay strings, end of text etc., which see. */ 1838 int stop_charpos; 1839 1840 /* Maximum string or buffer position + 1. ZV when iterating over 1841 current_buffer. */ 1842 int end_charpos; 1843 1844 /* C string to iterate over. Non-null means get characters from 1845 this string, otherwise characters are read from current_buffer 1846 or it->string. */ 1847 unsigned char *s; 1848 1849 /* Number of characters in the string (s, or it->string) we iterate 1850 over. */ 1851 int string_nchars; 1852 1853 /* Start and end of a visible region; -1 if the region is not 1854 visible in the window. */ 1855 int region_beg_charpos, region_end_charpos; 1856 1857 /* Position at which redisplay end trigger functions should be run. */ 1858 int redisplay_end_trigger_charpos; 1859 1860 /* 1 means multibyte characters are enabled. */ 1861 unsigned multibyte_p : 1; 1862 1863 /* 1 means window has a mode line at its top. */ 1864 unsigned header_line_p : 1; 1865 1866 /* 1 means `string' is the value of a `display' property. 1867 Don't handle some `display' properties in these strings. */ 1868 unsigned string_from_display_prop_p : 1; 1869 1870 /* When METHOD == next_element_from_display_vector, 1871 this is 1 if we're doing an ellipsis. Otherwise meaningless. */ 1872 unsigned ellipsis_p : 1; 1873 1874 /* Display table in effect or null for none. */ 1875 struct Lisp_Char_Table *dp; 1876 1877 /* Current display table vector to return characters from and its 1878 end. dpvec null means we are not returning characters from a 1879 display table entry; current.dpvec_index gives the current index 1880 into dpvec. This same mechanism is also used to return 1881 characters from translated control characters, i.e. `\003' or 1882 `^C'. */ 1883 Lisp_Object *dpvec, *dpend; 1884 1885 /* Length in bytes of the char that filled dpvec. A value of zero 1886 means that no such character is involved. */ 1887 int dpvec_char_len; 1888 1889 /* Face id to use for all characters in display vector. -1 if unused. */ 1890 int dpvec_face_id; 1891 1892 /* Face id of the iterator saved in case a glyph from dpvec contains 1893 a face. The face is restored when all glyphs from dpvec have 1894 been delivered. */ 1895 int saved_face_id; 1896 1897 /* Vector of glyphs for control character translation. The pointer 1898 dpvec is set to ctl_chars when a control character is translated. 1899 This vector is also used for incomplete multibyte character 1900 translation (e.g \222\244). Such a character is at most 4 bytes, 1901 thus we need at most 16 bytes here. */ 1902 Lisp_Object ctl_chars[16]; 1903 1904 /* Initial buffer or string position of the iterator, before skipping 1905 over display properties and invisible text. */ 1906 struct display_pos start; 1907 1908 /* Current buffer or string position of the iterator, including 1909 position in overlay strings etc. */ 1910 struct display_pos current; 1911 1912 /* Vector of overlays to process. Overlay strings are processed 1913 OVERLAY_STRING_CHUNK_SIZE at a time. */ 1914#define OVERLAY_STRING_CHUNK_SIZE 16 1915 Lisp_Object overlay_strings[OVERLAY_STRING_CHUNK_SIZE]; 1916 1917 /* Total number of overlay strings to process. This can be > 1918 OVERLAY_STRING_CHUNK_SIZE. */ 1919 int n_overlay_strings; 1920 1921 /* If non-nil, a Lisp string being processed. If 1922 current.overlay_string_index >= 0, this is an overlay string from 1923 pos. */ 1924 Lisp_Object string; 1925 1926 /* Stack of saved values. New entries are pushed when we begin to 1927 process an overlay string or a string from a `glyph' property. 1928 Entries are popped when we return to deliver display elements 1929 from what we previously had. */ 1930 struct iterator_stack_entry 1931 { 1932 Lisp_Object string; 1933 int string_nchars; 1934 int end_charpos; 1935 int stop_charpos; 1936 int face_id; 1937 1938 /* Save values specific to a given method. */ 1939 union { 1940 /* method == GET_FROM_IMAGE */ 1941 struct { 1942 Lisp_Object object; 1943 struct it_slice slice; 1944 int image_id; 1945 } image; 1946 /* method == GET_FROM_COMPOSITION */ 1947 struct { 1948 Lisp_Object object; 1949 int c, len; 1950 int cmp_id, cmp_len; 1951 } comp; 1952 /* method == GET_FROM_STRETCH */ 1953 struct { 1954 Lisp_Object object; 1955 } stretch; 1956 } u; 1957 1958 /* current text and display positions. */ 1959 struct text_pos position; 1960 struct display_pos current; 1961 enum glyph_row_area area; 1962 enum it_method method; 1963 unsigned multibyte_p : 1; 1964 unsigned string_from_display_prop_p : 1; 1965 unsigned display_ellipsis_p : 1; 1966 1967 /* properties from display property that are reset by another display property. */ 1968 Lisp_Object space_width; 1969 Lisp_Object font_height; 1970 short voffset; 1971 } 1972 stack[IT_STACK_SIZE]; 1973 1974 /* Stack pointer. */ 1975 int sp; 1976 1977 /* Setting of buffer-local variable selective-display-ellipsis. */ 1978 unsigned selective_display_ellipsis_p : 1; 1979 1980 /* 1 means control characters are translated into the form `^C' 1981 where the `^' can be replaced by a display table entry. */ 1982 unsigned ctl_arrow_p : 1; 1983 1984 /* -1 means selective display hides everything between a \r and the 1985 next newline; > 0 means hide lines indented more than that value. */ 1986 int selective; 1987 1988 /* An enumeration describing what the next display element is 1989 after a call to get_next_display_element. */ 1990 enum display_element_type what; 1991 1992 /* Face to use. */ 1993 int face_id; 1994 1995 /* Non-zero means that the current face has a box. */ 1996 unsigned face_box_p : 1; 1997 1998 /* Non-null means that the current character is the first in a run 1999 of characters with box face. */ 2000 unsigned start_of_box_run_p : 1; 2001 2002 /* Non-zero means that the current character is the last in a run 2003 of characters with box face. */ 2004 unsigned end_of_box_run_p : 1; 2005 2006 /* 1 means overlay strings at end_charpos have been processed. */ 2007 unsigned overlay_strings_at_end_processed_p : 1; 2008 2009 /* 1 means to ignore overlay strings at current pos, as they have 2010 already been processed. */ 2011 unsigned ignore_overlay_strings_at_pos_p : 1; 2012 2013 /* 1 means the actual glyph is not available in the current 2014 system. */ 2015 unsigned glyph_not_available_p : 1; 2016 2017 /* 1 means the next line in display_line continues a character 2018 consisting of more than one glyph, and some glyphs of this 2019 character have been put on the previous line. */ 2020 unsigned starts_in_middle_of_char_p : 1; 2021 2022 /* If 1, saved_face_id contains the id of the face in front of text 2023 skipped due to selective display. */ 2024 unsigned face_before_selective_p : 1; 2025 2026 /* If 1, adjust current glyph so it does not increase current row 2027 descent/ascent (line-height property). Reset after this glyph. */ 2028 unsigned constrain_row_ascent_descent_p : 1; 2029 2030 /* The ID of the default face to use. One of DEFAULT_FACE_ID, 2031 MODE_LINE_FACE_ID, etc, depending on what we are displaying. */ 2032 int base_face_id; 2033 2034 /* If what == IT_CHARACTER, character and length in bytes. This is 2035 a character from a buffer or string. It may be different from 2036 the character displayed in case that 2037 unibyte_display_via_language_environment is set. 2038 2039 If what == IT_COMPOSITION, the first component of a composition 2040 and length in bytes of the composition. */ 2041 int c, len; 2042 2043 /* If what == IT_COMPOSITION, identification number and length in 2044 chars of a composition. */ 2045 int cmp_id, cmp_len; 2046 2047 /* The character to display, possibly translated to multibyte 2048 if unibyte_display_via_language_environment is set. This 2049 is set after produce_glyphs has been called. */ 2050 int char_to_display; 2051 2052 /* If what == IT_IMAGE, the id of the image to display. */ 2053 int image_id; 2054 2055 /* Values from `slice' property. */ 2056 struct it_slice slice; 2057 2058 /* Value of the `space-width' property, if any; nil if none. */ 2059 Lisp_Object space_width; 2060 2061 /* Computed from the value of the `raise' property. */ 2062 short voffset; 2063 2064 /* Value of the `height' property, if any; nil if none. */ 2065 Lisp_Object font_height; 2066 2067 /* Object and position where the current display element came from. 2068 Object can be a Lisp string in case the current display element 2069 comes from an overlay string, or it is buffer. It may also be nil 2070 during mode-line update. Position is a position in object. */ 2071 Lisp_Object object; 2072 struct text_pos position; 2073 2074 /* 1 means lines are truncated. */ 2075 unsigned truncate_lines_p : 1; 2076 2077 /* Number of columns per \t. */ 2078 short tab_width; 2079 2080 /* Width in pixels of truncation and continuation glyphs. */ 2081 short truncation_pixel_width, continuation_pixel_width; 2082 2083 /* First and last visible x-position in the display area. If window 2084 is hscrolled by n columns, first_visible_x == n * FRAME_COLUMN_WIDTH 2085 (f), and last_visible_x == pixel width of W + first_visible_x. */ 2086 int first_visible_x, last_visible_x; 2087 2088 /* Last visible y-position + 1 in the display area without a mode 2089 line, if the window has one. */ 2090 int last_visible_y; 2091 2092 /* Default amount of additional space in pixels between lines (for 2093 window systems only.) */ 2094 int extra_line_spacing; 2095 2096 /* Max extra line spacing added in this row. */ 2097 int max_extra_line_spacing; 2098 2099 /* Override font height information for this glyph. 2100 Used if override_ascent >= 0. Cleared after this glyph. */ 2101 int override_ascent, override_descent, override_boff; 2102 2103 /* If non-null, glyphs are produced in glyph_row with each call to 2104 produce_glyphs. */ 2105 struct glyph_row *glyph_row; 2106 2107 /* The area of glyph_row to which glyphs are added. */ 2108 enum glyph_row_area area; 2109 2110 /* Number of glyphs needed for the last character requested via 2111 produce_glyphs. This is 1 except for tabs. */ 2112 int nglyphs; 2113 2114 /* Width of the display element in pixels. Result of 2115 produce_glyphs. */ 2116 int pixel_width; 2117 2118 /* Current, maximum logical, and maximum physical line height 2119 information. Result of produce_glyphs. */ 2120 int ascent, descent, max_ascent, max_descent; 2121 int phys_ascent, phys_descent, max_phys_ascent, max_phys_descent; 2122 2123 /* Current x pixel position within the display line. This value 2124 does not include the width of continuation lines in front of the 2125 line. The value of current_x is automatically incremented by 2126 pixel_width with each call to produce_glyphs. */ 2127 int current_x; 2128 2129 /* Accumulated width of continuation lines. If > 0, this means we 2130 are currently in a continuation line. This is initially zero and 2131 incremented/reset by display_line, move_it_to etc. */ 2132 int continuation_lines_width; 2133 2134 /* Current y-position. Automatically incremented by the height of 2135 glyph_row in move_it_to and display_line. */ 2136 int current_y; 2137 2138 /* Vertical matrix position of first text line in window. */ 2139 int first_vpos; 2140 2141 /* Current vertical matrix position, or line number. Automatically 2142 incremented by move_it_to and display_line. */ 2143 int vpos; 2144 2145 /* Horizontal matrix position reached in move_it_in_display_line. 2146 Only set there, not in display_line. */ 2147 int hpos; 2148 2149 /* Left fringe bitmap number (enum fringe_bitmap_type). */ 2150 unsigned left_user_fringe_bitmap : FRINGE_ID_BITS; 2151 2152 /* Right fringe bitmap number (enum fringe_bitmap_type). */ 2153 unsigned right_user_fringe_bitmap : FRINGE_ID_BITS; 2154 2155 /* Face of the left fringe glyph. */ 2156 unsigned left_user_fringe_face_id : FACE_ID_BITS; 2157 2158 /* Face of the right fringe glyph. */ 2159 unsigned right_user_fringe_face_id : FACE_ID_BITS; 2160}; 2161 2162 2163/* Access to positions of iterator IT. */ 2164 2165#define IT_CHARPOS(IT) CHARPOS ((IT).current.pos) 2166#define IT_BYTEPOS(IT) BYTEPOS ((IT).current.pos) 2167#define IT_STRING_CHARPOS(IT) CHARPOS ((IT).current.string_pos) 2168#define IT_STRING_BYTEPOS(IT) BYTEPOS ((IT).current.string_pos) 2169 2170/* Test if IT has reached the end of its buffer or string. This will 2171 only work after get_next_display_element has been called. */ 2172 2173#define ITERATOR_AT_END_P(IT) ((IT)->what == IT_EOB) 2174 2175/* Non-zero means IT is at the end of a line. This is the case if it 2176 is either on a newline or on a carriage return and selective 2177 display hides the rest of the line. */ 2178 2179#define ITERATOR_AT_END_OF_LINE_P(IT) \ 2180 ((IT)->what == IT_CHARACTER \ 2181 && ((IT)->c == '\n' \ 2182 || ((IT)->c == '\r' && (IT)->selective))) 2183 2184/* Call produce_glyphs or produce_glyphs_hook, if set. Shortcut to 2185 avoid the function call overhead. */ 2186 2187#define PRODUCE_GLYPHS(IT) \ 2188 do { \ 2189 extern int inhibit_free_realized_faces; \ 2190 if (rif != NULL) \ 2191 rif->produce_glyphs ((IT)); \ 2192 else \ 2193 produce_glyphs ((IT)); \ 2194 if ((IT)->glyph_row != NULL) \ 2195 inhibit_free_realized_faces = 1; \ 2196 } while (0) 2197 2198/* Bit-flags indicating what operation move_it_to should perform. */ 2199 2200enum move_operation_enum 2201{ 2202 /* Stop if specified x-position is reached. */ 2203 MOVE_TO_X = 0x01, 2204 2205 /* Stop if specified y-position is reached. */ 2206 MOVE_TO_Y = 0x02, 2207 2208 /* Stop if specified vpos is reached. */ 2209 MOVE_TO_VPOS = 0x04, 2210 2211 /* Stop if specified buffer or string position is reached. */ 2212 MOVE_TO_POS = 0x08 2213}; 2214 2215 2216 2217/*********************************************************************** 2218 Window-based redisplay interface 2219 ***********************************************************************/ 2220 2221/* Structure used to describe runs of lines that must be scrolled. */ 2222 2223struct run 2224{ 2225 /* Source and destination y pixel position. */ 2226 int desired_y, current_y; 2227 2228 /* Source and destination vpos in matrix. */ 2229 int desired_vpos, current_vpos; 2230 2231 /* Height in pixels, number of glyph rows. */ 2232 int height, nrows; 2233}; 2234 2235 2236/* Handlers for setting frame parameters. */ 2237 2238typedef void (*frame_parm_handler) P_ ((struct frame *, Lisp_Object, Lisp_Object)); 2239 2240 2241/* Structure holding system-dependent interface functions needed 2242 for window-based redisplay. */ 2243 2244struct redisplay_interface 2245{ 2246 /* Handlers for setting frame parameters. */ 2247 frame_parm_handler *frame_parm_handlers; 2248 2249 /* Produce glyphs/get display metrics for the display element IT is 2250 loaded with. */ 2251 void (*produce_glyphs) P_ ((struct it *it)); 2252 2253 /* Write or insert LEN glyphs from STRING at the nominal output 2254 position. */ 2255 void (*write_glyphs) P_ ((struct glyph *string, int len)); 2256 void (*insert_glyphs) P_ ((struct glyph *start, int len)); 2257 2258 /* Clear from nominal output position to X. X < 0 means clear 2259 to right end of display. */ 2260 void (*clear_end_of_line) P_ ((int x)); 2261 2262 /* Function to call to scroll the display as described by RUN on 2263 window W. */ 2264 void (*scroll_run_hook) P_ ((struct window *w, struct run *run)); 2265 2266 /* Function to call after a line in a display has been completely 2267 updated. Used to draw truncation marks and alike. DESIRED_ROW 2268 is the desired row which has been updated. */ 2269 void (*after_update_window_line_hook) P_ ((struct glyph_row *desired_row)); 2270 2271 /* Function to call before beginning to update window W in 2272 window-based redisplay. */ 2273 void (*update_window_begin_hook) P_ ((struct window *w)); 2274 2275 /* Function to call after window W has been updated in window-based 2276 redisplay. CURSOR_ON_P non-zero means switch cursor on. 2277 MOUSE_FACE_OVERWRITTEN_P non-zero means that some lines in W 2278 that contained glyphs in mouse-face were overwritten, so we 2279 have to update the mouse highlight. */ 2280 void (*update_window_end_hook) P_ ((struct window *w, int cursor_on_p, 2281 int mouse_face_overwritten_p)); 2282 2283 /* Move cursor to row/column position VPOS/HPOS, pixel coordinates 2284 Y/X. HPOS/VPOS are window-relative row and column numbers and X/Y 2285 are window-relative pixel positions. */ 2286 void (*cursor_to) P_ ((int vpos, int hpos, int y, int x)); 2287 2288 /* Flush the display of frame F. For X, this is XFlush. */ 2289 void (*flush_display) P_ ((struct frame *f)); 2290 2291 /* Flush the display of frame F if non-NULL. This is called 2292 during redisplay, and should be NULL on systems which flushes 2293 automatically before reading input. */ 2294 void (*flush_display_optional) P_ ((struct frame *f)); 2295 2296 /* Clear the mouse hightlight in window W, if there is any. */ 2297 void (*clear_window_mouse_face) P_ ((struct window *w)); 2298 2299 /* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on 2300 frame F. */ 2301 void (*get_glyph_overhangs) P_ ((struct glyph *glyph, struct frame *f, 2302 int *left, int *right)); 2303 2304 /* Fix the display of AREA of ROW in window W for overlapping rows. 2305 This function is called from redraw_overlapping_rows after 2306 desired rows have been made current. */ 2307 void (*fix_overlapping_area) P_ ((struct window *w, struct glyph_row *row, 2308 enum glyph_row_area area, int)); 2309 2310#ifdef HAVE_WINDOW_SYSTEM 2311 2312 /* Draw a fringe bitmap in window W of row ROW using parameters P. */ 2313 void (*draw_fringe_bitmap) P_ ((struct window *w, struct glyph_row *row, 2314 struct draw_fringe_bitmap_params *p)); 2315 2316 /* Define and destroy fringe bitmap no. WHICH. */ 2317 void (*define_fringe_bitmap) P_ ((int which, unsigned short *bits, 2318 int h, int wd)); 2319 void (*destroy_fringe_bitmap) P_ ((int which)); 2320 2321/* Get metrics of character CHAR2B in FONT of type FONT_TYPE. 2322 Value is null if CHAR2B is not contained in the font. */ 2323 XCharStruct * (*per_char_metric) P_ ((XFontStruct *font, XChar2b *char2b, 2324 int font_type)); 2325 2326/* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is 2327 the two-byte form of C. Encoding is returned in *CHAR2B. If 2328 TWO_BYTE_P is non-null, return non-zero there if font is two-byte. */ 2329 int (*encode_char) P_ ((int c, XChar2b *char2b, 2330 struct font_info *font_into, int *two_byte_p)); 2331 2332/* Compute left and right overhang of glyph string S. 2333 A NULL pointer if platform does not support this. */ 2334 void (*compute_glyph_string_overhangs) P_ ((struct glyph_string *s)); 2335 2336/* Draw a glyph string S. */ 2337 void (*draw_glyph_string) P_ ((struct glyph_string *s)); 2338 2339/* Define cursor CURSOR on frame F. */ 2340 void (*define_frame_cursor) P_ ((struct frame *f, Cursor cursor)); 2341 2342/* Clear the area at (X,Y,WIDTH,HEIGHT) of frame F. */ 2343 void (*clear_frame_area) P_ ((struct frame *f, int x, int y, 2344 int width, int height)); 2345 2346/* Draw specified cursor CURSOR_TYPE of width CURSOR_WIDTH 2347 at row GLYPH_ROW on window W if ON_P is 1. If ON_P is 2348 0, don't draw cursor. If ACTIVE_P is 1, system caret 2349 should track this cursor (when applicable). */ 2350 void (*draw_window_cursor) P_ ((struct window *w, 2351 struct glyph_row *glyph_row, 2352 int x, int y, 2353 int cursor_type, int cursor_width, 2354 int on_p, int active_p)); 2355 2356/* Draw vertical border for window W from (X,Y0) to (X,Y1). */ 2357 void (*draw_vertical_window_border) P_ ((struct window *w, 2358 int x, int y0, int y1)); 2359 2360/* Shift display of frame F to make room for inserted glyphs. 2361 The area at pixel (X,Y) of width WIDTH and height HEIGHT is 2362 shifted right by SHIFT_BY pixels. */ 2363 void (*shift_glyphs_for_insert) P_ ((struct frame *f, 2364 int x, int y, int width, 2365 int height, int shift_by)); 2366 2367#endif /* HAVE_WINDOW_SYSTEM */ 2368}; 2369 2370/* The current interface for window-based redisplay. */ 2371 2372extern struct redisplay_interface *rif; 2373 2374 2375/*********************************************************************** 2376 Images 2377 ***********************************************************************/ 2378 2379#ifdef HAVE_WINDOW_SYSTEM 2380 2381/* Structure forward declarations. */ 2382 2383struct image; 2384 2385 2386/* Each image format (JPEG, TIFF, ...) supported is described by 2387 a structure of the type below. */ 2388 2389struct image_type 2390{ 2391 /* A symbol uniquely identifying the image type, .e.g `jpeg'. */ 2392 Lisp_Object *type; 2393 2394 /* Check that SPEC is a valid image specification for the given 2395 image type. Value is non-zero if SPEC is valid. */ 2396 int (* valid_p) P_ ((Lisp_Object spec)); 2397 2398 /* Load IMG which is used on frame F from information contained in 2399 IMG->spec. Value is non-zero if successful. */ 2400 int (* load) P_ ((struct frame *f, struct image *img)); 2401 2402 /* Free resources of image IMG which is used on frame F. */ 2403 void (* free) P_ ((struct frame *f, struct image *img)); 2404 2405 /* Next in list of all supported image types. */ 2406 struct image_type *next; 2407}; 2408 2409 2410/* Structure describing an image. Specific image formats like XBM are 2411 converted into this form, so that display only has to deal with 2412 this type of image. */ 2413 2414struct image 2415{ 2416 /* The time in seconds at which the image was last displayed. Set 2417 in prepare_image_for_display. */ 2418 unsigned long timestamp; 2419 2420 /* Pixmaps of the image. */ 2421 Pixmap pixmap, mask; 2422 2423 /* Colors allocated for this image, if any. Allocated via xmalloc. */ 2424 unsigned long *colors; 2425 int ncolors; 2426 2427 /* A single `background color' for this image, for the use of anyone that 2428 cares about such a thing. Only valid if the `background_valid' field 2429 is true. This should generally be accessed by calling the accessor 2430 macro `IMAGE_BACKGROUND', which will heuristically calculate a value 2431 if necessary. */ 2432 unsigned long background; 2433 2434 /* True if this image has a `transparent' background -- that is, is 2435 uses an image mask. The accessor macro for this is 2436 `IMAGE_BACKGROUND_TRANSPARENT'. */ 2437 unsigned background_transparent : 1; 2438 2439 /* True if the `background' and `background_transparent' fields are 2440 valid, respectively. */ 2441 unsigned background_valid : 1, background_transparent_valid : 1; 2442 2443 /* Width and height of the image. */ 2444 int width, height; 2445 2446 /* These values are used for the rectangles displayed for images 2447 that can't be loaded. */ 2448#define DEFAULT_IMAGE_WIDTH 30 2449#define DEFAULT_IMAGE_HEIGHT 30 2450 2451 /* Top/left and bottom/right corner pixel of actual image data. 2452 Used by four_corners_best to consider the real image data, 2453 rather than looking at the optional image margin. */ 2454 int corners[4]; 2455#define TOP_CORNER 0 2456#define LEFT_CORNER 1 2457#define BOT_CORNER 2 2458#define RIGHT_CORNER 3 2459 2460 /* Percent of image height used as ascent. A value of 2461 CENTERED_IMAGE_ASCENT means draw the image centered on the 2462 line. */ 2463 int ascent; 2464#define DEFAULT_IMAGE_ASCENT 50 2465#define CENTERED_IMAGE_ASCENT -1 2466 2467 /* Lisp specification of this image. */ 2468 Lisp_Object spec; 2469 2470 /* Relief to draw around the image. */ 2471 int relief; 2472 2473 /* Optional margins around the image. This includes the relief. */ 2474 int hmargin, vmargin; 2475 2476 /* Reference to the type of the image. */ 2477 struct image_type *type; 2478 2479 /* 1 means that loading the image failed. Don't try again. */ 2480 unsigned load_failed_p; 2481 2482 /* A place for image types to store additional data. The member 2483 data.lisp_val is marked during GC, so it's safe to store Lisp data 2484 there. Image types should free this data when their `free' 2485 function is called. */ 2486 struct 2487 { 2488 int int_val; 2489 void *ptr_val; 2490 Lisp_Object lisp_val; 2491 } data; 2492 2493 /* Hash value of image specification to speed up comparisons. */ 2494 unsigned hash; 2495 2496 /* Image id of this image. */ 2497 int id; 2498 2499 /* Hash collision chain. */ 2500 struct image *next, *prev; 2501}; 2502 2503 2504/* Cache of images. Each frame has a cache. X frames with the same 2505 x_display_info share their caches. */ 2506 2507struct image_cache 2508{ 2509 /* Hash table of images. */ 2510 struct image **buckets; 2511 2512 /* Vector mapping image ids to images. */ 2513 struct image **images; 2514 2515 /* Allocated size of `images'. */ 2516 unsigned size; 2517 2518 /* Number of images in the cache. */ 2519 unsigned used; 2520 2521 /* Reference count (number of frames sharing this cache). */ 2522 int refcount; 2523}; 2524 2525 2526/* Value is a pointer to the image with id ID on frame F, or null if 2527 no image with that id exists. */ 2528 2529#define IMAGE_FROM_ID(F, ID) \ 2530 (((ID) >= 0 && (ID) < (FRAME_X_IMAGE_CACHE (F)->used)) \ 2531 ? FRAME_X_IMAGE_CACHE (F)->images[ID] \ 2532 : NULL) 2533 2534/* Size of bucket vector of image caches. Should be prime. */ 2535 2536#define IMAGE_CACHE_BUCKETS_SIZE 1001 2537 2538#endif /* HAVE_WINDOW_SYSTEM */ 2539 2540 2541 2542/*********************************************************************** 2543 Tool-bars 2544 ***********************************************************************/ 2545 2546/* Enumeration defining where to find tool-bar item information in 2547 tool-bar items vectors stored with frames. Each tool-bar item 2548 occupies TOOL_BAR_ITEM_NSLOTS elements in such a vector. */ 2549 2550enum tool_bar_item_idx 2551{ 2552 /* The key of the tool-bar item. Used to remove items when a binding 2553 for `undefined' is found. */ 2554 TOOL_BAR_ITEM_KEY, 2555 2556 /* Non-nil if item is enabled. */ 2557 TOOL_BAR_ITEM_ENABLED_P, 2558 2559 /* Non-nil if item is selected (pressed). */ 2560 TOOL_BAR_ITEM_SELECTED_P, 2561 2562 /* Caption. */ 2563 TOOL_BAR_ITEM_CAPTION, 2564 2565 /* Image(s) to display. This is either a single image specification 2566 or a vector of specifications. */ 2567 TOOL_BAR_ITEM_IMAGES, 2568 2569 /* The binding. */ 2570 TOOL_BAR_ITEM_BINDING, 2571 2572 /* Button type. One of nil, `:radio' or `:toggle'. */ 2573 TOOL_BAR_ITEM_TYPE, 2574 2575 /* Help string. */ 2576 TOOL_BAR_ITEM_HELP, 2577 2578 /* Sentinel = number of slots in tool_bar_items occupied by one 2579 tool-bar item. */ 2580 TOOL_BAR_ITEM_NSLOTS 2581}; 2582 2583 2584/* An enumeration for the different images that can be specified 2585 for a tool-bar item. */ 2586 2587enum tool_bar_item_image 2588{ 2589 TOOL_BAR_IMAGE_ENABLED_SELECTED, 2590 TOOL_BAR_IMAGE_ENABLED_DESELECTED, 2591 TOOL_BAR_IMAGE_DISABLED_SELECTED, 2592 TOOL_BAR_IMAGE_DISABLED_DESELECTED 2593}; 2594 2595/* Margin around tool-bar buttons in pixels. */ 2596 2597extern Lisp_Object Vtool_bar_button_margin; 2598 2599/* Thickness of relief to draw around tool-bar buttons. */ 2600 2601extern EMACS_INT tool_bar_button_relief; 2602 2603/* Default values of the above variables. */ 2604 2605#define DEFAULT_TOOL_BAR_BUTTON_MARGIN 4 2606#define DEFAULT_TOOL_BAR_BUTTON_RELIEF 1 2607 2608/* The height in pixels of the default tool-bar images. */ 2609 2610#define DEFAULT_TOOL_BAR_IMAGE_HEIGHT 24 2611 2612 2613/*********************************************************************** 2614 Terminal Capabilities 2615 ***********************************************************************/ 2616 2617/* Each of these is a bit representing a terminal `capability' (bold, 2618 inverse, etc). They are or'd together to specify the set of 2619 capabilities being queried for when calling `tty_capable_p' (which 2620 returns true if the terminal supports all of them). */ 2621 2622#define TTY_CAP_INVERSE 0x01 2623#define TTY_CAP_UNDERLINE 0x02 2624#define TTY_CAP_BOLD 0x04 2625#define TTY_CAP_DIM 0x08 2626#define TTY_CAP_BLINK 0x10 2627#define TTY_CAP_ALT_CHARSET 0x20 2628 2629 2630/*********************************************************************** 2631 Function Prototypes 2632 ***********************************************************************/ 2633 2634/* Defined in xdisp.c */ 2635 2636struct glyph_row *row_containing_pos P_ ((struct window *, int, 2637 struct glyph_row *, 2638 struct glyph_row *, int)); 2639int string_buffer_position P_ ((struct window *, Lisp_Object, int)); 2640int line_bottom_y P_ ((struct it *)); 2641int display_prop_intangible_p P_ ((Lisp_Object)); 2642void resize_echo_area_exactly P_ ((void)); 2643int resize_mini_window P_ ((struct window *, int)); 2644int try_window P_ ((Lisp_Object, struct text_pos, int)); 2645void window_box P_ ((struct window *, int, int *, int *, int *, int *)); 2646int window_box_height P_ ((struct window *)); 2647int window_text_bottom_y P_ ((struct window *)); 2648int window_box_width P_ ((struct window *, int)); 2649int window_box_left P_ ((struct window *, int)); 2650int window_box_left_offset P_ ((struct window *, int)); 2651int window_box_right P_ ((struct window *, int)); 2652int window_box_right_offset P_ ((struct window *, int)); 2653void window_box_edges P_ ((struct window *, int, int *, int *, int *, int *)); 2654int estimate_mode_line_height P_ ((struct frame *, enum face_id)); 2655void pixel_to_glyph_coords P_ ((struct frame *, int, int, int *, int *, 2656 NativeRectangle *, int)); 2657int glyph_to_pixel_coords P_ ((struct window *, int, int, int *, int *)); 2658void remember_mouse_glyph P_ ((struct frame *, int, int, NativeRectangle *)); 2659 2660void mark_window_display_accurate P_ ((Lisp_Object, int)); 2661void redisplay_preserve_echo_area P_ ((int)); 2662int set_cursor_from_row P_ ((struct window *, struct glyph_row *, 2663 struct glyph_matrix *, int, int, int, int)); 2664void init_iterator P_ ((struct it *, struct window *, int, 2665 int, struct glyph_row *, enum face_id)); 2666void init_iterator_to_row_start P_ ((struct it *, struct window *, 2667 struct glyph_row *)); 2668int get_next_display_element P_ ((struct it *)); 2669void set_iterator_to_next P_ ((struct it *, int)); 2670void produce_glyphs P_ ((struct it *)); 2671void produce_special_glyphs P_ ((struct it *, enum display_element_type)); 2672void start_display P_ ((struct it *, struct window *, struct text_pos)); 2673void move_it_to P_ ((struct it *, int, int, int, int, int)); 2674void move_it_vertically P_ ((struct it *, int)); 2675void move_it_vertically_backward P_ ((struct it *, int)); 2676void move_it_by_lines P_ ((struct it *, int, int)); 2677void move_it_past_eol P_ ((struct it *)); 2678int in_display_vector_p P_ ((struct it *)); 2679int frame_mode_line_height P_ ((struct frame *)); 2680void highlight_trailing_whitespace P_ ((struct frame *, struct glyph_row *)); 2681extern Lisp_Object Qtool_bar; 2682extern Lisp_Object Vshow_trailing_whitespace; 2683extern int mode_line_in_non_selected_windows; 2684extern int redisplaying_p; 2685extern void add_to_log P_ ((char *, Lisp_Object, Lisp_Object)); 2686extern int help_echo_showing_p; 2687extern int current_mode_line_height, current_header_line_height; 2688extern Lisp_Object help_echo_string, help_echo_window; 2689extern Lisp_Object help_echo_object, previous_help_echo_string; 2690extern int help_echo_pos; 2691extern struct frame *last_mouse_frame; 2692extern int last_tool_bar_item; 2693extern Lisp_Object Vmouse_autoselect_window; 2694extern int unibyte_display_via_language_environment; 2695 2696extern void reseat_at_previous_visible_line_start P_ ((struct it *)); 2697 2698extern int calc_pixel_width_or_height P_ ((double *, struct it *, Lisp_Object, 2699 /* XFontStruct */ void *, int, int *)); 2700 2701#ifdef HAVE_WINDOW_SYSTEM 2702 2703#if GLYPH_DEBUG 2704extern void dump_glyph_string P_ ((struct glyph_string *)); 2705#endif 2706 2707extern void x_get_glyph_overhangs P_ ((struct glyph *, struct frame *, 2708 int *, int *)); 2709extern void x_produce_glyphs P_ ((struct it *)); 2710 2711extern void x_write_glyphs P_ ((struct glyph *, int)); 2712extern void x_insert_glyphs P_ ((struct glyph *, int len)); 2713extern void x_clear_end_of_line P_ ((int)); 2714 2715extern int x_stretch_cursor_p; 2716extern struct cursor_pos output_cursor; 2717 2718extern void x_fix_overlapping_area P_ ((struct window *, struct glyph_row *, 2719 enum glyph_row_area, int)); 2720extern void draw_phys_cursor_glyph P_ ((struct window *, 2721 struct glyph_row *, 2722 enum draw_glyphs_face)); 2723extern void get_phys_cursor_geometry P_ ((struct window *, struct glyph_row *, 2724 struct glyph *, int *, int *, int *)); 2725extern void erase_phys_cursor P_ ((struct window *)); 2726extern void display_and_set_cursor P_ ((struct window *, 2727 int, int, int, int, int)); 2728 2729extern void set_output_cursor P_ ((struct cursor_pos *)); 2730extern void x_cursor_to P_ ((int, int, int, int)); 2731 2732extern void x_update_cursor P_ ((struct frame *, int)); 2733extern void x_clear_cursor P_ ((struct window *)); 2734extern void x_draw_vertical_border P_ ((struct window *w)); 2735 2736extern void frame_to_window_pixel_xy P_ ((struct window *, int *, int *)); 2737extern int get_glyph_string_clip_rects P_ ((struct glyph_string *, 2738 NativeRectangle *, int)); 2739extern void get_glyph_string_clip_rect P_ ((struct glyph_string *, 2740 NativeRectangle *nr)); 2741extern Lisp_Object find_hot_spot P_ ((Lisp_Object, int, int)); 2742extern void note_mouse_highlight P_ ((struct frame *, int, int)); 2743extern void x_clear_window_mouse_face P_ ((struct window *)); 2744extern void cancel_mouse_face P_ ((struct frame *)); 2745 2746extern void handle_tool_bar_click P_ ((struct frame *, 2747 int, int, int, unsigned int)); 2748 2749/* msdos.c defines its own versions of these functions. */ 2750extern int clear_mouse_face P_ ((Display_Info *)); 2751extern void show_mouse_face P_ ((Display_Info *, enum draw_glyphs_face)); 2752extern int cursor_in_mouse_face_p P_ ((struct window *w)); 2753 2754extern void expose_frame P_ ((struct frame *, int, int, int, int)); 2755extern int x_intersect_rectangles P_ ((XRectangle *, XRectangle *, 2756 XRectangle *)); 2757#endif 2758 2759/* Defined in fringe.c */ 2760 2761int lookup_fringe_bitmap (Lisp_Object); 2762void draw_fringe_bitmap P_ ((struct window *, struct glyph_row *, int)); 2763void draw_row_fringe_bitmaps P_ ((struct window *, struct glyph_row *)); 2764int draw_window_fringes P_ ((struct window *, int)); 2765int update_window_fringes P_ ((struct window *, int)); 2766void compute_fringe_widths P_ ((struct frame *, int)); 2767 2768#ifdef WINDOWS_NT 2769void w32_init_fringe P_ ((void)); 2770void w32_reset_fringes P_ ((void)); 2771#endif 2772#ifdef MAC_OS 2773void mac_init_fringe P_ ((void)); 2774#endif 2775 2776/* Defined in image.c */ 2777 2778#ifdef HAVE_WINDOW_SYSTEM 2779 2780extern int x_bitmap_height P_ ((struct frame *, int)); 2781extern int x_bitmap_width P_ ((struct frame *, int)); 2782extern int x_bitmap_pixmap P_ ((struct frame *, int)); 2783extern void x_reference_bitmap P_ ((struct frame *, int)); 2784extern int x_create_bitmap_from_data P_ ((struct frame *, char *, 2785 unsigned int, unsigned int)); 2786extern int x_create_bitmap_from_file P_ ((struct frame *, Lisp_Object)); 2787#if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) 2788extern int x_create_bitmap_from_xpm_data P_ ((struct frame *f, char **bits)); 2789#endif 2790#ifndef x_destroy_bitmap 2791extern void x_destroy_bitmap P_ ((struct frame *, int)); 2792#endif 2793extern void x_destroy_all_bitmaps P_ ((Display_Info *)); 2794extern int x_create_bitmap_mask P_ ((struct frame * , int)); 2795extern Lisp_Object x_find_image_file P_ ((Lisp_Object)); 2796 2797void x_kill_gs_process P_ ((Pixmap, struct frame *)); 2798struct image_cache *make_image_cache P_ ((void)); 2799void free_image_cache P_ ((struct frame *)); 2800void clear_image_cache P_ ((struct frame *, int)); 2801void forall_images_in_image_cache P_ ((struct frame *, 2802 void (*) P_ ((struct image *)))); 2803int valid_image_p P_ ((Lisp_Object)); 2804void prepare_image_for_display P_ ((struct frame *, struct image *)); 2805int lookup_image P_ ((struct frame *, Lisp_Object)); 2806 2807unsigned long image_background P_ ((struct image *, struct frame *, 2808 XImagePtr_or_DC ximg)); 2809int image_background_transparent P_ ((struct image *, struct frame *, 2810 XImagePtr_or_DC mask)); 2811 2812int image_ascent P_ ((struct image *, struct face *, struct glyph_slice *)); 2813 2814#endif 2815 2816/* Defined in sysdep.c */ 2817 2818void get_frame_size P_ ((int *, int *)); 2819void request_sigio P_ ((void)); 2820void unrequest_sigio P_ ((void)); 2821int tabs_safe_p P_ ((void)); 2822void init_baud_rate P_ ((void)); 2823void init_sigio P_ ((int)); 2824 2825/* Defined in xfaces.c */ 2826 2827#ifdef HAVE_X_WINDOWS 2828void x_free_colors P_ ((struct frame *, unsigned long *, int)); 2829#endif 2830 2831void update_face_from_frame_parameter P_ ((struct frame *, Lisp_Object, 2832 Lisp_Object)); 2833Lisp_Object tty_color_name P_ ((struct frame *, int)); 2834void clear_face_cache P_ ((int)); 2835unsigned long load_color P_ ((struct frame *, struct face *, Lisp_Object, 2836 enum lface_attribute_index)); 2837void unload_color P_ ((struct frame *, unsigned long)); 2838int face_font_available_p P_ ((struct frame *, Lisp_Object)); 2839int ascii_face_of_lisp_face P_ ((struct frame *, int)); 2840void prepare_face_for_display P_ ((struct frame *, struct face *)); 2841int xstricmp P_ ((const unsigned char *, const unsigned char *)); 2842int lookup_face P_ ((struct frame *, Lisp_Object *, int, struct face *)); 2843int lookup_named_face P_ ((struct frame *, Lisp_Object, int, int)); 2844int smaller_face P_ ((struct frame *, int, int)); 2845int face_with_height P_ ((struct frame *, int, int)); 2846int lookup_derived_face P_ ((struct frame *, Lisp_Object, int, int, int)); 2847void init_frame_faces P_ ((struct frame *)); 2848void free_frame_faces P_ ((struct frame *)); 2849void recompute_basic_faces P_ ((struct frame *)); 2850int face_at_buffer_position P_ ((struct window *, int, int, int, int *, 2851 int, int)); 2852int face_at_string_position P_ ((struct window *, Lisp_Object, int, int, int, 2853 int, int *, enum face_id, int)); 2854int merge_faces P_ ((struct frame *, Lisp_Object, int, int)); 2855int compute_char_face P_ ((struct frame *, int, Lisp_Object)); 2856void free_all_realized_faces P_ ((Lisp_Object)); 2857extern Lisp_Object Qforeground_color, Qbackground_color; 2858extern Lisp_Object Qframe_set_background_mode; 2859extern char unspecified_fg[], unspecified_bg[]; 2860void free_realized_multibyte_face P_ ((struct frame *, int)); 2861 2862/* Defined in xfns.c */ 2863 2864#ifdef HAVE_X_WINDOWS 2865void gamma_correct P_ ((struct frame *, XColor *)); 2866#endif 2867#ifdef WINDOWSNT 2868void gamma_correct P_ ((struct frame *, COLORREF *)); 2869#endif 2870#ifdef MAC_OS 2871void gamma_correct P_ ((struct frame *, unsigned long *)); 2872#endif 2873 2874#ifdef HAVE_WINDOW_SYSTEM 2875 2876int x_screen_planes P_ ((struct frame *)); 2877void x_implicitly_set_name P_ ((struct frame *, Lisp_Object, Lisp_Object)); 2878 2879extern Lisp_Object tip_frame; 2880extern Window tip_window; 2881EXFUN (Fx_show_tip, 6); 2882EXFUN (Fx_hide_tip, 0); 2883extern void start_hourglass P_ ((void)); 2884extern void cancel_hourglass P_ ((void)); 2885extern int hourglass_started P_ ((void)); 2886extern int display_hourglass_p; 2887 2888/* Returns the background color of IMG, calculating one heuristically if 2889 necessary. If non-zero, XIMG is an existing XImage object to use for 2890 the heuristic. */ 2891 2892#define IMAGE_BACKGROUND(img, f, ximg) \ 2893 ((img)->background_valid \ 2894 ? (img)->background \ 2895 : image_background (img, f, ximg)) 2896 2897/* Returns true if IMG has a `transparent' background, using heuristics 2898 to decide if necessary. If non-zero, MASK is an existing XImage 2899 object to use for the heuristic. */ 2900 2901#define IMAGE_BACKGROUND_TRANSPARENT(img, f, mask) \ 2902 ((img)->background_transparent_valid \ 2903 ? (img)->background_transparent \ 2904 : image_background_transparent (img, f, mask)) 2905 2906#endif /* HAVE_WINDOW_SYSTEM */ 2907 2908 2909/* Defined in xmenu.c */ 2910 2911int popup_activated P_ ((void)); 2912 2913/* Defined in dispnew.c */ 2914 2915extern int inverse_video; 2916extern int required_matrix_width P_ ((struct window *)); 2917extern int required_matrix_height P_ ((struct window *)); 2918extern Lisp_Object buffer_posn_from_coords P_ ((struct window *, 2919 int *, int *, 2920 struct display_pos *, 2921 Lisp_Object *, 2922 int *, int *, int *, int *)); 2923extern Lisp_Object mode_line_string P_ ((struct window *, enum window_part, 2924 int *, int *, int *, 2925 Lisp_Object *, 2926 int *, int *, int *, int *)); 2927extern Lisp_Object marginal_area_string P_ ((struct window *, enum window_part, 2928 int *, int *, int *, 2929 Lisp_Object *, 2930 int *, int *, int *, int *)); 2931extern void redraw_frame P_ ((struct frame *)); 2932extern void redraw_garbaged_frames P_ ((void)); 2933extern void cancel_line P_ ((int, struct frame *)); 2934extern void init_desired_glyphs P_ ((struct frame *)); 2935extern int scroll_frame_lines P_ ((struct frame *, int, int, int, int)); 2936extern int direct_output_for_insert P_ ((int)); 2937extern int direct_output_forward_char P_ ((int)); 2938extern int update_frame P_ ((struct frame *, int, int)); 2939extern int scrolling P_ ((struct frame *)); 2940extern void bitch_at_user P_ ((void)); 2941void adjust_glyphs P_ ((struct frame *)); 2942void free_glyphs P_ ((struct frame *)); 2943void free_window_matrices P_ ((struct window *)); 2944void check_glyph_memory P_ ((void)); 2945void mirrored_line_dance P_ ((struct glyph_matrix *, int, int, int *, char *)); 2946void clear_glyph_matrix P_ ((struct glyph_matrix *)); 2947void clear_current_matrices P_ ((struct frame *f)); 2948void clear_desired_matrices P_ ((struct frame *)); 2949void shift_glyph_matrix P_ ((struct window *, struct glyph_matrix *, 2950 int, int, int)); 2951void rotate_matrix P_ ((struct glyph_matrix *, int, int, int)); 2952void increment_matrix_positions P_ ((struct glyph_matrix *, 2953 int, int, int, int)); 2954void blank_row P_ ((struct window *, struct glyph_row *, int)); 2955void increment_row_positions P_ ((struct glyph_row *, int, int)); 2956void enable_glyph_matrix_rows P_ ((struct glyph_matrix *, int, int, int)); 2957void clear_glyph_row P_ ((struct glyph_row *)); 2958void prepare_desired_row P_ ((struct glyph_row *)); 2959int line_hash_code P_ ((struct glyph_row *)); 2960void set_window_update_flags P_ ((struct window *, int)); 2961void write_glyphs P_ ((struct glyph *, int)); 2962void insert_glyphs P_ ((struct glyph *, int)); 2963void redraw_frame P_ ((struct frame *)); 2964void redraw_garbaged_frames P_ ((void)); 2965int scroll_cost P_ ((struct frame *, int, int, int)); 2966int direct_output_for_insert P_ ((int)); 2967int direct_output_forward_char P_ ((int)); 2968int update_frame P_ ((struct frame *, int, int)); 2969void update_single_window P_ ((struct window *, int)); 2970int scrolling P_ ((struct frame *)); 2971void do_pending_window_change P_ ((int)); 2972void change_frame_size P_ ((struct frame *, int, int, int, int, int)); 2973void bitch_at_user P_ ((void)); 2974void init_display P_ ((void)); 2975void syms_of_display P_ ((void)); 2976extern Lisp_Object Qredisplay_dont_pause; 2977GLYPH spec_glyph_lookup_face P_ ((struct window *, GLYPH)); 2978 2979/* Defined in term.c */ 2980 2981extern void ring_bell P_ ((void)); 2982extern void set_terminal_modes P_ ((void)); 2983extern void reset_terminal_modes P_ ((void)); 2984extern void update_begin P_ ((struct frame *)); 2985extern void update_end P_ ((struct frame *)); 2986extern void set_terminal_window P_ ((int)); 2987extern void set_scroll_region P_ ((int, int)); 2988extern void turn_off_insert P_ ((void)); 2989extern void turn_off_highlight P_ ((void)); 2990extern void background_highlight P_ ((void)); 2991extern void clear_frame P_ ((void)); 2992extern void clear_end_of_line P_ ((int)); 2993extern void clear_end_of_line_raw P_ ((int)); 2994extern void delete_glyphs P_ ((int)); 2995extern void ins_del_lines P_ ((int, int)); 2996extern int string_cost P_ ((char *)); 2997extern int per_line_cost P_ ((char *)); 2998extern void calculate_costs P_ ((struct frame *)); 2999extern void set_tty_color_mode P_ ((struct frame *, Lisp_Object)); 3000extern void tty_setup_colors P_ ((int)); 3001extern void term_init P_ ((char *)); 3002void cursor_to P_ ((int, int)); 3003extern int tty_capable_p P_ ((struct frame *, unsigned, unsigned long, unsigned long)); 3004 3005/* Defined in scroll.c */ 3006 3007extern int scrolling_max_lines_saved P_ ((int, int, int *, int *, int *)); 3008extern int scroll_cost P_ ((struct frame *, int, int, int)); 3009extern void do_line_insertion_deletion_costs P_ ((struct frame *, char *, 3010 char *, char *, char *, 3011 char *, char *, int)); 3012void scrolling_1 P_ ((struct frame *, int, int, int, int *, int *, int *, 3013 int *, int)); 3014 3015/* Defined in frame.c */ 3016 3017#ifdef HAVE_WINDOW_SYSTEM 3018 3019/* Types we might convert a resource string into. */ 3020enum resource_types 3021{ 3022 RES_TYPE_NUMBER, 3023 RES_TYPE_FLOAT, 3024 RES_TYPE_BOOLEAN, 3025 RES_TYPE_STRING, 3026 RES_TYPE_SYMBOL 3027}; 3028 3029extern Lisp_Object x_get_arg P_ ((Display_Info *, Lisp_Object, 3030 Lisp_Object, char *, char *class, 3031 enum resource_types)); 3032extern Lisp_Object x_frame_get_arg P_ ((struct frame *, Lisp_Object, 3033 Lisp_Object, char *, char *, 3034 enum resource_types)); 3035extern Lisp_Object x_frame_get_and_record_arg P_ (( 3036 struct frame *, Lisp_Object, 3037 Lisp_Object, char *, char *, 3038 enum resource_types)); 3039extern Lisp_Object x_default_parameter P_ ((struct frame *, Lisp_Object, 3040 Lisp_Object, Lisp_Object, 3041 char *, char *, 3042 enum resource_types)); 3043 3044#endif /* HAVE_WINDOW_SYSTEM */ 3045 3046#endif /* not DISPEXTERN_H_INCLUDED */ 3047 3048/* arch-tag: c65c475f-1c1e-4534-8795-990b8509fd65 3049 (do not change this comment) */ 3050