src/dispextern.h

   1 /* Interface definitions for display code.
   2    Copyright (C) 1985, 1993, 1994, 1997, 1998, 1999
   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@acm.org>.  */
  23
  24 #ifndef DISPEXTERN_H_INCLUDED
  25 #define DISPEXTERN_H_INCLUDED
  26
  27 #ifdef HAVE_X_WINDOWS
  28 #include <X11/Xlib.h>
  29 #ifdef USE_X_TOOLKIT
  30 #include <X11/Intrinsic.h>
  31 #endif /* USE_X_TOOLKIT */
  32 #endif /* HAVE_X_WINDOWS */
  33
  34 #ifdef MSDOS
  35 #include "msdos.h"
  36 #endif
  37
  38 #ifdef HAVE_NTGUI
  39 #include "w32gui.h"
  40 #endif
  41
  42 #ifdef macintosh
  43 #include "macterm.h"
  44 #endif
  45
  46 /* Structure forward declarations.  Some are here because function
  47    prototypes below reference structure types before their definition
  48    in this file.  Some are here because not every file including
  49    dispextern.h also includes frame.h and windows.h.  */
  50
  51 struct glyph;
  52 struct glyph_row;
  53 struct glyph_matrix;
  54 struct glyph_pool;
  55 struct frame;
  56 struct window;
  57
  58
  59 \f
  60 /***********************************************************************
  61                               Debugging
  62  ***********************************************************************/
  63
  64 /* If GLYPH_DEBUG is non-zero, additional checks are activated.  Turn
  65    it off by defining the macro GLYPH_DEBUG to zero.  */
  66
  67 #ifndef GLYPH_DEBUG
  68 #define GLYPH_DEBUG 0
  69 #endif
  70
  71 /* Macros to include code only if GLYPH_DEBUG != 0.  */
  72
  73 #if GLYPH_DEBUG
  74 #define IF_DEBUG(X)     X
  75 #define xassert(X)      do {if (!(X)) abort ();} while (0)
  76 #else
  77 #define IF_DEBUG(X)     (void) 0
  78 #define xassert(X)      (void) 0
  79 #endif
  80
  81 /* Macro for displaying traces of redisplay.  If Emacs was compiled
  82    with GLYPH_DEBUG != 0, the variable trace_redisplay_p can be set to
  83    a non-zero value in debugging sessions to activate traces.  */
  84
  85 #if GLYPH_DEBUG
  86
  87 extern int trace_redisplay_p;
  88 #include <stdio.h>
  89
  90 #define TRACE(X)                                \
  91      if (trace_redisplay_p)                     \
  92        fprintf X;                               \
  93      else                                       \
  94        (void) 0
  95
  96 #else /* GLYPH_DEBUG == 0 */
  97
  98 #define TRACE(X)        (void) 0
  99
 100 #endif /* GLYPH_DEBUG == 0 */
 101
 102
 103 \f
 104 /***********************************************************************
 105                             Text positions
 106  ***********************************************************************/
 107
 108 /* Starting with Emacs 20.3, characters from strings and buffers have
 109    both a character and a byte position associated with them.  The
 110    following structure holds such a pair of positions.  */
 111
 112 struct text_pos
 113 {
 114   /* Character position.  */
 115   int charpos;
 116
 117   /* Corresponding byte position.  */
 118   int bytepos;
 119 };
 120
 121 /* Access character and byte position of POS in a functional form.  */
 122
 123 #define BYTEPOS(POS)    (POS).bytepos
 124 #define CHARPOS(POS)    (POS).charpos
 125
 126 /* Set character position of POS to CHARPOS, byte position to BYTEPOS.  */
 127
 128 #define SET_TEXT_POS(POS, CHARPOS, BYTEPOS) \
 129      ((POS).charpos = (CHARPOS), (POS).bytepos = BYTEPOS)
 130
 131 /* Increment text position POS.  */
 132
 133 #define INC_TEXT_POS(POS)                       \
 134      do                                         \
 135        {                                        \
 136          ++(POS).charpos;                       \
 137          INC_POS ((POS).bytepos);               \
 138        }                                        \
 139      while (0)
 140
 141 /* Decrement text position POS.  */
 142
 143 #define DEC_TEXT_POS(POS)                       \
 144      do                                         \
 145        {                                        \
 146          --(POS).charpos;                       \
 147          DEC_POS ((POS).bytepos);               \
 148        }                                        \
 149      while (0)
 150
 151 /* Set text position POS from marker MARKER.  */
 152
 153 #define SET_TEXT_POS_FROM_MARKER(POS, MARKER)           \
 154      (CHARPOS (POS) = marker_position ((MARKER)),       \
 155       BYTEPOS (POS) = marker_byte_position ((MARKER)))
 156
 157 /* Set marker MARKER from text position POS.  */
 158
 159 #define SET_MARKER_FROM_TEXT_POS(MARKER, POS) \
 160      set_marker_both ((MARKER), Qnil, CHARPOS ((POS)), BYTEPOS ((POS)))
 161
 162 /* Value is non-zero if character and byte positions of POS1 and POS2
 163    are equal.  */
 164
 165 #define TEXT_POS_EQUAL_P(POS1, POS2)            \
 166      ((POS1).charpos == (POS2).charpos          \
 167       && (POS1).bytepos == (POS2).bytepos)
 168
 169 /* When rendering glyphs, redisplay scans string or buffer text,
 170    overlay strings in that text, and does display table or control
 171    character translations.  The following structure captures a
 172    position taking all this into account.  */
 173
 174 struct display_pos
 175 {
 176   /* Buffer or string position.  */
 177   struct text_pos pos;
 178
 179   /* If this is a position in an overlay string, overlay_string_index
 180      is the index of that overlay string in the sequence of overlay
 181      strings at `pos' in the order redisplay processes them.  A value
 182      < 0 means that this is not a position in an overlay string.  */
 183   int overlay_string_index;
 184
 185   /* If this is a position in an overlay string, string_pos is the
 186      position within that string.  */
 187   struct text_pos string_pos;
 188
 189   /* If the character at the position above is a control character or
 190      has a display table entry, dpvec_index is an index in the display
 191      table or control character translation of that character.  A
 192      value < 0 means this is not a position in such a translation.  */
 193   int dpvec_index;
 194 };
 195
 196
 197 \f
 198 /***********************************************************************
 199                                 Glyphs
 200  ***********************************************************************/
 201
 202 /* Enumeration of glyph types.  Glyph structures contain a type field
 203    containing one of the enumerators defined here.  */
 204
 205 enum glyph_type
 206 {
 207   /* Glyph describes a character.  */
 208   CHAR_GLYPH,
 209
 210   /* Glyph describes an image.  */
 211   IMAGE_GLYPH,
 212
 213   /* Glyph is a space of fractional width and/or height.  */
 214   STRETCH_GLYPH
 215 };
 216
 217
 218 /* Glyphs.  */
 219
 220 struct glyph
 221 {
 222   /* Position from which this glyph was drawn.  If `object' below is a
 223      Lisp string, this is a position in that string.  If it is a
 224      buffer, this is a position in that buffer.  A value of -1
 225      together with a null object means glyph is a truncation glyph at
 226      the start of a row.  */
 227   int charpos;
 228
 229   /* Lisp object source of this glyph.  Currently either a buffer or
 230      a string, or 0.  */
 231   Lisp_Object object;
 232
 233   /* Width in pixels.  */
 234   short pixel_width;
 235
 236   /* Vertical offset.  If < 0, the glyph is displayed raised, if > 0
 237      the glyph is displayed lowered.  */
 238   short voffset;
 239
 240   /* Which kind of glyph this is---character, image etc.  Value
 241      should be an enumerator of type enum glyph_type.  */
 242   unsigned type : 2;
 243
 244   /* 1 means this glyph was produced from multibyte text.  Zero
 245      means it was produced from unibyte text, i.e. charsets aren't
 246      applicable, and encoding is not performed.  */
 247   unsigned multibyte_p : 1;
 248
 249   /* Non-zero means draw a box line at the left or right side of this
 250      glyph.  This is part of the implementation of the face attribute
 251      `:box'.  */
 252   unsigned left_box_line_p : 1;
 253   unsigned right_box_line_p : 1;
 254
 255   /* Non-zero means this glyph's physical ascent or descent is greater
 256      than its logical ascent/descent, i.e. it may potentially overlap
 257      glyphs above or below it.  */
 258   unsigned overlaps_vertically_p : 1;
 259
 260   /* A union of sub-structures for different glyph types.  */
 261   union
 262   {
 263     /* Sub-structure for character glyphs (type == CHAR_GLYPH).  */
 264     struct
 265     {
 266       /* Character code.  */
 267       unsigned code : 19;
 268
 269       /* Character's face.  */
 270       unsigned face_id : 11;
 271
 272       /* 1 means glyph is a padding glyph.  Padding glyphs are used
 273          for characters whose visual shape consists of more than one
 274          glyph (e.g. Asian characters).  All but the first glyph of
 275          such a glyph sequence have the padding_p flag set.  Only used
 276          for terminal frames, and there only to minimize code changes.
 277          A better way would probably be to use the width field of
 278          glyphs to express padding.  */
 279       unsigned padding_p : 1;
 280     }
 281     ch;
 282
 283     /* Sub-structure for image glyphs (type == IMAGE_GLYPH).  */
 284     struct
 285     {
 286       /* Image id.  */
 287       unsigned id : 20;
 288
 289       /* Face under the image.  */
 290       unsigned face_id : 12;
 291     }
 292     img;
 293
 294     /* Sub-structure for type == STRETCH_GLYPH.  */
 295     struct
 296     {
 297       /* The height of the glyph.  */
 298       unsigned height  : 11;
 299
 300       /* The ascent of the glyph.  */
 301       unsigned ascent  : 10;
 302
 303       /* The face of the stretch glyph.  */
 304       unsigned face_id : 11;
 305     }
 306     stretch;
 307
 308     /* Used to compare all bit-fields above in one step.  */
 309     unsigned val;
 310   } u;
 311 };
 312
 313
 314 /* Is GLYPH a space?  */
 315
 316 #define CHAR_GLYPH_SPACE_P(GLYPH) \
 317      (GLYPH_FROM_CHAR_GLYPH ((GLYPH)) == SPACEGLYPH)
 318
 319 /* Are glyphs *X and *Y equal?  */
 320
 321 #define GLYPH_EQUAL_P(X, Y)                                     \
 322      ((X)->type == (Y)->type                                    \
 323       && (X)->u.val == (Y)->u.val                               \
 324       && (X)->left_box_line_p == (Y)->left_box_line_p           \
 325       && (X)->right_box_line_p == (Y)->right_box_line_p         \
 326       && (X)->voffset == (Y)->voffset)
 327
 328 /* Fill a character glyph GLYPH.  CODE, FACE_ID, PADDING_P correspond
 329    to the bits defined for the typedef `GLYPH' in lisp.h.  */
 330
 331 #define SET_CHAR_GLYPH(GLYPH, CODE, FACE_ID, PADDING_P) \
 332      do                                                 \
 333        {                                                \
 334          (GLYPH).u.ch.code = (CODE);                    \
 335          (GLYPH).u.ch.face_id = (FACE_ID);              \
 336          (GLYPH).u.ch.padding_p = (PADDING_P);          \
 337        }                                                \
 338      while (0)
 339
 340 /* Fill a character type glyph GLYPH from a glyph typedef FROM as
 341    defined in lisp.h.  */
 342
 343 #define SET_CHAR_GLYPH_FROM_GLYPH(GLYPH, FROM)                  \
 344      SET_CHAR_GLYPH ((GLYPH),                                   \
 345                      FAST_GLYPH_CHAR ((FROM)),                  \
 346                      FAST_GLYPH_FACE ((FROM)),                  \
 347                      ((FROM) & GLYPH_MASK_PADDING) != 0)
 348
 349 /* Construct a typedef'd GLYPH value from a character glyph GLYPH.  */
 350
 351 #define GLYPH_FROM_CHAR_GLYPH(GLYPH)                            \
 352      ((GLYPH).u.ch.code                                         \
 353        | ((GLYPH).u.ch.face_id << CHARACTERBITS)                \
 354        | ((GLYPH).u.ch.padding_p ? GLYPH_MASK_PADDING : 0))
 355
 356 /* Is GLYPH a padding glyph?  */
 357
 358 #define CHAR_GLYPH_PADDING_P(GLYPH) (GLYPH).u.ch.padding_p
 359
 360
 361
 362 \f
 363 /***********************************************************************
 364                              Glyph Pools
 365  ***********************************************************************/
 366
 367 /* Glyph Pool.
 368
 369    Glyph memory for frame-based redisplay is allocated from the heap
 370    in one vector kept in a glyph pool structure which is stored with
 371    the frame.  The size of the vector is made large enough to cover
 372    all windows on the frame.
 373
 374    Both frame and window glyph matrices reference memory from a glyph
 375    pool in frame-based redisplay.
 376
 377    In window-based redisplay, no glyphs pools exist; windows allocate
 378    and free their glyph memory themselves.  */
 379
 380 struct glyph_pool
 381 {
 382   /* Vector of glyphs allocated from the heap.  */
 383   struct glyph *glyphs;
 384
 385   /* Allocated size of `glyphs'.  */
 386   int nglyphs;
 387
 388   /* Number of rows and columns in a matrix.  */
 389   int nrows, ncolumns;
 390 };
 391
 392
 393 \f
 394 /***********************************************************************
 395                              Glyph Matrix
 396  ***********************************************************************/
 397
 398 /* Glyph Matrix.
 399
 400    Three kinds of glyph matrices exist:
 401
 402    1. Frame glyph matrices.  These are used for terminal frames whose
 403    redisplay needs a view of the whole screen due to limited terminal
 404    capabilities.  Frame matrices are used only in the update phase
 405    of redisplay.  They are built in update_frame and not used after
 406    the update has been performed.
 407
 408    2. Window glyph matrices on frames having frame glyph matrices.
 409    Such matrices are sub-matrices of their corresponding frame matrix,
 410    i.e. frame glyph matrices and window glyph matrices share the same
 411    glyph memory which is allocated in form of a glyph_pool structure.
 412    Glyph rows in such a window matrix are slices of frame matrix rows.
 413
 414    2. Free-standing window glyph matrices managing their own glyph
 415    storage.  This form is used in window-based redisplay which
 416    includes variable width and height fonts etc.
 417
 418    The size of a window's row vector depends on the height of fonts
 419    defined on its frame.  It is chosen so that the vector is large
 420    enough to describe all lines in a window when it is displayed in
 421    the smallest possible character size.  When new fonts are loaded,
 422    or window sizes change, the row vector is adjusted accordingly.  */
 423
 424 struct glyph_matrix
 425 {
 426   /* The pool from which glyph memory is allocated, if any.  This is
 427      null for frame matrices and for window matrices managing their
 428      own storage.  */
 429   struct glyph_pool *pool;
 430
 431   /* Vector of glyph row structures.  The row at nrows - 1 is reserved
 432      for the mode line.  */
 433   struct glyph_row *rows;
 434
 435   /* Number of elements allocated for the vector rows above.  */
 436   int rows_allocated;
 437
 438   /* The number of rows used by the window if all lines were displayed
 439      with the smallest possible character height.  */
 440   int nrows;
 441
 442   /* Origin within the frame matrix if this is a window matrix on a
 443      frame having a frame matrix.  Both values are zero for
 444      window-based redisplay.  */
 445   int matrix_x, matrix_y;
 446
 447   /* Width and height of the matrix in columns and rows.  */
 448   int matrix_w, matrix_h;
 449
 450   /* If this structure describes a window matrix, window_top_y is the
 451      top-most y-position and window_height is the height of the
 452      window, and window_vscroll is the vscroll at the time the matrix
 453      was last adjusted.  Only set for window-based redisplay.  */
 454   int window_top_y, window_height, window_width, window_vscroll;
 455
 456   /* Number of glyphs reserved for left and right marginal areas when
 457      the matrix was last adjusted.  */
 458   int left_margin_glyphs, right_margin_glyphs;
 459
 460   /* Flag indicating that scrolling should not be tried in
 461      update_window.  This flag is set by functions like try_window_id
 462      which do their own scrolling.  */
 463   unsigned no_scrolling_p : 1;
 464
 465   /* Non-zero means window displayed in this matrix has a top mode
 466      line.  */
 467   unsigned header_line_p : 1;
 468
 469 #ifdef GLYPH_DEBUG
 470   /* A string identifying the method used to display the matrix.  */
 471   char method[512];
 472 #endif
 473
 474   /* The buffer this matrix displays.  Set in redisplay_internal.  */
 475   struct buffer *buffer;
 476
 477   /* Values of BEGV and ZV as of last redisplay.  */
 478   int begv, zv;
 479 };
 480
 481
 482 /* Check that glyph pointers stored in glyph rows of MATRIX are okay.
 483    This aborts if any pointer is found twice.  */
 484
 485 #if GLYPH_DEBUG
 486 void check_matrix_pointer_lossage P_ ((struct glyph_matrix *));
 487 #define CHECK_MATRIX(MATRIX) check_matrix_pointer_lossage ((MATRIX))
 488 #else
 489 #define CHECK_MATRIX(MATRIX) (void) 0
 490 #endif
 491
 492
 493 \f
 494 /***********************************************************************
 495                              Glyph Rows
 496  ***********************************************************************/
 497
 498 /* Area in window glyph matrix.  If values are added or removed, the
 499    function mark_object in alloc.c has to be changed.  */
 500
 501 enum glyph_row_area
 502 {
 503   LEFT_MARGIN_AREA,
 504   TEXT_AREA,
 505   RIGHT_MARGIN_AREA,
 506   LAST_AREA
 507 };
 508
 509
 510 /* Rows of glyphs in a windows or frame glyph matrix.
 511
 512    Each row is partitioned into three areas.  The start and end of
 513    each area is recorded in a pointer as shown below.
 514
 515    +--------------------+-------------+---------------------+
 516    |  left margin area  |  text area  |  right margin area  |
 517    +--------------------+-------------+---------------------+
 518    |                    |             |                     |
 519    glyphs[LEFT_MARGIN_AREA]           glyphs[RIGHT_MARGIN_AREA]
 520                         |                                   |
 521                         glyphs[TEXT_AREA]                   |
 522                                               glyphs[LAST_AREA]
 523
 524    Rows in frame matrices reference glyph memory allocated in a frame
 525    glyph pool (see the description of struct glyph_pool).  Rows in
 526    window matrices on frames having frame matrices reference slices of
 527    the glyphs of corresponding rows in the frame matrix.
 528
 529    Rows in window matrices on frames having no frame matrices point to
 530    glyphs allocated from the heap via xmalloc;
 531    glyphs[LEFT_MARGIN_AREA] is the start address of the allocated
 532    glyph structure array.  */
 533
 534 struct glyph_row
 535 {
 536   /* Pointers to beginnings of areas.  The end of an area A is found at
 537      A + 1 in the vector.  The last element of the vector is the end
 538      of the whole row.
 539
 540      Kludge alert: Even if used[TEXT_AREA] == 0, glyphs[TEXT_AREA][0]'s
 541      position field is used.  It is -1 if this row does not correspond
 542      to any text; it is some buffer position if the row corresponds to
 543      an empty display line that displays a line end.  This is what old
 544      redisplay used to do.  (Except in code for terminal frames, this
 545      kludge is no longer use, I believe. --gerd).
 546
 547      See also start, end, displays_text_p and ends_at_zv_p for cleaner
 548      ways to do it.  The special meaning of positions 0 and -1 will be
 549      removed some day, so don't use it in new code.  */
 550   struct glyph *glyphs[1 + LAST_AREA];
 551
 552   /* Number of glyphs actually filled in areas.  */
 553   short used[LAST_AREA];
 554
 555   /* Window-relative x and y-position of the top-left corner of this
 556      row.  If y < 0, this means that abs (y) pixels of the row are
 557      invisible because it is partially visible at the top of a window.
 558      If x < 0, this means that abs (x) pixels of the first glyph of
 559      the text area of the row are invisible because the glyph is
 560      partially visible.  */
 561   int x, y;
 562
 563   /* Width of the row in pixels without taking face extension at the
 564      end of the row into account.  */
 565   int pixel_width;
 566
 567   /* Logical ascent/height of this line.  The value of ascent is zero
 568      and height is 1 on terminal frames.  */
 569   int ascent, height;
 570
 571   /* Physical ascent/height of this line.  If max_ascent > ascent,
 572      this line overlaps the line above it on the display.  Otherwise,
 573      if max_height > height, this line overlaps the line beneath it.  */
 574   int phys_ascent, phys_height;
 575
 576   /* Portion of row that is visible.  Partially visible rows may be
 577      found at the top and bottom of a window.  This is 1 for tty
 578      frames.  It may be < 0 in case of completely invisible rows.  */
 579   int visible_height;
 580
 581   /* Hash code.  This hash code is available as soon as the row
 582      is constructed, i.e. after a call to display_line.  */
 583   unsigned hash;
 584
 585   /* First position in this row.  This is the text position, including
 586      overlay position information etc, where the display of this row
 587      started, and can thus be less the position of the first glyph
 588      (e.g. due to invisible text or horizontal scrolling).  */
 589   struct display_pos start;
 590
 591   /* Text position at the end of this row.  This is the position after
 592      the last glyph on this row.  It can be greater than the last
 593      glyph position + 1, due to truncation, invisible text etc.  In an
 594      up-to-date display, this should always be equal to the start
 595      position of the next row.  */
 596   struct display_pos end;
 597
 598   /* In a desired matrix, 1 means that this row must be updated.  In a
 599      current matrix, 0 means that the row has been invalidated, i.e.
 600      the row's contents do not agree with what is visible on the
 601      screen.  */
 602   unsigned enabled_p : 1;
 603
 604   /* Display this line in inverse video?  Used for the mode line and
 605      menu bar lines.  */
 606   unsigned inverse_p : 1;
 607
 608   /* 1 means row displays a text line that is truncated on the left or
 609      right side.  */
 610   unsigned truncated_on_left_p : 1;
 611   unsigned truncated_on_right_p : 1;
 612
 613   /* 1 means the overlay arrow is on this line.  */
 614   unsigned overlay_arrow_p : 1;
 615
 616   /* 1 means that this row displays a continued line, i.e. it has a
 617      continuation mark at the right side.  */
 618   unsigned continued_p : 1;
 619
 620   /* 0 means that this row does not contain any text, i.e. it is
 621      a blank line at the window and buffer end.  */
 622   unsigned displays_text_p : 1;
 623
 624   /* 1 means that this line ends at ZV.  */
 625   unsigned ends_at_zv_p : 1;
 626
 627   /* 1 means the face of the last glyph in the text area is drawn to
 628      the right end of the window.  This flag is used in
 629      update_text_area to optimize clearing to the end of the area.  */
 630   unsigned fill_line_p : 1;
 631
 632   /* Non-zero means display a bitmap on X frames indicating that this
 633      line contains no text and ends in ZV.  */
 634   unsigned indicate_empty_line_p : 1;
 635
 636   /* 1 means this row contains glyphs that overlap each other because
 637      of lbearing or rbearing.  */
 638   unsigned contains_overlapping_glyphs_p : 1;
 639
 640   /* 1 means this row is a wide as the window it is displayed in, including
 641      scroll bars, bitmap areas, and internal borders.  This also
 642      implies that the row doesn't have marginal areas.  */
 643   unsigned full_width_p : 1;
 644
 645   /* Non-zero means row is a mode or top-line.  */
 646   unsigned mode_line_p : 1;
 647
 648   /* 1 in a current row means this row is overlapped by another row.  */
 649   unsigned overlapped_p : 1;
 650
 651   /* 1 in a current row means this row overlaps others.  */
 652   unsigned overlapping_p : 1;
 653
 654   /* Continuation lines width at the start of the row.  */
 655   int continuation_lines_width;
 656 };
 657
 658
 659 /* Get a pointer to row number ROW in matrix MATRIX.  If GLYPH_DEBUG
 660    is defined to a non-zero value, the function matrix_row checks that
 661    we don't try to access rows that are out of bounds.  */
 662
 663 #if GLYPH_DEBUG
 664 struct glyph_row *matrix_row P_ ((struct glyph_matrix *, int));
 665 #define MATRIX_ROW(MATRIX, ROW)   matrix_row ((MATRIX), (ROW))
 666 #else
 667 #define MATRIX_ROW(MATRIX, ROW)   ((MATRIX)->rows + (ROW))
 668 #endif
 669
 670 /* Return a pointer to the row reserved for the mode line in MATRIX.
 671    Row MATRIX->nrows - 1 is always reserved for the mode line.  */
 672
 673 #define MATRIX_MODE_LINE_ROW(MATRIX) \
 674      ((MATRIX)->rows + (MATRIX)->nrows - 1)
 675
 676 /* Return a pointer to the row reserved for the top line in MATRIX.
 677    This is always the first row in MATRIX because that's the only
 678    way that works in frame-based redisplay.  */
 679
 680 #define MATRIX_HEADER_LINE_ROW(MATRIX) (MATRIX)->rows
 681
 682 /* Return a pointer to first row in MATRIX used for text display.  */
 683
 684 #define MATRIX_FIRST_TEXT_ROW(MATRIX) \
 685      ((MATRIX)->rows->mode_line_p ? (MATRIX)->rows + 1 : (MATRIX)->rows)
 686
 687 /* Return a pointer to the first glyph in the text area of a row.
 688    MATRIX is the glyph matrix accessed, and ROW is the row index in
 689    MATRIX.  */
 690
 691 #define MATRIX_ROW_GLYPH_START(MATRIX, ROW) \
 692      (MATRIX_ROW ((MATRIX), (ROW))->glyphs[TEXT_AREA])
 693
 694 /* Return the number of used glyphs in the text area of a row.  */
 695
 696 #define MATRIX_ROW_USED(MATRIX, ROW) \
 697      (MATRIX_ROW ((MATRIX), (ROW))->used[TEXT_AREA])
 698
 699 /* Return the character/ byte position at which the display of ROW
 700    starts.  */
 701
 702 #define MATRIX_ROW_START_CHARPOS(ROW) ((ROW)->start.pos.charpos)
 703 #define MATRIX_ROW_START_BYTEPOS(ROW) ((ROW)->start.pos.bytepos)
 704
 705 /* Return character/ byte position at which ROW ends.  */
 706
 707 #define MATRIX_ROW_END_CHARPOS(ROW) ((ROW)->end.pos.charpos)
 708 #define MATRIX_ROW_END_BYTEPOS(ROW) ((ROW)->end.pos.bytepos)
 709
 710 /* Return the vertical position of ROW in MATRIX.  */
 711
 712 #define MATRIX_ROW_VPOS(ROW, MATRIX) ((ROW) - (MATRIX)->rows)
 713
 714 /* Return the last glyph row + 1 in MATRIX on window W reserved for
 715    text.  If W has a mode line, the last row in the matrix is reserved
 716    for it.  */
 717
 718 #define MATRIX_BOTTOM_TEXT_ROW(MATRIX, W)               \
 719      ((MATRIX)->rows                                    \
 720       + (MATRIX)->nrows                                 \
 721       - (WINDOW_WANTS_MODELINE_P ((W)) ? 1 : 0))
 722
 723 /* Non-zero if the face of the last glyph in ROW's text area has
 724    to be drawn to the end of the text area.  */
 725
 726 #define MATRIX_ROW_EXTENDS_FACE_P(ROW) ((ROW)->fill_line_p)
 727
 728 /* Set and query the enabled_p flag of glyph row ROW in MATRIX.  */
 729
 730 #define SET_MATRIX_ROW_ENABLED_P(MATRIX, ROW, VALUE) \
 731      (MATRIX_ROW ((MATRIX), (ROW))->enabled_p = (VALUE) != 0)
 732
 733 #define MATRIX_ROW_ENABLED_P(MATRIX, ROW) \
 734      (MATRIX_ROW ((MATRIX), (ROW))->enabled_p)
 735
 736 /* Non-zero if ROW displays text.  Value is non-zero if the row is
 737    blank but displays a line end.  */
 738
 739 #define MATRIX_ROW_DISPLAYS_TEXT_P(ROW) ((ROW)->displays_text_p)
 740
 741 /* Non-zero if ROW is not completely visible in window W.  */
 742
 743 #define MATRIX_ROW_PARTIALLY_VISIBLE_P(ROW)     \
 744      ((ROW)->height != (ROW)->visible_height)
 745
 746 /* Non-zero if ROW is partially visible at the top of window W.  */
 747
 748 #define MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P(W, ROW)           \
 749      (MATRIX_ROW_PARTIALLY_VISIBLE_P ((ROW))                    \
 750       && (ROW)->y < WINDOW_DISPLAY_HEADER_LINE_HEIGHT ((W)))
 751
 752 /* Non-zero if ROW is partially visible at the bottom of window W.  */
 753
 754 #define MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P(W, ROW)                      \
 755      (MATRIX_ROW_PARTIALLY_VISIBLE_P ((ROW))                                  \
 756       && (ROW)->y + (ROW)->height > WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE ((W)))
 757
 758 /* Return the bottom Y + 1 of ROW.   */
 759
 760 #define MATRIX_ROW_BOTTOM_Y(ROW) ((ROW)->y + (ROW)->height)
 761
 762 /* Is ROW the last visible one in the display described by the
 763    iterator structure pointed to by IT?.  */
 764
 765 #define MATRIX_ROW_LAST_VISIBLE_P(ROW, IT) \
 766      (MATRIX_ROW_BOTTOM_Y ((ROW)) >= (IT)->last_visible_y)
 767
 768 /* Non-zero if ROW displays a continuation line.  */
 769
 770 #define MATRIX_ROW_CONTINUATION_LINE_P(ROW) \
 771      ((ROW)->continuation_lines_width > 0)
 772
 773 /* Non-zero if ROW ends in the middle of a character.  This is the
 774    case for continued lines showing only part of a display table entry
 775    or a control char, or an overlay string.  */
 776
 777 #define MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P(ROW)        \
 778      ((ROW)->end.dpvec_index >= 0                       \
 779       || (ROW)->end.overlay_string_index >= 0)
 780
 781 /* Non-zero if ROW ends in the middle of an overlay string.  */
 782
 783 #define MATRIX_ROW_ENDS_IN_OVERLAY_STRING_P(ROW) \
 784      ((ROW)->end.overlay_string_index >= 0)
 785
 786 /* Non-zero if ROW starts in the middle of a character.  See above.  */
 787
 788 #define MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P(ROW)      \
 789      ((ROW)->start.dpvec_index >= 0                     \
 790       || ((ROW)->start.overlay_string_index >= 0        \
 791           && (ROW)->start.string_pos.charpos > 0))
 792
 793 /* Non-zero means ROW overlaps its predecessor.  */
 794
 795 #define MATRIX_ROW_OVERLAPS_PRED_P(ROW) \
 796      ((ROW)->phys_ascent > (ROW)->ascent)
 797
 798 /* Non-zero means ROW overlaps its successor.  */
 799
 800 #define MATRIX_ROW_OVERLAPS_SUCC_P(ROW)         \
 801       ((ROW)->phys_height - (ROW)->phys_ascent  \
 802        > (ROW)->height - (ROW)->ascent)
 803
 804 /* Non-zero means that fonts have been loaded since the last glyph
 805    matrix adjustments.  The function redisplay_internal adjusts glyph
 806    matrices when this flag is non-zero.  */
 807
 808 extern int fonts_changed_p;
 809
 810 /* A glyph for a space.  */
 811
 812 extern struct glyph space_glyph;
 813
 814 /* Window being updated by update_window.  This is non-null as long as
 815    update_window has not finished, and null otherwise.  It's role is
 816    analogous to updating_frame.  */
 817
 818 extern struct window *updated_window;
 819
 820 /* Glyph row and area updated by update_window_line.  */
 821
 822 extern struct glyph_row *updated_row;
 823 extern int updated_area;
 824
 825 /* Non-zero means reading single-character input with prompt so put
 826    cursor on mini-buffer after the prompt.  Positive means at end of
 827    text in echo area; negative means at beginning of line.  */
 828
 829 extern int cursor_in_echo_area;
 830
 831 /* Non-zero means last display completed.  Zero means it was
 832    preempted.  */
 833
 834 extern int display_completed;
 835
 836 /* Non-zero means redisplay has been performed directly (see also
 837    direct_output_for_insert and direct_output_forward_char), so that
 838    no further updating has to be performed.  The function
 839    redisplay_internal checks this flag, and does nothing but reset it
 840    to zero if it is non-zero.  */
 841
 842 extern int redisplay_performed_directly_p;
 843
 844 /* A temporary storage area, including a row of glyphs.  Initialized
 845    in xdisp.c.  Used for various purposes, as an example see
 846    direct_output_for_insert.  */
 847
 848 extern struct glyph_row scratch_glyph_row;
 849
 850
 851 \f
 852 /************************************************************************
 853                           Display Dimensions
 854  ************************************************************************/
 855
 856 /* Return the height of the mode line in glyph matrix MATRIX, or zero
 857    if not known.  This macro is called under circumstances where
 858    MATRIX might not have been allocated yet.  */
 859
 860 #define MATRIX_MODE_LINE_HEIGHT(MATRIX)         \
 861      ((MATRIX) && (MATRIX)->rows                \
 862       ? MATRIX_MODE_LINE_ROW (MATRIX)->height   \
 863       : 0)
 864
 865 /* Return the height of the top line in glyph matrix MATRIX, or zero
 866    if not known.  This macro is called under circumstances where
 867    MATRIX might not have been allocated yet.  */
 868
 869 #define MATRIX_HEADER_LINE_HEIGHT(MATRIX)       \
 870      ((MATRIX) && (MATRIX)->rows                \
 871       ? MATRIX_HEADER_LINE_ROW (MATRIX)->height \
 872       : 0)
 873
 874 /* Return the current height of the mode line of window W.  If not
 875    known from W's current glyph matrix, return a default based on the
 876    height of the font of the face `modeline'.  */
 877
 878 #define CURRENT_MODE_LINE_HEIGHT(W)                     \
 879      (MATRIX_MODE_LINE_HEIGHT ((W)->current_matrix)     \
 880       ? MATRIX_MODE_LINE_HEIGHT ((W)->current_matrix)   \
 881       : estimate_mode_line_height (XFRAME ((W)->frame), MODE_LINE_FACE_ID))
 882
 883 /* Return the current height of the top line of window W.  If not
 884    known from W's current glyph matrix, return an estimation based on
 885    the height of the font of the face `top-line'.  */
 886
 887 #define CURRENT_HEADER_LINE_HEIGHT(W)                                      \
 888       (MATRIX_HEADER_LINE_HEIGHT ((W)->current_matrix)                     \
 889       ? MATRIX_HEADER_LINE_HEIGHT ((W)->current_matrix)                    \
 890       : estimate_mode_line_height (XFRAME ((W)->frame), HEADER_LINE_FACE_ID))
 891
 892 /* Return the height of the desired mode line of window W.  */
 893
 894 #define DESIRED_MODE_LINE_HEIGHT(W) \
 895      MATRIX_MODE_LINE_HEIGHT ((W)->desired_matrix)
 896
 897 /* Return the height of the desired top line of window W.  */
 898
 899 #define DESIRED_HEADER_LINE_HEIGHT(W) \
 900      MATRIX_HEADER_LINE_HEIGHT ((W)->desired_matrix)
 901
 902 /* Like FRAME_INTERNAL_BORDER_WIDTH but checks whether frame F is a
 903    window-system frame.  */
 904
 905 #define FRAME_INTERNAL_BORDER_WIDTH_SAFE(F) \
 906      (FRAME_WINDOW_P (F) ? FRAME_INTERNAL_BORDER_WIDTH (F) : 0)
 907
 908 /* Width of display region of window W.  For terminal frames, this
 909    equals the width of W since there are no vertical scroll bars.  For
 910    window system frames, the value has to be corrected by the pixel
 911    width of vertical scroll bars, and bitmap areas.  */
 912
 913 #define WINDOW_DISPLAY_PIXEL_WIDTH(W)                                   \
 914      (((XFASTINT ((W)->width)                                           \
 915         - FRAME_SCROLL_BAR_WIDTH (XFRAME (WINDOW_FRAME ((W))))          \
 916         - FRAME_FLAGS_AREA_COLS (XFRAME (WINDOW_FRAME ((W)))))          \
 917        * CANON_X_UNIT (XFRAME (WINDOW_FRAME ((W))))))
 918
 919 /* Height of the display region of W, including a mode line, if any.  */
 920
 921 #define WINDOW_DISPLAY_PIXEL_HEIGHT(W)                                  \
 922      (XFASTINT ((W)->height)                                            \
 923       * CANON_Y_UNIT (XFRAME (WINDOW_FRAME ((W)))))
 924
 925 /* Height in pixels of the mode line.  May be zero if W doesn't have a
 926    mode line.  */
 927
 928 #define WINDOW_DISPLAY_MODE_LINE_HEIGHT(W)      \
 929      (WINDOW_WANTS_MODELINE_P ((W))             \
 930       ? CURRENT_MODE_LINE_HEIGHT (W)            \
 931       : 0)
 932
 933 /* Height in pixels of the top line.  Zero if W doesn't have a top
 934    line.  */
 935
 936 #define WINDOW_DISPLAY_HEADER_LINE_HEIGHT(W)    \
 937      (WINDOW_WANTS_HEADER_LINE_P ((W))          \
 938       ? CURRENT_HEADER_LINE_HEIGHT (W)          \
 939       : 0)
 940
 941 /* Pixel height of window W without mode line.  */
 942
 943 #define WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE(W)   \
 944      (WINDOW_DISPLAY_PIXEL_HEIGHT ((W))         \
 945       - WINDOW_DISPLAY_MODE_LINE_HEIGHT ((W)))
 946
 947 /* Pixel height of window W without mode and top line.  */
 948
 949 #define WINDOW_DISPLAY_TEXT_HEIGHT(W)           \
 950      (WINDOW_DISPLAY_PIXEL_HEIGHT ((W))         \
 951       - WINDOW_DISPLAY_MODE_LINE_HEIGHT ((W))   \
 952       - WINDOW_DISPLAY_HEADER_LINE_HEIGHT ((W)))
 953
 954 /* Left edge of W in pixels relative to its frame.  */
 955
 956 #define WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X(W)                             \
 957      (FRAME_INTERNAL_BORDER_WIDTH_SAFE (XFRAME (WINDOW_FRAME ((W))))    \
 958       + (WINDOW_LEFT_MARGIN ((W))                                       \
 959          * CANON_X_UNIT (XFRAME (WINDOW_FRAME ((W)))))                  \
 960       + FRAME_LEFT_FLAGS_AREA_WIDTH (XFRAME (WINDOW_FRAME ((W)))))
 961
 962 /* Right edge of window W in pixels, relative to its frame.  */
 963
 964 #define WINDOW_DISPLAY_RIGHT_EDGE_PIXEL_X(W)            \
 965      (WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X ((W))            \
 966       + WINDOW_DISPLAY_PIXEL_WIDTH ((W)))
 967
 968 /* Top edge of W in pixels relative to its frame.  */
 969
 970 #define WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y(W)                              \
 971      (FRAME_INTERNAL_BORDER_WIDTH_SAFE (XFRAME (WINDOW_FRAME ((W))))    \
 972       + (XFASTINT ((W)->top)                                            \
 973          * CANON_Y_UNIT (XFRAME (WINDOW_FRAME ((W))))))
 974
 975 /* Bottom edge of window W relative to its frame.  */
 976
 977 #define WINDOW_DISPLAY_BOTTOM_EDGE_PIXEL_Y(W)           \
 978      (WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y ((W))             \
 979       + WINDOW_DISPLAY_PIXEL_HEIGHT ((W)))
 980
 981 /* Convert window W relative pixel X to frame pixel coordinates.  */
 982
 983 #define WINDOW_TO_FRAME_PIXEL_X(W, X) \
 984      ((X) + WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X ((W)))
 985
 986 /* Convert window W relative pixel Y to frame pixel coordinates.  */
 987
 988 #define WINDOW_TO_FRAME_PIXEL_Y(W, Y) \
 989      ((Y) + WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y ((W)))
 990
 991 /* Convert frame relative pixel X to window relative pixel X.  */
 992
 993 #define FRAME_TO_WINDOW_PIXEL_X(W, X) \
 994      ((X) - WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X ((W)))
 995
 996 /* Convert frame relative pixel X to window relative pixel Y.  */
 997
 998 #define FRAME_TO_WINDOW_PIXEL_Y(W, Y) \
 999      ((Y) - WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y ((W)))
1000
1001 /* Width of left margin area in pixels.  */
1002
1003 #define WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH(W)         \
1004      (NILP ((W)->left_margin_width)                     \
1005       ? 0                                               \
1006       : (XINT ((W)->left_margin_width)                  \
1007          * CANON_X_UNIT (XFRAME (WINDOW_FRAME ((W))))))
1008
1009 /* Width of right marginal area in pixels.  */
1010
1011 #define WINDOW_DISPLAY_RIGHT_AREA_PIXEL_WIDTH(W)        \
1012      (NILP ((W)->right_margin_width)                    \
1013       ? 0                                               \
1014       : (XINT ((W)->right_margin_width)                 \
1015          * CANON_X_UNIT (XFRAME (WINDOW_FRAME ((W))))))
1016
1017 /* Width of text area in pixels.  */
1018
1019 #define WINDOW_DISPLAY_TEXT_AREA_PIXEL_WIDTH(W)         \
1020      (WINDOW_DISPLAY_PIXEL_WIDTH ((W))                  \
1021       - WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH ((W))      \
1022       - WINDOW_DISPLAY_RIGHT_AREA_PIXEL_WIDTH ((W)))
1023
1024 /* Convert a text area relative x-position in window W to frame X
1025    pixel coordinates.  */
1026
1027 #define WINDOW_TEXT_TO_FRAME_PIXEL_X(W, X)              \
1028      (WINDOW_TO_FRAME_PIXEL_X ((W), (X))                \
1029       + WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH ((W)))
1030
1031 /* Translate an x-position relative to AREA in window W to frame pixel
1032    coordinates.  */
1033
1034 #define WINDOW_AREA_TO_FRAME_PIXEL_X(W, AREA, X)        \
1035      (WINDOW_TO_FRAME_PIXEL_X ((W), (X))                \
1036       + (((AREA) > LEFT_MARGIN_AREA)                    \
1037          ? WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH ((W))   \
1038          : 0)                                           \
1039       + (((AREA) > TEXT_AREA)                           \
1040          ? WINDOW_DISPLAY_TEXT_AREA_PIXEL_WIDTH ((W))   \
1041          : 0))
1042
1043 /* Return the pixel width of AREA in W.  */
1044
1045 #define WINDOW_AREA_PIXEL_WIDTH(W, AREA)                \
1046      (((AREA) == TEXT_AREA)                             \
1047       ? WINDOW_DISPLAY_TEXT_AREA_PIXEL_WIDTH ((W))      \
1048       : (((AREA) == LEFT_MARGIN_AREA)                   \
1049          ? WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH ((W))   \
1050          : WINDOW_DISPLAY_RIGHT_AREA_PIXEL_WIDTH ((W))))
1051
1052 /* Value is non-zero if window W has a mode line.  */
1053
1054 #define WINDOW_WANTS_MODELINE_P(W)                                      \
1055      (!MINI_WINDOW_P (W)                                                \
1056       && !(W)->pseudo_window_p                                          \
1057       && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (W)))             \
1058       && !NILP (XBUFFER ((W)->buffer)->mode_line_format))
1059
1060 /* Value is non-zero if window W wants a top line.  */
1061
1062 #define WINDOW_WANTS_HEADER_LINE_P(W)                                   \
1063      (!MINI_WINDOW_P (W)                                                \
1064       && !(W)->pseudo_window_p                                          \
1065       && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (W)))             \
1066       && !NILP (XBUFFER ((W)->buffer)->header_line_format))
1067
1068 \f
1069 /***********************************************************************
1070                                 Faces
1071  ***********************************************************************/
1072
1073 /* Indices of face attributes in Lisp face vectors.  Slot zero is the
1074    symbol `face'.  */
1075
1076 enum lface_attribute_index
1077 {
1078   LFACE_FAMILY_INDEX = 1,
1079   LFACE_SWIDTH_INDEX,
1080   LFACE_HEIGHT_INDEX,
1081   LFACE_WEIGHT_INDEX,
1082   LFACE_SLANT_INDEX,
1083   LFACE_UNDERLINE_INDEX,
1084   LFACE_INVERSE_INDEX,
1085   LFACE_FOREGROUND_INDEX,
1086   LFACE_BACKGROUND_INDEX,
1087   LFACE_STIPPLE_INDEX,
1088   LFACE_OVERLINE_INDEX,
1089   LFACE_STRIKE_THROUGH_INDEX,
1090   LFACE_BOX_INDEX,
1091   LFACE_VECTOR_SIZE
1092 };
1093
1094
1095 /* Box types of faces.  */
1096
1097 enum face_box_type
1098 {
1099   /* No box around text.  */
1100   FACE_NO_BOX,
1101
1102   /* Simple box of specified width and color.  Default width is 1, and
1103      default color is the foreground color of the face.  */
1104   FACE_SIMPLE_BOX,
1105
1106   /* Boxes with 3D shadows.  Color equals the background color of the
1107      face.  Width is specified.  */
1108   FACE_RAISED_BOX,
1109   FACE_SUNKEN_BOX
1110 };
1111
1112
1113 /* Structure describing a realized face.
1114
1115    For each Lisp face, 0..N realized faces can exist for different
1116    frames and different charsets.  Realized faces are built from Lisp
1117    faces and text properties/overlays by merging faces and adding
1118    unspecified attributes from the `default' face.  */
1119
1120 struct face
1121 {
1122   /* The id of this face.  The id equals the index of this face in the
1123      vector faces_by_id of its face cache.  */
1124   int id;
1125
1126 #ifdef HAVE_WINDOW_SYSTEM
1127
1128   /* If non-zero, a GC we can use without modification to draw
1129      characters in this face.  */
1130   GC gc;
1131
1132   /* Font used for this face, or null if the font could not be loaded
1133      for some reason.  This points to a `font' slot of a struct
1134      font_info, and we should not call XFreeFont on it because the
1135      font may still be used somewhere else.  */
1136   XFontStruct *font;
1137
1138   /* Background stipple or bitmap used for this face.  */
1139   Pixmap stipple;
1140
1141 #else /* not HAVE_WINDOW_SYSTEM */
1142
1143   /* Dummy.  */
1144   int stipple;
1145
1146 #endif /* not HAVE_WINDOW_SYSTEM */
1147
1148   /* Pixel value of foreground color for X frames.  Color index
1149      for tty frames.  */
1150   unsigned long foreground;
1151
1152   /* Pixel value or color index of background color.  */
1153   unsigned long background;
1154
1155   /* Pixel value or color index of underline color.  */
1156   unsigned long underline_color;
1157
1158   /* Pixel value or color index of overlined, strike-through, or box
1159      color.  */
1160   unsigned long overline_color;
1161   unsigned long strike_through_color;
1162   unsigned long box_color;
1163
1164   /* The font's name.  This points to a `name' of a font_info, and it
1165      must not be freed.  */
1166   char *font_name;
1167
1168   /* The X font registry and encoding of font_name.  */
1169   Lisp_Object registry;
1170
1171   /* Font info ID for this face's font.  An ID is stored here because
1172      pointers to font_info structures may change.  The reason is that
1173      they are pointers into a font table vector that is itself
1174      reallocated.  */
1175   int font_info_id;
1176
1177   /* Fontset ID if this face uses a fontset, or -1.  This is only >= 0
1178      if the face was realized for CHARSET_COMPOSITION.  For all other
1179      charsets, a specific font is loaded from the set of fonts
1180      specified by the fontset given by the family attribute of the face.  */
1181   int fontset;
1182
1183   /* Pixmap width and height.  */
1184   unsigned int pixmap_w, pixmap_h;
1185
1186   /* Non-zero means characters in this face have a box that thickness
1187      around them.  */
1188   int box_line_width;
1189
1190   /* Type of box drawn.  A value of FACE_NO_BOX means no box is drawn
1191      around text in this face.  A value of FACE_SIMPLE_BOX means a box
1192      of width box_line_width is drawn in color box_color.  A value of
1193      FACE_RAISED_BOX or FACE_SUNKEN_BOX means a 3D box is drawn with
1194      shadow colors derived from the background color of the face.  */
1195   enum face_box_type box;
1196
1197   /* If `box' above specifies a 3D type, 1 means use box_color for
1198      drawing shadows.  */
1199   unsigned use_box_color_for_shadows_p : 1;
1200
1201   /* The Lisp face attributes this face realizes.  All attributes
1202      in this vector are non-nil.  */
1203   Lisp_Object lface[LFACE_VECTOR_SIZE];
1204
1205   /* The hash value of this face.  */
1206   unsigned hash;
1207
1208   /* The charset for which this face was realized if it was realized
1209      for use in multibyte text.  If fontset >= 0, this is
1210      CHARSET_COMPOSITION.  A value of charset < 0 means the face was
1211      realized for use in unibyte text where the idea of Emacs
1212      charsets isn't applicable.  */
1213   int charset;
1214
1215   /* Non-zero if text in this face should be underlined, overlined,
1216      strike-through or have a box drawn around it.  */
1217   unsigned underline_p : 1;
1218   unsigned overline_p : 1;
1219   unsigned strike_through_p : 1;
1220
1221   /* 1 means that the colors specified for this face could not be
1222      loaded, and were replaced by default colors, so they shouldn't be
1223      freed.  */
1224   unsigned foreground_defaulted_p : 1;
1225   unsigned background_defaulted_p : 1;
1226
1227   /* 1 means that either no color is specified for underlining or that
1228      the the specified color couldn't be loaded.  Use the foreground
1229      color when drawing in that case. */
1230   unsigned underline_defaulted_p : 1;
1231
1232   /* 1 means that either no color is specified for the corresponding
1233      attribute or that the the specified color couldn't be loaded.
1234      Use the foreground color when drawing in that case. */
1235   unsigned overline_color_defaulted_p : 1;
1236   unsigned strike_through_color_defaulted_p : 1;
1237   unsigned box_color_defaulted_p : 1;
1238
1239   /* TTY appearances.  Blinking is not yet implemented.  Colors are
1240      found in `lface' with empty color string meaning the default
1241      color of the TTY.  */
1242   unsigned tty_bold_p : 1;
1243   unsigned tty_dim_p : 1;
1244   unsigned tty_underline_p : 1;
1245   unsigned tty_alt_charset_p : 1;
1246   unsigned tty_reverse_p : 1;
1247   unsigned tty_blinking_p : 1;
1248
1249   /* Next and previous face in hash collision list of face cache.  */
1250   struct face *next, *prev;
1251 };
1252
1253
1254 /* Color index indicating that face uses a terminal's default color.  */
1255
1256 #define FACE_TTY_DEFAULT_COLOR ((unsigned long) -1)
1257
1258 /* Non-zero if FACE was realized for unibyte use.  */
1259
1260 #define FACE_UNIBYTE_P(FACE) ((FACE)->charset < 0)
1261
1262
1263 /* IDs of important faces known by the C face code.  These are the IDs
1264    of the faces for CHARSET_ASCII.  */
1265
1266 enum face_id
1267 {
1268   DEFAULT_FACE_ID,
1269   MODE_LINE_FACE_ID,
1270   TOOL_BAR_FACE_ID,
1271   BITMAP_AREA_FACE_ID,
1272   HEADER_LINE_FACE_ID,
1273   SCROLL_BAR_FACE_ID,
1274   BORDER_FACE_ID,
1275   CURSOR_FACE_ID,
1276   MOUSE_FACE_ID,
1277   MENU_FACE_ID,
1278   BASIC_FACE_ID_SENTINEL
1279 };
1280
1281
1282 /* A cache of realized faces.  Each frame has its own cache because
1283    Emacs allows different frame-local face definitions.  */
1284
1285 struct face_cache
1286 {
1287   /* Hash table of cached realized faces.  */
1288   struct face **buckets;
1289
1290   /* Back-pointer to the frame this cache belongs to.  */
1291   struct frame *f;
1292
1293   /* A vector of faces so that faces can be referenced by an ID.  */
1294   struct face **faces_by_id;
1295
1296   /* The allocated size, and number of used slots of faces_by_id.  */
1297   int size, used;
1298 };
1299
1300
1301 /* Prepare face FACE for use on frame F.  This must be called before
1302    using X resources of FACE.  */
1303
1304 #define PREPARE_FACE_FOR_DISPLAY(F, FACE)       \
1305      if ((FACE)->gc == 0)                       \
1306        prepare_face_for_display ((F), (FACE));  \
1307      else                                       \
1308        (void) 0
1309
1310 /* Return a pointer to the face with ID on frame F, or null if such a
1311    face doesn't exist.  */
1312
1313 #define FACE_FROM_ID(F, ID)                             \
1314      (((ID) >= 0 && (ID) < FRAME_FACE_CACHE (F)->used)  \
1315       ? FRAME_FACE_CACHE (F)->faces_by_id[ID]           \
1316       : NULL)
1317
1318 /* Non-zero if FACE is suitable for displaying characters of CHARSET.
1319    CHARSET < 0 means unibyte text.  */
1320
1321 #define FACE_SUITABLE_FOR_CHARSET_P(FACE, CHARSET)                      \
1322      (((CHARSET) < 0                                                    \
1323        ? (EQ ((FACE)->registry, Vface_default_registry)                 \
1324           || !NILP (Fequal ((FACE)->registry, Vface_default_registry))) \
1325        : ((FACE)->charset == (CHARSET)                                  \
1326           || ((FACE)->charset == CHARSET_ASCII                          \
1327               && (CHARSET) == charset_latin_iso8859_1                   \
1328               && face_suitable_for_iso8859_1_p ((FACE)))                \
1329           || ((FACE)->charset == charset_latin_iso8859_1                \
1330               && (CHARSET) == CHARSET_ASCII))))
1331
1332 /* Return the id of the realized face on frame F that is like the face
1333    with id ID but is suitable for displaying characters of CHARSET.
1334    This macro is only meaningful for CHARSET >= 0, i.e. multibyte
1335    text.  */
1336
1337 #define FACE_FOR_CHARSET(F, ID, CHARSET)                                \
1338      (FACE_SUITABLE_FOR_CHARSET_P (FACE_FROM_ID ((F), (ID)), (CHARSET)) \
1339       ? (ID)                                                            \
1340       : lookup_face ((F), FACE_FROM_ID ((F), (ID))->lface, (CHARSET)))
1341
1342 /* The default registry and encoding to use.  */
1343
1344 extern Lisp_Object Vface_default_registry;
1345
1346 /* Non-zero means face attributes have been changed since the last
1347    redisplay.  Used in redisplay_internal.  */
1348
1349 extern int face_change_count;
1350
1351
1352
1353 \f
1354 /***********************************************************************
1355                             Display Iterator
1356  ***********************************************************************/
1357
1358 /* Iteration over things to display in current_buffer or in a string.
1359
1360    The iterator handles:
1361
1362    1. Overlay strings (after-string, before-string).
1363    2. Face properties.
1364    3. Invisible text properties.
1365    4. Selective display.
1366    5. Translation of characters via display tables.
1367    6. Translation of control characters to the forms `\003' or `^C'.
1368    7. `glyph' and `space-width' properties.
1369
1370    Iterators are initialized by calling init_iterator or one of the
1371    equivalent functions below.  A call to get_next_display_element
1372    loads the iterator structure with information about what next to
1373    display.  A call to set_iterator_to_next increments the iterator's
1374    position.
1375
1376    Characters from overlay strings, display table entries or control
1377    character translations are returned one at a time.  For example, if
1378    we have a text of `a\x01' where `a' has a display table definition
1379    of `cd' and the control character is displayed with a leading
1380    arrow, then the iterator will return:
1381
1382    Call         Return  Source          Call next
1383    -----------------------------------------------------------------
1384    next         c       display table   move
1385    next         d       display table   move
1386    next         ^       control char    move
1387    next         A       control char    move
1388
1389    The same mechanism is also used to return characters for ellipses
1390    displayed at the end of invisible text.
1391
1392    CAVEAT: Under some circumstances, move_.* functions can be called
1393    asynchronously, e.g. when computing a buffer position from an x and
1394    y pixel position.  This means that these functions and functions
1395    called from them SHOULD NOT USE xmalloc and alike.  See also the
1396    comment at the start of xdisp.c.  */
1397
1398 /* Enumeration describing what kind of display element an iterator is
1399    loaded with after a call to get_next_display_element.  */
1400
1401 enum display_element_type
1402 {
1403   /* A normal character.  */
1404   IT_CHARACTER,
1405
1406   /* An image.  */
1407   IT_IMAGE,
1408
1409   /* A flexible width and height space.  */
1410   IT_STRETCH,
1411
1412   /* End of buffer or string.  */
1413   IT_EOB,
1414
1415   /* Truncation glyphs.  Never returned by get_next_display_element.
1416      Used to get display information about truncation glyphs via
1417      produce_glyphs.  */
1418   IT_TRUNCATION,
1419
1420   /* Continuation glyphs.  See the comment for IT_TRUNCATION.  */
1421   IT_CONTINUATION
1422 };
1423
1424
1425 /* An enumerator for each text property that has a meaning for display
1426    purposes.  */
1427
1428 enum prop_idx
1429 {
1430   FONTIFIED_PROP_IDX,
1431   FACE_PROP_IDX,
1432   INVISIBLE_PROP_IDX,
1433   DISPLAY_PROP_IDX,
1434
1435   /* Not a property.  Used to indicate changes in overlays.  */
1436   OVERLAY_PROP_IDX,
1437
1438   /* Sentinel.  */
1439   LAST_PROP_IDX
1440 };
1441
1442
1443 struct it
1444 {
1445   /* The window in which we iterate over current_buffer (or a string).  */
1446   Lisp_Object window;
1447   struct window *w;
1448
1449   /* The window's frame.  */
1450   struct frame *f;
1451
1452   /* Function to call to load this structure with the next display
1453      element.  */
1454   int (* method) P_ ((struct it *it));
1455
1456   /* The next position at which to check for face changes, invisible
1457      text, overlay strings, end of text etc., which see.  */
1458   int stop_charpos;
1459
1460   /* Maximum string or buffer position + 1.  ZV when iterating over
1461      current_buffer.  */
1462   int end_charpos;
1463
1464   /* C string to iterate over.  Non-null means get characters from
1465      this string, otherwise characters are read from current_buffer
1466      or it->string.  */
1467   unsigned char *s;
1468
1469   /* Number of characters in the string (s, or it->string) we iterate
1470      over.  */
1471   int string_nchars;
1472
1473   /* Start and end of a visible region; -1 if the region is not
1474      visible in the window.  */
1475   int region_beg_charpos, region_end_charpos;
1476
1477   /* Position at which redisplay end trigger functions should be run.  */
1478   int redisplay_end_trigger_charpos;
1479
1480   /* 1 means multibyte characters are enabled.  */
1481   unsigned multibyte_p : 1;
1482
1483   /* 1 means window has a mode line at its top.  */
1484   unsigned header_line_p : 1;
1485
1486   /* 1 means `string' is the value of a `display' property.
1487      Don't handle some `display' properties in these strings.  */
1488   unsigned string_from_display_prop_p : 1;
1489
1490   /* Display table in effect or null for none.  */
1491   struct Lisp_Char_Table *dp;
1492
1493   /* Current display table vector to return characters from and its
1494      end.  dpvec null means we are not returning characters from a
1495      display table entry; current.dpvec_index gives the current index
1496      into dpvec.  This same mechanism is also used to return
1497      characters from translated control characters, i.e. `\003' or
1498      `^C'.  */
1499   Lisp_Object *dpvec, *dpend;
1500
1501   /* Length in bytes of the char that filled dpvec.  A value of zero
1502      means that no character such character is involved.  */
1503   int dpvec_char_len;
1504
1505   /* Face id of the iterator saved in case a glyph from dpvec contains
1506      a face.  The face is restored when all glyphs from dpvec have
1507      been delivered.  */
1508   int saved_face_id;
1509
1510   /* Vector of glyphs for control character translation.  The pointer
1511      dpvec is set to ctl_chars when a control character is translated.
1512      This vector is also used for incomplete multibyte character
1513      translation (e.g \222\244).  Such a character is at most 3 bytes,
1514      thus we need at most 12 bytes here.  */
1515   Lisp_Object ctl_chars[12];
1516
1517   /* Current buffer or string position of the iterator, including
1518      position in overlay strings etc.  */
1519   struct display_pos current;
1520
1521   /* Vector of overlays to process.  Overlay strings are processed
1522      OVERLAY_STRING_CHUNK_SIZE at a time.  */
1523 #define OVERLAY_STRING_CHUNK_SIZE 3
1524   Lisp_Object overlay_strings[OVERLAY_STRING_CHUNK_SIZE];
1525
1526   /* Total number of overlay strings to process.  This can be >
1527      OVERLAY_STRING_CHUNK_SIZE.  */
1528   int n_overlay_strings;
1529
1530   /* If non-nil, a Lisp string being processed.  If
1531      current.overlay_string_index >= 0, this is an overlay string from
1532      pos.  */
1533   Lisp_Object string;
1534
1535   /* Stack of saved values.  New entries are pushed when we begin to
1536      process an overlay string or a string from a `glyph' property.
1537      Entries are popped when we return to deliver display elements
1538      from what we previously had.  */
1539   struct iterator_stack_entry
1540   {
1541     int stop_charpos;
1542     int face_id;
1543     Lisp_Object string;
1544     struct display_pos pos;
1545     int end_charpos;
1546     int string_nchars;
1547     enum glyph_row_area area;
1548     unsigned multibyte_p : 1;
1549     unsigned string_from_display_prop_p : 1;
1550     Lisp_Object space_width;
1551     short voffset;
1552     Lisp_Object font_height;
1553   }
1554   stack[2];
1555
1556   /* Stack pointer.  */
1557   int sp;
1558
1559   /* Setting of buffer-local variable selective-display-ellipsis.  */
1560   unsigned selective_display_ellipsis_p : 1;
1561
1562   /* 1 means control characters are translated into the form `^C'
1563      where the `^' can be replaced by a display table entry.  */
1564   unsigned ctl_arrow_p : 1;
1565
1566   /* -1 means selective display hides everything between a \r and the
1567      next newline; > 0 means hide lines indented more than that value.  */
1568   int selective;
1569
1570   /* An enumeration describing what the next display element is
1571      after a call to get_next_display_element.  */
1572   enum display_element_type what;
1573
1574   /* Face to use.  */
1575   int face_id;
1576
1577   /* Non-zero means that the current face has a box.  */
1578   unsigned face_box_p : 1;
1579
1580   /* Non-null means that the current character is the first in a run
1581      of characters with box face.  */
1582   unsigned start_of_box_run_p : 1;
1583
1584   /* Non-zero means that the current character is the last in a run
1585      of characters with box face.  */
1586   unsigned end_of_box_run_p : 1;
1587
1588   /* 1 means overlay strings at end_charpos have been processed.  */
1589   unsigned overlay_strings_at_end_processed_p : 1;
1590
1591   /* The ID of the default face to use.  One of DEFAULT_FACE_ID,
1592      MODE_LINE_FACE_ID, or TOOL_BAR_FACE_ID, depending on what we
1593      are displaying.  */
1594   int base_face_id;
1595
1596   /* If what == IT_CHARACTER, character and length in bytes.  This is
1597      a character from a buffer or string.  It may be different from
1598      the character displayed in case that
1599      unibyte_display_via_language_environment is set.  */
1600   int c, len;
1601
1602   /* The character to display, possibly translated to multibyte
1603      if unibyte_display_via_language_environment is set.  This
1604      is set after x_produce_glyphs has been called.  */
1605   int char_to_display;
1606
1607   /* Charset for which face_id was computed.  This is the charset
1608      of char_to_display after x_produce_glyphs has been called.  */
1609   int charset;
1610
1611   /* If what == IT_IMAGE, the id of the image to display.  */
1612   int image_id;
1613
1614   /* Value of the `space-width' property, if any; nil if none.  */
1615   Lisp_Object space_width;
1616
1617   /* Computed from the value of the `raise' property.  */
1618   short voffset;
1619
1620   /* Value of the `height' property, if any; nil if none.  */
1621   Lisp_Object font_height;
1622
1623   /* Object and position where the current display element came from.
1624      Object can be a Lisp string in case the current display element
1625      comes from an overlay string, or it is buffer.  Position is
1626      a position in object.  */
1627   Lisp_Object object;
1628   struct text_pos position;
1629
1630   /* 1 means lines are truncated.  */
1631   unsigned truncate_lines_p : 1;
1632
1633   /* Number of columns per \t.  */
1634   short tab_width;
1635
1636   /* Width in pixels of truncation and continuation glyphs.  */
1637   short truncation_pixel_width, continuation_pixel_width;
1638
1639   /* First and last visible x-position in the display area.  If window
1640      is hscrolled by n columns, first_visible_x == n * CANON_X_UNIT
1641      (f), and last_visible_x == pixel width of W + first_visible_x.  */
1642   int first_visible_x, last_visible_x;
1643
1644   /* Last visible y-position + 1 in the display area without a mode
1645      line, if the window has one.  */
1646   int last_visible_y;
1647
1648   /* Width of a prompt in front of the line.  Used to perform tab
1649      calculations.  The x on which tab calculations are based is
1650      current_x - prompt_width + continuation_lines_width.  */
1651   int prompt_width;
1652
1653   /* If non-null, glyphs are produced in glyph_row with each call to
1654      produce_glyphs.  */
1655   struct glyph_row *glyph_row;
1656
1657   /* The area of glyph_row to which glyphs are added.  */
1658   enum glyph_row_area area;
1659
1660   /* Number of glyphs needed for the last character requested via
1661      produce_glyphs.  This is 1 except for tabs.  */
1662   int nglyphs;
1663
1664   /* Width of the display element in pixels.  Result of
1665      produce_glyphs.  */
1666   int pixel_width;
1667
1668   /* Current, maximum logical, and maximum physical line height
1669      information.  Result of produce_glyphs.  */
1670   int ascent, descent, max_ascent, max_descent;
1671   int phys_ascent, phys_descent, max_phys_ascent, max_phys_descent;
1672
1673   /* Current x pixel position within the display line.  This value
1674      does not include the width of continuation lines in front of the
1675      line.  The value of current_x is automatically incremented by
1676      pixel_width with each call to produce_glyphs.  */
1677   int current_x;
1678
1679   /* Accumulated width of continuation lines.  If > 0, this means we
1680      are currently in a continuation line.  This is initially zero and
1681      incremented/reset by display_line, move_it_to etc.  */
1682   int continuation_lines_width;
1683
1684   /* Current y-position.  Automatically incremented by the height of
1685      glyph_row in move_it_to and display_line.  */
1686   int current_y;
1687
1688   /* Current vertical matrix position, or line number.  Automatically
1689      incremented by move_it_to and display_line.  */
1690   int vpos;
1691
1692   /* Horizontal matrix position reached in move_it_in_display_line.
1693      Only set there, not in display_line.  */
1694   int hpos;
1695 };
1696
1697
1698 /* Access to positions of iterator IT.  */
1699
1700 #define IT_CHARPOS(IT)          CHARPOS ((IT).current.pos)
1701 #define IT_BYTEPOS(IT)          BYTEPOS ((IT).current.pos)
1702 #define IT_STRING_CHARPOS(IT)   CHARPOS ((IT).current.string_pos)
1703 #define IT_STRING_BYTEPOS(IT)   BYTEPOS ((IT).current.string_pos)
1704
1705 /* Test if IT has reached the end of its buffer or string.  This will
1706    only work after get_next_display_element has been called.  */
1707
1708 #define ITERATOR_AT_END_P(IT) ((IT)->what == IT_EOB)
1709
1710 /* Non-zero means IT is at the end of a line.  This is the case if it
1711    is either on a newline or on a carriage return and selective
1712    display hides the rest of the line.  */
1713
1714 #define ITERATOR_AT_END_OF_LINE_P(IT)                   \
1715      ((IT)->what == IT_CHARACTER                        \
1716       && ((IT)->c == '\n'                               \
1717           || ((IT)->c == '\r' && (IT)->selective)))
1718
1719 /* Call produce_glyphs or produce_glyphs_hook, if set.  Shortcut to
1720    avoid the function call overhead.  */
1721
1722 #define PRODUCE_GLYPHS(IT)                      \
1723      (rif                                       \
1724       ? rif->produce_glyphs ((IT))              \
1725       : produce_glyphs ((IT)))
1726
1727 /* Bit-flags indicating what operation move_it_to should perform.  */
1728
1729 enum move_operation_enum
1730 {
1731   /* Stop if specified x-position is reached.  */
1732   MOVE_TO_X = 0x01,
1733
1734   /* Stop if specified y-position is reached.  */
1735   MOVE_TO_Y = 0x02,
1736
1737   /* Stop if specified vpos is reached.  */
1738   MOVE_TO_VPOS = 0x04,
1739
1740   /* Stop if specified buffer or string position is reached.  */
1741   MOVE_TO_POS = 0x08
1742 };
1743
1744
1745 \f
1746 /***********************************************************************
1747                    Window-based redisplay interface
1748  ***********************************************************************/
1749
1750 /* Structure used to describe runs of lines that must be scrolled.  */
1751
1752 struct run
1753 {
1754   /* Source and destination y pixel position.  */
1755   int desired_y, current_y;
1756
1757   /* Source and destination vpos in matrix.  */
1758   int desired_vpos, current_vpos;
1759
1760   /* Height in pixels, number of glyph rows.  */
1761   int height, nrows;
1762 };
1763
1764
1765 /* Structure holding system-dependent interface functions needed
1766    for window-based redisplay.  */
1767
1768 struct redisplay_interface
1769 {
1770   /* Produce glyphs/get display metrics for the display element IT is
1771      loaded with.  */
1772   void (*produce_glyphs) P_ ((struct it *it));
1773
1774   /* Write or insert LEN glyphs from STRING at the nominal output
1775      position.  */
1776   void (*write_glyphs) P_ ((struct glyph *string, int len));
1777   void (*insert_glyphs) P_ ((struct glyph *start, int len));
1778
1779   /* Clear from nominal output position to X.  X < 0 means clear
1780      to right end of display.  */
1781   void (*clear_end_of_line) P_ ((int x));
1782
1783   /* Function to call to scroll the display as described by RUN on
1784      window W.  */
1785   void (*scroll_run_hook) P_ ((struct window *w, struct run *run));
1786
1787   /* Function to call after a line in a display has been completely
1788      updated.  Used to draw truncation marks and alike.  DESIRED_ROW
1789      is the desired row which has been updated.  */
1790   void (*after_update_window_line_hook) P_ ((struct glyph_row *desired_row));
1791
1792   /* Function to call before beginning to update window W in
1793      window-based redisplay.  */
1794   void (*update_window_begin_hook) P_ ((struct window *w));
1795
1796   /* Function to call after window W has been updated in window-based
1797      redisplay.  CURSOR_ON_P non-zero means switch cursor on.  */
1798   void (*update_window_end_hook) P_ ((struct window *w, int cursor_on_p));
1799
1800   /* Move cursor to row/column position VPOS/HPOS, pixel coordinates
1801      Y/X. HPOS/VPOS are window-relative row and column numbers and X/Y
1802      are window-relative pixel positions.  */
1803   void (*cursor_to) P_ ((int vpos, int hpos, int y, int x));
1804
1805   /* Flush the display of frame F.  For X, this is XFlush.  */
1806   void (*flush_display) P_ ((struct frame *f));
1807
1808   /* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
1809      frame F.  */
1810   void (*get_glyph_overhangs) P_ ((struct glyph *glyph, struct frame *f,
1811                                    int *left, int *right));
1812
1813   /* Fix the display of AREA of ROW in window W for overlapping rows.
1814      This function is called from redraw_overlapping_rows after
1815      desired rows have been made current.  */
1816   void (*fix_overlapping_area) P_ ((struct window *w, struct glyph_row *row,
1817                                     enum glyph_row_area area));
1818 };
1819
1820 /* The current interface for window-based redisplay.  */
1821
1822 extern struct redisplay_interface *rif;
1823
1824 /* Hook to call in estimate_mode_line_height.  */
1825
1826 extern int (* estimate_mode_line_height_hook) P_ ((struct frame *,
1827                                                    enum face_id));
1828
1829 \f
1830 /***********************************************************************
1831                                 Images
1832  ***********************************************************************/
1833
1834 #ifdef HAVE_X_WINDOWS
1835
1836 /* Structure forward declarations.  */
1837
1838 struct image;
1839
1840
1841 /* Each image format (JPEG, IIFF, ...) supported is described by
1842    a structure of the type below.  */
1843
1844 struct image_type
1845 {
1846   /* A symbol uniquely identifying the image type, .e.g `jpeg'.  */
1847   Lisp_Object *type;
1848
1849   /* Check that SPEC is a valid image specification for the given
1850      image type.  Value is non-zero if SPEC is valid.  */
1851   int (* valid_p) P_ ((Lisp_Object spec));
1852
1853   /* Load IMG which is used on frame F from information contained in
1854      IMG->spec.  Value is non-zero if successful.  */
1855   int (* load) P_ ((struct frame *f, struct image *img));
1856
1857   /* Free resources of image IMG which is used on frame F.  */
1858   void (* free) P_ ((struct frame *f, struct image *img));
1859
1860   /* Next in list of all supported image types.  */
1861   struct image_type *next;
1862 };
1863
1864
1865 /* Structure describing an image.  Specific image formats like XBM are
1866    converted into this form, so that display only has to deal with
1867    this type of image.  */
1868
1869 struct image
1870 {
1871   /* The time in seconds at which the image was last displayed.  Set
1872      in prepare_image_for_display.  */
1873   unsigned long timestamp;
1874
1875   /* Pixmaps of the image.  */
1876   Pixmap pixmap, mask;
1877
1878   /* Colors allocated for this image, if any.  Allocated via xmalloc.  */
1879   unsigned long *colors;
1880   int ncolors;
1881
1882   /* Width and height of the image.  */
1883   int width, height;
1884
1885   /* These values are used for the rectangles displayed for images
1886      that can't be loaded.  */
1887 #define DEFAULT_IMAGE_WIDTH 30
1888 #define DEFAULT_IMAGE_HEIGHT 30
1889
1890   /* Percent of image height used as ascent.  */
1891   int ascent;
1892 #define DEFAULT_IMAGE_ASCENT 50
1893
1894   /* Lisp specification of this image.  */
1895   Lisp_Object spec;
1896
1897   /* Relief to draw around the image.  */
1898   int relief;
1899
1900   /* Optional margin around the image.  This includes the relief.  */
1901   int margin;
1902
1903   /* Reference to the type of the image.  */
1904   struct image_type *type;
1905
1906   /* 1 means that loading the image failed.  Don't try again.  */
1907   unsigned load_failed_p;
1908
1909   /* A place for image types to store additional data.  The member
1910      data.lisp_val is marked during GC, so it's safe to store Lisp data
1911      there.  Image types should free this data when their `free'
1912      function is called.  */
1913   struct
1914   {
1915     int int_val;
1916     void *ptr_val;
1917     Lisp_Object lisp_val;
1918   } data;
1919
1920   /* Hash value of image specification to speed up comparisons.  */
1921   unsigned hash;
1922
1923   /* Image id of this image.  */
1924   int id;
1925
1926   /* Hash collision chain.  */
1927   struct image *next, *prev;
1928 };
1929
1930
1931 /* Cache of images.  Each frame has a cache.  X frames with the same
1932    x_display_info share their caches.  */
1933
1934 struct image_cache
1935 {
1936   /* Hash table of images.  */
1937   struct image **buckets;
1938
1939   /* Vector mapping image ids to images.  */
1940   struct image **images;
1941
1942   /* Allocated size of `images'.  */
1943   unsigned size;
1944
1945   /* Number of images in the cache.  */
1946   unsigned used;
1947
1948   /* Reference count (number of frames sharing this cache).  */
1949   int refcount;
1950 };
1951
1952
1953 /* Value is the ascent of image IMG.  */
1954
1955 #define IMAGE_ASCENT(IMG) \
1956      (((IMG)->height + (IMG)->margin) * (IMG)->ascent / 100.0)
1957
1958 /* Value is a pointer to the image with id ID on frame F, or null if
1959    no image with that id exists.  */
1960
1961 #define IMAGE_FROM_ID(F, ID)                                    \
1962      (((ID) >= 0 && (ID) < (FRAME_X_IMAGE_CACHE (F)->used))     \
1963       ? FRAME_X_IMAGE_CACHE (F)->images[ID]                     \
1964       : NULL)
1965
1966 /* Size of bucket vector of image caches.  Should be prime.  */
1967
1968 #define IMAGE_CACHE_BUCKETS_SIZE 1001
1969
1970 #endif /* HAVE_X_WINDOWS */
1971
1972
1973 \f
1974 /***********************************************************************
1975                                Tool-bars
1976  ***********************************************************************/
1977
1978 /* Enumeration defining where to find tool-bar item information in
1979    tool-bar items vectors stored with frames.  Each tool-bar item
1980    occupies TOOL_BAR_ITEM_NSLOTS elements in such a vector.  */
1981
1982 enum tool_bar_item_idx
1983 {
1984   /* The key of the tool-bar item.  Used to remove items when a binding
1985      for `undefined' is found.  */
1986   TOOL_BAR_ITEM_KEY,
1987
1988   /* Non-nil if item is enabled.  */
1989   TOOL_BAR_ITEM_ENABLED_P,
1990
1991   /* Non-nil if item is selected (pressed).  */
1992   TOOL_BAR_ITEM_SELECTED_P,
1993
1994   /* Caption.  */
1995   TOOL_BAR_ITEM_CAPTION,
1996
1997   /* Image(s) to display.  This is either a single image specification
1998      or a vector of specifications.  */
1999   TOOL_BAR_ITEM_IMAGES,
2000
2001   /* The binding.  */
2002   TOOL_BAR_ITEM_BINDING,
2003
2004   /* Button type.  One of nil, `:radio' or `:toggle'.  */
2005   TOOL_BAR_ITEM_TYPE,
2006
2007   /* Help string.  */
2008   TOOL_BAR_ITEM_HELP,
2009
2010   /* Sentinel = number of slots in tool_bar_items occupied by one
2011      tool-bar item.  */
2012   TOOL_BAR_ITEM_NSLOTS
2013 };
2014
2015
2016 /* An enumeration for the different images that can be specified
2017    for a tool-bar item.  */
2018
2019 enum tool_bar_item_image
2020 {
2021   TOOL_BAR_IMAGE_ENABLED_SELECTED,
2022   TOOL_BAR_IMAGE_ENABLED_DESELECTED,
2023   TOOL_BAR_IMAGE_DISABLED_SELECTED,
2024   TOOL_BAR_IMAGE_DISABLED_DESELECTED
2025 };
2026
2027 /* Non-zero means raise tool-bar buttons when the mouse moves over them.  */
2028
2029 extern int auto_raise_tool_bar_buttons_p;
2030
2031 /* Margin around tool-bar buttons in pixels.  */
2032
2033 extern int tool_bar_button_margin;
2034
2035 /* Thickness of relief to draw around tool-bar buttons.  */
2036
2037 extern int tool_bar_button_relief;
2038
2039
2040 \f
2041 /***********************************************************************
2042                          Function Prototypes
2043  ***********************************************************************/
2044
2045 /* Defined in xdisp.c */
2046
2047 void resize_echo_area_axactly P_ ((void));
2048 int resize_mini_window P_ ((struct window *, int));
2049 int try_window P_ ((Lisp_Object, struct text_pos));
2050 void window_box P_ ((struct window *, int, int *, int *, int *, int *));
2051 int window_box_height P_ ((struct window *));
2052 int window_text_bottom_y P_ ((struct window *));
2053 int window_box_width P_ ((struct window *, int));
2054 int window_box_left P_ ((struct window *, int));
2055 int window_box_right P_ ((struct window *, int));
2056 void window_box_edges P_ ((struct window *, int, int *, int *, int *, int *));
2057 void mark_window_display_accurate P_ ((Lisp_Object, int));
2058 void redisplay_preserve_echo_area P_ ((void));
2059 void set_cursor_from_row P_ ((struct window *, struct glyph_row *,
2060                               struct glyph_matrix *, int, int, int, int));
2061 void init_iterator P_ ((struct it *, struct window *, int,
2062                         int, struct glyph_row *, enum face_id));
2063 void init_iterator_to_row_start P_ ((struct it *, struct window *,
2064                                      struct glyph_row *));
2065 int get_next_display_element P_ ((struct it *));
2066 void set_iterator_to_next P_ ((struct it *));
2067 void produce_glyphs P_ ((struct it *));
2068 void produce_special_glyphs P_ ((struct it *, enum display_element_type));
2069 void start_display P_ ((struct it *, struct window *, struct text_pos));
2070 void move_it_to P_ ((struct it *, int, int, int, int, int));
2071 void move_it_vertically P_ ((struct it *, int));
2072 void move_it_by_lines P_ ((struct it *, int, int));
2073 int frame_mode_line_height P_ ((struct frame *));
2074 void highlight_trailing_whitespace P_ ((struct frame *, struct glyph_row *));
2075 int tool_bar_item_info P_ ((struct frame *, struct glyph *, int *));
2076 extern Lisp_Object Qtool_bar;
2077 extern Lisp_Object Vshow_trailing_whitespace;
2078 extern int redisplaying_p;
2079 extern void add_to_log P_ ((char *, Lisp_Object, Lisp_Object));
2080
2081 /* Defined in sysdep.c */
2082
2083 void get_frame_size P_ ((int *, int *));
2084 void request_sigio P_ ((void));
2085 void unrequest_sigio P_ ((void));
2086 int tabs_safe_p P_ ((void));
2087 void init_baud_rate P_ ((void));
2088 void init_sigio P_ ((int));
2089
2090 /* Defined in xfaces.c */
2091
2092 #ifdef USE_X_TOOLKIT
2093 void x_set_menu_resources_from_menu_face P_ ((struct frame *, Widget));
2094 #endif
2095
2096 void update_face_from_frame_parameter P_ ((struct frame *, Lisp_Object,
2097                                            Lisp_Object));
2098 char *x_charset_registry P_ ((int));
2099 void clear_face_cache P_ ((int));
2100 unsigned long load_color P_ ((struct frame *, struct face *, Lisp_Object,
2101                               enum lface_attribute_index));
2102 void unload_color P_ ((struct frame *, unsigned long));
2103 int frame_update_line_height P_ ((struct frame *));
2104 int ascii_face_of_lisp_face P_ ((struct frame *, int));
2105 void prepare_face_for_display P_ ((struct frame *, struct face *));
2106 int face_suitable_for_iso8859_1_p P_ ((struct face *));
2107 int xstricmp P_ ((unsigned char *, unsigned char *));
2108 int lookup_face P_ ((struct frame *, Lisp_Object *, int));
2109 int face_suitable_for_charset_p P_ ((struct face *, int));
2110 int lookup_named_face P_ ((struct frame *, Lisp_Object, int));
2111 int smaller_face P_ ((struct frame *, int, int));
2112 int face_with_height P_ ((struct frame *, int, int));
2113 int lookup_derived_face P_ ((struct frame *, Lisp_Object, int, int));
2114 void init_frame_faces P_ ((struct frame *));
2115 void free_frame_faces P_ ((struct frame *));
2116 void recompute_basic_faces P_ ((struct frame *));
2117 int face_at_buffer_position P_ ((struct window *, int, int, int, int *,
2118                                  int, int));
2119 int face_at_string_position P_ ((struct window *, Lisp_Object,
2120                                  int, int, int, int, int *, enum face_id));
2121 int compute_char_face P_ ((struct frame *, int, Lisp_Object));
2122 void free_all_realized_faces P_ ((Lisp_Object));
2123 extern Lisp_Object Qforeground_color, Qbackground_color;
2124
2125 /* Defined in xfns.c  */
2126
2127 #ifdef HAVE_X_WINDOWS
2128
2129 void gamma_correct P_ ((struct frame *, XColor *));
2130 void x_kill_gs_process P_ ((Pixmap, struct frame *));
2131 int x_screen_planes P_ ((struct frame *));
2132 void x_implicitly_set_name P_ ((struct frame *, Lisp_Object, Lisp_Object));
2133 struct image_cache *make_image_cache P_ ((void));
2134 void free_image_cache P_ ((struct frame *));
2135 void clear_image_cache P_ ((struct frame *, int));
2136 void forall_images_in_image_cache P_ ((struct frame *,
2137                                        void (*) P_ ((struct image *))));
2138 int valid_image_p P_ ((Lisp_Object));
2139 void prepare_image_for_display P_ ((struct frame *, struct image *));
2140 int lookup_image P_ ((struct frame *, Lisp_Object));
2141 extern struct frame *tip_frame;
2142 extern Window tip_window;
2143 EXFUN (Fx_show_tip, 4);
2144 EXFUN (Fx_hide_tip, 0);
2145 EXFUN (Fx_show_busy_cursor, 0);
2146 EXFUN (Fx_hide_busy_cursor, 1);
2147 extern int inhibit_busy_cursor;
2148 extern int display_busy_cursor_p;
2149
2150 #endif /* HAVE_X_WINDOWS */
2151
2152
2153 /* Defined in xmenu.c  */
2154
2155 int popup_activated P_ ((void));
2156
2157 /* Defined in dispnew.c  */
2158
2159 int estimate_mode_line_height P_ ((struct frame *, enum face_id));
2160 Lisp_Object mode_line_string P_ ((struct window *, int, int, int, int *));
2161 extern void redraw_frame P_ ((struct frame *));
2162 extern void redraw_garbaged_frames P_ ((void));
2163 extern void cancel_line P_ ((int, struct frame *));
2164 extern void init_desired_glyphs P_ ((struct frame *));
2165 extern int scroll_frame_lines P_ ((struct frame *, int, int, int, int));
2166 extern int direct_output_for_insert P_ ((int));
2167 extern int direct_output_forward_char P_ ((int));
2168 extern int update_frame P_ ((struct frame *, int, int));
2169 extern int scrolling P_ ((struct frame *));
2170 extern void bitch_at_user P_ ((void));
2171 void adjust_glyphs P_ ((struct frame *));
2172 void free_glyphs P_ ((struct frame *));
2173 void free_window_matrices P_ ((struct window *));
2174 void check_glyph_memory P_ ((void));
2175 void mirrored_line_dance P_ ((struct glyph_matrix *, int, int, int *, char *));
2176 void clear_glyph_matrix P_ ((struct glyph_matrix *));
2177 void clear_current_matrices P_ ((struct frame *f));
2178 void clear_desired_matrices P_ ((struct frame *));
2179 void shift_glyph_matrix P_ ((struct window *, struct glyph_matrix *,
2180                              int, int, int));
2181 void rotate_matrix P_ ((struct glyph_matrix *, int, int, int));
2182 void increment_glyph_matrix_buffer_positions P_ ((struct glyph_matrix *,
2183                                                   int, int, int, int));
2184 void blank_row P_ ((struct window *, struct glyph_row *, int));
2185 void increment_glyph_row_buffer_positions P_ ((struct glyph_row *, int, int));
2186 void enable_glyph_matrix_rows P_ ((struct glyph_matrix *, int, int, int));
2187 void clear_glyph_row P_ ((struct glyph_row *));
2188 void prepare_desired_row P_ ((struct glyph_row *));
2189 int line_hash_code P_ ((struct glyph_row *));
2190 void set_window_update_flags P_ ((struct window *, int));
2191 void write_glyphs P_ ((struct glyph *, int));
2192 void insert_glyphs P_ ((struct glyph *, int));
2193 void redraw_frame P_ ((struct frame *));
2194 void redraw_garbaged_frames P_ ((void));
2195 int scroll_cost P_ ((struct frame *, int, int, int));
2196 int direct_output_for_insert P_ ((int));
2197 int direct_output_forward_char P_ ((int));
2198 int update_frame P_ ((struct frame *, int, int));
2199 void update_single_window P_ ((struct window *, int));
2200 int scrolling P_ ((struct frame *));
2201 int buffer_posn_from_coords P_ ((struct window *, int *, int *));
2202 void do_pending_window_change P_ ((int));
2203 void change_frame_size P_ ((struct frame *, int, int, int, int, int));
2204 void bitch_at_user P_ ((void));
2205 Lisp_Object sit_for P_ ((int, int, int, int, int));
2206 void init_display P_ ((void));
2207 void syms_of_display P_ ((void));
2208
2209 /* Defined in term.c */
2210
2211 extern void ring_bell P_ ((void));
2212 extern void set_terminal_modes P_ ((void));
2213 extern void reset_terminal_modes P_ ((void));
2214 extern void update_begin P_ ((struct frame *));
2215 extern void update_end P_ ((struct frame *));
2216 extern void set_terminal_window P_ ((int));
2217 extern void set_scroll_region P_ ((int, int));
2218 extern void turn_off_insert P_ ((void));
2219 extern void turn_off_highlight P_ ((void));
2220 extern void background_highlight P_ ((void));
2221 extern void reassert_line_highlight P_ ((int, int));
2222 extern void clear_frame P_ ((void));
2223 extern void clear_end_of_line P_ ((int));
2224 extern void clear_end_of_line_raw P_ ((int));
2225 extern void delete_glyphs P_ ((int));
2226 extern void ins_del_lines P_ ((int, int));
2227 extern int string_cost P_ ((char *));
2228 extern int per_line_cost P_ ((char *));
2229 extern void calculate_costs P_ ((struct frame *));
2230 extern void term_init P_ ((char *));
2231 extern void fatal P_ ((/* char *, ... */));
2232 void cursor_to P_ ((int, int));
2233 void change_line_highlight P_ ((int, int, int, int));
2234
2235 /* Defined in scroll.c */
2236
2237 extern int scrolling_max_lines_saved P_ ((int, int, int *, int *, int *));
2238 extern int scroll_cost P_ ((struct frame *, int, int, int));
2239 extern void do_line_insertion_deletion_costs P_ ((struct frame *, char *,
2240                                                   char *, char *, char *,
2241                                                   char *, char *, int));
2242 void scrolling_1 P_ ((struct frame *, int, int, int, int *, int *, int *,
2243                       int *, int));
2244
2245 #endif /* not DISPEXTERN_H_INCLUDED */