src/dispextern.h

   1 /* Interface definitions for display code.
   2
   3 Copyright (C) 1985, 1993-1994, 1997-2014 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 3 of the License, or
  10 (at your option) 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.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* New redisplay written by Gerd Moellmann <gerd@gnu.org>.  */
  21
  22 #ifndef DISPEXTERN_H_INCLUDED
  23 #define DISPEXTERN_H_INCLUDED
  24
  25 #include "character.h"
  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 INLINE_HEADER_BEGIN
  52
  53 #include <c-strcase.h>
  54 INLINE int
  55 xstrcasecmp (char const *a, char const *b)
  56 {
  57   return c_strcasecmp (a, b);
  58 }
  59
  60 #ifdef HAVE_X_WINDOWS
  61 #include <X11/Xresource.h> /* for XrmDatabase */
  62 typedef struct x_display_info Display_Info;
  63 typedef XImage * XImagePtr;
  64 typedef XImagePtr XImagePtr_or_DC;
  65 #define NativeRectangle XRectangle
  66 #endif
  67
  68 #ifdef HAVE_NTGUI
  69 #include "w32gui.h"
  70 typedef struct w32_display_info Display_Info;
  71 typedef XImage *XImagePtr;
  72 typedef HDC XImagePtr_or_DC;
  73 #endif
  74
  75 #ifdef HAVE_NS
  76 #include "nsgui.h"
  77 /* Following typedef needed to accommodate the MSDOS port, believe it or not.  */
  78 typedef struct ns_display_info Display_Info;
  79 typedef Pixmap XImagePtr;
  80 typedef XImagePtr XImagePtr_or_DC;
  81 #endif
  82
  83 #ifdef HAVE_WINDOW_SYSTEM
  84 # include <time.h>
  85 #endif
  86
  87 #ifndef HAVE_WINDOW_SYSTEM
  88 typedef int Cursor;
  89 #define No_Cursor (0)
  90 #endif
  91
  92 #ifndef NativeRectangle
  93 #define NativeRectangle int
  94 #endif
  95
  96 /* Text cursor types.  */
  97
  98 enum text_cursor_kinds
  99 {
 100   DEFAULT_CURSOR = -2,
 101   NO_CURSOR = -1,
 102   FILLED_BOX_CURSOR,
 103   HOLLOW_BOX_CURSOR,
 104   BAR_CURSOR,
 105   HBAR_CURSOR
 106 };
 107
 108 /* Values returned from coordinates_in_window.  */
 109
 110 enum window_part
 111 {
 112   ON_NOTHING,
 113   ON_TEXT,
 114   ON_MODE_LINE,
 115   ON_VERTICAL_BORDER,
 116   ON_HEADER_LINE,
 117   ON_LEFT_FRINGE,
 118   ON_RIGHT_FRINGE,
 119   ON_LEFT_MARGIN,
 120   ON_RIGHT_MARGIN,
 121   ON_VERTICAL_SCROLL_BAR,
 122   ON_HORIZONTAL_SCROLL_BAR,
 123   ON_RIGHT_DIVIDER,
 124   ON_BOTTOM_DIVIDER
 125 };
 126
 127 /* Number of bits allocated to store fringe bitmap numbers.  */
 128 #define FRINGE_ID_BITS  16
 129
 130 /* Number of bits allocated to store fringe bitmap height.  */
 131 #define FRINGE_HEIGHT_BITS 8
 132
 133 \f
 134 /***********************************************************************
 135                               Debugging
 136  ***********************************************************************/
 137
 138 /* If GLYPH_DEBUG is defined, additional checks are activated.  */
 139
 140 /* Macros to include code only if GLYPH_DEBUG is defined.  */
 141
 142 #ifdef GLYPH_DEBUG
 143 #define IF_DEBUG(X)     ((void) (X))
 144 #else
 145 #define IF_DEBUG(X)     ((void) 0)
 146 #endif
 147
 148 /* Macro for displaying traces of redisplay.  If Emacs was compiled
 149    with GLYPH_DEBUG defined, the variable trace_redisplay_p can be set to
 150    a non-zero value in debugging sessions to activate traces.  */
 151
 152 #ifdef GLYPH_DEBUG
 153
 154 extern bool trace_redisplay_p EXTERNALLY_VISIBLE;
 155 #include <stdio.h>
 156
 157 #define TRACE(X)                                \
 158    do {                                         \
 159      if (trace_redisplay_p)                     \
 160        fprintf X;                               \
 161    } while (false)
 162
 163 #else /* not GLYPH_DEBUG */
 164
 165 #define TRACE(X)        ((void) 0)
 166
 167 #endif /* GLYPH_DEBUG */
 168
 169
 170 \f
 171 /***********************************************************************
 172                             Text positions
 173  ***********************************************************************/
 174
 175 /* Starting with Emacs 20.3, characters from strings and buffers have
 176    both a character and a byte position associated with them.  The
 177    following structure holds such a pair of positions.  */
 178
 179 struct text_pos
 180 {
 181   /* Character position.  */
 182   ptrdiff_t charpos;
 183
 184   /* Corresponding byte position.  */
 185   ptrdiff_t bytepos;
 186 };
 187
 188 /* Access character and byte position of POS in a functional form.  */
 189
 190 #define BYTEPOS(POS)    (POS).bytepos
 191 #define CHARPOS(POS)    (POS).charpos
 192
 193 /* Set character position of POS to CHARPOS, byte position to BYTEPOS.  */
 194
 195 #define SET_TEXT_POS(POS, CHARPOS, BYTEPOS) \
 196      ((POS).charpos = (CHARPOS), (POS).bytepos = BYTEPOS)
 197
 198 /* Increment text position POS.  */
 199
 200 #define INC_TEXT_POS(POS, MULTIBYTE_P)          \
 201      do                                         \
 202        {                                        \
 203          ++(POS).charpos;                       \
 204          if (MULTIBYTE_P)                       \
 205            INC_POS ((POS).bytepos);             \
 206          else                                   \
 207            ++(POS).bytepos;                     \
 208        }                                        \
 209      while (false)
 210
 211 /* Decrement text position POS.  */
 212
 213 #define DEC_TEXT_POS(POS, MULTIBYTE_P)          \
 214      do                                         \
 215        {                                        \
 216          --(POS).charpos;                       \
 217          if (MULTIBYTE_P)                       \
 218            DEC_POS ((POS).bytepos);             \
 219          else                                   \
 220            --(POS).bytepos;                     \
 221        }                                        \
 222      while (false)
 223
 224 /* Set text position POS from marker MARKER.  */
 225
 226 #define SET_TEXT_POS_FROM_MARKER(POS, MARKER)           \
 227   (CHARPOS (POS) = marker_position (MARKER),            \
 228    BYTEPOS (POS) = marker_byte_position (MARKER))
 229
 230 /* Like above, but clip POS within accessible range.  */
 231
 232 #define CLIP_TEXT_POS_FROM_MARKER(POS, MARKER)          \
 233   (CHARPOS (POS) = clip_to_bounds                       \
 234    (BEGV, marker_position (MARKER), ZV),                \
 235    BYTEPOS (POS) = clip_to_bounds                       \
 236    (BEGV_BYTE, marker_byte_position (MARKER), ZV_BYTE))
 237
 238 /* Set marker MARKER from text position POS.  */
 239
 240 #define SET_MARKER_FROM_TEXT_POS(MARKER, POS) \
 241      set_marker_both ((MARKER), Qnil, CHARPOS ((POS)), BYTEPOS ((POS)))
 242
 243 /* Value is non-zero if character and byte positions of POS1 and POS2
 244    are equal.  */
 245
 246 #define TEXT_POS_EQUAL_P(POS1, POS2)            \
 247      ((POS1).charpos == (POS2).charpos          \
 248       && (POS1).bytepos == (POS2).bytepos)
 249
 250 /* When rendering glyphs, redisplay scans string or buffer text,
 251    overlay strings in that text, and does display table or control
 252    character translations.  The following structure captures a
 253    position taking all this into account.  */
 254
 255 struct display_pos
 256 {
 257   /* Buffer or string position.  */
 258   struct text_pos pos;
 259
 260   /* If this is a position in an overlay string, overlay_string_index
 261      is the index of that overlay string in the sequence of overlay
 262      strings at `pos' in the order redisplay processes them.  A value
 263      < 0 means that this is not a position in an overlay string.  */
 264   ptrdiff_t overlay_string_index;
 265
 266   /* If this is a position in an overlay string, string_pos is the
 267      position within that string.  */
 268   struct text_pos string_pos;
 269
 270   /* If the character at the position above is a control character or
 271      has a display table entry, dpvec_index is an index in the display
 272      table or control character translation of that character.  A
 273      value < 0 means this is not a position in such a translation.  */
 274   int dpvec_index;
 275 };
 276
 277
 278 \f
 279 /***********************************************************************
 280                                 Glyphs
 281  ***********************************************************************/
 282
 283 /* The glyph datatype, used to represent characters on the display.
 284    It consists of a char code and a face id.  */
 285
 286 typedef struct {
 287   int ch;
 288   int face_id;
 289 } GLYPH;
 290
 291 /* Return a glyph's character code.  */
 292 INLINE int GLYPH_CHAR (GLYPH glyph) { return glyph.ch; }
 293
 294 /* Return a glyph's face ID.  */
 295 INLINE int GLYPH_FACE (GLYPH glyph) { return glyph.face_id; }
 296
 297 #define SET_GLYPH_CHAR(glyph, char) ((glyph).ch = (char))
 298 #define SET_GLYPH_FACE(glyph, face) ((glyph).face_id = (face))
 299 #define SET_GLYPH(glyph, char, face) \
 300   ((glyph).ch = (char), (glyph).face_id = (face))
 301
 302 /* The following are valid only if GLYPH_CODE_P (gc).  */
 303
 304 INLINE int
 305 GLYPH_CODE_CHAR (Lisp_Object gc)
 306 {
 307   return (CONSP (gc)
 308           ? XINT (XCAR (gc))
 309           : XINT (gc) & MAX_CHAR);
 310 }
 311
 312 INLINE int
 313 GLYPH_CODE_FACE (Lisp_Object gc)
 314 {
 315   return CONSP (gc) ? XINT (XCDR (gc)) : XINT (gc) >> CHARACTERBITS;
 316 }
 317
 318 #define SET_GLYPH_FROM_GLYPH_CODE(glyph, gc)                            \
 319   do                                                                    \
 320     {                                                                   \
 321       if (CONSP (gc))                                                   \
 322         SET_GLYPH (glyph, XINT (XCAR (gc)), XINT (XCDR (gc)));          \
 323       else                                                              \
 324         SET_GLYPH (glyph, (XINT (gc) & ((1 << CHARACTERBITS)-1)),       \
 325                    (XINT (gc) >> CHARACTERBITS));                       \
 326     }                                                                   \
 327   while (false)
 328
 329 /* The ID of the mode line highlighting face.  */
 330 enum { GLYPH_MODE_LINE_FACE = 1 };
 331
 332 /* Enumeration of glyph types.  Glyph structures contain a type field
 333    containing one of the enumerators defined here.  */
 334
 335 enum glyph_type
 336 {
 337   /* Glyph describes a character.  */
 338   CHAR_GLYPH,
 339
 340   /* Glyph describes a static composition.  */
 341   COMPOSITE_GLYPH,
 342
 343   /* Glyph describes a glyphless character.  */
 344   GLYPHLESS_GLYPH,
 345
 346   /* Glyph describes an image.  */
 347   IMAGE_GLYPH,
 348
 349   /* Glyph is a space of fractional width and/or height.  */
 350   STRETCH_GLYPH
 351 };
 352
 353
 354 /* Structure describing how to use partial glyphs (images slicing) */
 355
 356 struct glyph_slice
 357 {
 358   unsigned x : 16;
 359   unsigned y : 16;
 360   unsigned width : 16;
 361   unsigned height : 16;
 362 };
 363
 364
 365 /* Glyphs.
 366
 367    Be extra careful when changing this structure!  Esp. make sure that
 368    functions producing glyphs, like append_glyph, fill ALL of the
 369    glyph structure, and that GLYPH_EQUAL_P compares all
 370    display-relevant members of glyphs (not to imply that these are the
 371    only things to check when you add a member).  */
 372
 373 struct glyph
 374 {
 375   /* Position from which this glyph was drawn.  If `object' below is a
 376      Lisp string, this is an index into that string.  If it is a
 377      buffer, this is a position in that buffer.  In addition, some
 378      special glyphs have special values for this:
 379
 380       glyph standing for newline at end of line    0
 381       empty space after the end of the line       -1
 382       overlay arrow on a TTY                      -1
 383       glyph at EOB that ends in a newline         -1
 384       left truncation glyphs:                     -1
 385       right truncation/continuation glyphs        next buffer position
 386       glyph standing for newline of an empty line buffer position of newline
 387       stretch glyph at left edge of R2L lines     buffer position of newline  */
 388   ptrdiff_t charpos;
 389
 390   /* Lisp object source of this glyph.  Currently either a buffer or a
 391      string, if the glyph was produced from characters which came from
 392      a buffer or a string; or Lisp integer zero (a.k.a. "null object")
 393      if the glyph was inserted by redisplay for its own purposes, such
 394      as padding or truncation/continuation glyphs, or the
 395      overlay-arrow glyphs on TTYs.  */
 396   Lisp_Object object;
 397
 398   /* Width in pixels.  */
 399   short pixel_width;
 400
 401   /* Ascent and descent in pixels.  */
 402   short ascent, descent;
 403
 404   /* Vertical offset.  If < 0, the glyph is displayed raised, if > 0
 405      the glyph is displayed lowered.  */
 406   short voffset;
 407
 408   /* Which kind of glyph this is---character, image etc.  Value
 409      should be an enumerator of type enum glyph_type.  */
 410   unsigned type : 3;
 411
 412   /* True means this glyph was produced from multibyte text.  False
 413      means it was produced from unibyte text, i.e. charsets aren't
 414      applicable, and encoding is not performed.  */
 415   bool_bf multibyte_p : 1;
 416
 417   /* True means draw a box line at the left or right side of this
 418      glyph.  This is part of the implementation of the face attribute
 419      `:box'.  */
 420   bool_bf left_box_line_p : 1;
 421   bool_bf right_box_line_p : 1;
 422
 423   /* True means this glyph's physical ascent or descent is greater
 424      than its logical ascent/descent, i.e. it may potentially overlap
 425      glyphs above or below it.  */
 426   bool_bf overlaps_vertically_p : 1;
 427
 428   /* For terminal frames, true means glyph is a padding glyph.  Padding
 429      glyphs are used for characters whose visual shape consists of
 430      more than one glyph (e.g. Asian characters).  All but the first
 431      glyph of such a glyph sequence have the padding_p flag set.  This
 432      flag is used only to minimize code changes.  A better way would
 433      probably be to use the width field of glyphs to express padding.
 434
 435      For graphic frames, true means the pixel width of the glyph in a
 436      font is 0, but 1-pixel is padded on displaying for correct cursor
 437      displaying.  The member `pixel_width' above is set to 1.  */
 438   bool_bf padding_p : 1;
 439
 440   /* True means the actual glyph is not available, draw using `struct
 441      glyphless' below instead.  This can happen when a font couldn't
 442      be loaded, or a character doesn't have a glyph in a font.  */
 443   bool_bf glyph_not_available_p : 1;
 444
 445   /* True means don't display cursor here.  */
 446   bool_bf avoid_cursor_p : 1;
 447
 448   /* Resolved bidirectional level of this character [0..127].  */
 449   unsigned resolved_level : 7;
 450
 451   /* Resolved bidirectional type of this character, see enum
 452      bidi_type_t below.  Note that according to UAX#9, only some
 453      values (STRONG_L, STRONG_R, WEAK_AN, WEAK_EN, WEAK_BN, and
 454      NEUTRAL_B) can appear in the resolved type, so we only reserve
 455      space for those that can.  */
 456   unsigned bidi_type : 3;
 457
 458 #define FACE_ID_BITS    20
 459
 460   /* Face of the glyph.  This is a realized face ID,
 461      an index in the face cache of the frame.  */
 462   unsigned face_id : FACE_ID_BITS;
 463
 464   /* Type of font used to display the character glyph.  May be used to
 465      determine which set of functions to use to obtain font metrics
 466      for the glyph.  On W32, value should be an enumerator of the type
 467      w32_char_font_type.  Otherwise it equals FONT_TYPE_UNKNOWN.  */
 468   unsigned font_type : 3;
 469
 470   /* A union of sub-structures for different glyph types.  */
 471   union
 472   {
 473     /* Metrics of a partial glyph of an image (type == IMAGE_GLYPH).  */
 474     struct glyph_slice img;
 475     /* Start and end indices of glyphs of a grapheme cluster of a
 476        composition (type == COMPOSITE_GLYPH).  */
 477     struct { int from, to; } cmp;
 478     /* Pixel offsets for upper and lower part of the acronym.  */
 479     struct {
 480       short upper_xoff, upper_yoff;
 481       short lower_xoff, lower_yoff;
 482     } glyphless;
 483   } slice;
 484
 485   /* A union of sub-structures for different glyph types.  */
 486   union
 487   {
 488     /* Character code for character glyphs (type == CHAR_GLYPH).  */
 489     unsigned ch;
 490
 491     /* Sub-structures for type == COMPOSITE_GLYPH.  */
 492     struct
 493     {
 494       /* Flag to tell if the composition is automatic or not.  */
 495       bool_bf automatic : 1;
 496       /* ID of the composition.  */
 497       unsigned id    : 31;
 498     } cmp;
 499
 500     /* Image ID for image glyphs (type == IMAGE_GLYPH).  */
 501     int img_id;
 502
 503     /* Sub-structure for type == STRETCH_GLYPH.  */
 504     struct
 505     {
 506       /* The height of the glyph.  */
 507       unsigned height  : 16;
 508
 509       /* The ascent of the glyph.  */
 510       unsigned ascent  : 16;
 511     }
 512     stretch;
 513
 514     /* Sub-stretch for type == GLYPHLESS_GLYPH.  */
 515     struct
 516     {
 517       /* Value is an enum of the type glyphless_display_method.  */
 518       unsigned method : 2;
 519       /* True iff this glyph is for a character of no font. */
 520       bool_bf for_no_font : 1;
 521       /* Length of acronym or hexadecimal code string (at most 8).  */
 522       unsigned len : 4;
 523       /* Character to display.  Actually we need only 22 bits.  */
 524       unsigned ch : 25;
 525     } glyphless;
 526
 527     /* Used to compare all bit-fields above in one step.  */
 528     unsigned val;
 529   } u;
 530 };
 531
 532
 533 /* Default value of the glyph font_type field.  */
 534
 535 #define FONT_TYPE_UNKNOWN       0
 536
 537 /* Is GLYPH a space?  */
 538
 539 #define CHAR_GLYPH_SPACE_P(GLYPH) \
 540   ((GLYPH).u.ch == SPACEGLYPH && (GLYPH).face_id == DEFAULT_FACE_ID)
 541
 542 /* Are glyph slices of glyphs *X and *Y equal?  It assumes that both
 543    glyphs have the same type.
 544
 545    Note: for composition glyphs, we don't have to compare slice.cmp.to
 546    because they should be the same if and only if slice.cmp.from are
 547    the same.  */
 548
 549 #define GLYPH_SLICE_EQUAL_P(X, Y)                               \
 550   ((X)->type == IMAGE_GLYPH                                     \
 551    ? ((X)->slice.img.x == (Y)->slice.img.x                      \
 552       && (X)->slice.img.y == (Y)->slice.img.y                   \
 553       && (X)->slice.img.width == (Y)->slice.img.width           \
 554       && (X)->slice.img.height == (Y)->slice.img.height)        \
 555    : ((X)->type != COMPOSITE_GLYPH                              \
 556       || (X)->slice.cmp.from == (Y)->slice.cmp.from))
 557
 558 /* Are glyphs *X and *Y displayed equal?  */
 559
 560 #define GLYPH_EQUAL_P(X, Y)                                     \
 561      ((X)->type == (Y)->type                                    \
 562       && (X)->u.val == (Y)->u.val                               \
 563       && GLYPH_SLICE_EQUAL_P (X, Y)                             \
 564       && (X)->face_id == (Y)->face_id                           \
 565       && (X)->padding_p == (Y)->padding_p                       \
 566       && (X)->left_box_line_p == (Y)->left_box_line_p           \
 567       && (X)->right_box_line_p == (Y)->right_box_line_p         \
 568       && (X)->voffset == (Y)->voffset                           \
 569       && (X)->pixel_width == (Y)->pixel_width)
 570
 571 /* Are character codes, faces, padding_ps of glyphs *X and *Y equal?  */
 572
 573 #define GLYPH_CHAR_AND_FACE_EQUAL_P(X, Y)       \
 574   ((X)->u.ch == (Y)->u.ch                       \
 575    && (X)->face_id == (Y)->face_id              \
 576    && (X)->padding_p == (Y)->padding_p)
 577
 578 /* Fill a character glyph GLYPH.  CODE, FACE_ID, PADDING_P correspond
 579    to the bits defined for the typedef `GLYPH' in lisp.h.  */
 580
 581 #define SET_CHAR_GLYPH(GLYPH, CODE, FACE_ID, PADDING_P) \
 582      do                                                 \
 583        {                                                \
 584          (GLYPH).u.ch = (CODE);                         \
 585          (GLYPH).face_id = (FACE_ID);                   \
 586          (GLYPH).padding_p = (PADDING_P);               \
 587        }                                                \
 588      while (false)
 589
 590 /* Fill a character type glyph GLYPH from a glyph typedef FROM as
 591    defined in lisp.h.  */
 592
 593 #define SET_CHAR_GLYPH_FROM_GLYPH(GLYPH, FROM)                  \
 594      SET_CHAR_GLYPH ((GLYPH),                                   \
 595                      GLYPH_CHAR ((FROM)),                       \
 596                      GLYPH_FACE ((FROM)),                       \
 597                      false)
 598
 599 /* Construct a glyph code from a character glyph GLYPH.  If the
 600    character is multibyte, return -1 as we can't use glyph table for a
 601    multibyte character.  */
 602
 603 #define SET_GLYPH_FROM_CHAR_GLYPH(G, GLYPH)                     \
 604   do                                                            \
 605     {                                                           \
 606       if ((GLYPH).u.ch < 256)                                   \
 607         SET_GLYPH ((G), (GLYPH).u.ch, ((GLYPH).face_id));       \
 608       else                                                      \
 609         SET_GLYPH ((G), -1, 0);                                 \
 610     }                                                           \
 611   while (false)
 612
 613 #define GLYPH_INVALID_P(GLYPH) (GLYPH_CHAR (GLYPH) < 0)
 614
 615 /* Is GLYPH a padding glyph?  */
 616
 617 #define CHAR_GLYPH_PADDING_P(GLYPH) (GLYPH).padding_p
 618
 619
 620
 621 \f
 622 /***********************************************************************
 623                              Glyph Pools
 624  ***********************************************************************/
 625
 626 /* Glyph Pool.
 627
 628    Glyph memory for frame-based redisplay is allocated from the heap
 629    in one vector kept in a glyph pool structure which is stored with
 630    the frame.  The size of the vector is made large enough to cover
 631    all windows on the frame.
 632
 633    Both frame and window glyph matrices reference memory from a glyph
 634    pool in frame-based redisplay.
 635
 636    In window-based redisplay, no glyphs pools exist; windows allocate
 637    and free their glyph memory themselves.  */
 638
 639 struct glyph_pool
 640 {
 641   /* Vector of glyphs allocated from the heap.  */
 642   struct glyph *glyphs;
 643
 644   /* Allocated size of `glyphs'.  */
 645   ptrdiff_t nglyphs;
 646
 647   /* Number of rows and columns in a matrix.  */
 648   int nrows, ncolumns;
 649 };
 650
 651
 652 \f
 653 /***********************************************************************
 654                              Glyph Matrix
 655  ***********************************************************************/
 656
 657 /* Glyph Matrix.
 658
 659    Three kinds of glyph matrices exist:
 660
 661    1. Frame glyph matrices.  These are used for terminal frames whose
 662    redisplay needs a view of the whole screen due to limited terminal
 663    capabilities.  Frame matrices are used only in the update phase
 664    of redisplay.  They are built in update_frame and not used after
 665    the update has been performed.
 666
 667    2. Window glyph matrices on frames having frame glyph matrices.
 668    Such matrices are sub-matrices of their corresponding frame matrix,
 669    i.e., frame glyph matrices and window glyph matrices share the same
 670    glyph memory, which is allocated in the form of a glyph_pool structure.
 671    Glyph rows in such a window matrix are slices of frame matrix rows.
 672
 673    3. Free-standing window glyph matrices managing their own glyph
 674    storage.  This form is used in window-based redisplay which
 675    includes variable width and height fonts etc.
 676
 677    The size of a window's row vector depends on the height of fonts
 678    defined on its frame.  It is chosen so that the vector is large
 679    enough to describe all lines in a window when it is displayed in
 680    the smallest possible character size.  When new fonts are loaded,
 681    or window sizes change, the row vector is adjusted accordingly.  */
 682
 683 struct glyph_matrix
 684 {
 685   /* The pool from which glyph memory is allocated, if any.  This is
 686      null for frame matrices and for window matrices managing their
 687      own storage.  */
 688   struct glyph_pool *pool;
 689
 690   /* Vector of glyph row structures.  The row at nrows - 1 is reserved
 691      for the mode line.  */
 692   struct glyph_row *rows;
 693
 694   /* Number of elements allocated for the vector rows above.  */
 695   ptrdiff_t rows_allocated;
 696
 697   /* The number of rows used by the window if all lines were displayed
 698      with the smallest possible character height.  */
 699   int nrows;
 700
 701   /* Origin within the frame matrix if this is a window matrix on a
 702      frame having a frame matrix.  Both values are zero for
 703      window-based redisplay.  */
 704   int matrix_x, matrix_y;
 705
 706   /* Width and height of the matrix in columns and rows.  */
 707   int matrix_w, matrix_h;
 708
 709   /* If this structure describes a window matrix of window W,
 710      window_pixel_left is the value of W->pixel_left, window_pixel_top
 711      the value of W->pixel_top, window_height and window_width are width
 712      and height of W, as returned by window_box, and window_vscroll is
 713      the value of W->vscroll at the time the matrix was last adjusted.
 714      Only set for window-based redisplay.  */
 715   int window_pixel_left, window_pixel_top;
 716   int window_height, window_width;
 717   int window_vscroll;
 718
 719   /* Number of glyphs reserved for left and right marginal areas when
 720      the matrix was last adjusted.  */
 721   int left_margin_glyphs, right_margin_glyphs;
 722
 723   /* Flag indicating that scrolling should not be tried in
 724      update_window.  This flag is set by functions like try_window_id
 725      which do their own scrolling.  */
 726   bool_bf no_scrolling_p : 1;
 727
 728   /* True means window displayed in this matrix has a header
 729      line.  */
 730   bool_bf header_line_p : 1;
 731
 732 #ifdef GLYPH_DEBUG
 733   /* A string identifying the method used to display the matrix.  */
 734   char method[512];
 735 #endif
 736
 737   /* The buffer this matrix displays.  Set in
 738      mark_window_display_accurate_1.  */
 739   struct buffer *buffer;
 740
 741   /* Values of BEGV and ZV as of last redisplay.  Set in
 742      mark_window_display_accurate_1.  */
 743   ptrdiff_t begv, zv;
 744 };
 745
 746
 747 /* Check that glyph pointers stored in glyph rows of MATRIX are okay.
 748    This aborts if any pointer is found twice.  */
 749
 750 #ifdef GLYPH_DEBUG
 751 void check_matrix_pointer_lossage (struct glyph_matrix *);
 752 #define CHECK_MATRIX(MATRIX) check_matrix_pointer_lossage ((MATRIX))
 753 #else
 754 #define CHECK_MATRIX(MATRIX) ((void) 0)
 755 #endif
 756
 757
 758 \f
 759 /***********************************************************************
 760                              Glyph Rows
 761  ***********************************************************************/
 762
 763 /* Area in window glyph matrix.  If values are added or removed,
 764    the function mark_glyph_matrix in alloc.c may need to be changed.  */
 765
 766 enum glyph_row_area
 767 {
 768   ANY_AREA = -1,
 769   LEFT_MARGIN_AREA,
 770   TEXT_AREA,
 771   RIGHT_MARGIN_AREA,
 772   LAST_AREA
 773 };
 774
 775
 776 /* Rows of glyphs in a windows or frame glyph matrix.
 777
 778    Each row is partitioned into three areas.  The start and end of
 779    each area is recorded in a pointer as shown below.
 780
 781    +--------------------+-------------+---------------------+
 782    |  left margin area  |  text area  |  right margin area  |
 783    +--------------------+-------------+---------------------+
 784    |                    |             |                     |
 785    glyphs[LEFT_MARGIN_AREA]           glyphs[RIGHT_MARGIN_AREA]
 786                         |                                   |
 787                         glyphs[TEXT_AREA]                   |
 788                                               glyphs[LAST_AREA]
 789
 790    Rows in frame matrices reference glyph memory allocated in a frame
 791    glyph pool (see the description of struct glyph_pool).  Rows in
 792    window matrices on frames having frame matrices reference slices of
 793    the glyphs of corresponding rows in the frame matrix.
 794
 795    Rows in window matrices on frames having no frame matrices point to
 796    glyphs allocated from the heap via xmalloc;
 797    glyphs[LEFT_MARGIN_AREA] is the start address of the allocated
 798    glyph structure array.
 799
 800    NOTE: layout of first four members of this structure is important,
 801    see clear_glyph_row and copy_row_except_pointers to check why.  */
 802
 803 struct glyph_row
 804 {
 805   /* Pointers to beginnings of areas.  The end of an area A is found at
 806      A + 1 in the vector.  The last element of the vector is the end
 807      of the whole row.
 808
 809      Kludge alert: Even if used[TEXT_AREA] == 0, glyphs[TEXT_AREA][0]'s
 810      position field is used.  It is -1 if this row does not correspond
 811      to any text; it is some buffer position if the row corresponds to
 812      an empty display line that displays a line end.  This is what old
 813      redisplay used to do.  (Except in code for terminal frames, this
 814      kludge is no longer used, I believe. --gerd).
 815
 816      See also start, end, displays_text_p and ends_at_zv_p for cleaner
 817      ways to do it.  The special meaning of positions 0 and -1 will be
 818      removed some day, so don't use it in new code.  */
 819   struct glyph *glyphs[1 + LAST_AREA];
 820
 821   /* Number of glyphs actually filled in areas.  This could have size
 822      LAST_AREA, but it's 1 + LAST_AREA to simplify offset calculations.  */
 823   short used[1 + LAST_AREA];
 824
 825   /* Hash code.  This hash code is available as soon as the row
 826      is constructed, i.e. after a call to display_line.  */
 827   unsigned hash;
 828
 829   /* Window-relative x and y-position of the top-left corner of this
 830      row.  If y < 0, this means that eabs (y) pixels of the row are
 831      invisible because it is partially visible at the top of a window.
 832      If x < 0, this means that eabs (x) pixels of the first glyph of
 833      the text area of the row are invisible because the glyph is
 834      partially visible.  */
 835   int x, y;
 836
 837   /* Width of the row in pixels without taking face extension at the
 838      end of the row into account, and without counting truncation
 839      and continuation glyphs at the end of a row on ttys.  */
 840   int pixel_width;
 841
 842   /* Logical ascent/height of this line.  The value of ascent is zero
 843      and height is 1 on terminal frames.  */
 844   int ascent, height;
 845
 846   /* Physical ascent/height of this line.  If max_ascent > ascent,
 847      this line overlaps the line above it on the display.  Otherwise,
 848      if max_height > height, this line overlaps the line beneath it.  */
 849   int phys_ascent, phys_height;
 850
 851   /* Portion of row that is visible.  Partially visible rows may be
 852      found at the top and bottom of a window.  This is 1 for tty
 853      frames.  It may be < 0 in case of completely invisible rows.  */
 854   int visible_height;
 855
 856   /* Extra line spacing added after this row.  Do not consider this
 857      in last row when checking if row is fully visible.  */
 858   int extra_line_spacing;
 859
 860   /* First position in this row.  This is the text position, including
 861      overlay position information etc, where the display of this row
 862      started, and can thus be less than the position of the first
 863      glyph (e.g. due to invisible text or horizontal scrolling).
 864      BIDI Note: In R2L rows, that have its reversed_p flag set, this
 865      position is at or beyond the right edge of the row.  */
 866   struct display_pos start;
 867
 868   /* Text position at the end of this row.  This is the position after
 869      the last glyph on this row.  It can be greater than the last
 870      glyph position + 1, due to a newline that ends the line,
 871      truncation, invisible text etc.  In an up-to-date display, this
 872      should always be equal to the start position of the next row.
 873      BIDI Note: In R2L rows, this position is at or beyond the left
 874      edge of the row.  */
 875   struct display_pos end;
 876
 877   /* The smallest and the largest buffer positions that contributed to
 878      glyphs in this row.  Note that due to bidi reordering, these are
 879      in general different from the text positions stored in `start'
 880      and `end' members above, and also different from the buffer
 881      positions recorded in the glyphs displayed the leftmost and
 882      rightmost on the screen.  */
 883   struct text_pos minpos, maxpos;
 884
 885   /* Non-zero means the overlay arrow bitmap is on this line.
 886      -1 means use default overlay arrow bitmap, else
 887      it specifies actual fringe bitmap number.  */
 888   int overlay_arrow_bitmap;
 889
 890   /* Left fringe bitmap number (enum fringe_bitmap_type).  */
 891   unsigned left_user_fringe_bitmap : FRINGE_ID_BITS;
 892
 893   /* Right fringe bitmap number (enum fringe_bitmap_type).  */
 894   unsigned right_user_fringe_bitmap : FRINGE_ID_BITS;
 895
 896   /* Left fringe bitmap number (enum fringe_bitmap_type).  */
 897   unsigned left_fringe_bitmap : FRINGE_ID_BITS;
 898
 899   /* Right fringe bitmap number (enum fringe_bitmap_type).  */
 900   unsigned right_fringe_bitmap : FRINGE_ID_BITS;
 901
 902   /* Face of the left fringe glyph.  */
 903   unsigned left_user_fringe_face_id : FACE_ID_BITS;
 904
 905   /* Face of the right fringe glyph.  */
 906   unsigned right_user_fringe_face_id : FACE_ID_BITS;
 907
 908   /* Face of the left fringe glyph.  */
 909   unsigned left_fringe_face_id : FACE_ID_BITS;
 910
 911   /* Face of the right fringe glyph.  */
 912   unsigned right_fringe_face_id : FACE_ID_BITS;
 913
 914   /* Vertical offset of the left fringe bitmap.  */
 915   signed left_fringe_offset : FRINGE_HEIGHT_BITS;
 916
 917   /* Vertical offset of the right fringe bitmap.  */
 918   signed right_fringe_offset : FRINGE_HEIGHT_BITS;
 919
 920   /* True means that at least one of the left and right fringe bitmaps is
 921      periodic and thus depends on the y-position of the row.  */
 922   bool_bf fringe_bitmap_periodic_p : 1;
 923
 924   /* True means that we must draw the bitmaps of this row.  */
 925   bool_bf redraw_fringe_bitmaps_p : 1;
 926
 927   /* In a desired matrix, true means that this row must be updated.  In a
 928      current matrix, false means that the row has been invalidated, i.e.
 929      the row's contents do not agree with what is visible on the
 930      screen.  */
 931   bool_bf enabled_p : 1;
 932
 933   /* True means row displays a text line that is truncated on the left or
 934      right side.  */
 935   bool_bf truncated_on_left_p : 1;
 936   bool_bf truncated_on_right_p : 1;
 937
 938   /* True means that this row displays a continued line, i.e. it has a
 939      continuation mark at the right side.  */
 940   bool_bf continued_p : 1;
 941
 942   /* False means that this row does not contain any text, i.e., it is
 943      a blank line at the window and buffer end.  */
 944   bool_bf displays_text_p : 1;
 945
 946   /* True means that this line ends at ZV.  */
 947   bool_bf ends_at_zv_p : 1;
 948
 949   /* True means the face of the last glyph in the text area is drawn to
 950      the right end of the window.  This flag is used in
 951      update_text_area to optimize clearing to the end of the area.  */
 952   bool_bf fill_line_p : 1;
 953
 954   /* True means display a bitmap on X frames indicating that this
 955      line contains no text and ends in ZV.  */
 956   bool_bf indicate_empty_line_p : 1;
 957
 958   /* True means this row contains glyphs that overlap each other because
 959      of lbearing or rbearing.  */
 960   bool_bf contains_overlapping_glyphs_p : 1;
 961
 962   /* True means this row is as wide as the window it is displayed in, including
 963      scroll bars, fringes, and internal borders.  This also
 964      implies that the row doesn't have marginal areas.  */
 965   bool_bf full_width_p : 1;
 966
 967   /* True means row is a mode or header-line.  */
 968   bool_bf mode_line_p : 1;
 969
 970   /* True in a current row means this row is overlapped by another row.  */
 971   bool_bf overlapped_p : 1;
 972
 973   /* True means this line ends in the middle of a character consisting
 974      of more than one glyph.  Some glyphs have been put in this row,
 975      the rest are put in rows below this one.  */
 976   bool_bf ends_in_middle_of_char_p : 1;
 977
 978   /* True means this line starts in the middle of a character consisting
 979      of more than one glyph.  Some glyphs have been put in the
 980      previous row, the rest are put in this row.  */
 981   bool_bf starts_in_middle_of_char_p : 1;
 982
 983   /* True in a current row means this row overlaps others.  */
 984   bool_bf overlapping_p : 1;
 985
 986   /* True means some glyphs in this row are displayed in mouse-face.  */
 987   bool_bf mouse_face_p : 1;
 988
 989   /* True means this row was ended by a newline from a string.  */
 990   bool_bf ends_in_newline_from_string_p : 1;
 991
 992   /* True means this row width is exactly the width of the window, and the
 993      final newline character is hidden in the right fringe.  */
 994   bool_bf exact_window_width_line_p : 1;
 995
 996   /* True means this row currently shows the cursor in the right fringe.  */
 997   bool_bf cursor_in_fringe_p : 1;
 998
 999   /* True means the last glyph in the row is part of an ellipsis.  */
1000   bool_bf ends_in_ellipsis_p : 1;
1001
1002   /* True means display a bitmap on X frames indicating that this
1003      the first line of the buffer.  */
1004   bool_bf indicate_bob_p : 1;
1005
1006   /* True means display a bitmap on X frames indicating that this
1007      the top line of the window, but not start of the buffer.  */
1008   bool_bf indicate_top_line_p : 1;
1009
1010   /* True means display a bitmap on X frames indicating that this
1011      the last line of the buffer.  */
1012   bool_bf indicate_eob_p : 1;
1013
1014   /* True means display a bitmap on X frames indicating that this
1015      the bottom line of the window, but not end of the buffer.  */
1016   bool_bf indicate_bottom_line_p : 1;
1017
1018   /* True means the row was reversed to display text in a
1019      right-to-left paragraph.  */
1020   bool_bf reversed_p : 1;
1021
1022   /* Continuation lines width at the start of the row.  */
1023   int continuation_lines_width;
1024
1025 #ifdef HAVE_WINDOW_SYSTEM
1026   /* Non-NULL means the current clipping area.  This is temporarily
1027      set while exposing a region.  Coordinates are frame-relative.  */
1028   XRectangle *clip;
1029 #endif
1030 };
1031
1032
1033 /* Get a pointer to row number ROW in matrix MATRIX.  If GLYPH_DEBUG
1034    is defined, the function matrix_row checks that we don't try to
1035    access rows that are out of bounds.  */
1036
1037 #ifdef GLYPH_DEBUG
1038 struct glyph_row *matrix_row (struct glyph_matrix *, int);
1039 #define MATRIX_ROW(MATRIX, ROW)   matrix_row ((MATRIX), (ROW))
1040 #else
1041 #define MATRIX_ROW(MATRIX, ROW)   ((MATRIX)->rows + (ROW))
1042 #endif
1043
1044 /* Return a pointer to the row reserved for the mode line in MATRIX.
1045    Row MATRIX->nrows - 1 is always reserved for the mode line.  */
1046
1047 #define MATRIX_MODE_LINE_ROW(MATRIX) \
1048      ((MATRIX)->rows + (MATRIX)->nrows - 1)
1049
1050 /* Return a pointer to the row reserved for the header line in MATRIX.
1051    This is always the first row in MATRIX because that's the only
1052    way that works in frame-based redisplay.  */
1053
1054 #define MATRIX_HEADER_LINE_ROW(MATRIX) (MATRIX)->rows
1055
1056 /* Return a pointer to first row in MATRIX used for text display.  */
1057
1058 #define MATRIX_FIRST_TEXT_ROW(MATRIX) \
1059      ((MATRIX)->rows->mode_line_p ? (MATRIX)->rows + 1 : (MATRIX)->rows)
1060
1061 /* Return a pointer to the first glyph in the text area of a row.
1062    MATRIX is the glyph matrix accessed, and ROW is the row index in
1063    MATRIX.  */
1064
1065 #define MATRIX_ROW_GLYPH_START(MATRIX, ROW) \
1066      (MATRIX_ROW ((MATRIX), (ROW))->glyphs[TEXT_AREA])
1067
1068 /* Return the number of used glyphs in the text area of a row.  */
1069
1070 #define MATRIX_ROW_USED(MATRIX, ROW) \
1071      (MATRIX_ROW ((MATRIX), (ROW))->used[TEXT_AREA])
1072
1073 /* Return the character/ byte position at which the display of ROW
1074    starts.  BIDI Note: this is the smallest character/byte position
1075    among characters in ROW, i.e. the first logical-order character
1076    displayed by ROW, which is not necessarily the smallest horizontal
1077    position.  */
1078
1079 #define MATRIX_ROW_START_CHARPOS(ROW) ((ROW)->minpos.charpos)
1080 #define MATRIX_ROW_START_BYTEPOS(ROW) ((ROW)->minpos.bytepos)
1081
1082 /* Return the character/ byte position at which ROW ends.  BIDI Note:
1083    this is the largest character/byte position among characters in
1084    ROW, i.e. the last logical-order character displayed by ROW, which
1085    is not necessarily the largest horizontal position.  */
1086
1087 #define MATRIX_ROW_END_CHARPOS(ROW) ((ROW)->maxpos.charpos)
1088 #define MATRIX_ROW_END_BYTEPOS(ROW) ((ROW)->maxpos.bytepos)
1089
1090 /* Return the vertical position of ROW in MATRIX.  */
1091
1092 #define MATRIX_ROW_VPOS(ROW, MATRIX) ((ROW) - (MATRIX)->rows)
1093
1094 /* Return the last glyph row + 1 in MATRIX on window W reserved for
1095    text.  If W has a mode line, the last row in the matrix is reserved
1096    for it.  */
1097
1098 #define MATRIX_BOTTOM_TEXT_ROW(MATRIX, W)               \
1099      ((MATRIX)->rows                                    \
1100       + (MATRIX)->nrows                                 \
1101       - (WINDOW_WANTS_MODELINE_P ((W)) ? 1 : 0))
1102
1103 /* Non-zero if the face of the last glyph in ROW's text area has
1104    to be drawn to the end of the text area.  */
1105
1106 #define MATRIX_ROW_EXTENDS_FACE_P(ROW) ((ROW)->fill_line_p)
1107
1108 /* Set and query the enabled_p flag of glyph row ROW in MATRIX.  */
1109
1110 #define SET_MATRIX_ROW_ENABLED_P(MATRIX, ROW, VALUE) \
1111      (MATRIX_ROW (MATRIX, ROW)->enabled_p = (VALUE))
1112
1113 #define MATRIX_ROW_ENABLED_P(MATRIX, ROW) \
1114      (MATRIX_ROW (MATRIX, ROW)->enabled_p)
1115
1116 /* Non-zero if ROW displays text.  Value is non-zero if the row is
1117    blank but displays a line end.  */
1118
1119 #define MATRIX_ROW_DISPLAYS_TEXT_P(ROW) ((ROW)->displays_text_p)
1120
1121
1122 /* Helper macros */
1123
1124 #define MR_PARTIALLY_VISIBLE(ROW)       \
1125   ((ROW)->height != (ROW)->visible_height)
1126
1127 #define MR_PARTIALLY_VISIBLE_AT_TOP(W, ROW)  \
1128   ((ROW)->y < WINDOW_HEADER_LINE_HEIGHT ((W)))
1129
1130 #define MR_PARTIALLY_VISIBLE_AT_BOTTOM(W, ROW)  \
1131   (((ROW)->y + (ROW)->height - (ROW)->extra_line_spacing) \
1132    > WINDOW_BOX_HEIGHT_NO_MODE_LINE ((W)))
1133
1134 /* Non-zero if ROW is not completely visible in window W.  */
1135
1136 #define MATRIX_ROW_PARTIALLY_VISIBLE_P(W, ROW)          \
1137   (MR_PARTIALLY_VISIBLE ((ROW))                         \
1138    && (MR_PARTIALLY_VISIBLE_AT_TOP ((W), (ROW))         \
1139        || MR_PARTIALLY_VISIBLE_AT_BOTTOM ((W), (ROW))))
1140
1141
1142
1143 /* Non-zero if ROW is partially visible at the top of window W.  */
1144
1145 #define MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P(W, ROW)           \
1146   (MR_PARTIALLY_VISIBLE ((ROW))                                 \
1147    && MR_PARTIALLY_VISIBLE_AT_TOP ((W), (ROW)))
1148
1149 /* Non-zero if ROW is partially visible at the bottom of window W.  */
1150
1151 #define MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P(W, ROW)        \
1152   (MR_PARTIALLY_VISIBLE ((ROW))                                 \
1153    && MR_PARTIALLY_VISIBLE_AT_BOTTOM ((W), (ROW)))
1154
1155 /* Return the bottom Y + 1 of ROW.   */
1156
1157 #define MATRIX_ROW_BOTTOM_Y(ROW) ((ROW)->y + (ROW)->height)
1158
1159 /* Is ROW the last visible one in the display described by the
1160    iterator structure pointed to by IT?.  */
1161
1162 #define MATRIX_ROW_LAST_VISIBLE_P(ROW, IT) \
1163      (MATRIX_ROW_BOTTOM_Y ((ROW)) >= (IT)->last_visible_y)
1164
1165 /* Non-zero if ROW displays a continuation line.  */
1166
1167 #define MATRIX_ROW_CONTINUATION_LINE_P(ROW) \
1168      ((ROW)->continuation_lines_width > 0)
1169
1170 /* Non-zero if ROW ends in the middle of a character.  This is the
1171    case for continued lines showing only part of a display table entry
1172    or a control char, or an overlay string.  */
1173
1174 #define MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P(ROW)        \
1175      ((ROW)->end.dpvec_index > 0                        \
1176       || (ROW)->end.overlay_string_index >= 0           \
1177       || (ROW)->ends_in_middle_of_char_p)
1178
1179 /* Non-zero if ROW ends in the middle of an overlay string.  */
1180
1181 #define MATRIX_ROW_ENDS_IN_OVERLAY_STRING_P(ROW) \
1182      ((ROW)->end.overlay_string_index >= 0)
1183
1184 /* Non-zero if ROW starts in the middle of a character.  See above.  */
1185
1186 #define MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P(ROW)      \
1187      ((ROW)->start.dpvec_index > 0                      \
1188       || (ROW)->starts_in_middle_of_char_p              \
1189       || ((ROW)->start.overlay_string_index >= 0        \
1190           && (ROW)->start.string_pos.charpos > 0))
1191
1192 /* True means ROW overlaps its predecessor.  */
1193
1194 #define MATRIX_ROW_OVERLAPS_PRED_P(ROW) \
1195      ((ROW)->phys_ascent > (ROW)->ascent)
1196
1197 /* True means ROW overlaps its successor.  */
1198
1199 #define MATRIX_ROW_OVERLAPS_SUCC_P(ROW)         \
1200       ((ROW)->phys_height - (ROW)->phys_ascent  \
1201        > (ROW)->height - (ROW)->ascent)
1202
1203 /* A glyph for a space.  */
1204
1205 extern struct glyph space_glyph;
1206
1207 /* True means last display completed.  False means it was preempted.  */
1208
1209 extern bool display_completed;
1210
1211
1212 \f
1213 /************************************************************************
1214                           Glyph Strings
1215  ************************************************************************/
1216
1217 /* Enumeration for overriding/changing the face to use for drawing
1218    glyphs in draw_glyphs.  */
1219
1220 enum draw_glyphs_face
1221 {
1222   DRAW_NORMAL_TEXT,
1223   DRAW_INVERSE_VIDEO,
1224   DRAW_CURSOR,
1225   DRAW_MOUSE_FACE,
1226   DRAW_IMAGE_RAISED,
1227   DRAW_IMAGE_SUNKEN
1228 };
1229
1230 #ifdef HAVE_WINDOW_SYSTEM
1231
1232 /* A sequence of glyphs to be drawn in the same face.  */
1233
1234 struct glyph_string
1235 {
1236   /* X-origin of the string.  */
1237   int x;
1238
1239   /* Y-origin and y-position of the base line of this string.  */
1240   int y, ybase;
1241
1242   /* The width of the string, not including a face extension.  */
1243   int width;
1244
1245   /* The width of the string, including a face extension.  */
1246   int background_width;
1247
1248   /* The height of this string.  This is the height of the line this
1249      string is drawn in, and can be different from the height of the
1250      font the string is drawn in.  */
1251   int height;
1252
1253   /* Number of pixels this string overwrites in front of its x-origin.
1254      This number is zero if the string has an lbearing >= 0; it is
1255      -lbearing, if the string has an lbearing < 0.  */
1256   int left_overhang;
1257
1258   /* Number of pixels this string overwrites past its right-most
1259      nominal x-position, i.e. x + width.  Zero if the string's
1260      rbearing is <= its nominal width, rbearing - width otherwise.  */
1261   int right_overhang;
1262
1263   /* The frame on which the glyph string is drawn.  */
1264   struct frame *f;
1265
1266   /* The window on which the glyph string is drawn.  */
1267   struct window *w;
1268
1269   /* X display and window for convenience.  */
1270   Display *display;
1271   Window window;
1272
1273   /* The glyph row for which this string was built.  It determines the
1274      y-origin and height of the string.  */
1275   struct glyph_row *row;
1276
1277   /* The area within row.  */
1278   enum glyph_row_area area;
1279
1280   /* Characters to be drawn, and number of characters.  */
1281   XChar2b *char2b;
1282   int nchars;
1283
1284   /* A face-override for drawing cursors, mouse face and similar.  */
1285   enum draw_glyphs_face hl;
1286
1287   /* Face in which this string is to be drawn.  */
1288   struct face *face;
1289
1290   /* Font in which this string is to be drawn.  */
1291   struct font *font;
1292
1293   /* Non-null means this string describes (part of) a static
1294      composition.  */
1295   struct composition *cmp;
1296
1297   /* If not negative, this string describes a compos.  */
1298   ptrdiff_t cmp_id;
1299
1300   /* Start and end glyph indices in a glyph-string.  */
1301   int cmp_from, cmp_to;
1302
1303   /* True means this glyph strings face has to be drawn to the right end
1304      of the window's drawing area.  */
1305   bool_bf extends_to_end_of_line_p : 1;
1306
1307   /* True means the background of this string has been drawn.  */
1308   bool_bf background_filled_p : 1;
1309
1310   /* True means glyph string must be drawn with 16-bit functions.  */
1311   bool_bf two_byte_p : 1;
1312
1313   /* True means that the original font determined for drawing this glyph
1314      string could not be loaded.  The member `font' has been set to
1315      the frame's default font in this case.  */
1316   bool_bf font_not_found_p : 1;
1317
1318   /* True means that the face in which this glyph string is drawn has a
1319      stipple pattern.  */
1320   bool_bf stippled_p : 1;
1321
1322 #define OVERLAPS_PRED           (1 << 0)
1323 #define OVERLAPS_SUCC           (1 << 1)
1324 #define OVERLAPS_BOTH           (OVERLAPS_PRED | OVERLAPS_SUCC)
1325 #define OVERLAPS_ERASED_CURSOR  (1 << 2)
1326   /* Non-zero means only the foreground of this glyph string must be
1327      drawn, and we should use the physical height of the line this
1328      glyph string appears in as clip rect.  If the value is
1329      OVERLAPS_ERASED_CURSOR, the clip rect is restricted to the rect
1330      of the erased cursor.  OVERLAPS_PRED and OVERLAPS_SUCC mean we
1331      draw overlaps with the preceding and the succeeding rows,
1332      respectively.  */
1333   unsigned for_overlaps : 3;
1334
1335   /* True means that all glyphs in this glyph string has the flag
1336      padding_p set, and thus must be drawn one by one to have 1-pixel
1337      width even though the logical width in the font is zero.  */
1338   bool_bf padding_p : 1;
1339
1340   /* The GC to use for drawing this glyph string.  */
1341 #if defined (HAVE_X_WINDOWS)
1342   GC gc;
1343 #endif
1344 #if defined (HAVE_NTGUI)
1345   XGCValues *gc;
1346   HDC hdc;
1347 #endif
1348
1349   /* A pointer to the first glyph in the string.  This glyph
1350      corresponds to char2b[0].  Needed to draw rectangles if
1351      font_not_found_p is true.  */
1352   struct glyph *first_glyph;
1353
1354   /* Image, if any.  */
1355   struct image *img;
1356
1357   /* Slice */
1358   struct glyph_slice slice;
1359
1360   /* Non-null means the horizontal clipping region starts from the
1361      left edge of *clip_head, and ends with the right edge of
1362      *clip_tail, not including their overhangs.  */
1363   struct glyph_string *clip_head, *clip_tail;
1364
1365   /* The current clipping areas.  */
1366   NativeRectangle clip[2];
1367
1368   /* Number of clipping areas. */
1369   int num_clips;
1370
1371   int underline_position;
1372
1373   int underline_thickness;
1374
1375   struct glyph_string *next, *prev;
1376 };
1377
1378 #endif /* HAVE_WINDOW_SYSTEM */
1379
1380 \f
1381 /************************************************************************
1382                           Display Dimensions
1383  ************************************************************************/
1384
1385 /* Return the height of the mode line in glyph matrix MATRIX, or zero
1386    if not known.  This macro is called under circumstances where
1387    MATRIX might not have been allocated yet.  */
1388
1389 #define MATRIX_MODE_LINE_HEIGHT(MATRIX)         \
1390      ((MATRIX) && (MATRIX)->rows                \
1391       ? MATRIX_MODE_LINE_ROW (MATRIX)->height   \
1392       : 0)
1393
1394 /* Return the height of the header line in glyph matrix MATRIX, or zero
1395    if not known.  This macro is called under circumstances where
1396    MATRIX might not have been allocated yet.  */
1397
1398 #define MATRIX_HEADER_LINE_HEIGHT(MATRIX)       \
1399      ((MATRIX) && (MATRIX)->rows                \
1400       ? MATRIX_HEADER_LINE_ROW (MATRIX)->height \
1401       : 0)
1402
1403 /* Return the desired face id for the mode line of a window, depending
1404    on whether the window is selected or not, or if the window is the
1405    scrolling window for the currently active minibuffer window.
1406
1407    Due to the way display_mode_lines manipulates with the contents of
1408    selected_window, this macro needs three arguments: SELW which is
1409    compared against the current value of selected_window, MBW which is
1410    compared against minibuf_window (if SELW doesn't match), and SCRW
1411    which is compared against minibuf_selected_window (if MBW matches).  */
1412
1413 #define CURRENT_MODE_LINE_FACE_ID_3(SELW, MBW, SCRW)            \
1414      ((!mode_line_in_non_selected_windows                       \
1415        || (SELW) == XWINDOW (selected_window)                   \
1416        || (minibuf_level > 0                                    \
1417            && !NILP (minibuf_selected_window)                   \
1418            && (MBW) == XWINDOW (minibuf_window)                 \
1419            && (SCRW) == XWINDOW (minibuf_selected_window)))     \
1420       ? MODE_LINE_FACE_ID                                       \
1421       : MODE_LINE_INACTIVE_FACE_ID)
1422
1423
1424 /* Return the desired face id for the mode line of window W.  */
1425
1426 #define CURRENT_MODE_LINE_FACE_ID(W)            \
1427         (CURRENT_MODE_LINE_FACE_ID_3((W), XWINDOW (selected_window), (W)))
1428
1429 /* Return the current height of the mode line of window W.  If not known
1430    from W->mode_line_height, look at W's current glyph matrix, or return
1431    a default based on the height of the font of the face `mode-line'.  */
1432
1433 #define CURRENT_MODE_LINE_HEIGHT(W)                                     \
1434   (W->mode_line_height >= 0                                             \
1435    ? W->mode_line_height                                                \
1436    : (W->mode_line_height                                               \
1437       = (MATRIX_MODE_LINE_HEIGHT (W->current_matrix)                    \
1438          ? MATRIX_MODE_LINE_HEIGHT (W->current_matrix)                  \
1439          : estimate_mode_line_height                                    \
1440              (XFRAME (W->frame), CURRENT_MODE_LINE_FACE_ID (W)))))
1441
1442 /* Return the current height of the header line of window W.  If not known
1443    from W->header_line_height, look at W's current glyph matrix, or return
1444    an estimation based on the height of the font of the face `header-line'.  */
1445
1446 #define CURRENT_HEADER_LINE_HEIGHT(W)                           \
1447   (W->header_line_height >= 0                                   \
1448    ? W->header_line_height                                      \
1449    : (W->header_line_height                                     \
1450       = (MATRIX_HEADER_LINE_HEIGHT (W->current_matrix)          \
1451          ? MATRIX_HEADER_LINE_HEIGHT (W->current_matrix)        \
1452          : estimate_mode_line_height                            \
1453              (XFRAME (W->frame), HEADER_LINE_FACE_ID))))
1454
1455 /* Return the height of the desired mode line of window W.  */
1456
1457 #define DESIRED_MODE_LINE_HEIGHT(W) \
1458      MATRIX_MODE_LINE_HEIGHT ((W)->desired_matrix)
1459
1460 /* Return the height of the desired header line of window W.  */
1461
1462 #define DESIRED_HEADER_LINE_HEIGHT(W) \
1463      MATRIX_HEADER_LINE_HEIGHT ((W)->desired_matrix)
1464
1465 /* PXW: The height checks below serve to show at least one text line
1466    instead of a mode- and/or header line when a window gets very small.
1467    But (1) the check fails when the mode- or header-line is taller than
1468    the associated frame's line height and (2) we don't care much about
1469    text visibility anyway when shrinking a frame containing a toolbar.
1470
1471    So maybe these checks should be removed and any clipping left to the
1472    window manager.  */
1473
1474 /* Value is true if window W wants a mode line and is large enough
1475    to accommodate it.  */
1476 #define WINDOW_WANTS_MODELINE_P(W)                                      \
1477   (BUFFERP ((W)->contents)                                              \
1478    ? (!MINI_WINDOW_P (W)                                                \
1479       && !(W)->pseudo_window_p                                          \
1480       && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (W)))             \
1481       && !NILP (BVAR (XBUFFER ((W)->contents), mode_line_format))       \
1482       && WINDOW_PIXEL_HEIGHT (W) > WINDOW_FRAME_LINE_HEIGHT (W))        \
1483    : false)
1484
1485 /* Value is true if window W wants a header line and is large enough
1486    to accommodate it.  */
1487 #define WINDOW_WANTS_HEADER_LINE_P(W)                                   \
1488      (BUFFERP ((W)->contents)                                           \
1489       ? (!MINI_WINDOW_P (W)                                             \
1490          && !(W)->pseudo_window_p                                       \
1491          && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (W)))          \
1492          && !NILP (BVAR (XBUFFER ((W)->contents), header_line_format))  \
1493          && (WINDOW_PIXEL_HEIGHT (W)                                    \
1494              > (WINDOW_WANTS_MODELINE_P (W)                             \
1495                 ? (2 * WINDOW_FRAME_LINE_HEIGHT (W))                    \
1496                 : WINDOW_FRAME_LINE_HEIGHT (W))))                       \
1497       : false)
1498
1499 /* Return proper value to be used as baseline offset of font that has
1500    ASCENT and DESCENT to draw characters by the font at the vertical
1501    center of the line of frame F.
1502
1503    Here, our task is to find the value of BOFF in the following figure;
1504
1505         -------------------------+-----------+-
1506          -+-+---------+-+        |           |
1507           | |         | |        |           |
1508           | |         | |        F_ASCENT    F_HEIGHT
1509           | |         | ASCENT   |           |
1510      HEIGHT |         | |        |           |
1511           | |         |-|-+------+-----------|------- baseline
1512           | |         | | BOFF   |           |
1513           | |---------|-+-+      |           |
1514           | |         | DESCENT  |           |
1515          -+-+---------+-+        F_DESCENT   |
1516         -------------------------+-----------+-
1517
1518         -BOFF + DESCENT + (F_HEIGHT - HEIGHT) / 2 = F_DESCENT
1519         BOFF = DESCENT +  (F_HEIGHT - HEIGHT) / 2 - F_DESCENT
1520         DESCENT = FONT->descent
1521         HEIGHT = FONT_HEIGHT (FONT)
1522         F_DESCENT = (FRAME_FONT (F)->descent
1523                      - F->terminal->output_data.x->baseline_offset)
1524         F_HEIGHT = FRAME_LINE_HEIGHT (F)
1525 */
1526
1527 #define VCENTER_BASELINE_OFFSET(FONT, F)                        \
1528   (FONT_DESCENT (FONT)                                          \
1529    + (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT))            \
1530       + (FRAME_LINE_HEIGHT ((F)) > FONT_HEIGHT ((FONT)))) / 2   \
1531    - (FONT_DESCENT (FRAME_FONT (F)) - FRAME_BASELINE_OFFSET (F)))
1532
1533 \f
1534 /***********************************************************************
1535                                 Faces
1536  ***********************************************************************/
1537
1538 /* Indices of face attributes in Lisp face vectors.  Slot zero is the
1539    symbol `face'.  */
1540
1541 enum lface_attribute_index
1542 {
1543   LFACE_FAMILY_INDEX = 1,
1544   LFACE_FOUNDRY_INDEX,
1545   LFACE_SWIDTH_INDEX,
1546   LFACE_HEIGHT_INDEX,
1547   LFACE_WEIGHT_INDEX,
1548   LFACE_SLANT_INDEX,
1549   LFACE_UNDERLINE_INDEX,
1550   LFACE_INVERSE_INDEX,
1551   LFACE_FOREGROUND_INDEX,
1552   LFACE_BACKGROUND_INDEX,
1553   LFACE_STIPPLE_INDEX,
1554   LFACE_OVERLINE_INDEX,
1555   LFACE_STRIKE_THROUGH_INDEX,
1556   LFACE_BOX_INDEX,
1557   LFACE_FONT_INDEX,
1558   LFACE_INHERIT_INDEX,
1559   LFACE_FONTSET_INDEX,
1560   LFACE_DISTANT_FOREGROUND_INDEX,
1561   LFACE_VECTOR_SIZE
1562 };
1563
1564
1565 /* Box types of faces.  */
1566
1567 enum face_box_type
1568 {
1569   /* No box around text.  */
1570   FACE_NO_BOX,
1571
1572   /* Simple box of specified width and color.  Default width is 1, and
1573      default color is the foreground color of the face.  */
1574   FACE_SIMPLE_BOX,
1575
1576   /* Boxes with 3D shadows.  Color equals the background color of the
1577      face.  Width is specified.  */
1578   FACE_RAISED_BOX,
1579   FACE_SUNKEN_BOX
1580 };
1581
1582 /* Underline type. */
1583
1584 enum face_underline_type
1585 {
1586   FACE_UNDER_LINE,
1587   FACE_UNDER_WAVE
1588 };
1589
1590 /* Structure describing a realized face.
1591
1592    For each Lisp face, 0..N realized faces can exist for different
1593    frames and different charsets.  Realized faces are built from Lisp
1594    faces and text properties/overlays by merging faces and adding
1595    unspecified attributes from the `default' face.  */
1596
1597 struct face
1598 {
1599   /* The Lisp face attributes this face realizes.  All attributes
1600      in this vector are non-nil.  */
1601   Lisp_Object lface[LFACE_VECTOR_SIZE];
1602
1603   /* The id of this face.  The id equals the index of this face in the
1604      vector faces_by_id of its face cache.  */
1605   int id;
1606
1607 #ifdef HAVE_WINDOW_SYSTEM
1608
1609   /* If non-zero, this is a GC that we can use without modification for
1610      drawing the characters in this face.  */
1611   GC gc;
1612
1613   /* Background stipple or bitmap used for this face.  This is
1614      an id as returned from load_pixmap.  */
1615   ptrdiff_t stipple;
1616
1617 #endif /* not HAVE_WINDOW_SYSTEM */
1618
1619   /* Pixel value of foreground color for X frames.  Color index
1620      for tty frames.  */
1621   unsigned long foreground;
1622
1623   /* Pixel value or color index of background color.  */
1624   unsigned long background;
1625
1626   /* Pixel value or color index of underline color.  */
1627   unsigned long underline_color;
1628
1629   /* Pixel value or color index of overlined, strike-through, or box
1630      color.  */
1631   unsigned long overline_color;
1632   unsigned long strike_through_color;
1633   unsigned long box_color;
1634
1635   struct font *font;
1636
1637   /* Fontset ID if for this face's fontset.  Non-ASCII faces derived
1638      from the same ASCII face have the same fontset.  */
1639   int fontset;
1640
1641   /* Non-zero means characters in this face have a box of that
1642      thickness around them.  If this value is negative, its absolute
1643      value indicates the thickness, and the horizontal (top and
1644      bottom) borders of box are drawn inside of the character glyphs'
1645      area.  The vertical (left and right) borders of the box are drawn
1646      in the same way as when this value is positive.  */
1647   int box_line_width;
1648
1649   /* Type of box drawn.  A value of FACE_NO_BOX means no box is drawn
1650      around text in this face.  A value of FACE_SIMPLE_BOX means a box
1651      of width box_line_width is drawn in color box_color.  A value of
1652      FACE_RAISED_BOX or FACE_SUNKEN_BOX means a 3D box is drawn with
1653      shadow colors derived from the background color of the face.  */
1654   ENUM_BF (face_box_type) box : 2;
1655
1656   /* Style of underlining. */
1657   ENUM_BF (face_underline_type) underline_type : 1;
1658
1659   /* If `box' above specifies a 3D type, true means use box_color for
1660      drawing shadows.  */
1661   bool_bf use_box_color_for_shadows_p : 1;
1662
1663   /* Non-zero if text in this face should be underlined, overlined,
1664      strike-through or have a box drawn around it.  */
1665   bool_bf underline_p : 1;
1666   bool_bf overline_p : 1;
1667   bool_bf strike_through_p : 1;
1668
1669   /* True means that the colors specified for this face could not be
1670      loaded, and were replaced by default colors, so they shouldn't be
1671      freed.  */
1672   bool_bf foreground_defaulted_p : 1;
1673   bool_bf background_defaulted_p : 1;
1674
1675   /* True means that either no color is specified for underlining or that
1676      the specified color couldn't be loaded.  Use the foreground
1677      color when drawing in that case. */
1678   bool_bf underline_defaulted_p : 1;
1679
1680   /* True means that either no color is specified for the corresponding
1681      attribute or that the specified color couldn't be loaded.
1682      Use the foreground color when drawing in that case. */
1683   bool_bf overline_color_defaulted_p : 1;
1684   bool_bf strike_through_color_defaulted_p : 1;
1685   bool_bf box_color_defaulted_p : 1;
1686
1687   /* TTY appearances.  Colors are found in `lface' with empty color
1688      string meaning the default color of the TTY.  */
1689   bool_bf tty_bold_p : 1;
1690   bool_bf tty_italic_p : 1;
1691   bool_bf tty_underline_p : 1;
1692   bool_bf tty_reverse_p : 1;
1693
1694   /* True means that colors of this face may not be freed because they
1695      have been copied bitwise from a base face (see
1696      realize_x_face).  */
1697   bool_bf colors_copied_bitwise_p : 1;
1698
1699   /* If non-zero, use overstrike (to simulate bold-face).  */
1700   bool_bf overstrike : 1;
1701
1702 /* NOTE: this is not used yet, but eventually this impl should be done
1703          similarly to overstrike */
1704 #ifdef HAVE_NS
1705   /* If non-zero, use geometric rotation (to simulate italic).  */
1706   bool_bf synth_ital : 1;
1707 #endif
1708
1709   /* The hash value of this face.  */
1710   unsigned hash;
1711
1712   /* Next and previous face in hash collision list of face cache.  */
1713   struct face *next, *prev;
1714
1715   /* If this face is an ASCII face, this points to this face itself.
1716      Otherwise, this points to an ASCII face that has the same
1717      attributes except the font.  */
1718   struct face *ascii_face;
1719
1720 #ifdef HAVE_XFT
1721   /* Extra member that a font-driver uses privately.  */
1722   void *extra;
1723 #endif
1724 };
1725
1726
1727 /* Color index indicating that face uses a terminal's default color.  */
1728
1729 #define FACE_TTY_DEFAULT_COLOR ((unsigned long) -1)
1730
1731 /* Color index indicating that face uses an unknown foreground color.  */
1732
1733 #define FACE_TTY_DEFAULT_FG_COLOR ((unsigned long) -2)
1734
1735 /* Color index indicating that face uses an unknown background color.  */
1736
1737 #define FACE_TTY_DEFAULT_BG_COLOR ((unsigned long) -3)
1738
1739 /* True if COLOR is a specified (i.e., nondefault) foreground or
1740    background color for a tty face.  */
1741
1742 INLINE bool
1743 face_tty_specified_color (unsigned long color)
1744 {
1745   return color < FACE_TTY_DEFAULT_BG_COLOR;
1746 }
1747
1748 /* Non-zero if FACE was realized for unibyte use.  */
1749
1750 #define FACE_UNIBYTE_P(FACE) ((FACE)->charset < 0)
1751
1752
1753 /* IDs of important faces known by the C face code.  These are the IDs
1754    of the faces for CHARSET_ASCII.  */
1755
1756 enum face_id
1757 {
1758   DEFAULT_FACE_ID,
1759   MODE_LINE_FACE_ID,
1760   MODE_LINE_INACTIVE_FACE_ID,
1761   TOOL_BAR_FACE_ID,
1762   FRINGE_FACE_ID,
1763   HEADER_LINE_FACE_ID,
1764   SCROLL_BAR_FACE_ID,
1765   BORDER_FACE_ID,
1766   CURSOR_FACE_ID,
1767   MOUSE_FACE_ID,
1768   MENU_FACE_ID,
1769   VERTICAL_BORDER_FACE_ID,
1770   WINDOW_DIVIDER_FACE_ID,
1771   WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID,
1772   WINDOW_DIVIDER_LAST_PIXEL_FACE_ID,
1773   BASIC_FACE_ID_SENTINEL
1774 };
1775
1776 #define MAX_FACE_ID  ((1 << FACE_ID_BITS) - 1)
1777
1778 /* A cache of realized faces.  Each frame has its own cache because
1779    Emacs allows different frame-local face definitions.  */
1780
1781 struct face_cache
1782 {
1783   /* Hash table of cached realized faces.  */
1784   struct face **buckets;
1785
1786   /* Back-pointer to the frame this cache belongs to.  */
1787   struct frame *f;
1788
1789   /* A vector of faces so that faces can be referenced by an ID.  */
1790   struct face **faces_by_id;
1791
1792   /* The allocated size, and number of used slots of faces_by_id.  */
1793   ptrdiff_t size;
1794   int used;
1795
1796   /* Flag indicating that attributes of the `menu' face have been
1797      changed.  */
1798   bool_bf menu_face_changed_p : 1;
1799 };
1800
1801 /* Return a pointer to the face with ID on frame F, or null if such a
1802    face doesn't exist.  */
1803
1804 #define FACE_FROM_ID(F, ID)                             \
1805      (UNSIGNED_CMP (ID, <, FRAME_FACE_CACHE (F)->used)  \
1806       ? FRAME_FACE_CACHE (F)->faces_by_id[ID]           \
1807       : NULL)
1808
1809 #ifdef HAVE_WINDOW_SYSTEM
1810
1811 /* Non-zero if FACE is suitable for displaying character CHAR.  */
1812
1813 #define FACE_SUITABLE_FOR_ASCII_CHAR_P(FACE, CHAR)      \
1814   ((FACE) == (FACE)->ascii_face)
1815
1816 /* Return the id of the realized face on frame F that is like the face
1817    with id ID but is suitable for displaying character CHAR.
1818    This macro is only meaningful for multibyte character CHAR.  */
1819
1820 #define FACE_FOR_CHAR(F, FACE, CHAR, POS, OBJECT)       \
1821   face_for_char ((F), (FACE), (CHAR), (POS), (OBJECT))
1822
1823 #else /* not HAVE_WINDOW_SYSTEM */
1824
1825 #define FACE_SUITABLE_FOR_ASCII_CHAR_P(FACE, CHAR) true
1826 #define FACE_FOR_CHAR(F, FACE, CHAR, POS, OBJECT) ((FACE)->id)
1827
1828 #endif /* not HAVE_WINDOW_SYSTEM */
1829
1830 /* Return true if G contains a valid character code.  */
1831 INLINE bool
1832 GLYPH_CHAR_VALID_P (GLYPH g)
1833 {
1834   return CHAR_VALID_P (GLYPH_CHAR (g));
1835 }
1836
1837 /* The glyph code from a display vector may either be an integer which
1838    encodes a char code in the lower CHARACTERBITS bits and a (very small)
1839    face-id in the upper bits, or it may be a cons (CHAR . FACE-ID).  */
1840
1841 INLINE bool
1842 GLYPH_CODE_P (Lisp_Object gc)
1843 {
1844   return (CONSP (gc)
1845           ? (CHARACTERP (XCAR (gc))
1846              && RANGED_INTEGERP (0, XCDR (gc), MAX_FACE_ID))
1847           : (RANGED_INTEGERP
1848              (0, gc,
1849               (MAX_FACE_ID < TYPE_MAXIMUM (EMACS_INT) >> CHARACTERBITS
1850                ? ((EMACS_INT) MAX_FACE_ID << CHARACTERBITS) | MAX_CHAR
1851                : TYPE_MAXIMUM (EMACS_INT)))));
1852 }
1853
1854 /* Non-zero means face attributes have been changed since the last
1855    redisplay.  Used in redisplay_internal.  */
1856
1857 extern int face_change_count;
1858
1859 /* For reordering of bidirectional text.  */
1860
1861 /* UAX#9's max_depth value.  */
1862 #define BIDI_MAXDEPTH 125
1863
1864 /* Data type for describing the bidirectional character types.  The
1865    first 7 must be at the beginning, because they are the only values
1866    valid in the `bidi_type' member of `struct glyph'; we only reserve
1867    3 bits for it, so we cannot use there values larger than 7.
1868
1869    The order of members must be in sync with the 8th element of the
1870    member of unidata-prop-alist (in admin/unidata/unidata-gen.el) for
1871    Unicode character property `bidi-class'.  */
1872 typedef enum {
1873   UNKNOWN_BT = 0,
1874   STRONG_L,     /* strong left-to-right */
1875   STRONG_R,     /* strong right-to-left */
1876   WEAK_EN,      /* european number */
1877   WEAK_AN,      /* arabic number */
1878   WEAK_BN,      /* boundary neutral */
1879   NEUTRAL_B,    /* paragraph separator */
1880   STRONG_AL,    /* arabic right-to-left letter */
1881   LRE,          /* left-to-right embedding */
1882   LRO,          /* left-to-right override */
1883   RLE,          /* right-to-left embedding */
1884   RLO,          /* right-to-left override */
1885   PDF,          /* pop directional format */
1886   LRI,          /* left-to-right isolate */
1887   RLI,          /* right-to-left isolate */
1888   FSI,          /* first strong isolate */
1889   PDI,          /* pop directional isolate */
1890   WEAK_ES,      /* european number separator */
1891   WEAK_ET,      /* european number terminator */
1892   WEAK_CS,      /* common separator */
1893   WEAK_NSM,     /* non-spacing mark */
1894   NEUTRAL_S,    /* segment separator */
1895   NEUTRAL_WS,   /* whitespace */
1896   NEUTRAL_ON    /* other neutrals */
1897 } bidi_type_t;
1898
1899 /* Data type for describing the Bidi Paired Bracket Type of a character.
1900
1901    The order of members must be in sync with the 8th element of the
1902    member of unidata-prop-alist (in admin/unidata/unidata-gen.el) for
1903    Unicode character property `bracket-type'.  */
1904 typedef enum {
1905   BIDI_BRACKET_NONE = 1,
1906   BIDI_BRACKET_OPEN,
1907   BIDI_BRACKET_CLOSE
1908 } bidi_bracket_type_t;
1909
1910 /* The basic directionality data type.  */
1911 typedef enum { NEUTRAL_DIR, L2R, R2L } bidi_dir_t;
1912
1913 /* Data type for storing information about characters we need to
1914    remember.  */
1915 struct bidi_saved_info {
1916   ptrdiff_t charpos;            /* character's buffer position */
1917   bidi_type_t type;             /* character's resolved bidi type */
1918   bidi_type_t orig_type;        /* bidi type as we found it in the buffer */
1919 };
1920
1921 /* Data type for keeping track of information about saved embedding
1922    levels, override status, isolate status, and isolating sequence
1923    runs.  */
1924 struct bidi_stack {
1925   struct bidi_saved_info last_strong;
1926   struct bidi_saved_info next_for_neutral;
1927   struct bidi_saved_info prev_for_neutral;
1928   unsigned level : 7;
1929   bool_bf isolate_status : 1;
1930   unsigned override : 2;
1931   unsigned sos : 2;
1932 };
1933
1934 /* Data type for storing information about a string being iterated on.  */
1935 struct bidi_string_data {
1936   Lisp_Object lstring;          /* Lisp string to reorder, or nil */
1937   const unsigned char *s;       /* string data, or NULL if reordering buffer */
1938   ptrdiff_t schars;             /* the number of characters in the string,
1939                                    excluding the terminating null */
1940   ptrdiff_t bufpos;             /* buffer position of lstring, or 0 if N/A */
1941   bool_bf from_disp_str : 1;    /* True means the string comes from a
1942                                    display property */
1943   bool_bf unibyte : 1;          /* True means the string is unibyte */
1944 };
1945
1946 /* Data type for reordering bidirectional text.  */
1947 struct bidi_it {
1948   ptrdiff_t bytepos;            /* iterator's position in buffer/string */
1949   ptrdiff_t charpos;
1950   int ch;                       /* character at that position, or u+FFFC
1951                                    ("object replacement character") for a run
1952                                    of characters covered by a display string */
1953   ptrdiff_t nchars;             /* its "length", usually 1; it's > 1 for a run
1954                                    of characters covered by a display string */
1955   ptrdiff_t ch_len;             /* its length in bytes */
1956   bidi_type_t type;             /* final bidi type of this character, after
1957                                    resolving weak and neutral types */
1958   bidi_type_t type_after_wn;    /* bidi type after overrides and Wn */
1959   bidi_type_t orig_type;        /* original bidi type, as found in the buffer */
1960   char resolved_level;          /* final resolved level of this character */
1961   char isolate_level;           /* count of isolate initiators unmatched by PDI */
1962   ptrdiff_t invalid_levels;     /* how many PDFs to ignore */
1963   ptrdiff_t invalid_isolates;   /* how many PDIs to ignore */
1964   struct bidi_saved_info prev;  /* info about previous character */
1965   struct bidi_saved_info last_strong; /* last-seen strong directional char */
1966   struct bidi_saved_info next_for_neutral; /* surrounding characters for... */
1967   struct bidi_saved_info prev_for_neutral; /* ...resolving neutrals */
1968   struct bidi_saved_info next_for_ws; /* character after sequence of ws */
1969   ptrdiff_t bracket_pairing_pos;        /* position of pairing bracket */
1970   bidi_type_t bracket_enclosed_type;    /* type for bracket resolution */
1971   ptrdiff_t next_en_pos;        /* pos. of next char for determining ET type */
1972   bidi_type_t next_en_type;     /* type of char at next_en_pos */
1973   bidi_dir_t sos;               /* direction of start-of-sequence in effect */
1974   int scan_dir;                 /* direction of text scan, 1: forw, -1: back */
1975   ptrdiff_t disp_pos;           /* position of display string after ch */
1976   int disp_prop;                /* if non-zero, there really is a
1977                                    `display' property/string at disp_pos;
1978                                    if 2, the property is a `space' spec */
1979   int stack_idx;                /* index of current data on the stack */
1980   /* Note: Everything from here on is not copied/saved when the bidi
1981      iterator state is saved, pushed, or popped.  So only put here
1982      stuff that is not part of the bidi iterator's state!  */
1983   struct bidi_stack level_stack[BIDI_MAXDEPTH+2+1]; /* directional status stack */
1984   struct bidi_string_data string;       /* string to reorder */
1985   struct window *w;             /* the window being displayed */
1986   bidi_dir_t paragraph_dir;     /* current paragraph direction */
1987   ptrdiff_t separator_limit;    /* where paragraph separator should end */
1988   bool_bf first_elt : 1;        /* if true, examine current char first */
1989   bool_bf new_paragraph : 1;    /* if true, we expect a new paragraph */
1990   bool_bf frame_window_p : 1;   /* true if displaying on a GUI frame */
1991 };
1992
1993 /* Value is non-zero when the bidi iterator is at base paragraph
1994    embedding level.  */
1995 #define BIDI_AT_BASE_LEVEL(BIDI_IT) \
1996   ((BIDI_IT).resolved_level == (BIDI_IT).level_stack[0].level)
1997
1998 \f
1999 /***********************************************************************
2000                                Fringes
2001  ***********************************************************************/
2002
2003 /* Structure used to describe where and how to draw a fringe bitmap.
2004    WHICH is the fringe bitmap to draw.  WD and H is the (adjusted)
2005    width and height of the bitmap, DH is the height adjustment (if
2006    bitmap is periodic).  X and Y are frame coordinates of the area to
2007    display the bitmap, DY is relative offset of the bitmap into that
2008    area.  BX, NX, BY, NY specifies the area to clear if the bitmap
2009    does not fill the entire area.  FACE is the fringe face.  */
2010
2011 struct draw_fringe_bitmap_params
2012 {
2013   int which;  /* enum fringe_bitmap_type */
2014   unsigned short *bits;
2015   int wd, h, dh;
2016   int x, y;
2017   int bx, nx, by, ny;
2018   bool_bf cursor_p : 1;
2019   bool_bf overlay_p : 1;
2020   struct face *face;
2021 };
2022
2023 #define MAX_FRINGE_BITMAPS (1<<FRINGE_ID_BITS)
2024
2025 \f
2026 /***********************************************************************
2027                             Display Iterator
2028  ***********************************************************************/
2029
2030 /* Iteration over things to display in current_buffer or in a string.
2031
2032    The iterator handles:
2033
2034    1. Overlay strings (after-string, before-string).
2035    2. Face properties.
2036    3. Invisible text properties.
2037    4. Selective display.
2038    5. Translation of characters via display tables.
2039    6. Translation of control characters to the forms `\003' or `^C'.
2040    7. `glyph' and `space-width' properties.
2041
2042    Iterators are initialized by calling init_iterator or one of the
2043    equivalent functions below.  A call to get_next_display_element
2044    loads the iterator structure with information about what next to
2045    display.  A call to set_iterator_to_next increments the iterator's
2046    position.
2047
2048    Characters from overlay strings, display table entries or control
2049    character translations are returned one at a time.  For example, if
2050    we have a text of `a\x01' where `a' has a display table definition
2051    of `cd' and the control character is displayed with a leading
2052    arrow, then the iterator will return:
2053
2054    Call         Return  Source          Call next
2055    -----------------------------------------------------------------
2056    next         c       display table   move
2057    next         d       display table   move
2058    next         ^       control char    move
2059    next         A       control char    move
2060
2061    The same mechanism is also used to return characters for ellipses
2062    displayed at the end of invisible text.
2063
2064    CAVEAT: Under some circumstances, move_.* functions can be called
2065    asynchronously, e.g. when computing a buffer position from an x and
2066    y pixel position.  This means that these functions and functions
2067    called from them SHOULD NOT USE xmalloc and alike.  See also the
2068    comment at the start of xdisp.c.  */
2069
2070 /* Enumeration describing what kind of display element an iterator is
2071    loaded with after a call to get_next_display_element.  */
2072
2073 enum display_element_type
2074 {
2075   /* A normal character.  */
2076   IT_CHARACTER,
2077
2078   /* A composition (static and automatic).  */
2079   IT_COMPOSITION,
2080
2081   /* A glyphless character (e.g. ZWNJ, LRE).  */
2082   IT_GLYPHLESS,
2083
2084   /* An image.  */
2085   IT_IMAGE,
2086
2087   /* A flexible width and height space.  */
2088   IT_STRETCH,
2089
2090   /* End of buffer or string.  */
2091   IT_EOB,
2092
2093   /* Truncation glyphs.  Never returned by get_next_display_element.
2094      Used to get display information about truncation glyphs via
2095      produce_glyphs.  */
2096   IT_TRUNCATION,
2097
2098   /* Continuation glyphs.  See the comment for IT_TRUNCATION.  */
2099   IT_CONTINUATION
2100 };
2101
2102
2103 /* An enumerator for each text property that has a meaning for display
2104    purposes.  */
2105
2106 enum prop_idx
2107 {
2108   FONTIFIED_PROP_IDX,
2109   FACE_PROP_IDX,
2110   INVISIBLE_PROP_IDX,
2111   DISPLAY_PROP_IDX,
2112   COMPOSITION_PROP_IDX,
2113
2114   /* Not a property.  Used to indicate changes in overlays.  */
2115   OVERLAY_PROP_IDX,
2116
2117   /* Sentinel.  */
2118   LAST_PROP_IDX
2119 };
2120
2121 /* An enumerator for the method of wrapping long lines.  */
2122
2123 enum line_wrap_method
2124 {
2125   TRUNCATE,
2126   WORD_WRAP,
2127   WINDOW_WRAP
2128 };
2129
2130 /* An enumerator for the method of displaying glyphless characters.  */
2131
2132 enum glyphless_display_method
2133   {
2134     /* Display a thin (1-pixel width) space.  On a TTY, display a
2135        1-character width space.  */
2136     GLYPHLESS_DISPLAY_THIN_SPACE,
2137     /* Display an empty box of proper width.  */
2138     GLYPHLESS_DISPLAY_EMPTY_BOX,
2139     /* Display an acronym string in a box.  */
2140     GLYPHLESS_DISPLAY_ACRONYM,
2141     /* Display the hexadecimal code of the character in a box.  */
2142     GLYPHLESS_DISPLAY_HEX_CODE
2143   };
2144
2145 struct it_slice
2146 {
2147   Lisp_Object x;
2148   Lisp_Object y;
2149   Lisp_Object width;
2150   Lisp_Object height;
2151 };
2152
2153 /* Input sources for fetching characters or data to display.
2154    The input source is found in the `method' field.  */
2155
2156 enum it_method {
2157   GET_FROM_BUFFER = 0,
2158   GET_FROM_DISPLAY_VECTOR,
2159   GET_FROM_STRING,
2160   GET_FROM_C_STRING,
2161   GET_FROM_IMAGE,
2162   GET_FROM_STRETCH,
2163   NUM_IT_METHODS
2164 };
2165
2166 /* FIXME: What is this?  Why 5?  */
2167 #define IT_STACK_SIZE 5
2168
2169 /* Iterator for composition (both for static and automatic).  */
2170 struct composition_it
2171 {
2172   /* Next position at which to check the composition.  */
2173   ptrdiff_t stop_pos;
2174   /* ID number of the composition or glyph-string.  If negative, we
2175      are not iterating over a composition now.  */
2176   ptrdiff_t id;
2177   /* If non-negative, character that triggers the automatic
2178      composition at `stop_pos', and this is an automatic composition.
2179      If negative, this is a static composition.  This is set to -2
2180      temporarily if searching of composition reach a limit or a
2181      newline.  */
2182   int ch;
2183   /* If this is an automatic composition, index of a rule for making
2184      the automatic composition.  Provided that ELT is an element of
2185      Vcomposition_function_table for CH, (nth ELT RULE_IDX) is the
2186      rule for the composition.  */
2187   int rule_idx;
2188   /* If this is an automatic composition, how many characters to look
2189      back from the position where a character triggering the
2190      composition exists.  */
2191   ptrdiff_t lookback;
2192   /* If non-negative, number of glyphs of the glyph-string.  */
2193   int nglyphs;
2194   /* True iff the composition is created while buffer is scanned in
2195      reverse order, and thus the grapheme clusters must be rendered
2196      from the last to the first.  */
2197   bool reversed_p;
2198
2199   /** The following members contain information about the current
2200       grapheme cluster.  */
2201   /* Position of the first character of the current grapheme cluster.  */
2202   ptrdiff_t charpos;
2203   /* Number of characters and bytes of the current grapheme cluster.  */
2204   int nchars, nbytes;
2205   /* Indices of the glyphs for the current grapheme cluster.  */
2206   int from, to;
2207   /* Width of the current grapheme cluster in units of columns it will
2208      occupy on display; see CHAR_WIDTH.  */
2209   int width;
2210 };
2211
2212 struct it
2213 {
2214   /* The window in which we iterate over current_buffer (or a string).  */
2215   Lisp_Object window;
2216   struct window *w;
2217
2218   /* The window's frame.  */
2219   struct frame *f;
2220
2221   /* Method to use to load this structure with the next display element.  */
2222   enum it_method method;
2223
2224   /* The next position at which to check for face changes, invisible
2225      text, overlay strings, end of text etc., which see.  */
2226   ptrdiff_t stop_charpos;
2227
2228   /* Previous stop position, i.e. the last one before the current
2229      iterator position in `current'.  */
2230   ptrdiff_t prev_stop;
2231
2232   /* Last stop position iterated across whose bidi embedding level is
2233      equal to the current paragraph's base embedding level.  */
2234   ptrdiff_t base_level_stop;
2235
2236   /* Maximum string or buffer position + 1.  ZV when iterating over
2237      current_buffer.  */
2238   ptrdiff_t end_charpos;
2239
2240   /* C string to iterate over.  Non-null means get characters from
2241      this string, otherwise characters are read from current_buffer
2242      or it->string.  */
2243   const unsigned char *s;
2244
2245   /* Number of characters in the string (s, or it->string) we iterate
2246      over.  Used only in display_string and its subroutines; never
2247      used for overlay strings and strings from display properties.  */
2248   ptrdiff_t string_nchars;
2249
2250   /* Position at which redisplay end trigger functions should be run.  */
2251   ptrdiff_t redisplay_end_trigger_charpos;
2252
2253   /* True means multibyte characters are enabled.  */
2254   bool_bf multibyte_p : 1;
2255
2256   /* True means window has a mode line at its top.  */
2257   bool_bf header_line_p : 1;
2258
2259   /* True means `string' is the value of a `display' property.
2260      Don't handle some `display' properties in these strings.  */
2261   bool_bf string_from_display_prop_p : 1;
2262
2263   /* True means `string' comes from a `line-prefix' or `wrap-prefix'
2264      property.  */
2265   bool_bf string_from_prefix_prop_p : 1;
2266
2267   /* True means we are iterating an object that came from a value of a
2268      `display' property.  */
2269   bool_bf from_disp_prop_p : 1;
2270
2271   /* When METHOD == next_element_from_display_vector,
2272      this is true if we're doing an ellipsis.  Otherwise meaningless.  */
2273   bool_bf ellipsis_p : 1;
2274
2275   /* True means cursor shouldn't be displayed here.  */
2276   bool_bf avoid_cursor_p : 1;
2277
2278   /* Display table in effect or null for none.  */
2279   struct Lisp_Char_Table *dp;
2280
2281   /* Current display table vector to return characters from and its
2282      end.  dpvec null means we are not returning characters from a
2283      display table entry; current.dpvec_index gives the current index
2284      into dpvec.  This same mechanism is also used to return
2285      characters from translated control characters, i.e. `\003' or
2286      `^C'.  */
2287   Lisp_Object *dpvec, *dpend;
2288
2289   /* Length in bytes of the char that filled dpvec.  A value of zero
2290      means that no such character is involved.  A negative value means
2291      the rest of the line from the current iterator position onwards
2292      is hidden by selective display or ellipsis.  */
2293   int dpvec_char_len;
2294
2295   /* Face id to use for all characters in display vector.  -1 if unused. */
2296   int dpvec_face_id;
2297
2298   /* Face id of the iterator saved in case a glyph from dpvec contains
2299      a face.  The face is restored when all glyphs from dpvec have
2300      been delivered.  */
2301   int saved_face_id;
2302
2303   /* Vector of glyphs for control character translation.  The pointer
2304      dpvec is set to ctl_chars when a control character is translated.
2305      This vector is also used for incomplete multibyte character
2306      translation (e.g \222\244).  Such a character is at most 4 bytes,
2307      thus we need at most 16 bytes here.  */
2308   Lisp_Object ctl_chars[16];
2309
2310   /* Initial buffer or string position of the iterator, before skipping
2311      over display properties and invisible text.  */
2312   struct display_pos start;
2313
2314   /* Current buffer or string position of the iterator, including
2315      position in overlay strings etc.  */
2316   struct display_pos current;
2317
2318   /* Total number of overlay strings to process.  This can be >
2319      OVERLAY_STRING_CHUNK_SIZE.  Value is dependable only when
2320      current.overlay_string_index >= 0.  Use the latter to determine
2321      whether an overlay string is being iterated over, because
2322      n_overlay_strings can be positive even when we are not rendering
2323      an overlay string.  */
2324   ptrdiff_t n_overlay_strings;
2325
2326   /* The charpos where n_overlay_strings was calculated.  This should
2327      be set at the same time as n_overlay_strings.  It is needed
2328      because we show before-strings at the start of invisible text;
2329      see handle_invisible_prop in xdisp.c.  */
2330   ptrdiff_t overlay_strings_charpos;
2331
2332   /* Vector of overlays to process.  Overlay strings are processed
2333      OVERLAY_STRING_CHUNK_SIZE at a time.  */
2334 #define OVERLAY_STRING_CHUNK_SIZE 16
2335   Lisp_Object overlay_strings[OVERLAY_STRING_CHUNK_SIZE];
2336
2337   /* For each overlay string, the overlay it came from.  */
2338   Lisp_Object string_overlays[OVERLAY_STRING_CHUNK_SIZE];
2339
2340   /* If non-nil, a Lisp string being processed.  If
2341      current.overlay_string_index >= 0, this is an overlay string from
2342      pos.  Use STRINGP (it.string) to test whether we are rendering a
2343      string or something else; do NOT use BUFFERP (it.object).  */
2344   Lisp_Object string;
2345
2346   /* If non-nil, we are processing a string that came
2347      from a `display' property given by an overlay.  */
2348   Lisp_Object from_overlay;
2349
2350   /* Stack of saved values.  New entries are pushed when we begin to
2351      process an overlay string or a string from a `glyph' property.
2352      Entries are popped when we return to deliver display elements
2353      from what we previously had.  */
2354   struct iterator_stack_entry
2355   {
2356     Lisp_Object string;
2357     int string_nchars;
2358     ptrdiff_t end_charpos;
2359     ptrdiff_t stop_charpos;
2360     ptrdiff_t prev_stop;
2361     ptrdiff_t base_level_stop;
2362     struct composition_it cmp_it;
2363     int face_id;
2364
2365     /* Save values specific to a given method.  */
2366     union {
2367       /* method == GET_FROM_IMAGE */
2368       struct {
2369         Lisp_Object object;
2370         struct it_slice slice;
2371         ptrdiff_t image_id;
2372       } image;
2373       /* method == GET_FROM_COMPOSITION */
2374       struct {
2375         Lisp_Object object;
2376       } comp;
2377       /* method == GET_FROM_STRETCH */
2378       struct {
2379         Lisp_Object object;
2380       } stretch;
2381     } u;
2382
2383     /* Current text and display positions.  */
2384     struct text_pos position;
2385     struct display_pos current;
2386     Lisp_Object from_overlay;
2387     enum glyph_row_area area;
2388     enum it_method method;
2389     bidi_dir_t paragraph_embedding;
2390     bool_bf multibyte_p : 1;
2391     bool_bf string_from_display_prop_p : 1;
2392     bool_bf string_from_prefix_prop_p : 1;
2393     bool_bf display_ellipsis_p : 1;
2394     bool_bf avoid_cursor_p : 1;
2395     bool_bf bidi_p : 1;
2396     bool_bf from_disp_prop_p : 1;
2397     enum line_wrap_method line_wrap;
2398
2399     /* Properties from display property that are reset by another display
2400        property.  */
2401     short voffset;
2402     Lisp_Object space_width;
2403     Lisp_Object font_height;
2404   }
2405   stack[IT_STACK_SIZE];
2406
2407   /* Stack pointer.  */
2408   int sp;
2409
2410   /* -1 means selective display hides everything between a \r and the
2411      next newline; > 0 means hide lines indented more than that value.  */
2412   ptrdiff_t selective;
2413
2414   /* An enumeration describing what the next display element is
2415      after a call to get_next_display_element.  */
2416   enum display_element_type what;
2417
2418   /* Face to use.  */
2419   int face_id;
2420
2421   /* Setting of buffer-local variable selective-display-ellipsis.  */
2422   bool_bf selective_display_ellipsis_p : 1;
2423
2424   /* True means control characters are translated into the form `^C'
2425      where the `^' can be replaced by a display table entry.  */
2426   bool_bf ctl_arrow_p : 1;
2427
2428   /* True means that the current face has a box.  */
2429   bool_bf face_box_p : 1;
2430
2431   /* Non-null means that the current character is the first in a run
2432      of characters with box face.  */
2433   bool_bf start_of_box_run_p : 1;
2434
2435   /* True means that the current character is the last in a run
2436      of characters with box face.  */
2437   bool_bf end_of_box_run_p : 1;
2438
2439   /* True means overlay strings at end_charpos have been processed.  */
2440   bool_bf overlay_strings_at_end_processed_p : 1;
2441
2442   /* True means to ignore overlay strings at current pos, as they have
2443      already been processed.  */
2444   bool_bf ignore_overlay_strings_at_pos_p : 1;
2445
2446   /* True means the actual glyph is not available in the current
2447      system.  */
2448   bool_bf glyph_not_available_p : 1;
2449
2450   /* True means the next line in display_line continues a character
2451      consisting of more than one glyph, and some glyphs of this
2452      character have been put on the previous line.  */
2453   bool_bf starts_in_middle_of_char_p : 1;
2454
2455   /* If true, saved_face_id contains the id of the face in front of text
2456      skipped due to selective display.  */
2457   bool_bf face_before_selective_p : 1;
2458
2459   /* If true, adjust current glyph so it does not increase current row
2460      descent/ascent (line-height property).  Reset after this glyph.  */
2461   bool_bf constrain_row_ascent_descent_p : 1;
2462
2463   enum line_wrap_method line_wrap;
2464
2465   /* The ID of the default face to use.  One of DEFAULT_FACE_ID,
2466      MODE_LINE_FACE_ID, etc, depending on what we are displaying.  */
2467   int base_face_id;
2468
2469   /* If `what' == IT_CHARACTER, the character and the length in bytes
2470      of its multibyte sequence.  The character comes from a buffer or
2471      a string.  It may be different from the character displayed in
2472      case that unibyte_display_via_language_environment is set.
2473
2474      If `what' == IT_COMPOSITION, the first component of a composition
2475      and length in bytes of the composition.
2476
2477      If `what' is anything else, these two are undefined (will
2478      probably hold values for the last IT_CHARACTER or IT_COMPOSITION
2479      traversed by the iterator.
2480
2481      The values are updated by get_next_display_element, so they are
2482      out of sync with the value returned by IT_CHARPOS between the
2483      time set_iterator_to_next advances the position and the time
2484      get_next_display_element loads the new values into c and len.  */
2485   int c, len;
2486
2487   /* If what == IT_COMPOSITION, iterator substructure for the
2488      composition.  */
2489   struct composition_it cmp_it;
2490
2491   /* The character to display, possibly translated to multibyte if
2492      multibyte_p is zero or unibyte_display_via_language_environment
2493      is set.  This is set after get_next_display_element has been
2494      called.  If we are setting it->C directly before calling
2495      PRODUCE_GLYPHS, this should be set beforehand too.  */
2496   int char_to_display;
2497
2498   /* If what == IT_GLYPHLESS, the method to display such a
2499      character.  */
2500   enum glyphless_display_method glyphless_method;
2501
2502   /* If what == IT_IMAGE, the id of the image to display.  */
2503   ptrdiff_t image_id;
2504
2505   /* Values from `slice' property.  */
2506   struct it_slice slice;
2507
2508   /* Value of the `space-width' property, if any; nil if none.  */
2509   Lisp_Object space_width;
2510
2511   /* Computed from the value of the `raise' property.  */
2512   short voffset;
2513
2514   /* Number of columns per \t.  */
2515   short tab_width;
2516
2517   /* Value of the `height' property, if any; nil if none.  */
2518   Lisp_Object font_height;
2519
2520   /* Object and position where the current display element came from.
2521      Object is normally the buffer which is being rendered, but it can
2522      also be a Lisp string in case the current display element comes
2523      from an overlay string or from a display string (before- or
2524      after-string).  It may also be nil when a C string is being
2525      rendered, e.g., during mode-line or header-line update.  It can
2526      also be a cons cell of the form `(space ...)', when we produce a
2527      stretch glyph from a `display' specification.  Finally, it can be
2528      a zero-valued Lisp integer, but only temporarily, when we are
2529      producing special glyphs for display purposes, like truncation
2530      and continuation glyphs, or blanks that extend each line to the
2531      edge of the window on a TTY.
2532
2533      Do NOT use !BUFFERP (it.object) as a test whether we are
2534      iterating over a string; use STRINGP (it.string) instead.
2535
2536      Position is the current iterator position in object.  */
2537   Lisp_Object object;
2538   struct text_pos position;
2539
2540   /* Width in pixels of truncation and continuation glyphs.  */
2541   short truncation_pixel_width, continuation_pixel_width;
2542
2543   /* First and last visible x-position in the display area.  If window
2544      is hscrolled by n columns, first_visible_x == n * FRAME_COLUMN_WIDTH
2545      (f), and last_visible_x == pixel width of W + first_visible_x.
2546      When truncation or continuation glyphs are produced due to lack of
2547      fringes, last_visible_x excludes the space required for these glyphs.  */
2548   int first_visible_x, last_visible_x;
2549
2550   /* Last visible y-position + 1 in the display area without a mode
2551      line, if the window has one.  */
2552   int last_visible_y;
2553
2554   /* Default amount of additional space in pixels between lines (for
2555      window systems only.)  */
2556   int extra_line_spacing;
2557
2558   /* Max extra line spacing added in this row.  */
2559   int max_extra_line_spacing;
2560
2561   /* Override font height information for this glyph.
2562      Used if override_ascent >= 0.  Cleared after this glyph.  */
2563   int override_ascent, override_descent, override_boff;
2564
2565   /* If non-null, glyphs are produced in glyph_row with each call to
2566      produce_glyphs.  */
2567   struct glyph_row *glyph_row;
2568
2569   /* The area of glyph_row to which glyphs are added.  */
2570   enum glyph_row_area area;
2571
2572   /* Number of glyphs needed for the last character requested via
2573      produce_glyphs.  This is 1 except for tabs.  */
2574   int nglyphs;
2575
2576   /* Width of the display element in pixels.  Result of
2577      produce_glyphs.  */
2578   int pixel_width;
2579
2580   /* Current, maximum logical, and maximum physical line height
2581      information.  Result of produce_glyphs.  */
2582   int ascent, descent, max_ascent, max_descent;
2583   int phys_ascent, phys_descent, max_phys_ascent, max_phys_descent;
2584
2585   /* Current x pixel position within the display line.  This value
2586      does not include the width of continuation lines in front of the
2587      line.  The value of current_x is automatically incremented by
2588      pixel_width with each call to produce_glyphs.  */
2589   int current_x;
2590
2591   /* Accumulated width of continuation lines.  If > 0, this means we
2592      are currently in a continuation line.  This is initially zero and
2593      incremented/reset by display_line, move_it_to etc.  */
2594   int continuation_lines_width;
2595
2596   /* Buffer position that ends the buffer text line being iterated.
2597      This is normally the position after the newline at EOL.  If this
2598      is the last line of the buffer and it doesn't have a newline,
2599      value is ZV/ZV_BYTE.  Set and used only if IT->bidi_p, for
2600      setting the end position of glyph rows produced for continuation
2601      lines, see display_line.  */
2602   struct text_pos eol_pos;
2603
2604   /* Current y-position.  Automatically incremented by the height of
2605      glyph_row in move_it_to and display_line.  */
2606   int current_y;
2607
2608   /* Vertical matrix position of first text line in window.  */
2609   int first_vpos;
2610
2611   /* Current vertical matrix position, or line number.  Automatically
2612      incremented by move_it_to and display_line.  */
2613   int vpos;
2614
2615   /* Horizontal matrix position reached in move_it_in_display_line.
2616      Only set there, not in display_line, and only when the X
2617      coordinate is past first_visible_x.  */
2618   int hpos;
2619
2620   /* Left fringe bitmap number (enum fringe_bitmap_type).  */
2621   unsigned left_user_fringe_bitmap : FRINGE_ID_BITS;
2622
2623   /* Right fringe bitmap number (enum fringe_bitmap_type).  */
2624   unsigned right_user_fringe_bitmap : FRINGE_ID_BITS;
2625
2626   /* Face of the left fringe glyph.  */
2627   unsigned left_user_fringe_face_id : FACE_ID_BITS;
2628
2629   /* Face of the right fringe glyph.  */
2630   unsigned right_user_fringe_face_id : FACE_ID_BITS;
2631
2632   /* True means we need to reorder bidirectional text for display
2633      in the visual order.  */
2634   bool_bf bidi_p : 1;
2635
2636   /* For iterating over bidirectional text.  */
2637   struct bidi_it bidi_it;
2638   bidi_dir_t paragraph_embedding;
2639 };
2640
2641
2642 /* Access to positions of iterator IT.  */
2643
2644 #define IT_CHARPOS(IT)          CHARPOS ((IT).current.pos)
2645 #define IT_BYTEPOS(IT)          BYTEPOS ((IT).current.pos)
2646 #define IT_STRING_CHARPOS(IT)   CHARPOS ((IT).current.string_pos)
2647 #define IT_STRING_BYTEPOS(IT)   BYTEPOS ((IT).current.string_pos)
2648
2649 /* Test if IT has reached the end of its buffer or string.  This will
2650    only work after get_next_display_element has been called.  */
2651
2652 #define ITERATOR_AT_END_P(IT) ((IT)->what == IT_EOB)
2653
2654 /* True means IT is at the end of a line.  This is the case if it
2655    is either on a newline or on a carriage return and selective
2656    display hides the rest of the line.  */
2657
2658 #define ITERATOR_AT_END_OF_LINE_P(IT)                   \
2659      ((IT)->what == IT_CHARACTER                        \
2660       && ((IT)->c == '\n'                               \
2661           || ((IT)->c == '\r' && (IT)->selective)))
2662
2663 /* Call produce_glyphs or FRAME_RIF->produce_glyphs, if set.  Shortcut
2664    to avoid the function call overhead.  */
2665
2666 #define PRODUCE_GLYPHS(IT)                              \
2667   do {                                                  \
2668     if ((IT)->glyph_row != NULL && (IT)->bidi_p)        \
2669       (IT)->glyph_row->reversed_p = (IT)->bidi_it.paragraph_dir == R2L; \
2670     if (FRAME_RIF ((IT)->f) != NULL)                    \
2671       FRAME_RIF ((IT)->f)->produce_glyphs ((IT));       \
2672     else                                                \
2673       produce_glyphs ((IT));                            \
2674     if ((IT)->glyph_row != NULL)                        \
2675       inhibit_free_realized_faces = true;               \
2676   } while (false)
2677
2678 /* Bit-flags indicating what operation move_it_to should perform.  */
2679
2680 enum move_operation_enum
2681 {
2682   /* Stop if specified x-position is reached.  */
2683   MOVE_TO_X = 0x01,
2684
2685   /* Stop if specified y-position is reached.  */
2686   MOVE_TO_Y = 0x02,
2687
2688   /* Stop if specified vpos is reached.  */
2689   MOVE_TO_VPOS = 0x04,
2690
2691   /* Stop if specified buffer or string position is reached.  */
2692   MOVE_TO_POS = 0x08
2693 };
2694
2695 /***********************************************************************
2696                             Mouse Highlight
2697  ***********************************************************************/
2698
2699 /* Structure to hold mouse highlight data.  */
2700
2701 typedef struct {
2702   /* These variables describe the range of text currently shown in its
2703      mouse-face, together with the window they apply to.  As long as
2704      the mouse stays within this range, we need not redraw anything on
2705      its account.  Rows and columns are glyph matrix positions in
2706      MOUSE_FACE_WINDOW.  */
2707   int mouse_face_beg_row, mouse_face_beg_col, mouse_face_beg_x;
2708   int mouse_face_end_row, mouse_face_end_col, mouse_face_end_x;
2709   Lisp_Object mouse_face_window;
2710   int mouse_face_face_id;
2711   Lisp_Object mouse_face_overlay;
2712
2713   /* FRAME and X, Y position of mouse when last checked for
2714      highlighting.  X and Y can be negative or out of range for the frame.  */
2715   struct frame *mouse_face_mouse_frame;
2716   int mouse_face_mouse_x, mouse_face_mouse_y;
2717
2718   /* Nonzero if part of the text currently shown in
2719      its mouse-face is beyond the window end.  */
2720   bool_bf mouse_face_past_end : 1;
2721
2722   /* True means defer mouse-motion highlighting.  */
2723   bool_bf mouse_face_defer : 1;
2724
2725   /* True means that the mouse highlight should not be shown.  */
2726   bool_bf mouse_face_hidden : 1;
2727 } Mouse_HLInfo;
2728
2729 INLINE void
2730 reset_mouse_highlight (Mouse_HLInfo *hlinfo)
2731 {
2732
2733     hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
2734     hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
2735     hlinfo->mouse_face_mouse_x = hlinfo->mouse_face_mouse_y = 0;
2736     hlinfo->mouse_face_beg_x = hlinfo->mouse_face_end_x = 0;
2737     hlinfo->mouse_face_face_id = DEFAULT_FACE_ID;
2738     hlinfo->mouse_face_mouse_frame = NULL;
2739     hlinfo->mouse_face_window = Qnil;
2740     hlinfo->mouse_face_overlay = Qnil;
2741     hlinfo->mouse_face_past_end = false;
2742     hlinfo->mouse_face_hidden = false;
2743     hlinfo->mouse_face_defer = false;
2744 }
2745
2746 /***********************************************************************
2747                    Window-based redisplay interface
2748  ***********************************************************************/
2749
2750 /* Structure used to describe runs of lines that must be scrolled.  */
2751
2752 struct run
2753 {
2754   /* Source and destination y pixel position.  */
2755   int desired_y, current_y;
2756
2757   /* Source and destination vpos in matrix.  */
2758   int desired_vpos, current_vpos;
2759
2760   /* Height in pixels, number of glyph rows.  */
2761   int height, nrows;
2762 };
2763
2764
2765 /* Handlers for setting frame parameters.  */
2766
2767 typedef void (*frame_parm_handler) (struct frame *, Lisp_Object, Lisp_Object);
2768
2769
2770 /* Structure holding system-dependent interface functions needed
2771    for window-based redisplay.  */
2772
2773 struct redisplay_interface
2774 {
2775   /* Handlers for setting frame parameters.  */
2776   frame_parm_handler *frame_parm_handlers;
2777
2778   /* Produce glyphs/get display metrics for the display element IT is
2779      loaded with.  */
2780   void (*produce_glyphs) (struct it *it);
2781
2782   /* Write or insert LEN glyphs from STRING at the nominal output
2783      position.  */
2784   void (*write_glyphs) (struct window *w, struct glyph_row *row,
2785                         struct glyph *string, enum glyph_row_area area,
2786                         int len);
2787   void (*insert_glyphs) (struct window *w, struct glyph_row *row,
2788                          struct glyph *start, enum glyph_row_area area,
2789                          int len);
2790
2791   /* Clear from nominal output position to X.  X < 0 means clear
2792      to right end of display.  */
2793   void (*clear_end_of_line) (struct window *w, struct glyph_row *row,
2794                              enum glyph_row_area area, int x);
2795
2796   /* Function to call to scroll the display as described by RUN on
2797      window W.  */
2798   void (*scroll_run_hook) (struct window *w, struct run *run);
2799
2800   /* Function to call after a line in a display has been completely
2801      updated.  Used to draw truncation marks and alike.  DESIRED_ROW
2802      is the desired row which has been updated.  */
2803   void (*after_update_window_line_hook) (struct window *w,
2804                                          struct glyph_row *desired_row);
2805
2806   /* Function to call before beginning to update window W in
2807      window-based redisplay.  */
2808   void (*update_window_begin_hook) (struct window *w);
2809
2810   /* Function to call after window W has been updated in window-based
2811      redisplay.  CURSOR_ON_P true means switch cursor on.
2812      MOUSE_FACE_OVERWRITTEN_P true means that some lines in W
2813      that contained glyphs in mouse-face were overwritten, so we
2814      have to update the mouse highlight.  */
2815   void (*update_window_end_hook) (struct window *w, bool cursor_on_p,
2816                                   bool mouse_face_overwritten_p);
2817
2818   /* Flush the display of frame F.  For X, this is XFlush.  */
2819   void (*flush_display) (struct frame *f);
2820
2821   /* Clear the mouse highlight in window W, if there is any.  */
2822   void (*clear_window_mouse_face) (struct window *w);
2823
2824   /* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
2825      frame F.  */
2826   void (*get_glyph_overhangs) (struct glyph *glyph, struct frame *f,
2827                                int *left, int *right);
2828
2829   /* Fix the display of AREA of ROW in window W for overlapping rows.
2830      This function is called from redraw_overlapping_rows after
2831      desired rows have been made current.  */
2832   void (*fix_overlapping_area) (struct window *w, struct glyph_row *row,
2833                                 enum glyph_row_area area, int);
2834
2835 #ifdef HAVE_WINDOW_SYSTEM
2836
2837   /* Draw a fringe bitmap in window W of row ROW using parameters P.  */
2838   void (*draw_fringe_bitmap) (struct window *w, struct glyph_row *row,
2839                               struct draw_fringe_bitmap_params *p);
2840
2841   /* Define and destroy fringe bitmap no. WHICH.  */
2842   void (*define_fringe_bitmap) (int which, unsigned short *bits,
2843                                 int h, int wd);
2844   void (*destroy_fringe_bitmap) (int which);
2845
2846   /* Compute left and right overhang of glyph string S.
2847      A NULL pointer if platform does not support this. */
2848   void (*compute_glyph_string_overhangs) (struct glyph_string *s);
2849
2850   /* Draw a glyph string S.  */
2851   void (*draw_glyph_string) (struct glyph_string *s);
2852
2853   /* Define cursor CURSOR on frame F.  */
2854   void (*define_frame_cursor) (struct frame *f, Cursor cursor);
2855
2856   /* Clear the area at (X,Y,WIDTH,HEIGHT) of frame F.  */
2857   void (*clear_frame_area) (struct frame *f, int x, int y,
2858                             int width, int height);
2859
2860   /* Draw specified cursor CURSOR_TYPE of width CURSOR_WIDTH
2861      at row GLYPH_ROW on window W if ON_P is true.  If ON_P is
2862      false, don't draw cursor.  If ACTIVE_P is true, system caret
2863      should track this cursor (when applicable).  */
2864   void (*draw_window_cursor) (struct window *w,
2865                               struct glyph_row *glyph_row,
2866                               int x, int y,
2867                               enum text_cursor_kinds cursor_type,
2868                               int cursor_width, bool on_p, bool active_p);
2869
2870   /* Draw vertical border for window W from (X,Y_0) to (X,Y_1).  */
2871   void (*draw_vertical_window_border) (struct window *w,
2872                                        int x, int y_0, int y_1);
2873
2874   /* Draw window divider for window W from (X_0, Y_0) to (X_1, ,Y_1).  */
2875   void (*draw_window_divider) (struct window *w,
2876                                int x_0, int x_1, int y_0, int y_1);
2877
2878   /* Shift display of frame F to make room for inserted glyphs.
2879      The area at pixel (X,Y) of width WIDTH and height HEIGHT is
2880      shifted right by SHIFT_BY pixels.  */
2881   void (*shift_glyphs_for_insert) (struct frame *f,
2882                                    int x, int y, int width,
2883                                    int height, int shift_by);
2884
2885   /* Start display hourglass cursor on frame F.  */
2886   void (*show_hourglass) (struct frame *f);
2887
2888   /* Cancel hourglass cursor on frame F.  */
2889   void (*hide_hourglass) (struct frame *f);
2890
2891 #endif /* HAVE_WINDOW_SYSTEM */
2892 };
2893
2894 \f
2895 /***********************************************************************
2896                                 Images
2897  ***********************************************************************/
2898
2899 #ifdef HAVE_WINDOW_SYSTEM
2900
2901 /* Each image format (JPEG, TIFF, ...) supported is described by
2902    a structure of the type below.  */
2903
2904 struct image_type
2905 {
2906   /* A symbol uniquely identifying the image type, .e.g `jpeg'.  */
2907   Lisp_Object *type;
2908
2909   /* Check that SPEC is a valid image specification for the given
2910      image type.  Value is true if SPEC is valid.  */
2911   bool (* valid_p) (Lisp_Object spec);
2912
2913   /* Load IMG which is used on frame F from information contained in
2914      IMG->spec.  Value is true if successful.  */
2915   bool (* load) (struct frame *f, struct image *img);
2916
2917   /* Free resources of image IMG which is used on frame F.  */
2918   void (* free) (struct frame *f, struct image *img);
2919
2920   /* Initialization function (used for dynamic loading of image
2921      libraries on Windows), or NULL if none.  */
2922   bool (* init) (void);
2923
2924   /* Next in list of all supported image types.  */
2925   struct image_type *next;
2926 };
2927
2928
2929 /* Structure describing an image.  Specific image formats like XBM are
2930    converted into this form, so that display only has to deal with
2931    this type of image.  */
2932
2933 struct image
2934 {
2935   /* The time in seconds at which the image was last displayed.  Set
2936      in prepare_image_for_display.  */
2937   struct timespec timestamp;
2938
2939   /* Pixmaps of the image.  */
2940   Pixmap pixmap, mask;
2941
2942 #ifdef HAVE_X_WINDOWS
2943   /* X images of the image, corresponding to the above Pixmaps.
2944      Non-NULL means it and its Pixmap counterpart may be out of sync
2945      and the latter is outdated.  NULL means the X image has been
2946      synchronized to Pixmap.  */
2947   XImagePtr ximg, mask_img;
2948 #endif
2949
2950   /* Colors allocated for this image, if any.  Allocated via xmalloc.  */
2951   unsigned long *colors;
2952   int ncolors;
2953
2954   /* A single `background color' for this image, for the use of anyone that
2955      cares about such a thing.  Only valid if the `background_valid' field
2956      is true.  This should generally be accessed by calling the accessor
2957      macro `IMAGE_BACKGROUND', which will heuristically calculate a value
2958      if necessary.  */
2959   unsigned long background;
2960
2961   /* Foreground and background colors of the frame on which the image
2962      is created.  */
2963   unsigned long frame_foreground, frame_background;
2964
2965   /* True if this image has a `transparent' background -- that is, is
2966      uses an image mask.  The accessor macro for this is
2967      `IMAGE_BACKGROUND_TRANSPARENT'.  */
2968   bool_bf background_transparent : 1;
2969
2970   /* True if the `background' and `background_transparent' fields are
2971      valid, respectively. */
2972   bool_bf background_valid : 1, background_transparent_valid : 1;
2973
2974   /* Width and height of the image.  */
2975   int width, height;
2976
2977   /* These values are used for the rectangles displayed for images
2978      that can't be loaded.  */
2979 #define DEFAULT_IMAGE_WIDTH 30
2980 #define DEFAULT_IMAGE_HEIGHT 30
2981
2982   /* Top/left and bottom/right corner pixel of actual image data.
2983      Used by four_corners_best to consider the real image data,
2984      rather than looking at the optional image margin.  */
2985   int corners[4];
2986 #define TOP_CORNER 0
2987 #define LEFT_CORNER 1
2988 #define BOT_CORNER 2
2989 #define RIGHT_CORNER 3
2990
2991   /* Percent of image height used as ascent.  A value of
2992      CENTERED_IMAGE_ASCENT means draw the image centered on the
2993      line.  */
2994   int ascent;
2995 #define DEFAULT_IMAGE_ASCENT 50
2996 #define CENTERED_IMAGE_ASCENT -1
2997
2998   /* Lisp specification of this image.  */
2999   Lisp_Object spec;
3000
3001   /* List of "references" followed to build the image.
3002      Typically will just contain the name of the image file.
3003      Used to allow fine-grained cache flushing.  */
3004   Lisp_Object dependencies;
3005
3006   /* Relief to draw around the image.  */
3007   int relief;
3008
3009   /* Optional margins around the image.  This includes the relief.  */
3010   int hmargin, vmargin;
3011
3012   /* Reference to the type of the image.  */
3013   struct image_type *type;
3014
3015   /* True means that loading the image failed.  Don't try again.  */
3016   bool load_failed_p;
3017
3018   /* A place for image types to store additional data.  It is marked
3019      during GC.  */
3020   Lisp_Object lisp_data;
3021
3022   /* Hash value of image specification to speed up comparisons.  */
3023   EMACS_UINT hash;
3024
3025   /* Image id of this image.  */
3026   ptrdiff_t id;
3027
3028   /* Hash collision chain.  */
3029   struct image *next, *prev;
3030 };
3031
3032
3033 /* Cache of images.  Each frame has a cache.  X frames with the same
3034    x_display_info share their caches.  */
3035
3036 struct image_cache
3037 {
3038   /* Hash table of images.  */
3039   struct image **buckets;
3040
3041   /* Vector mapping image ids to images.  */
3042   struct image **images;
3043
3044   /* Allocated size of `images'.  */
3045   ptrdiff_t size;
3046
3047   /* Number of images in the cache.  */
3048   ptrdiff_t used;
3049
3050   /* Reference count (number of frames sharing this cache).  */
3051   ptrdiff_t refcount;
3052 };
3053
3054
3055 /* Value is a pointer to the image with id ID on frame F, or null if
3056    no image with that id exists.  */
3057
3058 #define IMAGE_FROM_ID(F, ID)                                    \
3059      (((ID) >= 0 && (ID) < (FRAME_IMAGE_CACHE (F)->used))       \
3060       ? FRAME_IMAGE_CACHE (F)->images[ID]                       \
3061       : NULL)
3062
3063 /* Size of bucket vector of image caches.  Should be prime.  */
3064
3065 #define IMAGE_CACHE_BUCKETS_SIZE 1001
3066
3067 #endif /* HAVE_WINDOW_SYSTEM */
3068
3069
3070 \f
3071 /***********************************************************************
3072                                Tool-bars
3073  ***********************************************************************/
3074
3075 /* Enumeration defining where to find tool-bar item information in
3076    tool-bar items vectors stored with frames.  Each tool-bar item
3077    occupies TOOL_BAR_ITEM_NSLOTS elements in such a vector.  */
3078
3079 enum tool_bar_item_idx
3080 {
3081   /* The key of the tool-bar item.  Used to remove items when a binding
3082      for `undefined' is found.  */
3083   TOOL_BAR_ITEM_KEY,
3084
3085   /* Non-nil if item is enabled.  */
3086   TOOL_BAR_ITEM_ENABLED_P,
3087
3088   /* Non-nil if item is selected (pressed).  */
3089   TOOL_BAR_ITEM_SELECTED_P,
3090
3091   /* Caption.  */
3092   TOOL_BAR_ITEM_CAPTION,
3093
3094   /* Image(s) to display.  This is either a single image specification
3095      or a vector of specifications.  */
3096   TOOL_BAR_ITEM_IMAGES,
3097
3098   /* The binding.  */
3099   TOOL_BAR_ITEM_BINDING,
3100
3101   /* Button type.  One of nil (default button), t (a separator),
3102      `:radio', or `:toggle'.  The latter two currently do nothing.  */
3103   TOOL_BAR_ITEM_TYPE,
3104
3105   /* Help string.  */
3106   TOOL_BAR_ITEM_HELP,
3107
3108   /* Icon file name of right to left image when an RTL locale is used.  */
3109   TOOL_BAR_ITEM_RTL_IMAGE,
3110
3111   /* Label to show when text labels are enabled.  */
3112   TOOL_BAR_ITEM_LABEL,
3113
3114   /* If we shall show the label only below the icon and not beside it.  */
3115   TOOL_BAR_ITEM_VERT_ONLY,
3116
3117   /* Sentinel = number of slots in tool_bar_items occupied by one
3118      tool-bar item.  */
3119   TOOL_BAR_ITEM_NSLOTS
3120 };
3121
3122
3123 /* An enumeration for the different images that can be specified
3124    for a tool-bar item.  */
3125
3126 enum tool_bar_item_image
3127 {
3128   TOOL_BAR_IMAGE_ENABLED_SELECTED,
3129   TOOL_BAR_IMAGE_ENABLED_DESELECTED,
3130   TOOL_BAR_IMAGE_DISABLED_SELECTED,
3131   TOOL_BAR_IMAGE_DISABLED_DESELECTED
3132 };
3133
3134 #define DEFAULT_TOOL_BAR_LABEL_SIZE 14
3135
3136 /* Default values of the above variables.  */
3137
3138 #define DEFAULT_TOOL_BAR_BUTTON_MARGIN 4
3139 #define DEFAULT_TOOL_BAR_BUTTON_RELIEF 1
3140
3141 /* The height in pixels of the default tool-bar images.  */
3142
3143 #define DEFAULT_TOOL_BAR_IMAGE_HEIGHT 24
3144
3145 \f
3146 /***********************************************************************
3147                          Terminal Capabilities
3148  ***********************************************************************/
3149
3150 /* Each of these is a bit representing a terminal `capability' (bold,
3151    inverse, etc).  They are or'd together to specify the set of
3152    capabilities being queried for when calling `tty_capable_p' (which
3153    returns true if the terminal supports all of them).  */
3154
3155 #define TTY_CAP_INVERSE         0x01
3156 #define TTY_CAP_UNDERLINE       0x02
3157 #define TTY_CAP_BOLD            0x04
3158 #define TTY_CAP_DIM             0x08
3159 #define TTY_CAP_ITALIC          0x10
3160
3161 \f
3162 /***********************************************************************
3163                           Function Prototypes
3164  ***********************************************************************/
3165
3166 /* Defined in bidi.c */
3167
3168 extern void bidi_init_it (ptrdiff_t, ptrdiff_t, bool, struct bidi_it *);
3169 extern void bidi_move_to_visually_next (struct bidi_it *);
3170 extern void bidi_paragraph_init (bidi_dir_t, struct bidi_it *, bool);
3171 extern int  bidi_mirror_char (int);
3172 extern void bidi_push_it (struct bidi_it *);
3173 extern void bidi_pop_it (struct bidi_it *);
3174 extern void *bidi_shelve_cache (void);
3175 extern void bidi_unshelve_cache (void *, bool);
3176
3177 /* Defined in xdisp.c */
3178
3179 struct glyph_row *row_containing_pos (struct window *, ptrdiff_t,
3180                                       struct glyph_row *,
3181                                       struct glyph_row *, int);
3182 int line_bottom_y (struct it *);
3183 int default_line_pixel_height (struct window *);
3184 int display_prop_intangible_p (Lisp_Object, Lisp_Object, ptrdiff_t, ptrdiff_t);
3185 void resize_echo_area_exactly (void);
3186 int resize_mini_window (struct window *, int);
3187 void set_vertical_scroll_bar (struct window *);
3188 void set_horizontal_scroll_bar (struct window *);
3189 int try_window (Lisp_Object, struct text_pos, int);
3190 void window_box (struct window *, enum glyph_row_area,
3191                  int *, int *, int *, int *);
3192 int window_box_height (struct window *);
3193 int window_text_bottom_y (struct window *);
3194 int window_box_width (struct window *, enum glyph_row_area);
3195 int window_box_left (struct window *, enum glyph_row_area);
3196 int window_box_left_offset (struct window *, enum glyph_row_area);
3197 int window_box_right (struct window *, enum glyph_row_area);
3198 int estimate_mode_line_height (struct frame *, enum face_id);
3199 int move_it_to (struct it *, ptrdiff_t, int, int, int, int);
3200 void pixel_to_glyph_coords (struct frame *, int, int, int *, int *,
3201                             NativeRectangle *, int);
3202 void remember_mouse_glyph (struct frame *, int, int, NativeRectangle *);
3203
3204 void mark_window_display_accurate (Lisp_Object, int);
3205 void redisplay_preserve_echo_area (int);
3206 void init_iterator (struct it *, struct window *, ptrdiff_t,
3207                     ptrdiff_t, struct glyph_row *, enum face_id);
3208 void init_iterator_to_row_start (struct it *, struct window *,
3209                                  struct glyph_row *);
3210 void start_display (struct it *, struct window *, struct text_pos);
3211 void move_it_vertically (struct it *, int);
3212 void move_it_vertically_backward (struct it *, int);
3213 void move_it_by_lines (struct it *, ptrdiff_t);
3214 void move_it_past_eol (struct it *);
3215 void move_it_in_display_line (struct it *it,
3216                               ptrdiff_t to_charpos, int to_x,
3217                               enum move_operation_enum op);
3218 bool in_display_vector_p (struct it *);
3219 int frame_mode_line_height (struct frame *);
3220 extern Lisp_Object Qtool_bar;
3221 extern bool redisplaying_p;
3222 extern bool help_echo_showing_p;
3223 extern Lisp_Object help_echo_string, help_echo_window;
3224 extern Lisp_Object help_echo_object, previous_help_echo_string;
3225 extern ptrdiff_t help_echo_pos;
3226 extern int last_tool_bar_item;
3227 extern void reseat_at_previous_visible_line_start (struct it *);
3228 extern Lisp_Object lookup_glyphless_char_display (int, struct it *);
3229 extern ptrdiff_t compute_display_string_pos (struct text_pos *,
3230                                              struct bidi_string_data *,
3231                                              struct window *, int, int *);
3232 extern ptrdiff_t compute_display_string_end (ptrdiff_t,
3233                                              struct bidi_string_data *);
3234 extern void produce_stretch_glyph (struct it *);
3235 extern int merge_glyphless_glyph_face (struct it *);
3236
3237 #ifdef HAVE_WINDOW_SYSTEM
3238
3239 #ifdef GLYPH_DEBUG
3240 extern void dump_glyph_string (struct glyph_string *) EXTERNALLY_VISIBLE;
3241 #endif
3242
3243 extern void x_get_glyph_overhangs (struct glyph *, struct frame *,
3244                                    int *, int *);
3245 extern void x_produce_glyphs (struct it *);
3246
3247 extern void x_write_glyphs (struct window *, struct glyph_row *,
3248                             struct glyph *, enum glyph_row_area, int);
3249 extern void x_insert_glyphs (struct window *, struct glyph_row *,
3250                              struct glyph *, enum glyph_row_area, int);
3251 extern void x_clear_end_of_line (struct window *, struct glyph_row *,
3252                                  enum glyph_row_area, int);
3253 extern void x_fix_overlapping_area (struct window *, struct glyph_row *,
3254                                     enum glyph_row_area, int);
3255 extern void draw_phys_cursor_glyph (struct window *,
3256                                     struct glyph_row *,
3257                                     enum draw_glyphs_face);
3258 extern void get_phys_cursor_geometry (struct window *, struct glyph_row *,
3259                                       struct glyph *, int *, int *, int *);
3260 extern void erase_phys_cursor (struct window *);
3261 extern void display_and_set_cursor (struct window *, bool, int, int, int, int);
3262 extern void x_update_cursor (struct frame *, bool);
3263 extern void x_clear_cursor (struct window *);
3264 extern void x_draw_vertical_border (struct window *w);
3265 extern void x_draw_right_divider (struct window *w);
3266
3267 extern int get_glyph_string_clip_rects (struct glyph_string *,
3268                                         NativeRectangle *, int);
3269 extern void get_glyph_string_clip_rect (struct glyph_string *,
3270                                         NativeRectangle *nr);
3271 extern Lisp_Object find_hot_spot (Lisp_Object, int, int);
3272
3273 extern void handle_tool_bar_click (struct frame *,
3274                                    int, int, int, int);
3275
3276 extern void expose_frame (struct frame *, int, int, int, int);
3277 extern int x_intersect_rectangles (XRectangle *, XRectangle *,
3278                                    XRectangle *);
3279 #endif  /* HAVE_WINDOW_SYSTEM */
3280
3281 extern void note_mouse_highlight (struct frame *, int, int);
3282 extern void x_clear_window_mouse_face (struct window *);
3283 extern void cancel_mouse_face (struct frame *);
3284 extern int clear_mouse_face (Mouse_HLInfo *);
3285 extern bool cursor_in_mouse_face_p (struct window *w);
3286 extern void tty_draw_row_with_mouse_face (struct window *, struct glyph_row *,
3287                                           int, int, enum draw_glyphs_face);
3288 extern void display_tty_menu_item (const char *, int, int, int, int, int);
3289
3290 /* Flags passed to try_window.  */
3291 #define TRY_WINDOW_CHECK_MARGINS        (1 << 0)
3292 #define TRY_WINDOW_IGNORE_FONTS_CHANGE  (1 << 1)
3293
3294 int lookup_fringe_bitmap (Lisp_Object);
3295 void draw_fringe_bitmap (struct window *, struct glyph_row *, int);
3296 void draw_row_fringe_bitmaps (struct window *, struct glyph_row *);
3297 bool draw_window_fringes (struct window *, bool);
3298 bool update_window_fringes (struct window *, bool);
3299
3300 #ifdef HAVE_NTGUI
3301 void w32_init_fringe (struct redisplay_interface *);
3302 void w32_reset_fringes (void);
3303 #endif
3304
3305 extern unsigned row_hash (struct glyph_row *);
3306
3307 /* Defined in image.c */
3308
3309 #ifdef HAVE_WINDOW_SYSTEM
3310
3311 extern ptrdiff_t x_bitmap_pixmap (struct frame *, ptrdiff_t);
3312 extern void x_reference_bitmap (struct frame *, ptrdiff_t);
3313 extern ptrdiff_t x_create_bitmap_from_data (struct frame *, char *,
3314                                             unsigned int, unsigned int);
3315 extern ptrdiff_t x_create_bitmap_from_file (struct frame *, Lisp_Object);
3316 #if defined HAVE_XPM && defined HAVE_X_WINDOWS && !defined USE_GTK
3317 extern ptrdiff_t x_create_bitmap_from_xpm_data (struct frame *, const char **);
3318 #endif
3319 #ifndef x_destroy_bitmap
3320 extern void x_destroy_bitmap (struct frame *, ptrdiff_t);
3321 #endif
3322 extern void x_destroy_all_bitmaps (Display_Info *);
3323 extern void x_create_bitmap_mask (struct frame *, ptrdiff_t);
3324 extern Lisp_Object x_find_image_file (Lisp_Object);
3325
3326 void x_kill_gs_process (Pixmap, struct frame *);
3327 struct image_cache *make_image_cache (void);
3328 void free_image_cache (struct frame *);
3329 void clear_image_caches (Lisp_Object);
3330 void mark_image_cache (struct image_cache *);
3331 bool valid_image_p (Lisp_Object);
3332 void prepare_image_for_display (struct frame *, struct image *);
3333 ptrdiff_t lookup_image (struct frame *, Lisp_Object);
3334
3335 #if defined (HAVE_X_WINDOWS) ||  defined (HAVE_NS)
3336 #define RGB_PIXEL_COLOR unsigned long
3337 #endif
3338
3339 #ifdef HAVE_NTGUI
3340 #define RGB_PIXEL_COLOR COLORREF
3341 #endif
3342
3343 RGB_PIXEL_COLOR image_background (struct image *, struct frame *,
3344                                 XImagePtr_or_DC ximg);
3345 int image_background_transparent (struct image *, struct frame *,
3346                                   XImagePtr_or_DC mask);
3347
3348 int image_ascent (struct image *, struct face *, struct glyph_slice *);
3349
3350 #endif
3351
3352 /* Defined in sysdep.c */
3353
3354 void get_tty_size (int, int *, int *);
3355 void request_sigio (void);
3356 void unrequest_sigio (void);
3357 bool tabs_safe_p (int);
3358 void init_baud_rate (int);
3359 void init_sigio (int);
3360 void ignore_sigio (void);
3361
3362 /* Defined in xfaces.c.  */
3363
3364 #ifdef HAVE_X_WINDOWS
3365 void unload_color (struct frame *, unsigned long);
3366 void x_free_colors (struct frame *, unsigned long *, int);
3367 #endif
3368
3369 void update_face_from_frame_parameter (struct frame *, Lisp_Object,
3370                                        Lisp_Object);
3371 Lisp_Object tty_color_name (struct frame *, int);
3372 void clear_face_cache (int);
3373 unsigned long load_color (struct frame *, struct face *, Lisp_Object,
3374                           enum lface_attribute_index);
3375 char *choose_face_font (struct frame *, Lisp_Object *, Lisp_Object,
3376                         int *);
3377 #ifdef HAVE_WINDOW_SYSTEM
3378 void prepare_face_for_display (struct frame *, struct face *);
3379 #endif
3380 int lookup_named_face (struct frame *, Lisp_Object, int);
3381 int lookup_basic_face (struct frame *, int);
3382 int smaller_face (struct frame *, int, int);
3383 int face_with_height (struct frame *, int, int);
3384 int lookup_derived_face (struct frame *, Lisp_Object, int, int);
3385 void init_frame_faces (struct frame *);
3386 void free_frame_faces (struct frame *);
3387 void recompute_basic_faces (struct frame *);
3388 int face_at_buffer_position (struct window *w, ptrdiff_t pos,
3389                              ptrdiff_t *endptr, ptrdiff_t limit,
3390                              int mouse, int base_face_id);
3391 int face_for_overlay_string (struct window *w, ptrdiff_t pos,
3392                              ptrdiff_t *endptr, ptrdiff_t limit,
3393                              int mouse, Lisp_Object overlay);
3394 int face_at_string_position (struct window *w, Lisp_Object string,
3395                              ptrdiff_t pos, ptrdiff_t bufpos,
3396                              ptrdiff_t *endptr, enum face_id, int mouse);
3397 int merge_faces (struct frame *, Lisp_Object, int, int);
3398 int compute_char_face (struct frame *, int, Lisp_Object);
3399 void free_all_realized_faces (Lisp_Object);
3400 extern Lisp_Object Qforeground_color, Qbackground_color;
3401 extern char unspecified_fg[], unspecified_bg[];
3402
3403 /* Defined in xfns.c.  */
3404
3405 #ifdef HAVE_X_WINDOWS
3406 void gamma_correct (struct frame *, XColor *);
3407 #endif
3408 #ifdef HAVE_NTGUI
3409 void gamma_correct (struct frame *, COLORREF *);
3410 #endif
3411
3412 #ifdef HAVE_WINDOW_SYSTEM
3413
3414 void x_implicitly_set_name (struct frame *, Lisp_Object, Lisp_Object);
3415 void x_change_tool_bar_height (struct frame *f, int);
3416
3417 extern Lisp_Object tip_frame;
3418 extern Window tip_window;
3419 extern frame_parm_handler x_frame_parm_handlers[];
3420
3421 extern void start_hourglass (void);
3422 extern void cancel_hourglass (void);
3423
3424 /* Returns the background color of IMG, calculating one heuristically if
3425    necessary.  If non-zero, XIMG is an existing XImage object to use for
3426    the heuristic.  */
3427
3428 #define IMAGE_BACKGROUND(img, f, ximg)                                        \
3429    ((img)->background_valid                                                   \
3430     ? (img)->background                                                       \
3431     : image_background (img, f, ximg))
3432
3433 /* Returns true if IMG has a `transparent' background, using heuristics
3434    to decide if necessary.  If non-zero, MASK is an existing XImage
3435    object to use for the heuristic.  */
3436
3437 #define IMAGE_BACKGROUND_TRANSPARENT(img, f, mask)                            \
3438    ((img)->background_transparent_valid                                       \
3439     ? (img)->background_transparent                                           \
3440     : image_background_transparent (img, f, mask))
3441
3442 #endif /* HAVE_WINDOW_SYSTEM */
3443
3444
3445 /* Defined in xmenu.c  */
3446
3447 int popup_activated (void);
3448
3449 /* Defined in dispnew.c */
3450
3451 extern Lisp_Object buffer_posn_from_coords (struct window *,
3452                                             int *, int *,
3453                                             struct display_pos *,
3454                                             Lisp_Object *,
3455                                             int *, int *, int *, int *);
3456 extern Lisp_Object mode_line_string (struct window *, enum window_part,
3457                                      int *, int *, ptrdiff_t *,
3458                                      Lisp_Object *,
3459                                      int *, int *, int *, int *);
3460 extern Lisp_Object marginal_area_string (struct window *, enum window_part,
3461                                          int *, int *, ptrdiff_t *,
3462                                          Lisp_Object *,
3463                                          int *, int *, int *, int *);
3464 extern void redraw_frame (struct frame *);
3465 extern bool update_frame (struct frame *, bool, bool);
3466 extern void update_frame_with_menu (struct frame *, int, int);
3467 extern void bitch_at_user (void);
3468 extern void adjust_frame_glyphs (struct frame *);
3469 void free_glyphs (struct frame *);
3470 void free_window_matrices (struct window *);
3471 void check_glyph_memory (void);
3472 void mirrored_line_dance (struct glyph_matrix *, int, int, int *, char *);
3473 void clear_glyph_matrix (struct glyph_matrix *);
3474 void clear_current_matrices (struct frame *f);
3475 void clear_desired_matrices (struct frame *);
3476 void shift_glyph_matrix (struct window *, struct glyph_matrix *,
3477                          int, int, int);
3478 void rotate_matrix (struct glyph_matrix *, int, int, int);
3479 void increment_matrix_positions (struct glyph_matrix *,
3480                                  int, int, ptrdiff_t, ptrdiff_t);
3481 void blank_row (struct window *, struct glyph_row *, int);
3482 void clear_glyph_matrix_rows (struct glyph_matrix *, int, int);
3483 void clear_glyph_row (struct glyph_row *);
3484 void prepare_desired_row (struct window *, struct glyph_row *, bool);
3485 void update_single_window (struct window *, bool);
3486 void do_pending_window_change (bool);
3487 void change_frame_size (struct frame *, int, int, bool, bool, bool, bool);
3488 void init_display (void);
3489 void syms_of_display (void);
3490 extern Lisp_Object Qredisplay_dont_pause;
3491 extern void spec_glyph_lookup_face (struct window *, GLYPH *);
3492 extern void fill_up_frame_row_with_spaces (struct glyph_row *, int);
3493
3494 /* Defined in terminal.c */
3495
3496 extern void ring_bell (struct frame *);
3497 extern void update_begin (struct frame *);
3498 extern void update_end (struct frame *);
3499 extern void set_terminal_window (struct frame *, int);
3500 extern void cursor_to (struct frame *, int, int);
3501 extern void raw_cursor_to (struct frame *, int, int);
3502 extern void clear_to_end (struct frame *);
3503 extern void clear_frame (struct frame *);
3504 extern void clear_end_of_line (struct frame *, int);
3505 extern void write_glyphs (struct frame *, struct glyph *, int);
3506 extern void insert_glyphs (struct frame *, struct glyph *, int);
3507 extern void delete_glyphs (struct frame *, int);
3508 extern void ins_del_lines (struct frame *, int, int);
3509
3510 extern struct terminal *init_initial_terminal (void);
3511
3512
3513 /* Defined in term.c */
3514
3515 extern void tty_turn_off_insert (struct tty_display_info *);
3516 extern int string_cost (const char *);
3517 extern int per_line_cost (const char *);
3518 extern void calculate_costs (struct frame *);
3519 extern void produce_glyphs (struct it *);
3520 extern bool tty_capable_p (struct tty_display_info *, unsigned);
3521 extern void set_tty_color_mode (struct tty_display_info *, struct frame *);
3522 extern void create_tty_output (struct frame *);
3523 extern struct terminal *init_tty (const char *, const char *, bool);
3524 extern void tty_append_glyph (struct it *);
3525
3526
3527 /* Defined in scroll.c */
3528
3529 extern int scrolling_max_lines_saved (int, int, unsigned *, unsigned *, int *);
3530 extern void do_line_insertion_deletion_costs (struct frame *, const char *,
3531                                               const char *, const char *,
3532                                               const char *, const char *,
3533                                               const char *, int);
3534 void scrolling_1 (struct frame *, int, int, int, int *, int *, unsigned *,
3535                   unsigned *, int);
3536
3537 /* Defined in frame.c */
3538
3539 #ifdef HAVE_WINDOW_SYSTEM
3540
3541 /* Types we might convert a resource string into.  */
3542 enum resource_types
3543 {
3544   RES_TYPE_NUMBER,
3545   RES_TYPE_FLOAT,
3546   RES_TYPE_BOOLEAN,
3547   RES_TYPE_STRING,
3548   RES_TYPE_SYMBOL,
3549   RES_TYPE_BOOLEAN_NUMBER
3550 };
3551
3552 extern Display_Info *check_x_display_info (Lisp_Object);
3553 extern Lisp_Object x_get_arg (Display_Info *, Lisp_Object,
3554                               Lisp_Object, const char *, const char *class,
3555                               enum resource_types);
3556 extern Lisp_Object x_frame_get_and_record_arg (struct frame *, Lisp_Object,
3557                                                Lisp_Object,
3558                                                const char *, const char *,
3559                                                enum resource_types);
3560 extern Lisp_Object x_default_parameter (struct frame *, Lisp_Object,
3561                                         Lisp_Object, Lisp_Object,
3562                                         const char *, const char *,
3563                                         enum resource_types);
3564 extern char *x_get_string_resource (XrmDatabase, const char *,
3565                                     const char *);
3566
3567 #ifndef HAVE_NS /* These both used on W32 and X only.  */
3568 extern bool x_mouse_grabbed (Display_Info *);
3569 extern void x_redo_mouse_highlight (Display_Info *);
3570 #endif /* HAVE_NS */
3571
3572 #endif /* HAVE_WINDOW_SYSTEM */
3573
3574 INLINE_HEADER_END
3575
3576 #endif /* not DISPEXTERN_H_INCLUDED */