xdisp.c 809 KB
Newer Older
Jim Blandy's avatar
Jim Blandy committed
1
/* Display generation from window structure and buffer text.
2

3
Copyright (C) 1985-1988, 1993-1995, 1997-2011  Free Software Foundation, Inc.
Jim Blandy's avatar
Jim Blandy committed
4 5 6

This file is part of GNU Emacs.

7
GNU Emacs is free software: you can redistribute it and/or modify
Jim Blandy's avatar
Jim Blandy committed
8
it under the terms of the GNU General Public License as published by
9 10
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Jim Blandy's avatar
Jim Blandy committed
11 12 13 14 15 16 17

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
18
along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
Jim Blandy's avatar
Jim Blandy committed
19

Gerd Moellmann's avatar
Gerd Moellmann committed
20 21 22 23 24 25 26 27 28 29 30 31 32
/* New redisplay written by Gerd Moellmann <gerd@gnu.org>.

   Redisplay.

   Emacs separates the task of updating the display from code
   modifying global state, e.g. buffer text.  This way functions
   operating on buffers don't also have to be concerned with updating
   the display.

   Updating the display is triggered by the Lisp interpreter when it
   decides it's time to do it.  This is done either automatically for
   you as part of the interpreter's command loop or as the result of
   calling Lisp functions like `sit-for'.  The C function `redisplay'
33
   in xdisp.c is the only entry into the inner redisplay code.
Gerd Moellmann's avatar
Gerd Moellmann committed
34 35 36 37 38 39 40 41 42 43 44

   The following diagram shows how redisplay code is invoked.  As you
   can see, Lisp calls redisplay and vice versa.  Under window systems
   like X, some portions of the redisplay code are also called
   asynchronously during mouse movement or expose events.  It is very
   important that these code parts do NOT use the C library (malloc,
   free) because many C libraries under Unix are not reentrant.  They
   may also NOT call functions of the Lisp interpreter which could
   change the interpreter's state.  If you don't follow these rules,
   you will encounter bugs which are very hard to explain.

45
   +--------------+   redisplay     +----------------+
Gerd Moellmann's avatar
Gerd Moellmann committed
46 47 48 49 50 51 52 53 54 55 56
   | Lisp machine |---------------->| Redisplay code |<--+
   +--------------+   (xdisp.c)     +----------------+   |
	  ^				     |		 |
	  +----------------------------------+           |
	    Don't use this path when called		 |
	    asynchronously!				 |
                                                         |
                           expose_window (asynchronous)  |
                                                         |
			           X expose events  -----+

57
   What does redisplay do?  Obviously, it has to figure out somehow what
Gerd Moellmann's avatar
Gerd Moellmann committed
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
   has been changed since the last time the display has been updated,
   and to make these changes visible.  Preferably it would do that in
   a moderately intelligent way, i.e. fast.

   Changes in buffer text can be deduced from window and buffer
   structures, and from some global variables like `beg_unchanged' and
   `end_unchanged'.  The contents of the display are additionally
   recorded in a `glyph matrix', a two-dimensional matrix of glyph
   structures.  Each row in such a matrix corresponds to a line on the
   display, and each glyph in a row corresponds to a column displaying
   a character, an image, or what else.  This matrix is called the
   `current glyph matrix' or `current matrix' in redisplay
   terminology.

   For buffer parts that have been changed since the last update, a
   second glyph matrix is constructed, the so called `desired glyph
   matrix' or short `desired matrix'.  Current and desired matrix are
   then compared to find a cheap way to update the display, e.g. by
   reusing part of the display by scrolling lines.

Pavel Janík's avatar
Pavel Janík committed
78
   You will find a lot of redisplay optimizations when you start
Gerd Moellmann's avatar
Gerd Moellmann committed
79 80
   looking at the innards of redisplay.  The overall goal of all these
   optimizations is to make redisplay fast because it is done
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
   frequently.  Some of these optimizations are implemented by the
   following functions:

    . try_cursor_movement

      This function tries to update the display if the text in the
      window did not change and did not scroll, only point moved, and
      it did not move off the displayed portion of the text.

    . try_window_reusing_current_matrix

      This function reuses the current matrix of a window when text
      has not changed, but the window start changed (e.g., due to
      scrolling).

    . try_window_id

      This function attempts to redisplay a window by reusing parts of
      its existing display.  It finds and reuses the part that was not
      changed, and redraws the rest.

    . try_window

      This function performs the full redisplay of a single window
      assuming that its fonts were not changed and that the cursor
      will not end up in the scroll margins.  (Loading fonts requires
      re-adjustment of dimensions of glyph matrices, which makes this
      method impossible to use.)

   These optimizations are tried in sequence (some can be skipped if
   it is known that they are not applicable).  If none of the
   optimizations were successful, redisplay calls redisplay_windows,
   which performs a full redisplay of all windows.
Gerd Moellmann's avatar
Gerd Moellmann committed
114 115 116 117 118 119 120 121 122 123 124 125 126 127

   Desired matrices.

   Desired matrices are always built per Emacs window.  The function
   `display_line' is the central function to look at if you are
   interested.  It constructs one row in a desired matrix given an
   iterator structure containing both a buffer position and a
   description of the environment in which the text is to be
   displayed.  But this is too early, read on.

   Characters and pixmaps displayed for a range of buffer text depend
   on various settings of buffers and windows, on overlays and text
   properties, on display tables, on selective display.  The good news
   is that all this hairy stuff is hidden behind a small set of
128
   interface functions taking an iterator structure (struct it)
Gerd Moellmann's avatar
Gerd Moellmann committed
129 130
   argument.

Pavel Janík's avatar
Pavel Janík committed
131
   Iteration over things to be displayed is then simple.  It is
Gerd Moellmann's avatar
Gerd Moellmann committed
132 133 134
   started by initializing an iterator with a call to init_iterator.
   Calls to get_next_display_element fill the iterator structure with
   relevant information about the next thing to display.  Calls to
Gerd Moellmann's avatar
Gerd Moellmann committed
135 136 137 138 139 140 141 142 143 144
   set_iterator_to_next move the iterator to the next thing.

   Besides this, an iterator also contains information about the
   display environment in which glyphs for display elements are to be
   produced.  It has fields for the width and height of the display,
   the information whether long lines are truncated or continued, a
   current X and Y position, and lots of other stuff you can better
   see in dispextern.h.

   Glyphs in a desired matrix are normally constructed in a loop
145 146
   calling get_next_display_element and then PRODUCE_GLYPHS.  The call
   to PRODUCE_GLYPHS will fill the iterator structure with pixel
Gerd Moellmann's avatar
Gerd Moellmann committed
147 148 149
   information about the element being displayed and at the same time
   produce glyphs for it.  If the display element fits on the line
   being displayed, set_iterator_to_next is called next, otherwise the
150 151 152 153 154
   glyphs produced are discarded.  The function display_line is the
   workhorse of filling glyph rows in the desired matrix with glyphs.
   In addition to producing glyphs, it also handles line truncation
   and continuation, word wrap, and cursor positioning (for the
   latter, see also set_cursor_from_row).
Gerd Moellmann's avatar
Gerd Moellmann committed
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174

   Frame matrices.

   That just couldn't be all, could it?  What about terminal types not
   supporting operations on sub-windows of the screen?  To update the
   display on such a terminal, window-based glyph matrices are not
   well suited.  To be able to reuse part of the display (scrolling
   lines up and down), we must instead have a view of the whole
   screen.  This is what `frame matrices' are for.  They are a trick.

   Frames on terminals like above have a glyph pool.  Windows on such
   a frame sub-allocate their glyph memory from their frame's glyph
   pool.  The frame itself is given its own glyph matrices.  By
   coincidence---or maybe something else---rows in window glyph
   matrices are slices of corresponding rows in frame matrices.  Thus
   writing to window matrices implicitly updates a frame matrix which
   provides us with the view of the whole screen that we originally
   wanted to have without having to move many bytes around.  To be
   honest, there is a little bit more done, but not much more.  If you
   plan to extend that code, take a look at dispnew.c.  The function
175 176 177 178 179 180 181 182 183 184
   build_frame_matrix is a good starting point.

   Bidirectional display.

   Bidirectional display adds quite some hair to this already complex
   design.  The good news are that a large portion of that hairy stuff
   is hidden in bidi.c behind only 3 interfaces.  bidi.c implements a
   reordering engine which is called by set_iterator_to_next and
   returns the next character to display in the visual order.  See
   commentary on bidi.c for more details.  As far as redisplay is
185
   concerned, the effect of calling bidi_move_to_visually_next, the
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
   main interface of the reordering engine, is that the iterator gets
   magically placed on the buffer or string position that is to be
   displayed next.  In other words, a linear iteration through the
   buffer/string is replaced with a non-linear one.  All the rest of
   the redisplay is oblivious to the bidi reordering.

   Well, almost oblivious---there are still complications, most of
   them due to the fact that buffer and string positions no longer
   change monotonously with glyph indices in a glyph row.  Moreover,
   for continued lines, the buffer positions may not even be
   monotonously changing with vertical positions.  Also, accounting
   for face changes, overlays, etc. becomes more complex because
   non-linear iteration could potentially skip many positions with
   changes, and then cross them again on the way back...

   One other prominent effect of bidirectional display is that some
   paragraphs of text need to be displayed starting at the right
   margin of the window---the so-called right-to-left, or R2L
   paragraphs.  R2L paragraphs are displayed with R2L glyph rows,
   which have their reversed_p flag set.  The bidi reordering engine
   produces characters in such rows starting from the character which
   should be the rightmost on display.  PRODUCE_GLYPHS then reverses
   the order, when it fills up the glyph row whose reversed_p flag is
   set, by prepending each new glyph to what is already there, instead
   of appending it.  When the glyph row is complete, the function
   extend_face_to_end_of_line fills the empty space to the left of the
   leftmost character with special glyphs, which will display as,
   well, empty.  On text terminals, these special glyphs are simply
   blank characters.  On graphics terminals, there's a single stretch
215
   glyph of a suitably computed width.  Both the blanks and the
216 217
   stretch glyph are given the face of the background of the line.
   This way, the terminal-specific back-end can still draw the glyphs
218 219
   left to right, even for R2L lines.

220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
   Bidirectional display and character compositions

   Some scripts cannot be displayed by drawing each character
   individually, because adjacent characters change each other's shape
   on display.  For example, Arabic and Indic scripts belong to this
   category.

   Emacs display supports this by providing "character compositions",
   most of which is implemented in composite.c.  During the buffer
   scan that delivers characters to PRODUCE_GLYPHS, if the next
   character to be delivered is a composed character, the iteration
   calls composition_reseat_it and next_element_from_composition.  If
   they succeed to compose the character with one or more of the
   following characters, the whole sequence of characters that where
   composed is recorded in the `struct composition_it' object that is
   part of the buffer iterator.  The composed sequence could produce
   one or more font glyphs (called "grapheme clusters") on the screen.
   Each of these grapheme clusters is then delivered to PRODUCE_GLYPHS
   in the direction corresponding to the current bidi scan direction
   (recorded in the scan_dir member of the `struct bidi_it' object
   that is part of the buffer iterator).  In particular, if the bidi
   iterator currently scans the buffer backwards, the grapheme
   clusters are delivered back to front.  This reorders the grapheme
   clusters as appropriate for the current bidi context.  Note that
   this means that the grapheme clusters are always stored in the
   LGSTRING object (see composite.c) in the logical order.

   Moving an iterator in bidirectional text
   without producing glyphs

250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
   Note one important detail mentioned above: that the bidi reordering
   engine, driven by the iterator, produces characters in R2L rows
   starting at the character that will be the rightmost on display.
   As far as the iterator is concerned, the geometry of such rows is
   still left to right, i.e. the iterator "thinks" the first character
   is at the leftmost pixel position.  The iterator does not know that
   PRODUCE_GLYPHS reverses the order of the glyphs that the iterator
   delivers.  This is important when functions from the the move_it_*
   family are used to get to certain screen position or to match
   screen coordinates with buffer coordinates: these functions use the
   iterator geometry, which is left to right even in R2L paragraphs.
   This works well with most callers of move_it_*, because they need
   to get to a specific column, and columns are still numbered in the
   reading order, i.e. the rightmost character in a R2L paragraph is
   still column zero.  But some callers do not get well with this; a
   notable example is mouse clicks that need to find the character
   that corresponds to certain pixel coordinates.  See
   buffer_posn_from_coords in dispnew.c for how this is handled.  */
Jim Blandy's avatar
Jim Blandy committed
268

269
#include <config.h>
Jim Blandy's avatar
Jim Blandy committed
270
#include <stdio.h>
271
#include <limits.h>
272
#include <setjmp.h>
273

Jim Blandy's avatar
Jim Blandy committed
274
#include "lisp.h"
275
#include "keyboard.h"
Jim Blandy's avatar
Jim Blandy committed
276
#include "frame.h"
Jim Blandy's avatar
Jim Blandy committed
277 278 279 280
#include "window.h"
#include "termchar.h"
#include "dispextern.h"
#include "buffer.h"
Kenichi Handa's avatar
Kenichi Handa committed
281
#include "character.h"
282
#include "charset.h"
Jim Blandy's avatar
Jim Blandy committed
283 284
#include "indent.h"
#include "commands.h"
285
#include "keymap.h"
Jim Blandy's avatar
Jim Blandy committed
286 287
#include "macros.h"
#include "disptab.h"
288
#include "termhooks.h"
289
#include "termopts.h"
290
#include "intervals.h"
291 292
#include "coding.h"
#include "process.h"
Andreas Schwab's avatar
Andreas Schwab committed
293
#include "region-cache.h"
Kenichi Handa's avatar
Kenichi Handa committed
294
#include "font.h"
Dave Love's avatar
Dave Love committed
295
#include "fontset.h"
296
#include "blockinput.h"
Andreas Schwab's avatar
Andreas Schwab committed
297

298
#ifdef HAVE_X_WINDOWS
Andreas Schwab's avatar
Andreas Schwab committed
299 300
#include "xterm.h"
#endif
301 302 303
#ifdef WINDOWSNT
#include "w32term.h"
#endif
304 305 306
#ifdef HAVE_NS
#include "nsterm.h"
#endif
307 308 309
#ifdef USE_GTK
#include "gtkutil.h"
#endif
Jim Blandy's avatar
Jim Blandy committed
310

311 312
#include "font.h"

313 314 315 316
#ifndef FRAME_X_OUTPUT
#define FRAME_X_OUTPUT(f) ((f)->output_data.x)
#endif

Gerd Moellmann's avatar
Gerd Moellmann committed
317 318
#define INFINITY 10000000

319
Lisp_Object Qoverriding_local_map, Qoverriding_terminal_local_map;
320 321 322
Lisp_Object Qwindow_scroll_functions;
Lisp_Object Qwindow_text_change_functions;
Lisp_Object Qredisplay_end_trigger_functions;
323
Lisp_Object Qinhibit_point_motion_hooks;
324
Lisp_Object QCeval, QCfile, QCdata, QCpropertize;
Gerd Moellmann's avatar
Gerd Moellmann committed
325
Lisp_Object Qfontified;
326
Lisp_Object Qgrow_only;
327
Lisp_Object Qinhibit_eval_during_redisplay;
328
Lisp_Object Qbuffer_position, Qposition, Qobject;
329
Lisp_Object Qright_to_left, Qleft_to_right;
Gerd Moellmann's avatar
Gerd Moellmann committed
330

331 332 333
/* Cursor shapes */
Lisp_Object Qbar, Qhbar, Qbox, Qhollow;

Kenichi Handa's avatar
Kenichi Handa committed
334 335 336
/* Pointer shapes */
Lisp_Object Qarrow, Qhand, Qtext;

337 338 339
/* Holds the list (error).  */
Lisp_Object list_of_error;

Gerd Moellmann's avatar
Gerd Moellmann committed
340 341
Lisp_Object Qfontification_functions;

342 343
Lisp_Object Qwrap_prefix;
Lisp_Object Qline_prefix;
344

345 346
/* Non-nil means don't actually do any redisplay.  */

347
Lisp_Object Qinhibit_redisplay;
348

Gerd Moellmann's avatar
Gerd Moellmann committed
349 350
/* Names of text properties relevant for redisplay.  */

Kenichi Handa's avatar
Kenichi Handa committed
351
Lisp_Object Qdisplay;
Gerd Moellmann's avatar
Gerd Moellmann committed
352 353

Lisp_Object Qspace, QCalign_to, QCrelative_width, QCrelative_height;
354
Lisp_Object Qleft_margin, Qright_margin, Qspace_width, Qraise;
Kim F. Storm's avatar
Kim F. Storm committed
355
Lisp_Object Qslice;
Kenichi Handa's avatar
Kenichi Handa committed
356 357
Lisp_Object Qcenter;
Lisp_Object Qmargin, Qpointer;
358
Lisp_Object Qline_height;
Gerd Moellmann's avatar
Gerd Moellmann committed
359

Kenichi Handa's avatar
Kenichi Handa committed
360 361 362 363 364
#ifdef HAVE_WINDOW_SYSTEM

/* Test if overflow newline into fringe.  Called with iterator IT
   at or past right window margin, and with IT->current_x set.  */

365 366 367 368 369 370 371 372
#define IT_OVERFLOW_NEWLINE_INTO_FRINGE(IT)		\
  (!NILP (Voverflow_newline_into_fringe)		\
   && FRAME_WINDOW_P ((IT)->f)				\
   && ((IT)->bidi_it.paragraph_dir == R2L		\
       ? (WINDOW_LEFT_FRINGE_WIDTH ((IT)->w) > 0)	\
       : (WINDOW_RIGHT_FRINGE_WIDTH ((IT)->w) > 0))	\
   && (IT)->current_x == (IT)->last_visible_x		\
   && (IT)->line_wrap != WORD_WRAP)
Kenichi Handa's avatar
Kenichi Handa committed
373

374 375
#else /* !HAVE_WINDOW_SYSTEM */
#define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it) 0
Kenichi Handa's avatar
Kenichi Handa committed
376 377
#endif /* HAVE_WINDOW_SYSTEM */

378 379 380 381 382 383
/* Test if the display element loaded in IT is a space or tab
   character.  This is used to determine word wrapping.  */

#define IT_DISPLAYING_WHITESPACE(it)				\
  (it->what == IT_CHARACTER && (it->c == ' ' || it->c == '\t'))

Gerd Moellmann's avatar
Gerd Moellmann committed
384 385 386 387
/* Name of the face used to highlight trailing whitespace.  */

Lisp_Object Qtrailing_whitespace;

388 389 390 391
/* Name and number of the face used to highlight escape glyphs.  */

Lisp_Object Qescape_glyph;

Juri Linkov's avatar
Juri Linkov committed
392 393
/* Name and number of the face used to highlight non-breaking spaces.  */

394
Lisp_Object Qnobreak_space;
Juri Linkov's avatar
Juri Linkov committed
395

Gerd Moellmann's avatar
Gerd Moellmann committed
396
/* The symbol `image' which is the car of the lists used to represent
397
   images in Lisp.  Also a tool bar style.  */
Gerd Moellmann's avatar
Gerd Moellmann committed
398 399 400

Lisp_Object Qimage;

Kenichi Handa's avatar
Kenichi Handa committed
401 402 403 404
/* The image map types.  */
Lisp_Object QCmap, QCpointer;
Lisp_Object Qrect, Qcircle, Qpoly;

405
/* Tool bar styles */
406
Lisp_Object Qboth, Qboth_horiz, Qtext_image_horiz;
407

Gerd Moellmann's avatar
Gerd Moellmann committed
408 409
/* Non-zero means print newline to stdout before next mini-buffer
   message.  */
Jim Blandy's avatar
Jim Blandy committed
410 411 412

int noninteractive_need_newline;

Gerd Moellmann's avatar
Gerd Moellmann committed
413
/* Non-zero means print newline to message log before next message.  */
414

415
static int message_log_need_newline;
416

417 418 419 420 421 422
/* Three markers that message_dolog uses.
   It could allocate them itself, but that causes trouble
   in handling memory-full errors.  */
static Lisp_Object message_dolog_marker1;
static Lisp_Object message_dolog_marker2;
static Lisp_Object message_dolog_marker3;
Gerd Moellmann's avatar
Gerd Moellmann committed
423 424 425 426 427

/* The buffer position of the first character appearing entirely or
   partially on the line of the selected window which contains the
   cursor; <= 0 if not known.  Set by set_cursor_from_row, used for
   redisplay optimization in redisplay_internal.  */
Jim Blandy's avatar
Jim Blandy committed
428

Gerd Moellmann's avatar
Gerd Moellmann committed
429
static struct text_pos this_line_start_pos;
Jim Blandy's avatar
Jim Blandy committed
430

Gerd Moellmann's avatar
Gerd Moellmann committed
431 432 433 434 435 436
/* Number of characters past the end of the line above, including the
   terminating newline.  */

static struct text_pos this_line_end_pos;

/* The vertical positions and the height of this line.  */
Jim Blandy's avatar
Jim Blandy committed
437 438

static int this_line_vpos;
Gerd Moellmann's avatar
Gerd Moellmann committed
439 440 441 442 443 444 445
static int this_line_y;
static int this_line_pixel_height;

/* X position at which this display line starts.  Usually zero;
   negative if first character is partially visible.  */

static int this_line_start_x;
Jim Blandy's avatar
Jim Blandy committed
446

Gerd Moellmann's avatar
Gerd Moellmann committed
447
/* Buffer that this_line_.* variables are referring to.  */
Jim Blandy's avatar
Jim Blandy committed
448 449 450 451

static struct buffer *this_line_buffer;


Kenichi Handa's avatar
Kenichi Handa committed
452 453 454
/* Values of those variables at last redisplay are stored as
   properties on `overlay-arrow-position' symbol.  However, if
   Voverlay_arrow_position is a marker, last-arrow-position is its
Gerd Moellmann's avatar
Gerd Moellmann committed
455 456
   numerical position.  */

Kenichi Handa's avatar
Kenichi Handa committed
457 458 459 460 461 462
Lisp_Object Qlast_arrow_position, Qlast_arrow_string;

/* Alternative overlay-arrow-string and overlay-arrow-bitmap
   properties on a symbol in overlay-arrow-variable-list.  */

Lisp_Object Qoverlay_arrow_string, Qoverlay_arrow_bitmap;
463

464
Lisp_Object Qmenu_bar_update_hook;
465

466
/* Nonzero if an overlay arrow has been displayed in this window.  */
Jim Blandy's avatar
Jim Blandy committed
467

Gerd Moellmann's avatar
Gerd Moellmann committed
468
static int overlay_arrow_seen;
Karl Heuer's avatar
Karl Heuer committed
469

Gerd Moellmann's avatar
Gerd Moellmann committed
470 471 472
/* Number of windows showing the buffer of the selected window (or
   another buffer with the same base buffer).  keyboard.c refers to
   this.  */
Jim Blandy's avatar
Jim Blandy committed
473 474 475

int buffer_shared;

Gerd Moellmann's avatar
Gerd Moellmann committed
476
/* Vector containing glyphs for an ellipsis `...'.  */
Jim Blandy's avatar
Jim Blandy committed
477

Gerd Moellmann's avatar
Gerd Moellmann committed
478
static Lisp_Object default_invis_vector[3];
Jim Blandy's avatar
Jim Blandy committed
479

Gerd Moellmann's avatar
Gerd Moellmann committed
480 481
/* Prompt to display in front of the mini-buffer contents.  */

482
Lisp_Object minibuf_prompt;
Jim Blandy's avatar
Jim Blandy committed
483

Gerd Moellmann's avatar
Gerd Moellmann committed
484 485 486
/* Width of current mini-buffer prompt.  Only set after display_line
   of the line that contains the prompt.  */

Jim Blandy's avatar
Jim Blandy committed
487
int minibuf_prompt_width;
Gerd Moellmann's avatar
Gerd Moellmann committed
488 489 490 491 492

/* This is the window where the echo area message was displayed.  It
   is always a mini-buffer window, but it may not be the same window
   currently active as a mini-buffer.  */

493 494
Lisp_Object echo_area_window;

495 496 497 498 499 500 501
/* List of pairs (MESSAGE . MULTIBYTE).  The function save_message
   pushes the current message and the value of
   message_enable_multibyte on the stack, the function restore_message
   pops the stack and displays MESSAGE again.  */

Lisp_Object Vmessage_stack;

502 503
/* Nonzero means multibyte characters were enabled when the echo area
   message was specified.  */
Gerd Moellmann's avatar
Gerd Moellmann committed
504

505 506
int message_enable_multibyte;

507
/* Nonzero if we should redraw the mode lines on the next redisplay.  */
Gerd Moellmann's avatar
Gerd Moellmann committed
508

Jim Blandy's avatar
Jim Blandy committed
509 510
int update_mode_lines;

Gerd Moellmann's avatar
Gerd Moellmann committed
511
/* Nonzero if window sizes or contents have changed since last
512
   redisplay that finished.  */
Gerd Moellmann's avatar
Gerd Moellmann committed
513

Jim Blandy's avatar
Jim Blandy committed
514 515
int windows_or_buffers_changed;

516 517 518 519
/* Nonzero means a frame's cursor type has been changed.  */

int cursor_type_changed;

Gerd Moellmann's avatar
Gerd Moellmann committed
520 521 522
/* Nonzero after display_mode_line if %l was used and it displayed a
   line number.  */

523 524
int line_number_displayed;

525 526 527 528
/* The name of the *Messages* buffer, a string.  */

static Lisp_Object Vmessages_buffer_name;

529 530
/* Current, index 0, and last displayed echo area message.  Either
   buffers from echo_buffers, or nil to indicate no message.  */
531 532 533

Lisp_Object echo_area_buffer[2];

534
/* The buffers referenced from echo_area_buffer.  */
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551

static Lisp_Object echo_buffer[2];

/* A vector saved used in with_area_buffer to reduce consing.  */

static Lisp_Object Vwith_echo_area_save_vector;

/* Non-zero means display_echo_area should display the last echo area
   message again.  Set by redisplay_preserve_echo_area.  */

static int display_last_displayed_message_p;

/* Nonzero if echo area is being used by print; zero if being used by
   message.  */

int message_buf_print;

552 553 554
/* The symbol `inhibit-menubar-update' and its DEFVAR_BOOL variable.  */

Lisp_Object Qinhibit_menubar_update;
555
Lisp_Object Qmessage_truncate_lines;
556

557
/* Set to 1 in clear_message to make redisplay_internal aware
558
   of an emptied echo area.  */
559 560 561

static int message_cleared_p;

Gerd Moellmann's avatar
Gerd Moellmann committed
562 563
/* A scratch glyph row with contents used for generating truncation
   glyphs.  Also used in direct_output_for_insert.  */
564

Gerd Moellmann's avatar
Gerd Moellmann committed
565 566 567
#define MAX_SCRATCH_GLYPHS 100
struct glyph_row scratch_glyph_row;
static struct glyph scratch_glyphs[MAX_SCRATCH_GLYPHS];
568

Gerd Moellmann's avatar
Gerd Moellmann committed
569 570 571 572
/* Ascent and height of the last line processed by move_it_to.  */

static int last_max_ascent, last_height;

573 574 575 576
/* Non-zero if there's a help-echo in the echo area.  */

int help_echo_showing_p;

577 578 579 580 581 582
/* If >= 0, computed, exact values of mode-line and header-line height
   to use in the macros CURRENT_MODE_LINE_HEIGHT and
   CURRENT_HEADER_LINE_HEIGHT.  */

int current_mode_line_height, current_header_line_height;

Gerd Moellmann's avatar
Gerd Moellmann committed
583
/* The maximum distance to look ahead for text properties.  Values
584
   that are too small let us call compute_char_face and similar
Gerd Moellmann's avatar
Gerd Moellmann committed
585 586 587 588 589 590
   functions too often which is expensive.  Values that are too large
   let us call compute_char_face and alike too often because we
   might not be interested in text properties that far away.  */

#define TEXT_PROP_DISTANCE_LIMIT 100

591 592
#if GLYPH_DEBUG

Gerd Moellmann's avatar
Gerd Moellmann committed
593 594 595 596
/* Non-zero means print traces of redisplay if compiled with
   GLYPH_DEBUG != 0.  */

int trace_redisplay_p;
597

598
#endif /* GLYPH_DEBUG */
599

600 601
#ifdef DEBUG_TRACE_MOVE
/* Non-zero means trace with TRACE_MOVE to stderr.  */
602 603 604 605
int trace_move;

#define TRACE_MOVE(x)	if (trace_move) fprintf x; else (void) 0
#else
606
#define TRACE_MOVE(x)	(void) 0
Gerd Moellmann's avatar
Gerd Moellmann committed
607
#endif
608

609
Lisp_Object Qauto_hscroll_mode;
610

611 612 613 614
/* Buffer being redisplayed -- for redisplay_window_error.  */

struct buffer *displayed_buffer;

Gerd Moellmann's avatar
Gerd Moellmann committed
615 616 617
/* Value returned from text property handlers (see below).  */

enum prop_handled
618
{
Gerd Moellmann's avatar
Gerd Moellmann committed
619 620 621 622 623
  HANDLED_NORMALLY,
  HANDLED_RECOMPUTE_PROPS,
  HANDLED_OVERLAY_STRING_CONSUMED,
  HANDLED_RETURN
};
624

Gerd Moellmann's avatar
Gerd Moellmann committed
625 626
/* A description of text properties that redisplay is interested
   in.  */
627

Gerd Moellmann's avatar
Gerd Moellmann committed
628 629 630 631
struct props
{
  /* The name of the property.  */
  Lisp_Object *name;
632

Gerd Moellmann's avatar
Gerd Moellmann committed
633 634 635 636 637
  /* A unique index for the property.  */
  enum prop_idx idx;

  /* A handler function called to set up iterator IT from the property
     at IT's current position.  Value is used to steer handle_stop.  */
638
  enum prop_handled (*handler) (struct it *it);
Gerd Moellmann's avatar
Gerd Moellmann committed
639 640
};

641 642 643 644 645 646
static enum prop_handled handle_face_prop (struct it *);
static enum prop_handled handle_invisible_prop (struct it *);
static enum prop_handled handle_display_prop (struct it *);
static enum prop_handled handle_composition_prop (struct it *);
static enum prop_handled handle_overlay_change (struct it *);
static enum prop_handled handle_fontified_prop (struct it *);
Gerd Moellmann's avatar
Gerd Moellmann committed
647 648 649 650

/* Properties handled by iterators.  */

static struct props it_props[] =
Karl Heuer's avatar
Karl Heuer committed
651
{
Gerd Moellmann's avatar
Gerd Moellmann committed
652 653 654 655 656 657
  {&Qfontified,		FONTIFIED_PROP_IDX,	handle_fontified_prop},
  /* Handle `face' before `display' because some sub-properties of
     `display' need to know the face.  */
  {&Qface,		FACE_PROP_IDX,		handle_face_prop},
  {&Qdisplay,		DISPLAY_PROP_IDX,	handle_display_prop},
  {&Qinvisible,		INVISIBLE_PROP_IDX,	handle_invisible_prop},
658
  {&Qcomposition,	COMPOSITION_PROP_IDX,	handle_composition_prop},
Gerd Moellmann's avatar
Gerd Moellmann committed
659 660
  {NULL,		0,			NULL}
};
Karl Heuer's avatar
Karl Heuer committed
661

Gerd Moellmann's avatar
Gerd Moellmann committed
662 663
/* Value is the position described by X.  If X is a marker, value is
   the marker_position of X.  Otherwise, value is X.  */
664

Gerd Moellmann's avatar
Gerd Moellmann committed
665
#define COERCE_MARKER(X) (MARKERP ((X)) ? Fmarker_position (X) : (X))
666

Gerd Moellmann's avatar
Gerd Moellmann committed
667
/* Enumeration returned by some move_it_.* functions internally.  */
668

Gerd Moellmann's avatar
Gerd Moellmann committed
669 670 671 672
enum move_it_result
{
  /* Not used.  Undefined value.  */
  MOVE_UNDEFINED,
673

Gerd Moellmann's avatar
Gerd Moellmann committed
674 675
  /* Move ended at the requested buffer position or ZV.  */
  MOVE_POS_MATCH_OR_ZV,
676

Gerd Moellmann's avatar
Gerd Moellmann committed
677 678
  /* Move ended at the requested X pixel position.  */
  MOVE_X_REACHED,
679

Gerd Moellmann's avatar
Gerd Moellmann committed
680 681 682
  /* Move within a line ended at the end of a line that must be
     continued.  */
  MOVE_LINE_CONTINUED,
683

Gerd Moellmann's avatar
Gerd Moellmann committed
684 685 686
  /* Move within a line ended at the end of a line that would
     be displayed truncated.  */
  MOVE_LINE_TRUNCATED,
687

Gerd Moellmann's avatar
Gerd Moellmann committed
688 689 690
  /* Move within a line ended at a line end.  */
  MOVE_NEWLINE_OR_CR
};
691

692 693 694 695 696 697 698 699
/* This counter is used to clear the face cache every once in a while
   in redisplay_internal.  It is incremented for each redisplay.
   Every CLEAR_FACE_CACHE_COUNT full redisplays, the face cache is
   cleared.  */

#define CLEAR_FACE_CACHE_COUNT	500
static int clear_face_cache_count;

700 701 702 703 704
/* Similarly for the image cache.  */

#ifdef HAVE_WINDOW_SYSTEM
#define CLEAR_IMAGE_CACHE_COUNT	101
static int clear_image_cache_count;
Eli Zaretskii's avatar
Eli Zaretskii committed
705 706 707

/* Null glyph slice */
static struct glyph_slice null_glyph_slice = { 0, 0, 0, 0 };
708 709
#endif

710 711 712 713
/* Non-zero while redisplay_internal is in progress.  */

int redisplaying_p;

714
Lisp_Object Qinhibit_free_realized_faces;
715

716 717 718 719 720 721
/* If a string, XTread_socket generates an event to display that string.
   (The display is done in read_char.)  */

Lisp_Object help_echo_string;
Lisp_Object help_echo_window;
Lisp_Object help_echo_object;
722
EMACS_INT help_echo_pos;
723 724 725 726 727

/* Temporary variable for XTread_socket.  */

Lisp_Object previous_help_echo_string;

728 729 730 731 732 733
/* Platform-independent portion of hourglass implementation. */

/* Non-zero means an hourglass cursor is currently shown.  */
int hourglass_shown_p;

/* If non-null, an asynchronous timer that, when it expires, displays
734
   an hourglass cursor on all frames.  */
735 736
struct atimer *hourglass_atimer;

737 738 739 740 741 742 743
/* Name of the face used to display glyphless characters.  */
Lisp_Object Qglyphless_char;

/* Symbol for the purpose of Vglyphless_char_display.  */
Lisp_Object Qglyphless_char_display;

/* Method symbols for Vglyphless_char_display.  */
744
static Lisp_Object Qhex_code, Qempty_box, Qthin_space, Qzero_width;
745 746 747 748

/* Default pixel width of `thin-space' display method.  */
#define THIN_SPACE_WIDTH 1

749 750 751 752
/* Default number of seconds to wait before displaying an hourglass
   cursor.  */
#define DEFAULT_HOURGLASS_DELAY 1

Gerd Moellmann's avatar
Gerd Moellmann committed
753 754 755

/* Function prototypes.  */

756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772
static void setup_for_ellipsis (struct it *, int);
static void mark_window_display_accurate_1 (struct window *, int);
static int single_display_spec_string_p (Lisp_Object, Lisp_Object);
static int display_prop_string_p (Lisp_Object, Lisp_Object);
static int cursor_row_p (struct window *, struct glyph_row *);
static int redisplay_mode_lines (Lisp_Object, int);
static char *decode_mode_spec_coding (Lisp_Object, char *, int);

static Lisp_Object get_it_property (struct it *it, Lisp_Object prop);

static void handle_line_prefix (struct it *);

static void pint2str (char *, int, int);
static void pint2hrstr (char *, int, int);
static struct text_pos run_window_scroll_functions (Lisp_Object,
                                                    struct text_pos);
static void reconsider_clip_changes (struct window *, struct buffer *);
773 774
static int text_outside_line_unchanged_p (struct window *,
					  EMACS_INT, EMACS_INT);
775
static void store_mode_line_noprop_char (char);
776
static int store_mode_line_noprop (const char *, int, int);
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806
static void handle_stop (struct it *);
static void handle_stop_backwards (struct it *, EMACS_INT);
static int single_display_spec_intangible_p (Lisp_Object);
static void ensure_echo_area_buffers (void);
static Lisp_Object unwind_with_echo_area_buffer (Lisp_Object);
static Lisp_Object with_echo_area_buffer_unwind_data (struct window *);
static int with_echo_area_buffer (struct window *, int,
                                  int (*) (EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT),
                                  EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT);
static void clear_garbaged_frames (void);
static int current_message_1 (EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT);
static int truncate_message_1 (EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT);
static int set_message_1 (EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT);
static int display_echo_area (struct window *);
static int display_echo_area_1 (EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT);
static int resize_mini_window_1 (EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT);
static Lisp_Object unwind_redisplay (Lisp_Object);
static int string_char_and_length (const unsigned char *, int *);
static struct text_pos display_prop_end (struct it *, Lisp_Object,
                                         struct text_pos);
static int compute_window_start_on_continuation_line (struct window *);
static Lisp_Object safe_eval_handler (Lisp_Object);
static void insert_left_trunc_glyphs (struct it *);
static struct glyph_row *get_overlay_arrow_glyph_row (struct window *,
                                                      Lisp_Object);
static void extend_face_to_end_of_line (struct it *);
static int append_space_for_newline (struct it *, int);
static int cursor_row_fully_visible_p (struct window *, int, int);
static int try_scrolling (Lisp_Object, int, EMACS_INT, EMACS_INT, int, int);
static int try_cursor_movement (Lisp_Object, struct text_pos, int *);
807 808 809
static int trailing_whitespace_p (EMACS_INT);
static int message_log_check_duplicate (EMACS_INT, EMACS_INT,
					EMACS_INT, EMACS_INT);
810 811 812 813 814 815 816 817
static void push_it (struct it *);
static void pop_it (struct it *);
static void sync_frame_with_window_matrix_rows (struct window *);
static void select_frame_for_redisplay (Lisp_Object);
static void redisplay_internal (int);
static int echo_area_display (int);
static void redisplay_windows (Lisp_Object);
static void redisplay_window (Lisp_Object, int);
818
static Lisp_Object redisplay_window_error (Lisp_Object);
819 820 821 822 823 824 825 826 827
static Lisp_Object redisplay_window_0 (Lisp_Object);
static Lisp_Object redisplay_window_1 (Lisp_Object);
static int update_menu_bar (struct frame *, int, int);
static int try_window_reusing_current_matrix (struct window *);
static int try_window_id (struct window *);
static int display_line (struct it *);
static int display_mode_lines (struct window *);
static int display_mode_line (struct window *, enum face_id, Lisp_Object);
static int display_mode_element (struct it *, int, int, int, Lisp_Object, Lisp_Object, int);
828 829 830
static int store_mode_line_string (const char *, Lisp_Object, int, int, int, Lisp_Object);
static const char *decode_mode_spec (struct window *, int, int, int,
				     Lisp_Object *);
831
static void display_menu_bar (struct window *);
832 833
static int display_count_lines (EMACS_INT, EMACS_INT, EMACS_INT, int,
				EMACS_INT *);
834
static int display_string (const char *, Lisp_Object, Lisp_Object,
835 836 837
                           EMACS_INT, EMACS_INT, struct it *, int, int, int, int);
static void compute_line_metrics (struct it *);
static void run_redisplay_end_trigger_hook (struct it *);
838 839
static int get_overlay_strings (struct it *, EMACS_INT);
static int get_overlay_strings_1 (struct it *, EMACS_INT, int);
840 841 842 843 844 845 846 847 848 849 850 851 852 853
static void next_overlay_string (struct it *);
static void reseat (struct it *, struct text_pos, int);
static void reseat_1 (struct it *, struct text_pos, int);
static void back_to_previous_visible_line_start (struct it *);
void reseat_at_previous_visible_line_start (struct it *);
static void reseat_at_next_visible_line_start (struct it *, int);
static int next_element_from_ellipsis (struct it *);
static int next_element_from_display_vector (struct it *);
static int next_element_from_string (struct it *);
static int next_element_from_c_string (struct it *);
static int next_element_from_buffer (struct it *);
static int next_element_from_composition (struct it *);
static int next_element_from_image (struct it *);
static int next_element_from_stretch (struct it *);
854
static void load_overlay_strings (struct it *, EMACS_INT);
855 856
static int init_from_display_pos (struct it *, struct window *,
                                  struct display_pos *);
857
static void reseat_to_string (struct it *, const char *,
858
                              Lisp_Object, EMACS_INT, EMACS_INT, int, int);
859 860 861
static enum move_it_result
       move_it_in_display_line_to (struct it *, EMACS_INT, int,
				   enum move_operation_enum);
862 863 864 865 866 867 868 869
void move_it_vertically_backward (struct it *, int);
static void init_to_row_start (struct it *, struct window *,
                               struct glyph_row *);
static int init_to_row_end (struct it *, struct window *,
                            struct glyph_row *);
static void back_to_previous_line_start (struct it *);
static int forward_to_next_line_start (struct it *, int *);
static struct text_pos string_pos_nchars_ahead (struct text_pos,
870 871
                                                Lisp_Object, EMACS_INT);
static struct text_pos string_pos (EMACS_INT, Lisp_Object);
872 873
static struct text_pos c_string_pos (EMACS_INT, const char *, int);
static EMACS_INT number_of_chars (const char *, int);
874 875 876 877 878 879 880 881 882 883 884
static void compute_stop_pos (struct it *);
static void compute_string_pos (struct text_pos *, struct text_pos,
                                Lisp_Object);
static int face_before_or_after_it_pos (struct it *, int);
static EMACS_INT next_overlay_change (EMACS_INT);
static int handle_single_display_spec (struct it *, Lisp_Object,
                                       Lisp_Object, Lisp_Object,
                                       struct text_pos *, int);
static int underlying_face_id (struct it *);
static int in_ellipses_for_invisible_text_p (struct display_pos *,
                                             struct window *);
Gerd Moellmann's avatar
Gerd Moellmann committed
885 886 887

#define face_before_it_pos(IT) face_before_or_after_it_pos ((IT), 1)
#define face_after_it_pos(IT)  face_before_or_after_it_pos ((IT), 0)
888

Gerd Moellmann's avatar
Gerd Moellmann committed
889
#ifdef HAVE_WINDOW_SYSTEM
890

891 892
static void x_consider_frame_title (Lisp_Object);
static int tool_bar_lines_needed (struct frame *, int *);
893 894 895 896 897 898 899 900 901
static void update_tool_bar (struct frame *, int);
static void build_desired_tool_bar_string (struct frame *f);
static int redisplay_tool_bar (struct frame *);
static void display_tool_bar_line (struct it *, int);
static void notice_overwritten_cursor (struct window *,
                                       enum glyph_row_area,
                                       int, int, int, int);
static void append_stretch_glyph (struct it *, Lisp_Object,
                                  int, int, int);
902

903

Gerd Moellmann's avatar
Gerd Moellmann committed
904
#endif /* HAVE_WINDOW_SYSTEM */
905

906 907 908
static int coords_in_mouse_face_p (struct window *, int, int);


Gerd Moellmann's avatar
Gerd Moellmann committed
909 910 911 912

/***********************************************************************
		      Window display dimensions
 ***********************************************************************/
913

914 915 916 917 918
/* Return the bottom boundary y-position for text lines in window W.
   This is the first y position at which a line cannot start.
   It is relative to the top of the window.

   This is the height of W minus the height of a mode line, if any.  */
Gerd Moellmann's avatar
Gerd Moellmann committed
919 920

INLINE int
921
window_text_bottom_y (struct window *w)
Gerd Moellmann's avatar
Gerd Moellmann committed
922
{
923
  int height = WINDOW_TOTAL_HEIGHT (w);
924

Gerd Moellmann's avatar
Gerd Moellmann committed
925 926 927
  if (WINDOW_WANTS_MODELINE_P (w))
    height -= CURRENT_MODE_LINE_HEIGHT (w);
  return height;
928 929
}

Gerd Moellmann's avatar
Gerd Moellmann committed
930
/* Return the pixel width of display area AREA of window W.  AREA < 0
Kim F. Storm's avatar
Kim F. Storm committed
931
   means return the total width of W, not including fringes to
Gerd Moellmann's avatar
Gerd Moellmann committed
932
   the left and right of the window.  */
933

Gerd Moellmann's avatar
Gerd Moellmann committed
934
INLINE int
935
window_box_width (struct window *w, int area)
Gerd Moellmann's avatar
Gerd Moellmann committed
936
{
937 938
  int cols = XFASTINT (w->total_cols);
  int pixels = 0;
939

Gerd Moellmann's avatar
Gerd Moellmann committed
940
  if (!w->pseudo_window_p)
941
    {
942
      cols -= WINDOW_SCROLL_BAR_COLS (w);
943

Gerd Moellmann's avatar
Gerd Moellmann committed
944 945
      if (area == TEXT_AREA)
	{
946 947 948 949 950
	  if (INTEGERP (w->left_margin_cols))
	    cols -= XFASTINT (w->left_margin_cols);
	  if (INTEGERP (w->right_margin_cols))
	    cols -= XFASTINT (w->right_margin_cols);
	  pixels = -WINDOW_TOTAL_FRINGE_WIDTH (w);
Gerd Moellmann's avatar
Gerd Moellmann committed
951 952
	}
      else if (area == LEFT_MARGIN_AREA)
953 954 955 956 957
	{
	  cols = (INTEGERP (w->left_margin_cols)
		   ? XFASTINT (w->left_margin_cols) : 0);
	  pixels = 0;
	}
Gerd Moellmann's avatar
Gerd Moellmann committed
958
      else if (area == RIGHT_MARGIN_AREA)
959 960 961 962 963
	{
	  cols = (INTEGERP (w->right_margin_cols)
		   ? XFASTINT (w->right_margin_cols) : 0);
	  pixels = 0;
	}
964
    }
Gerd Moellmann's avatar
Gerd Moellmann committed
965

966
  return cols * WINDOW_FRAME_COLUMN_WIDTH (w) + pixels;
967
}
968 969


Gerd Moellmann's avatar
Gerd Moellmann committed
970
/* Return the pixel height of the display area of window W, not
971
   including mode lines of W, if any.  */
972

Gerd Moellmann's avatar
Gerd Moellmann committed
973
INLINE int
974
window_box_height (struct window *w)
975
{
Gerd Moellmann's avatar
Gerd Moellmann committed
976
  struct frame *f = XFRAME (w->frame);
977
  int height = WINDOW_TOTAL_HEIGHT (w);
978 979

  xassert (height >= 0);
980

981 982 983 984 985 986
  /* Note: the code below that determines the mode-line/header-line
     height is essentially the same as that contained in the macro
     CURRENT_{MODE,HEADER}_LINE_HEIGHT, except that it checks whether
     the appropriate glyph row has its `mode_line_p' flag set,
     and if it doesn't, uses estimate_mode_line_height instead.  */

Gerd Moellmann's avatar
Gerd Moellmann committed
987
  if (WINDOW_WANTS_MODELINE_P (w))
988 989 990 991 992 993 994 995
    {
      struct glyph_row *ml_row
	= (w->current_matrix && w->current_matrix->rows
	   ? MATRIX_MODE_LINE_ROW (w->current_matrix)
	   : 0);
      if (ml_row && ml_row->mode_line_p)
	height -= ml_row->height;
      else
996
	height -= estimate_mode_line_height (f, CURRENT_MODE_LINE_FACE_ID (w));
997
    }
Gerd Moellmann's avatar
Gerd Moellmann committed
998

Gerd Moellmann's avatar
Change  
Gerd Moellmann committed
999
  if (WINDOW_WANTS_HEADER_LINE_P (w))
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
    {
      struct glyph_row *hl_row
	= (w->current_matrix && w->current_matrix->rows
	   ? MATRIX_HEADER_LINE_ROW (w->current_matrix)
	   : 0);
      if (hl_row && hl_row->mode_line_p)
	height -= hl_row->height;
      else
	height -= estimate_mode_line_height (f, HEADER_LINE_FACE_ID);
    }
Gerd Moellmann's avatar
Gerd Moellmann committed
1010

1011 1012 1013
  /* With a very small font and a mode-line that's taller than
     default, we might end up with a negative height.  */
  return max (0, height);
Karl Heuer's avatar
Karl Heuer committed
1014 1015
}

1016 1017 1018 1019 1020
/* Return the window-relative coordinate of the left edge of display
   area AREA of window W.  AREA < 0 means return the left edge of the
   whole window, to the right of the left fringe of W.  */

INLINE int
1021
window_box_left_offset (struct window *w, int area)
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
{
  int x;

  if (w->pseudo_window_p)
    return 0;

  x = WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w);

  if (area == TEXT_AREA)
    x += (WINDOW_LEFT_FRINGE_WIDTH (w)
	  + window_box_width (w, LEFT_MARGIN_AREA));
  else if (area == RIGHT_MARGIN_AREA)
    x += (WINDOW_LEFT_FRINGE_WIDTH (w)
	  + window_box_width (w, LEFT_MARGIN_AREA)
	  + window_box_width (w, TEXT_AREA)
	  + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
	     ? 0
	     : WINDOW_RIGHT_FRINGE_WIDTH (w)));
  else if (area == LEFT_MARGIN_AREA
	   && WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
    x += WINDOW_LEFT_FRINGE_WIDTH (w);

  return x;
}


/* Return the window-relative coordinate of the right edge of display
1049
   area AREA of window W.  AREA < 0 means return the right edge of the
1050 1051 1052
   whole window, to the left of the right fringe of W.  */

INLINE int
1053
window_box_right_offset (struct window *w, int area)
1054 1055 1056
{
  return window_box_left_offset (w, area) + window_box_width (w, area);
}
Karl Heuer's avatar
Karl Heuer committed
1057

Gerd Moellmann's avatar
Gerd Moellmann committed
1058 1059
/* Return the frame-relative coordinate of the left edge of display
   area AREA of window W.  AREA < 0 means return the left edge of the
Kim F. Storm's avatar
Kim F. Storm committed
1060
   whole window, to the right of the left fringe of W.  */
Karl Heuer's avatar
Karl Heuer committed
1061

Gerd Moellmann's avatar
Gerd Moellmann committed
1062
INLINE int
1063
window_box_left (struct window *w, int area)
1064
{
Gerd Moellmann's avatar
Gerd Moellmann committed
1065
  struct frame *f = XFRAME (w->frame);
1066
  int x;
1067

1068 1069
  if (w->pseudo_window_p)
    return FRAME_INTERNAL_BORDER_WIDTH (f);
1070

1071 1072
  x = (WINDOW_LEFT_EDGE_X (w)
       + window_box_left_offset (w, area));
1073

Gerd Moellmann's avatar
Gerd Moellmann committed
1074
  return x;
1075
}
1076

1077

Gerd Moellmann's avatar
Gerd Moellmann committed
1078
/* Return the frame-relative coordinate of the right edge of display
1079
   area AREA of window W.  AREA < 0 means return the right edge of the
Kim F. Storm's avatar
Kim F. Storm committed
1080
   whole window, to the left of the right fringe of W.  */
1081

Gerd Moellmann's avatar
Gerd Moellmann committed
1082
INLINE int
1083
window_box_right (struct window *w, int area)
Gerd Moellmann's avatar
Gerd Moellmann committed
1084 1085
{
  return window_box_left (w, area) + window_box_width (w, area);
1086 1087
}

Gerd Moellmann's avatar
Gerd Moellmann committed
1088 1089
/* Get the bounding box of the display area AREA of window W, without
   mode lines, in frame-relative coordinates.  AREA < 0 means the
Kim F. Storm's avatar
Kim F. Storm committed
1090
   whole window, not including the left and right fringes of
Gerd Moellmann's avatar
Gerd Moellmann committed
1091 1092 1093 1094 1095
   the window.  Return in *BOX_X and *BOX_Y the frame-relative pixel
   coordinates of the upper-left corner of the box.  Return in
   *BOX_WIDTH, and *BOX_HEIGHT the pixel width and height of the box.  */

INLINE void
1096 1097
window_box (struct window *w, int area, int *box_x, int *box_y,
	    int *box_width, int *box_height)
Gerd Moellmann's avatar
Gerd Moellmann committed
1098
{
1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110
  if (box_width)
    *box_width = window_box_width (w, area);
  if (box_height)
    *box_height = window_box_height (w);
  if (box_x)
    *box_x = window_box_left (w, area);
  if (box_y)
    {
      *box_y = WINDOW_TOP_EDGE_Y (w);
      if (WINDOW_WANTS_HEADER_LINE_P (w))
	*box_y += CURRENT_HEADER_LINE_HEIGHT (w);
    }
1111
}
1112 1113


Gerd Moellmann's avatar
Gerd Moellmann committed
1114
/* Get the bounding box of the display area AREA of window W, without
Kim F. Storm's avatar
Kim F. Storm committed
1115 1116
   mode lines.  AREA < 0 means the whole window, not including the
   left and right fringe of the window.  Return in *TOP_LEFT_X
Gerd Moellmann's avatar
Gerd Moellmann committed
1117 1118 1119