src/dispextern.h

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