src/dispextern.h

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