src/dispextern.h

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