src/dispextern.h

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