1 /* Display generation from window structure and buffer text.
    2    Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995,
    3                  1997, 1998, 1999, 2000, 2001, 2002, 2003,
    4                  2004, 2005, 2006, 2007, 2008, 2009, 2010
    5                  Free Software Foundation, Inc.
    6 
    7 This file is part of GNU Emacs.
    8 
    9 GNU Emacs is free software: you can redistribute it and/or modify
   10 it under the terms of the GNU General Public License as published by
   11 the Free Software Foundation, either version 3 of the License, or
   12 (at your option) any later version.
   13 
   14 GNU Emacs is distributed in the hope that it will be useful,
   15 but WITHOUT ANY WARRANTY; without even the implied warranty of
   16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   17 GNU General Public License for more details.
   18 
   19 You should have received a copy of the GNU General Public License
   20 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
   21 
   22 /* New redisplay written by Gerd Moellmann <gerd@gnu.org>.
   23 
   24    Redisplay.
   25 
   26    Emacs separates the task of updating the display from code
   27    modifying global state, e.g. buffer text.  This way functions
   28    operating on buffers don't also have to be concerned with updating
   29    the display.
   30 
   31    Updating the display is triggered by the Lisp interpreter when it
   32    decides it's time to do it.  This is done either automatically for
   33    you as part of the interpreter's command loop or as the result of
   34    calling Lisp functions like `sit-for'.  The C function `redisplay'
   35    in xdisp.c is the only entry into the inner redisplay code.
   36 
   37    The following diagram shows how redisplay code is invoked.  As you
   38    can see, Lisp calls redisplay and vice versa.  Under window systems
   39    like X, some portions of the redisplay code are also called
   40    asynchronously during mouse movement or expose events.  It is very
   41    important that these code parts do NOT use the C library (malloc,
   42    free) because many C libraries under Unix are not reentrant.  They
   43    may also NOT call functions of the Lisp interpreter which could
   44    change the interpreter's state.  If you don't follow these rules,
   45    you will encounter bugs which are very hard to explain.
   46 
   47    +--------------+   redisplay     +----------------+
   48    | Lisp machine |---------------->| Redisplay code |<--+
   49    +--------------+   (xdisp.c)     +----------------+   |
   50           ^                                  |           |
   51           +----------------------------------+           |
   52             Don't use this path when called              |
   53             asynchronously!                              |
   54                                                          |
   55                            expose_window (asynchronous)  |
   56                                                          |
   57                                    X expose events  -----+
   58 
   59    What does redisplay do?  Obviously, it has to figure out somehow what
   60    has been changed since the last time the display has been updated,
   61    and to make these changes visible.  Preferably it would do that in
   62    a moderately intelligent way, i.e. fast.
   63 
   64    Changes in buffer text can be deduced from window and buffer
   65    structures, and from some global variables like `beg_unchanged' and
   66    `end_unchanged'.  The contents of the display are additionally
   67    recorded in a `glyph matrix', a two-dimensional matrix of glyph
   68    structures.  Each row in such a matrix corresponds to a line on the
   69    display, and each glyph in a row corresponds to a column displaying
   70    a character, an image, or what else.  This matrix is called the
   71    `current glyph matrix' or `current matrix' in redisplay
   72    terminology.
   73 
   74    For buffer parts that have been changed since the last update, a
   75    second glyph matrix is constructed, the so called `desired glyph
   76    matrix' or short `desired matrix'.  Current and desired matrix are
   77    then compared to find a cheap way to update the display, e.g. by
   78    reusing part of the display by scrolling lines.
   79 
   80    You will find a lot of redisplay optimizations when you start
   81    looking at the innards of redisplay.  The overall goal of all these
   82    optimizations is to make redisplay fast because it is done
   83    frequently.  Some of these optimizations are implemented by the
   84    following functions:
   85 
   86     . try_cursor_movement
   87 
   88       This function tries to update the display if the text in the
   89       window did not change and did not scroll, only point moved, and
   90       it did not move off the displayed portion of the text.
   91 
   92     . try_window_reusing_current_matrix
   93 
   94       This function reuses the current matrix of a window when text
   95       has not changed, but the window start changed (e.g., due to
   96       scrolling).
   97 
   98     . try_window_id
   99 
  100       This function attempts to redisplay a window by reusing parts of
  101       its existing display.  It finds and reuses the part that was not
  102       changed, and redraws the rest.
  103 
  104     . try_window
  105 
  106       This function performs the full redisplay of a single window
  107       assuming that its fonts were not changed and that the cursor
  108       will not end up in the scroll margins.  (Loading fonts requires
  109       re-adjustment of dimensions of glyph matrices, which makes this
  110       method impossible to use.)
  111 
  112    These optimizations are tried in sequence (some can be skipped if
  113    it is known that they are not applicable).  If none of the
  114    optimizations were successful, redisplay calls redisplay_windows,
  115    which performs a full redisplay of all windows.
  116 
  117    Desired matrices.
  118 
  119    Desired matrices are always built per Emacs window.  The function
  120    `display_line' is the central function to look at if you are
  121    interested.  It constructs one row in a desired matrix given an
  122    iterator structure containing both a buffer position and a
  123    description of the environment in which the text is to be
  124    displayed.  But this is too early, read on.
  125 
  126    Characters and pixmaps displayed for a range of buffer text depend
  127    on various settings of buffers and windows, on overlays and text
  128    properties, on display tables, on selective display.  The good news
  129    is that all this hairy stuff is hidden behind a small set of
  130    interface functions taking an iterator structure (struct it)
  131    argument.
  132 
  133    Iteration over things to be displayed is then simple.  It is
  134    started by initializing an iterator with a call to init_iterator.
  135    Calls to get_next_display_element fill the iterator structure with
  136    relevant information about the next thing to display.  Calls to
  137    set_iterator_to_next move the iterator to the next thing.
  138 
  139    Besides this, an iterator also contains information about the
  140    display environment in which glyphs for display elements are to be
  141    produced.  It has fields for the width and height of the display,
  142    the information whether long lines are truncated or continued, a
  143    current X and Y position, and lots of other stuff you can better
  144    see in dispextern.h.
  145 
  146    Glyphs in a desired matrix are normally constructed in a loop
  147    calling get_next_display_element and then PRODUCE_GLYPHS.  The call
  148    to PRODUCE_GLYPHS will fill the iterator structure with pixel
  149    information about the element being displayed and at the same time
  150    produce glyphs for it.  If the display element fits on the line
  151    being displayed, set_iterator_to_next is called next, otherwise the
  152    glyphs produced are discarded.  The function display_line is the
  153    workhorse of filling glyph rows in the desired matrix with glyphs.
  154    In addition to producing glyphs, it also handles line truncation
  155    and continuation, word wrap, and cursor positioning (for the
  156    latter, see also set_cursor_from_row).
  157 
  158    Frame matrices.
  159 
  160    That just couldn't be all, could it?  What about terminal types not
  161    supporting operations on sub-windows of the screen?  To update the
  162    display on such a terminal, window-based glyph matrices are not
  163    well suited.  To be able to reuse part of the display (scrolling
  164    lines up and down), we must instead have a view of the whole
  165    screen.  This is what `frame matrices' are for.  They are a trick.
  166 
  167    Frames on terminals like above have a glyph pool.  Windows on such
  168    a frame sub-allocate their glyph memory from their frame's glyph
  169    pool.  The frame itself is given its own glyph matrices.  By
  170    coincidence---or maybe something else---rows in window glyph
  171    matrices are slices of corresponding rows in frame matrices.  Thus
  172    writing to window matrices implicitly updates a frame matrix which
  173    provides us with the view of the whole screen that we originally
  174    wanted to have without having to move many bytes around.  To be
  175    honest, there is a little bit more done, but not much more.  If you
  176    plan to extend that code, take a look at dispnew.c.  The function
  177    build_frame_matrix is a good starting point.
  178 
  179    Bidirectional display.
  180 
  181    Bidirectional display adds quite some hair to this already complex
  182    design.  The good news are that a large portion of that hairy stuff
  183    is hidden in bidi.c behind only 3 interfaces.  bidi.c implements a
  184    reordering engine which is called by set_iterator_to_next and
  185    returns the next character to display in the visual order.  See
  186    commentary on bidi.c for more details.  As far as redisplay is
  187    concerned, the effect of calling bidi_move_to_visually_next, the
  188    main interface of the reordering engine, is that the iterator gets
  189    magically placed on the buffer or string position that is to be
  190    displayed next.  In other words, a linear iteration through the
  191    buffer/string is replaced with a non-linear one.  All the rest of
  192    the redisplay is oblivious to the bidi reordering.
  193 
  194    Well, almost oblivious---there are still complications, most of
  195    them due to the fact that buffer and string positions no longer
  196    change monotonously with glyph indices in a glyph row.  Moreover,
  197    for continued lines, the buffer positions may not even be
  198    monotonously changing with vertical positions.  Also, accounting
  199    for face changes, overlays, etc. becomes more complex because
  200    non-linear iteration could potentially skip many positions with
  201    changes, and then cross them again on the way back...
  202 
  203    One other prominent effect of bidirectional display is that some
  204    paragraphs of text need to be displayed starting at the right
  205    margin of the window---the so-called right-to-left, or R2L
  206    paragraphs.  R2L paragraphs are displayed with R2L glyph rows,
  207    which have their reversed_p flag set.  The bidi reordering engine
  208    produces characters in such rows starting from the character which
  209    should be the rightmost on display.  PRODUCE_GLYPHS then reverses
  210    the order, when it fills up the glyph row whose reversed_p flag is
  211    set, by prepending each new glyph to what is already there, instead
  212    of appending it.  When the glyph row is complete, the function
  213    extend_face_to_end_of_line fills the empty space to the left of the
  214    leftmost character with special glyphs, which will display as,
  215    well, empty.  On text terminals, these special glyphs are simply
  216    blank characters.  On graphics terminals, there's a single stretch
  217    glyph with suitably computed width.  Both the blanks and the
  218    stretch glyph are given the face of the background of the line.
  219    This way, the terminal-specific back-end can still draw the glyphs
  220    left to right, even for R2L lines.  */
  221 
  222 #include <config.h>
  223 #include <stdio.h>
  224 #include <limits.h>
  225 #include <setjmp.h>
  226 
  227 #include "lisp.h"
  228 #include "keyboard.h"
  229 #include "frame.h"
  230 #include "window.h"
  231 #include "termchar.h"
  232 #include "dispextern.h"
  233 #include "buffer.h"
  234 #include "character.h"
  235 #include "charset.h"
  236 #include "indent.h"
  237 #include "commands.h"
  238 #include "keymap.h"
  239 #include "macros.h"
  240 #include "disptab.h"
  241 #include "termhooks.h"
  242 #include "intervals.h"
  243 #include "coding.h"
  244 #include "process.h"
  245 #include "region-cache.h"
  246 #include "font.h"
  247 #include "fontset.h"
  248 #include "blockinput.h"
  249 
  250 #ifdef HAVE_X_WINDOWS
  251 #include "xterm.h"
  252 #endif
  253 #ifdef WINDOWSNT
  254 #include "w32term.h"
  255 #endif
  256 #ifdef HAVE_NS
  257 #include "nsterm.h"
  258 #endif
  259 #ifdef USE_GTK
  260 #include "gtkutil.h"
  261 #endif
  262 
  263 #include "font.h"
  264 
  265 #ifndef FRAME_X_OUTPUT
  266 #define FRAME_X_OUTPUT(f) ((f)->output_data.x)
  267 #endif
  268 
  269 #define INFINITY 10000000
  270 
  271 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
  272     || defined(HAVE_NS) || defined (USE_GTK)
  273 extern void set_frame_menubar P_ ((struct frame *f, int, int));
  274 extern int pending_menu_activation;
  275 #endif
  276 
  277 extern int interrupt_input;
  278 extern int command_loop_level;
  279 
  280 extern Lisp_Object do_mouse_tracking;
  281 
  282 extern int minibuffer_auto_raise;
  283 extern Lisp_Object Vminibuffer_list;
  284 
  285 extern Lisp_Object Qface;
  286 extern Lisp_Object Qmode_line, Qmode_line_inactive, Qheader_line;
  287 
  288 extern Lisp_Object Voverriding_local_map;
  289 extern Lisp_Object Voverriding_local_map_menu_flag;
  290 extern Lisp_Object Qmenu_item;
  291 extern Lisp_Object Qwhen;
  292 extern Lisp_Object Qhelp_echo;
  293 extern Lisp_Object Qbefore_string, Qafter_string;
  294 
  295 Lisp_Object Qoverriding_local_map, Qoverriding_terminal_local_map;
  296 Lisp_Object Qwindow_scroll_functions, Vwindow_scroll_functions;
  297 Lisp_Object Qwindow_text_change_functions, Vwindow_text_change_functions;
  298 Lisp_Object Qredisplay_end_trigger_functions, Vredisplay_end_trigger_functions;
  299 Lisp_Object Qinhibit_point_motion_hooks;
  300 Lisp_Object QCeval, QCfile, QCdata, QCpropertize;
  301 Lisp_Object Qfontified;
  302 Lisp_Object Qgrow_only;
  303 Lisp_Object Qinhibit_eval_during_redisplay;
  304 Lisp_Object Qbuffer_position, Qposition, Qobject;
  305 Lisp_Object Qright_to_left, Qleft_to_right;
  306 
  307 /* Cursor shapes */
  308 Lisp_Object Qbar, Qhbar, Qbox, Qhollow;
  309 
  310 /* Pointer shapes */
  311 Lisp_Object Qarrow, Qhand, Qtext;
  312 
  313 Lisp_Object Qrisky_local_variable;
  314 
  315 /* Holds the list (error).  */
  316 Lisp_Object list_of_error;
  317 
  318 /* Functions called to fontify regions of text.  */
  319 
  320 Lisp_Object Vfontification_functions;
  321 Lisp_Object Qfontification_functions;
  322 
  323 /* Non-nil means automatically select any window when the mouse
  324    cursor moves into it.  */
  325 Lisp_Object Vmouse_autoselect_window;
  326 
  327 Lisp_Object Vwrap_prefix, Qwrap_prefix;
  328 Lisp_Object Vline_prefix, Qline_prefix;
  329 
  330 /* Non-zero means draw tool bar buttons raised when the mouse moves
  331    over them.  */
  332 
  333 int auto_raise_tool_bar_buttons_p;
  334 
  335 /* Non-zero means to reposition window if cursor line is only partially visible.  */
  336 
  337 int make_cursor_line_fully_visible_p;
  338 
  339 /* Margin below tool bar in pixels.  0 or nil means no margin.
  340    If value is `internal-border-width' or `border-width',
  341    the corresponding frame parameter is used.  */
  342 
  343 Lisp_Object Vtool_bar_border;
  344 
  345 /* Margin around tool bar buttons in pixels.  */
  346 
  347 Lisp_Object Vtool_bar_button_margin;
  348 
  349 /* Thickness of shadow to draw around tool bar buttons.  */
  350 
  351 EMACS_INT tool_bar_button_relief;
  352 
  353 /* Non-nil means automatically resize tool-bars so that all tool-bar
  354    items are visible, and no blank lines remain.
  355 
  356    If value is `grow-only', only make tool-bar bigger.  */
  357 
  358 Lisp_Object Vauto_resize_tool_bars;
  359 
  360 /* Type of tool bar.  Can be symbols image, text, both or both-hroiz.  */
  361 
  362 Lisp_Object Vtool_bar_style;
  363 
  364 /* Maximum number of characters a label can have to be shown.  */
  365 
  366 EMACS_INT tool_bar_max_label_size;
  367 
  368 /* Non-zero means draw block and hollow cursor as wide as the glyph
  369    under it.  For example, if a block cursor is over a tab, it will be
  370    drawn as wide as that tab on the display.  */
  371 
  372 int x_stretch_cursor_p;
  373 
  374 /* Non-nil means don't actually do any redisplay.  */
  375 
  376 Lisp_Object Vinhibit_redisplay, Qinhibit_redisplay;
  377 
  378 /* Non-zero means Lisp evaluation during redisplay is inhibited.  */
  379 
  380 int inhibit_eval_during_redisplay;
  381 
  382 /* Names of text properties relevant for redisplay.  */
  383 
  384 Lisp_Object Qdisplay;
  385 extern Lisp_Object Qface, Qinvisible, Qwidth;
  386 
  387 /* Symbols used in text property values.  */
  388 
  389 Lisp_Object Vdisplay_pixels_per_inch;
  390 Lisp_Object Qspace, QCalign_to, QCrelative_width, QCrelative_height;
  391 Lisp_Object Qleft_margin, Qright_margin, Qspace_width, Qraise;
  392 Lisp_Object Qslice;
  393 Lisp_Object Qcenter;
  394 Lisp_Object Qmargin, Qpointer;
  395 Lisp_Object Qline_height;
  396 extern Lisp_Object Qheight;
  397 extern Lisp_Object QCwidth, QCheight, QCascent;
  398 extern Lisp_Object Qscroll_bar;
  399 extern Lisp_Object Qcursor;
  400 
  401 /* Non-nil means highlight trailing whitespace.  */
  402 
  403 Lisp_Object Vshow_trailing_whitespace;
  404 
  405 /* Non-nil means escape non-break space and hyphens.  */
  406 
  407 Lisp_Object Vnobreak_char_display;
  408 
  409 #ifdef HAVE_WINDOW_SYSTEM
  410 extern Lisp_Object Voverflow_newline_into_fringe;
  411 
  412 /* Test if overflow newline into fringe.  Called with iterator IT
  413    at or past right window margin, and with IT->current_x set.  */
  414 
  415 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(IT)             \
  416   (!NILP (Voverflow_newline_into_fringe)                \
  417    && FRAME_WINDOW_P ((IT)->f)                          \
  418    && ((IT)->bidi_it.paragraph_dir == R2L               \
  419        ? (WINDOW_LEFT_FRINGE_WIDTH ((IT)->w) > 0)       \
  420        : (WINDOW_RIGHT_FRINGE_WIDTH ((IT)->w) > 0))     \
  421    && (IT)->current_x == (IT)->last_visible_x           \
  422    && (IT)->line_wrap != WORD_WRAP)
  423 
  424 #else /* !HAVE_WINDOW_SYSTEM */
  425 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it) 0
  426 #endif /* HAVE_WINDOW_SYSTEM */
  427 
  428 /* Test if the display element loaded in IT is a space or tab
  429    character.  This is used to determine word wrapping.  */
  430 
  431 #define IT_DISPLAYING_WHITESPACE(it)                            \
  432   (it->what == IT_CHARACTER && (it->c == ' ' || it->c == '\t'))
  433 
  434 /* Non-nil means show the text cursor in void text areas
  435    i.e. in blank areas after eol and eob.  This used to be
  436    the default in 21.3.  */
  437 
  438 Lisp_Object Vvoid_text_area_pointer;
  439 
  440 /* Name of the face used to highlight trailing whitespace.  */
  441 
  442 Lisp_Object Qtrailing_whitespace;
  443 
  444 /* Name and number of the face used to highlight escape glyphs.  */
  445 
  446 Lisp_Object Qescape_glyph;
  447 
  448 /* Name and number of the face used to highlight non-breaking spaces.  */
  449 
  450 Lisp_Object Qnobreak_space;
  451 
  452 /* The symbol `image' which is the car of the lists used to represent
  453    images in Lisp.  Also a tool bar style.  */
  454 
  455 Lisp_Object Qimage;
  456 
  457 /* The image map types.  */
  458 Lisp_Object QCmap, QCpointer;
  459 Lisp_Object Qrect, Qcircle, Qpoly;
  460 
  461 /* Tool bar styles */
  462 Lisp_Object Qtext, Qboth, Qboth_horiz;
  463 
  464 /* Non-zero means print newline to stdout before next mini-buffer
  465    message.  */
  466 
  467 int noninteractive_need_newline;
  468 
  469 /* Non-zero means print newline to message log before next message.  */
  470 
  471 static int message_log_need_newline;
  472 
  473 /* Three markers that message_dolog uses.
  474    It could allocate them itself, but that causes trouble
  475    in handling memory-full errors.  */
  476 static Lisp_Object message_dolog_marker1;
  477 static Lisp_Object message_dolog_marker2;
  478 static Lisp_Object message_dolog_marker3;
  479 
  480 /* The buffer position of the first character appearing entirely or
  481    partially on the line of the selected window which contains the
  482    cursor; <= 0 if not known.  Set by set_cursor_from_row, used for
  483    redisplay optimization in redisplay_internal.  */
  484 
  485 static struct text_pos this_line_start_pos;
  486 
  487 /* Number of characters past the end of the line above, including the
  488    terminating newline.  */
  489 
  490 static struct text_pos this_line_end_pos;
  491 
  492 /* The vertical positions and the height of this line.  */
  493 
  494 static int this_line_vpos;
  495 static int this_line_y;
  496 static int this_line_pixel_height;
  497 
  498 /* X position at which this display line starts.  Usually zero;
  499    negative if first character is partially visible.  */
  500 
  501 static int this_line_start_x;
  502 
  503 /* Buffer that this_line_.* variables are referring to.  */
  504 
  505 static struct buffer *this_line_buffer;
  506 
  507 /* Nonzero means truncate lines in all windows less wide than the
  508    frame.  */
  509 
  510 Lisp_Object Vtruncate_partial_width_windows;
  511 
  512 /* A flag to control how to display unibyte 8-bit character.  */
  513 
  514 int unibyte_display_via_language_environment;
  515 
  516 /* Nonzero means we have more than one non-mini-buffer-only frame.
  517    Not guaranteed to be accurate except while parsing
  518    frame-title-format.  */
  519 
  520 int multiple_frames;
  521 
  522 Lisp_Object Vglobal_mode_string;
  523 
  524 
  525 /* List of variables (symbols) which hold markers for overlay arrows.
  526    The symbols on this list are examined during redisplay to determine
  527    where to display overlay arrows.  */
  528 
  529 Lisp_Object Voverlay_arrow_variable_list;
  530 
  531 /* Marker for where to display an arrow on top of the buffer text.  */
  532 
  533 Lisp_Object Voverlay_arrow_position;
  534 
  535 /* String to display for the arrow.  Only used on terminal frames.  */
  536 
  537 Lisp_Object Voverlay_arrow_string;
  538 
  539 /* Values of those variables at last redisplay are stored as
  540    properties on `overlay-arrow-position' symbol.  However, if
  541    Voverlay_arrow_position is a marker, last-arrow-position is its
  542    numerical position.  */
  543 
  544 Lisp_Object Qlast_arrow_position, Qlast_arrow_string;
  545 
  546 /* Alternative overlay-arrow-string and overlay-arrow-bitmap
  547    properties on a symbol in overlay-arrow-variable-list.  */
  548 
  549 Lisp_Object Qoverlay_arrow_string, Qoverlay_arrow_bitmap;
  550 
  551 /* Like mode-line-format, but for the title bar on a visible frame.  */
  552 
  553 Lisp_Object Vframe_title_format;
  554 
  555 /* Like mode-line-format, but for the title bar on an iconified frame.  */
  556 
  557 Lisp_Object Vicon_title_format;
  558 
  559 /* List of functions to call when a window's size changes.  These
  560    functions get one arg, a frame on which one or more windows' sizes
  561    have changed.  */
  562 
  563 static Lisp_Object Vwindow_size_change_functions;
  564 
  565 Lisp_Object Qmenu_bar_update_hook, Vmenu_bar_update_hook;
  566 
  567 /* Nonzero if an overlay arrow has been displayed in this window.  */
  568 
  569 static int overlay_arrow_seen;
  570 
  571 /* Nonzero means highlight the region even in nonselected windows.  */
  572 
  573 int highlight_nonselected_windows;
  574 
  575 /* If cursor motion alone moves point off frame, try scrolling this
  576    many lines up or down if that will bring it back.  */
  577 
  578 static EMACS_INT scroll_step;
  579 
  580 /* Nonzero means scroll just far enough to bring point back on the
  581    screen, when appropriate.  */
  582 
  583 static EMACS_INT scroll_conservatively;
  584 
  585 /* Recenter the window whenever point gets within this many lines of
  586    the top or bottom of the window.  This value is translated into a
  587    pixel value by multiplying it with FRAME_LINE_HEIGHT, which means
  588    that there is really a fixed pixel height scroll margin.  */
  589 
  590 EMACS_INT scroll_margin;
  591 
  592 /* Number of windows showing the buffer of the selected window (or
  593    another buffer with the same base buffer).  keyboard.c refers to
  594    this.  */
  595 
  596 int buffer_shared;
  597 
  598 /* Vector containing glyphs for an ellipsis `...'.  */
  599 
  600 static Lisp_Object default_invis_vector[3];
  601 
  602 /* Zero means display the mode-line/header-line/menu-bar in the default face
  603    (this slightly odd definition is for compatibility with previous versions
  604    of emacs), non-zero means display them using their respective faces.
  605 
  606    This variable is deprecated.  */
  607 
  608 int mode_line_inverse_video;
  609 
  610 /* Prompt to display in front of the mini-buffer contents.  */
  611 
  612 Lisp_Object minibuf_prompt;
  613 
  614 /* Width of current mini-buffer prompt.  Only set after display_line
  615    of the line that contains the prompt.  */
  616 
  617 int minibuf_prompt_width;
  618 
  619 /* This is the window where the echo area message was displayed.  It
  620    is always a mini-buffer window, but it may not be the same window
  621    currently active as a mini-buffer.  */
  622 
  623 Lisp_Object echo_area_window;
  624 
  625 /* List of pairs (MESSAGE . MULTIBYTE).  The function save_message
  626    pushes the current message and the value of
  627    message_enable_multibyte on the stack, the function restore_message
  628    pops the stack and displays MESSAGE again.  */
  629 
  630 Lisp_Object Vmessage_stack;
  631 
  632 /* Nonzero means multibyte characters were enabled when the echo area
  633    message was specified.  */
  634 
  635 int message_enable_multibyte;
  636 
  637 /* Nonzero if we should redraw the mode lines on the next redisplay.  */
  638 
  639 int update_mode_lines;
  640 
  641 /* Nonzero if window sizes or contents have changed since last
  642    redisplay that finished.  */
  643 
  644 int windows_or_buffers_changed;
  645 
  646 /* Nonzero means a frame's cursor type has been changed.  */
  647 
  648 int cursor_type_changed;
  649 
  650 /* Nonzero after display_mode_line if %l was used and it displayed a
  651    line number.  */
  652 
  653 int line_number_displayed;
  654 
  655 /* Maximum buffer size for which to display line numbers.  */
  656 
  657 Lisp_Object Vline_number_display_limit;
  658 
  659 /* Line width to consider when repositioning for line number display.  */
  660 
  661 static EMACS_INT line_number_display_limit_width;
  662 
  663 /* Number of lines to keep in the message log buffer.  t means
  664    infinite.  nil means don't log at all.  */
  665 
  666 Lisp_Object Vmessage_log_max;
  667 
  668 /* The name of the *Messages* buffer, a string.  */
  669 
  670 static Lisp_Object Vmessages_buffer_name;
  671 
  672 /* Current, index 0, and last displayed echo area message.  Either
  673    buffers from echo_buffers, or nil to indicate no message.  */
  674 
  675 Lisp_Object echo_area_buffer[2];
  676 
  677 /* The buffers referenced from echo_area_buffer.  */
  678 
  679 static Lisp_Object echo_buffer[2];
  680 
  681 /* A vector saved used in with_area_buffer to reduce consing.  */
  682 
  683 static Lisp_Object Vwith_echo_area_save_vector;
  684 
  685 /* Non-zero means display_echo_area should display the last echo area
  686    message again.  Set by redisplay_preserve_echo_area.  */
  687 
  688 static int display_last_displayed_message_p;
  689 
  690 /* Nonzero if echo area is being used by print; zero if being used by
  691    message.  */
  692 
  693 int message_buf_print;
  694 
  695 /* The symbol `inhibit-menubar-update' and its DEFVAR_BOOL variable.  */
  696 
  697 Lisp_Object Qinhibit_menubar_update;
  698 int inhibit_menubar_update;
  699 
  700 /* When evaluating expressions from menu bar items (enable conditions,
  701    for instance), this is the frame they are being processed for.  */
  702 
  703 Lisp_Object Vmenu_updating_frame;
  704 
  705 /* Maximum height for resizing mini-windows.  Either a float
  706    specifying a fraction of the available height, or an integer
  707    specifying a number of lines.  */
  708 
  709 Lisp_Object Vmax_mini_window_height;
  710 
  711 /* Non-zero means messages should be displayed with truncated
  712    lines instead of being continued.  */
  713 
  714 int message_truncate_lines;
  715 Lisp_Object Qmessage_truncate_lines;
  716 
  717 /* Set to 1 in clear_message to make redisplay_internal aware
  718    of an emptied echo area.  */
  719 
  720 static int message_cleared_p;
  721 
  722 /* How to blink the default frame cursor off.  */
  723 Lisp_Object Vblink_cursor_alist;
  724 
  725 /* A scratch glyph row with contents used for generating truncation
  726    glyphs.  Also used in direct_output_for_insert.  */
  727 
  728 #define MAX_SCRATCH_GLYPHS 100
  729 struct glyph_row scratch_glyph_row;
  730 static struct glyph scratch_glyphs[MAX_SCRATCH_GLYPHS];
  731 
  732 /* Ascent and height of the last line processed by move_it_to.  */
  733 
  734 static int last_max_ascent, last_height;
  735 
  736 /* Non-zero if there's a help-echo in the echo area.  */
  737 
  738 int help_echo_showing_p;
  739 
  740 /* If >= 0, computed, exact values of mode-line and header-line height
  741    to use in the macros CURRENT_MODE_LINE_HEIGHT and
  742    CURRENT_HEADER_LINE_HEIGHT.  */
  743 
  744 int current_mode_line_height, current_header_line_height;
  745 
  746 /* The maximum distance to look ahead for text properties.  Values
  747    that are too small let us call compute_char_face and similar
  748    functions too often which is expensive.  Values that are too large
  749    let us call compute_char_face and alike too often because we
  750    might not be interested in text properties that far away.  */
  751 
  752 #define TEXT_PROP_DISTANCE_LIMIT 100
  753 
  754 #if GLYPH_DEBUG
  755 
  756 /* Variables to turn off display optimizations from Lisp.  */
  757 
  758 int inhibit_try_window_id, inhibit_try_window_reusing;
  759 int inhibit_try_cursor_movement;
  760 
  761 /* Non-zero means print traces of redisplay if compiled with
  762    GLYPH_DEBUG != 0.  */
  763 
  764 int trace_redisplay_p;
  765 
  766 #endif /* GLYPH_DEBUG */
  767 
  768 #ifdef DEBUG_TRACE_MOVE
  769 /* Non-zero means trace with TRACE_MOVE to stderr.  */
  770 int trace_move;
  771 
  772 #define TRACE_MOVE(x)   if (trace_move) fprintf x; else (void) 0
  773 #else
  774 #define TRACE_MOVE(x)   (void) 0
  775 #endif
  776 
  777 /* Non-zero means automatically scroll windows horizontally to make
  778    point visible.  */
  779 
  780 int automatic_hscrolling_p;
  781 Lisp_Object Qauto_hscroll_mode;
  782 
  783 /* How close to the margin can point get before the window is scrolled
  784    horizontally.  */
  785 EMACS_INT hscroll_margin;
  786 
  787 /* How much to scroll horizontally when point is inside the above margin.  */
  788 Lisp_Object Vhscroll_step;
  789 
  790 /* The variable `resize-mini-windows'.  If nil, don't resize
  791    mini-windows.  If t, always resize them to fit the text they
  792    display.  If `grow-only', let mini-windows grow only until they
  793    become empty.  */
  794 
  795 Lisp_Object Vresize_mini_windows;
  796 
  797 /* Buffer being redisplayed -- for redisplay_window_error.  */
  798 
  799 struct buffer *displayed_buffer;
  800 
  801 /* Space between overline and text. */
  802 
  803 EMACS_INT overline_margin;
  804 
  805 /* Require underline to be at least this many screen pixels below baseline
  806    This to avoid underline "merging" with the base of letters at small
  807    font sizes, particularly when x_use_underline_position_properties is on. */
  808 
  809 EMACS_INT underline_minimum_offset;
  810 
  811 /* Value returned from text property handlers (see below).  */
  812 
  813 enum prop_handled
  814 {
  815   HANDLED_NORMALLY,
  816   HANDLED_RECOMPUTE_PROPS,
  817   HANDLED_OVERLAY_STRING_CONSUMED,
  818   HANDLED_RETURN
  819 };
  820 
  821 /* A description of text properties that redisplay is interested
  822    in.  */
  823 
  824 struct props
  825 {
  826   /* The name of the property.  */
  827   Lisp_Object *name;
  828 
  829   /* A unique index for the property.  */
  830   enum prop_idx idx;
  831 
  832   /* A handler function called to set up iterator IT from the property
  833      at IT's current position.  Value is used to steer handle_stop.  */
  834   enum prop_handled (*handler) P_ ((struct it *it));
  835 };
  836 
  837 static enum prop_handled handle_face_prop P_ ((struct it *));
  838 static enum prop_handled handle_invisible_prop P_ ((struct it *));
  839 static enum prop_handled handle_display_prop P_ ((struct it *));
  840 static enum prop_handled handle_composition_prop P_ ((struct it *));
  841 static enum prop_handled handle_overlay_change P_ ((struct it *));
  842 static enum prop_handled handle_fontified_prop P_ ((struct it *));
  843 
  844 /* Properties handled by iterators.  */
  845 
  846 static struct props it_props[] =
  847 {
  848   {&Qfontified,         FONTIFIED_PROP_IDX,     handle_fontified_prop},
  849   /* Handle `face' before `display' because some sub-properties of
  850      `display' need to know the face.  */
  851   {&Qface,              FACE_PROP_IDX,          handle_face_prop},
  852   {&Qdisplay,           DISPLAY_PROP_IDX,       handle_display_prop},
  853   {&Qinvisible,         INVISIBLE_PROP_IDX,     handle_invisible_prop},
  854   {&Qcomposition,       COMPOSITION_PROP_IDX,   handle_composition_prop},
  855   {NULL,                0,                      NULL}
  856 };
  857 
  858 /* Value is the position described by X.  If X is a marker, value is
  859    the marker_position of X.  Otherwise, value is X.  */
  860 
  861 #define COERCE_MARKER(X) (MARKERP ((X)) ? Fmarker_position (X) : (X))
  862 
  863 /* Enumeration returned by some move_it_.* functions internally.  */
  864 
  865 enum move_it_result
  866 {
  867   /* Not used.  Undefined value.  */
  868   MOVE_UNDEFINED,
  869 
  870   /* Move ended at the requested buffer position or ZV.  */
  871   MOVE_POS_MATCH_OR_ZV,
  872 
  873   /* Move ended at the requested X pixel position.  */
  874   MOVE_X_REACHED,
  875 
  876   /* Move within a line ended at the end of a line that must be
  877      continued.  */
  878   MOVE_LINE_CONTINUED,
  879 
  880   /* Move within a line ended at the end of a line that would
  881      be displayed truncated.  */
  882   MOVE_LINE_TRUNCATED,
  883 
  884   /* Move within a line ended at a line end.  */
  885   MOVE_NEWLINE_OR_CR
  886 };
  887 
  888 /* This counter is used to clear the face cache every once in a while
  889    in redisplay_internal.  It is incremented for each redisplay.
  890    Every CLEAR_FACE_CACHE_COUNT full redisplays, the face cache is
  891    cleared.  */
  892 
  893 #define CLEAR_FACE_CACHE_COUNT  500
  894 static int clear_face_cache_count;
  895 
  896 /* Similarly for the image cache.  */
  897 
  898 #ifdef HAVE_WINDOW_SYSTEM
  899 #define CLEAR_IMAGE_CACHE_COUNT 101
  900 static int clear_image_cache_count;
  901 #endif
  902 
  903 /* Non-zero while redisplay_internal is in progress.  */
  904 
  905 int redisplaying_p;
  906 
  907 /* Non-zero means don't free realized faces.  Bound while freeing
  908    realized faces is dangerous because glyph matrices might still
  909    reference them.  */
  910 
  911 int inhibit_free_realized_faces;
  912 Lisp_Object Qinhibit_free_realized_faces;
  913 
  914 /* If a string, XTread_socket generates an event to display that string.
  915    (The display is done in read_char.)  */
  916 
  917 Lisp_Object help_echo_string;
  918 Lisp_Object help_echo_window;
  919 Lisp_Object help_echo_object;
  920 int help_echo_pos;
  921 
  922 /* Temporary variable for XTread_socket.  */
  923 
  924 Lisp_Object previous_help_echo_string;
  925 
  926 /* Null glyph slice */
  927 
  928 static struct glyph_slice null_glyph_slice = { 0, 0, 0, 0 };
  929 
  930 /* Platform-independent portion of hourglass implementation. */
  931 
  932 /* Non-zero means we're allowed to display a hourglass pointer.  */
  933 int display_hourglass_p;
  934 
  935 /* Non-zero means an hourglass cursor is currently shown.  */
  936 int hourglass_shown_p;
  937 
  938 /* If non-null, an asynchronous timer that, when it expires, displays
  939    an hourglass cursor on all frames.  */
  940 struct atimer *hourglass_atimer;
  941 
  942 /* Number of seconds to wait before displaying an hourglass cursor.  */
  943 Lisp_Object Vhourglass_delay;
  944 
  945 /* Default number of seconds to wait before displaying an hourglass
  946    cursor.  */
  947 #define DEFAULT_HOURGLASS_DELAY 1
  948 
  949 
  950 /* Function prototypes.  */
  951 
  952 static void setup_for_ellipsis P_ ((struct it *, int));
  953 static void mark_window_display_accurate_1 P_ ((struct window *, int));
  954 static int single_display_spec_string_p P_ ((Lisp_Object, Lisp_Object));
  955 static int display_prop_string_p P_ ((Lisp_Object, Lisp_Object));
  956 static int cursor_row_p P_ ((struct window *, struct glyph_row *));
  957 static int redisplay_mode_lines P_ ((Lisp_Object, int));
  958 static char *decode_mode_spec_coding P_ ((Lisp_Object, char *, int));
  959 
  960 static Lisp_Object get_it_property P_ ((struct it *it, Lisp_Object prop));
  961 
  962 static void handle_line_prefix P_ ((struct it *));
  963 
  964 static void pint2str P_ ((char *, int, int));
  965 static void pint2hrstr P_ ((char *, int, int));
  966 static struct text_pos run_window_scroll_functions P_ ((Lisp_Object,
  967                                                         struct text_pos));
  968 static void reconsider_clip_changes P_ ((struct window *, struct buffer *));
  969 static int text_outside_line_unchanged_p P_ ((struct window *, int, int));
  970 static void store_mode_line_noprop_char P_ ((char));
  971 static int store_mode_line_noprop P_ ((const unsigned char *, int, int));
  972 static void x_consider_frame_title P_ ((Lisp_Object));
  973 static void handle_stop P_ ((struct it *));
  974 static void handle_stop_backwards P_ ((struct it *, EMACS_INT));
  975 static int tool_bar_lines_needed P_ ((struct frame *, int *));
  976 static int single_display_spec_intangible_p P_ ((Lisp_Object));
  977 static void ensure_echo_area_buffers P_ ((void));
  978 static Lisp_Object unwind_with_echo_area_buffer P_ ((Lisp_Object));
  979 static Lisp_Object with_echo_area_buffer_unwind_data P_ ((struct window *));
  980 static int with_echo_area_buffer P_ ((struct window *, int,
  981                                       int (*) (EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT),
  982                                       EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
  983 static void clear_garbaged_frames P_ ((void));
  984 static int current_message_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
  985 static int truncate_message_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
  986 static int set_message_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
  987 static int display_echo_area P_ ((struct window *));
  988 static int display_echo_area_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
  989 static int resize_mini_window_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
  990 static Lisp_Object unwind_redisplay P_ ((Lisp_Object));
  991 static int string_char_and_length P_ ((const unsigned char *, int *));
  992 static struct text_pos display_prop_end P_ ((struct it *, Lisp_Object,
  993                                              struct text_pos));
  994 static int compute_window_start_on_continuation_line P_ ((struct window *));
  995 static Lisp_Object safe_eval_handler P_ ((Lisp_Object));
  996 static void insert_left_trunc_glyphs P_ ((struct it *));
  997 static struct glyph_row *get_overlay_arrow_glyph_row P_ ((struct window *,
  998                                                           Lisp_Object));
  999 static void extend_face_to_end_of_line P_ ((struct it *));
 1000 static int append_space_for_newline P_ ((struct it *, int));
 1001 static int cursor_row_fully_visible_p P_ ((struct window *, int, int));
 1002 static int try_scrolling P_ ((Lisp_Object, int, EMACS_INT, EMACS_INT, int, int));
 1003 static int try_cursor_movement P_ ((Lisp_Object, struct text_pos, int *));
 1004 static int trailing_whitespace_p P_ ((int));
 1005 static int message_log_check_duplicate P_ ((int, int, int, int));
 1006 static void push_it P_ ((struct it *));
 1007 static void pop_it P_ ((struct it *));
 1008 static void sync_frame_with_window_matrix_rows P_ ((struct window *));
 1009 static void select_frame_for_redisplay P_ ((Lisp_Object));
 1010 static void redisplay_internal P_ ((int));
 1011 static int echo_area_display P_ ((int));
 1012 static void redisplay_windows P_ ((Lisp_Object));
 1013 static void redisplay_window P_ ((Lisp_Object, int));
 1014 static Lisp_Object redisplay_window_error ();
 1015 static Lisp_Object redisplay_window_0 P_ ((Lisp_Object));
 1016 static Lisp_Object redisplay_window_1 P_ ((Lisp_Object));
 1017 static int update_menu_bar P_ ((struct frame *, int, int));
 1018 static int try_window_reusing_current_matrix P_ ((struct window *));
 1019 static int try_window_id P_ ((struct window *));
 1020 static int display_line P_ ((struct it *));
 1021 static int display_mode_lines P_ ((struct window *));
 1022 static int display_mode_line P_ ((struct window *, enum face_id, Lisp_Object));
 1023 static int display_mode_element P_ ((struct it *, int, int, int, Lisp_Object, Lisp_Object, int));
 1024 static int store_mode_line_string P_ ((char *, Lisp_Object, int, int, int, Lisp_Object));
 1025 static char *decode_mode_spec P_ ((struct window *, int, int, int,
 1026                                    Lisp_Object *));
 1027 static void display_menu_bar P_ ((struct window *));
 1028 static int display_count_lines P_ ((int, int, int, int, int *));
 1029 static int display_string P_ ((unsigned char *, Lisp_Object, Lisp_Object,
 1030                                EMACS_INT, EMACS_INT, struct it *, int, int, int, int));
 1031 static void compute_line_metrics P_ ((struct it *));
 1032 static void run_redisplay_end_trigger_hook P_ ((struct it *));
 1033 static int get_overlay_strings P_ ((struct it *, int));
 1034 static int get_overlay_strings_1 P_ ((struct it *, int, int));
 1035 static void next_overlay_string P_ ((struct it *));
 1036 static void reseat P_ ((struct it *, struct text_pos, int));
 1037 static void reseat_1 P_ ((struct it *, struct text_pos, int));
 1038 static void back_to_previous_visible_line_start P_ ((struct it *));
 1039 void reseat_at_previous_visible_line_start P_ ((struct it *));
 1040 static void reseat_at_next_visible_line_start P_ ((struct it *, int));
 1041 static int next_element_from_ellipsis P_ ((struct it *));
 1042 static int next_element_from_display_vector P_ ((struct it *));
 1043 static int next_element_from_string P_ ((struct it *));
 1044 static int next_element_from_c_string P_ ((struct it *));
 1045 static int next_element_from_buffer P_ ((struct it *));
 1046 static int next_element_from_composition P_ ((struct it *));
 1047 static int next_element_from_image P_ ((struct it *));
 1048 static int next_element_from_stretch P_ ((struct it *));
 1049 static void load_overlay_strings P_ ((struct it *, int));
 1050 static int init_from_display_pos P_ ((struct it *, struct window *,
 1051                                       struct display_pos *));
 1052 static void reseat_to_string P_ ((struct it *, unsigned char *,
 1053                                   Lisp_Object, int, int, int, int));
 1054 static enum move_it_result
 1055        move_it_in_display_line_to (struct it *, EMACS_INT, int,
 1056                                    enum move_operation_enum);
 1057 void move_it_vertically_backward P_ ((struct it *, int));
 1058 static void init_to_row_start P_ ((struct it *, struct window *,
 1059                                    struct glyph_row *));
 1060 static int init_to_row_end P_ ((struct it *, struct window *,
 1061                                 struct glyph_row *));
 1062 static void back_to_previous_line_start P_ ((struct it *));
 1063 static int forward_to_next_line_start P_ ((struct it *, int *));
 1064 static struct text_pos string_pos_nchars_ahead P_ ((struct text_pos,
 1065                                                     Lisp_Object, int));
 1066 static struct text_pos string_pos P_ ((int, Lisp_Object));
 1067 static struct text_pos c_string_pos P_ ((int, unsigned char *, int));
 1068 static int number_of_chars P_ ((unsigned char *, int));
 1069 static void compute_stop_pos P_ ((struct it *));
 1070 static void compute_string_pos P_ ((struct text_pos *, struct text_pos,
 1071                                     Lisp_Object));
 1072 static int face_before_or_after_it_pos P_ ((struct it *, int));
 1073 static EMACS_INT next_overlay_change P_ ((EMACS_INT));
 1074 static int handle_single_display_spec P_ ((struct it *, Lisp_Object,
 1075                                            Lisp_Object, Lisp_Object,
 1076                                            struct text_pos *, int));
 1077 static int underlying_face_id P_ ((struct it *));
 1078 static int in_ellipses_for_invisible_text_p P_ ((struct display_pos *,
 1079                                                  struct window *));
 1080 
 1081 #define face_before_it_pos(IT) face_before_or_after_it_pos ((IT), 1)
 1082 #define face_after_it_pos(IT)  face_before_or_after_it_pos ((IT), 0)
 1083 
 1084 #ifdef HAVE_WINDOW_SYSTEM
 1085 
 1086 static void update_tool_bar P_ ((struct frame *, int));
 1087 static void build_desired_tool_bar_string P_ ((struct frame *f));
 1088 static int redisplay_tool_bar P_ ((struct frame *));
 1089 static void display_tool_bar_line P_ ((struct it *, int));
 1090 static void notice_overwritten_cursor P_ ((struct window *,
 1091                                            enum glyph_row_area,
 1092                                            int, int, int, int));
 1093 static void append_stretch_glyph P_ ((struct it *, Lisp_Object,
 1094                                       int, int, int));
 1095 
 1096 
 1097 
 1098 #endif /* HAVE_WINDOW_SYSTEM */
 1099 
 1100 
 1101 /***********************************************************************
 1102                       Window display dimensions
 1103  ***********************************************************************/
 1104 
 1105 /* Return the bottom boundary y-position for text lines in window W.
 1106    This is the first y position at which a line cannot start.
 1107    It is relative to the top of the window.
 1108 
 1109    This is the height of W minus the height of a mode line, if any.  */
 1110 
 1111 INLINE int
 1112 window_text_bottom_y (w)
 1113      struct window *w;
 1114 {
 1115   int height = WINDOW_TOTAL_HEIGHT (w);
 1116 
 1117   if (WINDOW_WANTS_MODELINE_P (w))
 1118     height -= CURRENT_MODE_LINE_HEIGHT (w);
 1119   return height;
 1120 }
 1121 
 1122 /* Return the pixel width of display area AREA of window W.  AREA < 0
 1123    means return the total width of W, not including fringes to
 1124    the left and right of the window.  */
 1125 
 1126 INLINE int
 1127 window_box_width (w, area)
 1128      struct window *w;
 1129      int area;
 1130 {
 1131   int cols = XFASTINT (w->total_cols);
 1132   int pixels = 0;
 1133 
 1134   if (!w->pseudo_window_p)
 1135     {
 1136       cols -= WINDOW_SCROLL_BAR_COLS (w);
 1137 
 1138       if (area == TEXT_AREA)
 1139         {
 1140           if (INTEGERP (w->left_margin_cols))
 1141             cols -= XFASTINT (w->left_margin_cols);
 1142           if (INTEGERP (w->right_margin_cols))
 1143             cols -= XFASTINT (w->right_margin_cols);
 1144           pixels = -WINDOW_TOTAL_FRINGE_WIDTH (w);
 1145         }
 1146       else if (area == LEFT_MARGIN_AREA)
 1147         {
 1148           cols = (INTEGERP (w->left_margin_cols)
 1149                    ? XFASTINT (w->left_margin_cols) : 0);
 1150           pixels = 0;
 1151         }
 1152       else if (area == RIGHT_MARGIN_AREA)
 1153         {
 1154           cols = (INTEGERP (w->right_margin_cols)
 1155                    ? XFASTINT (w->right_margin_cols) : 0);
 1156           pixels = 0;
 1157         }
 1158     }
 1159 
 1160   return cols * WINDOW_FRAME_COLUMN_WIDTH (w) + pixels;
 1161 }
 1162 
 1163 
 1164 /* Return the pixel height of the display area of window W, not
 1165    including mode lines of W, if any.  */
 1166 
 1167 INLINE int
 1168 window_box_height (w)
 1169      struct window *w;
 1170 {
 1171   struct frame *f = XFRAME (w->frame);
 1172   int height = WINDOW_TOTAL_HEIGHT (w);
 1173 
 1174   xassert (height >= 0);
 1175 
 1176   /* Note: the code below that determines the mode-line/header-line
 1177      height is essentially the same as that contained in the macro
 1178      CURRENT_{MODE,HEADER}_LINE_HEIGHT, except that it checks whether
 1179      the appropriate glyph row has its `mode_line_p' flag set,
 1180      and if it doesn't, uses estimate_mode_line_height instead.  */
 1181 
 1182   if (WINDOW_WANTS_MODELINE_P (w))
 1183     {
 1184       struct glyph_row *ml_row
 1185         = (w->current_matrix && w->current_matrix->rows
 1186            ? MATRIX_MODE_LINE_ROW (w->current_matrix)
 1187            : 0);
 1188       if (ml_row && ml_row->mode_line_p)
 1189         height -= ml_row->height;
 1190       else
 1191         height -= estimate_mode_line_height (f, CURRENT_MODE_LINE_FACE_ID (w));
 1192     }
 1193 
 1194   if (WINDOW_WANTS_HEADER_LINE_P (w))
 1195     {
 1196       struct glyph_row *hl_row
 1197         = (w->current_matrix && w->current_matrix->rows
 1198            ? MATRIX_HEADER_LINE_ROW (w->current_matrix)
 1199            : 0);
 1200       if (hl_row && hl_row->mode_line_p)
 1201         height -= hl_row->height;
 1202       else
 1203         height -= estimate_mode_line_height (f, HEADER_LINE_FACE_ID);
 1204     }
 1205 
 1206   /* With a very small font and a mode-line that's taller than
 1207      default, we might end up with a negative height.  */
 1208   return max (0, height);
 1209 }
 1210 
 1211 /* Return the window-relative coordinate of the left edge of display
 1212    area AREA of window W.  AREA < 0 means return the left edge of the
 1213    whole window, to the right of the left fringe of W.  */
 1214 
 1215 INLINE int
 1216 window_box_left_offset (w, area)
 1217      struct window *w;
 1218      int area;
 1219 {
 1220   int x;
 1221 
 1222   if (w->pseudo_window_p)
 1223     return 0;
 1224 
 1225   x = WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w);
 1226 
 1227   if (area == TEXT_AREA)
 1228     x += (WINDOW_LEFT_FRINGE_WIDTH (w)
 1229           + window_box_width (w, LEFT_MARGIN_AREA));
 1230   else if (area == RIGHT_MARGIN_AREA)
 1231     x += (WINDOW_LEFT_FRINGE_WIDTH (w)
 1232           + window_box_width (w, LEFT_MARGIN_AREA)
 1233           + window_box_width (w, TEXT_AREA)
 1234           + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
 1235              ? 0
 1236              : WINDOW_RIGHT_FRINGE_WIDTH (w)));
 1237   else if (area == LEFT_MARGIN_AREA
 1238            && WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
 1239     x += WINDOW_LEFT_FRINGE_WIDTH (w);
 1240 
 1241   return x;
 1242 }
 1243 
 1244 
 1245 /* Return the window-relative coordinate of the right edge of display
 1246    area AREA of window W.  AREA < 0 means return the left edge of the
 1247    whole window, to the left of the right fringe of W.  */
 1248 
 1249 INLINE int
 1250 window_box_right_offset (w, area)
 1251      struct window *w;
 1252      int area;
 1253 {
 1254   return window_box_left_offset (w, area) + window_box_width (w, area);
 1255 }
 1256 
 1257 /* Return the frame-relative coordinate of the left edge of display
 1258    area AREA of window W.  AREA < 0 means return the left edge of the
 1259    whole window, to the right of the left fringe of W.  */
 1260 
 1261 INLINE int
 1262 window_box_left (w, area)
 1263      struct window *w;
 1264      int area;
 1265 {
 1266   struct frame *f = XFRAME (w->frame);
 1267   int x;
 1268 
 1269   if (w->pseudo_window_p)
 1270     return FRAME_INTERNAL_BORDER_WIDTH (f);
 1271 
 1272   x = (WINDOW_LEFT_EDGE_X (w)
 1273        + window_box_left_offset (w, area));
 1274 
 1275   return x;
 1276 }
 1277 
 1278 
 1279 /* Return the frame-relative coordinate of the right edge of display
 1280    area AREA of window W.  AREA < 0 means return the left edge of the
 1281    whole window, to the left of the right fringe of W.  */
 1282 
 1283 INLINE int
 1284 window_box_right (w, area)
 1285      struct window *w;
 1286      int area;
 1287 {
 1288   return window_box_left (w, area) + window_box_width (w, area);
 1289 }
 1290 
 1291 /* Get the bounding box of the display area AREA of window W, without
 1292    mode lines, in frame-relative coordinates.  AREA < 0 means the
 1293    whole window, not including the left and right fringes of
 1294    the window.  Return in *BOX_X and *BOX_Y the frame-relative pixel
 1295    coordinates of the upper-left corner of the box.  Return in
 1296    *BOX_WIDTH, and *BOX_HEIGHT the pixel width and height of the box.  */
 1297 
 1298 INLINE void
 1299 window_box (w, area, box_x, box_y, box_width, box_height)
 1300      struct window *w;
 1301      int area;
 1302      int *box_x, *box_y, *box_width, *box_height;
 1303 {
 1304   if (box_width)
 1305     *box_width = window_box_width (w, area);
 1306   if (box_height)
 1307     *box_height = window_box_height (w);
 1308   if (box_x)
 1309     *box_x = window_box_left (w, area);
 1310   if (box_y)
 1311     {
 1312       *box_y = WINDOW_TOP_EDGE_Y (w);
 1313       if (WINDOW_WANTS_HEADER_LINE_P (w))
 1314         *box_y += CURRENT_HEADER_LINE_HEIGHT (w);
 1315     }
 1316 }
 1317 
 1318 
 1319 /* Get the bounding box of the display area AREA of window W, without
 1320    mode lines.  AREA < 0 means the whole window, not including the
 1321    left and right fringe of the window.  Return in *TOP_LEFT_X
 1322    and TOP_LEFT_Y the frame-relative pixel coordinates of the
 1323    upper-left corner of the box.  Return in *BOTTOM_RIGHT_X, and
 1324    *BOTTOM_RIGHT_Y the coordinates of the bottom-right corner of the
 1325    box.  */
 1326 
 1327 INLINE void
 1328 window_box_edges (w, area, top_left_x, top_left_y,
 1329                   bottom_right_x, bottom_right_y)
 1330      struct window *w;
 1331      int area;
 1332      int *top_left_x, *top_left_y, *bottom_right_x, *bottom_right_y;
 1333 {
 1334   window_box (w, area, top_left_x, top_left_y, bottom_right_x,
 1335               bottom_right_y);
 1336   *bottom_right_x += *top_left_x;
 1337   *bottom_right_y += *top_left_y;
 1338 }
 1339 
 1340 
 1341 
 1342 /***********************************************************************
 1343                               Utilities
 1344  ***********************************************************************/
 1345 
 1346 /* Return the bottom y-position of the line the iterator IT is in.
 1347    This can modify IT's settings.  */
 1348 
 1349 int
 1350 line_bottom_y (it)
 1351      struct it *it;
 1352 {
 1353   int line_height = it->max_ascent + it->max_descent;
 1354   int line_top_y = it->current_y;
 1355 
 1356   if (line_height == 0)
 1357     {
 1358       if (last_height)
 1359         line_height = last_height;
 1360       else if (IT_CHARPOS (*it) < ZV)
 1361         {
 1362           move_it_by_lines (it, 1, 1);
 1363           line_height = (it->max_ascent || it->max_descent
 1364                          ? it->max_ascent + it->max_descent
 1365                          : last_height);
 1366         }
 1367       else
 1368         {
 1369           struct glyph_row *row = it->glyph_row;
 1370 
 1371           /* Use the default character height.  */
 1372           it->glyph_row = NULL;
 1373           it->what = IT_CHARACTER;
 1374           it->c = ' ';
 1375           it->len = 1;
 1376           PRODUCE_GLYPHS (it);
 1377           line_height = it->ascent + it->descent;
 1378           it->glyph_row = row;
 1379         }
 1380     }
 1381 
 1382   return line_top_y + line_height;
 1383 }
 1384 
 1385 
 1386 /* Return 1 if position CHARPOS is visible in window W.
 1387    CHARPOS < 0 means return info about WINDOW_END position.
 1388    If visible, set *X and *Y to pixel coordinates of top left corner.
 1389    Set *RTOP and *RBOT to pixel height of an invisible area of glyph at POS.
 1390    Set *ROWH and *VPOS to row's visible height and VPOS (row number).  */
 1391 
 1392 int
 1393 pos_visible_p (w, charpos, x, y, rtop, rbot, rowh, vpos)
 1394      struct window *w;
 1395      int charpos, *x, *y, *rtop, *rbot, *rowh, *vpos;
 1396 {
 1397   struct it it;
 1398   struct text_pos top;
 1399   int visible_p = 0;
 1400   struct buffer *old_buffer = NULL;
 1401 
 1402   if (FRAME_INITIAL_P (XFRAME (WINDOW_FRAME (w))))
 1403     return visible_p;
 1404 
 1405   if (XBUFFER (w->buffer) != current_buffer)
 1406     {
 1407       old_buffer = current_buffer;
 1408       set_buffer_internal_1 (XBUFFER (w->buffer));
 1409     }
 1410 
 1411   SET_TEXT_POS_FROM_MARKER (top, w->start);
 1412 
 1413   /* Compute exact mode line heights.  */
 1414   if (WINDOW_WANTS_MODELINE_P (w))
 1415     current_mode_line_height
 1416       = display_mode_line (w, CURRENT_MODE_LINE_FACE_ID (w),
 1417                            current_buffer->mode_line_format);
 1418 
 1419   if (WINDOW_WANTS_HEADER_LINE_P (w))
 1420     current_header_line_height
 1421       = display_mode_line (w, HEADER_LINE_FACE_ID,
 1422                                current_buffer->header_line_format);
 1423 
 1424   start_display (&it, w, top);
 1425   move_it_to (&it, charpos, -1, it.last_visible_y-1, -1,
 1426               (charpos >= 0 ? MOVE_TO_POS : 0) | MOVE_TO_Y);
 1427 
 1428   if (charpos >= 0 && IT_CHARPOS (it) >= charpos)
 1429     {
 1430       /* We have reached CHARPOS, or passed it.  How the call to
 1431          move_it_to can overshoot: (i) If CHARPOS is on invisible
 1432          text, move_it_to stops at the end of the invisible text,
 1433          after CHARPOS.  (ii) If CHARPOS is in a display vector,
 1434          move_it_to stops on its last glyph.  */
 1435       int top_x = it.current_x;
 1436       int top_y = it.current_y;
 1437       enum it_method it_method = it.method;
 1438       /* Calling line_bottom_y may change it.method, it.position, etc.  */
 1439       int bottom_y = (last_height = 0, line_bottom_y (&it));
 1440       int window_top_y = WINDOW_HEADER_LINE_HEIGHT (w);
 1441 
 1442       if (top_y < window_top_y)
 1443         visible_p = bottom_y > window_top_y;
 1444       else if (top_y < it.last_visible_y)
 1445         visible_p = 1;
 1446       if (visible_p)
 1447         {
 1448           if (it_method == GET_FROM_DISPLAY_VECTOR)
 1449             {
 1450               /* We stopped on the last glyph of a display vector.
 1451                  Try and recompute.  Hack alert!  */
 1452               if (charpos < 2 || top.charpos >= charpos)
 1453                 top_x = it.glyph_row->x;
 1454               else
 1455                 {
 1456                   struct it it2;
 1457                   start_display (&it2, w, top);
 1458                   move_it_to (&it2, charpos - 1, -1, -1, -1, MOVE_TO_POS);
 1459                   get_next_display_element (&it2);
 1460                   PRODUCE_GLYPHS (&it2);
 1461                   if (ITERATOR_AT_END_OF_LINE_P (&it2)
 1462                       || it2.current_x > it2.last_visible_x)
 1463                     top_x = it.glyph_row->x;
 1464                   else
 1465                     {
 1466                       top_x = it2.current_x;
 1467                       top_y = it2.current_y;
 1468                     }
 1469                 }
 1470             }
 1471 
 1472           *x = top_x;
 1473           *y = max (top_y + max (0, it.max_ascent - it.ascent), window_top_y);
 1474           *rtop = max (0, window_top_y - top_y);
 1475           *rbot = max (0, bottom_y - it.last_visible_y);
 1476           *rowh = max (0, (min (bottom_y, it.last_visible_y)
 1477                            - max (top_y, window_top_y)));
 1478           *vpos = it.vpos;
 1479         }
 1480     }
 1481   else
 1482     {
 1483       struct it it2;
 1484 
 1485       it2 = it;
 1486       if (IT_CHARPOS (it) < ZV && FETCH_BYTE (IT_BYTEPOS (it)) != '\n')
 1487         move_it_by_lines (&it, 1, 0);
 1488       if (charpos < IT_CHARPOS (it)
 1489           || (it.what == IT_EOB && charpos == IT_CHARPOS (it)))
 1490         {
 1491           visible_p = 1;
 1492           move_it_to (&it2, charpos, -1, -1, -1, MOVE_TO_POS);
 1493           *x = it2.current_x;
 1494           *y = it2.current_y + it2.max_ascent - it2.ascent;
 1495           *rtop = max (0, -it2.current_y);
 1496           *rbot = max (0, ((it2.current_y + it2.max_ascent + it2.max_descent)
 1497                            - it.last_visible_y));
 1498           *rowh = max (0, (min (it2.current_y + it2.max_ascent + it2.max_descent,
 1499                                 it.last_visible_y)
 1500                            - max (it2.current_y,
 1501                                   WINDOW_HEADER_LINE_HEIGHT (w))));
 1502           *vpos = it2.vpos;
 1503         }
 1504     }
 1505 
 1506   if (old_buffer)
 1507     set_buffer_internal_1 (old_buffer);
 1508 
 1509   current_header_line_height = current_mode_line_height = -1;
 1510 
 1511   if (visible_p && XFASTINT (w->hscroll) > 0)
 1512     *x -= XFASTINT (w->hscroll) * WINDOW_FRAME_COLUMN_WIDTH (w);
 1513 
 1514 #if 0
 1515   /* Debugging code.  */
 1516   if (visible_p)
 1517     fprintf (stderr, "+pv pt=%d vs=%d --> x=%d y=%d rt=%d rb=%d rh=%d vp=%d\n",
 1518              charpos, w->vscroll, *x, *y, *rtop, *rbot, *rowh, *vpos);
 1519   else
 1520     fprintf (stderr, "-pv pt=%d vs=%d\n", charpos, w->vscroll);
 1521 #endif
 1522 
 1523   return visible_p;
 1524 }
 1525 
 1526 
 1527 /* Return the next character from STR which is MAXLEN bytes long.
 1528    Return in *LEN the length of the character.  This is like
 1529    STRING_CHAR_AND_LENGTH but never returns an invalid character.  If
 1530    we find one, we return a `?', but with the length of the invalid
 1531    character.  */
 1532 
 1533 static INLINE int
 1534 string_char_and_length (str, len)
 1535      const unsigned char *str;
 1536      int *len;
 1537 {
 1538   int c;
 1539 
 1540   c = STRING_CHAR_AND_LENGTH (str, *len);
 1541   if (!CHAR_VALID_P (c, 1))
 1542     /* We may not change the length here because other places in Emacs
 1543        don't use this function, i.e. they silently accept invalid
 1544        characters.  */
 1545     c = '?';
 1546 
 1547   return c;
 1548 }
 1549 
 1550 
 1551 
 1552 /* Given a position POS containing a valid character and byte position
 1553    in STRING, return the position NCHARS ahead (NCHARS >= 0).  */
 1554 
 1555 static struct text_pos
 1556 string_pos_nchars_ahead (pos, string, nchars)
 1557      struct text_pos pos;
 1558      Lisp_Object string;
 1559      int nchars;
 1560 {
 1561   xassert (STRINGP (string) && nchars >= 0);
 1562 
 1563   if (STRING_MULTIBYTE (string))
 1564     {
 1565       int rest = SBYTES (string) - BYTEPOS (pos);
 1566       const unsigned char *p = SDATA (string) + BYTEPOS (pos);
 1567       int len;
 1568 
 1569       while (nchars--)
 1570         {
 1571           string_char_and_length (p, &len);
 1572           p += len, rest -= len;
 1573           xassert (rest >= 0);
 1574           CHARPOS (pos) += 1;
 1575           BYTEPOS (pos) += len;
 1576         }
 1577     }
 1578   else
 1579     SET_TEXT_POS (pos, CHARPOS (pos) + nchars, BYTEPOS (pos) + nchars);
 1580 
 1581   return pos;
 1582 }
 1583 
 1584 
 1585 /* Value is the text position, i.e. character and byte position,
 1586    for character position CHARPOS in STRING.  */
 1587 
 1588 static INLINE struct text_pos
 1589 string_pos (charpos, string)
 1590      int charpos;
 1591      Lisp_Object string;
 1592 {
 1593   struct text_pos pos;
 1594   xassert (STRINGP (string));
 1595   xassert (charpos >= 0);
 1596   SET_TEXT_POS (pos, charpos, string_char_to_byte (string, charpos));
 1597   return pos;
 1598 }
 1599 
 1600 
 1601 /* Value is a text position, i.e. character and byte position, for
 1602    character position CHARPOS in C string S.  MULTIBYTE_P non-zero
 1603    means recognize multibyte characters.  */
 1604 
 1605 static struct text_pos
 1606 c_string_pos (charpos, s, multibyte_p)
 1607      int charpos;
 1608      unsigned char *s;
 1609      int multibyte_p;
 1610 {
 1611   struct text_pos pos;
 1612 
 1613   xassert (s != NULL);
 1614   xassert (charpos >= 0);
 1615 
 1616   if (multibyte_p)
 1617     {
 1618       int rest = strlen (s), len;
 1619 
 1620       SET_TEXT_POS (pos, 0, 0);
 1621       while (charpos--)
 1622         {
 1623           string_char_and_length (s, &len);
 1624           s += len, rest -= len;
 1625           xassert (rest >= 0);
 1626           CHARPOS (pos) += 1;
 1627           BYTEPOS (pos) += len;
 1628         }
 1629     }
 1630   else
 1631     SET_TEXT_POS (pos, charpos, charpos);
 1632 
 1633   return pos;
 1634 }
 1635 
 1636 
 1637 /* Value is the number of characters in C string S.  MULTIBYTE_P
 1638    non-zero means recognize multibyte characters.  */
 1639 
 1640 static int
 1641 number_of_chars (s, multibyte_p)
 1642      unsigned char *s;
 1643      int multibyte_p;
 1644 {
 1645   int nchars;
 1646 
 1647   if (multibyte_p)
 1648     {
 1649       int rest = strlen (s), len;
 1650       unsigned char *p = (unsigned char *) s;
 1651 
 1652       for (nchars = 0; rest > 0; ++nchars)
 1653         {
 1654           string_char_and_length (p, &len);
 1655           rest -= len, p += len;
 1656         }
 1657     }
 1658   else
 1659     nchars = strlen (s);
 1660 
 1661   return nchars;
 1662 }
 1663 
 1664 
 1665 /* Compute byte position NEWPOS->bytepos corresponding to
 1666    NEWPOS->charpos.  POS is a known position in string STRING.
 1667    NEWPOS->charpos must be >= POS.charpos.  */
 1668 
 1669 static void
 1670 compute_string_pos (newpos, pos, string)
 1671      struct text_pos *newpos, pos;
 1672      Lisp_Object string;
 1673 {
 1674   xassert (STRINGP (string));
 1675   xassert (CHARPOS (*newpos) >= CHARPOS (pos));
 1676 
 1677   if (STRING_MULTIBYTE (string))
 1678     *newpos = string_pos_nchars_ahead (pos, string,
 1679                                        CHARPOS (*newpos) - CHARPOS (pos));
 1680   else
 1681     BYTEPOS (*newpos) = CHARPOS (*newpos);
 1682 }
 1683 
 1684 /* EXPORT:
 1685    Return an estimation of the pixel height of mode or header lines on
 1686    frame F.  FACE_ID specifies what line's height to estimate.  */
 1687 
 1688 int
 1689 estimate_mode_line_height (f, face_id)
 1690      struct frame *f;
 1691      enum face_id face_id;
 1692 {
 1693 #ifdef HAVE_WINDOW_SYSTEM
 1694   if (FRAME_WINDOW_P (f))
 1695     {
 1696       int height = FONT_HEIGHT (FRAME_FONT (f));
 1697 
 1698       /* This function is called so early when Emacs starts that the face
 1699          cache and mode line face are not yet initialized.  */
 1700       if (FRAME_FACE_CACHE (f))
 1701         {
 1702           struct face *face = FACE_FROM_ID (f, face_id);
 1703           if (face)
 1704             {
 1705               if (face->font)
 1706                 height = FONT_HEIGHT (face->font);
 1707               if (face->box_line_width > 0)
 1708                 height += 2 * face->box_line_width;
 1709             }
 1710         }
 1711 
 1712       return height;
 1713     }
 1714 #endif
 1715 
 1716   return 1;
 1717 }
 1718 
 1719 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
 1720    co-ordinates in (*X, *Y).  Set *BOUNDS to the rectangle that the
 1721    glyph at X, Y occupies, if BOUNDS != 0.  If NOCLIP is non-zero, do
 1722    not force the value into range.  */
 1723 
 1724 void
 1725 pixel_to_glyph_coords (f, pix_x, pix_y, x, y, bounds, noclip)
 1726      FRAME_PTR f;
 1727      register int pix_x, pix_y;
 1728      int *x, *y;
 1729      NativeRectangle *bounds;
 1730      int noclip;
 1731 {
 1732 
 1733 #ifdef HAVE_WINDOW_SYSTEM
 1734   if (FRAME_WINDOW_P (f))
 1735     {
 1736       /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to round down
 1737          even for negative values.  */
 1738       if (pix_x < 0)
 1739         pix_x -= FRAME_COLUMN_WIDTH (f) - 1;
 1740       if (pix_y < 0)
 1741         pix_y -= FRAME_LINE_HEIGHT (f) - 1;
 1742 
 1743       pix_x = FRAME_PIXEL_X_TO_COL (f, pix_x);
 1744       pix_y = FRAME_PIXEL_Y_TO_LINE (f, pix_y);
 1745 
 1746       if (bounds)
 1747         STORE_NATIVE_RECT (*bounds,
 1748                            FRAME_COL_TO_PIXEL_X (f, pix_x),
 1749                            FRAME_LINE_TO_PIXEL_Y (f, pix_y),
 1750                            FRAME_COLUMN_WIDTH (f) - 1,
 1751                            FRAME_LINE_HEIGHT (f) - 1);
 1752 
 1753       if (!noclip)
 1754         {
 1755           if (pix_x < 0)
 1756             pix_x = 0;
 1757           else if (pix_x > FRAME_TOTAL_COLS (f))
 1758             pix_x = FRAME_TOTAL_COLS (f);
 1759 
 1760           if (pix_y < 0)
 1761             pix_y = 0;
 1762           else if (pix_y > FRAME_LINES (f))
 1763             pix_y = FRAME_LINES (f);
 1764         }
 1765     }
 1766 #endif
 1767 
 1768   *x = pix_x;
 1769   *y = pix_y;
 1770 }
 1771 
 1772 
 1773 /* Given HPOS/VPOS in the current matrix of W, return corresponding
 1774    frame-relative pixel positions in *FRAME_X and *FRAME_Y.  If we
 1775    can't tell the positions because W's display is not up to date,
 1776    return 0.  */
 1777 
 1778 int
 1779 glyph_to_pixel_coords (w, hpos, vpos, frame_x, frame_y)
 1780      struct window *w;
 1781      int hpos, vpos;
 1782      int *frame_x, *frame_y;
 1783 {
 1784 #ifdef HAVE_WINDOW_SYSTEM
 1785   if (FRAME_WINDOW_P (XFRAME (WINDOW_FRAME (w))))
 1786     {
 1787       int success_p;
 1788 
 1789       xassert (hpos >= 0 && hpos < w->current_matrix->matrix_w);
 1790       xassert (vpos >= 0 && vpos < w->current_matrix->matrix_h);
 1791 
 1792       if (display_completed)
 1793         {
 1794           struct glyph_row *row = MATRIX_ROW (w->current_matrix, vpos);
 1795           struct glyph *glyph = row->glyphs[TEXT_AREA];
 1796           struct glyph *end = glyph + min (hpos, row->used[TEXT_AREA]);
 1797 
 1798           hpos = row->x;
 1799           vpos = row->y;
 1800           while (glyph < end)
 1801             {
 1802               hpos += glyph->pixel_width;
 1803               ++glyph;
 1804             }
 1805 
 1806           /* If first glyph is partially visible, its first visible position is still 0.  */
 1807           if (hpos < 0)
 1808             hpos = 0;
 1809 
 1810           success_p = 1;
 1811         }
 1812       else
 1813         {
 1814           hpos = vpos = 0;
 1815           success_p = 0;
 1816         }
 1817 
 1818       *frame_x = WINDOW_TO_FRAME_PIXEL_X (w, hpos);
 1819       *frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, vpos);
 1820       return success_p;
 1821     }
 1822 #endif
 1823 
 1824   *frame_x = hpos;
 1825   *frame_y = vpos;
 1826   return 1;
 1827 }
 1828 
 1829 
 1830 #ifdef HAVE_WINDOW_SYSTEM
 1831 
 1832 /* Find the glyph under window-relative coordinates X/Y in window W.
 1833    Consider only glyphs from buffer text, i.e. no glyphs from overlay
 1834    strings.  Return in *HPOS and *VPOS the row and column number of
 1835    the glyph found.  Return in *AREA the glyph area containing X.
 1836    Value is a pointer to the glyph found or null if X/Y is not on
 1837    text, or we can't tell because W's current matrix is not up to
 1838    date.  */
 1839 
 1840 static
 1841 struct glyph *
 1842 x_y_to_hpos_vpos (w, x, y, hpos, vpos, dx, dy, area)
 1843      struct window *w;
 1844      int x, y;
 1845      int *hpos, *vpos, *dx, *dy, *area;
 1846 {
 1847   struct glyph *glyph, *end;
 1848   struct glyph_row *row = NULL;
 1849   int x0, i;
 1850 
 1851   /* Find row containing Y.  Give up if some row is not enabled.  */
 1852   for (i = 0; i < w->current_matrix->nrows; ++i)
 1853     {
 1854       row = MATRIX_ROW (w->current_matrix, i);
 1855       if (!row->enabled_p)
 1856         return NULL;
 1857       if (y >= row->y && y < MATRIX_ROW_BOTTOM_Y (row))
 1858         break;
 1859     }
 1860 
 1861   *vpos = i;
 1862   *hpos = 0;
 1863 
 1864   /* Give up if Y is not in the window.  */
 1865   if (i == w->current_matrix->nrows)
 1866     return NULL;
 1867 
 1868   /* Get the glyph area containing X.  */
 1869   if (w->pseudo_window_p)
 1870     {
 1871       *area = TEXT_AREA;
 1872       x0 = 0;
 1873     }
 1874   else
 1875     {
 1876       if (x < window_box_left_offset (w, TEXT_AREA))
 1877         {
 1878           *area = LEFT_MARGIN_AREA;
 1879           x0 = window_box_left_offset (w, LEFT_MARGIN_AREA);
 1880         }
 1881       else if (x < window_box_right_offset (w, TEXT_AREA))
 1882         {
 1883           *area = TEXT_AREA;
 1884           x0 = window_box_left_offset (w, TEXT_AREA) + min (row->x, 0);
 1885         }
 1886       else
 1887         {
 1888           *area = RIGHT_MARGIN_AREA;
 1889           x0 = window_box_left_offset (w, RIGHT_MARGIN_AREA);
 1890         }
 1891     }
 1892 
 1893   /* Find glyph containing X.  */
 1894   glyph = row->glyphs[*area];
 1895   end = glyph + row->used[*area];
 1896   x -= x0;
 1897   while (glyph < end && x >= glyph->pixel_width)
 1898     {
 1899       x -= glyph->pixel_width;
 1900       ++glyph;
 1901     }
 1902 
 1903   if (glyph == end)
 1904     return NULL;
 1905 
 1906   if (dx)
 1907     {
 1908       *dx = x;
 1909       *dy = y - (row->y + row->ascent - glyph->ascent);
 1910     }
 1911 
 1912   *hpos = glyph - row->glyphs[*area];
 1913   return glyph;
 1914 }
 1915 
 1916 
 1917 /* EXPORT:
 1918    Convert frame-relative x/y to coordinates relative to window W.
 1919    Takes pseudo-windows into account.  */
 1920 
 1921 void
 1922 frame_to_window_pixel_xy (w, x, y)
 1923      struct window *w;
 1924      int *x, *y;
 1925 {
 1926   if (w->pseudo_window_p)
 1927     {
 1928       /* A pseudo-window is always full-width, and starts at the
 1929          left edge of the frame, plus a frame border.  */
 1930       struct frame *f = XFRAME (w->frame);
 1931       *x -= FRAME_INTERNAL_BORDER_WIDTH (f);
 1932       *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
 1933     }
 1934   else
 1935     {
 1936       *x -= WINDOW_LEFT_EDGE_X (w);
 1937       *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
 1938     }
 1939 }
 1940 
 1941 /* EXPORT:
 1942    Return in RECTS[] at most N clipping rectangles for glyph string S.
 1943    Return the number of stored rectangles.  */
 1944 
 1945 int
 1946 get_glyph_string_clip_rects (s, rects, n)
 1947      struct glyph_string *s;
 1948      NativeRectangle *rects;
 1949      int n;
 1950 {
 1951   XRectangle r;
 1952 
 1953   if (n <= 0)
 1954     return 0;
 1955 
 1956   if (s->row->full_width_p)
 1957     {
 1958       /* Draw full-width.  X coordinates are relative to S->w->left_col.  */
 1959       r.x = WINDOW_LEFT_EDGE_X (s->w);
 1960       r.width = WINDOW_TOTAL_WIDTH (s->w);
 1961 
 1962       /* Unless displaying a mode or menu bar line, which are always
 1963          fully visible, clip to the visible part of the row.  */
 1964       if (s->w->pseudo_window_p)
 1965         r.height = s->row->visible_height;
 1966       else
 1967         r.height = s->height;
 1968     }
 1969   else
 1970     {
 1971       /* This is a text line that may be partially visible.  */
 1972       r.x = window_box_left (s->w, s->area);
 1973       r.width = window_box_width (s->w, s->area);
 1974       r.height = s->row->visible_height;
 1975     }
 1976 
 1977   if (s->clip_head)
 1978     if (r.x < s->clip_head->x)
 1979       {
 1980         if (r.width >= s->clip_head->x - r.x)
 1981           r.width -= s->clip_head->x - r.x;
 1982         else
 1983           r.width = 0;
 1984         r.x = s->clip_head->x;
 1985       }
 1986   if (s->clip_tail)
 1987     if (r.x + r.width > s->clip_tail->x + s->clip_tail->background_width)
 1988       {
 1989         if (s->clip_tail->x + s->clip_tail->background_width >= r.x)
 1990           r.width = s->clip_tail->x + s->clip_tail->background_width - r.x;
 1991         else
 1992           r.width = 0;
 1993       }
 1994 
 1995   /* If S draws overlapping rows, it's sufficient to use the top and
 1996      bottom of the window for clipping because this glyph string
 1997      intentionally draws over other lines.  */
 1998   if (s->for_overlaps)
 1999     {
 2000       r.y = WINDOW_HEADER_LINE_HEIGHT (s->w);
 2001       r.height = window_text_bottom_y (s->w) - r.y;
 2002 
 2003       /* Alas, the above simple strategy does not work for the
 2004          environments with anti-aliased text: if the same text is
 2005          drawn onto the same place multiple times, it gets thicker.
 2006          If the overlap we are processing is for the erased cursor, we
 2007          take the intersection with the rectagle of the cursor.  */
 2008       if (s->for_overlaps & OVERLAPS_ERASED_CURSOR)
 2009         {
 2010           XRectangle rc, r_save = r;
 2011 
 2012           rc.x = WINDOW_TEXT_TO_FRAME_PIXEL_X (s->w, s->w->phys_cursor.x);
 2013           rc.y = s->w->phys_cursor.y;
 2014           rc.width = s->w->phys_cursor_width;
 2015           rc.height = s->w->phys_cursor_height;
 2016 
 2017           x_intersect_rectangles (&r_save, &rc, &r);
 2018         }
 2019     }
 2020   else
 2021     {
 2022       /* Don't use S->y for clipping because it doesn't take partially
 2023          visible lines into account.  For example, it can be negative for
 2024          partially visible lines at the top of a window.  */
 2025       if (!s->row->full_width_p
 2026           && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s->w, s->row))
 2027         r.y = WINDOW_HEADER_LINE_HEIGHT (s->w);
 2028       else
 2029         r.y = max (0, s->row->y);
 2030     }
 2031 
 2032   r.y = WINDOW_TO_FRAME_PIXEL_Y (s->w, r.y);
 2033 
 2034   /* If drawing the cursor, don't let glyph draw outside its
 2035      advertised boundaries. Cleartype does this under some circumstances.  */
 2036   if (s->hl == DRAW_CURSOR)
 2037     {
 2038       struct glyph *glyph = s->first_glyph;
 2039       int height, max_y;
 2040 
 2041       if (s->x > r.x)
 2042         {
 2043           r.width -= s->x - r.x;
 2044           r.x = s->x;
 2045         }
 2046       r.width = min (r.width, glyph->pixel_width);
 2047 
 2048       /* If r.y is below window bottom, ensure that we still see a cursor.  */
 2049       height = min (glyph->ascent + glyph->descent,
 2050                     min (FRAME_LINE_HEIGHT (s->f), s->row->visible_height));
 2051       max_y = window_text_bottom_y (s->w) - height;
 2052       max_y = WINDOW_TO_FRAME_PIXEL_Y (s->w, max_y);
 2053       if (s->ybase - glyph->ascent > max_y)
 2054         {
 2055           r.y = max_y;
 2056           r.height = height;
 2057         }
 2058       else
 2059         {
 2060           /* Don't draw cursor glyph taller than our actual glyph.  */
 2061           height = max (FRAME_LINE_HEIGHT (s->f), glyph->ascent + glyph->descent);
 2062           if (height < r.height)
 2063             {
 2064               max_y = r.y + r.height;
 2065               r.y = min (max_y, max (r.y, s->ybase + glyph->descent - height));
 2066               r.height = min (max_y - r.y, height);
 2067             }
 2068         }
 2069     }
 2070 
 2071   if (s->row->clip)
 2072     {
 2073       XRectangle r_save = r;
 2074 
 2075       if (! x_intersect_rectangles (&r_save, s->row->clip, &r))
 2076         r.width = 0;
 2077     }
 2078 
 2079   if ((s->for_overlaps & OVERLAPS_BOTH) == 0
 2080       || ((s->for_overlaps & OVERLAPS_BOTH) == OVERLAPS_BOTH && n == 1))
 2081     {
 2082 #ifdef CONVERT_FROM_XRECT
 2083       CONVERT_FROM_XRECT (r, *rects);
 2084 #else
 2085       *rects = r;
 2086 #endif
 2087       return 1;
 2088     }
 2089   else
 2090     {
 2091       /* If we are processing overlapping and allowed to return
 2092          multiple clipping rectangles, we exclude the row of the glyph
 2093          string from the clipping rectangle.  This is to avoid drawing
 2094          the same text on the environment with anti-aliasing.  */
 2095 #ifdef CONVERT_FROM_XRECT
 2096       XRectangle rs[2];
 2097 #else
 2098       XRectangle *rs = rects;
 2099 #endif
 2100       int i = 0, row_y = WINDOW_TO_FRAME_PIXEL_Y (s->w, s->row->y);
 2101 
 2102       if (s->for_overlaps & OVERLAPS_PRED)
 2103         {
 2104           rs[i] = r;
 2105           if (r.y + r.height > row_y)
 2106             {
 2107               if (r.y < row_y)
 2108                 rs[i].height = row_y - r.y;
 2109               else
 2110                 rs[i].height = 0;
 2111             }
 2112           i++;
 2113         }
 2114       if (s->for_overlaps & OVERLAPS_SUCC)
 2115         {
 2116           rs[i] = r;
 2117           if (r.y < row_y + s->row->visible_height)
 2118             {
 2119               if (r.y + r.height > row_y + s->row->visible_height)
 2120                 {
 2121                   rs[i].y = row_y + s->row->visible_height;
 2122                   rs[i].height = r.y + r.height - rs[i].y;
 2123                 }
 2124               else
 2125                 rs[i].height = 0;
 2126             }
 2127           i++;
 2128         }
 2129 
 2130       n = i;
 2131 #ifdef CONVERT_FROM_XRECT
 2132       for (i = 0; i < n; i++)
 2133         CONVERT_FROM_XRECT (rs[i], rects[i]);
 2134 #endif
 2135       return n;
 2136     }
 2137 }
 2138 
 2139 /* EXPORT:
 2140    Return in *NR the clipping rectangle for glyph string S.  */
 2141 
 2142 void
 2143 get_glyph_string_clip_rect (s, nr)
 2144      struct glyph_string *s;
 2145      NativeRectangle *nr;
 2146 {
 2147   get_glyph_string_clip_rects (s, nr, 1);
 2148 }
 2149 
 2150 
 2151 /* EXPORT:
 2152    Return the position and height of the phys cursor in window W.
 2153    Set w->phys_cursor_width to width of phys cursor.
 2154 */
 2155 
 2156 void
 2157 get_phys_cursor_geometry (w, row, glyph, xp, yp, heightp)
 2158      struct window *w;
 2159      struct glyph_row *row;
 2160      struct glyph *glyph;
 2161      int *xp, *yp, *heightp;
 2162 {
 2163   struct frame *f = XFRAME (WINDOW_FRAME (w));
 2164   int x, y, wd, h, h0, y0;
 2165 
 2166   /* Compute the width of the rectangle to draw.  If on a stretch
 2167      glyph, and `x-stretch-block-cursor' is nil, don't draw a
 2168      rectangle as wide as the glyph, but use a canonical character
 2169      width instead.  */
 2170   wd = glyph->pixel_width - 1;
 2171 #if defined(HAVE_NTGUI) || defined(HAVE_NS)
 2172   wd++; /* Why? */
 2173 #endif
 2174 
 2175   x = w->phys_cursor.x;
 2176   if (x < 0)
 2177     {
 2178       wd += x;
 2179       x = 0;
 2180     }
 2181 
 2182   if (glyph->type == STRETCH_GLYPH
 2183       && !x_stretch_cursor_p)
 2184     wd = min (FRAME_COLUMN_WIDTH (f), wd);
 2185   w->phys_cursor_width = wd;
 2186 
 2187   y = w->phys_cursor.y + row->ascent - glyph->ascent;
 2188 
 2189   /* If y is below window bottom, ensure that we still see a cursor.  */
 2190   h0 = min (FRAME_LINE_HEIGHT (f), row->visible_height);
 2191 
 2192   h = max (h0, glyph->ascent + glyph->descent);
 2193   h0 = min (h0, glyph->ascent + glyph->descent);
 2194 
 2195   y0 = WINDOW_HEADER_LINE_HEIGHT (w);
 2196   if (y < y0)
 2197     {
 2198       h = max (h - (y0 - y) + 1, h0);
 2199       y = y0 - 1;
 2200     }
 2201   else
 2202     {
 2203       y0 = window_text_bottom_y (w) - h0;
 2204       if (y > y0)
 2205         {
 2206           h += y - y0;
 2207           y = y0;
 2208         }
 2209     }
 2210 
 2211   *xp = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, x);
 2212   *yp = WINDOW_TO_FRAME_PIXEL_Y (w, y);
 2213   *heightp = h;
 2214 }
 2215 
 2216 /*
 2217  * Remember which glyph the mouse is over.
 2218  */
 2219 
 2220 void
 2221 remember_mouse_glyph (f, gx, gy, rect)
 2222      struct frame *f;
 2223      int gx, gy;
 2224      NativeRectangle *rect;
 2225 {
 2226   Lisp_Object window;
 2227   struct window *w;
 2228   struct glyph_row *r, *gr, *end_row;
 2229   enum window_part part;
 2230   enum glyph_row_area area;
 2231   int x, y, width, height;
 2232 
 2233   /* Try to determine frame pixel position and size of the glyph under
 2234      frame pixel coordinates X/Y on frame F.  */
 2235 
 2236   if (!f->glyphs_initialized_p
 2237       || (window = window_from_coordinates (f, gx, gy, &part, &x, &y, 0),
 2238           NILP (window)))
 2239     {
 2240       width = FRAME_SMALLEST_CHAR_WIDTH (f);
 2241       height = FRAME_SMALLEST_FONT_HEIGHT (f);
 2242       goto virtual_glyph;
 2243     }
 2244 
 2245   w = XWINDOW (window);
 2246   width = WINDOW_FRAME_COLUMN_WIDTH (w);
 2247   height = WINDOW_FRAME_LINE_HEIGHT (w);
 2248 
 2249   r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 2250   end_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
 2251 
 2252   if (w->pseudo_window_p)
 2253     {
 2254       area = TEXT_AREA;
 2255       part = ON_MODE_LINE; /* Don't adjust margin. */
 2256       goto text_glyph;
 2257     }
 2258 
 2259   switch (part)
 2260     {
 2261     case ON_LEFT_MARGIN:
 2262       area = LEFT_MARGIN_AREA;
 2263       goto text_glyph;
 2264 
 2265     case ON_RIGHT_MARGIN:
 2266       area = RIGHT_MARGIN_AREA;
 2267       goto text_glyph;
 2268 
 2269     case ON_HEADER_LINE:
 2270     case ON_MODE_LINE:
 2271       gr = (part == ON_HEADER_LINE
 2272             ? MATRIX_HEADER_LINE_ROW (w->current_matrix)
 2273             : MATRIX_MODE_LINE_ROW (w->current_matrix));
 2274       gy = gr->y;
 2275       area = TEXT_AREA;
 2276       goto text_glyph_row_found;
 2277 
 2278     case ON_TEXT:
 2279       area = TEXT_AREA;
 2280 
 2281     text_glyph:
 2282       gr = 0; gy = 0;
 2283       for (; r <= end_row && r->enabled_p; ++r)
 2284         if (r->y + r->height > y)
 2285           {
 2286             gr = r; gy = r->y;
 2287             break;
 2288           }
 2289 
 2290     text_glyph_row_found:
 2291       if (gr && gy <= y)
 2292         {
 2293           struct glyph *g = gr->glyphs[area];
 2294           struct glyph *end = g + gr->used[area];
 2295 
 2296           height = gr->height;
 2297           for (gx = gr->x; g < end; gx += g->pixel_width, ++g)
 2298             if (gx + g->pixel_width > x)
 2299               break;
 2300 
 2301           if (g < end)
 2302             {
 2303               if (g->type == IMAGE_GLYPH)
 2304                 {
 2305                   /* Don't remember when mouse is over image, as
 2306                      image may have hot-spots.  */
 2307                   STORE_NATIVE_RECT (*rect, 0, 0, 0, 0);
 2308                   return;
 2309                 }
 2310               width = g->pixel_width;
 2311             }
 2312           else
 2313             {
 2314               /* Use nominal char spacing at end of line.  */
 2315               x -= gx;
 2316               gx += (x / width) * width;
 2317             }
 2318 
 2319           if (part != ON_MODE_LINE && part != ON_HEADER_LINE)
 2320             gx += window_box_left_offset (w, area);
 2321         }
 2322       else
 2323         {
 2324           /* Use nominal line height at end of window.  */
 2325           gx = (x / width) * width;
 2326           y -= gy;
 2327           gy += (y / height) * height;
 2328         }
 2329       break;
 2330 
 2331     case ON_LEFT_FRINGE:
 2332       gx = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
 2333             ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w)
 2334             : window_box_right_offset (w, LEFT_MARGIN_AREA));
 2335       width = WINDOW_LEFT_FRINGE_WIDTH (w);
 2336       goto row_glyph;
 2337 
 2338     case ON_RIGHT_FRINGE:
 2339       gx = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
 2340             ? window_box_right_offset (w, RIGHT_MARGIN_AREA)
 2341             : window_box_right_offset (w, TEXT_AREA));
 2342       width = WINDOW_RIGHT_FRINGE_WIDTH (w);
 2343       goto row_glyph;
 2344 
 2345     case ON_SCROLL_BAR:
 2346       gx = (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)
 2347             ? 0
 2348             : (window_box_right_offset (w, RIGHT_MARGIN_AREA)
 2349                + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
 2350                   ? WINDOW_RIGHT_FRINGE_WIDTH (w)
 2351                   : 0)));
 2352       width = WINDOW_SCROLL_BAR_AREA_WIDTH (w);
 2353 
 2354     row_glyph:
 2355       gr = 0, gy = 0;
 2356       for (; r <= end_row && r->enabled_p; ++r)
 2357         if (r->y + r->height > y)
 2358           {
 2359             gr = r; gy = r->y;
 2360             break;
 2361           }
 2362 
 2363       if (gr && gy <= y)
 2364         height = gr->height;
 2365       else
 2366         {
 2367           /* Use nominal line height at end of window.  */
 2368           y -= gy;
 2369           gy += (y / height) * height;
 2370         }
 2371       break;
 2372 
 2373     default:
 2374       ;
 2375     virtual_glyph:
 2376       /* If there is no glyph under the mouse, then we divide the screen
 2377          into a grid of the smallest glyph in the frame, and use that
 2378          as our "glyph".  */
 2379 
 2380       /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
 2381          round down even for negative values.  */
 2382       if (gx < 0)
 2383         gx -= width - 1;
 2384       if (gy < 0)
 2385         gy -= height - 1;
 2386 
 2387       gx = (gx / width) * width;
 2388       gy = (gy / height) * height;
 2389 
 2390       goto store_rect;
 2391     }
 2392 
 2393   gx += WINDOW_LEFT_EDGE_X (w);
 2394   gy += WINDOW_TOP_EDGE_Y (w);
 2395 
 2396  store_rect:
 2397   STORE_NATIVE_RECT (*rect, gx, gy, width, height);
 2398 
 2399   /* Visible feedback for debugging.  */
 2400 #if 0
 2401 #if HAVE_X_WINDOWS
 2402   XDrawRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
 2403                   f->output_data.x->normal_gc,
 2404                   gx, gy, width, height);
 2405 #endif
 2406 #endif
 2407 }
 2408 
 2409 
 2410 #endif /* HAVE_WINDOW_SYSTEM */
 2411 
 2412 
 2413 /***********************************************************************
 2414                         Lisp form evaluation
 2415  ***********************************************************************/
 2416 
 2417 /* Error handler for safe_eval and safe_call.  */
 2418 
 2419 static Lisp_Object
 2420 safe_eval_handler (arg)
 2421      Lisp_Object arg;
 2422 {
 2423   add_to_log ("Error during redisplay: %s", arg, Qnil);
 2424   return Qnil;
 2425 }
 2426 
 2427 
 2428 /* Evaluate SEXPR and return the result, or nil if something went
 2429    wrong.  Prevent redisplay during the evaluation.  */
 2430 
 2431 /* Call function ARGS[0] with arguments ARGS[1] to ARGS[NARGS - 1].
 2432    Return the result, or nil if something went wrong.  Prevent
 2433    redisplay during the evaluation.  */
 2434 
 2435 Lisp_Object
 2436 safe_call (nargs, args)
 2437      int nargs;
 2438      Lisp_Object *args;
 2439 {
 2440   Lisp_Object val;
 2441 
 2442   if (inhibit_eval_during_redisplay)
 2443     val = Qnil;
 2444   else
 2445     {
 2446       int count = SPECPDL_INDEX ();
 2447       struct gcpro gcpro1;
 2448 
 2449       GCPRO1 (args[0]);
 2450       gcpro1.nvars = nargs;
 2451       specbind (Qinhibit_redisplay, Qt);
 2452       /* Use Qt to ensure debugger does not run,
 2453          so there is no possibility of wanting to redisplay.  */
 2454       val = internal_condition_case_n (Ffuncall, nargs, args, Qt,
 2455                                        safe_eval_handler);
 2456       UNGCPRO;
 2457       val = unbind_to (count, val);
 2458     }
 2459 
 2460   return val;
 2461 }
 2462 
 2463 
 2464 /* Call function FN with one argument ARG.
 2465    Return the result, or nil if something went wrong.  */
 2466 
 2467 Lisp_Object
 2468 safe_call1 (fn, arg)
 2469      Lisp_Object fn, arg;
 2470 {
 2471   Lisp_Object args[2];
 2472   args[0] = fn;
 2473   args[1] = arg;
 2474   return safe_call (2, args);
 2475 }
 2476 
 2477 static Lisp_Object Qeval;
 2478 
 2479 Lisp_Object
 2480 safe_eval (Lisp_Object sexpr)
 2481 {
 2482   return safe_call1 (Qeval, sexpr);
 2483 }
 2484 
 2485 /* Call function FN with one argument ARG.
 2486    Return the result, or nil if something went wrong.  */
 2487 
 2488 Lisp_Object
 2489 safe_call2 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2)
 2490 {
 2491   Lisp_Object args[3];
 2492   args[0] = fn;
 2493   args[1] = arg1;
 2494   args[2] = arg2;
 2495   return safe_call (3, args);
 2496 }
 2497 
 2498 
 2499 
 2500 /***********************************************************************
 2501                               Debugging
 2502  ***********************************************************************/
 2503 
 2504 #if 0
 2505 
 2506 /* Define CHECK_IT to perform sanity checks on iterators.
 2507    This is for debugging.  It is too slow to do unconditionally.  */
 2508 
 2509 static void
 2510 check_it (it)
 2511      struct it *it;
 2512 {
 2513   if (it->method == GET_FROM_STRING)
 2514     {
 2515       xassert (STRINGP (it->string));
 2516       xassert (IT_STRING_CHARPOS (*it) >= 0);
 2517     }
 2518   else
 2519     {
 2520       xassert (IT_STRING_CHARPOS (*it) < 0);
 2521       if (it->method == GET_FROM_BUFFER)
 2522         {
 2523           /* Check that character and byte positions agree.  */
 2524           xassert (IT_CHARPOS (*it) == BYTE_TO_CHAR (IT_BYTEPOS (*it)));
 2525         }
 2526     }
 2527 
 2528   if (it->dpvec)
 2529     xassert (it->current.dpvec_index >= 0);
 2530   else
 2531     xassert (it->current.dpvec_index < 0);
 2532 }
 2533 
 2534 #define CHECK_IT(IT)    check_it ((IT))
 2535 
 2536 #else /* not 0 */
 2537 
 2538 #define CHECK_IT(IT)    (void) 0
 2539 
 2540 #endif /* not 0 */
 2541 
 2542 
 2543 #if GLYPH_DEBUG
 2544 
 2545 /* Check that the window end of window W is what we expect it
 2546    to be---the last row in the current matrix displaying text.  */
 2547 
 2548 static void
 2549 check_window_end (w)
 2550      struct window *w;
 2551 {
 2552   if (!MINI_WINDOW_P (w)
 2553       && !NILP (w->window_end_valid))
 2554     {
 2555       struct glyph_row *row;
 2556       xassert ((row = MATRIX_ROW (w->current_matrix,
 2557                                   XFASTINT (w->window_end_vpos)),
 2558                 !row->enabled_p
 2559                 || MATRIX_ROW_DISPLAYS_TEXT_P (row)
 2560                 || MATRIX_ROW_VPOS (row, w->current_matrix) == 0));
 2561     }
 2562 }
 2563 
 2564 #define CHECK_WINDOW_END(W)     check_window_end ((W))
 2565 
 2566 #else /* not GLYPH_DEBUG */
 2567 
 2568 #define CHECK_WINDOW_END(W)     (void) 0
 2569 
 2570 #endif /* not GLYPH_DEBUG */
 2571 
 2572 
 2573 
 2574 /***********************************************************************
 2575                        Iterator initialization
 2576  ***********************************************************************/
 2577 
 2578 /* Initialize IT for displaying current_buffer in window W, starting
 2579    at character position CHARPOS.  CHARPOS < 0 means that no buffer
 2580    position is specified which is useful when the iterator is assigned
 2581    a position later.  BYTEPOS is the byte position corresponding to
 2582    CHARPOS.  BYTEPOS < 0 means compute it from CHARPOS.
 2583 
 2584    If ROW is not null, calls to produce_glyphs with IT as parameter
 2585    will produce glyphs in that row.
 2586 
 2587    BASE_FACE_ID is the id of a base face to use.  It must be one of
 2588    DEFAULT_FACE_ID for normal text, MODE_LINE_FACE_ID,
 2589    MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID for displaying
 2590    mode lines, or TOOL_BAR_FACE_ID for displaying the tool-bar.
 2591 
 2592    If ROW is null and BASE_FACE_ID is equal to MODE_LINE_FACE_ID,
 2593    MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID, the iterator
 2594    will be initialized to use the corresponding mode line glyph row of
 2595    the desired matrix of W.  */
 2596 
 2597 void
 2598 init_iterator (it, w, charpos, bytepos, row, base_face_id)
 2599      struct it *it;
 2600      struct window *w;
 2601      EMACS_INT charpos, bytepos;
 2602      struct glyph_row *row;
 2603      enum face_id base_face_id;
 2604 {
 2605   int highlight_region_p;
 2606   enum face_id remapped_base_face_id = base_face_id;
 2607 
 2608   /* Some precondition checks.  */
 2609   xassert (w != NULL && it != NULL);
 2610   xassert (charpos < 0 || (charpos >= BUF_BEG (current_buffer)
 2611                            && charpos <= ZV));
 2612 
 2613   /* If face attributes have been changed since the last redisplay,
 2614      free realized faces now because they depend on face definitions
 2615      that might have changed.  Don't free faces while there might be
 2616      desired matrices pending which reference these faces.  */
 2617   if (face_change_count && !inhibit_free_realized_faces)
 2618     {
 2619       face_change_count = 0;
 2620       free_all_realized_faces (Qnil);
 2621     }
 2622 
 2623   /* Perhaps remap BASE_FACE_ID to a user-specified alternative.  */
 2624   if (! NILP (Vface_remapping_alist))
 2625     remapped_base_face_id = lookup_basic_face (XFRAME (w->frame), base_face_id);
 2626 
 2627   /* Use one of the mode line rows of W's desired matrix if
 2628      appropriate.  */
 2629   if (row == NULL)
 2630     {
 2631       if (base_face_id == MODE_LINE_FACE_ID
 2632           || base_face_id == MODE_LINE_INACTIVE_FACE_ID)
 2633         row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
 2634       else if (base_face_id == HEADER_LINE_FACE_ID)
 2635         row = MATRIX_HEADER_LINE_ROW (w->desired_matrix);
 2636     }
 2637 
 2638   /* Clear IT.  */
 2639   bzero (it, sizeof *it);
 2640   it->current.overlay_string_index = -1;
 2641   it->current.dpvec_index = -1;
 2642   it->base_face_id = remapped_base_face_id;
 2643   it->string = Qnil;
 2644   IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = -1;
 2645 
 2646   /* The window in which we iterate over current_buffer:  */
 2647   XSETWINDOW (it->window, w);
 2648   it->w = w;
 2649   it->f = XFRAME (w->frame);
 2650 
 2651   it->cmp_it.id = -1;
 2652 
 2653   /* Extra space between lines (on window systems only).  */
 2654   if (base_face_id == DEFAULT_FACE_ID
 2655       && FRAME_WINDOW_P (it->f))
 2656     {
 2657       if (NATNUMP (current_buffer->extra_line_spacing))
 2658         it->extra_line_spacing = XFASTINT (current_buffer->extra_line_spacing);
 2659       else if (FLOATP (current_buffer->extra_line_spacing))
 2660         it->extra_line_spacing = (XFLOAT_DATA (current_buffer->extra_line_spacing)
 2661                                   * FRAME_LINE_HEIGHT (it->f));
 2662       else if (it->f->extra_line_spacing > 0)
 2663         it->extra_line_spacing = it->f->extra_line_spacing;
 2664       it->max_extra_line_spacing = 0;
 2665     }
 2666 
 2667   /* If realized faces have been removed, e.g. because of face
 2668      attribute changes of named faces, recompute them.  When running
 2669      in batch mode, the face cache of the initial frame is null.  If
 2670      we happen to get called, make a dummy face cache.  */
 2671   if (FRAME_FACE_CACHE (it->f) == NULL)
 2672     init_frame_faces (it->f);
 2673   if (FRAME_FACE_CACHE (it->f)->used == 0)
 2674     recompute_basic_faces (it->f);
 2675 
 2676   /* Current value of the `slice', `space-width', and 'height' properties.  */
 2677   it->slice.x = it->slice.y = it->slice.width = it->slice.height = Qnil;
 2678   it->space_width = Qnil;
 2679   it->font_height = Qnil;
 2680   it->override_ascent = -1;
 2681 
 2682   /* Are control characters displayed as `^C'?  */
 2683   it->ctl_arrow_p = !NILP (current_buffer->ctl_arrow);
 2684 
 2685   /* -1 means everything between a CR and the following line end
 2686      is invisible.  >0 means lines indented more than this value are
 2687      invisible.  */
 2688   it->selective = (INTEGERP (current_buffer->selective_display)
 2689                    ? XFASTINT (current_buffer->selective_display)
 2690                    : (!NILP (current_buffer->selective_display)
 2691                       ? -1 : 0));
 2692   it->selective_display_ellipsis_p
 2693     = !NILP (current_buffer->selective_display_ellipses);
 2694 
 2695   /* Display table to use.  */
 2696   it->dp = window_display_table (w);
 2697 
 2698   /* Are multibyte characters enabled in current_buffer?  */
 2699   it->multibyte_p = !NILP (current_buffer->enable_multibyte_characters);
 2700 
 2701   /* Do we need to reorder bidirectional text?  Not if this is a
 2702      unibyte buffer: by definition, none of the single-byte characters
 2703      are strong R2L, so no reordering is needed.  And bidi.c doesn't
 2704      support unibyte buffers anyway.  */
 2705   it->bidi_p
 2706     = !NILP (current_buffer->bidi_display_reordering) && it->multibyte_p;
 2707 
 2708   /* Non-zero if we should highlight the region.  */
 2709   highlight_region_p
 2710     = (!NILP (Vtransient_mark_mode)
 2711        && !NILP (current_buffer->mark_active)
 2712        && XMARKER (current_buffer->mark)->buffer != 0);
 2713 
 2714   /* Set IT->region_beg_charpos and IT->region_end_charpos to the
 2715      start and end of a visible region in window IT->w.  Set both to
 2716      -1 to indicate no region.  */
 2717   if (highlight_region_p
 2718       /* Maybe highlight only in selected window.  */
 2719       && (/* Either show region everywhere.  */
 2720           highlight_nonselected_windows
 2721           /* Or show region in the selected window.  */
 2722           || w == XWINDOW (selected_window)
 2723           /* Or show the region if we are in the mini-buffer and W is
 2724              the window the mini-buffer refers to.  */
 2725           || (MINI_WINDOW_P (XWINDOW (selected_window))
 2726               && WINDOWP (minibuf_selected_window)
 2727               && w == XWINDOW (minibuf_selected_window))))
 2728     {
 2729       int charpos = marker_position (current_buffer->mark);
 2730       it->region_beg_charpos = min (PT, charpos);
 2731       it->region_end_charpos = max (PT, charpos);
 2732     }
 2733   else
 2734     it->region_beg_charpos = it->region_end_charpos = -1;
 2735 
 2736   /* Get the position at which the redisplay_end_trigger hook should
 2737      be run, if it is to be run at all.  */
 2738   if (MARKERP (w->redisplay_end_trigger)
 2739       && XMARKER (w->redisplay_end_trigger)->buffer != 0)
 2740     it->redisplay_end_trigger_charpos
 2741       = marker_position (w->redisplay_end_trigger);
 2742   else if (INTEGERP (w->redisplay_end_trigger))
 2743     it->redisplay_end_trigger_charpos = XINT (w->redisplay_end_trigger);
 2744 
 2745   /* Correct bogus values of tab_width.  */
 2746   it->tab_width = XINT (current_buffer->tab_width);
 2747   if (it->tab_width <= 0 || it->tab_width > 1000)
 2748     it->tab_width = 8;
 2749 
 2750   /* Are lines in the display truncated?  */
 2751   if (base_face_id != DEFAULT_FACE_ID
 2752       || XINT (it->w->hscroll)
 2753       || (! WINDOW_FULL_WIDTH_P (it->w)
 2754           && ((!NILP (Vtruncate_partial_width_windows)
 2755                && !INTEGERP (Vtruncate_partial_width_windows))
 2756               || (INTEGERP (Vtruncate_partial_width_windows)
 2757                   && (WINDOW_TOTAL_COLS (it->w)
 2758                       < XINT (Vtruncate_partial_width_windows))))))
 2759     it->line_wrap = TRUNCATE;
 2760   else if (NILP (current_buffer->truncate_lines))
 2761     it->line_wrap = NILP (current_buffer->word_wrap)
 2762       ? WINDOW_WRAP : WORD_WRAP;
 2763   else
 2764     it->line_wrap = TRUNCATE;
 2765 
 2766   /* Get dimensions of truncation and continuation glyphs.  These are
 2767      displayed as fringe bitmaps under X, so we don't need them for such
 2768      frames.  */
 2769   if (!FRAME_WINDOW_P (it->f))
 2770     {
 2771       if (it->line_wrap == TRUNCATE)
 2772         {
 2773           /* We will need the truncation glyph.  */
 2774           xassert (it->glyph_row == NULL);
 2775           produce_special_glyphs (it, IT_TRUNCATION);
 2776           it->truncation_pixel_width = it->pixel_width;
 2777         }
 2778       else
 2779         {
 2780           /* We will need the continuation glyph.  */
 2781           xassert (it->glyph_row == NULL);
 2782           produce_special_glyphs (it, IT_CONTINUATION);
 2783           it->continuation_pixel_width = it->pixel_width;
 2784         }
 2785 
 2786       /* Reset these values to zero because the produce_special_glyphs
 2787          above has changed them.  */
 2788       it->pixel_width = it->ascent = it->descent = 0;
 2789       it->phys_ascent = it->phys_descent = 0;
 2790     }
 2791 
 2792   /* Set this after getting the dimensions of truncation and
 2793      continuation glyphs, so that we don't produce glyphs when calling
 2794      produce_special_glyphs, above.  */
 2795   it->glyph_row = row;
 2796   it->area = TEXT_AREA;
 2797 
 2798   /* Forget any previous info about this row being reversed.  */
 2799   if (it->glyph_row)
 2800     it->glyph_row->reversed_p = 0;
 2801 
 2802   /* Get the dimensions of the display area.  The display area
 2803      consists of the visible window area plus a horizontally scrolled
 2804      part to the left of the window.  All x-values are relative to the
 2805      start of this total display area.  */
 2806   if (base_face_id != DEFAULT_FACE_ID)
 2807     {
 2808       /* Mode lines, menu bar in terminal frames.  */
 2809       it->first_visible_x = 0;
 2810       it->last_visible_x = WINDOW_TOTAL_WIDTH (w);
 2811     }
 2812   else
 2813     {
 2814       it->first_visible_x
 2815         = XFASTINT (it->w->hscroll) * FRAME_COLUMN_WIDTH (it->f);
 2816       it->last_visible_x = (it->first_visible_x
 2817                             + window_box_width (w, TEXT_AREA));
 2818 
 2819       /* If we truncate lines, leave room for the truncator glyph(s) at
 2820          the right margin.  Otherwise, leave room for the continuation
 2821          glyph(s).  Truncation and continuation glyphs are not inserted
 2822          for window-based redisplay.  */
 2823       if (!FRAME_WINDOW_P (it->f))
 2824         {
 2825           if (it->line_wrap == TRUNCATE)
 2826             it->last_visible_x -= it->truncation_pixel_width;
 2827           else
 2828             it->last_visible_x -= it->continuation_pixel_width;
 2829         }
 2830 
 2831       it->header_line_p = WINDOW_WANTS_HEADER_LINE_P (w);
 2832       it->current_y = WINDOW_HEADER_LINE_HEIGHT (w) + w->vscroll;
 2833     }
 2834 
 2835   /* Leave room for a border glyph.  */
 2836   if (!FRAME_WINDOW_P (it->f)
 2837       && !WINDOW_RIGHTMOST_P (it->w))
 2838     it->last_visible_x -= 1;
 2839 
 2840   it->last_visible_y = window_text_bottom_y (w);
 2841 
 2842   /* For mode lines and alike, arrange for the first glyph having a
 2843      left box line if the face specifies a box.  */
 2844   if (base_face_id != DEFAULT_FACE_ID)
 2845     {
 2846       struct face *face;
 2847 
 2848       it->face_id = remapped_base_face_id;
 2849 
 2850       /* If we have a boxed mode line, make the first character appear
 2851          with a left box line.  */
 2852       face = FACE_FROM_ID (it->f, remapped_base_face_id);
 2853       if (face->box != FACE_NO_BOX)
 2854         it->start_of_box_run_p = 1;
 2855     }
 2856 
 2857   /* If we are to reorder bidirectional text, init the bidi
 2858      iterator.  */
 2859   if (it->bidi_p)
 2860     {
 2861       /* Note the paragraph direction that this buffer wants to
 2862          use.  */
 2863       if (EQ (current_buffer->bidi_paragraph_direction, Qleft_to_right))
 2864         it->paragraph_embedding = L2R;
 2865       else if (EQ (current_buffer->bidi_paragraph_direction, Qright_to_left))
 2866         it->paragraph_embedding = R2L;
 2867       else
 2868         it->paragraph_embedding = NEUTRAL_DIR;
 2869       bidi_init_it (charpos, bytepos, &it->bidi_it);
 2870     }
 2871 
 2872   /* If a buffer position was specified, set the iterator there,
 2873      getting overlays and face properties from that position.  */
 2874   if (charpos >= BUF_BEG (current_buffer))
 2875     {
 2876       it->end_charpos = ZV;
 2877       it->face_id = -1;
 2878       IT_CHARPOS (*it) = charpos;
 2879 
 2880       /* Compute byte position if not specified.  */
 2881       if (bytepos < charpos)
 2882         IT_BYTEPOS (*it) = CHAR_TO_BYTE (charpos);
 2883       else
 2884         IT_BYTEPOS (*it) = bytepos;
 2885 
 2886       it->start = it->current;
 2887 
 2888       /* Compute faces etc.  */
 2889       reseat (it, it->current.pos, 1);
 2890     }
 2891 
 2892   CHECK_IT (it);
 2893 }
 2894 
 2895 
 2896 /* Initialize IT for the display of window W with window start POS.  */
 2897 
 2898 void
 2899 start_display (it, w, pos)
 2900      struct it *it;
 2901      struct window *w;
 2902      struct text_pos pos;
 2903 {
 2904   struct glyph_row *row;
 2905   int first_vpos = WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0;
 2906 
 2907   row = w->desired_matrix->rows + first_vpos;
 2908   init_iterator (it, w, CHARPOS (pos), BYTEPOS (pos), row, DEFAULT_FACE_ID);
 2909   it->first_vpos = first_vpos;
 2910 
 2911   /* Don't reseat to previous visible line start if current start
 2912      position is in a string or image.  */
 2913   if (it->method == GET_FROM_BUFFER && it->line_wrap != TRUNCATE)
 2914     {
 2915       int start_at_line_beg_p;
 2916       int first_y = it->current_y;
 2917 
 2918       /* If window start is not at a line start, skip forward to POS to
 2919          get the correct continuation lines width.  */
 2920       start_at_line_beg_p = (CHARPOS (pos) == BEGV
 2921                              || FETCH_BYTE (BYTEPOS (pos) - 1) == '\n');
 2922       if (!start_at_line_beg_p)
 2923         {
 2924           int new_x;
 2925 
 2926           reseat_at_previous_visible_line_start (it);
 2927           move_it_to (it, CHARPOS (pos), -1, -1, -1, MOVE_TO_POS);
 2928 
 2929           new_x = it->current_x + it->pixel_width;
 2930 
 2931           /* If lines are continued, this line may end in the middle
 2932              of a multi-glyph character (e.g. a control character
 2933              displayed as \003, or in the middle of an overlay
 2934              string).  In this case move_it_to above will not have
 2935              taken us to the start of the continuation line but to the
 2936              end of the continued line.  */
 2937           if (it->current_x > 0
 2938               && it->line_wrap != TRUNCATE /* Lines are continued.  */
 2939               && (/* And glyph doesn't fit on the line.  */
 2940                   new_x > it->last_visible_x
 2941                   /* Or it fits exactly and we're on a window
 2942                      system frame.  */
 2943                   || (new_x == it->last_visible_x
 2944                       && FRAME_WINDOW_P (it->f))))
 2945             {
 2946               if (it->current.dpvec_index >= 0
 2947                   || it->current.overlay_string_index >= 0)
 2948                 {
 2949                   set_iterator_to_next (it, 1);
 2950                   move_it_in_display_line_to (it, -1, -1, 0);
 2951                 }
 2952 
 2953               it->continuation_lines_width += it->current_x;
 2954             }
 2955 
 2956           /* We're starting a new display line, not affected by the
 2957              height of the continued line, so clear the appropriate
 2958              fields in the iterator structure.  */
 2959           it->max_ascent = it->max_descent = 0;
 2960           it->max_phys_ascent = it->max_phys_descent = 0;
 2961 
 2962           it->current_y = first_y;
 2963           it->vpos = 0;
 2964           it->current_x = it->hpos = 0;
 2965         }
 2966     }
 2967 }
 2968 
 2969 
 2970 /* Return 1 if POS is a position in ellipses displayed for invisible
 2971    text.  W is the window we display, for text property lookup.  */
 2972 
 2973 static int
 2974 in_ellipses_for_invisible_text_p (pos, w)
 2975      struct display_pos *pos;
 2976      struct window *w;
 2977 {
 2978   Lisp_Object prop, window;
 2979   int ellipses_p = 0;
 2980   int charpos = CHARPOS (pos->pos);
 2981 
 2982   /* If POS specifies a position in a display vector, this might
 2983      be for an ellipsis displayed for invisible text.  We won't
 2984      get the iterator set up for delivering that ellipsis unless
 2985      we make sure that it gets aware of the invisible text.  */
 2986   if (pos->dpvec_index >= 0
 2987       && pos->overlay_string_index < 0
 2988       && CHARPOS (pos->string_pos) < 0
 2989       && charpos > BEGV
 2990       && (XSETWINDOW (window, w),
 2991           prop = Fget_char_property (make_number (charpos),
 2992                                      Qinvisible, window),
 2993           !TEXT_PROP_MEANS_INVISIBLE (prop)))
 2994     {
 2995       prop = Fget_char_property (make_number (charpos - 1), Qinvisible,
 2996                                  window);
 2997       ellipses_p = 2 == TEXT_PROP_MEANS_INVISIBLE (prop);
 2998     }
 2999 
 3000   return ellipses_p;
 3001 }
 3002 
 3003 
 3004 /* Initialize IT for stepping through current_buffer in window W,
 3005    starting at position POS that includes overlay string and display
 3006    vector/ control character translation position information.  Value
 3007    is zero if there are overlay strings with newlines at POS.  */
 3008 
 3009 static int
 3010 init_from_display_pos (it, w, pos)
 3011      struct it *it;
 3012      struct window *w;
 3013      struct display_pos *pos;
 3014 {
 3015   EMACS_INT charpos = CHARPOS (pos->pos), bytepos = BYTEPOS (pos->pos);
 3016   int i, overlay_strings_with_newlines = 0;
 3017 
 3018   /* If POS specifies a position in a display vector, this might
 3019      be for an ellipsis displayed for invisible text.  We won't
 3020      get the iterator set up for delivering that ellipsis unless
 3021      we make sure that it gets aware of the invisible text.  */
 3022   if (in_ellipses_for_invisible_text_p (pos, w))
 3023     {
 3024       --charpos;
 3025       bytepos = 0;
 3026     }
 3027 
 3028   /* Keep in mind: the call to reseat in init_iterator skips invisible
 3029      text, so we might end up at a position different from POS.  This
 3030      is only a problem when POS is a row start after a newline and an
 3031      overlay starts there with an after-string, and the overlay has an
 3032      invisible property.  Since we don't skip invisible text in
 3033      display_line and elsewhere immediately after consuming the
 3034      newline before the row start, such a POS will not be in a string,
 3035      but the call to init_iterator below will move us to the
 3036      after-string.  */
 3037   init_iterator (it, w, charpos, bytepos, NULL, DEFAULT_FACE_ID);
 3038 
 3039   /* This only scans the current chunk -- it should scan all chunks.
 3040      However, OVERLAY_STRING_CHUNK_SIZE has been increased from 3 in 21.1
 3041      to 16 in 22.1 to make this a lesser problem.  */
 3042   for (i = 0; i < it->n_overlay_strings && i < OVERLAY_STRING_CHUNK_SIZE; ++i)
 3043     {
 3044       const char *s = SDATA (it->overlay_strings[i]);
 3045       const char *e = s + SBYTES (it->overlay_strings[i]);
 3046 
 3047       while (s < e && *s != '\n')
 3048         ++s;
 3049 
 3050       if (s < e)
 3051         {
 3052           overlay_strings_with_newlines = 1;
 3053           break;
 3054         }
 3055     }
 3056 
 3057   /* If position is within an overlay string, set up IT to the right
 3058      overlay string.  */
 3059   if (pos->overlay_string_index >= 0)
 3060     {
 3061       int relative_index;
 3062 
 3063       /* If the first overlay string happens to have a `display'
 3064          property for an image, the iterator will be set up for that
 3065          image, and we have to undo that setup first before we can
 3066          correct the overlay string index.  */
 3067       if (it->method == GET_FROM_IMAGE)
 3068         pop_it (it);
 3069 
 3070       /* We already have the first chunk of overlay strings in
 3071          IT->overlay_strings.  Load more until the one for
 3072          pos->overlay_string_index is in IT->overlay_strings.  */
 3073       if (pos->overlay_string_index >= OVERLAY_STRING_CHUNK_SIZE)
 3074         {
 3075           int n = pos->overlay_string_index / OVERLAY_STRING_CHUNK_SIZE;
 3076           it->current.overlay_string_index = 0;
 3077           while (n--)
 3078             {
 3079               load_overlay_strings (it, 0);
 3080               it->current.overlay_string_index += OVERLAY_STRING_CHUNK_SIZE;
 3081             }
 3082         }
 3083 
 3084       it->current.overlay_string_index = pos->overlay_string_index;
 3085       relative_index = (it->current.overlay_string_index
 3086                         % OVERLAY_STRING_CHUNK_SIZE);
 3087       it->string = it->overlay_strings[relative_index];
 3088       xassert (STRINGP (it->string));
 3089       it->current.string_pos = pos->string_pos;
 3090       it->method = GET_FROM_STRING;
 3091     }
 3092 
 3093   if (CHARPOS (pos->string_pos) >= 0)
 3094     {
 3095       /* Recorded position is not in an overlay string, but in another
 3096          string.  This can only be a string from a `display' property.
 3097          IT should already be filled with that string.  */
 3098       it->current.string_pos = pos->string_pos;
 3099       xassert (STRINGP (it->string));
 3100     }
 3101 
 3102   /* Restore position in display vector translations, control
 3103      character translations or ellipses.  */
 3104   if (pos->dpvec_index >= 0)
 3105     {
 3106       if (it->dpvec == NULL)
 3107         get_next_display_element (it);
 3108       xassert (it->dpvec && it->current.dpvec_index == 0);
 3109       it->current.dpvec_index = pos->dpvec_index;
 3110     }
 3111 
 3112   CHECK_IT (it);
 3113   return !overlay_strings_with_newlines;
 3114 }
 3115 
 3116 
 3117 /* Initialize IT for stepping through current_buffer in window W
 3118    starting at ROW->start.  */
 3119 
 3120 static void
 3121 init_to_row_start (it, w, row)
 3122      struct it *it;
 3123      struct window *w;
 3124      struct glyph_row *row;
 3125 {
 3126   init_from_display_pos (it, w, &row->start);
 3127   it->start = row->start;
 3128   it->continuation_lines_width = row->continuation_lines_width;
 3129   CHECK_IT (it);
 3130 }
 3131 
 3132 
 3133 /* Initialize IT for stepping through current_buffer in window W
 3134    starting in the line following ROW, i.e. starting at ROW->end.
 3135    Value is zero if there are overlay strings with newlines at ROW's
 3136    end position.  */
 3137 
 3138 static int
 3139 init_to_row_end (it, w, row)
 3140      struct it *it;
 3141      struct window *w;
 3142      struct glyph_row *row;
 3143 {
 3144   int success = 0;
 3145 
 3146   if (init_from_display_pos (it, w, &row->end))
 3147     {
 3148       if (row->continued_p)
 3149         it->continuation_lines_width
 3150           = row->continuation_lines_width + row->pixel_width;
 3151       CHECK_IT (it);
 3152       success = 1;
 3153     }
 3154 
 3155   return success;
 3156 }
 3157 
 3158 
 3159 
 3160 
 3161 /***********************************************************************
 3162                            Text properties
 3163  ***********************************************************************/
 3164 
 3165 /* Called when IT reaches IT->stop_charpos.  Handle text property and
 3166    overlay changes.  Set IT->stop_charpos to the next position where
 3167    to stop.  */
 3168 
 3169 static void
 3170 handle_stop (it)
 3171      struct it *it;
 3172 {
 3173   enum prop_handled handled;
 3174   int handle_overlay_change_p;
 3175   struct props *p;
 3176 
 3177   it->dpvec = NULL;
 3178   it->current.dpvec_index = -1;
 3179   handle_overlay_change_p = !it->ignore_overlay_strings_at_pos_p;
 3180   it->ignore_overlay_strings_at_pos_p = 0;
 3181   it->ellipsis_p = 0;
 3182 
 3183   /* Use face of preceding text for ellipsis (if invisible) */
 3184   if (it->selective_display_ellipsis_p)
 3185     it->saved_face_id = it->face_id;
 3186 
 3187   do
 3188     {
 3189       handled = HANDLED_NORMALLY;
 3190 
 3191       /* Call text property handlers.  */
 3192       for (p = it_props; p->handler; ++p)
 3193         {
 3194           handled = p->handler (it);
 3195 
 3196           if (handled == HANDLED_RECOMPUTE_PROPS)
 3197             break;
 3198           else if (handled == HANDLED_RETURN)
 3199             {
 3200               /* We still want to show before and after strings from
 3201                  overlays even if the actual buffer text is replaced.  */
 3202               if (!handle_overlay_change_p
 3203                   || it->sp > 1
 3204                   || !get_overlay_strings_1 (it, 0, 0))
 3205                 {
 3206                   if (it->ellipsis_p)
 3207                     setup_for_ellipsis (it, 0);
 3208                   /* When handling a display spec, we might load an
 3209                      empty string.  In that case, discard it here.  We
 3210                      used to discard it in handle_single_display_spec,
 3211                      but that causes get_overlay_strings_1, above, to
 3212                      ignore overlay strings that we must check.  */
 3213                   if (STRINGP (it->string) && !SCHARS (it->string))
 3214                     pop_it (it);
 3215                   return;
 3216                 }
 3217               else if (STRINGP (it->string) && !SCHARS (it->string))
 3218                 pop_it (it);
 3219               else
 3220                 {
 3221                   it->ignore_overlay_strings_at_pos_p = 1;
 3222                   it->string_from_display_prop_p = 0;
 3223                   handle_overlay_change_p = 0;
 3224                 }
 3225               handled = HANDLED_RECOMPUTE_PROPS;
 3226               break;
 3227             }
 3228           else if (handled == HANDLED_OVERLAY_STRING_CONSUMED)
 3229             handle_overlay_change_p = 0;
 3230         }
 3231 
 3232       if (handled != HANDLED_RECOMPUTE_PROPS)
 3233         {
 3234           /* Don't check for overlay strings below when set to deliver
 3235              characters from a display vector.  */
 3236           if (it->method == GET_FROM_DISPLAY_VECTOR)
 3237             handle_overlay_change_p = 0;
 3238 
 3239           /* Handle overlay changes.
 3240              This sets HANDLED to HANDLED_RECOMPUTE_PROPS
 3241              if it finds overlays.  */
 3242           if (handle_overlay_change_p)
 3243             handled = handle_overlay_change (it);
 3244         }
 3245 
 3246       if (it->ellipsis_p)
 3247         {
 3248           setup_for_ellipsis (it, 0);
 3249           break;
 3250         }
 3251     }
 3252   while (handled == HANDLED_RECOMPUTE_PROPS);
 3253 
 3254   /* Determine where to stop next.  */
 3255   if (handled == HANDLED_NORMALLY)
 3256     compute_stop_pos (it);
 3257 }
 3258 
 3259 
 3260 /* Compute IT->stop_charpos from text property and overlay change
 3261    information for IT's current position.  */
 3262 
 3263 static void
 3264 compute_stop_pos (it)
 3265      struct it *it;
 3266 {
 3267   register INTERVAL iv, next_iv;
 3268   Lisp_Object object, limit, position;
 3269   EMACS_INT charpos, bytepos;
 3270 
 3271   /* If nowhere else, stop at the end.  */
 3272   it->stop_charpos = it->end_charpos;
 3273 
 3274   if (STRINGP (it->string))
 3275     {
 3276       /* Strings are usually short, so don't limit the search for
 3277          properties.  */
 3278       object = it->string;
 3279       limit = Qnil;
 3280       charpos = IT_STRING_CHARPOS (*it);
 3281       bytepos = IT_STRING_BYTEPOS (*it);
 3282     }
 3283   else
 3284     {
 3285       EMACS_INT pos;
 3286 
 3287       /* If next overlay change is in front of the current stop pos
 3288          (which is IT->end_charpos), stop there.  Note: value of
 3289          next_overlay_change is point-max if no overlay change
 3290          follows.  */
 3291       charpos = IT_CHARPOS (*it);
 3292       bytepos = IT_BYTEPOS (*it);
 3293       pos = next_overlay_change (charpos);
 3294       if (pos < it->stop_charpos)
 3295         it->stop_charpos = pos;
 3296 
 3297       /* If showing the region, we have to stop at the region
 3298          start or end because the face might change there.  */
 3299       if (it->region_beg_charpos > 0)
 3300         {
 3301           if (IT_CHARPOS (*it) < it->region_beg_charpos)
 3302             it->stop_charpos = min (it->stop_charpos, it->region_beg_charpos);
 3303           else if (IT_CHARPOS (*it) < it->region_end_charpos)
 3304             it->stop_charpos = min (it->stop_charpos, it->region_end_charpos);
 3305         }
 3306 
 3307       /* Set up variables for computing the stop position from text
 3308          property changes.  */
 3309       XSETBUFFER (object, current_buffer);
 3310       limit = make_number (IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT);
 3311     }
 3312 
 3313   /* Get the interval containing IT's position.  Value is a null
 3314      interval if there isn't such an interval.  */
 3315   position = make_number (charpos);
 3316   iv = validate_interval_range (object, &position, &position, 0);
 3317   if (!NULL_INTERVAL_P (iv))
 3318     {
 3319       Lisp_Object values_here[LAST_PROP_IDX];
 3320       struct props *p;
 3321 
 3322       /* Get properties here.  */
 3323       for (p = it_props; p->handler; ++p)
 3324         values_here[p->idx] = textget (iv->plist, *p->name);
 3325 
 3326       /* Look for an interval following iv that has different
 3327          properties.  */
 3328       for (next_iv = next_interval (iv);
 3329            (!NULL_INTERVAL_P (next_iv)
 3330             && (NILP (limit)
 3331                 || XFASTINT (limit) > next_iv->position));
 3332            next_iv = next_interval (next_iv))
 3333         {
 3334           for (p = it_props; p->handler; ++p)
 3335             {
 3336               Lisp_Object new_value;
 3337 
 3338               new_value = textget (next_iv->plist, *p->name);
 3339               if (!EQ (values_here[p->idx], new_value))
 3340                 break;
 3341             }
 3342 
 3343           if (p->handler)
 3344             break;
 3345         }
 3346 
 3347       if (!NULL_INTERVAL_P (next_iv))
 3348         {
 3349           if (INTEGERP (limit)
 3350               && next_iv->position >= XFASTINT (limit))
 3351             /* No text property change up to limit.  */
 3352             it->stop_charpos = min (XFASTINT (limit), it->stop_charpos);
 3353           else
 3354             /* Text properties change in next_iv.  */
 3355             it->stop_charpos = min (it->stop_charpos, next_iv->position);
 3356         }
 3357     }
 3358 
 3359   composition_compute_stop_pos (&it->cmp_it, charpos, bytepos,
 3360                                 it->stop_charpos, it->string);
 3361 
 3362   xassert (STRINGP (it->string)
 3363            || (it->stop_charpos >= BEGV
 3364                && it->stop_charpos >= IT_CHARPOS (*it)));
 3365 }
 3366 
 3367 
 3368 /* Return the position of the next overlay change after POS in
 3369    current_buffer.  Value is point-max if no overlay change
 3370    follows.  This is like `next-overlay-change' but doesn't use
 3371    xmalloc.  */
 3372 
 3373 static EMACS_INT
 3374 next_overlay_change (pos)
 3375      EMACS_INT pos;
 3376 {
 3377   int noverlays;
 3378   EMACS_INT endpos;
 3379   Lisp_Object *overlays;
 3380   int i;
 3381 
 3382   /* Get all overlays at the given position.  */
 3383   GET_OVERLAYS_AT (pos, overlays, noverlays, &endpos, 1);
 3384 
 3385   /* If any of these overlays ends before endpos,
 3386      use its ending point instead.  */
 3387   for (i = 0; i < noverlays; ++i)
 3388     {
 3389       Lisp_Object oend;
 3390       EMACS_INT oendpos;
 3391 
 3392       oend = OVERLAY_END (overlays[i]);
 3393       oendpos = OVERLAY_POSITION (oend);
 3394       endpos = min (endpos, oendpos);
 3395     }
 3396 
 3397   return endpos;
 3398 }
 3399 
 3400 
 3401 
 3402 /***********************************************************************
 3403                             Fontification
 3404  ***********************************************************************/
 3405 
 3406 /* Handle changes in the `fontified' property of the current buffer by
 3407    calling hook functions from Qfontification_functions to fontify
 3408    regions of text.  */
 3409 
 3410 static enum prop_handled
 3411 handle_fontified_prop (it)
 3412      struct it *it;
 3413 {
 3414   Lisp_Object prop, pos;
 3415   enum prop_handled handled = HANDLED_NORMALLY;
 3416 
 3417   if (!NILP (Vmemory_full))
 3418     return handled;
 3419 
 3420   /* Get the value of the `fontified' property at IT's current buffer
 3421      position.  (The `fontified' property doesn't have a special
 3422      meaning in strings.)  If the value is nil, call functions from
 3423      Qfontification_functions.  */
 3424   if (!STRINGP (it->string)
 3425       && it->s == NULL
 3426       && !NILP (Vfontification_functions)
 3427       && !NILP (Vrun_hooks)
 3428       && (pos = make_number (IT_CHARPOS (*it)),
 3429           prop = Fget_char_property (pos, Qfontified, Qnil),
 3430           /* Ignore the special cased nil value always present at EOB since
 3431              no amount of fontifying will be able to change it.  */
 3432           NILP (prop) && IT_CHARPOS (*it) < Z))
 3433     {
 3434       int count = SPECPDL_INDEX ();
 3435       Lisp_Object val;
 3436 
 3437       val = Vfontification_functions;
 3438       specbind (Qfontification_functions, Qnil);
 3439 
 3440       if (!CONSP (val) || EQ (XCAR (val), Qlambda))
 3441         safe_call1 (val, pos);
 3442       else
 3443         {
 3444           Lisp_Object globals, fn;
 3445           struct gcpro gcpro1, gcpro2;
 3446 
 3447           globals = Qnil;
 3448           GCPRO2 (val, globals);
 3449 
 3450           for (; CONSP (val); val = XCDR (val))
 3451             {
 3452               fn = XCAR (val);
 3453 
 3454               if (EQ (fn, Qt))
 3455                 {
 3456                   /* A value of t indicates this hook has a local
 3457                      binding; it means to run the global binding too.
 3458                      In a global value, t should not occur.  If it
 3459                      does, we must ignore it to avoid an endless
 3460                      loop.  */
 3461                   for (globals = Fdefault_value (Qfontification_functions);
 3462                        CONSP (globals);
 3463                        globals = XCDR (globals))
 3464                     {
 3465                       fn = XCAR (globals);
 3466                       if (!EQ (fn, Qt))
 3467                         safe_call1 (fn, pos);
 3468                     }
 3469                 }
 3470               else
 3471                 safe_call1 (fn, pos);
 3472             }
 3473 
 3474           UNGCPRO;
 3475         }
 3476 
 3477       unbind_to (count, Qnil);
 3478 
 3479       /* Return HANDLED_RECOMPUTE_PROPS only if function fontified
 3480          something.  This avoids an endless loop if they failed to
 3481          fontify the text for which reason ever.  */
 3482       if (!NILP (Fget_char_property (pos, Qfontified, Qnil)))
 3483         handled = HANDLED_RECOMPUTE_PROPS;
 3484     }
 3485 
 3486   return handled;
 3487 }
 3488 
 3489 
 3490 
 3491 /***********************************************************************
 3492                                 Faces
 3493  ***********************************************************************/
 3494 
 3495 /* Set up iterator IT from face properties at its current position.
 3496    Called from handle_stop.  */
 3497 
 3498 static enum prop_handled
 3499 handle_face_prop (it)
 3500      struct it *it;
 3501 {
 3502   int new_face_id;
 3503   EMACS_INT next_stop;
 3504 
 3505   if (!STRINGP (it->string))
 3506     {
 3507       new_face_id
 3508         = face_at_buffer_position (it->w,
 3509                                    IT_CHARPOS (*it),
 3510                                    it->region_beg_charpos,
 3511                                    it->region_end_charpos,
 3512                                    &next_stop,
 3513                                    (IT_CHARPOS (*it)
 3514                                     + TEXT_PROP_DISTANCE_LIMIT),
 3515                                    0, it->base_face_id);
 3516 
 3517       /* Is this a start of a run of characters with box face?
 3518          Caveat: this can be called for a freshly initialized
 3519          iterator; face_id is -1 in this case.  We know that the new
 3520          face will not change until limit, i.e. if the new face has a
 3521          box, all characters up to limit will have one.  But, as
 3522          usual, we don't know whether limit is really the end.  */
 3523       if (new_face_id != it->face_id)
 3524         {
 3525           struct face *new_face = FACE_FROM_ID (it->f, new_face_id);
 3526 
 3527           /* If new face has a box but old face has not, this is
 3528              the start of a run of characters with box, i.e. it has
 3529              a shadow on the left side.  The value of face_id of the
 3530              iterator will be -1 if this is the initial call that gets
 3531              the face.  In this case, we have to look in front of IT's
 3532              position and see whether there is a face != new_face_id.  */
 3533           it->start_of_box_run_p
 3534             = (new_face->box != FACE_NO_BOX
 3535                && (it->face_id >= 0
 3536                    || IT_CHARPOS (*it) == BEG
 3537                    || new_face_id != face_before_it_pos (it)));
 3538           it->face_box_p = new_face->box != FACE_NO_BOX;
 3539         }
 3540     }
 3541   else
 3542     {
 3543       int base_face_id, bufpos;
 3544       int i;
 3545       Lisp_Object from_overlay
 3546         = (it->current.overlay_string_index >= 0
 3547            ? it->string_overlays[it->current.overlay_string_index]
 3548            : Qnil);
 3549 
 3550       /* See if we got to this string directly or indirectly from
 3551          an overlay property.  That includes the before-string or
 3552          after-string of an overlay, strings in display properties
 3553          provided by an overlay, their text properties, etc.
 3554 
 3555          FROM_OVERLAY is the overlay that brought us here, or nil if none.  */
 3556       if (! NILP (from_overlay))
 3557         for (i = it->sp - 1; i >= 0; i--)
 3558           {
 3559             if (it->stack[i].current.overlay_string_index >= 0)
 3560               from_overlay
 3561                 = it->string_overlays[it->stack[i].current.overlay_string_index];
 3562             else if (! NILP (it->stack[i].from_overlay))
 3563               from_overlay = it->stack[i].from_overlay;
 3564 
 3565             if (!NILP (from_overlay))
 3566               break;
 3567           }
 3568 
 3569       if (! NILP (from_overlay))
 3570         {
 3571           bufpos = IT_CHARPOS (*it);
 3572           /* For a string from an overlay, the base face depends
 3573              only on text properties and ignores overlays.  */
 3574           base_face_id
 3575             = face_for_overlay_string (it->w,
 3576                                        IT_CHARPOS (*it),
 3577                                        it->region_beg_charpos,
 3578                                        it->region_end_charpos,
 3579                                        &next_stop,
 3580                                        (IT_CHARPOS (*it)
 3581                                         + TEXT_PROP_DISTANCE_LIMIT),
 3582                                        0,
 3583                                        from_overlay);
 3584         }
 3585       else
 3586         {
 3587           bufpos = 0;
 3588 
 3589           /* For strings from a `display' property, use the face at
 3590              IT's current buffer position as the base face to merge
 3591              with, so that overlay strings appear in the same face as
 3592              surrounding text, unless they specify their own
 3593              faces.  */
 3594           base_face_id = underlying_face_id (it);
 3595         }
 3596 
 3597       new_face_id = face_at_string_position (it->w,
 3598                                              it->string,
 3599                                              IT_STRING_CHARPOS (*it),
 3600                                              bufpos,
 3601                                              it->region_beg_charpos,
 3602                                              it->region_end_charpos,
 3603                                              &next_stop,
 3604                                              base_face_id, 0);
 3605 
 3606       /* Is this a start of a run of characters with box?  Caveat:
 3607          this can be called for a freshly allocated iterator; face_id
 3608          is -1 is this case.  We know that the new face will not
 3609          change until the next check pos, i.e. if the new face has a
 3610          box, all characters up to that position will have a
 3611          box.  But, as usual, we don't know whether that position
 3612          is really the end.  */
 3613       if (new_face_id != it->face_id)
 3614         {
 3615           struct face *new_face = FACE_FROM_ID (it->f, new_face_id);
 3616           struct face *old_face = FACE_FROM_ID (it->f, it->face_id);
 3617 
 3618           /* If new face has a box but old face hasn't, this is the
 3619              start of a run of characters with box, i.e. it has a
 3620              shadow on the left side.  */
 3621           it->start_of_box_run_p
 3622             = new_face->box && (old_face == NULL || !old_face->box);
 3623           it->face_box_p = new_face->box != FACE_NO_BOX;
 3624         }
 3625     }
 3626 
 3627   it->face_id = new_face_id;
 3628   return HANDLED_NORMALLY;
 3629 }
 3630 
 3631 
 3632 /* Return the ID of the face ``underlying'' IT's current position,
 3633    which is in a string.  If the iterator is associated with a
 3634    buffer, return the face at IT's current buffer position.
 3635    Otherwise, use the iterator's base_face_id.  */
 3636 
 3637 static int
 3638 underlying_face_id (it)
 3639      struct it *it;
 3640 {
 3641   int face_id = it->base_face_id, i;
 3642 
 3643   xassert (STRINGP (it->string));
 3644 
 3645   for (i = it->sp - 1; i >= 0; --i)
 3646     if (NILP (it->stack[i].string))
 3647       face_id = it->stack[i].face_id;
 3648 
 3649   return face_id;
 3650 }
 3651 
 3652 
 3653 /* Compute the face one character before or after the current position
 3654    of IT.  BEFORE_P non-zero means get the face in front of IT's
 3655    position.  Value is the id of the face.  */
 3656 
 3657 static int
 3658 face_before_or_after_it_pos (it, before_p)
 3659      struct it *it;
 3660      int before_p;
 3661 {
 3662   int face_id, limit;
 3663   EMACS_INT next_check_charpos;
 3664   struct text_pos pos;
 3665 
 3666   xassert (it->s == NULL);
 3667 
 3668   if (STRINGP (it->string))
 3669     {
 3670       int bufpos, base_face_id;
 3671 
 3672       /* No face change past the end of the string (for the case
 3673          we are padding with spaces).  No face change before the
 3674          string start.  */
 3675       if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string)
 3676           || (IT_STRING_CHARPOS (*it) == 0 && before_p))
 3677         return it->face_id;
 3678 
 3679       /* Set pos to the position before or after IT's current position.  */
 3680       if (before_p)
 3681         pos = string_pos (IT_STRING_CHARPOS (*it) - 1, it->string);
 3682       else
 3683         /* For composition, we must check the character after the
 3684            composition.  */
 3685         pos = (it->what == IT_COMPOSITION
 3686                ? string_pos (IT_STRING_CHARPOS (*it)
 3687                              + it->cmp_it.nchars, it->string)
 3688                : string_pos (IT_STRING_CHARPOS (*it) + 1, it->string));
 3689 
 3690       if (it->current.overlay_string_index >= 0)
 3691         bufpos = IT_CHARPOS (*it);
 3692       else
 3693         bufpos = 0;
 3694 
 3695       base_face_id = underlying_face_id (it);
 3696 
 3697       /* Get the face for ASCII, or unibyte.  */
 3698       face_id = face_at_string_position (it->w,
 3699                                          it->string,
 3700                                          CHARPOS (pos),
 3701                                          bufpos,
 3702                                          it->region_beg_charpos,
 3703                                          it->region_end_charpos,
 3704                                          &next_check_charpos,
 3705                                          base_face_id, 0);
 3706 
 3707       /* Correct the face for charsets different from ASCII.  Do it
 3708          for the multibyte case only.  The face returned above is
 3709          suitable for unibyte text if IT->string is unibyte.  */
 3710       if (STRING_MULTIBYTE (it->string))
 3711         {
 3712           const unsigned char *p = SDATA (it->string) + BYTEPOS (pos);
 3713           int rest = SBYTES (it->string) - BYTEPOS (pos);
 3714           int c, len;
 3715           struct face *face = FACE_FROM_ID (it->f, face_id);
 3716 
 3717           c = string_char_and_length (p, &len);
 3718           face_id = FACE_FOR_CHAR (it->f, face, c, CHARPOS (pos), it->string);
 3719         }
 3720     }
 3721   else
 3722     {
 3723       if ((IT_CHARPOS (*it) >= ZV && !before_p)
 3724           || (IT_CHARPOS (*it) <= BEGV && before_p))
 3725         return it->face_id;
 3726 
 3727       limit = IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT;
 3728       pos = it->current.pos;
 3729 
 3730       if (before_p)
 3731         DEC_TEXT_POS (pos, it->multibyte_p);
 3732       else
 3733         {
 3734           if (it->what == IT_COMPOSITION)
 3735             /* For composition, we must check the position after the
 3736                composition.  */
 3737             pos.charpos += it->cmp_it.nchars, pos.bytepos += it->len;
 3738           else
 3739             INC_TEXT_POS (pos, it->multibyte_p);
 3740         }
 3741 
 3742       /* Determine face for CHARSET_ASCII, or unibyte.  */
 3743       face_id = face_at_buffer_position (it->w,
 3744                                          CHARPOS (pos),
 3745                                          it->region_beg_charpos,
 3746                                          it->region_end_charpos,
 3747                                          &next_check_charpos,
 3748                                          limit, 0, -1);
 3749 
 3750       /* Correct the face for charsets different from ASCII.  Do it
 3751          for the multibyte case only.  The face returned above is
 3752          suitable for unibyte text if current_buffer is unibyte.  */
 3753       if (it->multibyte_p)
 3754         {
 3755           int c = FETCH_MULTIBYTE_CHAR (BYTEPOS (pos));
 3756           struct face *face = FACE_FROM_ID (it->f, face_id);
 3757           face_id = FACE_FOR_CHAR (it->f, face, c, CHARPOS (pos), Qnil);
 3758         }
 3759     }
 3760 
 3761   return face_id;
 3762 }
 3763 
 3764 
 3765 
 3766 /***********************************************************************
 3767                             Invisible text
 3768  ***********************************************************************/
 3769 
 3770 /* Set up iterator IT from invisible properties at its current
 3771    position.  Called from handle_stop.  */
 3772 
 3773 static enum prop_handled
 3774 handle_invisible_prop (it)
 3775      struct it *it;
 3776 {
 3777   enum prop_handled handled = HANDLED_NORMALLY;
 3778 
 3779   if (STRINGP (it->string))
 3780     {
 3781       extern Lisp_Object Qinvisible;
 3782       Lisp_Object prop, end_charpos, limit, charpos;
 3783 
 3784       /* Get the value of the invisible text property at the
 3785          current position.  Value will be nil if there is no such
 3786          property.  */
 3787       charpos = make_number (IT_STRING_CHARPOS (*it));
 3788       prop = Fget_text_property (charpos, Qinvisible, it->string);
 3789 
 3790       if (!NILP (prop)
 3791           && IT_STRING_CHARPOS (*it) < it->end_charpos)
 3792         {
 3793           handled = HANDLED_RECOMPUTE_PROPS;
 3794 
 3795           /* Get the position at which the next change of the
 3796              invisible text property can be found in IT->string.
 3797              Value will be nil if the property value is the same for
 3798              all the rest of IT->string.  */
 3799           XSETINT (limit, SCHARS (it->string));
 3800           end_charpos = Fnext_single_property_change (charpos, Qinvisible,
 3801                                                       it->string, limit);
 3802 
 3803           /* Text at current position is invisible.  The next
 3804              change in the property is at position end_charpos.
 3805              Move IT's current position to that position.  */
 3806           if (INTEGERP (end_charpos)
 3807               && XFASTINT (end_charpos) < XFASTINT (limit))
 3808             {
 3809               struct text_pos old;
 3810               old = it->current.string_pos;
 3811               IT_STRING_CHARPOS (*it) = XFASTINT (end_charpos);
 3812               compute_string_pos (&it->current.string_pos, old, it->string);
 3813             }
 3814           else
 3815             {
 3816               /* The rest of the string is invisible.  If this is an
 3817                  overlay string, proceed with the next overlay string
 3818                  or whatever comes and return a character from there.  */
 3819               if (it->current.overlay_string_index >= 0)
 3820                 {
 3821                   next_overlay_string (it);
 3822                   /* Don't check for overlay strings when we just
 3823                      finished processing them.  */
 3824                   handled = HANDLED_OVERLAY_STRING_CONSUMED;
 3825                 }
 3826               else
 3827                 {
 3828                   IT_STRING_CHARPOS (*it) = SCHARS (it->string);
 3829                   IT_STRING_BYTEPOS (*it) = SBYTES (it->string);
 3830                 }
 3831             }
 3832         }
 3833     }
 3834   else
 3835     {
 3836       int invis_p;
 3837       EMACS_INT newpos, next_stop, start_charpos, tem;
 3838       Lisp_Object pos, prop, overlay;
 3839 
 3840       /* First of all, is there invisible text at this position?  */
 3841       tem = start_charpos = IT_CHARPOS (*it);
 3842       pos = make_number (tem);
 3843       prop = get_char_property_and_overlay (pos, Qinvisible, it->window,
 3844                                             &overlay);
 3845       invis_p = TEXT_PROP_MEANS_INVISIBLE (prop);
 3846 
 3847       /* If we are on invisible text, skip over it.  */
 3848       if (invis_p && start_charpos < it->end_charpos)
 3849         {
 3850           /* Record whether we have to display an ellipsis for the
 3851              invisible text.  */
 3852           int display_ellipsis_p = invis_p == 2;
 3853 
 3854           handled = HANDLED_RECOMPUTE_PROPS;
 3855 
 3856           /* Loop skipping over invisible text.  The loop is left at
 3857              ZV or with IT on the first char being visible again.  */
 3858           do
 3859             {
 3860               /* Try to skip some invisible text.  Return value is the
 3861                  position reached which can be equal to where we start
 3862                  if there is nothing invisible there.  This skips both
 3863                  over invisible text properties and overlays with
 3864                  invisible property.  */
 3865               newpos = skip_invisible (tem, &next_stop, ZV, it->window);
 3866 
 3867               /* If we skipped nothing at all we weren't at invisible
 3868                  text in the first place.  If everything to the end of
 3869                  the buffer was skipped, end the loop.  */
 3870               if (newpos == tem || newpos >= ZV)
 3871                 invis_p = 0;
 3872               else
 3873                 {
 3874                   /* We skipped some characters but not necessarily
 3875                      all there are.  Check if we ended up on visible
 3876                      text.  Fget_char_property returns the property of
 3877                      the char before the given position, i.e. if we
 3878                      get invis_p = 0, this means that the char at
 3879                      newpos is visible.  */
 3880                   pos = make_number (newpos);
 3881                   prop = Fget_char_property (pos, Qinvisible, it->window);
 3882                   invis_p = TEXT_PROP_MEANS_INVISIBLE (prop);
 3883                 }
 3884 
 3885               /* If we ended up on invisible text, proceed to
 3886                  skip starting with next_stop.  */
 3887               if (invis_p)
 3888                 tem = next_stop;
 3889 
 3890               /* If there are adjacent invisible texts, don't lose the
 3891                  second one's ellipsis. */
 3892               if (invis_p == 2)
 3893                 display_ellipsis_p = 1;
 3894             }
 3895           while (invis_p);
 3896 
 3897           /* The position newpos is now either ZV or on visible text.  */
 3898           if (it->bidi_p && newpos < ZV)
 3899             {
 3900               /* With bidi iteration, the region of invisible text
 3901                  could start and/or end in the middle of a non-base
 3902                  embedding level.  Therefore, we need to skip
 3903                  invisible text using the bidi iterator, starting at
 3904                  IT's current position, until we find ourselves
 3905                  outside the invisible text.  Skipping invisible text
 3906                  _after_ bidi iteration avoids affecting the visual
 3907                  order of the displayed text when invisible properties
 3908                  are added or removed.  */
 3909               if (it->bidi_it.first_elt)
 3910                 {
 3911                   /* If we were `reseat'ed to a new paragraph,
 3912                      determine the paragraph base direction.  We need
 3913                      to do it now because next_element_from_buffer may
 3914                      not have a chance to do it, if we are going to
 3915                      skip any text at the beginning, which resets the
 3916                      FIRST_ELT flag.  */
 3917                   bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
 3918                 }
 3919               do
 3920                 {
 3921                   bidi_move_to_visually_next (&it->bidi_it);
 3922                 }
 3923               while (it->stop_charpos <= it->bidi_it.charpos
 3924                      && it->bidi_it.charpos < newpos);
 3925               IT_CHARPOS (*it) = it->bidi_it.charpos;
 3926               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
 3927               /* If we overstepped NEWPOS, record its position in the
 3928                  iterator, so that we skip invisible text if later the
 3929                  bidi iteration lands us in the invisible region
 3930                  again. */
 3931               if (IT_CHARPOS (*it) >= newpos)
 3932                 it->prev_stop = newpos;
 3933             }
 3934           else
 3935             {
 3936               IT_CHARPOS (*it) = newpos;
 3937               IT_BYTEPOS (*it) = CHAR_TO_BYTE (newpos);
 3938             }
 3939 
 3940           /* If there are before-strings at the start of invisible
 3941              text, and the text is invisible because of a text
 3942              property, arrange to show before-strings because 20.x did
 3943              it that way.  (If the text is invisible because of an
 3944              overlay property instead of a text property, this is
 3945              already handled in the overlay code.)  */
 3946           if (NILP (overlay)
 3947               && get_overlay_strings (it, it->stop_charpos))
 3948             {
 3949               handled = HANDLED_RECOMPUTE_PROPS;
 3950               it->stack[it->sp - 1].display_ellipsis_p = display_ellipsis_p;
 3951             }
 3952           else if (display_ellipsis_p)
 3953             {
 3954               /* Make sure that the glyphs of the ellipsis will get
 3955                  correct `charpos' values.  If we would not update
 3956                  it->position here, the glyphs would belong to the
 3957                  last visible character _before_ the invisible
 3958                  text, which confuses `set_cursor_from_row'.
 3959 
 3960                  We use the last invisible position instead of the
 3961                  first because this way the cursor is always drawn on
 3962                  the first "." of the ellipsis, whenever PT is inside
 3963                  the invisible text.  Otherwise the cursor would be
 3964                  placed _after_ the ellipsis when the point is after the
 3965                  first invisible character.  */
 3966               if (!STRINGP (it->object))
 3967                 {
 3968                   it->position.charpos = newpos - 1;
 3969                   it->position.bytepos = CHAR_TO_BYTE (it->position.charpos);
 3970                 }
 3971               it->ellipsis_p = 1;
 3972               /* Let the ellipsis display before
 3973                  considering any properties of the following char.
 3974                  Fixes jasonr@gnu.org 01 Oct 07 bug.  */
 3975               handled = HANDLED_RETURN;
 3976             }
 3977         }
 3978     }
 3979 
 3980   return handled;
 3981 }
 3982 
 3983 
 3984 /* Make iterator IT return `...' next.
 3985    Replaces LEN characters from buffer.  */
 3986 
 3987 static void
 3988 setup_for_ellipsis (it, len)
 3989      struct it *it;
 3990      int len;
 3991 {
 3992   /* Use the display table definition for `...'.  Invalid glyphs
 3993      will be handled by the method returning elements from dpvec.  */
 3994   if (it->dp && VECTORP (DISP_INVIS_VECTOR (it->dp)))
 3995     {
 3996       struct Lisp_Vector *v = XVECTOR (DISP_INVIS_VECTOR (it->dp));
 3997       it->dpvec = v->contents;
 3998       it->dpend = v->contents + v->size;
 3999     }
 4000   else
 4001     {
 4002       /* Default `...'.  */
 4003       it->dpvec = default_invis_vector;
 4004       it->dpend = default_invis_vector + 3;
 4005     }
 4006 
 4007   it->dpvec_char_len = len;
 4008   it->current.dpvec_index = 0;
 4009   it->dpvec_face_id = -1;
 4010 
 4011   /* Remember the current face id in case glyphs specify faces.
 4012      IT's face is restored in set_iterator_to_next.
 4013      saved_face_id was set to preceding char's face in handle_stop.  */
 4014   if (it->saved_face_id < 0 || it->saved_face_id != it->face_id)
 4015     it->saved_face_id = it->face_id = DEFAULT_FACE_ID;
 4016 
 4017   it->method = GET_FROM_DISPLAY_VECTOR;
 4018   it->ellipsis_p = 1;
 4019 }
 4020 
 4021 
 4022 
 4023 /***********************************************************************
 4024                             'display' property
 4025  ***********************************************************************/
 4026 
 4027 /* Set up iterator IT from `display' property at its current position.
 4028    Called from handle_stop.
 4029    We return HANDLED_RETURN if some part of the display property
 4030    overrides the display of the buffer text itself.
 4031    Otherwise we return HANDLED_NORMALLY.  */
 4032 
 4033 static enum prop_handled
 4034 handle_display_prop (it)
 4035      struct it *it;
 4036 {
 4037   Lisp_Object prop, object, overlay;
 4038   struct text_pos *position;
 4039   /* Nonzero if some property replaces the display of the text itself.  */
 4040   int display_replaced_p = 0;
 4041 
 4042   if (STRINGP (it->string))
 4043     {
 4044       object = it->string;
 4045       position = &it->current.string_pos;
 4046     }
 4047   else
 4048     {
 4049       XSETWINDOW (object, it->w);
 4050       position = &it->current.pos;
 4051     }
 4052 
 4053   /* Reset those iterator values set from display property values.  */
 4054   it->slice.x = it->slice.y = it->slice.width = it->slice.height = Qnil;
 4055   it->space_width = Qnil;
 4056   it->font_height = Qnil;
 4057   it->voffset = 0;
 4058 
 4059   /* We don't support recursive `display' properties, i.e. string
 4060      values that have a string `display' property, that have a string
 4061      `display' property etc.  */
 4062   if (!it->string_from_display_prop_p)
 4063     it->area = TEXT_AREA;
 4064 
 4065   prop = get_char_property_and_overlay (make_number (position->charpos),
 4066                                         Qdisplay, object, &overlay);
 4067   if (NILP (prop))
 4068     return HANDLED_NORMALLY;
 4069   /* Now OVERLAY is the overlay that gave us this property, or nil
 4070      if it was a text property.  */
 4071 
 4072   if (!STRINGP (it->string))
 4073     object = it->w->buffer;
 4074 
 4075   if (CONSP (prop)
 4076       /* Simple properties.  */
 4077       && !EQ (XCAR (prop), Qimage)
 4078       && !EQ (XCAR (prop), Qspace)
 4079       && !EQ (XCAR (prop), Qwhen)
 4080       && !EQ (XCAR (prop), Qslice)
 4081       && !EQ (XCAR (prop), Qspace_width)
 4082       && !EQ (XCAR (prop), Qheight)
 4083       && !EQ (XCAR (prop), Qraise)
 4084       /* Marginal area specifications.  */
 4085       && !(CONSP (XCAR (prop)) && EQ (XCAR (XCAR (prop)), Qmargin))
 4086       && !EQ (XCAR (prop), Qleft_fringe)
 4087       && !EQ (XCAR (prop), Qright_fringe)
 4088       && !NILP (XCAR (prop)))
 4089     {
 4090       for (; CONSP (prop); prop = XCDR (prop))
 4091         {
 4092           if (handle_single_display_spec (it, XCAR (prop), object, overlay,
 4093                                           position, display_replaced_p))
 4094             {
 4095               display_replaced_p = 1;
 4096               /* If some text in a string is replaced, `position' no
 4097                  longer points to the position of `object'.  */
 4098               if (STRINGP (object))
 4099                 break;
 4100             }
 4101         }
 4102     }
 4103   else if (VECTORP (prop))
 4104     {
 4105       int i;
 4106       for (i = 0; i < ASIZE (prop); ++i)
 4107         if (handle_single_display_spec (it, AREF (prop, i), object, overlay,
 4108                                         position, display_replaced_p))
 4109           {
 4110             display_replaced_p = 1;
 4111             /* If some text in a string is replaced, `position' no
 4112                longer points to the position of `object'.  */
 4113             if (STRINGP (object))
 4114               break;
 4115           }
 4116     }
 4117   else
 4118     {
 4119       if (handle_single_display_spec (it, prop, object, overlay,
 4120                                       position, 0))
 4121         display_replaced_p = 1;
 4122     }
 4123 
 4124   return display_replaced_p ? HANDLED_RETURN : HANDLED_NORMALLY;
 4125 }
 4126 
 4127 
 4128 /* Value is the position of the end of the `display' property starting
 4129    at START_POS in OBJECT.  */
 4130 
 4131 static struct text_pos
 4132 display_prop_end (it, object, start_pos)
 4133      struct it *it;
 4134      Lisp_Object object;
 4135      struct text_pos start_pos;
 4136 {
 4137   Lisp_Object end;
 4138   struct text_pos end_pos;
 4139 
 4140   end = Fnext_single_char_property_change (make_number (CHARPOS (start_pos)),
 4141                                            Qdisplay, object, Qnil);
 4142   CHARPOS (end_pos) = XFASTINT (end);
 4143   if (STRINGP (object))
 4144     compute_string_pos (&end_pos, start_pos, it->string);
 4145   else
 4146     BYTEPOS (end_pos) = CHAR_TO_BYTE (XFASTINT (end));
 4147 
 4148   return end_pos;
 4149 }
 4150 
 4151 
 4152 /* Set up IT from a single `display' specification PROP.  OBJECT
 4153    is the object in which the `display' property was found.  *POSITION
 4154    is the position at which it was found.  DISPLAY_REPLACED_P non-zero
 4155    means that we previously saw a display specification which already
 4156    replaced text display with something else, for example an image;
 4157    we ignore such properties after the first one has been processed.
 4158 
 4159    OVERLAY is the overlay this `display' property came from,
 4160    or nil if it was a text property.
 4161 
 4162    If PROP is a `space' or `image' specification, and in some other
 4163    cases too, set *POSITION to the position where the `display'
 4164    property ends.
 4165 
 4166    Value is non-zero if something was found which replaces the display
 4167    of buffer or string text.  */
 4168 
 4169 static int
 4170 handle_single_display_spec (it, spec, object, overlay, position,
 4171                             display_replaced_before_p)
 4172      struct it *it;
 4173      Lisp_Object spec;
 4174      Lisp_Object object;
 4175      Lisp_Object overlay;
 4176      struct text_pos *position;
 4177      int display_replaced_before_p;
 4178 {
 4179   Lisp_Object form;
 4180   Lisp_Object location, value;
 4181   struct text_pos start_pos, save_pos;
 4182   int valid_p;
 4183 
 4184   /* If SPEC is a list of the form `(when FORM . VALUE)', evaluate FORM.
 4185      If the result is non-nil, use VALUE instead of SPEC.  */
 4186   form = Qt;
 4187   if (CONSP (spec) && EQ (XCAR (spec), Qwhen))
 4188     {
 4189       spec = XCDR (spec);
 4190       if (!CONSP (spec))
 4191         return 0;
 4192       form = XCAR (spec);
 4193       spec = XCDR (spec);
 4194     }
 4195 
 4196   if (!NILP (form) && !EQ (form, Qt))
 4197     {
 4198       int count = SPECPDL_INDEX ();
 4199       struct gcpro gcpro1;
 4200 
 4201       /* Bind `object' to the object having the `display' property, a
 4202          buffer or string.  Bind `position' to the position in the
 4203          object where the property was found, and `buffer-position'
 4204          to the current position in the buffer.  */
 4205       specbind (Qobject, object);
 4206       specbind (Qposition, make_number (CHARPOS (*position)));
 4207       specbind (Qbuffer_position,
 4208                 make_number (STRINGP (object)
 4209                              ? IT_CHARPOS (*it) : CHARPOS (*position)));
 4210       GCPRO1 (form);
 4211       form = safe_eval (form);
 4212       UNGCPRO;
 4213       unbind_to (count, Qnil);
 4214     }
 4215 
 4216   if (NILP (form))
 4217     return 0;
 4218 
 4219   /* Handle `(height HEIGHT)' specifications.  */
 4220   if (CONSP (spec)
 4221       && EQ (XCAR (spec), Qheight)
 4222       && CONSP (XCDR (spec)))
 4223     {
 4224       if (!FRAME_WINDOW_P (it->f))
 4225         return 0;
 4226 
 4227       it->font_height = XCAR (XCDR (spec));
 4228       if (!NILP (it->font_height))
 4229         {
 4230           struct face *face = FACE_FROM_ID (it->f, it->face_id);
 4231           int new_height = -1;
 4232 
 4233           if (CONSP (it->font_height)
 4234               && (EQ (XCAR (it->font_height), Qplus)
 4235                   || EQ (XCAR (it->font_height), Qminus))
 4236               && CONSP (XCDR (it->font_height))
 4237               && INTEGERP (XCAR (XCDR (it->font_height))))
 4238             {
 4239               /* `(+ N)' or `(- N)' where N is an integer.  */
 4240               int steps = XINT (XCAR (XCDR (it->font_height)));
 4241               if (EQ (XCAR (it->font_height), Qplus))
 4242                 steps = - steps;
 4243               it->face_id = smaller_face (it->f, it->face_id, steps);
 4244             }
 4245           else if (FUNCTIONP (it->font_height))
 4246             {
 4247               /* Call function with current height as argument.
 4248                  Value is the new height.  */
 4249               Lisp_Object height;
 4250               height = safe_call1 (it->font_height,
 4251                                    face->lface[LFACE_HEIGHT_INDEX]);
 4252               if (NUMBERP (height))
 4253                 new_height = XFLOATINT (height);
 4254             }
 4255           else if (NUMBERP (it->font_height))
 4256             {
 4257               /* Value is a multiple of the canonical char height.  */
 4258               struct face *face;
 4259 
 4260               face = FACE_FROM_ID (it->f,
 4261                                    lookup_basic_face (it->f, DEFAULT_FACE_ID));
 4262               new_height = (XFLOATINT (it->font_height)
 4263                             * XINT (face->lface[LFACE_HEIGHT_INDEX]));
 4264             }
 4265           else
 4266             {
 4267               /* Evaluate IT->font_height with `height' bound to the
 4268                  current specified height to get the new height.  */
 4269               int count = SPECPDL_INDEX ();
 4270 
 4271               specbind (Qheight, face->lface[LFACE_HEIGHT_INDEX]);
 4272               value = safe_eval (it->font_height);
 4273               unbind_to (count, Qnil);
 4274 
 4275               if (NUMBERP (value))
 4276                 new_height = XFLOATINT (value);
 4277             }
 4278 
 4279           if (new_height > 0)
 4280             it->face_id = face_with_height (it->f, it->face_id, new_height);
 4281         }
 4282 
 4283       return 0;
 4284     }
 4285 
 4286   /* Handle `(space-width WIDTH)'.  */
 4287   if (CONSP (spec)
 4288       && EQ (XCAR (spec), Qspace_width)
 4289       && CONSP (XCDR (spec)))
 4290     {
 4291       if (!FRAME_WINDOW_P (it->f))
 4292         return 0;
 4293 
 4294       value = XCAR (XCDR (spec));
 4295       if (NUMBERP (value) && XFLOATINT (value) > 0)
 4296         it->space_width = value;
 4297 
 4298       return 0;
 4299     }
 4300 
 4301   /* Handle `(slice X Y WIDTH HEIGHT)'.  */
 4302   if (CONSP (spec)
 4303       && EQ (XCAR (spec), Qslice))
 4304     {
 4305       Lisp_Object tem;
 4306 
 4307       if (!FRAME_WINDOW_P (it->f))
 4308         return 0;
 4309 
 4310       if (tem = XCDR (spec), CONSP (tem))
 4311         {
 4312           it->slice.x = XCAR (tem);
 4313           if (tem = XCDR (tem), CONSP (tem))
 4314             {
 4315               it->slice.y = XCAR (tem);
 4316               if (tem = XCDR (tem), CONSP (tem))
 4317                 {
 4318                   it->slice.width = XCAR (tem);
 4319                   if (tem = XCDR (tem), CONSP (tem))
 4320                     it->slice.height = XCAR (tem);
 4321                 }
 4322             }
 4323         }
 4324 
 4325       return 0;
 4326     }
 4327 
 4328   /* Handle `(raise FACTOR)'.  */
 4329   if (CONSP (spec)
 4330       && EQ (XCAR (spec), Qraise)
 4331       && CONSP (XCDR (spec)))
 4332     {
 4333       if (!FRAME_WINDOW_P (it->f))
 4334         return 0;
 4335 
 4336 #ifdef HAVE_WINDOW_SYSTEM
 4337       value = XCAR (XCDR (spec));
 4338       if (NUMBERP (value))
 4339         {
 4340           struct face *face = FACE_FROM_ID (it->f, it->face_id);
 4341           it->voffset = - (XFLOATINT (value)
 4342                            * (FONT_HEIGHT (face->font)));
 4343         }
 4344 #endif /* HAVE_WINDOW_SYSTEM */
 4345 
 4346       return 0;
 4347     }
 4348 
 4349   /* Don't handle the other kinds of display specifications
 4350      inside a string that we got from a `display' property.  */
 4351   if (it->string_from_display_prop_p)
 4352     return 0;
 4353 
 4354   /* Characters having this form of property are not displayed, so
 4355      we have to find the end of the property.  */
 4356   start_pos = *position;
 4357   *position = display_prop_end (it, object, start_pos);
 4358   value = Qnil;
 4359 
 4360   /* Stop the scan at that end position--we assume that all
 4361      text properties change there.  */
 4362   it->stop_charpos = position->charpos;
 4363 
 4364   /* Handle `(left-fringe BITMAP [FACE])'
 4365      and `(right-fringe BITMAP [FACE])'.  */
 4366   if (CONSP (spec)
 4367       && (EQ (XCAR (spec), Qleft_fringe)
 4368           || EQ (XCAR (spec), Qright_fringe))
 4369       && CONSP (XCDR (spec)))
 4370     {
 4371       int face_id = lookup_basic_face (it->f, DEFAULT_FACE_ID);
 4372       int fringe_bitmap;
 4373 
 4374       if (!FRAME_WINDOW_P (it->f))
 4375         /* If we return here, POSITION has been advanced
 4376            across the text with this property.  */
 4377         return 0;
 4378 
 4379 #ifdef HAVE_WINDOW_SYSTEM
 4380       value = XCAR (XCDR (spec));
 4381       if (!SYMBOLP (value)
 4382           || !(fringe_bitmap = lookup_fringe_bitmap (value)))
 4383         /* If we return here, POSITION has been advanced
 4384            across the text with this property.  */
 4385         return 0;
 4386 
 4387       if (CONSP (XCDR (XCDR (spec))))
 4388         {
 4389           Lisp_Object face_name = XCAR (XCDR (XCDR (spec)));
 4390           int face_id2 = lookup_derived_face (it->f, face_name,
 4391                                               FRINGE_FACE_ID, 0);
 4392           if (face_id2 >= 0)
 4393             face_id = face_id2;
 4394         }
 4395 
 4396       /* Save current settings of IT so that we can restore them
 4397          when we are finished with the glyph property value.  */
 4398 
 4399       save_pos = it->position;
 4400       it->position = *position;
 4401       push_it (it);
 4402       it->position = save_pos;
 4403 
 4404       it->area = TEXT_AREA;
 4405       it->what = IT_IMAGE;
 4406       it->image_id = -1; /* no image */
 4407       it->position = start_pos;
 4408       it->object = NILP (object) ? it->w->buffer : object;
 4409       it->method = GET_FROM_IMAGE;
 4410       it->from_overlay = Qnil;
 4411       it->face_id = face_id;
 4412 
 4413       /* Say that we haven't consumed the characters with
 4414          `display' property yet.  The call to pop_it in
 4415          set_iterator_to_next will clean this up.  */
 4416       *position = start_pos;
 4417 
 4418       if (EQ (XCAR (spec), Qleft_fringe))
 4419         {
 4420           it->left_user_fringe_bitmap = fringe_bitmap;
 4421           it->left_user_fringe_face_id = face_id;
 4422         }
 4423       else
 4424         {
 4425           it->right_user_fringe_bitmap = fringe_bitmap;
 4426           it->right_user_fringe_face_id = face_id;
 4427         }
 4428 #endif /* HAVE_WINDOW_SYSTEM */
 4429       return 1;
 4430     }
 4431 
 4432   /* Prepare to handle `((margin left-margin) ...)',
 4433      `((margin right-margin) ...)' and `((margin nil) ...)'
 4434      prefixes for display specifications.  */
 4435   location = Qunbound;
 4436   if (CONSP (spec) && CONSP (XCAR (spec)))
 4437     {
 4438       Lisp_Object tem;
 4439 
 4440       value = XCDR (spec);
 4441       if (CONSP (value))
 4442         value = XCAR (value);
 4443 
 4444       tem = XCAR (spec);
 4445       if (EQ (XCAR (tem), Qmargin)
 4446           && (tem = XCDR (tem),
 4447               tem = CONSP (tem) ? XCAR (tem) : Qnil,
 4448               (NILP (tem)
 4449                || EQ (tem, Qleft_margin)
 4450                || EQ (tem, Qright_margin))))
 4451         location = tem;
 4452     }
 4453 
 4454   if (EQ (location, Qunbound))
 4455     {
 4456       location = Qnil;
 4457       value = spec;
 4458     }
 4459 
 4460   /* After this point, VALUE is the property after any
 4461      margin prefix has been stripped.  It must be a string,
 4462      an image specification, or `(space ...)'.
 4463 
 4464      LOCATION specifies where to display: `left-margin',
 4465      `right-margin' or nil.  */
 4466 
 4467   valid_p = (STRINGP (value)
 4468 #ifdef HAVE_WINDOW_SYSTEM
 4469              || (FRAME_WINDOW_P (it->f) && valid_image_p (value))
 4470 #endif /* not HAVE_WINDOW_SYSTEM */
 4471              || (CONSP (value) && EQ (XCAR (value), Qspace)));
 4472 
 4473   if (valid_p && !display_replaced_before_p)
 4474     {
 4475       /* Save current settings of IT so that we can restore them
 4476          when we are finished with the glyph property value.  */
 4477       save_pos = it->position;
 4478       it->position = *position;
 4479       push_it (it);
 4480       it->position = save_pos;
 4481       it->from_overlay = overlay;
 4482 
 4483       if (NILP (location))
 4484         it->area = TEXT_AREA;
 4485       else if (EQ (location, Qleft_margin))
 4486         it->area = LEFT_MARGIN_AREA;
 4487       else
 4488         it->area = RIGHT_MARGIN_AREA;
 4489 
 4490       if (STRINGP (value))
 4491         {
 4492           it->string = value;
 4493           it->multibyte_p = STRING_MULTIBYTE (it->string);
 4494           it->current.overlay_string_index = -1;
 4495           IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
 4496           it->end_charpos = it->string_nchars = SCHARS (it->string);
 4497           it->method = GET_FROM_STRING;
 4498           it->stop_charpos = 0;
 4499           it->string_from_display_prop_p = 1;
 4500           /* Say that we haven't consumed the characters with
 4501              `display' property yet.  The call to pop_it in
 4502              set_iterator_to_next will clean this up.  */
 4503           if (BUFFERP (object))
 4504             *position = start_pos;
 4505         }
 4506       else if (CONSP (value) && EQ (XCAR (value), Qspace))
 4507         {
 4508           it->method = GET_FROM_STRETCH;
 4509           it->object = value;
 4510           *position = it->position = start_pos;
 4511         }
 4512 #ifdef HAVE_WINDOW_SYSTEM
 4513       else
 4514         {
 4515           it->what = IT_IMAGE;
 4516           it->image_id = lookup_image (it->f, value);
 4517           it->position = start_pos;
 4518           it->object = NILP (object) ? it->w->buffer : object;
 4519           it->method = GET_FROM_IMAGE;
 4520 
 4521           /* Say that we haven't consumed the characters with
 4522              `display' property yet.  The call to pop_it in
 4523              set_iterator_to_next will clean this up.  */
 4524           *position = start_pos;
 4525         }
 4526 #endif /* HAVE_WINDOW_SYSTEM */
 4527 
 4528       return 1;
 4529     }
 4530 
 4531   /* Invalid property or property not supported.  Restore
 4532      POSITION to what it was before.  */
 4533   *position = start_pos;
 4534   return 0;
 4535 }
 4536 
 4537 
 4538 /* Check if SPEC is a display sub-property value whose text should be
 4539    treated as intangible.  */
 4540 
 4541 static int
 4542 single_display_spec_intangible_p (prop)
 4543      Lisp_Object prop;
 4544 {
 4545   /* Skip over `when FORM'.  */
 4546   if (CONSP (prop) && EQ (XCAR (prop), Qwhen))
 4547     {
 4548       prop = XCDR (prop);
 4549       if (!CONSP (prop))
 4550         return 0;
 4551       prop = XCDR (prop);
 4552     }
 4553 
 4554   if (STRINGP (prop))
 4555     return 1;
 4556 
 4557   if (!CONSP (prop))
 4558     return 0;
 4559 
 4560   /* Skip over `margin LOCATION'.  If LOCATION is in the margins,
 4561      we don't need to treat text as intangible.  */
 4562   if (EQ (XCAR (prop), Qmargin))
 4563     {
 4564       prop = XCDR (prop);
 4565       if (!CONSP (prop))
 4566         return 0;
 4567 
 4568       prop = XCDR (prop);
 4569       if (!CONSP (prop)
 4570           || EQ (XCAR (prop), Qleft_margin)
 4571           || EQ (XCAR (prop), Qright_margin))
 4572         return 0;
 4573     }
 4574 
 4575   return (CONSP (prop)
 4576           && (EQ (XCAR (prop), Qimage)
 4577               || EQ (XCAR (prop), Qspace)));
 4578 }
 4579 
 4580 
 4581 /* Check if PROP is a display property value whose text should be
 4582    treated as intangible.  */
 4583 
 4584 int
 4585 display_prop_intangible_p (prop)
 4586      Lisp_Object prop;
 4587 {
 4588   if (CONSP (prop)
 4589       && CONSP (XCAR (prop))
 4590       && !EQ (Qmargin, XCAR (XCAR (prop))))
 4591     {
 4592       /* A list of sub-properties.  */
 4593       while (CONSP (prop))
 4594         {
 4595           if (single_display_spec_intangible_p (XCAR (prop)))
 4596             return 1;
 4597           prop = XCDR (prop);
 4598         }
 4599     }
 4600   else if (VECTORP (prop))
 4601     {
 4602       /* A vector of sub-properties.  */
 4603       int i;
 4604       for (i = 0; i < ASIZE (prop); ++i)
 4605         if (single_display_spec_intangible_p (AREF (prop, i)))
 4606           return 1;
 4607     }
 4608   else
 4609     return single_display_spec_intangible_p (prop);
 4610 
 4611   return 0;
 4612 }
 4613 
 4614 
 4615 /* Return 1 if PROP is a display sub-property value containing STRING.  */
 4616 
 4617 static int
 4618 single_display_spec_string_p (prop, string)
 4619      Lisp_Object prop, string;
 4620 {
 4621   if (EQ (string, prop))
 4622     return 1;
 4623 
 4624   /* Skip over `when FORM'.  */
 4625   if (CONSP (prop) && EQ (XCAR (prop), Qwhen))
 4626     {
 4627       prop = XCDR (prop);
 4628       if (!CONSP (prop))
 4629         return 0;
 4630       prop = XCDR (prop);
 4631     }
 4632 
 4633   if (CONSP (prop))
 4634     /* Skip over `margin LOCATION'.  */
 4635     if (EQ (XCAR (prop), Qmargin))
 4636       {
 4637         prop = XCDR (prop);
 4638         if (!CONSP (prop))
 4639           return 0;
 4640 
 4641         prop = XCDR (prop);
 4642         if (!CONSP (prop))
 4643           return 0;
 4644       }
 4645 
 4646   return CONSP (prop) && EQ (XCAR (prop), string);
 4647 }
 4648 
 4649 
 4650 /* Return 1 if STRING appears in the `display' property PROP.  */
 4651 
 4652 static int
 4653 display_prop_string_p (prop, string)
 4654      Lisp_Object prop, string;
 4655 {
 4656   if (CONSP (prop)
 4657       && CONSP (XCAR (prop))
 4658       && !EQ (Qmargin, XCAR (XCAR (prop))))
 4659     {
 4660       /* A list of sub-properties.  */
 4661       while (CONSP (prop))
 4662         {
 4663           if (single_display_spec_string_p (XCAR (prop), string))
 4664             return 1;
 4665           prop = XCDR (prop);
 4666         }
 4667     }
 4668   else if (VECTORP (prop))
 4669     {
 4670       /* A vector of sub-properties.  */
 4671       int i;
 4672       for (i = 0; i < ASIZE (prop); ++i)
 4673         if (single_display_spec_string_p (AREF (prop, i), string))
 4674           return 1;
 4675     }
 4676   else
 4677     return single_display_spec_string_p (prop, string);
 4678 
 4679   return 0;
 4680 }
 4681 
 4682 /* Look for STRING in overlays and text properties in W's buffer,
 4683    between character positions FROM and TO (excluding TO).
 4684    BACK_P non-zero means look back (in this case, TO is supposed to be
 4685    less than FROM).
 4686    Value is the first character position where STRING was found, or
 4687    zero if it wasn't found before hitting TO.
 4688 
 4689    W's buffer must be current.
 4690 
 4691    This function may only use code that doesn't eval because it is
 4692    called asynchronously from note_mouse_highlight.  */
 4693 
 4694 static EMACS_INT
 4695 string_buffer_position_lim (w, string, from, to, back_p)
 4696      struct window *w;
 4697      Lisp_Object string;
 4698      EMACS_INT from, to;
 4699      int back_p;
 4700 {
 4701   Lisp_Object limit, prop, pos;
 4702   int found = 0;
 4703 
 4704   pos = make_number (from);
 4705 
 4706   if (!back_p)  /* looking forward */
 4707     {
 4708       limit = make_number (min (to, ZV));
 4709       while (!found && !EQ (pos, limit))
 4710         {
 4711           prop = Fget_char_property (pos, Qdisplay, Qnil);
 4712           if (!NILP (prop) && display_prop_string_p (prop, string))
 4713             found = 1;
 4714           else
 4715             pos = Fnext_single_char_property_change (pos, Qdisplay, Qnil,
 4716                                                      limit);
 4717         }
 4718     }
 4719   else          /* looking back */
 4720     {
 4721       limit = make_number (max (to, BEGV));
 4722       while (!found && !EQ (pos, limit))
 4723         {
 4724           prop = Fget_char_property (pos, Qdisplay, Qnil);
 4725           if (!NILP (prop) && display_prop_string_p (prop, string))
 4726             found = 1;
 4727           else
 4728             pos = Fprevious_single_char_property_change (pos, Qdisplay, Qnil,
 4729                                                          limit);
 4730         }
 4731     }
 4732 
 4733   return found ? XINT (pos) : 0;
 4734 }
 4735 
 4736 /* Determine which buffer position in W's buffer STRING comes from.
 4737    AROUND_CHARPOS is an approximate position where it could come from.
 4738    Value is the buffer position or 0 if it couldn't be determined.
 4739 
 4740    W's buffer must be current.
 4741 
 4742    This function is necessary because we don't record buffer positions
 4743    in glyphs generated from strings (to keep struct glyph small).
 4744    This function may only use code that doesn't eval because it is
 4745    called asynchronously from note_mouse_highlight.  */
 4746 
 4747 EMACS_INT
 4748 string_buffer_position (w, string, around_charpos)
 4749      struct window *w;
 4750      Lisp_Object string;
 4751      EMACS_INT around_charpos;
 4752 {
 4753   Lisp_Object limit, prop, pos;
 4754   const int MAX_DISTANCE = 1000;
 4755   EMACS_INT found = string_buffer_position_lim (w, string, around_charpos,
 4756                                                 around_charpos + MAX_DISTANCE,
 4757                                                 0);
 4758 
 4759   if (!found)
 4760     found = string_buffer_position_lim (w, string, around_charpos,
 4761                                         around_charpos - MAX_DISTANCE, 1);
 4762   return found;
 4763 }
 4764 
 4765 
 4766 
 4767 /***********************************************************************
 4768                         `composition' property
 4769  ***********************************************************************/
 4770 
 4771 /* Set up iterator IT from `composition' property at its current
 4772    position.  Called from handle_stop.  */
 4773 
 4774 static enum prop_handled
 4775 handle_composition_prop (it)
 4776      struct it *it;
 4777 {
 4778   Lisp_Object prop, string;
 4779   EMACS_INT pos, pos_byte, start, end;
 4780 
 4781   if (STRINGP (it->string))
 4782     {
 4783       unsigned char *s;
 4784 
 4785       pos = IT_STRING_CHARPOS (*it);
 4786       pos_byte = IT_STRING_BYTEPOS (*it);
 4787       string = it->string;
 4788       s = SDATA (string) + pos_byte;
 4789       it->c = STRING_CHAR (s);
 4790     }
 4791   else
 4792     {
 4793       pos = IT_CHARPOS (*it);
 4794       pos_byte = IT_BYTEPOS (*it);
 4795       string = Qnil;
 4796       it->c = FETCH_CHAR (pos_byte);
 4797     }
 4798 
 4799   /* If there's a valid composition and point is not inside of the
 4800      composition (in the case that the composition is from the current
 4801      buffer), draw a glyph composed from the composition components.  */
 4802   if (find_composition (pos, -1, &start, &end, &prop, string)
 4803       && COMPOSITION_VALID_P (start, end, prop)
 4804       && (STRINGP (it->string) || (PT <= start || PT >= end)))
 4805     {
 4806       if (start != pos)
 4807         {
 4808           if (STRINGP (it->string))
 4809             pos_byte = string_char_to_byte (it->string, start);
 4810           else
 4811             pos_byte = CHAR_TO_BYTE (start);
 4812         }
 4813       it->cmp_it.id = get_composition_id (start, pos_byte, end - start,
 4814                                                prop, string);
 4815 
 4816       if (it->cmp_it.id >= 0)
 4817         {
 4818           it->cmp_it.ch = -1;
 4819           it->cmp_it.nchars = COMPOSITION_LENGTH (prop);
 4820           it->cmp_it.nglyphs = -1;
 4821         }
 4822     }
 4823 
 4824   return HANDLED_NORMALLY;
 4825 }
 4826 
 4827 
 4828 
 4829 /***********************************************************************
 4830                            Overlay strings
 4831  ***********************************************************************/
 4832 
 4833 /* The following structure is used to record overlay strings for
 4834    later sorting in load_overlay_strings.  */
 4835 
 4836 struct overlay_entry
 4837 {
 4838   Lisp_Object overlay;
 4839   Lisp_Object string;
 4840   int priority;
 4841   int after_string_p;
 4842 };
 4843 
 4844 
 4845 /* Set up iterator IT from overlay strings at its current position.
 4846    Called from handle_stop.  */
 4847 
 4848 static enum prop_handled
 4849 handle_overlay_change (it)
 4850      struct it *it;
 4851 {
 4852   if (!STRINGP (it->string) && get_overlay_strings (it, 0))
 4853     return HANDLED_RECOMPUTE_PROPS;
 4854   else
 4855     return HANDLED_NORMALLY;
 4856 }
 4857 
 4858 
 4859 /* Set up the next overlay string for delivery by IT, if there is an
 4860    overlay string to deliver.  Called by set_iterator_to_next when the
 4861    end of the current overlay string is reached.  If there are more
 4862    overlay strings to display, IT->string and
 4863    IT->current.overlay_string_index are set appropriately here.
 4864    Otherwise IT->string is set to nil.  */
 4865 
 4866 static void
 4867 next_overlay_string (it)
 4868      struct it *it;
 4869 {
 4870   ++it->current.overlay_string_index;
 4871   if (it->current.overlay_string_index == it->n_overlay_strings)
 4872     {
 4873       /* No more overlay strings.  Restore IT's settings to what
 4874          they were before overlay strings were processed, and
 4875          continue to deliver from current_buffer.  */
 4876 
 4877       it->ellipsis_p = (it->stack[it->sp - 1].display_ellipsis_p != 0);
 4878       pop_it (it);
 4879       xassert (it->sp > 0
 4880                || (NILP (it->string)
 4881                    && it->method == GET_FROM_BUFFER
 4882                    && it->stop_charpos >= BEGV
 4883                    && it->stop_charpos <= it->end_charpos));
 4884       it->current.overlay_string_index = -1;
 4885       it->n_overlay_strings = 0;
 4886 
 4887       /* If we're at the end of the buffer, record that we have
 4888          processed the overlay strings there already, so that
 4889          next_element_from_buffer doesn't try it again.  */
 4890       if (NILP (it->string) && IT_CHARPOS (*it) >= it->end_charpos)
 4891         it->overlay_strings_at_end_processed_p = 1;
 4892     }
 4893   else
 4894     {
 4895       /* There are more overlay strings to process.  If
 4896          IT->current.overlay_string_index has advanced to a position
 4897          where we must load IT->overlay_strings with more strings, do
 4898          it.  */
 4899       int i = it->current.overlay_string_index % OVERLAY_STRING_CHUNK_SIZE;
 4900 
 4901       if (it->current.overlay_string_index && i == 0)
 4902         load_overlay_strings (it, 0);
 4903 
 4904       /* Initialize IT to deliver display elements from the overlay
 4905          string.  */
 4906       it->string = it->overlay_strings[i];
 4907       it->multibyte_p = STRING_MULTIBYTE (it->string);
 4908       SET_TEXT_POS (it->current.string_pos, 0, 0);
 4909       it->method = GET_FROM_STRING;
 4910       it->stop_charpos = 0;
 4911       if (it->cmp_it.stop_pos >= 0)
 4912         it->cmp_it.stop_pos = 0;
 4913     }
 4914 
 4915   CHECK_IT (it);
 4916 }
 4917 
 4918 
 4919 /* Compare two overlay_entry structures E1 and E2.  Used as a
 4920    comparison function for qsort in load_overlay_strings.  Overlay
 4921    strings for the same position are sorted so that
 4922 
 4923    1. All after-strings come in front of before-strings, except
 4924    when they come from the same overlay.
 4925 
 4926    2. Within after-strings, strings are sorted so that overlay strings
 4927    from overlays with higher priorities come first.
 4928 
 4929    2. Within before-strings, strings are sorted so that overlay
 4930    strings from overlays with higher priorities come last.
 4931 
 4932    Value is analogous to strcmp.  */
 4933 
 4934 
 4935 static int
 4936 compare_overlay_entries (e1, e2)
 4937      void *e1, *e2;
 4938 {
 4939   struct overlay_entry *entry1 = (struct overlay_entry *) e1;
 4940   struct overlay_entry *entry2 = (struct overlay_entry *) e2;
 4941   int result;
 4942 
 4943   if (entry1->after_string_p != entry2->after_string_p)
 4944     {
 4945       /* Let after-strings appear in front of before-strings if
 4946          they come from different overlays.  */
 4947       if (EQ (entry1->overlay, entry2->overlay))
 4948         result = entry1->after_string_p ? 1 : -1;
 4949       else
 4950         result = entry1->after_string_p ? -1 : 1;
 4951     }
 4952   else if (entry1->after_string_p)
 4953     /* After-strings sorted in order of decreasing priority.  */
 4954     result = entry2->priority - entry1->priority;
 4955   else
 4956     /* Before-strings sorted in order of increasing priority.  */
 4957     result = entry1->priority - entry2->priority;
 4958 
 4959   return result;
 4960 }
 4961 
 4962 
 4963 /* Load the vector IT->overlay_strings with overlay strings from IT's
 4964    current buffer position, or from CHARPOS if that is > 0.  Set
 4965    IT->n_overlays to the total number of overlay strings found.
 4966 
 4967    Overlay strings are processed OVERLAY_STRING_CHUNK_SIZE strings at
 4968    a time.  On entry into load_overlay_strings,
 4969    IT->current.overlay_string_index gives the number of overlay
 4970    strings that have already been loaded by previous calls to this
 4971    function.
 4972 
 4973    IT->add_overlay_start contains an additional overlay start
 4974    position to consider for taking overlay strings from, if non-zero.
 4975    This position comes into play when the overlay has an `invisible'
 4976    property, and both before and after-strings.  When we've skipped to
 4977    the end of the overlay, because of its `invisible' property, we
 4978    nevertheless want its before-string to appear.
 4979    IT->add_overlay_start will contain the overlay start position
 4980    in this case.
 4981 
 4982    Overlay strings are sorted so that after-string strings come in
 4983    front of before-string strings.  Within before and after-strings,
 4984    strings are sorted by overlay priority.  See also function
 4985    compare_overlay_entries.  */
 4986 
 4987 static void
 4988 load_overlay_strings (it, charpos)
 4989      struct it *it;
 4990      int charpos;
 4991 {
 4992   extern Lisp_Object Qwindow, Qpriority;
 4993   Lisp_Object overlay, window, str, invisible;
 4994   struct Lisp_Overlay *ov;
 4995   int start, end;
 4996   int size = 20;
 4997   int n = 0, i, j, invis_p;
 4998   struct overlay_entry *entries
 4999     = (struct overlay_entry *) alloca (size * sizeof *entries);
 5000 
 5001   if (charpos <= 0)
 5002     charpos = IT_CHARPOS (*it);
 5003 
 5004   /* Append the overlay string STRING of overlay OVERLAY to vector
 5005      `entries' which has size `size' and currently contains `n'
 5006      elements.  AFTER_P non-zero means STRING is an after-string of
 5007      OVERLAY.  */
 5008 #define RECORD_OVERLAY_STRING(OVERLAY, STRING, AFTER_P)                 \
 5009   do                                                                    \
 5010     {                                                                   \
 5011       Lisp_Object priority;                                             \
 5012                                                                         \
 5013       if (n == size)                                                    \
 5014         {                                                               \
 5015           int new_size = 2 * size;                                      \
 5016           struct overlay_entry *old = entries;                          \
 5017           entries =                                                     \
 5018             (struct overlay_entry *) alloca (new_size                   \
 5019                                              * sizeof *entries);        \
 5020           bcopy (old, entries, size * sizeof *entries);                 \
 5021           size = new_size;                                              \
 5022         }                                                               \
 5023                                                                         \
 5024       entries[n].string = (STRING);                                     \
 5025       entries[n].overlay = (OVERLAY);                                   \
 5026       priority = Foverlay_get ((OVERLAY), Qpriority);                   \
 5027       entries[n].priority = INTEGERP (priority) ? XINT (priority) : 0;  \
 5028       entries[n].after_string_p = (AFTER_P);                            \
 5029       ++n;                                                              \
 5030     }                                                                   \
 5031   while (0)
 5032 
 5033   /* Process overlay before the overlay center.  */
 5034   for (ov = current_buffer->overlays_before; ov; ov = ov->next)
 5035     {
 5036       XSETMISC (overlay, ov);
 5037       xassert (OVERLAYP (overlay));
 5038       start = OVERLAY_POSITION (OVERLAY_START (overlay));
 5039       end = OVERLAY_POSITION (OVERLAY_END (overlay));
 5040 
 5041       if (end < charpos)
 5042         break;
 5043 
 5044       /* Skip this overlay if it doesn't start or end at IT's current
 5045          position.  */
 5046       if (end != charpos && start != charpos)
 5047         continue;
 5048 
 5049       /* Skip this overlay if it doesn't apply to IT->w.  */
 5050       window = Foverlay_get (overlay, Qwindow);
 5051       if (WINDOWP (window) && XWINDOW (window) != it->w)
 5052         continue;
 5053 
 5054       /* If the text ``under'' the overlay is invisible, both before-
 5055          and after-strings from this overlay are visible; start and
 5056          end position are indistinguishable.  */
 5057       invisible = Foverlay_get (overlay, Qinvisible);
 5058       invis_p = TEXT_PROP_MEANS_INVISIBLE (invisible);
 5059 
 5060       /* If overlay has a non-empty before-string, record it.  */
 5061       if ((start == charpos || (end == charpos && invis_p))
 5062           && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str))
 5063           && SCHARS (str))
 5064         RECORD_OVERLAY_STRING (overlay, str, 0);
 5065 
 5066       /* If overlay has a non-empty after-string, record it.  */
 5067       if ((end == charpos || (start == charpos && invis_p))
 5068           && (str = Foverlay_get (overlay, Qafter_string), STRINGP (str))
 5069           && SCHARS (str))
 5070         RECORD_OVERLAY_STRING (overlay, str, 1);
 5071     }
 5072 
 5073   /* Process overlays after the overlay center.  */
 5074   for (ov = current_buffer->overlays_after; ov; ov = ov->next)
 5075     {
 5076       XSETMISC (overlay, ov);
 5077       xassert (OVERLAYP (overlay));
 5078       start = OVERLAY_POSITION (OVERLAY_START (overlay));
 5079       end = OVERLAY_POSITION (OVERLAY_END (overlay));
 5080 
 5081       if (start > charpos)
 5082         break;
 5083 
 5084       /* Skip this overlay if it doesn't start or end at IT's current
 5085          position.  */
 5086       if (end != charpos && start != charpos)
 5087         continue;
 5088 
 5089       /* Skip this overlay if it doesn't apply to IT->w.  */
 5090       window = Foverlay_get (overlay, Qwindow);
 5091       if (WINDOWP (window) && XWINDOW (window) != it->w)
 5092         continue;
 5093 
 5094       /* If the text ``under'' the overlay is invisible, it has a zero
 5095          dimension, and both before- and after-strings apply.  */
 5096       invisible = Foverlay_get (overlay, Qinvisible);
 5097       invis_p = TEXT_PROP_MEANS_INVISIBLE (invisible);
 5098 
 5099       /* If overlay has a non-empty before-string, record it.  */
 5100       if ((start == charpos || (end == charpos && invis_p))
 5101           && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str))
 5102           && SCHARS (str))
 5103         RECORD_OVERLAY_STRING (overlay, str, 0);
 5104 
 5105       /* If overlay has a non-empty after-string, record it.  */
 5106       if ((end == charpos || (start == charpos && invis_p))
 5107           && (str = Foverlay_get (overlay, Qafter_string), STRINGP (str))
 5108           && SCHARS (str))
 5109         RECORD_OVERLAY_STRING (overlay, str, 1);
 5110     }
 5111 
 5112 #undef RECORD_OVERLAY_STRING
 5113 
 5114   /* Sort entries.  */
 5115   if (n > 1)
 5116     qsort (entries, n, sizeof *entries, compare_overlay_entries);
 5117 
 5118   /* Record the total number of strings to process.  */
 5119   it->n_overlay_strings = n;
 5120 
 5121   /* IT->current.overlay_string_index is the number of overlay strings
 5122      that have already been consumed by IT.  Copy some of the
 5123      remaining overlay strings to IT->overlay_strings.  */
 5124   i = 0;
 5125   j = it->current.overlay_string_index;
 5126   while (i < OVERLAY_STRING_CHUNK_SIZE && j < n)
 5127     {
 5128       it->overlay_strings[i] = entries[j].string;
 5129       it->string_overlays[i++] = entries[j++].overlay;
 5130     }
 5131 
 5132   CHECK_IT (it);
 5133 }
 5134 
 5135 
 5136 /* Get the first chunk of overlay strings at IT's current buffer
 5137    position, or at CHARPOS if that is > 0.  Value is non-zero if at
 5138    least one overlay string was found.  */
 5139 
 5140 static int
 5141 get_overlay_strings_1 (it, charpos, compute_stop_p)
 5142      struct it *it;
 5143      int charpos;
 5144      int compute_stop_p;
 5145 {
 5146   /* Get the first OVERLAY_STRING_CHUNK_SIZE overlay strings to
 5147      process.  This fills IT->overlay_strings with strings, and sets
 5148      IT->n_overlay_strings to the total number of strings to process.
 5149      IT->pos.overlay_string_index has to be set temporarily to zero
 5150      because load_overlay_strings needs this; it must be set to -1
 5151      when no overlay strings are found because a zero value would
 5152      indicate a position in the first overlay string.  */
 5153   it->current.overlay_string_index = 0;
 5154   load_overlay_strings (it, charpos);
 5155 
 5156   /* If we found overlay strings, set up IT to deliver display
 5157      elements from the first one.  Otherwise set up IT to deliver
 5158      from current_buffer.  */
 5159   if (it->n_overlay_strings)
 5160     {
 5161       /* Make sure we know settings in current_buffer, so that we can
 5162          restore meaningful values when we're done with the overlay
 5163          strings.  */
 5164       if (compute_stop_p)
 5165         compute_stop_pos (it);
 5166       xassert (it->face_id >= 0);
 5167 
 5168       /* Save IT's settings.  They are restored after all overlay
 5169          strings have been processed.  */
 5170       xassert (!compute_stop_p || it->sp == 0);
 5171 
 5172       /* When called from handle_stop, there might be an empty display
 5173          string loaded.  In that case, don't bother saving it.  */
 5174       if (!STRINGP (it->string) || SCHARS (it->string))
 5175         push_it (it);
 5176 
 5177       /* Set up IT to deliver display elements from the first overlay
 5178          string.  */
 5179       IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
 5180       it->string = it->overlay_strings[0];
 5181       it->from_overlay = Qnil;
 5182       it->stop_charpos = 0;
 5183       xassert (STRINGP (it->string));
 5184       it->end_charpos = SCHARS (it->string);
 5185       it->multibyte_p = STRING_MULTIBYTE (it->string);
 5186       it->method = GET_FROM_STRING;
 5187       return 1;
 5188     }
 5189 
 5190   it->current.overlay_string_index = -1;
 5191   return 0;
 5192 }
 5193 
 5194 static int
 5195 get_overlay_strings (it, charpos)
 5196      struct it *it;
 5197      int charpos;
 5198 {
 5199   it->string = Qnil;
 5200   it->method = GET_FROM_BUFFER;
 5201 
 5202   (void) get_overlay_strings_1 (it, charpos, 1);
 5203 
 5204   CHECK_IT (it);
 5205 
 5206   /* Value is non-zero if we found at least one overlay string.  */
 5207   return STRINGP (it->string);
 5208 }
 5209 
 5210 
 5211 
 5212 /***********************************************************************
 5213                       Saving and restoring state
 5214  ***********************************************************************/
 5215 
 5216 /* Save current settings of IT on IT->stack.  Called, for example,
 5217    before setting up IT for an overlay string, to be able to restore
 5218    IT's settings to what they were after the overlay string has been
 5219    processed.  */
 5220 
 5221 static void
 5222 push_it (it)
 5223      struct it *it;
 5224 {
 5225   struct iterator_stack_entry *p;
 5226 
 5227   xassert (it->sp < IT_STACK_SIZE);
 5228   p = it->stack + it->sp;
 5229 
 5230   p->stop_charpos = it->stop_charpos;
 5231   p->prev_stop = it->prev_stop;
 5232   p->base_level_stop = it->base_level_stop;
 5233   p->cmp_it = it->cmp_it;
 5234   xassert (it->face_id >= 0);
 5235   p->face_id = it->face_id;
 5236   p->string = it->string;
 5237   p->method = it->method;
 5238   p->from_overlay = it->from_overlay;
 5239   switch (p->method)
 5240     {
 5241     case GET_FROM_IMAGE:
 5242       p->u.image.object = it->object;
 5243       p->u.image.image_id = it->image_id;
 5244       p->u.image.slice = it->slice;
 5245       break;
 5246     case GET_FROM_STRETCH:
 5247       p->u.stretch.object = it->object;
 5248       break;
 5249     }
 5250   p->position = it->position;
 5251   p->current = it->current;
 5252   p->end_charpos = it->end_charpos;
 5253   p->string_nchars = it->string_nchars;
 5254   p->area = it->area;
 5255   p->multibyte_p = it->multibyte_p;
 5256   p->avoid_cursor_p = it->avoid_cursor_p;
 5257   p->space_width = it->space_width;
 5258   p->font_height = it->font_height;
 5259   p->voffset = it->voffset;
 5260   p->string_from_display_prop_p = it->string_from_display_prop_p;
 5261   p->display_ellipsis_p = 0;
 5262   p->line_wrap = it->line_wrap;
 5263   ++it->sp;
 5264 }
 5265 
 5266 static void
 5267 iterate_out_of_display_property (it)
 5268      struct it *it;
 5269 {
 5270   /* Maybe initialize paragraph direction.  If we are at the beginning
 5271      of a new paragraph, next_element_from_buffer may not have a
 5272      chance to do that.  */
 5273   if (it->bidi_it.first_elt && it->bidi_it.charpos < ZV)
 5274     bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
 5275   /* prev_stop can be zero, so check against BEGV as well.  */
 5276   while (it->bidi_it.charpos >= BEGV
 5277          && it->prev_stop <= it->bidi_it.charpos
 5278          && it->bidi_it.charpos < CHARPOS (it->position))
 5279     bidi_move_to_visually_next (&it->bidi_it);
 5280   /* Record the stop_pos we just crossed, for when we cross it
 5281      back, maybe.  */
 5282   if (it->bidi_it.charpos > CHARPOS (it->position))
 5283     it->prev_stop = CHARPOS (it->position);
 5284   /* If we ended up not where pop_it put us, resync IT's
 5285      positional members with the bidi iterator. */
 5286   if (it->bidi_it.charpos != CHARPOS (it->position))
 5287     {
 5288       SET_TEXT_POS (it->position,
 5289                     it->bidi_it.charpos, it->bidi_it.bytepos);
 5290       it->current.pos = it->position;
 5291     }
 5292 }
 5293 
 5294 /* Restore IT's settings from IT->stack.  Called, for example, when no
 5295    more overlay strings must be processed, and we return to delivering
 5296    display elements from a buffer, or when the end of a string from a
 5297    `display' property is reached and we return to delivering display
 5298    elements from an overlay string, or from a buffer.  */
 5299 
 5300 static void
 5301 pop_it (it)
 5302      struct it *it;
 5303 {
 5304   struct iterator_stack_entry *p;
 5305 
 5306   xassert (it->sp > 0);
 5307   --it->sp;
 5308   p = it->stack + it->sp;
 5309   it->stop_charpos = p->stop_charpos;
 5310   it->prev_stop = p->prev_stop;
 5311   it->base_level_stop = p->base_level_stop;
 5312   it->cmp_it = p->cmp_it;
 5313   it->face_id = p->face_id;
 5314   it->current = p->current;
 5315   it->position = p->position;
 5316   it->string = p->string;
 5317   it->from_overlay = p->from_overlay;
 5318   if (NILP (it->string))
 5319     SET_TEXT_POS (it->current.string_pos, -1, -1);
 5320   it->method = p->method;
 5321   switch (it->method)
 5322     {
 5323     case GET_FROM_IMAGE:
 5324       it->image_id = p->u.image.image_id;
 5325       it->object = p->u.image.object;
 5326       it->slice = p->u.image.slice;
 5327       break;
 5328     case GET_FROM_STRETCH:
 5329       it->object = p->u.comp.object;
 5330       break;
 5331     case GET_FROM_BUFFER:
 5332       it->object = it->w->buffer;
 5333       if (it->bidi_p)
 5334         {
 5335           /* Bidi-iterate until we get out of the portion of text, if
 5336              any, covered by a `display' text property or an overlay
 5337              with `display' property.  (We cannot just jump there,
 5338              because the internal coherency of the bidi iterator state
 5339              can not be preserved across such jumps.)  We also must
 5340              determine the paragraph base direction if the overlay we
 5341              just processed is at the beginning of a new
 5342              paragraph.  */
 5343           iterate_out_of_display_property (it);
 5344         }
 5345       break;
 5346     case GET_FROM_STRING:
 5347       it->object = it->string;
 5348       break;
 5349     case GET_FROM_DISPLAY_VECTOR:
 5350       if (it->s)
 5351         it->method = GET_FROM_C_STRING;
 5352       else if (STRINGP (it->string))
 5353         it->method = GET_FROM_STRING;
 5354       else
 5355         {
 5356           it->method = GET_FROM_BUFFER;
 5357           it->object = it->w->buffer;
 5358         }
 5359     }
 5360   it->end_charpos = p->end_charpos;
 5361   it->string_nchars = p->string_nchars;
 5362   it->area = p->area;
 5363   it->multibyte_p = p->multibyte_p;
 5364   it->avoid_cursor_p = p->avoid_cursor_p;
 5365   it->space_width = p->space_width;
 5366   it->font_height = p->font_height;
 5367   it->voffset = p->voffset;
 5368   it->string_from_display_prop_p = p->string_from_display_prop_p;
 5369   it->line_wrap = p->line_wrap;
 5370 }
 5371 
 5372 
 5373 
 5374 /***********************************************************************
 5375                           Moving over lines
 5376  ***********************************************************************/
 5377 
 5378 /* Set IT's current position to the previous line start.  */
 5379 
 5380 static void
 5381 back_to_previous_line_start (it)
 5382      struct it *it;
 5383 {
 5384   IT_CHARPOS (*it) = find_next_newline_no_quit (IT_CHARPOS (*it) - 1, -1);
 5385   IT_BYTEPOS (*it) = CHAR_TO_BYTE (IT_CHARPOS (*it));
 5386 }
 5387 
 5388 
 5389 /* Move IT to the next line start.
 5390 
 5391    Value is non-zero if a newline was found.  Set *SKIPPED_P to 1 if
 5392    we skipped over part of the text (as opposed to moving the iterator
 5393    continuously over the text).  Otherwise, don't change the value
 5394    of *SKIPPED_P.
 5395 
 5396    Newlines may come from buffer text, overlay strings, or strings
 5397    displayed via the `display' property.  That's the reason we can't
 5398    simply use find_next_newline_no_quit.
 5399 
 5400    Note that this function may not skip over invisible text that is so
 5401    because of text properties and immediately follows a newline.  If
 5402    it would, function reseat_at_next_visible_line_start, when called
 5403    from set_iterator_to_next, would effectively make invisible
 5404    characters following a newline part of the wrong glyph row, which
 5405    leads to wrong cursor motion.  */
 5406 
 5407 static int
 5408 forward_to_next_line_start (it, skipped_p)
 5409      struct it *it;
 5410      int *skipped_p;
 5411 {
 5412   int old_selective, newline_found_p, n;
 5413   const int MAX_NEWLINE_DISTANCE = 500;
 5414 
 5415   /* If already on a newline, just consume it to avoid unintended
 5416      skipping over invisible text below.  */
 5417   if (it->what == IT_CHARACTER
 5418       && it->c == '\n'
 5419       && CHARPOS (it->position) == IT_CHARPOS (*it))
 5420     {
 5421       set_iterator_to_next (it, 0);
 5422       it->c = 0;
 5423       return 1;
 5424     }
 5425 
 5426   /* Don't handle selective display in the following.  It's (a)
 5427      unnecessary because it's done by the caller, and (b) leads to an
 5428      infinite recursion because next_element_from_ellipsis indirectly
 5429      calls this function.  */
 5430   old_selective = it->selective;
 5431   it->selective = 0;
 5432 
 5433   /* Scan for a newline within MAX_NEWLINE_DISTANCE display elements
 5434      from buffer text.  */
 5435   for (n = newline_found_p = 0;
 5436        !newline_found_p && n < MAX_NEWLINE_DISTANCE;
 5437        n += STRINGP (it->string) ? 0 : 1)
 5438     {
 5439       if (!get_next_display_element (it))
 5440         return 0;
 5441       newline_found_p = it->what == IT_CHARACTER && it->c == '\n';
 5442       set_iterator_to_next (it, 0);
 5443     }
 5444 
 5445   /* If we didn't find a newline near enough, see if we can use a
 5446      short-cut.  */
 5447   if (!newline_found_p)
 5448     {
 5449       int start = IT_CHARPOS (*it);
 5450       int limit = find_next_newline_no_quit (start, 1);
 5451       Lisp_Object pos;
 5452 
 5453       xassert (!STRINGP (it->string));
 5454 
 5455       /* If there isn't any `display' property in sight, and no
 5456          overlays, we can just use the position of the newline in
 5457          buffer text.  */
 5458       if (it->stop_charpos >= limit
 5459           || ((pos = Fnext_single_property_change (make_number (start),
 5460                                                    Qdisplay,
 5461                                                    Qnil, make_number (limit)),
 5462                NILP (pos))
 5463               && next_overlay_change (start) == ZV))
 5464         {
 5465           IT_CHARPOS (*it) = limit;
 5466           IT_BYTEPOS (*it) = CHAR_TO_BYTE (limit);
 5467           *skipped_p = newline_found_p = 1;
 5468         }
 5469       else
 5470         {
 5471           while (get_next_display_element (it)
 5472                  && !newline_found_p)
 5473             {
 5474               newline_found_p = ITERATOR_AT_END_OF_LINE_P (it);
 5475               set_iterator_to_next (it, 0);
 5476             }
 5477         }
 5478     }
 5479 
 5480   it->selective = old_selective;
 5481   return newline_found_p;
 5482 }
 5483 
 5484 
 5485 /* Set IT's current position to the previous visible line start.  Skip
 5486    invisible text that is so either due to text properties or due to
 5487    selective display.  Caution: this does not change IT->current_x and
 5488    IT->hpos.  */
 5489 
 5490 static void
 5491 back_to_previous_visible_line_start (it)
 5492      struct it *it;
 5493 {
 5494   while (IT_CHARPOS (*it) > BEGV)
 5495     {
 5496       back_to_previous_line_start (it);
 5497 
 5498       if (IT_CHARPOS (*it) <= BEGV)
 5499         break;
 5500 
 5501       /* If selective > 0, then lines indented more than its value are
 5502          invisible.  */
 5503       if (it->selective > 0
 5504           && indented_beyond_p (IT_CHARPOS (*it), IT_BYTEPOS (*it),
 5505                                 (double) it->selective)) /* iftc */
 5506         continue;
 5507 
 5508       /* Check the newline before point for invisibility.  */
 5509       {
 5510         Lisp_Object prop;
 5511         prop = Fget_char_property (make_number (IT_CHARPOS (*it) - 1),
 5512                                      Qinvisible, it->window);
 5513         if (TEXT_PROP_MEANS_INVISIBLE (prop))
 5514           continue;
 5515       }
 5516 
 5517       if (IT_CHARPOS (*it) <= BEGV)
 5518         break;
 5519 
 5520       {
 5521         struct it it2;
 5522         int pos;
 5523         EMACS_INT beg, end;
 5524         Lisp_Object val, overlay;
 5525 
 5526         /* If newline is part of a composition, continue from start of composition */
 5527         if (find_composition (IT_CHARPOS (*it), -1, &beg, &end, &val, Qnil)
 5528             && beg < IT_CHARPOS (*it))
 5529           goto replaced;
 5530 
 5531         /* If newline is replaced by a display property, find start of overlay
 5532            or interval and continue search from that point.  */
 5533         it2 = *it;
 5534         pos = --IT_CHARPOS (it2);
 5535         --IT_BYTEPOS (it2);
 5536         it2.sp = 0;
 5537         it2.string_from_display_prop_p = 0;
 5538         if (handle_display_prop (&it2) == HANDLED_RETURN
 5539             && !NILP (val = get_char_property_and_overlay
 5540                       (make_number (pos), Qdisplay, Qnil, &overlay))
 5541             && (OVERLAYP (overlay)
 5542                 ? (beg = OVERLAY_POSITION (OVERLAY_START (overlay)))
 5543                 : get_property_and_range (pos, Qdisplay, &val, &beg, &end, Qnil)))
 5544           goto replaced;
 5545 
 5546         /* Newline is not replaced by anything -- so we are done.  */
 5547         break;
 5548 
 5549       replaced:
 5550         if (beg < BEGV)
 5551           beg = BEGV;
 5552         IT_CHARPOS (*it) = beg;
 5553         IT_BYTEPOS (*it) = buf_charpos_to_bytepos (current_buffer, beg);
 5554       }
 5555     }
 5556 
 5557   it->continuation_lines_width = 0;
 5558 
 5559   xassert (IT_CHARPOS (*it) >= BEGV);
 5560   xassert (IT_CHARPOS (*it) == BEGV
 5561            || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n');
 5562   CHECK_IT (it);
 5563 }
 5564 
 5565 
 5566 /* Reseat iterator IT at the previous visible line start.  Skip
 5567    invisible text that is so either due to text properties or due to
 5568    selective display.  At the end, update IT's overlay information,
 5569    face information etc.  */
 5570 
 5571 void
 5572 reseat_at_previous_visible_line_start (it)
 5573      struct it *it;
 5574 {
 5575   back_to_previous_visible_line_start (it);
 5576   reseat (it, it->current.pos, 1);
 5577   CHECK_IT (it);
 5578 }
 5579 
 5580 
 5581 /* Reseat iterator IT on the next visible line start in the current
 5582    buffer.  ON_NEWLINE_P non-zero means position IT on the newline
 5583    preceding the line start.  Skip over invisible text that is so
 5584    because of selective display.  Compute faces, overlays etc at the
 5585    new position.  Note that this function does not skip over text that
 5586    is invisible because of text properties.  */
 5587 
 5588 static void
 5589 reseat_at_next_visible_line_start (it, on_newline_p)
 5590      struct it *it;
 5591      int on_newline_p;
 5592 {
 5593   int newline_found_p, skipped_p = 0;
 5594 
 5595   newline_found_p = forward_to_next_line_start (it, &skipped_p);
 5596 
 5597   /* Skip over lines that are invisible because they are indented
 5598      more than the value of IT->selective.  */
 5599   if (it->selective > 0)
 5600     while (IT_CHARPOS (*it) < ZV
 5601            && indented_beyond_p (IT_CHARPOS (*it), IT_BYTEPOS (*it),
 5602                                  (double) it->selective)) /* iftc */
 5603       {
 5604         xassert (IT_BYTEPOS (*it) == BEGV
 5605                  || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n');
 5606         newline_found_p = forward_to_next_line_start (it, &skipped_p);
 5607       }
 5608 
 5609   /* Position on the newline if that's what's requested.  */
 5610   if (on_newline_p && newline_found_p)
 5611     {
 5612       if (STRINGP (it->string))
 5613         {
 5614           if (IT_STRING_CHARPOS (*it) > 0)
 5615             {
 5616               --IT_STRING_CHARPOS (*it);
 5617               --IT_STRING_BYTEPOS (*it);
 5618             }
 5619         }
 5620       else if (IT_CHARPOS (*it) > BEGV)
 5621         {
 5622           --IT_CHARPOS (*it);
 5623           --IT_BYTEPOS (*it);
 5624           reseat (it, it->current.pos, 0);
 5625         }
 5626     }
 5627   else if (skipped_p)
 5628     reseat (it, it->current.pos, 0);
 5629 
 5630   CHECK_IT (it);
 5631 }
 5632 
 5633 
 5634 
 5635 /***********************************************************************
 5636                    Changing an iterator's position
 5637 ***********************************************************************/
 5638 
 5639 /* Change IT's current position to POS in current_buffer.  If FORCE_P
 5640    is non-zero, always check for text properties at the new position.
 5641    Otherwise, text properties are only looked up if POS >=
 5642    IT->check_charpos of a property.  */
 5643 
 5644 static void
 5645 reseat (it, pos, force_p)
 5646      struct it *it;
 5647      struct text_pos pos;
 5648      int force_p;
 5649 {
 5650   int original_pos = IT_CHARPOS (*it);
 5651 
 5652   reseat_1 (it, pos, 0);
 5653 
 5654   /* Determine where to check text properties.  Avoid doing it
 5655      where possible because text property lookup is very expensive.  */
 5656   if (force_p
 5657       || CHARPOS (pos) > it->stop_charpos
 5658       || CHARPOS (pos) < original_pos)
 5659     {
 5660       if (it->bidi_p)
 5661         {
 5662           /* For bidi iteration, we need to prime prev_stop and
 5663              base_level_stop with our best estimations.  */
 5664           if (CHARPOS (pos) < it->prev_stop)
 5665             {
 5666               handle_stop_backwards (it, BEGV);
 5667               if (CHARPOS (pos) < it->base_level_stop)
 5668                 it->base_level_stop = 0;
 5669             }
 5670           else if (CHARPOS (pos) > it->stop_charpos
 5671                    && it->stop_charpos >= BEGV)
 5672             handle_stop_backwards (it, it->stop_charpos);
 5673           else  /* force_p */
 5674             handle_stop (it);
 5675         }
 5676       else
 5677         {
 5678           handle_stop (it);
 5679           it->prev_stop = it->base_level_stop = 0;
 5680         }
 5681 
 5682     }
 5683 
 5684   CHECK_IT (it);
 5685 }
 5686 
 5687 
 5688 /* Change IT's buffer position to POS.  SET_STOP_P non-zero means set
 5689    IT->stop_pos to POS, also.  */
 5690 
 5691 static void
 5692 reseat_1 (it, pos, set_stop_p)
 5693      struct it *it;
 5694      struct text_pos pos;
 5695      int set_stop_p;
 5696 {
 5697   /* Don't call this function when scanning a C string.  */
 5698   xassert (it->s == NULL);
 5699 
 5700   /* POS must be a reasonable value.  */
 5701   xassert (CHARPOS (pos) >= BEGV && CHARPOS (pos) <= ZV);
 5702 
 5703   it->current.pos = it->position = pos;
 5704   it->end_charpos = ZV;
 5705   it->dpvec = NULL;
 5706   it->current.dpvec_index = -1;
 5707   it->current.overlay_string_index = -1;
 5708   IT_STRING_CHARPOS (*it) = -1;
 5709   IT_STRING_BYTEPOS (*it) = -1;
 5710   it->string = Qnil;
 5711   it->string_from_display_prop_p = 0;
 5712   it->method = GET_FROM_BUFFER;
 5713   it->object = it->w->buffer;
 5714   it->area = TEXT_AREA;
 5715   it->multibyte_p = !NILP (current_buffer->enable_multibyte_characters);
 5716   it->sp = 0;
 5717   it->string_from_display_prop_p = 0;
 5718   it->face_before_selective_p = 0;
 5719   if (it->bidi_p)
 5720     it->bidi_it.first_elt = 1;
 5721 
 5722   if (set_stop_p)
 5723     {
 5724       it->stop_charpos = CHARPOS (pos);
 5725       it->base_level_stop = CHARPOS (pos);
 5726     }
 5727 }
 5728 
 5729 
 5730 /* Set up IT for displaying a string, starting at CHARPOS in window W.
 5731    If S is non-null, it is a C string to iterate over.  Otherwise,
 5732    STRING gives a Lisp string to iterate over.
 5733 
 5734    If PRECISION > 0, don't return more then PRECISION number of
 5735    characters from the string.
 5736 
 5737    If FIELD_WIDTH > 0, return padding spaces until FIELD_WIDTH
 5738    characters have been returned.  FIELD_WIDTH < 0 means an infinite
 5739    field width.
 5740 
 5741    MULTIBYTE = 0 means disable processing of multibyte characters,
 5742    MULTIBYTE > 0 means enable it,
 5743    MULTIBYTE < 0 means use IT->multibyte_p.
 5744 
 5745    IT must be initialized via a prior call to init_iterator before
 5746    calling this function.  */
 5747 
 5748 static void
 5749 reseat_to_string (it, s, string, charpos, precision, field_width, multibyte)
 5750      struct it *it;
 5751      unsigned char *s;
 5752      Lisp_Object string;
 5753      int charpos;
 5754      int precision, field_width, multibyte;
 5755 {
 5756   /* No region in strings.  */
 5757   it->region_beg_charpos = it->region_end_charpos = -1;
 5758 
 5759   /* No text property checks performed by default, but see below.  */
 5760   it->stop_charpos = -1;
 5761 
 5762   /* Set iterator position and end position.  */
 5763   bzero (&it->current, sizeof it->current);
 5764   it->current.overlay_string_index = -1;
 5765   it->current.dpvec_index = -1;
 5766   xassert (charpos >= 0);
 5767 
 5768   /* If STRING is specified, use its multibyteness, otherwise use the
 5769      setting of MULTIBYTE, if specified.  */
 5770   if (multibyte >= 0)
 5771     it->multibyte_p = multibyte > 0;
 5772 
 5773   if (s == NULL)
 5774     {
 5775       xassert (STRINGP (string));
 5776       it->string = string;
 5777       it->s = NULL;
 5778       it->end_charpos = it->string_nchars = SCHARS (string);
 5779       it->method = GET_FROM_STRING;
 5780       it->current.string_pos = string_pos (charpos, string);
 5781     }
 5782   else
 5783     {
 5784       it->s = s;
 5785       it->string = Qnil;
 5786 
 5787       /* Note that we use IT->current.pos, not it->current.string_pos,
 5788          for displaying C strings.  */
 5789       IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = -1;
 5790       if (it->multibyte_p)
 5791         {
 5792           it->current.pos = c_string_pos (charpos, s, 1);
 5793           it->end_charpos = it->string_nchars = number_of_chars (s, 1);
 5794         }
 5795       else
 5796         {
 5797           IT_CHARPOS (*it) = IT_BYTEPOS (*it) = charpos;
 5798           it->end_charpos = it->string_nchars = strlen (s);
 5799         }
 5800 
 5801       it->method = GET_FROM_C_STRING;
 5802     }
 5803 
 5804   /* PRECISION > 0 means don't return more than PRECISION characters
 5805      from the string.  */
 5806   if (precision > 0 && it->end_charpos - charpos > precision)
 5807     it->end_charpos = it->string_nchars = charpos + precision;
 5808 
 5809   /* FIELD_WIDTH > 0 means pad with spaces until FIELD_WIDTH
 5810      characters have been returned.  FIELD_WIDTH == 0 means don't pad,
 5811      FIELD_WIDTH < 0 means infinite field width.  This is useful for
 5812      padding with `-' at the end of a mode line.  */
 5813   if (field_width < 0)
 5814     field_width = INFINITY;
 5815   if (field_width > it->end_charpos - charpos)
 5816     it->end_charpos = charpos + field_width;
 5817 
 5818   /* Use the standard display table for displaying strings.  */
 5819   if (DISP_TABLE_P (Vstandard_display_table))
 5820     it->dp = XCHAR_TABLE (Vstandard_display_table);
 5821 
 5822   it->stop_charpos = charpos;
 5823   if (s == NULL && it->multibyte_p)
 5824     {
 5825       EMACS_INT endpos = SCHARS (it->string);
 5826       if (endpos > it->end_charpos)
 5827         endpos = it->end_charpos;
 5828       composition_compute_stop_pos (&it->cmp_it, charpos, -1, endpos,
 5829                                     it->string);
 5830     }
 5831   CHECK_IT (it);
 5832 }
 5833 
 5834 
 5835 
 5836 /***********************************************************************
 5837                               Iteration
 5838 ***********************************************************************/
 5839 
 5840 /* Map enum it_method value to corresponding next_element_from_* function.  */
 5841 
 5842 static int (* get_next_element[NUM_IT_METHODS]) P_ ((struct it *it)) =
 5843 {
 5844   next_element_from_buffer,
 5845   next_element_from_display_vector,
 5846   next_element_from_string,
 5847   next_element_from_c_string,
 5848   next_element_from_image,
 5849   next_element_from_stretch
 5850 };
 5851 
 5852 #define GET_NEXT_DISPLAY_ELEMENT(it) (*get_next_element[(it)->method]) (it)
 5853 
 5854 
 5855 /* Return 1 iff a character at CHARPOS (and BYTEPOS) is composed
 5856    (possibly with the following characters).  */
 5857 
 5858 #define CHAR_COMPOSED_P(IT,CHARPOS,BYTEPOS,END_CHARPOS)                 \
 5859   ((IT)->cmp_it.id >= 0                                                 \
 5860    || ((IT)->cmp_it.stop_pos == (CHARPOS)                               \
 5861        && composition_reseat_it (&(IT)->cmp_it, CHARPOS, BYTEPOS,       \
 5862                                  END_CHARPOS, (IT)->w,                  \
 5863                                  FACE_FROM_ID ((IT)->f, (IT)->face_id), \
 5864                                  (IT)->string)))
 5865 
 5866 
 5867 /* Load IT's display element fields with information about the next
 5868    display element from the current position of IT.  Value is zero if
 5869    end of buffer (or C string) is reached.  */
 5870 
 5871 static struct frame *last_escape_glyph_frame = NULL;
 5872 static unsigned last_escape_glyph_face_id = (1 << FACE_ID_BITS);
 5873 static int last_escape_glyph_merged_face_id = 0;
 5874 
 5875 int
 5876 get_next_display_element (it)
 5877      struct it *it;
 5878 {
 5879   /* Non-zero means that we found a display element.  Zero means that
 5880      we hit the end of what we iterate over.  Performance note: the
 5881      function pointer `method' used here turns out to be faster than
 5882      using a sequence of if-statements.  */
 5883   int success_p;
 5884 
 5885  get_next:
 5886   success_p = GET_NEXT_DISPLAY_ELEMENT (it);
 5887 
 5888   if (it->what == IT_CHARACTER)
 5889     {
 5890       /* UAX#9, L4: "A character is depicted by a mirrored glyph if
 5891          and only if (a) the resolved directionality of that character
 5892          is R..."  */
 5893       /* FIXME: Do we need an exception for characters from display
 5894          tables?  */
 5895       if (it->bidi_p && it->bidi_it.type == STRONG_R)
 5896         it->c = bidi_mirror_char (it->c);
 5897       /* Map via display table or translate control characters.
 5898          IT->c, IT->len etc. have been set to the next character by
 5899          the function call above.  If we have a display table, and it
 5900          contains an entry for IT->c, translate it.  Don't do this if
 5901          IT->c itself comes from a display table, otherwise we could
 5902          end up in an infinite recursion.  (An alternative could be to
 5903          count the recursion depth of this function and signal an
 5904          error when a certain maximum depth is reached.)  Is it worth
 5905          it?  */
 5906       if (success_p && it->dpvec == NULL)
 5907         {
 5908           Lisp_Object dv;
 5909           struct charset *unibyte = CHARSET_FROM_ID (charset_unibyte);
 5910           enum { char_is_other = 0, char_is_nbsp, char_is_soft_hyphen }
 5911           nbsp_or_shy = char_is_other;
 5912           int decoded = it->c;
 5913 
 5914           if (it->dp
 5915               && (dv = DISP_CHAR_VECTOR (it->dp, it->c),
 5916                   VECTORP (dv)))
 5917             {
 5918               struct Lisp_Vector *v = XVECTOR (dv);
 5919 
 5920               /* Return the first character from the display table
 5921                  entry, if not empty.  If empty, don't display the
 5922                  current character.  */
 5923               if (v->size)
 5924                 {
 5925                   it->dpvec_char_len = it->len;
 5926                   it->dpvec = v->contents;
 5927                   it->dpend = v->contents + v->size;
 5928                   it->current.dpvec_index = 0;
 5929                   it->dpvec_face_id = -1;
 5930                   it->saved_face_id = it->face_id;
 5931                   it->method = GET_FROM_DISPLAY_VECTOR;
 5932                   it->ellipsis_p = 0;
 5933                 }
 5934               else
 5935                 {
 5936                   set_iterator_to_next (it, 0);
 5937                 }
 5938               goto get_next;
 5939             }
 5940 
 5941           if (unibyte_display_via_language_environment
 5942               && !ASCII_CHAR_P (it->c))
 5943             decoded = DECODE_CHAR (unibyte, it->c);
 5944 
 5945           if (it->c >= 0x80 && ! NILP (Vnobreak_char_display))
 5946             {
 5947               if (it->multibyte_p)
 5948                 nbsp_or_shy = (it->c == 0xA0   ? char_is_nbsp
 5949                                : it->c == 0xAD ? char_is_soft_hyphen
 5950                                :                 char_is_other);
 5951               else if (unibyte_display_via_language_environment)
 5952                 nbsp_or_shy = (decoded == 0xA0   ? char_is_nbsp
 5953                                : decoded == 0xAD ? char_is_soft_hyphen
 5954                                :                   char_is_other);
 5955             }
 5956 
 5957           /* Translate control characters into `\003' or `^C' form.
 5958              Control characters coming from a display table entry are
 5959              currently not translated because we use IT->dpvec to hold
 5960              the translation.  This could easily be changed but I
 5961              don't believe that it is worth doing.
 5962 
 5963              If it->multibyte_p is nonzero, non-printable non-ASCII
 5964              characters are also translated to octal form.
 5965 
 5966              If it->multibyte_p is zero, eight-bit characters that
 5967              don't have corresponding multibyte char code are also
 5968              translated to octal form.  */
 5969           if ((it->c < ' '
 5970                ? (it->area != TEXT_AREA
 5971                   /* In mode line, treat \n, \t like other crl chars.  */
 5972                   || (it->c != '\t'
 5973                       && it->glyph_row
 5974                       && (it->glyph_row->mode_line_p || it->avoid_cursor_p))
 5975                   || (it->c != '\n' && it->c != '\t'))
 5976                : (nbsp_or_shy
 5977                   || (it->multibyte_p
 5978                       ? ! CHAR_PRINTABLE_P (it->c)
 5979                       : (! unibyte_display_via_language_environment
 5980                          ? it->c >= 0x80
 5981                          : (decoded >= 0x80 && decoded < 0xA0))))))
 5982             {
 5983               /* IT->c is a control character which must be displayed
 5984                  either as '\003' or as `^C' where the '\\' and '^'
 5985                  can be defined in the display table.  Fill
 5986                  IT->ctl_chars with glyphs for what we have to
 5987                  display.  Then, set IT->dpvec to these glyphs.  */
 5988               Lisp_Object gc;
 5989               int ctl_len;
 5990               int face_id, lface_id = 0 ;
 5991               int escape_glyph;
 5992 
 5993               /* Handle control characters with ^.  */
 5994 
 5995               if (it->c < 128 && it->ctl_arrow_p)
 5996                 {
 5997                   int g;
 5998 
 5999                   g = '^';           /* default glyph for Control */
 6000                   /* Set IT->ctl_chars[0] to the glyph for `^'.  */
 6001                   if (it->dp
 6002                       && (gc = DISP_CTRL_GLYPH (it->dp), GLYPH_CODE_P (gc))
 6003                       && GLYPH_CODE_CHAR_VALID_P (gc))
 6004                     {
 6005                       g = GLYPH_CODE_CHAR (gc);
 6006                       lface_id = GLYPH_CODE_FACE (gc);
 6007                     }
 6008                   if (lface_id)
 6009                     {
 6010                       face_id = merge_faces (it->f, Qt, lface_id, it->face_id);
 6011                     }
 6012                   else if (it->f == last_escape_glyph_frame
 6013                            && it->face_id == last_escape_glyph_face_id)
 6014                     {
 6015                       face_id = last_escape_glyph_merged_face_id;
 6016                     }
 6017                   else
 6018                     {
 6019                       /* Merge the escape-glyph face into the current face.  */
 6020                       face_id = merge_faces (it->f, Qescape_glyph, 0,
 6021                                              it->face_id);
 6022                       last_escape_glyph_frame = it->f;
 6023                       last_escape_glyph_face_id = it->face_id;
 6024                       last_escape_glyph_merged_face_id = face_id;
 6025                     }
 6026 
 6027                   XSETINT (it->ctl_chars[0], g);
 6028                   XSETINT (it->ctl_chars[1], it->c ^ 0100);
 6029                   ctl_len = 2;
 6030                   goto display_control;
 6031                 }
 6032 
 6033               /* Handle non-break space in the mode where it only gets
 6034                  highlighting.  */
 6035 
 6036               if (EQ (Vnobreak_char_display, Qt)
 6037                   && nbsp_or_shy == char_is_nbsp)
 6038                 {
 6039                   /* Merge the no-break-space face into the current face.  */
 6040                   face_id = merge_faces (it->f, Qnobreak_space, 0,
 6041                                          it->face_id);
 6042 
 6043                   it->c = ' ';
 6044                   XSETINT (it->ctl_chars[0], ' ');
 6045                   ctl_len = 1;
 6046                   goto display_control;
 6047                 }
 6048 
 6049               /* Handle sequences that start with the "escape glyph".  */
 6050 
 6051               /* the default escape glyph is \.  */
 6052               escape_glyph = '\\';
 6053 
 6054               if (it->dp
 6055                   && (gc = DISP_ESCAPE_GLYPH (it->dp), GLYPH_CODE_P (gc))
 6056                   && GLYPH_CODE_CHAR_VALID_P (gc))
 6057                 {
 6058                   escape_glyph = GLYPH_CODE_CHAR (gc);
 6059                   lface_id = GLYPH_CODE_FACE (gc);
 6060                 }
 6061               if (lface_id)
 6062                 {
 6063                   /* The display table specified a face.
 6064                      Merge it into face_id and also into escape_glyph.  */
 6065                   face_id = merge_faces (it->f, Qt, lface_id,
 6066                                          it->face_id);
 6067                 }
 6068               else if (it->f == last_escape_glyph_frame
 6069                        && it->face_id == last_escape_glyph_face_id)
 6070                 {
 6071                   face_id = last_escape_glyph_merged_face_id;
 6072                 }
 6073               else
 6074                 {
 6075                   /* Merge the escape-glyph face into the current face.  */
 6076                   face_id = merge_faces (it->f, Qescape_glyph, 0,
 6077                                          it->face_id);
 6078                   last_escape_glyph_frame = it->f;
 6079                   last_escape_glyph_face_id = it->face_id;
 6080                   last_escape_glyph_merged_face_id = face_id;
 6081                 }
 6082 
 6083               /* Handle soft hyphens in the mode where they only get
 6084                  highlighting.  */
 6085 
 6086               if (EQ (Vnobreak_char_display, Qt)
 6087                   && nbsp_or_shy == char_is_soft_hyphen)
 6088                 {
 6089                   it->c = '-';
 6090                   XSETINT (it->ctl_chars[0], '-');
 6091                   ctl_len = 1;
 6092                   goto display_control;
 6093                 }
 6094 
 6095               /* Handle non-break space and soft hyphen
 6096                  with the escape glyph.  */
 6097 
 6098               if (nbsp_or_shy)
 6099                 {
 6100                   XSETINT (it->ctl_chars[0], escape_glyph);
 6101                   it->c = (nbsp_or_shy == char_is_nbsp ? ' ' : '-');
 6102                   XSETINT (it->ctl_chars[1], it->c);
 6103                   ctl_len = 2;
 6104                   goto display_control;
 6105                 }
 6106 
 6107               {
 6108                 unsigned char str[MAX_MULTIBYTE_LENGTH];
 6109                 int len;
 6110                 int i;
 6111 
 6112                 /* Set IT->ctl_chars[0] to the glyph for `\\'.  */
 6113                 if (CHAR_BYTE8_P (it->c))
 6114                   {
 6115                     str[0] = CHAR_TO_BYTE8 (it->c);
 6116                     len = 1;
 6117                   }
 6118                 else if (it->c < 256)
 6119                   {
 6120                     str[0] = it->c;
 6121                     len = 1;
 6122                   }
 6123                 else
 6124                   {
 6125                     /* It's an invalid character, which shouldn't
 6126                        happen actually, but due to bugs it may
 6127                        happen.  Let's print the char as is, there's
 6128                        not much meaningful we can do with it.  */
 6129                     str[0] = it->c;
 6130                     str[1] = it->c >> 8;
 6131                     str[2] = it->c >> 16;
 6132                     str[3] = it->c >> 24;
 6133                     len = 4;
 6134                   }
 6135 
 6136                 for (i = 0; i < len; i++)
 6137                   {
 6138                     int g;
 6139                     XSETINT (it->ctl_chars[i * 4], escape_glyph);
 6140                     /* Insert three more glyphs into IT->ctl_chars for
 6141                        the octal display of the character.  */
 6142                     g = ((str[i] >> 6) & 7) + '0';
 6143                     XSETINT (it->ctl_chars[i * 4 + 1], g);
 6144                     g = ((str[i] >> 3) & 7) + '0';
 6145                     XSETINT (it->ctl_chars[i * 4 + 2], g);
 6146                     g = (str[i] & 7) + '0';
 6147                     XSETINT (it->ctl_chars[i * 4 + 3], g);
 6148                   }
 6149                 ctl_len = len * 4;
 6150               }
 6151 
 6152             display_control:
 6153               /* Set up IT->dpvec and return first character from it.  */
 6154               it->dpvec_char_len = it->len;
 6155               it->dpvec = it->ctl_chars;
 6156               it->dpend = it->dpvec + ctl_len;
 6157               it->current.dpvec_index = 0;
 6158               it->dpvec_face_id = face_id;
 6159               it->saved_face_id = it->face_id;
 6160               it->method = GET_FROM_DISPLAY_VECTOR;
 6161               it->ellipsis_p = 0;
 6162               goto get_next;
 6163             }
 6164         }
 6165     }
 6166 
 6167 #ifdef HAVE_WINDOW_SYSTEM
 6168   /* Adjust face id for a multibyte character.  There are no multibyte
 6169      character in unibyte text.  */
 6170   if ((it->what == IT_CHARACTER || it->what == IT_COMPOSITION)
 6171       && it->multibyte_p
 6172       && success_p
 6173       && FRAME_WINDOW_P (it->f))
 6174     {
 6175       struct face *face = FACE_FROM_ID (it->f, it->face_id);
 6176 
 6177       if (it->what == IT_COMPOSITION && it->cmp_it.ch >= 0)
 6178         {
 6179           /* Automatic composition with glyph-string.   */
 6180           Lisp_Object gstring = composition_gstring_from_id (it->cmp_it.id);
 6181 
 6182           it->face_id = face_for_font (it->f, LGSTRING_FONT (gstring), face);
 6183         }
 6184       else
 6185         {
 6186           int pos = (it->s ? -1
 6187                      : STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
 6188                      : IT_CHARPOS (*it));
 6189 
 6190           it->face_id = FACE_FOR_CHAR (it->f, face, it->c, pos, it->string);
 6191         }
 6192     }
 6193 #endif
 6194 
 6195   /* Is this character the last one of a run of characters with
 6196      box?  If yes, set IT->end_of_box_run_p to 1.  */
 6197   if (it->face_box_p
 6198       && it->s == NULL)
 6199     {
 6200       if (it->method == GET_FROM_STRING && it->sp)
 6201         {
 6202           int face_id = underlying_face_id (it);
 6203           struct face *face = FACE_FROM_ID (it->f, face_id);
 6204 
 6205           if (face)
 6206             {
 6207               if (face->box == FACE_NO_BOX)
 6208                 {
 6209                   /* If the box comes from face properties in a
 6210                      display string, check faces in that string.  */
 6211                   int string_face_id = face_after_it_pos (it);
 6212                   it->end_of_box_run_p
 6213                     = (FACE_FROM_ID (it->f, string_face_id)->box
 6214                        == FACE_NO_BOX);
 6215                 }
 6216               /* Otherwise, the box comes from the underlying face.
 6217                  If this is the last string character displayed, check
 6218                  the next buffer location.  */
 6219               else if ((IT_STRING_CHARPOS (*it) >= SCHARS (it->string) - 1)
 6220                        && (it->current.overlay_string_index
 6221                            == it->n_overlay_strings - 1))
 6222                 {
 6223                   EMACS_INT ignore;
 6224                   int next_face_id;
 6225                   struct text_pos pos = it->current.pos;
 6226                   INC_TEXT_POS (pos, it->multibyte_p);
 6227 
 6228                   next_face_id = face_at_buffer_position
 6229                     (it->w, CHARPOS (pos), it->region_beg_charpos,
 6230                      it->region_end_charpos, &ignore,
 6231                      (IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT), 0,
 6232                      -1);
 6233                   it->end_of_box_run_p
 6234                     = (FACE_FROM_ID (it->f, next_face_id)->box
 6235                        == FACE_NO_BOX);
 6236                 }
 6237             }
 6238         }
 6239       else
 6240         {
 6241           int face_id = face_after_it_pos (it);
 6242           it->end_of_box_run_p
 6243             = (face_id != it->face_id
 6244                && FACE_FROM_ID (it->f, face_id)->box == FACE_NO_BOX);
 6245         }
 6246     }
 6247 
 6248   /* Value is 0 if end of buffer or string reached.  */
 6249   return success_p;
 6250 }
 6251 
 6252 
 6253 /* Move IT to the next display element.
 6254 
 6255    RESEAT_P non-zero means if called on a newline in buffer text,
 6256    skip to the next visible line start.
 6257 
 6258    Functions get_next_display_element and set_iterator_to_next are
 6259    separate because I find this arrangement easier to handle than a
 6260    get_next_display_element function that also increments IT's
 6261    position.  The way it is we can first look at an iterator's current
 6262    display element, decide whether it fits on a line, and if it does,
 6263    increment the iterator position.  The other way around we probably
 6264    would either need a flag indicating whether the iterator has to be
 6265    incremented the next time, or we would have to implement a
 6266    decrement position function which would not be easy to write.  */
 6267 
 6268 void
 6269 set_iterator_to_next (it, reseat_p)
 6270      struct it *it;
 6271      int reseat_p;
 6272 {
 6273   /* Reset flags indicating start and end of a sequence of characters
 6274      with box.  Reset them at the start of this function because
 6275      moving the iterator to a new position might set them.  */
 6276   it->start_of_box_run_p = it->end_of_box_run_p = 0;
 6277 
 6278   switch (it->method)
 6279     {
 6280     case GET_FROM_BUFFER:
 6281       /* The current display element of IT is a character from
 6282          current_buffer.  Advance in the buffer, and maybe skip over
 6283          invisible lines that are so because of selective display.  */
 6284       if (ITERATOR_AT_END_OF_LINE_P (it) && reseat_p)
 6285         reseat_at_next_visible_line_start (it, 0);
 6286       else if (it->cmp_it.id >= 0)
 6287         {
 6288           /* We are currently getting glyphs from a composition.  */
 6289           int i;
 6290 
 6291           if (! it->bidi_p)
 6292             {
 6293               IT_CHARPOS (*it) += it->cmp_it.nchars;
 6294               IT_BYTEPOS (*it) += it->cmp_it.nbytes;
 6295               if (it->cmp_it.to < it->cmp_it.nglyphs)
 6296                 {
 6297                   it->cmp_it.from = it->cmp_it.to;
 6298                 }
 6299               else
 6300                 {
 6301                   it->cmp_it.id = -1;
 6302                   composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
 6303                                                 IT_BYTEPOS (*it),
 6304                                                 it->stop_charpos, Qnil);
 6305                 }
 6306             }
 6307           else if (! it->cmp_it.reversed_p)
 6308             {
 6309               /* Composition created while scanning forward.  */
 6310               /* Update IT's char/byte positions to point to the first
 6311                  character of the next grapheme cluster, or to the
 6312                  character visually after the current composition.  */
 6313               for (i = 0; i < it->cmp_it.nchars; i++)
 6314                 bidi_move_to_visually_next (&it->bidi_it);
 6315               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
 6316               IT_CHARPOS (*it) = it->bidi_it.charpos;
 6317 
 6318               if (it->cmp_it.to < it->cmp_it.nglyphs)
 6319                 {
 6320                   /* Proceed to the next grapheme cluster.  */
 6321                   it->cmp_it.from = it->cmp_it.to;
 6322                 }
 6323               else
 6324                 {
 6325                   /* No more grapheme clusters in this composition.
 6326                      Find the next stop position.  */
 6327                   EMACS_INT stop = it->stop_charpos;
 6328                   if (it->bidi_it.scan_dir < 0)
 6329                     /* Now we are scanning backward and don't know
 6330                        where to stop.  */
 6331                     stop = -1;
 6332                   composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
 6333                                                 IT_BYTEPOS (*it), stop, Qnil);
 6334                 }
 6335             }
 6336           else
 6337             {
 6338               /* Composition created while scanning backward.  */
 6339               /* Update IT's char/byte positions to point to the last
 6340                  character of the previous grapheme cluster, or the
 6341                  character visually after the current composition.  */
 6342               for (i = 0; i < it->cmp_it.nchars; i++)
 6343                 bidi_move_to_visually_next (&it->bidi_it);
 6344               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
 6345               IT_CHARPOS (*it) = it->bidi_it.charpos;
 6346               if (it->cmp_it.from > 0)
 6347                 {
 6348                   /* Proceed to the previous grapheme cluster.  */
 6349                   it->cmp_it.to = it->cmp_it.from;
 6350                 }
 6351               else
 6352                 {
 6353                   /* No more grapheme clusters in this composition.
 6354                      Find the next stop position.  */
 6355                   EMACS_INT stop = it->stop_charpos;
 6356                   if (it->bidi_it.scan_dir < 0)
 6357                     /* Now we are scanning backward and don't know
 6358                        where to stop.  */
 6359                     stop = -1;
 6360                   composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
 6361                                                 IT_BYTEPOS (*it), stop, Qnil);
 6362                 }
 6363             }
 6364         }
 6365       else
 6366         {
 6367           xassert (it->len != 0);
 6368 
 6369           if (!it->bidi_p)
 6370             {
 6371               IT_BYTEPOS (*it) += it->len;
 6372               IT_CHARPOS (*it) += 1;
 6373             }
 6374           else
 6375             {
 6376               int prev_scan_dir = it->bidi_it.scan_dir;
 6377               /* If this is a new paragraph, determine its base
 6378                  direction (a.k.a. its base embedding level).  */
 6379               if (it->bidi_it.new_paragraph)
 6380                 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
 6381               bidi_move_to_visually_next (&it->bidi_it);
 6382               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
 6383               IT_CHARPOS (*it) = it->bidi_it.charpos;
 6384               if (prev_scan_dir != it->bidi_it.scan_dir)
 6385                 {
 6386                   /* As the scan direction was changed, we must
 6387                      re-compute the stop position for composition.  */
 6388                   EMACS_INT stop = it->stop_charpos;
 6389                   if (it->bidi_it.scan_dir < 0)
 6390                     stop = -1;
 6391                   composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
 6392                                                 IT_BYTEPOS (*it), stop, Qnil);
 6393                 }
 6394             }
 6395           xassert (IT_BYTEPOS (*it) == CHAR_TO_BYTE (IT_CHARPOS (*it)));
 6396         }
 6397       break;
 6398 
 6399     case GET_FROM_C_STRING:
 6400       /* Current display element of IT is from a C string.  */
 6401       IT_BYTEPOS (*it) += it->len;
 6402       IT_CHARPOS (*it) += 1;
 6403       break;
 6404 
 6405     case GET_FROM_DISPLAY_VECTOR:
 6406       /* Current display element of IT is from a display table entry.
 6407          Advance in the display table definition.  Reset it to null if
 6408          end reached, and continue with characters from buffers/
 6409          strings.  */
 6410       ++it->current.dpvec_index;
 6411 
 6412       /* Restore face of the iterator to what they were before the
 6413          display vector entry (these entries may contain faces).  */
 6414       it->face_id = it->saved_face_id;
 6415 
 6416       if (it->dpvec + it->current.dpvec_index == it->dpend)
 6417         {
 6418           int recheck_faces = it->ellipsis_p;
 6419 
 6420           if (it->s)
 6421             it->method = GET_FROM_C_STRING;
 6422           else if (STRINGP (it->string))
 6423             it->method = GET_FROM_STRING;
 6424           else
 6425             {
 6426               it->method = GET_FROM_BUFFER;
 6427               it->object = it->w->buffer;
 6428             }
 6429 
 6430           it->dpvec = NULL;
 6431           it->current.dpvec_index = -1;
 6432 
 6433           /* Skip over characters which were displayed via IT->dpvec.  */
 6434           if (it->dpvec_char_len < 0)
 6435             reseat_at_next_visible_line_start (it, 1);
 6436           else if (it->dpvec_char_len > 0)
 6437             {
 6438               if (it->method == GET_FROM_STRING
 6439                   && it->n_overlay_strings > 0)
 6440                 it->ignore_overlay_strings_at_pos_p = 1;
 6441               it->len = it->dpvec_char_len;
 6442               set_iterator_to_next (it, reseat_p);
 6443             }
 6444 
 6445           /* Maybe recheck faces after display vector */
 6446           if (recheck_faces)
 6447             it->stop_charpos = IT_CHARPOS (*it);
 6448         }
 6449       break;
 6450 
 6451     case GET_FROM_STRING:
 6452       /* Current display element is a character from a Lisp string.  */
 6453       xassert (it->s == NULL && STRINGP (it->string));
 6454       if (it->cmp_it.id >= 0)
 6455         {
 6456           IT_STRING_CHARPOS (*it) += it->cmp_it.nchars;
 6457           IT_STRING_BYTEPOS (*it) += it->cmp_it.nbytes;
 6458           if (it->cmp_it.to < it->cmp_it.nglyphs)
 6459             it->cmp_it.from = it->cmp_it.to;
 6460           else
 6461             {
 6462               it->cmp_it.id = -1;
 6463               composition_compute_stop_pos (&it->cmp_it,
 6464                                             IT_STRING_CHARPOS (*it),
 6465                                             IT_STRING_BYTEPOS (*it),
 6466                                             it->stop_charpos, it->string);
 6467             }
 6468         }
 6469       else
 6470         {
 6471           IT_STRING_BYTEPOS (*it) += it->len;
 6472           IT_STRING_CHARPOS (*it) += 1;
 6473         }
 6474 
 6475     consider_string_end:
 6476 
 6477       if (it->current.overlay_string_index >= 0)
 6478         {
 6479           /* IT->string is an overlay string.  Advance to the
 6480              next, if there is one.  */
 6481           if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
 6482             {
 6483               it->ellipsis_p = 0;
 6484               next_overlay_string (it);
 6485               if (it->ellipsis_p)
 6486                 setup_for_ellipsis (it, 0);
 6487             }
 6488         }
 6489       else
 6490         {
 6491           /* IT->string is not an overlay string.  If we reached
 6492              its end, and there is something on IT->stack, proceed
 6493              with what is on the stack.  This can be either another
 6494              string, this time an overlay string, or a buffer.  */
 6495           if (IT_STRING_CHARPOS (*it) == SCHARS (it->string)
 6496               && it->sp > 0)
 6497             {
 6498               pop_it (it);
 6499               if (it->method == GET_FROM_STRING)
 6500                 goto consider_string_end;
 6501             }
 6502         }
 6503       break;
 6504 
 6505     case GET_FROM_IMAGE:
 6506     case GET_FROM_STRETCH:
 6507       /* The position etc with which we have to proceed are on
 6508          the stack.  The position may be at the end of a string,
 6509          if the `display' property takes up the whole string.  */
 6510       xassert (it->sp > 0);
 6511       pop_it (it);
 6512       if (it->method == GET_FROM_STRING)
 6513         goto consider_string_end;
 6514       break;
 6515 
 6516     default:
 6517       /* There are no other methods defined, so this should be a bug.  */
 6518       abort ();
 6519     }
 6520 
 6521   xassert (it->method != GET_FROM_STRING
 6522            || (STRINGP (it->string)
 6523                && IT_STRING_CHARPOS (*it) >= 0));
 6524 }
 6525 
 6526 /* Load IT's display element fields with information about the next
 6527    display element which comes from a display table entry or from the
 6528    result of translating a control character to one of the forms `^C'
 6529    or `\003'.
 6530 
 6531    IT->dpvec holds the glyphs to return as characters.
 6532    IT->saved_face_id holds the face id before the display vector--it
 6533    is restored into IT->face_id in set_iterator_to_next.  */
 6534 
 6535 static int
 6536 next_element_from_display_vector (it)
 6537      struct it *it;
 6538 {
 6539   Lisp_Object gc;
 6540 
 6541   /* Precondition.  */
 6542   xassert (it->dpvec && it->current.dpvec_index >= 0);
 6543 
 6544   it->face_id = it->saved_face_id;
 6545 
 6546   /* KFS: This code used to check ip->dpvec[0] instead of the current element.
 6547      That seemed totally bogus - so I changed it...  */
 6548   gc = it->dpvec[it->current.dpvec_index];
 6549 
 6550   if (GLYPH_CODE_P (gc) && GLYPH_CODE_CHAR_VALID_P (gc))
 6551     {
 6552       it->c = GLYPH_CODE_CHAR (gc);
 6553       it->len = CHAR_BYTES (it->c);
 6554 
 6555       /* The entry may contain a face id to use.  Such a face id is
 6556          the id of a Lisp face, not a realized face.  A face id of
 6557          zero means no face is specified.  */
 6558       if (it->dpvec_face_id >= 0)
 6559         it->face_id = it->dpvec_face_id;
 6560       else
 6561         {
 6562           int lface_id = GLYPH_CODE_FACE (gc);
 6563           if (lface_id > 0)
 6564             it->face_id = merge_faces (it->f, Qt, lface_id,
 6565                                        it->saved_face_id);
 6566         }
 6567     }
 6568   else
 6569     /* Display table entry is invalid.  Return a space.  */
 6570     it->c = ' ', it->len = 1;
 6571 
 6572   /* Don't change position and object of the iterator here.  They are
 6573      still the values of the character that had this display table
 6574      entry or was translated, and that's what we want.  */
 6575   it->what = IT_CHARACTER;
 6576   return 1;
 6577 }
 6578 
 6579 
 6580 /* Load IT with the next display element from Lisp string IT->string.
 6581    IT->current.string_pos is the current position within the string.
 6582    If IT->current.overlay_string_index >= 0, the Lisp string is an
 6583    overlay string.  */
 6584 
 6585 static int
 6586 next_element_from_string (it)
 6587      struct it *it;
 6588 {
 6589   struct text_pos position;
 6590 
 6591   xassert (STRINGP (it->string));
 6592   xassert (IT_STRING_CHARPOS (*it) >= 0);
 6593   position = it->current.string_pos;
 6594 
 6595   /* Time to check for invisible text?  */
 6596   if (IT_STRING_CHARPOS (*it) < it->end_charpos
 6597       && IT_STRING_CHARPOS (*it) == it->stop_charpos)
 6598     {
 6599       handle_stop (it);
 6600 
 6601       /* Since a handler may have changed IT->method, we must
 6602          recurse here.  */
 6603       return GET_NEXT_DISPLAY_ELEMENT (it);
 6604     }
 6605 
 6606   if (it->current.overlay_string_index >= 0)
 6607     {
 6608       /* Get the next character from an overlay string.  In overlay
 6609          strings, There is no field width or padding with spaces to
 6610          do.  */
 6611       if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
 6612         {
 6613           it->what = IT_EOB;
 6614           return 0;
 6615         }
 6616       else if (CHAR_COMPOSED_P (it, IT_STRING_CHARPOS (*it),
 6617                                 IT_STRING_BYTEPOS (*it), SCHARS (it->string))
 6618                && next_element_from_composition (it))
 6619         {
 6620           return 1;
 6621         }
 6622       else if (STRING_MULTIBYTE (it->string))
 6623         {
 6624           int remaining = SBYTES (it->string) - IT_STRING_BYTEPOS (*it);
 6625           const unsigned char *s = (SDATA (it->string)
 6626                                     + IT_STRING_BYTEPOS (*it));
 6627           it->c = string_char_and_length (s, &it->len);
 6628         }
 6629       else
 6630         {
 6631           it->c = SREF (it->string, IT_STRING_BYTEPOS (*it));
 6632           it->len = 1;
 6633         }
 6634     }
 6635   else
 6636     {
 6637       /* Get the next character from a Lisp string that is not an
 6638          overlay string.  Such strings come from the mode line, for
 6639          example.  We may have to pad with spaces, or truncate the
 6640          string.  See also next_element_from_c_string.  */
 6641       if (IT_STRING_CHARPOS (*it) >= it->end_charpos)
 6642         {
 6643           it->what = IT_EOB;
 6644           return 0;
 6645         }
 6646       else if (IT_STRING_CHARPOS (*it) >= it->string_nchars)
 6647         {
 6648           /* Pad with spaces.  */
 6649           it->c = ' ', it->len = 1;
 6650           CHARPOS (position) = BYTEPOS (position) = -1;
 6651         }
 6652       else if (CHAR_COMPOSED_P (it, IT_STRING_CHARPOS (*it),
 6653                                 IT_STRING_BYTEPOS (*it), it->string_nchars)
 6654                && next_element_from_composition (it))
 6655         {
 6656           return 1;
 6657         }
 6658       else if (STRING_MULTIBYTE (it->string))
 6659         {
 6660           int maxlen = SBYTES (it->string) - IT_STRING_BYTEPOS (*it);
 6661           const unsigned char *s = (SDATA (it->string)
 6662                                     + IT_STRING_BYTEPOS (*it));
 6663           it->c = string_char_and_length (s, &it->len);
 6664         }
 6665       else
 6666         {
 6667           it->c = SREF (it->string, IT_STRING_BYTEPOS (*it));
 6668           it->len = 1;
 6669         }
 6670     }
 6671 
 6672   /* Record what we have and where it came from.  */
 6673   it->what = IT_CHARACTER;
 6674   it->object = it->string;
 6675   it->position = position;
 6676   return 1;
 6677 }
 6678 
 6679 
 6680 /* Load IT with next display element from C string IT->s.
 6681    IT->string_nchars is the maximum number of characters to return
 6682    from the string.  IT->end_charpos may be greater than
 6683    IT->string_nchars when this function is called, in which case we
 6684    may have to return padding spaces.  Value is zero if end of string
 6685    reached, including padding spaces.  */
 6686 
 6687 static int
 6688 next_element_from_c_string (it)
 6689      struct it *it;
 6690 {
 6691   int success_p = 1;
 6692 
 6693   xassert (it->s);
 6694   it->what = IT_CHARACTER;
 6695   BYTEPOS (it->position) = CHARPOS (it->position) = 0;
 6696   it->object = Qnil;
 6697 
 6698   /* IT's position can be greater IT->string_nchars in case a field
 6699      width or precision has been specified when the iterator was
 6700      initialized.  */
 6701   if (IT_CHARPOS (*it) >= it->end_charpos)
 6702     {
 6703       /* End of the game.  */
 6704       it->what = IT_EOB;
 6705       success_p = 0;
 6706     }
 6707   else if (IT_CHARPOS (*it) >= it->string_nchars)
 6708     {
 6709       /* Pad with spaces.  */
 6710       it->c = ' ', it->len = 1;
 6711       BYTEPOS (it->position) = CHARPOS (it->position) = -1;
 6712     }
 6713   else if (it->multibyte_p)
 6714     {
 6715       /* Implementation note: The calls to strlen apparently aren't a
 6716          performance problem because there is no noticeable performance
 6717          difference between Emacs running in unibyte or multibyte mode.  */
 6718       int maxlen = strlen (it->s) - IT_BYTEPOS (*it);
 6719       it->c = string_char_and_length (it->s + IT_BYTEPOS (*it), &it->len);
 6720     }
 6721   else
 6722     it->c = it->s[IT_BYTEPOS (*it)], it->len = 1;
 6723 
 6724   return success_p;
 6725 }
 6726 
 6727 
 6728 /* Set up IT to return characters from an ellipsis, if appropriate.
 6729    The definition of the ellipsis glyphs may come from a display table
 6730    entry.  This function fills IT with the first glyph from the
 6731    ellipsis if an ellipsis is to be displayed.  */
 6732 
 6733 static int
 6734 next_element_from_ellipsis (it)
 6735      struct it *it;
 6736 {
 6737   if (it->selective_display_ellipsis_p)
 6738     setup_for_ellipsis (it, it->len);
 6739   else
 6740     {
 6741       /* The face at the current position may be different from the
 6742          face we find after the invisible text.  Remember what it
 6743          was in IT->saved_face_id, and signal that it's there by
 6744          setting face_before_selective_p.  */
 6745       it->saved_face_id = it->face_id;
 6746       it->method = GET_FROM_BUFFER;
 6747       it->object = it->w->buffer;
 6748       reseat_at_next_visible_line_start (it, 1);
 6749       it->face_before_selective_p = 1;
 6750     }
 6751 
 6752   return GET_NEXT_DISPLAY_ELEMENT (it);
 6753 }
 6754 
 6755 
 6756 /* Deliver an image display element.  The iterator IT is already
 6757    filled with image information (done in handle_display_prop).  Value
 6758    is always 1.  */
 6759 
 6760 
 6761 static int
 6762 next_element_from_image (it)
 6763      struct it *it;
 6764 {
 6765   it->what = IT_IMAGE;
 6766   return 1;
 6767 }
 6768 
 6769 
 6770 /* Fill iterator IT with next display element from a stretch glyph
 6771    property.  IT->object is the value of the text property.  Value is
 6772    always 1.  */
 6773 
 6774 static int
 6775 next_element_from_stretch (it)
 6776      struct it *it;
 6777 {
 6778   it->what = IT_STRETCH;
 6779   return 1;
 6780 }
 6781 
 6782 /* Scan forward from CHARPOS in the current buffer, until we find a
 6783    stop position > current IT's position.  Then handle the stop
 6784    position before that.  This is called when we bump into a stop
 6785    position while reordering bidirectional text.  CHARPOS should be
 6786    the last previously processed stop_pos (or BEGV, if none were
 6787    processed yet) whose position is less that IT's current
 6788    position.  */
 6789 
 6790 static void
 6791 handle_stop_backwards (it, charpos)
 6792      struct it *it;
 6793      EMACS_INT charpos;
 6794 {
 6795   EMACS_INT where_we_are = IT_CHARPOS (*it);
 6796   struct display_pos save_current = it->current;
 6797   struct text_pos save_position = it->position;
 6798   struct text_pos pos1;
 6799   EMACS_INT next_stop;
 6800 
 6801   /* Scan in strict logical order.  */
 6802   it->bidi_p = 0;
 6803   do
 6804     {
 6805       it->prev_stop = charpos;
 6806       SET_TEXT_POS (pos1, charpos, CHAR_TO_BYTE (charpos));
 6807       reseat_1 (it, pos1, 0);
 6808       compute_stop_pos (it);
 6809       /* We must advance forward, right?  */
 6810       if (it->stop_charpos <= it->prev_stop)
 6811         abort ();
 6812       charpos = it->stop_charpos;
 6813     }
 6814   while (charpos <= where_we_are);
 6815 
 6816   next_stop = it->stop_charpos;
 6817   it->stop_charpos = it->prev_stop;
 6818   it->bidi_p = 1;
 6819   it->current = save_current;
 6820   it->position = save_position;
 6821   handle_stop (it);
 6822   it->stop_charpos = next_stop;
 6823 }
 6824 
 6825 /* Load IT with the next display element from current_buffer.  Value
 6826    is zero if end of buffer reached.  IT->stop_charpos is the next
 6827    position at which to stop and check for text properties or buffer
 6828    end.  */
 6829 
 6830 static int
 6831 next_element_from_buffer (it)
 6832      struct it *it;
 6833 {
 6834   int success_p = 1;
 6835 
 6836   xassert (IT_CHARPOS (*it) >= BEGV);
 6837 
 6838   /* With bidi reordering, the character to display might not be the
 6839      character at IT_CHARPOS.  BIDI_IT.FIRST_ELT non-zero means that
 6840      we were reseat()ed to a new buffer position, which is potentially
 6841      a different paragraph.  */
 6842   if (it->bidi_p && it->bidi_it.first_elt)
 6843     {
 6844       it->bidi_it.charpos = IT_CHARPOS (*it);
 6845       it->bidi_it.bytepos = IT_BYTEPOS (*it);
 6846       if (it->bidi_it.bytepos == ZV_BYTE)
 6847         {
 6848           /* Nothing to do, but reset the FIRST_ELT flag, like
 6849              bidi_paragraph_init does, because we are not going to
 6850              call it.  */
 6851           it->bidi_it.first_elt = 0;
 6852         }
 6853       else if (it->bidi_it.bytepos == BEGV_BYTE
 6854           /* FIXME: Should support all Unicode line separators.  */
 6855           || FETCH_CHAR (it->bidi_it.bytepos - 1) == '\n'
 6856           || FETCH_CHAR (it->bidi_it.bytepos) == '\n')
 6857         {
 6858           /* If we are at the beginning of a line, we can produce the
 6859              next element right away.  */
 6860           bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
 6861           bidi_move_to_visually_next (&it->bidi_it);
 6862         }
 6863       else
 6864         {
 6865           int orig_bytepos = IT_BYTEPOS (*it);
 6866 
 6867           /* We need to prime the bidi iterator starting at the line's
 6868              beginning, before we will be able to produce the next
 6869              element.  */
 6870           IT_CHARPOS (*it) = find_next_newline_no_quit (IT_CHARPOS (*it), -1);
 6871           IT_BYTEPOS (*it) = CHAR_TO_BYTE (IT_CHARPOS (*it));
 6872           it->bidi_it.charpos = IT_CHARPOS (*it);
 6873           it->bidi_it.bytepos = IT_BYTEPOS (*it);
 6874           bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
 6875           do
 6876             {
 6877               /* Now return to buffer position where we were asked to
 6878                  get the next display element, and produce that.  */
 6879               bidi_move_to_visually_next (&it->bidi_it);
 6880             }
 6881           while (it->bidi_it.bytepos != orig_bytepos
 6882                  && it->bidi_it.bytepos < ZV_BYTE);
 6883         }
 6884 
 6885       it->bidi_it.first_elt = 0; /* paranoia: bidi.c does this */
 6886       /*  Adjust IT's position information to where we ended up.  */
 6887       IT_CHARPOS (*it) = it->bidi_it.charpos;
 6888       IT_BYTEPOS (*it) = it->bidi_it.bytepos;
 6889       SET_TEXT_POS (it->position, IT_CHARPOS (*it), IT_BYTEPOS (*it));
 6890       {
 6891         EMACS_INT stop = it->stop_charpos;
 6892         if (it->bidi_it.scan_dir < 0)
 6893           stop = -1;
 6894         composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
 6895                                       IT_BYTEPOS (*it), stop, Qnil);
 6896       }
 6897     }
 6898 
 6899   if (IT_CHARPOS (*it) >= it->stop_charpos)
 6900     {
 6901       if (IT_CHARPOS (*it) >= it->end_charpos)
 6902         {
 6903           int overlay_strings_follow_p;
 6904 
 6905           /* End of the game, except when overlay strings follow that
 6906              haven't been returned yet.  */
 6907           if (it->overlay_strings_at_end_processed_p)
 6908             overlay_strings_follow_p = 0;
 6909           else
 6910             {
 6911               it->overlay_strings_at_end_processed_p = 1;
 6912               overlay_strings_follow_p = get_overlay_strings (it, 0);
 6913             }
 6914 
 6915           if (overlay_strings_follow_p)
 6916             success_p = GET_NEXT_DISPLAY_ELEMENT (it);
 6917           else
 6918             {
 6919               it->what = IT_EOB;
 6920               it->position = it->current.pos;
 6921               success_p = 0;
 6922             }
 6923         }
 6924       else if (!(!it->bidi_p
 6925                  || BIDI_AT_BASE_LEVEL (it->bidi_it)
 6926                  || IT_CHARPOS (*it) == it->stop_charpos))
 6927         {
 6928           /* With bidi non-linear iteration, we could find ourselves
 6929              far beyond the last computed stop_charpos, with several
 6930              other stop positions in between that we missed.  Scan
 6931              them all now, in buffer's logical order, until we find
 6932              and handle the last stop_charpos that precedes our
 6933              current position.  */
 6934           handle_stop_backwards (it, it->stop_charpos);
 6935           return GET_NEXT_DISPLAY_ELEMENT (it);
 6936         }
 6937       else
 6938         {
 6939           if (it->bidi_p)
 6940             {
 6941               /* Take note of the stop position we just moved across,
 6942                  for when we will move back across it.  */
 6943               it->prev_stop = it->stop_charpos;
 6944               /* If we are at base paragraph embedding level, take
 6945                  note of the last stop position seen at this
 6946                  level.  */
 6947               if (BIDI_AT_BASE_LEVEL (it->bidi_it))
 6948                 it->base_level_stop = it->stop_charpos;
 6949             }
 6950           handle_stop (it);
 6951           return GET_NEXT_DISPLAY_ELEMENT (it);
 6952         }
 6953     }
 6954   else if (it->bidi_p
 6955            /* We can sometimes back up for reasons that have nothing
 6956               to do with bidi reordering.  E.g., compositions.  The
 6957               code below is only needed when we are above the base
 6958               embedding level, so test for that explicitly.  */
 6959            && !BIDI_AT_BASE_LEVEL (it->bidi_it)
 6960            && IT_CHARPOS (*it) < it->prev_stop)
 6961     {
 6962       if (it->base_level_stop <= 0)
 6963         it->base_level_stop = BEGV;
 6964       if (IT_CHARPOS (*it) < it->base_level_stop)
 6965         abort ();
 6966       handle_stop_backwards (it, it->base_level_stop);
 6967       return GET_NEXT_DISPLAY_ELEMENT (it);
 6968     }
 6969   else
 6970     {
 6971       /* No face changes, overlays etc. in sight, so just return a
 6972          character from current_buffer.  */
 6973       unsigned char *p;
 6974       EMACS_INT stop;
 6975 
 6976       /* Maybe run the redisplay end trigger hook.  Performance note:
 6977          This doesn't seem to cost measurable time.  */
 6978       if (it->redisplay_end_trigger_charpos
 6979           && it->glyph_row
 6980           && IT_CHARPOS (*it) >= it->redisplay_end_trigger_charpos)
 6981         run_redisplay_end_trigger_hook (it);
 6982 
 6983       stop = it->bidi_it.scan_dir < 0 ? -1 : it->end_charpos;
 6984       if (CHAR_COMPOSED_P (it, IT_CHARPOS (*it), IT_BYTEPOS (*it),
 6985                            stop)
 6986           && next_element_from_composition (it))
 6987         {
 6988           return 1;
 6989         }
 6990 
 6991       /* Get the next character, maybe multibyte.  */
 6992       p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
 6993       if (it->multibyte_p && !ASCII_BYTE_P (*p))
 6994         it->c = STRING_CHAR_AND_LENGTH (p, it->len);
 6995       else
 6996         it->c = *p, it->len = 1;
 6997 
 6998       /* Record what we have and where it came from.  */
 6999       it->what = IT_CHARACTER;
 7000       it->object = it->w->buffer;
 7001       it->position = it->current.pos;
 7002 
 7003       /* Normally we return the character found above, except when we
 7004          really want to return an ellipsis for selective display.  */
 7005       if (it->selective)
 7006         {
 7007           if (it->c == '\n')
 7008             {
 7009               /* A value of selective > 0 means hide lines indented more
 7010                  than that number of columns.  */
 7011               if (it->selective > 0
 7012                   && IT_CHARPOS (*it) + 1 < ZV
 7013                   && indented_beyond_p (IT_CHARPOS (*it) + 1,
 7014                                         IT_BYTEPOS (*it) + 1,
 7015                                         (double) it->selective)) /* iftc */
 7016                 {
 7017                   success_p = next_element_from_ellipsis (it);
 7018                   it->dpvec_char_len = -1;
 7019                 }
 7020             }
 7021           else if (it->c == '\r' && it->selective == -1)
 7022             {
 7023               /* A value of selective == -1 means that everything from the
 7024                  CR to the end of the line is invisible, with maybe an
 7025                  ellipsis displayed for it.  */
 7026               success_p = next_element_from_ellipsis (it);
 7027               it->dpvec_char_len = -1;
 7028             }
 7029         }
 7030     }
 7031 
 7032   /* Value is zero if end of buffer reached.  */
 7033   xassert (!success_p || it->what != IT_CHARACTER || it->len > 0);
 7034   return success_p;
 7035 }
 7036 
 7037 
 7038 /* Run the redisplay end trigger hook for IT.  */
 7039 
 7040 static void
 7041 run_redisplay_end_trigger_hook (it)
 7042      struct it *it;
 7043 {
 7044   Lisp_Object args[3];
 7045 
 7046   /* IT->glyph_row should be non-null, i.e. we should be actually
 7047      displaying something, or otherwise we should not run the hook.  */
 7048   xassert (it->glyph_row);
 7049 
 7050   /* Set up hook arguments.  */
 7051   args[0] = Qredisplay_end_trigger_functions;
 7052   args[1] = it->window;
 7053   XSETINT (args[2], it->redisplay_end_trigger_charpos);
 7054   it->redisplay_end_trigger_charpos = 0;
 7055 
 7056   /* Since we are *trying* to run these functions, don't try to run
 7057      them again, even if they get an error.  */
 7058   it->w->redisplay_end_trigger = Qnil;
 7059   Frun_hook_with_args (3, args);
 7060 
 7061   /* Notice if it changed the face of the character we are on.  */
 7062   handle_face_prop (it);
 7063 }
 7064 
 7065 
 7066 /* Deliver a composition display element.  Unlike the other
 7067    next_element_from_XXX, this function is not registered in the array
 7068    get_next_element[].  It is called from next_element_from_buffer and
 7069    next_element_from_string when necessary.  */
 7070 
 7071 static int
 7072 next_element_from_composition (it)
 7073      struct it *it;
 7074 {
 7075   it->what = IT_COMPOSITION;
 7076   it->len = it->cmp_it.nbytes;
 7077   if (STRINGP (it->string))
 7078     {
 7079       if (it->c < 0)
 7080         {
 7081           IT_STRING_CHARPOS (*it) += it->cmp_it.nchars;
 7082           IT_STRING_BYTEPOS (*it) += it->cmp_it.nbytes;
 7083           return 0;
 7084         }
 7085       it->position = it->current.string_pos;
 7086       it->object = it->string;
 7087       it->c = composition_update_it (&it->cmp_it, IT_STRING_CHARPOS (*it),
 7088                                      IT_STRING_BYTEPOS (*it), it->string);
 7089     }
 7090   else
 7091     {
 7092       if (it->c < 0)
 7093         {
 7094           IT_CHARPOS (*it) += it->cmp_it.nchars;
 7095           IT_BYTEPOS (*it) += it->cmp_it.nbytes;
 7096           if (it->bidi_p)
 7097             {
 7098               if (it->bidi_it.new_paragraph)
 7099                 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it);
 7100               /* Resync the bidi iterator with IT's new position.
 7101                  FIXME: this doesn't support bidirectional text.  */
 7102               while (it->bidi_it.charpos < IT_CHARPOS (*it))
 7103                 bidi_move_to_visually_next (&it->bidi_it);
 7104             }
 7105           return 0;
 7106         }
 7107       it->position = it->current.pos;
 7108       it->object = it->w->buffer;
 7109       it->c = composition_update_it (&it->cmp_it, IT_CHARPOS (*it),
 7110                                      IT_BYTEPOS (*it), Qnil);
 7111     }
 7112   return 1;
 7113 }
 7114 
 7115 
 7116 
 7117 /***********************************************************************
 7118              Moving an iterator without producing glyphs
 7119  ***********************************************************************/
 7120 
 7121 /* Check if iterator is at a position corresponding to a valid buffer
 7122    position after some move_it_ call.  */
 7123 
 7124 #define IT_POS_VALID_AFTER_MOVE_P(it)                   \
 7125   ((it)->method == GET_FROM_STRING                      \
 7126    ? IT_STRING_CHARPOS (*it) == 0                       \
 7127    : 1)
 7128 
 7129 
 7130 /* Move iterator IT to a specified buffer or X position within one
 7131    line on the display without producing glyphs.
 7132 
 7133    OP should be a bit mask including some or all of these bits:
 7134     MOVE_TO_X: Stop upon reaching x-position TO_X.
 7135     MOVE_TO_POS: Stop upon reaching buffer or string position TO_CHARPOS.
 7136    Regardless of OP's value, stop upon reaching the end of the display line.
 7137 
 7138    TO_X is normally a value 0 <= TO_X <= IT->last_visible_x.
 7139    This means, in particular, that TO_X includes window's horizontal
 7140    scroll amount.
 7141 
 7142    The return value has several possible values that
 7143    say what condition caused the scan to stop:
 7144 
 7145    MOVE_POS_MATCH_OR_ZV
 7146      - when TO_POS or ZV was reached.
 7147 
 7148    MOVE_X_REACHED
 7149      -when TO_X was reached before TO_POS or ZV were reached.
 7150 
 7151    MOVE_LINE_CONTINUED
 7152      - when we reached the end of the display area and the line must
 7153      be continued.
 7154 
 7155    MOVE_LINE_TRUNCATED
 7156      - when we reached the end of the display area and the line is
 7157      truncated.
 7158 
 7159    MOVE_NEWLINE_OR_CR
 7160      - when we stopped at a line end, i.e. a newline or a CR and selective
 7161      display is on.  */
 7162 
 7163 static enum move_it_result
 7164 move_it_in_display_line_to (struct it *it,
 7165                             EMACS_INT to_charpos, int to_x,
 7166                             enum move_operation_enum op)
 7167 {
 7168   enum move_it_result result = MOVE_UNDEFINED;
 7169   struct glyph_row *saved_glyph_row;
 7170   struct it wrap_it, atpos_it, atx_it;
 7171   int may_wrap = 0;
 7172   enum it_method prev_method = it->method;
 7173   EMACS_INT prev_pos = IT_CHARPOS (*it);
 7174 
 7175   /* Don't produce glyphs in produce_glyphs.  */
 7176   saved_glyph_row = it->glyph_row;
 7177   it->glyph_row = NULL;
 7178 
 7179   /* Use wrap_it to save a copy of IT wherever a word wrap could
 7180      occur.  Use atpos_it to save a copy of IT at the desired buffer
 7181      position, if found, so that we can scan ahead and check if the
 7182      word later overshoots the window edge.  Use atx_it similarly, for
 7183      pixel positions.  */
 7184   wrap_it.sp = -1;
 7185   atpos_it.sp = -1;
 7186   atx_it.sp = -1;
 7187 
 7188 #define BUFFER_POS_REACHED_P()                                  \
 7189   ((op & MOVE_TO_POS) != 0                                      \
 7190    && BUFFERP (it->object)                                      \
 7191    && (IT_CHARPOS (*it) == to_charpos                           \
 7192        || (!it->bidi_p && IT_CHARPOS (*it) > to_charpos))       \
 7193    && (it->method == GET_FROM_BUFFER                            \
 7194        || (it->method == GET_FROM_DISPLAY_VECTOR                \
 7195            && it->dpvec + it->current.dpvec_index + 1 >= it->dpend)))
 7196 
 7197   /* If there's a line-/wrap-prefix, handle it.  */
 7198   if (it->hpos == 0 && it->method == GET_FROM_BUFFER
 7199       && it->current_y < it->last_visible_y)
 7200     handle_line_prefix (it);
 7201 
 7202   while (1)
 7203     {
 7204       int x, i, ascent = 0, descent = 0;
 7205 
 7206 /* Utility macro to reset an iterator with x, ascent, and descent.  */
 7207 #define IT_RESET_X_ASCENT_DESCENT(IT)                   \
 7208   ((IT)->current_x = x, (IT)->max_ascent = ascent,      \
 7209    (IT)->max_descent = descent)
 7210 
 7211       /* Stop if we move beyond TO_CHARPOS (after an image or stretch
 7212          glyph).  */
 7213       if ((op & MOVE_TO_POS) != 0
 7214           && BUFFERP (it->object)
 7215           && it->method == GET_FROM_BUFFER
 7216           && ((!it->bidi_p && IT_CHARPOS (*it) > to_charpos)
 7217               || (it->bidi_p
 7218                   && (prev_method == GET_FROM_IMAGE
 7219                       || prev_method == GET_FROM_STRETCH)
 7220                   /* Passed TO_CHARPOS from left to right.  */
 7221                   && ((prev_pos < to_charpos
 7222                        && IT_CHARPOS (*it) > to_charpos)
 7223                       /* Passed TO_CHARPOS from right to left.  */
 7224                       || (prev_pos > to_charpos
 7225                           && IT_CHARPOS (*it) < to_charpos)))))
 7226         {
 7227           if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
 7228             {
 7229               result = MOVE_POS_MATCH_OR_ZV;
 7230               break;
 7231             }
 7232           else if (it->line_wrap == WORD_WRAP && atpos_it.sp < 0)
 7233             /* If wrap_it is valid, the current position might be in a
 7234                word that is wrapped.  So, save the iterator in
 7235                atpos_it and continue to see if wrapping happens.  */
 7236             atpos_it = *it;
 7237         }
 7238 
 7239       prev_method = it->method;
 7240       if (it->method == GET_FROM_BUFFER)
 7241         prev_pos = IT_CHARPOS (*it);
 7242       /* Stop when ZV reached.
 7243          We used to stop here when TO_CHARPOS reached as well, but that is
 7244          too soon if this glyph does not fit on this line.  So we handle it
 7245          explicitly below.  */
 7246       if (!get_next_display_element (it))
 7247         {
 7248           result = MOVE_POS_MATCH_OR_ZV;
 7249           break;
 7250         }
 7251 
 7252       if (it->line_wrap == TRUNCATE)
 7253         {
 7254           if (BUFFER_POS_REACHED_P ())
 7255             {
 7256               result = MOVE_POS_MATCH_OR_ZV;
 7257               break;
 7258             }
 7259         }
 7260       else
 7261         {
 7262           if (it->line_wrap == WORD_WRAP)
 7263             {
 7264               if (IT_DISPLAYING_WHITESPACE (it))
 7265                 may_wrap = 1;
 7266               else if (may_wrap)
 7267                 {
 7268                   /* We have reached a glyph that follows one or more
 7269                      whitespace characters.  If the position is
 7270                      already found, we are done.  */
 7271                   if (atpos_it.sp >= 0)
 7272                     {
 7273                       *it = atpos_it;
 7274                       result = MOVE_POS_MATCH_OR_ZV;
 7275                       goto done;
 7276                     }
 7277                   if (atx_it.sp >= 0)
 7278                     {
 7279                       *it = atx_it;
 7280                       result = MOVE_X_REACHED;
 7281                       goto done;
 7282                     }
 7283                   /* Otherwise, we can wrap here.  */
 7284                   wrap_it = *it;
 7285                   may_wrap = 0;
 7286                 }
 7287             }
 7288         }
 7289 
 7290       /* Remember the line height for the current line, in case
 7291          the next element doesn't fit on the line.  */
 7292       ascent = it->max_ascent;
 7293       descent = it->max_descent;
 7294 
 7295       /* The call to produce_glyphs will get the metrics of the
 7296          display element IT is loaded with.  Record the x-position
 7297          before this display element, in case it doesn't fit on the
 7298          line.  */
 7299       x = it->current_x;
 7300 
 7301       PRODUCE_GLYPHS (it);
 7302 
 7303       if (it->area != TEXT_AREA)
 7304         {
 7305           set_iterator_to_next (it, 1);
 7306           continue;
 7307         }
 7308 
 7309       /* The number of glyphs we get back in IT->nglyphs will normally
 7310          be 1 except when IT->c is (i) a TAB, or (ii) a multi-glyph
 7311          character on a terminal frame, or (iii) a line end.  For the
 7312          second case, IT->nglyphs - 1 padding glyphs will be present.
 7313          (On X frames, there is only one glyph produced for a
 7314          composite character.)
 7315 
 7316          The behavior implemented below means, for continuation lines,
 7317          that as many spaces of a TAB as fit on the current line are
 7318          displayed there.  For terminal frames, as many glyphs of a
 7319          multi-glyph character are displayed in the current line, too.
 7320          This is what the old redisplay code did, and we keep it that
 7321          way.  Under X, the whole shape of a complex character must
 7322          fit on the line or it will be completely displayed in the
 7323          next line.
 7324 
 7325          Note that both for tabs and padding glyphs, all glyphs have
 7326          the same width.  */
 7327       if (it->nglyphs)
 7328         {
 7329           /* More than one glyph or glyph doesn't fit on line.  All
 7330              glyphs have the same width.  */
 7331           int single_glyph_width = it->pixel_width / it->nglyphs;
 7332           int new_x;
 7333           int x_before_this_char = x;
 7334           int hpos_before_this_char = it->hpos;
 7335 
 7336           for (i = 0; i < it->nglyphs; ++i, x = new_x)
 7337             {
 7338               new_x = x + single_glyph_width;
 7339 
 7340               /* We want to leave anything reaching TO_X to the caller.  */
 7341               if ((op & MOVE_TO_X) && new_x > to_x)
 7342                 {
 7343                   if (BUFFER_POS_REACHED_P ())
 7344                     {
 7345                       if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
 7346                         goto buffer_pos_reached;
 7347                       if (atpos_it.sp < 0)
 7348                         {
 7349                           atpos_it = *it;
 7350                           IT_RESET_X_ASCENT_DESCENT (&atpos_it);
 7351                         }
 7352                     }
 7353                   else
 7354                     {
 7355                       if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
 7356                         {
 7357                           it->current_x = x;
 7358                           result = MOVE_X_REACHED;
 7359                           break;
 7360                         }
 7361                       if (atx_it.sp < 0)
 7362                         {
 7363                           atx_it = *it;
 7364                           IT_RESET_X_ASCENT_DESCENT (&atx_it);
 7365                         }
 7366                     }
 7367                 }
 7368 
 7369               if (/* Lines are continued.  */
 7370                   it->line_wrap != TRUNCATE
 7371                   && (/* And glyph doesn't fit on the line.  */
 7372                       new_x > it->last_visible_x
 7373                       /* Or it fits exactly and we're on a window
 7374                          system frame.  */
 7375                       || (new_x == it->last_visible_x
 7376                           && FRAME_WINDOW_P (it->f))))
 7377                 {
 7378                   if (/* IT->hpos == 0 means the very first glyph
 7379                          doesn't fit on the line, e.g. a wide image.  */
 7380                       it->hpos == 0
 7381                       || (new_x == it->last_visible_x
 7382                           && FRAME_WINDOW_P (it->f)))
 7383                     {
 7384                       ++it->hpos;
 7385                       it->current_x = new_x;
 7386 
 7387                       /* The character's last glyph just barely fits
 7388                          in this row.  */
 7389                       if (i == it->nglyphs - 1)
 7390                         {
 7391                           /* If this is the destination position,
 7392                              return a position *before* it in this row,
 7393                              now that we know it fits in this row.  */
 7394                           if (BUFFER_POS_REACHED_P ())
 7395                             {
 7396                               if (it->line_wrap != WORD_WRAP
 7397                                   || wrap_it.sp < 0)
 7398                                 {
 7399                                   it->hpos = hpos_before_this_char;
 7400                                   it->current_x = x_before_this_char;
 7401                                   result = MOVE_POS_MATCH_OR_ZV;
 7402                                   break;
 7403                                 }
 7404                               if (it->line_wrap == WORD_WRAP
 7405                                   && atpos_it.sp < 0)
 7406                                 {
 7407                                   atpos_it = *it;
 7408                                   atpos_it.current_x = x_before_this_char;
 7409                                   atpos_it.hpos = hpos_before_this_char;
 7410                                 }
 7411                             }
 7412 
 7413                           set_iterator_to_next (it, 1);
 7414                           /* On graphical terminals, newlines may
 7415                              "overflow" into the fringe if
 7416                              overflow-newline-into-fringe is non-nil.
 7417                              On text-only terminals, newlines may
 7418                              overflow into the last glyph on the
 7419                              display line.*/
 7420                           if (!FRAME_WINDOW_P (it->f)
 7421                               || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 7422                             {
 7423                               if (!get_next_display_element (it))
 7424                                 {
 7425                                   result = MOVE_POS_MATCH_OR_ZV;
 7426                                   break;
 7427                                 }
 7428                               if (BUFFER_POS_REACHED_P ())
 7429                                 {
 7430                                   if (ITERATOR_AT_END_OF_LINE_P (it))
 7431                                     result = MOVE_POS_MATCH_OR_ZV;
 7432                                   else
 7433                                     result = MOVE_LINE_CONTINUED;
 7434                                   break;
 7435                                 }
 7436                               if (ITERATOR_AT_END_OF_LINE_P (it))
 7437                                 {
 7438                                   result = MOVE_NEWLINE_OR_CR;
 7439                                   break;
 7440                                 }
 7441                             }
 7442                         }
 7443                     }
 7444                   else
 7445                     IT_RESET_X_ASCENT_DESCENT (it);
 7446 
 7447                   if (wrap_it.sp >= 0)
 7448                     {
 7449                       *it = wrap_it;
 7450                       atpos_it.sp = -1;
 7451                       atx_it.sp = -1;
 7452                     }
 7453 
 7454                   TRACE_MOVE ((stderr, "move_it_in: continued at %d\n",
 7455                                IT_CHARPOS (*it)));
 7456                   result = MOVE_LINE_CONTINUED;
 7457                   break;
 7458                 }
 7459 
 7460               if (BUFFER_POS_REACHED_P ())
 7461                 {
 7462                   if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
 7463                     goto buffer_pos_reached;
 7464                   if (it->line_wrap == WORD_WRAP && atpos_it.sp < 0)
 7465                     {
 7466                       atpos_it = *it;
 7467                       IT_RESET_X_ASCENT_DESCENT (&atpos_it);
 7468                     }
 7469                 }
 7470 
 7471               if (new_x > it->first_visible_x)
 7472                 {
 7473                   /* Glyph is visible.  Increment number of glyphs that
 7474                      would be displayed.  */
 7475                   ++it->hpos;
 7476                 }
 7477             }
 7478 
 7479           if (result != MOVE_UNDEFINED)
 7480             break;
 7481         }
 7482       else if (BUFFER_POS_REACHED_P ())
 7483         {
 7484         buffer_pos_reached:
 7485           IT_RESET_X_ASCENT_DESCENT (it);
 7486           result = MOVE_POS_MATCH_OR_ZV;
 7487           break;
 7488         }
 7489       else if ((op & MOVE_TO_X) && it->current_x >= to_x)
 7490         {
 7491           /* Stop when TO_X specified and reached.  This check is
 7492              necessary here because of lines consisting of a line end,
 7493              only.  The line end will not produce any glyphs and we
 7494              would never get MOVE_X_REACHED.  */
 7495           xassert (it->nglyphs == 0);
 7496           result = MOVE_X_REACHED;
 7497           break;
 7498         }
 7499 
 7500       /* Is this a line end?  If yes, we're done.  */
 7501       if (ITERATOR_AT_END_OF_LINE_P (it))
 7502         {
 7503           result = MOVE_NEWLINE_OR_CR;
 7504           break;
 7505         }
 7506 
 7507       if (it->method == GET_FROM_BUFFER)
 7508         prev_pos = IT_CHARPOS (*it);
 7509       /* The current display element has been consumed.  Advance
 7510          to the next.  */
 7511       set_iterator_to_next (it, 1);
 7512 
 7513       /* Stop if lines are truncated and IT's current x-position is
 7514          past the right edge of the window now.  */
 7515       if (it->line_wrap == TRUNCATE
 7516           && it->current_x >= it->last_visible_x)
 7517         {
 7518           if (!FRAME_WINDOW_P (it->f)
 7519               || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 7520             {
 7521               if (!get_next_display_element (it)
 7522                   || BUFFER_POS_REACHED_P ())
 7523                 {
 7524                   result = MOVE_POS_MATCH_OR_ZV;
 7525                   break;
 7526                 }
 7527               if (ITERATOR_AT_END_OF_LINE_P (it))
 7528                 {
 7529                   result = MOVE_NEWLINE_OR_CR;
 7530                   break;
 7531                 }
 7532             }
 7533           result = MOVE_LINE_TRUNCATED;
 7534           break;
 7535         }
 7536 #undef IT_RESET_X_ASCENT_DESCENT
 7537     }
 7538 
 7539 #undef BUFFER_POS_REACHED_P
 7540 
 7541   /* If we scanned beyond to_pos and didn't find a point to wrap at,
 7542      restore the saved iterator.  */
 7543   if (atpos_it.sp >= 0)
 7544     *it = atpos_it;
 7545   else if (atx_it.sp >= 0)
 7546     *it = atx_it;
 7547 
 7548  done:
 7549 
 7550   /* Restore the iterator settings altered at the beginning of this
 7551      function.  */
 7552   it->glyph_row = saved_glyph_row;
 7553   return result;
 7554 }
 7555 
 7556 /* For external use.  */
 7557 void
 7558 move_it_in_display_line (struct it *it,
 7559                          EMACS_INT to_charpos, int to_x,
 7560                          enum move_operation_enum op)
 7561 {
 7562   if (it->line_wrap == WORD_WRAP
 7563       && (op & MOVE_TO_X))
 7564     {
 7565       struct it save_it = *it;
 7566       int skip = move_it_in_display_line_to (it, to_charpos, to_x, op);
 7567       /* When word-wrap is on, TO_X may lie past the end
 7568          of a wrapped line.  Then it->current is the
 7569          character on the next line, so backtrack to the
 7570          space before the wrap point.  */
 7571       if (skip == MOVE_LINE_CONTINUED)
 7572         {
 7573           int prev_x = max (it->current_x - 1, 0);
 7574           *it = save_it;
 7575           move_it_in_display_line_to
 7576             (it, -1, prev_x, MOVE_TO_X);
 7577         }
 7578     }
 7579   else
 7580     move_it_in_display_line_to (it, to_charpos, to_x, op);
 7581 }
 7582 
 7583 
 7584 /* Move IT forward until it satisfies one or more of the criteria in
 7585    TO_CHARPOS, TO_X, TO_Y, and TO_VPOS.
 7586 
 7587    OP is a bit-mask that specifies where to stop, and in particular,
 7588    which of those four position arguments makes a difference.  See the
 7589    description of enum move_operation_enum.
 7590 
 7591    If TO_CHARPOS is in invisible text, e.g. a truncated part of a
 7592    screen line, this function will set IT to the next position >
 7593    TO_CHARPOS.  */
 7594 
 7595 void
 7596 move_it_to (it, to_charpos, to_x, to_y, to_vpos, op)
 7597      struct it *it;
 7598      int to_charpos, to_x, to_y, to_vpos;
 7599      int op;
 7600 {
 7601   enum move_it_result skip, skip2 = MOVE_X_REACHED;
 7602   int line_height, line_start_x = 0, reached = 0;
 7603 
 7604   for (;;)
 7605     {
 7606       if (op & MOVE_TO_VPOS)
 7607         {
 7608           /* If no TO_CHARPOS and no TO_X specified, stop at the
 7609              start of the line TO_VPOS.  */
 7610           if ((op & (MOVE_TO_X | MOVE_TO_POS)) == 0)
 7611             {
 7612               if (it->vpos == to_vpos)
 7613                 {
 7614                   reached = 1;
 7615                   break;
 7616                 }
 7617               else
 7618                 skip = move_it_in_display_line_to (it, -1, -1, 0);
 7619             }
 7620           else
 7621             {
 7622               /* TO_VPOS >= 0 means stop at TO_X in the line at
 7623                  TO_VPOS, or at TO_POS, whichever comes first.  */
 7624               if (it->vpos == to_vpos)
 7625                 {
 7626                   reached = 2;
 7627                   break;
 7628                 }
 7629 
 7630               skip = move_it_in_display_line_to (it, to_charpos, to_x, op);
 7631 
 7632               if (skip == MOVE_POS_MATCH_OR_ZV || it->vpos == to_vpos)
 7633                 {
 7634                   reached = 3;
 7635                   break;
 7636                 }
 7637               else if (skip == MOVE_X_REACHED && it->vpos != to_vpos)
 7638                 {
 7639                   /* We have reached TO_X but not in the line we want.  */
 7640                   skip = move_it_in_display_line_to (it, to_charpos,
 7641                                                      -1, MOVE_TO_POS);
 7642                   if (skip == MOVE_POS_MATCH_OR_ZV)
 7643                     {
 7644                       reached = 4;
 7645                       break;
 7646                     }
 7647                 }
 7648             }
 7649         }
 7650       else if (op & MOVE_TO_Y)
 7651         {
 7652           struct it it_backup;
 7653 
 7654           if (it->line_wrap == WORD_WRAP)
 7655             it_backup = *it;
 7656 
 7657           /* TO_Y specified means stop at TO_X in the line containing
 7658              TO_Y---or at TO_CHARPOS if this is reached first.  The
 7659              problem is that we can't really tell whether the line
 7660              contains TO_Y before we have completely scanned it, and
 7661              this may skip past TO_X.  What we do is to first scan to
 7662              TO_X.
 7663 
 7664              If TO_X is not specified, use a TO_X of zero.  The reason
 7665              is to make the outcome of this function more predictable.
 7666              If we didn't use TO_X == 0, we would stop at the end of
 7667              the line which is probably not what a caller would expect
 7668              to happen.  */
 7669           skip = move_it_in_display_line_to
 7670             (it, to_charpos, ((op & MOVE_TO_X) ? to_x : 0),
 7671              (MOVE_TO_X | (op & MOVE_TO_POS)));
 7672 
 7673           /* If TO_CHARPOS is reached or ZV, we don't have to do more.  */
 7674           if (skip == MOVE_POS_MATCH_OR_ZV)
 7675             reached = 5;
 7676           else if (skip == MOVE_X_REACHED)
 7677             {
 7678               /* If TO_X was reached, we want to know whether TO_Y is
 7679                  in the line.  We know this is the case if the already
 7680                  scanned glyphs make the line tall enough.  Otherwise,
 7681                  we must check by scanning the rest of the line.  */
 7682               line_height = it->max_ascent + it->max_descent;
 7683               if (to_y >= it->current_y
 7684                   && to_y < it->current_y + line_height)
 7685                 {
 7686                   reached = 6;
 7687                   break;
 7688                 }
 7689               it_backup = *it;
 7690               TRACE_MOVE ((stderr, "move_it: from %d\n", IT_CHARPOS (*it)));
 7691               skip2 = move_it_in_display_line_to (it, to_charpos, -1,
 7692                                                   op & MOVE_TO_POS);
 7693               TRACE_MOVE ((stderr, "move_it: to %d\n", IT_CHARPOS (*it)));
 7694               line_height = it->max_ascent + it->max_descent;
 7695               TRACE_MOVE ((stderr, "move_it: line_height = %d\n", line_height));
 7696 
 7697               if (to_y >= it->current_y
 7698                   && to_y < it->current_y + line_height)
 7699                 {
 7700                   /* If TO_Y is in this line and TO_X was reached
 7701                      above, we scanned too far.  We have to restore
 7702                      IT's settings to the ones before skipping.  */
 7703                   *it = it_backup;
 7704                   reached = 6;
 7705                 }
 7706               else
 7707                 {
 7708                   skip = skip2;
 7709                   if (skip == MOVE_POS_MATCH_OR_ZV)
 7710                     reached = 7;
 7711                 }
 7712             }
 7713           else
 7714             {
 7715               /* Check whether TO_Y is in this line.  */
 7716               line_height = it->max_ascent + it->max_descent;
 7717               TRACE_MOVE ((stderr, "move_it: line_height = %d\n", line_height));
 7718 
 7719               if (to_y >= it->current_y
 7720                   && to_y < it->current_y + line_height)
 7721                 {
 7722                   /* When word-wrap is on, TO_X may lie past the end
 7723                      of a wrapped line.  Then it->current is the
 7724                      character on the next line, so backtrack to the
 7725                      space before the wrap point.  */
 7726                   if (skip == MOVE_LINE_CONTINUED
 7727                       && it->line_wrap == WORD_WRAP)
 7728                     {
 7729                       int prev_x = max (it->current_x - 1, 0);
 7730                       *it = it_backup;
 7731                       skip = move_it_in_display_line_to
 7732                         (it, -1, prev_x, MOVE_TO_X);
 7733                     }
 7734                   reached = 6;
 7735                 }
 7736             }
 7737 
 7738           if (reached)
 7739             break;
 7740         }
 7741       else if (BUFFERP (it->object)
 7742                && (it->method == GET_FROM_BUFFER
 7743                    || it->method == GET_FROM_STRETCH)
 7744                && IT_CHARPOS (*it) >= to_charpos)
 7745         skip = MOVE_POS_MATCH_OR_ZV;
 7746       else
 7747         skip = move_it_in_display_line_to (it, to_charpos, -1, MOVE_TO_POS);
 7748 
 7749       switch (skip)
 7750         {
 7751         case MOVE_POS_MATCH_OR_ZV:
 7752           reached = 8;
 7753           goto out;
 7754 
 7755         case MOVE_NEWLINE_OR_CR:
 7756           set_iterator_to_next (it, 1);
 7757           it->continuation_lines_width = 0;
 7758           break;
 7759 
 7760         case MOVE_LINE_TRUNCATED:
 7761           it->continuation_lines_width = 0;
 7762           reseat_at_next_visible_line_start (it, 0);
 7763           if ((op & MOVE_TO_POS) != 0
 7764               && IT_CHARPOS (*it) > to_charpos)
 7765             {
 7766               reached = 9;
 7767               goto out;
 7768             }
 7769           break;
 7770 
 7771         case MOVE_LINE_CONTINUED:
 7772           /* For continued lines ending in a tab, some of the glyphs
 7773              associated with the tab are displayed on the current
 7774              line.  Since it->current_x does not include these glyphs,
 7775              we use it->last_visible_x instead.  */
 7776           if (it->c == '\t')
 7777             {
 7778               it->continuation_lines_width += it->last_visible_x;
 7779               /* When moving by vpos, ensure that the iterator really
 7780                  advances to the next line (bug#847, bug#969).  Fixme:
 7781                  do we need to do this in other circumstances?  */
 7782               if (it->current_x != it->last_visible_x
 7783                   && (op & MOVE_TO_VPOS)
 7784                   && !(op & (MOVE_TO_X | MOVE_TO_POS)))
 7785                 {
 7786                   line_start_x = it->current_x + it->pixel_width
 7787                     - it->last_visible_x;
 7788                   set_iterator_to_next (it, 0);
 7789                 }
 7790             }
 7791           else
 7792             it->continuation_lines_width += it->current_x;
 7793           break;
 7794 
 7795         default:
 7796           abort ();
 7797         }
 7798 
 7799       /* Reset/increment for the next run.  */
 7800       recenter_overlay_lists (current_buffer, IT_CHARPOS (*it));
 7801       it->current_x = line_start_x;
 7802       line_start_x = 0;
 7803       it->hpos = 0;
 7804       it->current_y += it->max_ascent + it->max_descent;
 7805       ++it->vpos;
 7806       last_height = it->max_ascent + it->max_descent;
 7807       last_max_ascent = it->max_ascent;
 7808       it->max_ascent = it->max_descent = 0;
 7809     }
 7810 
 7811  out:
 7812 
 7813   /* On text terminals, we may stop at the end of a line in the middle
 7814      of a multi-character glyph.  If the glyph itself is continued,
 7815      i.e. it is actually displayed on the next line, don't treat this
 7816      stopping point as valid; move to the next line instead (unless
 7817      that brings us offscreen).  */
 7818   if (!FRAME_WINDOW_P (it->f)
 7819       && op & MOVE_TO_POS
 7820       && IT_CHARPOS (*it) == to_charpos
 7821       && it->what == IT_CHARACTER
 7822       && it->nglyphs > 1
 7823       && it->line_wrap == WINDOW_WRAP
 7824       && it->current_x == it->last_visible_x - 1
 7825       && it->c != '\n'
 7826       && it->c != '\t'
 7827       && it->vpos < XFASTINT (it->w->window_end_vpos))
 7828     {
 7829       it->continuation_lines_width += it->current_x;
 7830       it->current_x = it->hpos = it->max_ascent = it->max_descent = 0;
 7831       it->current_y += it->max_ascent + it->max_descent;
 7832       ++it->vpos;
 7833       last_height = it->max_ascent + it->max_descent;
 7834       last_max_ascent = it->max_ascent;
 7835     }
 7836 
 7837   TRACE_MOVE ((stderr, "move_it_to: reached %d\n", reached));
 7838 }
 7839 
 7840 
 7841 /* Move iterator IT backward by a specified y-distance DY, DY >= 0.
 7842 
 7843    If DY > 0, move IT backward at least that many pixels.  DY = 0
 7844    means move IT backward to the preceding line start or BEGV.  This
 7845    function may move over more than DY pixels if IT->current_y - DY
 7846    ends up in the middle of a line; in this case IT->current_y will be
 7847    set to the top of the line moved to.  */
 7848 
 7849 void
 7850 move_it_vertically_backward (it, dy)
 7851      struct it *it;
 7852      int dy;
 7853 {
 7854   int nlines, h;
 7855   struct it it2, it3;
 7856   int start_pos;
 7857 
 7858  move_further_back:
 7859   xassert (dy >= 0);
 7860 
 7861   start_pos = IT_CHARPOS (*it);
 7862 
 7863   /* Estimate how many newlines we must move back.  */
 7864   nlines = max (1, dy / FRAME_LINE_HEIGHT (it->f));
 7865 
 7866   /* Set the iterator's position that many lines back.  */
 7867   while (nlines-- && IT_CHARPOS (*it) > BEGV)
 7868     back_to_previous_visible_line_start (it);
 7869 
 7870   /* Reseat the iterator here.  When moving backward, we don't want
 7871      reseat to skip forward over invisible text, set up the iterator
 7872      to deliver from overlay strings at the new position etc.  So,
 7873      use reseat_1 here.  */
 7874   reseat_1 (it, it->current.pos, 1);
 7875 
 7876   /* We are now surely at a line start.  */
 7877   it->current_x = it->hpos = 0;
 7878   it->continuation_lines_width = 0;
 7879 
 7880   /* Move forward and see what y-distance we moved.  First move to the
 7881      start of the next line so that we get its height.  We need this
 7882      height to be able to tell whether we reached the specified
 7883      y-distance.  */
 7884   it2 = *it;
 7885   it2.max_ascent = it2.max_descent = 0;
 7886   do
 7887     {
 7888       move_it_to (&it2, start_pos, -1, -1, it2.vpos + 1,
 7889                   MOVE_TO_POS | MOVE_TO_VPOS);
 7890     }
 7891   while (!IT_POS_VALID_AFTER_MOVE_P (&it2));
 7892   xassert (IT_CHARPOS (*it) >= BEGV);
 7893   it3 = it2;
 7894 
 7895   move_it_to (&it2, start_pos, -1, -1, -1, MOVE_TO_POS);
 7896   xassert (IT_CHARPOS (*it) >= BEGV);
 7897   /* H is the actual vertical distance from the position in *IT
 7898      and the starting position.  */
 7899   h = it2.current_y - it->current_y;
 7900   /* NLINES is the distance in number of lines.  */
 7901   nlines = it2.vpos - it->vpos;
 7902 
 7903   /* Correct IT's y and vpos position
 7904      so that they are relative to the starting point.  */
 7905   it->vpos -= nlines;
 7906   it->current_y -= h;
 7907 
 7908   if (dy == 0)
 7909     {
 7910       /* DY == 0 means move to the start of the screen line.  The
 7911          value of nlines is > 0 if continuation lines were involved.  */
 7912       if (nlines > 0)
 7913         move_it_by_lines (it, nlines, 1);
 7914     }
 7915   else
 7916     {
 7917       /* The y-position we try to reach, relative to *IT.
 7918          Note that H has been subtracted in front of the if-statement.  */
 7919       int target_y = it->current_y + h - dy;
 7920       int y0 = it3.current_y;
 7921       int y1 = line_bottom_y (&it3);
 7922       int line_height = y1 - y0;
 7923 
 7924       /* If we did not reach target_y, try to move further backward if
 7925          we can.  If we moved too far backward, try to move forward.  */
 7926       if (target_y < it->current_y
 7927           /* This is heuristic.  In a window that's 3 lines high, with
 7928              a line height of 13 pixels each, recentering with point
 7929              on the bottom line will try to move -39/2 = 19 pixels
 7930              backward.  Try to avoid moving into the first line.  */
 7931           && (it->current_y - target_y
 7932               > min (window_box_height (it->w), line_height * 2 / 3))
 7933           && IT_CHARPOS (*it) > BEGV)
 7934         {
 7935           TRACE_MOVE ((stderr, "  not far enough -> move_vert %d\n",
 7936                        target_y - it->current_y));
 7937           dy = it->current_y - target_y;
 7938           goto move_further_back;
 7939         }
 7940       else if (target_y >= it->current_y + line_height
 7941                && IT_CHARPOS (*it) < ZV)
 7942         {
 7943           /* Should move forward by at least one line, maybe more.
 7944 
 7945              Note: Calling move_it_by_lines can be expensive on
 7946              terminal frames, where compute_motion is used (via
 7947              vmotion) to do the job, when there are very long lines
 7948              and truncate-lines is nil.  That's the reason for
 7949              treating terminal frames specially here.  */
 7950 
 7951           if (!FRAME_WINDOW_P (it->f))
 7952             move_it_vertically (it, target_y - (it->current_y + line_height));
 7953           else
 7954             {
 7955               do
 7956                 {
 7957                   move_it_by_lines (it, 1, 1);
 7958                 }
 7959               while (target_y >= line_bottom_y (it) && IT_CHARPOS (*it) < ZV);
 7960             }
 7961         }
 7962     }
 7963 }
 7964 
 7965 
 7966 /* Move IT by a specified amount of pixel lines DY.  DY negative means
 7967    move backwards.  DY = 0 means move to start of screen line.  At the
 7968    end, IT will be on the start of a screen line.  */
 7969 
 7970 void
 7971 move_it_vertically (it, dy)
 7972     struct it *it;
 7973     int dy;
 7974 {
 7975   if (dy <= 0)
 7976     move_it_vertically_backward (it, -dy);
 7977   else
 7978     {
 7979       TRACE_MOVE ((stderr, "move_it_v: from %d, %d\n", IT_CHARPOS (*it), dy));
 7980       move_it_to (it, ZV, -1, it->current_y + dy, -1,
 7981                   MOVE_TO_POS | MOVE_TO_Y);
 7982       TRACE_MOVE ((stderr, "move_it_v: to %d\n", IT_CHARPOS (*it)));
 7983 
 7984       /* If buffer ends in ZV without a newline, move to the start of
 7985          the line to satisfy the post-condition.  */
 7986       if (IT_CHARPOS (*it) == ZV
 7987           && ZV > BEGV
 7988           && FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n')
 7989         move_it_by_lines (it, 0, 0);
 7990     }
 7991 }
 7992 
 7993 
 7994 /* Move iterator IT past the end of the text line it is in.  */
 7995 
 7996 void
 7997 move_it_past_eol (it)
 7998      struct it *it;
 7999 {
 8000   enum move_it_result rc;
 8001 
 8002   rc = move_it_in_display_line_to (it, Z, 0, MOVE_TO_POS);
 8003   if (rc == MOVE_NEWLINE_OR_CR)
 8004     set_iterator_to_next (it, 0);
 8005 }
 8006 
 8007 
 8008 /* Move IT by a specified number DVPOS of screen lines down.  DVPOS
 8009    negative means move up.  DVPOS == 0 means move to the start of the
 8010    screen line.  NEED_Y_P non-zero means calculate IT->current_y.  If
 8011    NEED_Y_P is zero, IT->current_y will be left unchanged.
 8012 
 8013    Further optimization ideas: If we would know that IT->f doesn't use
 8014    a face with proportional font, we could be faster for
 8015    truncate-lines nil.  */
 8016 
 8017 void
 8018 move_it_by_lines (it, dvpos, need_y_p)
 8019      struct it *it;
 8020      int dvpos, need_y_p;
 8021 {
 8022   struct position pos;
 8023 
 8024   /* The commented-out optimization uses vmotion on terminals.  This
 8025      gives bad results, because elements like it->what, on which
 8026      callers such as pos_visible_p rely, aren't updated. */
 8027   /*  if (!FRAME_WINDOW_P (it->f))
 8028     {
 8029       struct text_pos textpos;
 8030 
 8031       pos = *vmotion (IT_CHARPOS (*it), dvpos, it->w);
 8032       SET_TEXT_POS (textpos, pos.bufpos, pos.bytepos);
 8033       reseat (it, textpos, 1);
 8034       it->vpos += pos.vpos;
 8035       it->current_y += pos.vpos;
 8036     }
 8037     else */
 8038 
 8039   if (dvpos == 0)
 8040     {
 8041       /* DVPOS == 0 means move to the start of the screen line.  */
 8042       move_it_vertically_backward (it, 0);
 8043       xassert (it->current_x == 0 && it->hpos == 0);
 8044       /* Let next call to line_bottom_y calculate real line height */
 8045       last_height = 0;
 8046     }
 8047   else if (dvpos > 0)
 8048     {
 8049       move_it_to (it, -1, -1, -1, it->vpos + dvpos, MOVE_TO_VPOS);
 8050       if (!IT_POS_VALID_AFTER_MOVE_P (it))
 8051         move_it_to (it, IT_CHARPOS (*it) + 1, -1, -1, -1, MOVE_TO_POS);
 8052     }
 8053   else
 8054     {
 8055       struct it it2;
 8056       int start_charpos, i;
 8057 
 8058       /* Start at the beginning of the screen line containing IT's
 8059          position.  This may actually move vertically backwards,
 8060          in case of overlays, so adjust dvpos accordingly.  */
 8061       dvpos += it->vpos;
 8062       move_it_vertically_backward (it, 0);
 8063       dvpos -= it->vpos;
 8064 
 8065       /* Go back -DVPOS visible lines and reseat the iterator there.  */
 8066       start_charpos = IT_CHARPOS (*it);
 8067       for (i = -dvpos; i > 0 && IT_CHARPOS (*it) > BEGV; --i)
 8068         back_to_previous_visible_line_start (it);
 8069       reseat (it, it->current.pos, 1);
 8070 
 8071       /* Move further back if we end up in a string or an image.  */
 8072       while (!IT_POS_VALID_AFTER_MOVE_P (it))
 8073         {
 8074           /* First try to move to start of display line.  */
 8075           dvpos += it->vpos;
 8076           move_it_vertically_backward (it, 0);
 8077           dvpos -= it->vpos;
 8078           if (IT_POS_VALID_AFTER_MOVE_P (it))
 8079             break;
 8080           /* If start of line is still in string or image,
 8081              move further back.  */
 8082           back_to_previous_visible_line_start (it);
 8083           reseat (it, it->current.pos, 1);
 8084           dvpos--;
 8085         }
 8086 
 8087       it->current_x = it->hpos = 0;
 8088 
 8089       /* Above call may have moved too far if continuation lines
 8090          are involved.  Scan forward and see if it did.  */
 8091       it2 = *it;
 8092       it2.vpos = it2.current_y = 0;
 8093       move_it_to (&it2, start_charpos, -1, -1, -1, MOVE_TO_POS);
 8094       it->vpos -= it2.vpos;
 8095       it->current_y -= it2.current_y;
 8096       it->current_x = it->hpos = 0;
 8097 
 8098       /* If we moved too far back, move IT some lines forward.  */
 8099       if (it2.vpos > -dvpos)
 8100         {
 8101           int delta = it2.vpos + dvpos;
 8102           it2 = *it;
 8103           move_it_to (it, -1, -1, -1, it->vpos + delta, MOVE_TO_VPOS);
 8104           /* Move back again if we got too far ahead.  */
 8105           if (IT_CHARPOS (*it) >= start_charpos)
 8106             *it = it2;
 8107         }
 8108     }
 8109 }
 8110 
 8111 /* Return 1 if IT points into the middle of a display vector.  */
 8112 
 8113 int
 8114 in_display_vector_p (it)
 8115      struct it *it;
 8116 {
 8117   return (it->method == GET_FROM_DISPLAY_VECTOR
 8118           && it->current.dpvec_index > 0
 8119           && it->dpvec + it->current.dpvec_index != it->dpend);
 8120 }
 8121 
 8122 
 8123 /***********************************************************************
 8124                                Messages
 8125  ***********************************************************************/
 8126 
 8127 
 8128 /* Add a message with format string FORMAT and arguments ARG1 and ARG2
 8129    to *Messages*.  */
 8130 
 8131 void
 8132 add_to_log (format, arg1, arg2)
 8133      char *format;
 8134      Lisp_Object arg1, arg2;
 8135 {
 8136   Lisp_Object args[3];
 8137   Lisp_Object msg, fmt;
 8138   char *buffer;
 8139   int len;
 8140   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
 8141   USE_SAFE_ALLOCA;
 8142 
 8143   /* Do nothing if called asynchronously.  Inserting text into
 8144      a buffer may call after-change-functions and alike and
 8145      that would means running Lisp asynchronously.  */
 8146   if (handling_signal)
 8147     return;
 8148 
 8149   fmt = msg = Qnil;
 8150   GCPRO4 (fmt, msg, arg1, arg2);
 8151 
 8152   args[0] = fmt = build_string (format);
 8153   args[1] = arg1;
 8154   args[2] = arg2;
 8155   msg = Fformat (3, args);
 8156 
 8157   len = SBYTES (msg) + 1;
 8158   SAFE_ALLOCA (buffer, char *, len);
 8159   bcopy (SDATA (msg), buffer, len);
 8160 
 8161   message_dolog (buffer, len - 1, 1, 0);
 8162   SAFE_FREE ();
 8163 
 8164   UNGCPRO;
 8165 }
 8166 
 8167 
 8168 /* Output a newline in the *Messages* buffer if "needs" one.  */
 8169 
 8170 void
 8171 message_log_maybe_newline ()
 8172 {
 8173   if (message_log_need_newline)
 8174     message_dolog ("", 0, 1, 0);
 8175 }
 8176 
 8177 
 8178 /* Add a string M of length NBYTES to the message log, optionally
 8179    terminated with a newline when NLFLAG is non-zero.  MULTIBYTE, if
 8180    nonzero, means interpret the contents of M as multibyte.  This
 8181    function calls low-level routines in order to bypass text property
 8182    hooks, etc. which might not be safe to run.
 8183 
 8184    This may GC (insert may run before/after change hooks),
 8185    so the buffer M must NOT point to a Lisp string.  */
 8186 
 8187 void
 8188 message_dolog (m, nbytes, nlflag, multibyte)
 8189      const char *m;
 8190      int nbytes, nlflag, multibyte;
 8191 {
 8192   if (!NILP (Vmemory_full))
 8193     return;
 8194 
 8195   if (!NILP (Vmessage_log_max))
 8196     {
 8197       struct buffer *oldbuf;
 8198       Lisp_Object oldpoint, oldbegv, oldzv;
 8199       int old_windows_or_buffers_changed = windows_or_buffers_changed;
 8200       int point_at_end = 0;
 8201       int zv_at_end = 0;
 8202       Lisp_Object old_deactivate_mark, tem;
 8203       struct gcpro gcpro1;
 8204 
 8205       old_deactivate_mark = Vdeactivate_mark;
 8206       oldbuf = current_buffer;
 8207       Fset_buffer (Fget_buffer_create (Vmessages_buffer_name));
 8208       current_buffer->undo_list = Qt;
 8209 
 8210       oldpoint = message_dolog_marker1;
 8211       set_marker_restricted (oldpoint, make_number (PT), Qnil);
 8212       oldbegv = message_dolog_marker2;
 8213       set_marker_restricted (oldbegv, make_number (BEGV), Qnil);
 8214       oldzv = message_dolog_marker3;
 8215       set_marker_restricted (oldzv, make_number (ZV), Qnil);
 8216       GCPRO1 (old_deactivate_mark);
 8217 
 8218       if (PT == Z)
 8219         point_at_end = 1;
 8220       if (ZV == Z)
 8221         zv_at_end = 1;
 8222 
 8223       BEGV = BEG;
 8224       BEGV_BYTE = BEG_BYTE;
 8225       ZV = Z;
 8226       ZV_BYTE = Z_BYTE;
 8227       TEMP_SET_PT_BOTH (Z, Z_BYTE);
 8228 
 8229       /* Insert the string--maybe converting multibyte to single byte
 8230          or vice versa, so that all the text fits the buffer.  */
 8231       if (multibyte
 8232           && NILP (current_buffer->enable_multibyte_characters))
 8233         {
 8234           int i, c, char_bytes;
 8235           unsigned char work[1];
 8236 
 8237           /* Convert a multibyte string to single-byte
 8238              for the *Message* buffer.  */
 8239           for (i = 0; i < nbytes; i += char_bytes)
 8240             {
 8241               c = string_char_and_length (m + i, &char_bytes);
 8242               work[0] = (ASCII_CHAR_P (c)
 8243                          ? c
 8244                          : multibyte_char_to_unibyte (c, Qnil));
 8245               insert_1_both (work, 1, 1, 1, 0, 0);
 8246             }
 8247         }
 8248       else if (! multibyte
 8249                && ! NILP (current_buffer->enable_multibyte_characters))
 8250         {
 8251           int i, c, char_bytes;
 8252           unsigned char *msg = (unsigned char *) m;
 8253           unsigned char str[MAX_MULTIBYTE_LENGTH];
 8254           /* Convert a single-byte string to multibyte
 8255              for the *Message* buffer.  */
 8256           for (i = 0; i < nbytes; i++)
 8257             {
 8258               c = msg[i];
 8259               MAKE_CHAR_MULTIBYTE (c);
 8260               char_bytes = CHAR_STRING (c, str);
 8261               insert_1_both (str, 1, char_bytes, 1, 0, 0);
 8262             }
 8263         }
 8264       else if (nbytes)
 8265         insert_1 (m, nbytes, 1, 0, 0);
 8266 
 8267       if (nlflag)
 8268         {
 8269           int this_bol, this_bol_byte, prev_bol, prev_bol_byte, dup;
 8270           insert_1 ("\n", 1, 1, 0, 0);
 8271 
 8272           scan_newline (Z, Z_BYTE, BEG, BEG_BYTE, -2, 0);
 8273           this_bol = PT;
 8274           this_bol_byte = PT_BYTE;
 8275 
 8276           /* See if this line duplicates the previous one.
 8277              If so, combine duplicates.  */
 8278           if (this_bol > BEG)
 8279             {
 8280               scan_newline (PT, PT_BYTE, BEG, BEG_BYTE, -2, 0);
 8281               prev_bol = PT;
 8282               prev_bol_byte = PT_BYTE;
 8283 
 8284               dup = message_log_check_duplicate (prev_bol, prev_bol_byte,
 8285                                                  this_bol, this_bol_byte);
 8286               if (dup)
 8287                 {
 8288                   del_range_both (prev_bol, prev_bol_byte,
 8289                                   this_bol, this_bol_byte, 0);
 8290                   if (dup > 1)
 8291                     {
 8292                       char dupstr[40];
 8293                       int duplen;
 8294 
 8295                       /* If you change this format, don't forget to also
 8296                          change message_log_check_duplicate.  */
 8297                       sprintf (dupstr, " [%d times]", dup);
 8298                       duplen = strlen (dupstr);
 8299                       TEMP_SET_PT_BOTH (Z - 1, Z_BYTE - 1);
 8300                       insert_1 (dupstr, duplen, 1, 0, 1);
 8301                     }
 8302                 }
 8303             }
 8304 
 8305           /* If we have more than the desired maximum number of lines
 8306              in the *Messages* buffer now, delete the oldest ones.
 8307              This is safe because we don't have undo in this buffer.  */
 8308 
 8309           if (NATNUMP (Vmessage_log_max))
 8310             {
 8311               scan_newline (Z, Z_BYTE, BEG, BEG_BYTE,
 8312                             -XFASTINT (Vmessage_log_max) - 1, 0);
 8313               del_range_both (BEG, BEG_BYTE, PT, PT_BYTE, 0);
 8314             }
 8315         }
 8316       BEGV = XMARKER (oldbegv)->charpos;
 8317       BEGV_BYTE = marker_byte_position (oldbegv);
 8318 
 8319       if (zv_at_end)
 8320         {
 8321           ZV = Z;
 8322           ZV_BYTE = Z_BYTE;
 8323         }
 8324       else
 8325         {
 8326           ZV = XMARKER (oldzv)->charpos;
 8327           ZV_BYTE = marker_byte_position (oldzv);
 8328         }
 8329 
 8330       if (point_at_end)
 8331         TEMP_SET_PT_BOTH (Z, Z_BYTE);
 8332       else
 8333         /* We can't do Fgoto_char (oldpoint) because it will run some
 8334            Lisp code.  */
 8335         TEMP_SET_PT_BOTH (XMARKER (oldpoint)->charpos,
 8336                           XMARKER (oldpoint)->bytepos);
 8337 
 8338       UNGCPRO;
 8339       unchain_marker (XMARKER (oldpoint));
 8340       unchain_marker (XMARKER (oldbegv));
 8341       unchain_marker (XMARKER (oldzv));
 8342 
 8343       tem = Fget_buffer_window (Fcurrent_buffer (), Qt);
 8344       set_buffer_internal (oldbuf);
 8345       if (NILP (tem))
 8346         windows_or_buffers_changed = old_windows_or_buffers_changed;
 8347       message_log_need_newline = !nlflag;
 8348       Vdeactivate_mark = old_deactivate_mark;
 8349     }
 8350 }
 8351 
 8352 
 8353 /* We are at the end of the buffer after just having inserted a newline.
 8354    (Note: We depend on the fact we won't be crossing the gap.)
 8355    Check to see if the most recent message looks a lot like the previous one.
 8356    Return 0 if different, 1 if the new one should just replace it, or a
 8357    value N > 1 if we should also append " [N times]".  */
 8358 
 8359 static int
 8360 message_log_check_duplicate (prev_bol, prev_bol_byte, this_bol, this_bol_byte)
 8361      int prev_bol, this_bol;
 8362      int prev_bol_byte, this_bol_byte;
 8363 {
 8364   int i;
 8365   int len = Z_BYTE - 1 - this_bol_byte;
 8366   int seen_dots = 0;
 8367   unsigned char *p1 = BUF_BYTE_ADDRESS (current_buffer, prev_bol_byte);
 8368   unsigned char *p2 = BUF_BYTE_ADDRESS (current_buffer, this_bol_byte);
 8369 
 8370   for (i = 0; i < len; i++)
 8371     {
 8372       if (i >= 3 && p1[i-3] == '.' && p1[i-2] == '.' && p1[i-1] == '.')
 8373         seen_dots = 1;
 8374       if (p1[i] != p2[i])
 8375         return seen_dots;
 8376     }
 8377   p1 += len;
 8378   if (*p1 == '\n')
 8379     return 2;
 8380   if (*p1++ == ' ' && *p1++ == '[')
 8381     {
 8382       int n = 0;
 8383       while (*p1 >= '0' && *p1 <= '9')
 8384         n = n * 10 + *p1++ - '0';
 8385       if (strncmp (p1, " times]\n", 8) == 0)
 8386         return n+1;
 8387     }
 8388   return 0;
 8389 }
 8390 
 8391 
 8392 /* Display an echo area message M with a specified length of NBYTES
 8393    bytes.  The string may include null characters.  If M is 0, clear
 8394    out any existing message, and let the mini-buffer text show
 8395    through.
 8396 
 8397    This may GC, so the buffer M must NOT point to a Lisp string.  */
 8398 
 8399 void
 8400 message2 (m, nbytes, multibyte)
 8401      const char *m;
 8402      int nbytes;
 8403      int multibyte;
 8404 {
 8405   /* First flush out any partial line written with print.  */
 8406   message_log_maybe_newline ();
 8407   if (m)
 8408     message_dolog (m, nbytes, 1, multibyte);
 8409   message2_nolog (m, nbytes, multibyte);
 8410 }
 8411 
 8412 
 8413 /* The non-logging counterpart of message2.  */
 8414 
 8415 void
 8416 message2_nolog (m, nbytes, multibyte)
 8417      const char *m;
 8418      int nbytes, multibyte;
 8419 {
 8420   struct frame *sf = SELECTED_FRAME ();
 8421   message_enable_multibyte = multibyte;
 8422 
 8423   if (FRAME_INITIAL_P (sf))
 8424     {
 8425       if (noninteractive_need_newline)
 8426         putc ('\n', stderr);
 8427       noninteractive_need_newline = 0;
 8428       if (m)
 8429         fwrite (m, nbytes, 1, stderr);
 8430       if (cursor_in_echo_area == 0)
 8431         fprintf (stderr, "\n");
 8432       fflush (stderr);
 8433     }
 8434   /* A null message buffer means that the frame hasn't really been
 8435      initialized yet.  Error messages get reported properly by
 8436      cmd_error, so this must be just an informative message; toss it.  */
 8437   else if (INTERACTIVE
 8438            && sf->glyphs_initialized_p
 8439            && FRAME_MESSAGE_BUF (sf))
 8440     {
 8441       Lisp_Object mini_window;
 8442       struct frame *f;
 8443 
 8444       /* Get the frame containing the mini-buffer
 8445          that the selected frame is using.  */
 8446       mini_window = FRAME_MINIBUF_WINDOW (sf);
 8447       f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
 8448 
 8449       FRAME_SAMPLE_VISIBILITY (f);
 8450       if (FRAME_VISIBLE_P (sf)
 8451           && ! FRAME_VISIBLE_P (f))
 8452         Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window)));
 8453 
 8454       if (m)
 8455         {
 8456           set_message (m, Qnil, nbytes, multibyte);
 8457           if (minibuffer_auto_raise)
 8458             Fraise_frame  (WINDOW_FRAME (XWINDOW (mini_window)));
 8459         }
 8460       else
 8461         clear_message (1, 1);
 8462 
 8463       do_pending_window_change (0);
 8464       echo_area_display (1);
 8465       do_pending_window_change (0);
 8466       if (FRAME_TERMINAL (f)->frame_up_to_date_hook != 0 && ! gc_in_progress)
 8467         (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
 8468     }
 8469 }
 8470 
 8471 
 8472 /* Display an echo area message M with a specified length of NBYTES
 8473    bytes.  The string may include null characters.  If M is not a
 8474    string, clear out any existing message, and let the mini-buffer
 8475    text show through.
 8476 
 8477    This function cancels echoing.  */
 8478 
 8479 void
 8480 message3 (m, nbytes, multibyte)
 8481      Lisp_Object m;
 8482      int nbytes;
 8483      int multibyte;
 8484 {
 8485   struct gcpro gcpro1;
 8486 
 8487   GCPRO1 (m);
 8488   clear_message (1,1);
 8489   cancel_echoing ();
 8490 
 8491   /* First flush out any partial line written with print.  */
 8492   message_log_maybe_newline ();
 8493   if (STRINGP (m))
 8494     {
 8495       char *buffer;
 8496       USE_SAFE_ALLOCA;
 8497 
 8498       SAFE_ALLOCA (buffer, char *, nbytes);
 8499       bcopy (SDATA (m), buffer, nbytes);
 8500       message_dolog (buffer, nbytes, 1, multibyte);
 8501       SAFE_FREE ();
 8502     }
 8503   message3_nolog (m, nbytes, multibyte);
 8504 
 8505   UNGCPRO;
 8506 }
 8507 
 8508 
 8509 /* The non-logging version of message3.
 8510    This does not cancel echoing, because it is used for echoing.
 8511    Perhaps we need to make a separate function for echoing
 8512    and make this cancel echoing.  */
 8513 
 8514 void
 8515 message3_nolog (m, nbytes, multibyte)
 8516      Lisp_Object m;
 8517      int nbytes, multibyte;
 8518 {
 8519   struct frame *sf = SELECTED_FRAME ();
 8520   message_enable_multibyte = multibyte;
 8521 
 8522   if (FRAME_INITIAL_P (sf))
 8523     {
 8524       if (noninteractive_need_newline)
 8525         putc ('\n', stderr);
 8526       noninteractive_need_newline = 0;
 8527       if (STRINGP (m))
 8528         fwrite (SDATA (m), nbytes, 1, stderr);
 8529       if (cursor_in_echo_area == 0)
 8530         fprintf (stderr, "\n");
 8531       fflush (stderr);
 8532     }
 8533   /* A null message buffer means that the frame hasn't really been
 8534      initialized yet.  Error messages get reported properly by
 8535      cmd_error, so this must be just an informative message; toss it.  */
 8536   else if (INTERACTIVE
 8537            && sf->glyphs_initialized_p
 8538            && FRAME_MESSAGE_BUF (sf))
 8539     {
 8540       Lisp_Object mini_window;
 8541       Lisp_Object frame;
 8542       struct frame *f;
 8543 
 8544       /* Get the frame containing the mini-buffer
 8545          that the selected frame is using.  */
 8546       mini_window = FRAME_MINIBUF_WINDOW (sf);
 8547       frame = XWINDOW (mini_window)->frame;
 8548       f = XFRAME (frame);
 8549 
 8550       FRAME_SAMPLE_VISIBILITY (f);
 8551       if (FRAME_VISIBLE_P (sf)
 8552           && !FRAME_VISIBLE_P (f))
 8553         Fmake_frame_visible (frame);
 8554 
 8555       if (STRINGP (m) && SCHARS (m) > 0)
 8556         {
 8557           set_message (NULL, m, nbytes, multibyte);
 8558           if (minibuffer_auto_raise)
 8559             Fraise_frame (frame);
 8560           /* Assume we are not echoing.
 8561              (If we are, echo_now will override this.)  */
 8562           echo_message_buffer = Qnil;
 8563         }
 8564       else
 8565         clear_message (1, 1);
 8566 
 8567       do_pending_window_change (0);
 8568       echo_area_display (1);
 8569       do_pending_window_change (0);
 8570       if (FRAME_TERMINAL (f)->frame_up_to_date_hook != 0 && ! gc_in_progress)
 8571         (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
 8572     }
 8573 }
 8574 
 8575 
 8576 /* Display a null-terminated echo area message M.  If M is 0, clear
 8577    out any existing message, and let the mini-buffer text show through.
 8578 
 8579    The buffer M must continue to exist until after the echo area gets
 8580    cleared or some other message gets displayed there.  Do not pass
 8581    text that is stored in a Lisp string.  Do not pass text in a buffer
 8582    that was alloca'd.  */
 8583 
 8584 void
 8585 message1 (m)
 8586      char *m;
 8587 {
 8588   message2 (m, (m ? strlen (m) : 0), 0);
 8589 }
 8590 
 8591 
 8592 /* The non-logging counterpart of message1.  */
 8593 
 8594 void
 8595 message1_nolog (m)
 8596      char *m;
 8597 {
 8598   message2_nolog (m, (m ? strlen (m) : 0), 0);
 8599 }
 8600 
 8601 /* Display a message M which contains a single %s
 8602    which gets replaced with STRING.  */
 8603 
 8604 void
 8605 message_with_string (m, string, log)
 8606      char *m;
 8607      Lisp_Object string;
 8608      int log;
 8609 {
 8610   CHECK_STRING (string);
 8611 
 8612   if (noninteractive)
 8613     {
 8614       if (m)
 8615         {
 8616           if (noninteractive_need_newline)
 8617             putc ('\n', stderr);
 8618           noninteractive_need_newline = 0;
 8619           fprintf (stderr, m, SDATA (string));
 8620           if (!cursor_in_echo_area)
 8621             fprintf (stderr, "\n");
 8622           fflush (stderr);
 8623         }
 8624     }
 8625   else if (INTERACTIVE)
 8626     {
 8627       /* The frame whose minibuffer we're going to display the message on.
 8628          It may be larger than the selected frame, so we need
 8629          to use its buffer, not the selected frame's buffer.  */
 8630       Lisp_Object mini_window;
 8631       struct frame *f, *sf = SELECTED_FRAME ();
 8632 
 8633       /* Get the frame containing the minibuffer
 8634          that the selected frame is using.  */
 8635       mini_window = FRAME_MINIBUF_WINDOW (sf);
 8636       f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
 8637 
 8638       /* A null message buffer means that the frame hasn't really been
 8639          initialized yet.  Error messages get reported properly by
 8640          cmd_error, so this must be just an informative message; toss it.  */
 8641       if (FRAME_MESSAGE_BUF (f))
 8642         {
 8643           Lisp_Object args[2], message;
 8644           struct gcpro gcpro1, gcpro2;
 8645 
 8646           args[0] = build_string (m);
 8647           args[1] = message = string;
 8648           GCPRO2 (args[0], message);
 8649           gcpro1.nvars = 2;
 8650 
 8651           message = Fformat (2, args);
 8652 
 8653           if (log)
 8654             message3 (message, SBYTES (message), STRING_MULTIBYTE (message));
 8655           else
 8656             message3_nolog (message, SBYTES (message), STRING_MULTIBYTE (message));
 8657 
 8658           UNGCPRO;
 8659 
 8660           /* Print should start at the beginning of the message
 8661              buffer next time.  */
 8662           message_buf_print = 0;
 8663         }
 8664     }
 8665 }
 8666 
 8667 
 8668 /* Dump an informative message to the minibuf.  If M is 0, clear out
 8669    any existing message, and let the mini-buffer text show through.  */
 8670 
 8671 /* VARARGS 1 */
 8672 void
 8673 message (m, a1, a2, a3)
 8674      char *m;
 8675      EMACS_INT a1, a2, a3;
 8676 {
 8677   if (noninteractive)
 8678     {
 8679       if (m)
 8680         {
 8681           if (noninteractive_need_newline)
 8682             putc ('\n', stderr);
 8683           noninteractive_need_newline = 0;
 8684           fprintf (stderr, m, a1, a2, a3);
 8685           if (cursor_in_echo_area == 0)
 8686             fprintf (stderr, "\n");
 8687           fflush (stderr);
 8688         }
 8689     }
 8690   else if (INTERACTIVE)
 8691     {
 8692       /* The frame whose mini-buffer we're going to display the message
 8693          on.  It may be larger than the selected frame, so we need to
 8694          use its buffer, not the selected frame's buffer.  */
 8695       Lisp_Object mini_window;
 8696       struct frame *f, *sf = SELECTED_FRAME ();
 8697 
 8698       /* Get the frame containing the mini-buffer
 8699          that the selected frame is using.  */
 8700       mini_window = FRAME_MINIBUF_WINDOW (sf);
 8701       f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
 8702 
 8703       /* A null message buffer means that the frame hasn't really been
 8704          initialized yet.  Error messages get reported properly by
 8705          cmd_error, so this must be just an informative message; toss
 8706          it.  */
 8707       if (FRAME_MESSAGE_BUF (f))
 8708         {
 8709           if (m)
 8710             {
 8711               int len;
 8712               char *a[3];
 8713               a[0] = (char *) a1;
 8714               a[1] = (char *) a2;
 8715               a[2] = (char *) a3;
 8716 
 8717               len = doprnt (FRAME_MESSAGE_BUF (f),
 8718                             FRAME_MESSAGE_BUF_SIZE (f), m, (char *)0, 3, a);
 8719 
 8720               message2 (FRAME_MESSAGE_BUF (f), len, 0);
 8721             }
 8722           else
 8723             message1 (0);
 8724 
 8725           /* Print should start at the beginning of the message
 8726              buffer next time.  */
 8727           message_buf_print = 0;
 8728         }
 8729     }
 8730 }
 8731 
 8732 
 8733 /* The non-logging version of message.  */
 8734 
 8735 void
 8736 message_nolog (m, a1, a2, a3)
 8737      char *m;
 8738      EMACS_INT a1, a2, a3;
 8739 {
 8740   Lisp_Object old_log_max;
 8741   old_log_max = Vmessage_log_max;
 8742   Vmessage_log_max = Qnil;
 8743   message (m, a1, a2, a3);
 8744   Vmessage_log_max = old_log_max;
 8745 }
 8746 
 8747 
 8748 /* Display the current message in the current mini-buffer.  This is
 8749    only called from error handlers in process.c, and is not time
 8750    critical.  */
 8751 
 8752 void
 8753 update_echo_area ()
 8754 {
 8755   if (!NILP (echo_area_buffer[0]))
 8756     {
 8757       Lisp_Object string;
 8758       string = Fcurrent_message ();
 8759       message3 (string, SBYTES (string),
 8760                 !NILP (current_buffer->enable_multibyte_characters));
 8761     }
 8762 }
 8763 
 8764 
 8765 /* Make sure echo area buffers in `echo_buffers' are live.
 8766    If they aren't, make new ones.  */
 8767 
 8768 static void
 8769 ensure_echo_area_buffers ()
 8770 {
 8771   int i;
 8772 
 8773   for (i = 0; i < 2; ++i)
 8774     if (!BUFFERP (echo_buffer[i])
 8775         || NILP (XBUFFER (echo_buffer[i])->name))
 8776       {
 8777         char name[30];
 8778         Lisp_Object old_buffer;
 8779         int j;
 8780 
 8781         old_buffer = echo_buffer[i];
 8782         sprintf (name, " *Echo Area %d*", i);
 8783         echo_buffer[i] = Fget_buffer_create (build_string (name));
 8784         XBUFFER (echo_buffer[i])->truncate_lines = Qnil;
 8785         /* to force word wrap in echo area -
 8786            it was decided to postpone this*/
 8787         /* XBUFFER (echo_buffer[i])->word_wrap = Qt; */
 8788 
 8789         for (j = 0; j < 2; ++j)
 8790           if (EQ (old_buffer, echo_area_buffer[j]))
 8791             echo_area_buffer[j] = echo_buffer[i];
 8792       }
 8793 }
 8794 
 8795 
 8796 /* Call FN with args A1..A4 with either the current or last displayed
 8797    echo_area_buffer as current buffer.
 8798 
 8799    WHICH zero means use the current message buffer
 8800    echo_area_buffer[0].  If that is nil, choose a suitable buffer
 8801    from echo_buffer[] and clear it.
 8802 
 8803    WHICH > 0 means use echo_area_buffer[1].  If that is nil, choose a
 8804    suitable buffer from echo_buffer[] and clear it.
 8805 
 8806    If WHICH < 0, set echo_area_buffer[1] to echo_area_buffer[0], so
 8807    that the current message becomes the last displayed one, make
 8808    choose a suitable buffer for echo_area_buffer[0], and clear it.
 8809 
 8810    Value is what FN returns.  */
 8811 
 8812 static int
 8813 with_echo_area_buffer (w, which, fn, a1, a2, a3, a4)
 8814      struct window *w;
 8815      int which;
 8816      int (*fn) P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
 8817      EMACS_INT a1;
 8818      Lisp_Object a2;
 8819      EMACS_INT a3, a4;
 8820 {
 8821   Lisp_Object buffer;
 8822   int this_one, the_other, clear_buffer_p, rc;
 8823   int count = SPECPDL_INDEX ();
 8824 
 8825   /* If buffers aren't live, make new ones.  */
 8826   ensure_echo_area_buffers ();
 8827 
 8828   clear_buffer_p = 0;
 8829 
 8830   if (which == 0)
 8831     this_one = 0, the_other = 1;
 8832   else if (which > 0)
 8833     this_one = 1, the_other = 0;
 8834   else
 8835     {
 8836       this_one = 0, the_other = 1;
 8837       clear_buffer_p = 1;
 8838 
 8839       /* We need a fresh one in case the current echo buffer equals
 8840          the one containing the last displayed echo area message.  */
 8841       if (!NILP (echo_area_buffer[this_one])
 8842           && EQ (echo_area_buffer[this_one], echo_area_buffer[the_other]))
 8843         echo_area_buffer[this_one] = Qnil;
 8844     }
 8845 
 8846   /* Choose a suitable buffer from echo_buffer[] is we don't
 8847      have one.  */
 8848   if (NILP (echo_area_buffer[this_one]))
 8849     {
 8850       echo_area_buffer[this_one]
 8851         = (EQ (echo_area_buffer[the_other], echo_buffer[this_one])
 8852            ? echo_buffer[the_other]
 8853            : echo_buffer[this_one]);
 8854       clear_buffer_p = 1;
 8855     }
 8856 
 8857   buffer = echo_area_buffer[this_one];
 8858 
 8859   /* Don't get confused by reusing the buffer used for echoing
 8860      for a different purpose.  */
 8861   if (echo_kboard == NULL && EQ (buffer, echo_message_buffer))
 8862     cancel_echoing ();
 8863 
 8864   record_unwind_protect (unwind_with_echo_area_buffer,
 8865                          with_echo_area_buffer_unwind_data (w));
 8866 
 8867   /* Make the echo area buffer current.  Note that for display
 8868      purposes, it is not necessary that the displayed window's buffer
 8869      == current_buffer, except for text property lookup.  So, let's
 8870      only set that buffer temporarily here without doing a full
 8871      Fset_window_buffer.  We must also change w->pointm, though,
 8872      because otherwise an assertions in unshow_buffer fails, and Emacs
 8873      aborts.  */
 8874   set_buffer_internal_1 (XBUFFER (buffer));
 8875   if (w)
 8876     {
 8877       w->buffer = buffer;
 8878       set_marker_both (w->pointm, buffer, BEG, BEG_BYTE);
 8879     }
 8880 
 8881   current_buffer->undo_list = Qt;
 8882   current_buffer->read_only = Qnil;
 8883   specbind (Qinhibit_read_only, Qt);
 8884   specbind (Qinhibit_modification_hooks, Qt);
 8885 
 8886   if (clear_buffer_p && Z > BEG)
 8887     del_range (BEG, Z);
 8888 
 8889   xassert (BEGV >= BEG);
 8890   xassert (ZV <= Z && ZV >= BEGV);
 8891 
 8892   rc = fn (a1, a2, a3, a4);
 8893 
 8894   xassert (BEGV >= BEG);
 8895   xassert (ZV <= Z && ZV >= BEGV);
 8896 
 8897   unbind_to (count, Qnil);
 8898   return rc;
 8899 }
 8900 
 8901 
 8902 /* Save state that should be preserved around the call to the function
 8903    FN called in with_echo_area_buffer.  */
 8904 
 8905 static Lisp_Object
 8906 with_echo_area_buffer_unwind_data (w)
 8907      struct window *w;
 8908 {
 8909   int i = 0;
 8910   Lisp_Object vector, tmp;
 8911 
 8912   /* Reduce consing by keeping one vector in
 8913      Vwith_echo_area_save_vector.  */
 8914   vector = Vwith_echo_area_save_vector;
 8915   Vwith_echo_area_save_vector = Qnil;
 8916 
 8917   if (NILP (vector))
 8918     vector = Fmake_vector (make_number (7), Qnil);
 8919 
 8920   XSETBUFFER (tmp, current_buffer); ASET (vector, i, tmp); ++i;
 8921   ASET (vector, i, Vdeactivate_mark); ++i;
 8922   ASET (vector, i, make_number (windows_or_buffers_changed)); ++i;
 8923 
 8924   if (w)
 8925     {
 8926       XSETWINDOW (tmp, w); ASET (vector, i, tmp); ++i;
 8927       ASET (vector, i, w->buffer); ++i;
 8928       ASET (vector, i, make_number (XMARKER (w->pointm)->charpos)); ++i;
 8929       ASET (vector, i, make_number (XMARKER (w->pointm)->bytepos)); ++i;
 8930     }
 8931   else
 8932     {
 8933       int end = i + 4;
 8934       for (; i < end; ++i)
 8935         ASET (vector, i, Qnil);
 8936     }
 8937 
 8938   xassert (i == ASIZE (vector));
 8939   return vector;
 8940 }
 8941 
 8942 
 8943 /* Restore global state from VECTOR which was created by
 8944    with_echo_area_buffer_unwind_data.  */
 8945 
 8946 static Lisp_Object
 8947 unwind_with_echo_area_buffer (vector)
 8948      Lisp_Object vector;
 8949 {
 8950   set_buffer_internal_1 (XBUFFER (AREF (vector, 0)));
 8951   Vdeactivate_mark = AREF (vector, 1);
 8952   windows_or_buffers_changed = XFASTINT (AREF (vector, 2));
 8953 
 8954   if (WINDOWP (AREF (vector, 3)))
 8955     {
 8956       struct window *w;
 8957       Lisp_Object buffer, charpos, bytepos;
 8958 
 8959       w = XWINDOW (AREF (vector, 3));
 8960       buffer = AREF (vector, 4);
 8961       charpos = AREF (vector, 5);
 8962       bytepos = AREF (vector, 6);
 8963 
 8964       w->buffer = buffer;
 8965       set_marker_both (w->pointm, buffer,
 8966                        XFASTINT (charpos), XFASTINT (bytepos));
 8967     }
 8968 
 8969   Vwith_echo_area_save_vector = vector;
 8970   return Qnil;
 8971 }
 8972 
 8973 
 8974 /* Set up the echo area for use by print functions.  MULTIBYTE_P
 8975    non-zero means we will print multibyte.  */
 8976 
 8977 void
 8978 setup_echo_area_for_printing (multibyte_p)
 8979      int multibyte_p;
 8980 {
 8981   /* If we can't find an echo area any more, exit.  */
 8982   if (! FRAME_LIVE_P (XFRAME (selected_frame)))
 8983     Fkill_emacs (Qnil);
 8984 
 8985   ensure_echo_area_buffers ();
 8986 
 8987   if (!message_buf_print)
 8988     {
 8989       /* A message has been output since the last time we printed.
 8990          Choose a fresh echo area buffer.  */
 8991       if (EQ (echo_area_buffer[1], echo_buffer[0]))
 8992         echo_area_buffer[0] = echo_buffer[1];
 8993       else
 8994         echo_area_buffer[0] = echo_buffer[0];
 8995 
 8996       /* Switch to that buffer and clear it.  */
 8997       set_buffer_internal (XBUFFER (echo_area_buffer[0]));
 8998       current_buffer->truncate_lines = Qnil;
 8999 
 9000       if (Z > BEG)
 9001         {
 9002           int count = SPECPDL_INDEX ();
 9003           specbind (Qinhibit_read_only, Qt);
 9004           /* Note that undo recording is always disabled.  */
 9005           del_range (BEG, Z);
 9006           unbind_to (count, Qnil);
 9007         }
 9008       TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
 9009 
 9010       /* Set up the buffer for the multibyteness we need.  */
 9011       if (multibyte_p
 9012           != !NILP (current_buffer->enable_multibyte_characters))
 9013         Fset_buffer_multibyte (multibyte_p ? Qt : Qnil);
 9014 
 9015       /* Raise the frame containing the echo area.  */
 9016       if (minibuffer_auto_raise)
 9017         {
 9018           struct frame *sf = SELECTED_FRAME ();
 9019           Lisp_Object mini_window;
 9020           mini_window = FRAME_MINIBUF_WINDOW (sf);
 9021           Fraise_frame  (WINDOW_FRAME (XWINDOW (mini_window)));
 9022         }
 9023 
 9024       message_log_maybe_newline ();
 9025       message_buf_print = 1;
 9026     }
 9027   else
 9028     {
 9029       if (NILP (echo_area_buffer[0]))
 9030         {
 9031           if (EQ (echo_area_buffer[1], echo_buffer[0]))
 9032             echo_area_buffer[0] = echo_buffer[1];
 9033           else
 9034             echo_area_buffer[0] = echo_buffer[0];
 9035         }
 9036 
 9037       if (current_buffer != XBUFFER (echo_area_buffer[0]))
 9038         {
 9039           /* Someone switched buffers between print requests.  */
 9040           set_buffer_internal (XBUFFER (echo_area_buffer[0]));
 9041           current_buffer->truncate_lines = Qnil;
 9042         }
 9043     }
 9044 }
 9045 
 9046 
 9047 /* Display an echo area message in window W.  Value is non-zero if W's
 9048    height is changed.  If display_last_displayed_message_p is
 9049    non-zero, display the message that was last displayed, otherwise
 9050    display the current message.  */
 9051 
 9052 static int
 9053 display_echo_area (w)
 9054      struct window *w;
 9055 {
 9056   int i, no_message_p, window_height_changed_p, count;
 9057 
 9058   /* Temporarily disable garbage collections while displaying the echo
 9059      area.  This is done because a GC can print a message itself.
 9060      That message would modify the echo area buffer's contents while a
 9061      redisplay of the buffer is going on, and seriously confuse
 9062      redisplay.  */
 9063   count = inhibit_garbage_collection ();
 9064 
 9065   /* If there is no message, we must call display_echo_area_1
 9066      nevertheless because it resizes the window.  But we will have to
 9067      reset the echo_area_buffer in question to nil at the end because
 9068      with_echo_area_buffer will sets it to an empty buffer.  */
 9069   i = display_last_displayed_message_p ? 1 : 0;
 9070   no_message_p = NILP (echo_area_buffer[i]);
 9071 
 9072   window_height_changed_p
 9073     = with_echo_area_buffer (w, display_last_displayed_message_p,
 9074                              display_echo_area_1,
 9075                              (EMACS_INT) w, Qnil, 0, 0);
 9076 
 9077   if (no_message_p)
 9078     echo_area_buffer[i] = Qnil;
 9079 
 9080   unbind_to (count, Qnil);
 9081   return window_height_changed_p;
 9082 }
 9083 
 9084 
 9085 /* Helper for display_echo_area.  Display the current buffer which
 9086    contains the current echo area message in window W, a mini-window,
 9087    a pointer to which is passed in A1.  A2..A4 are currently not used.
 9088    Change the height of W so that all of the message is displayed.
 9089    Value is non-zero if height of W was changed.  */
 9090 
 9091 static int
 9092 display_echo_area_1 (a1, a2, a3, a4)
 9093      EMACS_INT a1;
 9094      Lisp_Object a2;
 9095      EMACS_INT a3, a4;
 9096 {
 9097   struct window *w = (struct window *) a1;
 9098   Lisp_Object window;
 9099   struct text_pos start;
 9100   int window_height_changed_p = 0;
 9101 
 9102   /* Do this before displaying, so that we have a large enough glyph
 9103      matrix for the display.  If we can't get enough space for the
 9104      whole text, display the last N lines.  That works by setting w->start.  */
 9105   window_height_changed_p = resize_mini_window (w, 0);
 9106 
 9107   /* Use the starting position chosen by resize_mini_window.  */
 9108   SET_TEXT_POS_FROM_MARKER (start, w->start);
 9109 
 9110   /* Display.  */
 9111   clear_glyph_matrix (w->desired_matrix);
 9112   XSETWINDOW (window, w);
 9113   try_window (window, start, 0);
 9114 
 9115   return window_height_changed_p;
 9116 }
 9117 
 9118 
 9119 /* Resize the echo area window to exactly the size needed for the
 9120    currently displayed message, if there is one.  If a mini-buffer
 9121    is active, don't shrink it.  */
 9122 
 9123 void
 9124 resize_echo_area_exactly ()
 9125 {
 9126   if (BUFFERP (echo_area_buffer[0])
 9127       && WINDOWP (echo_area_window))
 9128     {
 9129       struct window *w = XWINDOW (echo_area_window);
 9130       int resized_p;
 9131       Lisp_Object resize_exactly;
 9132 
 9133       if (minibuf_level == 0)
 9134         resize_exactly = Qt;
 9135       else
 9136         resize_exactly = Qnil;
 9137 
 9138       resized_p = with_echo_area_buffer (w, 0, resize_mini_window_1,
 9139                                          (EMACS_INT) w, resize_exactly, 0, 0);
 9140       if (resized_p)
 9141         {
 9142           ++windows_or_buffers_changed;
 9143           ++update_mode_lines;
 9144           redisplay_internal (0);
 9145         }
 9146     }
 9147 }
 9148 
 9149 
 9150 /* Callback function for with_echo_area_buffer, when used from
 9151    resize_echo_area_exactly.  A1 contains a pointer to the window to
 9152    resize, EXACTLY non-nil means resize the mini-window exactly to the
 9153    size of the text displayed.  A3 and A4 are not used.  Value is what
 9154    resize_mini_window returns.  */
 9155 
 9156 static int
 9157 resize_mini_window_1 (a1, exactly, a3, a4)
 9158      EMACS_INT a1;
 9159      Lisp_Object exactly;
 9160      EMACS_INT a3, a4;
 9161 {
 9162   return resize_mini_window ((struct window *) a1, !NILP (exactly));
 9163 }
 9164 
 9165 
 9166 /* Resize mini-window W to fit the size of its contents.  EXACT_P
 9167    means size the window exactly to the size needed.  Otherwise, it's
 9168    only enlarged until W's buffer is empty.
 9169 
 9170    Set W->start to the right place to begin display.  If the whole
 9171    contents fit, start at the beginning.  Otherwise, start so as
 9172    to make the end of the contents appear.  This is particularly
 9173    important for y-or-n-p, but seems desirable generally.
 9174 
 9175    Value is non-zero if the window height has been changed.  */
 9176 
 9177 int
 9178 resize_mini_window (w, exact_p)
 9179      struct window *w;
 9180      int exact_p;
 9181 {
 9182   struct frame *f = XFRAME (w->frame);
 9183   int window_height_changed_p = 0;
 9184 
 9185   xassert (MINI_WINDOW_P (w));
 9186 
 9187   /* By default, start display at the beginning.  */
 9188   set_marker_both (w->start, w->buffer,
 9189                    BUF_BEGV (XBUFFER (w->buffer)),
 9190                    BUF_BEGV_BYTE (XBUFFER (w->buffer)));
 9191 
 9192   /* Don't resize windows while redisplaying a window; it would
 9193      confuse redisplay functions when the size of the window they are
 9194      displaying changes from under them.  Such a resizing can happen,
 9195      for instance, when which-func prints a long message while
 9196      we are running fontification-functions.  We're running these
 9197      functions with safe_call which binds inhibit-redisplay to t.  */
 9198   if (!NILP (Vinhibit_redisplay))
 9199     return 0;
 9200 
 9201   /* Nil means don't try to resize.  */
 9202   if (NILP (Vresize_mini_windows)
 9203       || (FRAME_X_P (f) && FRAME_X_OUTPUT (f) == NULL))
 9204     return 0;
 9205 
 9206   if (!FRAME_MINIBUF_ONLY_P (f))
 9207     {
 9208       struct it it;
 9209       struct window *root = XWINDOW (FRAME_ROOT_WINDOW (f));
 9210       int total_height = WINDOW_TOTAL_LINES (root) + WINDOW_TOTAL_LINES (w);
 9211       int height, max_height;
 9212       int unit = FRAME_LINE_HEIGHT (f);
 9213       struct text_pos start;
 9214       struct buffer *old_current_buffer = NULL;
 9215 
 9216       if (current_buffer != XBUFFER (w->buffer))
 9217         {
 9218           old_current_buffer = current_buffer;
 9219           set_buffer_internal (XBUFFER (w->buffer));
 9220         }
 9221 
 9222       init_iterator (&it, w, BEGV, BEGV_BYTE, NULL, DEFAULT_FACE_ID);
 9223 
 9224       /* Compute the max. number of lines specified by the user.  */
 9225       if (FLOATP (Vmax_mini_window_height))
 9226         max_height = XFLOATINT (Vmax_mini_window_height) * FRAME_LINES (f);
 9227       else if (INTEGERP (Vmax_mini_window_height))
 9228         max_height = XINT (Vmax_mini_window_height);
 9229       else
 9230         max_height = total_height / 4;
 9231 
 9232       /* Correct that max. height if it's bogus.  */
 9233       max_height = max (1, max_height);
 9234       max_height = min (total_height, max_height);
 9235 
 9236       /* Find out the height of the text in the window.  */
 9237       if (it.line_wrap == TRUNCATE)
 9238         height = 1;
 9239       else
 9240         {
 9241           last_height = 0;
 9242           move_it_to (&it, ZV, -1, -1, -1, MOVE_TO_POS);
 9243           if (it.max_ascent == 0 && it.max_descent == 0)
 9244             height = it.current_y + last_height;
 9245           else
 9246             height = it.current_y + it.max_ascent + it.max_descent;
 9247           height -= min (it.extra_line_spacing, it.max_extra_line_spacing);
 9248           height = (height + unit - 1) / unit;
 9249         }
 9250 
 9251       /* Compute a suitable window start.  */
 9252       if (height > max_height)
 9253         {
 9254           height = max_height;
 9255           init_iterator (&it, w, ZV, ZV_BYTE, NULL, DEFAULT_FACE_ID);
 9256           move_it_vertically_backward (&it, (height - 1) * unit);
 9257           start = it.current.pos;
 9258         }
 9259       else
 9260         SET_TEXT_POS (start, BEGV, BEGV_BYTE);
 9261       SET_MARKER_FROM_TEXT_POS (w->start, start);
 9262 
 9263       if (EQ (Vresize_mini_windows, Qgrow_only))
 9264         {
 9265           /* Let it grow only, until we display an empty message, in which
 9266              case the window shrinks again.  */
 9267           if (height > WINDOW_TOTAL_LINES (w))
 9268             {
 9269               int old_height = WINDOW_TOTAL_LINES (w);
 9270               freeze_window_starts (f, 1);
 9271               grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
 9272               window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
 9273             }
 9274           else if (height < WINDOW_TOTAL_LINES (w)
 9275                    && (exact_p || BEGV == ZV))
 9276             {
 9277               int old_height = WINDOW_TOTAL_LINES (w);
 9278               freeze_window_starts (f, 0);
 9279               shrink_mini_window (w);
 9280               window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
 9281             }
 9282         }
 9283       else
 9284         {
 9285           /* Always resize to exact size needed.  */
 9286           if (height > WINDOW_TOTAL_LINES (w))
 9287             {
 9288               int old_height = WINDOW_TOTAL_LINES (w);
 9289               freeze_window_starts (f, 1);
 9290               grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
 9291               window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
 9292             }
 9293           else if (height < WINDOW_TOTAL_LINES (w))
 9294             {
 9295               int old_height = WINDOW_TOTAL_LINES (w);
 9296               freeze_window_starts (f, 0);
 9297               shrink_mini_window (w);
 9298 
 9299               if (height)
 9300                 {
 9301                   freeze_window_starts (f, 1);
 9302                   grow_mini_window (w, height - WINDOW_TOTAL_LINES (w));
 9303                 }
 9304 
 9305               window_height_changed_p = WINDOW_TOTAL_LINES (w) != old_height;
 9306             }
 9307         }
 9308 
 9309       if (old_current_buffer)
 9310         set_buffer_internal (old_current_buffer);
 9311     }
 9312 
 9313   return window_height_changed_p;
 9314 }
 9315 
 9316 
 9317 /* Value is the current message, a string, or nil if there is no
 9318    current message.  */
 9319 
 9320 Lisp_Object
 9321 current_message ()
 9322 {
 9323   Lisp_Object msg;
 9324 
 9325   if (!BUFFERP (echo_area_buffer[0]))
 9326     msg = Qnil;
 9327   else
 9328     {
 9329       with_echo_area_buffer (0, 0, current_message_1,
 9330                              (EMACS_INT) &msg, Qnil, 0, 0);
 9331       if (NILP (msg))
 9332         echo_area_buffer[0] = Qnil;
 9333     }
 9334 
 9335   return msg;
 9336 }
 9337 
 9338 
 9339 static int
 9340 current_message_1 (a1, a2, a3, a4)
 9341      EMACS_INT a1;
 9342      Lisp_Object a2;
 9343      EMACS_INT a3, a4;
 9344 {
 9345   Lisp_Object *msg = (Lisp_Object *) a1;
 9346 
 9347   if (Z > BEG)
 9348     *msg = make_buffer_string (BEG, Z, 1);
 9349   else
 9350     *msg = Qnil;
 9351   return 0;
 9352 }
 9353 
 9354 
 9355 /* Push the current message on Vmessage_stack for later restauration
 9356    by restore_message.  Value is non-zero if the current message isn't
 9357    empty.  This is a relatively infrequent operation, so it's not
 9358    worth optimizing.  */
 9359 
 9360 int
 9361 push_message ()
 9362 {
 9363   Lisp_Object msg;
 9364   msg = current_message ();
 9365   Vmessage_stack = Fcons (msg, Vmessage_stack);
 9366   return STRINGP (msg);
 9367 }
 9368 
 9369 
 9370 /* Restore message display from the top of Vmessage_stack.  */
 9371 
 9372 void
 9373 restore_message ()
 9374 {
 9375   Lisp_Object msg;
 9376 
 9377   xassert (CONSP (Vmessage_stack));
 9378   msg = XCAR (Vmessage_stack);
 9379   if (STRINGP (msg))
 9380     message3_nolog (msg, SBYTES (msg), STRING_MULTIBYTE (msg));
 9381   else
 9382     message3_nolog (msg, 0, 0);
 9383 }
 9384 
 9385 
 9386 /* Handler for record_unwind_protect calling pop_message.  */
 9387 
 9388 Lisp_Object
 9389 pop_message_unwind (dummy)
 9390      Lisp_Object dummy;
 9391 {
 9392   pop_message ();
 9393   return Qnil;
 9394 }
 9395 
 9396 /* Pop the top-most entry off Vmessage_stack.  */
 9397 
 9398 void
 9399 pop_message ()
 9400 {
 9401   xassert (CONSP (Vmessage_stack));
 9402   Vmessage_stack = XCDR (Vmessage_stack);
 9403 }
 9404 
 9405 
 9406 /* Check that Vmessage_stack is nil.  Called from emacs.c when Emacs
 9407    exits.  If the stack is not empty, we have a missing pop_message
 9408    somewhere.  */
 9409 
 9410 void
 9411 check_message_stack ()
 9412 {
 9413   if (!NILP (Vmessage_stack))
 9414     abort ();
 9415 }
 9416 
 9417 
 9418 /* Truncate to NCHARS what will be displayed in the echo area the next
 9419    time we display it---but don't redisplay it now.  */
 9420 
 9421 void
 9422 truncate_echo_area (nchars)
 9423      int nchars;
 9424 {
 9425   if (nchars == 0)
 9426     echo_area_buffer[0] = Qnil;
 9427   /* A null message buffer means that the frame hasn't really been
 9428      initialized yet.  Error messages get reported properly by
 9429      cmd_error, so this must be just an informative message; toss it.  */
 9430   else if (!noninteractive
 9431            && INTERACTIVE
 9432            && !NILP (echo_area_buffer[0]))
 9433     {
 9434       struct frame *sf = SELECTED_FRAME ();
 9435       if (FRAME_MESSAGE_BUF (sf))
 9436         with_echo_area_buffer (0, 0, truncate_message_1, nchars, Qnil, 0, 0);
 9437     }
 9438 }
 9439 
 9440 
 9441 /* Helper function for truncate_echo_area.  Truncate the current
 9442    message to at most NCHARS characters.  */
 9443 
 9444 static int
 9445 truncate_message_1 (nchars, a2, a3, a4)
 9446      EMACS_INT nchars;
 9447      Lisp_Object a2;
 9448      EMACS_INT a3, a4;
 9449 {
 9450   if (BEG + nchars < Z)
 9451     del_range (BEG + nchars, Z);
 9452   if (Z == BEG)
 9453     echo_area_buffer[0] = Qnil;
 9454   return 0;
 9455 }
 9456 
 9457 
 9458 /* Set the current message to a substring of S or STRING.
 9459 
 9460    If STRING is a Lisp string, set the message to the first NBYTES
 9461    bytes from STRING.  NBYTES zero means use the whole string.  If
 9462    STRING is multibyte, the message will be displayed multibyte.
 9463 
 9464    If S is not null, set the message to the first LEN bytes of S.  LEN
 9465    zero means use the whole string.  MULTIBYTE_P non-zero means S is
 9466    multibyte.  Display the message multibyte in that case.
 9467 
 9468    Doesn't GC, as with_echo_area_buffer binds Qinhibit_modification_hooks
 9469    to t before calling set_message_1 (which calls insert).
 9470   */
 9471 
 9472 void
 9473 set_message (s, string, nbytes, multibyte_p)
 9474      const char *s;
 9475      Lisp_Object string;
 9476      int nbytes, multibyte_p;
 9477 {
 9478   message_enable_multibyte
 9479     = ((s && multibyte_p)
 9480        || (STRINGP (string) && STRING_MULTIBYTE (string)));
 9481 
 9482   with_echo_area_buffer (0, -1, set_message_1,
 9483                          (EMACS_INT) s, string, nbytes, multibyte_p);
 9484   message_buf_print = 0;
 9485   help_echo_showing_p = 0;
 9486 }
 9487 
 9488 
 9489 /* Helper function for set_message.  Arguments have the same meaning
 9490    as there, with A1 corresponding to S and A2 corresponding to STRING
 9491    This function is called with the echo area buffer being
 9492    current.  */
 9493 
 9494 static int
 9495 set_message_1 (a1, a2, nbytes, multibyte_p)
 9496      EMACS_INT a1;
 9497      Lisp_Object a2;
 9498      EMACS_INT nbytes, multibyte_p;
 9499 {
 9500   const char *s = (const char *) a1;
 9501   Lisp_Object string = a2;
 9502 
 9503   /* Change multibyteness of the echo buffer appropriately.  */
 9504   if (message_enable_multibyte
 9505       != !NILP (current_buffer->enable_multibyte_characters))
 9506     Fset_buffer_multibyte (message_enable_multibyte ? Qt : Qnil);
 9507 
 9508   current_buffer->truncate_lines = message_truncate_lines ? Qt : Qnil;
 9509 
 9510   /* Insert new message at BEG.  */
 9511   TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
 9512 
 9513   if (STRINGP (string))
 9514     {
 9515       int nchars;
 9516 
 9517       if (nbytes == 0)
 9518         nbytes = SBYTES (string);
 9519       nchars = string_byte_to_char (string, nbytes);
 9520 
 9521       /* This function takes care of single/multibyte conversion.  We
 9522          just have to ensure that the echo area buffer has the right
 9523          setting of enable_multibyte_characters.  */
 9524       insert_from_string (string, 0, 0, nchars, nbytes, 1);
 9525     }
 9526   else if (s)
 9527     {
 9528       if (nbytes == 0)
 9529         nbytes = strlen (s);
 9530 
 9531       if (multibyte_p && NILP (current_buffer->enable_multibyte_characters))
 9532         {
 9533           /* Convert from multi-byte to single-byte.  */
 9534           int i, c, n;
 9535           unsigned char work[1];
 9536 
 9537           /* Convert a multibyte string to single-byte.  */
 9538           for (i = 0; i < nbytes; i += n)
 9539             {
 9540               c = string_char_and_length (s + i, &n);
 9541               work[0] = (ASCII_CHAR_P (c)
 9542                          ? c
 9543                          : multibyte_char_to_unibyte (c, Qnil));
 9544               insert_1_both (work, 1, 1, 1, 0, 0);
 9545             }
 9546         }
 9547       else if (!multibyte_p
 9548                && !NILP (current_buffer->enable_multibyte_characters))
 9549         {
 9550           /* Convert from single-byte to multi-byte.  */
 9551           int i, c, n;
 9552           const unsigned char *msg = (const unsigned char *) s;
 9553           unsigned char str[MAX_MULTIBYTE_LENGTH];
 9554 
 9555           /* Convert a single-byte string to multibyte.  */
 9556           for (i = 0; i < nbytes; i++)
 9557             {
 9558               c = msg[i];
 9559               MAKE_CHAR_MULTIBYTE (c);
 9560               n = CHAR_STRING (c, str);
 9561               insert_1_both (str, 1, n, 1, 0, 0);
 9562             }
 9563         }
 9564       else
 9565         insert_1 (s, nbytes, 1, 0, 0);
 9566     }
 9567 
 9568   return 0;
 9569 }
 9570 
 9571 
 9572 /* Clear messages.  CURRENT_P non-zero means clear the current
 9573    message.  LAST_DISPLAYED_P non-zero means clear the message
 9574    last displayed.  */
 9575 
 9576 void
 9577 clear_message (current_p, last_displayed_p)
 9578      int current_p, last_displayed_p;
 9579 {
 9580   if (current_p)
 9581     {
 9582       echo_area_buffer[0] = Qnil;
 9583       message_cleared_p = 1;
 9584     }
 9585 
 9586   if (last_displayed_p)
 9587     echo_area_buffer[1] = Qnil;
 9588 
 9589   message_buf_print = 0;
 9590 }
 9591 
 9592 /* Clear garbaged frames.
 9593 
 9594    This function is used where the old redisplay called
 9595    redraw_garbaged_frames which in turn called redraw_frame which in
 9596    turn called clear_frame.  The call to clear_frame was a source of
 9597    flickering.  I believe a clear_frame is not necessary.  It should
 9598    suffice in the new redisplay to invalidate all current matrices,
 9599    and ensure a complete redisplay of all windows.  */
 9600 
 9601 static void
 9602 clear_garbaged_frames ()
 9603 {
 9604   if (frame_garbaged)
 9605     {
 9606       Lisp_Object tail, frame;
 9607       int changed_count = 0;
 9608 
 9609       FOR_EACH_FRAME (tail, frame)
 9610         {
 9611           struct frame *f = XFRAME (frame);
 9612 
 9613           if (FRAME_VISIBLE_P (f) && FRAME_GARBAGED_P (f))
 9614             {
 9615               if (f->resized_p)
 9616                 {
 9617                   Fredraw_frame (frame);
 9618                   f->force_flush_display_p = 1;
 9619                 }
 9620               clear_current_matrices (f);
 9621               changed_count++;
 9622               f->garbaged = 0;
 9623               f->resized_p = 0;
 9624             }
 9625         }
 9626 
 9627       frame_garbaged = 0;
 9628       if (changed_count)
 9629         ++windows_or_buffers_changed;
 9630     }
 9631 }
 9632 
 9633 
 9634 /* Redisplay the echo area of the selected frame.  If UPDATE_FRAME_P
 9635    is non-zero update selected_frame.  Value is non-zero if the
 9636    mini-windows height has been changed.  */
 9637 
 9638 static int
 9639 echo_area_display (update_frame_p)
 9640      int update_frame_p;
 9641 {
 9642   Lisp_Object mini_window;
 9643   struct window *w;
 9644   struct frame *f;
 9645   int window_height_changed_p = 0;
 9646   struct frame *sf = SELECTED_FRAME ();
 9647 
 9648   mini_window = FRAME_MINIBUF_WINDOW (sf);
 9649   w = XWINDOW (mini_window);
 9650   f = XFRAME (WINDOW_FRAME (w));
 9651 
 9652   /* Don't display if frame is invisible or not yet initialized.  */
 9653   if (!FRAME_VISIBLE_P (f) || !f->glyphs_initialized_p)
 9654     return 0;
 9655 
 9656 #ifdef HAVE_WINDOW_SYSTEM
 9657   /* When Emacs starts, selected_frame may be the initial terminal
 9658      frame.  If we let this through, a message would be displayed on
 9659      the terminal.  */
 9660   if (FRAME_INITIAL_P (XFRAME (selected_frame)))
 9661     return 0;
 9662 #endif /* HAVE_WINDOW_SYSTEM */
 9663 
 9664   /* Redraw garbaged frames.  */
 9665   if (frame_garbaged)
 9666     clear_garbaged_frames ();
 9667 
 9668   if (!NILP (echo_area_buffer[0]) || minibuf_level == 0)
 9669     {
 9670       echo_area_window = mini_window;
 9671       window_height_changed_p = display_echo_area (w);
 9672       w->must_be_updated_p = 1;
 9673 
 9674       /* Update the display, unless called from redisplay_internal.
 9675          Also don't update the screen during redisplay itself.  The
 9676          update will happen at the end of redisplay, and an update
 9677          here could cause confusion.  */
 9678       if (update_frame_p && !redisplaying_p)
 9679         {
 9680           int n = 0;
 9681 
 9682           /* If the display update has been interrupted by pending
 9683              input, update mode lines in the frame.  Due to the
 9684              pending input, it might have been that redisplay hasn't
 9685              been called, so that mode lines above the echo area are
 9686              garbaged.  This looks odd, so we prevent it here.  */
 9687           if (!display_completed)
 9688             n = redisplay_mode_lines (FRAME_ROOT_WINDOW (f), 0);
 9689 
 9690           if (window_height_changed_p
 9691               /* Don't do this if Emacs is shutting down.  Redisplay
 9692                  needs to run hooks.  */
 9693               && !NILP (Vrun_hooks))
 9694             {
 9695               /* Must update other windows.  Likewise as in other
 9696                  cases, don't let this update be interrupted by
 9697                  pending input.  */
 9698               int count = SPECPDL_INDEX ();
 9699               specbind (Qredisplay_dont_pause, Qt);
 9700               windows_or_buffers_changed = 1;
 9701               redisplay_internal (0);
 9702               unbind_to (count, Qnil);
 9703             }
 9704           else if (FRAME_WINDOW_P (f) && n == 0)
 9705             {
 9706               /* Window configuration is the same as before.
 9707                  Can do with a display update of the echo area,
 9708                  unless we displayed some mode lines.  */
 9709               update_single_window (w, 1);
 9710               FRAME_RIF (f)->flush_display (f);
 9711             }
 9712           else
 9713             update_frame (f, 1, 1);
 9714 
 9715           /* If cursor is in the echo area, make sure that the next
 9716              redisplay displays the minibuffer, so that the cursor will
 9717              be replaced with what the minibuffer wants.  */
 9718           if (cursor_in_echo_area)
 9719             ++windows_or_buffers_changed;
 9720         }
 9721     }
 9722   else if (!EQ (mini_window, selected_window))
 9723     windows_or_buffers_changed++;
 9724 
 9725   /* Last displayed message is now the current message.  */
 9726   echo_area_buffer[1] = echo_area_buffer[0];
 9727   /* Inform read_char that we're not echoing.  */
 9728   echo_message_buffer = Qnil;
 9729 
 9730   /* Prevent redisplay optimization in redisplay_internal by resetting
 9731      this_line_start_pos.  This is done because the mini-buffer now
 9732      displays the message instead of its buffer text.  */
 9733   if (EQ (mini_window, selected_window))
 9734     CHARPOS (this_line_start_pos) = 0;
 9735 
 9736   return window_height_changed_p;
 9737 }
 9738 
 9739 
 9740 
 9741 /***********************************************************************
 9742                      Mode Lines and Frame Titles
 9743  ***********************************************************************/
 9744 
 9745 /* A buffer for constructing non-propertized mode-line strings and
 9746    frame titles in it; allocated from the heap in init_xdisp and
 9747    resized as needed in store_mode_line_noprop_char.  */
 9748 
 9749 static char *mode_line_noprop_buf;
 9750 
 9751 /* The buffer's end, and a current output position in it.  */
 9752 
 9753 static char *mode_line_noprop_buf_end;
 9754 static char *mode_line_noprop_ptr;
 9755 
 9756 #define MODE_LINE_NOPROP_LEN(start) \
 9757   ((mode_line_noprop_ptr - mode_line_noprop_buf) - start)
 9758 
 9759 static enum {
 9760   MODE_LINE_DISPLAY = 0,
 9761   MODE_LINE_TITLE,
 9762   MODE_LINE_NOPROP,
 9763   MODE_LINE_STRING
 9764 } mode_line_target;
 9765 
 9766 /* Alist that caches the results of :propertize.
 9767    Each element is (PROPERTIZED-STRING . PROPERTY-LIST).  */
 9768 static Lisp_Object mode_line_proptrans_alist;
 9769 
 9770 /* List of strings making up the mode-line.  */
 9771 static Lisp_Object mode_line_string_list;
 9772 
 9773 /* Base face property when building propertized mode line string.  */
 9774 static Lisp_Object mode_line_string_face;
 9775 static Lisp_Object mode_line_string_face_prop;
 9776 
 9777 
 9778 /* Unwind data for mode line strings */
 9779 
 9780 static Lisp_Object Vmode_line_unwind_vector;
 9781 
 9782 static Lisp_Object
 9783 format_mode_line_unwind_data (struct buffer *obuf,
 9784                               Lisp_Object owin,
 9785                               int save_proptrans)
 9786 {
 9787   Lisp_Object vector, tmp;
 9788 
 9789   /* Reduce consing by keeping one vector in
 9790      Vwith_echo_area_save_vector.  */
 9791   vector = Vmode_line_unwind_vector;
 9792   Vmode_line_unwind_vector = Qnil;
 9793 
 9794   if (NILP (vector))
 9795     vector = Fmake_vector (make_number (8), Qnil);
 9796 
 9797   ASET (vector, 0, make_number (mode_line_target));
 9798   ASET (vector, 1, make_number (MODE_LINE_NOPROP_LEN (0)));
 9799   ASET (vector, 2, mode_line_string_list);
 9800   ASET (vector, 3, save_proptrans ? mode_line_proptrans_alist : Qt);
 9801   ASET (vector, 4, mode_line_string_face);
 9802   ASET (vector, 5, mode_line_string_face_prop);
 9803 
 9804   if (obuf)
 9805     XSETBUFFER (tmp, obuf);
 9806   else
 9807     tmp = Qnil;
 9808   ASET (vector, 6, tmp);
 9809   ASET (vector, 7, owin);
 9810 
 9811   return vector;
 9812 }
 9813 
 9814 static Lisp_Object
 9815 unwind_format_mode_line (vector)
 9816      Lisp_Object vector;
 9817 {
 9818   mode_line_target = XINT (AREF (vector, 0));
 9819   mode_line_noprop_ptr = mode_line_noprop_buf + XINT (AREF (vector, 1));
 9820   mode_line_string_list = AREF (vector, 2);
 9821   if (! EQ (AREF (vector, 3), Qt))
 9822     mode_line_proptrans_alist = AREF (vector, 3);
 9823   mode_line_string_face = AREF (vector, 4);
 9824   mode_line_string_face_prop = AREF (vector, 5);
 9825 
 9826   if (!NILP (AREF (vector, 7)))
 9827     /* Select window before buffer, since it may change the buffer.  */
 9828     Fselect_window (AREF (vector, 7), Qt);
 9829 
 9830   if (!NILP (AREF (vector, 6)))
 9831     {
 9832       set_buffer_internal_1 (XBUFFER (AREF (vector, 6)));
 9833       ASET (vector, 6, Qnil);
 9834     }
 9835 
 9836   Vmode_line_unwind_vector = vector;
 9837   return Qnil;
 9838 }
 9839 
 9840 
 9841 /* Store a single character C for the frame title in mode_line_noprop_buf.
 9842    Re-allocate mode_line_noprop_buf if necessary.  */
 9843 
 9844 static void
 9845 #ifdef PROTOTYPES
 9846 store_mode_line_noprop_char (char c)
 9847 #else
 9848 store_mode_line_noprop_char (c)
 9849     char c;
 9850 #endif
 9851 {
 9852   /* If output position has reached the end of the allocated buffer,
 9853      double the buffer's size.  */
 9854   if (mode_line_noprop_ptr == mode_line_noprop_buf_end)
 9855     {
 9856       int len = MODE_LINE_NOPROP_LEN (0);
 9857       int new_size = 2 * len * sizeof *mode_line_noprop_buf;
 9858       mode_line_noprop_buf = (char *) xrealloc (mode_line_noprop_buf, new_size);
 9859       mode_line_noprop_buf_end = mode_line_noprop_buf + new_size;
 9860       mode_line_noprop_ptr = mode_line_noprop_buf + len;
 9861     }
 9862 
 9863   *mode_line_noprop_ptr++ = c;
 9864 }
 9865 
 9866 
 9867 /* Store part of a frame title in mode_line_noprop_buf, beginning at
 9868    mode_line_noprop_ptr.  STR is the string to store.  Do not copy
 9869    characters that yield more columns than PRECISION; PRECISION <= 0
 9870    means copy the whole string.  Pad with spaces until FIELD_WIDTH
 9871    number of characters have been copied; FIELD_WIDTH <= 0 means don't
 9872    pad.  Called from display_mode_element when it is used to build a
 9873    frame title.  */
 9874 
 9875 static int
 9876 store_mode_line_noprop (str, field_width, precision)
 9877      const unsigned char *str;
 9878      int field_width, precision;
 9879 {
 9880   int n = 0;
 9881   int dummy, nbytes;
 9882 
 9883   /* Copy at most PRECISION chars from STR.  */
 9884   nbytes = strlen (str);
 9885   n += c_string_width (str, nbytes, precision, &dummy, &nbytes);
 9886   while (nbytes--)
 9887     store_mode_line_noprop_char (*str++);
 9888 
 9889   /* Fill up with spaces until FIELD_WIDTH reached.  */
 9890   while (field_width > 0
 9891          && n < field_width)
 9892     {
 9893       store_mode_line_noprop_char (' ');
 9894       ++n;
 9895     }
 9896 
 9897   return n;
 9898 }
 9899 
 9900 /***********************************************************************
 9901                              Frame Titles
 9902  ***********************************************************************/
 9903 
 9904 #ifdef HAVE_WINDOW_SYSTEM
 9905 
 9906 /* Set the title of FRAME, if it has changed.  The title format is
 9907    Vicon_title_format if FRAME is iconified, otherwise it is
 9908    frame_title_format.  */
 9909 
 9910 static void
 9911 x_consider_frame_title (frame)
 9912      Lisp_Object frame;
 9913 {
 9914   struct frame *f = XFRAME (frame);
 9915 
 9916   if (FRAME_WINDOW_P (f)
 9917       || FRAME_MINIBUF_ONLY_P (f)
 9918       || f->explicit_name)
 9919     {
 9920       /* Do we have more than one visible frame on this X display?  */
 9921       Lisp_Object tail;
 9922       Lisp_Object fmt;
 9923       int title_start;
 9924       char *title;
 9925       int len;
 9926       struct it it;
 9927       int count = SPECPDL_INDEX ();
 9928 
 9929       for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
 9930         {
 9931           Lisp_Object other_frame = XCAR (tail);
 9932           struct frame *tf = XFRAME (other_frame);
 9933 
 9934           if (tf != f
 9935               && FRAME_KBOARD (tf) == FRAME_KBOARD (f)
 9936               && !FRAME_MINIBUF_ONLY_P (tf)
 9937               && !EQ (other_frame, tip_frame)
 9938               && (FRAME_VISIBLE_P (tf) || FRAME_ICONIFIED_P (tf)))
 9939             break;
 9940         }
 9941 
 9942       /* Set global variable indicating that multiple frames exist.  */
 9943       multiple_frames = CONSP (tail);
 9944 
 9945       /* Switch to the buffer of selected window of the frame.  Set up
 9946          mode_line_target so that display_mode_element will output into
 9947          mode_line_noprop_buf; then display the title.  */
 9948       record_unwind_protect (unwind_format_mode_line,
 9949                              format_mode_line_unwind_data
 9950                                 (current_buffer, selected_window, 0));
 9951 
 9952       Fselect_window (f->selected_window, Qt);
 9953       set_buffer_internal_1 (XBUFFER (XWINDOW (f->selected_window)->buffer));
 9954       fmt = FRAME_ICONIFIED_P (f) ? Vicon_title_format : Vframe_title_format;
 9955 
 9956       mode_line_target = MODE_LINE_TITLE;
 9957       title_start = MODE_LINE_NOPROP_LEN (0);
 9958       init_iterator (&it, XWINDOW (f->selected_window), -1, -1,
 9959                      NULL, DEFAULT_FACE_ID);
 9960       display_mode_element (&it, 0, -1, -1, fmt, Qnil, 0);
 9961       len = MODE_LINE_NOPROP_LEN (title_start);
 9962       title = mode_line_noprop_buf + title_start;
 9963       unbind_to (count, Qnil);
 9964 
 9965       /* Set the title only if it's changed.  This avoids consing in
 9966          the common case where it hasn't.  (If it turns out that we've
 9967          already wasted too much time by walking through the list with
 9968          display_mode_element, then we might need to optimize at a
 9969          higher level than this.)  */
 9970       if (! STRINGP (f->name)
 9971           || SBYTES (f->name) != len
 9972           || bcmp (title, SDATA (f->name), len) != 0)
 9973         x_implicitly_set_name (f, make_string (title, len), Qnil);
 9974     }
 9975 }
 9976 
 9977 #endif /* not HAVE_WINDOW_SYSTEM */
 9978 
 9979 
 9980 
 9981 
 9982 /***********************************************************************
 9983                               Menu Bars
 9984  ***********************************************************************/
 9985 
 9986 
 9987 /* Prepare for redisplay by updating menu-bar item lists when
 9988    appropriate.  This can call eval.  */
 9989 
 9990 void
 9991 prepare_menu_bars ()
 9992 {
 9993   int all_windows;
 9994   struct gcpro gcpro1, gcpro2;
 9995   struct frame *f;
 9996   Lisp_Object tooltip_frame;
 9997 
 9998 #ifdef HAVE_WINDOW_SYSTEM
 9999   tooltip_frame = tip_frame;
10000 #else
10001   tooltip_frame = Qnil;
10002 #endif
10003 
10004   /* Update all frame titles based on their buffer names, etc.  We do
10005      this before the menu bars so that the buffer-menu will show the
10006      up-to-date frame titles.  */
10007 #ifdef HAVE_WINDOW_SYSTEM
10008   if (windows_or_buffers_changed || update_mode_lines)
10009     {
10010       Lisp_Object tail, frame;
10011 
10012       FOR_EACH_FRAME (tail, frame)
10013         {
10014           f = XFRAME (frame);
10015           if (!EQ (frame, tooltip_frame)
10016               && (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f)))
10017             x_consider_frame_title (frame);
10018         }
10019     }
10020 #endif /* HAVE_WINDOW_SYSTEM */
10021 
10022   /* Update the menu bar item lists, if appropriate.  This has to be
10023      done before any actual redisplay or generation of display lines.  */
10024   all_windows = (update_mode_lines
10025                  || buffer_shared > 1
10026                  || windows_or_buffers_changed);
10027   if (all_windows)
10028     {
10029       Lisp_Object tail, frame;
10030       int count = SPECPDL_INDEX ();
10031       /* 1 means that update_menu_bar has run its hooks
10032          so any further calls to update_menu_bar shouldn't do so again.  */
10033       int menu_bar_hooks_run = 0;
10034 
10035       record_unwind_save_match_data ();
10036 
10037       FOR_EACH_FRAME (tail, frame)
10038         {
10039           f = XFRAME (frame);
10040 
10041           /* Ignore tooltip frame.  */
10042           if (EQ (frame, tooltip_frame))
10043             continue;
10044 
10045           /* If a window on this frame changed size, report that to
10046              the user and clear the size-change flag.  */
10047           if (FRAME_WINDOW_SIZES_CHANGED (f))
10048             {
10049               Lisp_Object functions;
10050 
10051               /* Clear flag first in case we get an error below.  */
10052               FRAME_WINDOW_SIZES_CHANGED (f) = 0;
10053               functions = Vwindow_size_change_functions;
10054               GCPRO2 (tail, functions);
10055 
10056               while (CONSP (functions))
10057                 {
10058                   if (!EQ (XCAR (functions), Qt))
10059                     call1 (XCAR (functions), frame);
10060                   functions = XCDR (functions);
10061                 }
10062               UNGCPRO;
10063             }
10064 
10065           GCPRO1 (tail);
10066           menu_bar_hooks_run = update_menu_bar (f, 0, menu_bar_hooks_run);
10067 #ifdef HAVE_WINDOW_SYSTEM
10068           update_tool_bar (f, 0);
10069 #endif
10070 #ifdef HAVE_NS
10071           if (windows_or_buffers_changed
10072               && FRAME_NS_P (f))
10073             ns_set_doc_edited (f, Fbuffer_modified_p
10074                                (XWINDOW (f->selected_window)->buffer));
10075 #endif
10076           UNGCPRO;
10077         }
10078 
10079       unbind_to (count, Qnil);
10080     }
10081   else
10082     {
10083       struct frame *sf = SELECTED_FRAME ();
10084       update_menu_bar (sf, 1, 0);
10085 #ifdef HAVE_WINDOW_SYSTEM
10086       update_tool_bar (sf, 1);
10087 #endif
10088     }
10089 
10090   /* Motif needs this.  See comment in xmenu.c.  Turn it off when
10091      pending_menu_activation is not defined.  */
10092 #ifdef USE_X_TOOLKIT
10093   pending_menu_activation = 0;
10094 #endif
10095 }
10096 
10097 
10098 /* Update the menu bar item list for frame F.  This has to be done
10099    before we start to fill in any display lines, because it can call
10100    eval.
10101 
10102    If SAVE_MATCH_DATA is non-zero, we must save and restore it here.
10103 
10104    If HOOKS_RUN is 1, that means a previous call to update_menu_bar
10105    already ran the menu bar hooks for this redisplay, so there
10106    is no need to run them again.  The return value is the
10107    updated value of this flag, to pass to the next call.  */
10108 
10109 static int
10110 update_menu_bar (f, save_match_data, hooks_run)
10111      struct frame *f;
10112      int save_match_data;
10113      int hooks_run;
10114 {
10115   Lisp_Object window;
10116   register struct window *w;
10117 
10118   /* If called recursively during a menu update, do nothing.  This can
10119      happen when, for instance, an activate-menubar-hook causes a
10120      redisplay.  */
10121   if (inhibit_menubar_update)
10122     return hooks_run;
10123 
10124   window = FRAME_SELECTED_WINDOW (f);
10125   w = XWINDOW (window);
10126 
10127   if (FRAME_WINDOW_P (f)
10128       ?
10129 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
10130     || defined (HAVE_NS) || defined (USE_GTK)
10131       FRAME_EXTERNAL_MENU_BAR (f)
10132 #else
10133       FRAME_MENU_BAR_LINES (f) > 0
10134 #endif
10135       : FRAME_MENU_BAR_LINES (f) > 0)
10136     {
10137       /* If the user has switched buffers or windows, we need to
10138          recompute to reflect the new bindings.  But we'll
10139          recompute when update_mode_lines is set too; that means
10140          that people can use force-mode-line-update to request
10141          that the menu bar be recomputed.  The adverse effect on
10142          the rest of the redisplay algorithm is about the same as
10143          windows_or_buffers_changed anyway.  */
10144       if (windows_or_buffers_changed
10145           /* This used to test w->update_mode_line, but we believe
10146              there is no need to recompute the menu in that case.  */
10147           || update_mode_lines
10148           || ((BUF_SAVE_MODIFF (XBUFFER (w->buffer))
10149                < BUF_MODIFF (XBUFFER (w->buffer)))
10150               != !NILP (w->last_had_star))
10151           || ((!NILP (Vtransient_mark_mode)
10152                && !NILP (XBUFFER (w->buffer)->mark_active))
10153               != !NILP (w->region_showing)))
10154         {
10155           struct buffer *prev = current_buffer;
10156           int count = SPECPDL_INDEX ();
10157 
10158           specbind (Qinhibit_menubar_update, Qt);
10159 
10160           set_buffer_internal_1 (XBUFFER (w->buffer));
10161           if (save_match_data)
10162             record_unwind_save_match_data ();
10163           if (NILP (Voverriding_local_map_menu_flag))
10164             {
10165               specbind (Qoverriding_terminal_local_map, Qnil);
10166               specbind (Qoverriding_local_map, Qnil);
10167             }
10168 
10169           if (!hooks_run)
10170             {
10171               /* Run the Lucid hook.  */
10172               safe_run_hooks (Qactivate_menubar_hook);
10173 
10174               /* If it has changed current-menubar from previous value,
10175                  really recompute the menu-bar from the value.  */
10176               if (! NILP (Vlucid_menu_bar_dirty_flag))
10177                 call0 (Qrecompute_lucid_menubar);
10178 
10179               safe_run_hooks (Qmenu_bar_update_hook);
10180 
10181               hooks_run = 1;
10182             }
10183 
10184           XSETFRAME (Vmenu_updating_frame, f);
10185           FRAME_MENU_BAR_ITEMS (f) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f));
10186 
10187           /* Redisplay the menu bar in case we changed it.  */
10188 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
10189     || defined (HAVE_NS) || defined (USE_GTK)
10190           if (FRAME_WINDOW_P (f))
10191             {
10192 #if defined (HAVE_NS)
10193               /* All frames on Mac OS share the same menubar.  So only
10194                  the selected frame should be allowed to set it.  */
10195               if (f == SELECTED_FRAME ())
10196 #endif
10197                 set_frame_menubar (f, 0, 0);
10198             }
10199           else
10200             /* On a terminal screen, the menu bar is an ordinary screen
10201                line, and this makes it get updated.  */
10202             w->update_mode_line = Qt;
10203 #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */
10204           /* In the non-toolkit version, the menu bar is an ordinary screen
10205              line, and this makes it get updated.  */
10206           w->update_mode_line = Qt;
10207 #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */
10208 
10209           unbind_to (count, Qnil);
10210           set_buffer_internal_1 (prev);
10211         }
10212     }
10213 
10214   return hooks_run;
10215 }
10216 
10217 
10218 
10219 /***********************************************************************
10220                             Output Cursor
10221  ***********************************************************************/
10222 
10223 #ifdef HAVE_WINDOW_SYSTEM
10224 
10225 /* EXPORT:
10226    Nominal cursor position -- where to draw output.
10227    HPOS and VPOS are window relative glyph matrix coordinates.
10228    X and Y are window relative pixel coordinates.  */
10229 
10230 struct cursor_pos output_cursor;
10231 
10232 
10233 /* EXPORT:
10234    Set the global variable output_cursor to CURSOR.  All cursor
10235    positions are relative to updated_window.  */
10236 
10237 void
10238 set_output_cursor (cursor)
10239     struct cursor_pos *cursor;
10240 {
10241   output_cursor.hpos = cursor->hpos;
10242   output_cursor.vpos = cursor->vpos;
10243   output_cursor.x = cursor->x;
10244   output_cursor.y = cursor->y;
10245 }
10246 
10247 
10248 /* EXPORT for RIF:
10249    Set a nominal cursor position.
10250 
10251    HPOS and VPOS are column/row positions in a window glyph matrix.  X
10252    and Y are window text area relative pixel positions.
10253 
10254    If this is done during an update, updated_window will contain the
10255    window that is being updated and the position is the future output
10256    cursor position for that window.  If updated_window is null, use
10257    selected_window and display the cursor at the given position.  */
10258 
10259 void
10260 x_cursor_to (vpos, hpos, y, x)
10261      int vpos, hpos, y, x;
10262 {
10263   struct window *w;
10264 
10265   /* If updated_window is not set, work on selected_window.  */
10266   if (updated_window)
10267     w = updated_window;
10268   else
10269     w = XWINDOW (selected_window);
10270 
10271   /* Set the output cursor.  */
10272   output_cursor.hpos = hpos;
10273   output_cursor.vpos = vpos;
10274   output_cursor.x = x;
10275   output_cursor.y = y;
10276 
10277   /* If not called as part of an update, really display the cursor.
10278      This will also set the cursor position of W.  */
10279   if (updated_window == NULL)
10280     {
10281       BLOCK_INPUT;
10282       display_and_set_cursor (w, 1, hpos, vpos, x, y);
10283       if (FRAME_RIF (SELECTED_FRAME ())->flush_display_optional)
10284         FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (SELECTED_FRAME ());
10285       UNBLOCK_INPUT;
10286     }
10287 }
10288 
10289 #endif /* HAVE_WINDOW_SYSTEM */
10290 
10291 
10292 /***********************************************************************
10293                                Tool-bars
10294  ***********************************************************************/
10295 
10296 #ifdef HAVE_WINDOW_SYSTEM
10297 
10298 /* Where the mouse was last time we reported a mouse event.  */
10299 
10300 FRAME_PTR last_mouse_frame;
10301 
10302 /* Tool-bar item index of the item on which a mouse button was pressed
10303    or -1.  */
10304 
10305 int last_tool_bar_item;
10306 
10307 
10308 static Lisp_Object
10309 update_tool_bar_unwind (frame)
10310      Lisp_Object frame;
10311 {
10312   selected_frame = frame;
10313   return Qnil;
10314 }
10315 
10316 /* Update the tool-bar item list for frame F.  This has to be done
10317    before we start to fill in any display lines.  Called from
10318    prepare_menu_bars.  If SAVE_MATCH_DATA is non-zero, we must save
10319    and restore it here.  */
10320 
10321 static void
10322 update_tool_bar (f, save_match_data)
10323      struct frame *f;
10324      int save_match_data;
10325 {
10326 #if defined (USE_GTK) || defined (HAVE_NS)
10327   int do_update = FRAME_EXTERNAL_TOOL_BAR (f);
10328 #else
10329   int do_update = WINDOWP (f->tool_bar_window)
10330     && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)) > 0;
10331 #endif
10332 
10333   if (do_update)
10334     {
10335       Lisp_Object window;
10336       struct window *w;
10337 
10338       window = FRAME_SELECTED_WINDOW (f);
10339       w = XWINDOW (window);
10340 
10341       /* If the user has switched buffers or windows, we need to
10342          recompute to reflect the new bindings.  But we'll
10343          recompute when update_mode_lines is set too; that means
10344          that people can use force-mode-line-update to request
10345          that the menu bar be recomputed.  The adverse effect on
10346          the rest of the redisplay algorithm is about the same as
10347          windows_or_buffers_changed anyway.  */
10348       if (windows_or_buffers_changed
10349           || !NILP (w->update_mode_line)
10350           || update_mode_lines
10351           || ((BUF_SAVE_MODIFF (XBUFFER (w->buffer))
10352                < BUF_MODIFF (XBUFFER (w->buffer)))
10353               != !NILP (w->last_had_star))
10354           || ((!NILP (Vtransient_mark_mode)
10355                && !NILP (XBUFFER (w->buffer)->mark_active))
10356               != !NILP (w->region_showing)))
10357         {
10358           struct buffer *prev = current_buffer;
10359           int count = SPECPDL_INDEX ();
10360           Lisp_Object frame, new_tool_bar;
10361           int new_n_tool_bar;
10362           struct gcpro gcpro1;
10363 
10364           /* Set current_buffer to the buffer of the selected
10365              window of the frame, so that we get the right local
10366              keymaps.  */
10367           set_buffer_internal_1 (XBUFFER (w->buffer));
10368 
10369           /* Save match data, if we must.  */
10370           if (save_match_data)
10371             record_unwind_save_match_data ();
10372 
10373           /* Make sure that we don't accidentally use bogus keymaps.  */
10374           if (NILP (Voverriding_local_map_menu_flag))
10375             {
10376               specbind (Qoverriding_terminal_local_map, Qnil);
10377               specbind (Qoverriding_local_map, Qnil);
10378             }
10379 
10380           GCPRO1 (new_tool_bar);
10381 
10382           /* We must temporarily set the selected frame to this frame
10383              before calling tool_bar_items, because the calculation of
10384              the tool-bar keymap uses the selected frame (see
10385              `tool-bar-make-keymap' in tool-bar.el).  */
10386           record_unwind_protect (update_tool_bar_unwind, selected_frame);
10387           XSETFRAME (frame, f);
10388           selected_frame = frame;
10389 
10390           /* Build desired tool-bar items from keymaps.  */
10391           new_tool_bar = tool_bar_items (Fcopy_sequence (f->tool_bar_items),
10392                                          &new_n_tool_bar);
10393 
10394           /* Redisplay the tool-bar if we changed it.  */
10395           if (new_n_tool_bar != f->n_tool_bar_items
10396               || NILP (Fequal (new_tool_bar, f->tool_bar_items)))
10397             {
10398               /* Redisplay that happens asynchronously due to an expose event
10399                  may access f->tool_bar_items.  Make sure we update both
10400                  variables within BLOCK_INPUT so no such event interrupts.  */
10401               BLOCK_INPUT;
10402               f->tool_bar_items = new_tool_bar;
10403               f->n_tool_bar_items = new_n_tool_bar;
10404               w->update_mode_line = Qt;
10405               UNBLOCK_INPUT;
10406             }
10407 
10408           UNGCPRO;
10409 
10410           unbind_to (count, Qnil);
10411           set_buffer_internal_1 (prev);
10412         }
10413     }
10414 }
10415 
10416 
10417 /* Set F->desired_tool_bar_string to a Lisp string representing frame
10418    F's desired tool-bar contents.  F->tool_bar_items must have
10419    been set up previously by calling prepare_menu_bars.  */
10420 
10421 static void
10422 build_desired_tool_bar_string (f)
10423      struct frame *f;
10424 {
10425   int i, size, size_needed;
10426   struct gcpro gcpro1, gcpro2, gcpro3;
10427   Lisp_Object image, plist, props;
10428 
10429   image = plist = props = Qnil;
10430   GCPRO3 (image, plist, props);
10431 
10432   /* Prepare F->desired_tool_bar_string.  If we can reuse it, do so.
10433      Otherwise, make a new string.  */
10434 
10435   /* The size of the string we might be able to reuse.  */
10436   size = (STRINGP (f->desired_tool_bar_string)
10437           ? SCHARS (f->desired_tool_bar_string)
10438           : 0);
10439 
10440   /* We need one space in the string for each image.  */
10441   size_needed = f->n_tool_bar_items;
10442 
10443   /* Reuse f->desired_tool_bar_string, if possible.  */
10444   if (size < size_needed || NILP (f->desired_tool_bar_string))
10445     f->desired_tool_bar_string = Fmake_string (make_number (size_needed),
10446                                                make_number (' '));
10447   else
10448     {
10449       props = list4 (Qdisplay, Qnil, Qmenu_item, Qnil);
10450       Fremove_text_properties (make_number (0), make_number (size),
10451                                props, f->desired_tool_bar_string);
10452     }
10453 
10454   /* Put a `display' property on the string for the images to display,
10455      put a `menu_item' property on tool-bar items with a value that
10456      is the index of the item in F's tool-bar item vector.  */
10457   for (i = 0; i < f->n_tool_bar_items; ++i)
10458     {
10459 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
10460 
10461       int enabled_p = !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P));
10462       int selected_p = !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P));
10463       int hmargin, vmargin, relief, idx, end;
10464       extern Lisp_Object QCrelief, QCmargin, QCconversion;
10465 
10466       /* If image is a vector, choose the image according to the
10467          button state.  */
10468       image = PROP (TOOL_BAR_ITEM_IMAGES);
10469       if (VECTORP (image))
10470         {
10471           if (enabled_p)
10472             idx = (selected_p
10473                    ? TOOL_BAR_IMAGE_ENABLED_SELECTED
10474                    : TOOL_BAR_IMAGE_ENABLED_DESELECTED);
10475           else
10476             idx = (selected_p
10477                    ? TOOL_BAR_IMAGE_DISABLED_SELECTED
10478                    : TOOL_BAR_IMAGE_DISABLED_DESELECTED);
10479 
10480           xassert (ASIZE (image) >= idx);
10481           image = AREF (image, idx);
10482         }
10483       else
10484         idx = -1;
10485 
10486       /* Ignore invalid image specifications.  */
10487       if (!valid_image_p (image))
10488         continue;
10489 
10490       /* Display the tool-bar button pressed, or depressed.  */
10491       plist = Fcopy_sequence (XCDR (image));
10492 
10493       /* Compute margin and relief to draw.  */
10494       relief = (tool_bar_button_relief >= 0
10495                 ? tool_bar_button_relief
10496                 : DEFAULT_TOOL_BAR_BUTTON_RELIEF);
10497       hmargin = vmargin = relief;
10498 
10499       if (INTEGERP (Vtool_bar_button_margin)
10500           && XINT (Vtool_bar_button_margin) > 0)
10501         {
10502           hmargin += XFASTINT (Vtool_bar_button_margin);
10503           vmargin += XFASTINT (Vtool_bar_button_margin);
10504         }
10505       else if (CONSP (Vtool_bar_button_margin))
10506         {
10507           if (INTEGERP (XCAR (Vtool_bar_button_margin))
10508               && XINT (XCAR (Vtool_bar_button_margin)) > 0)
10509             hmargin += XFASTINT (XCAR (Vtool_bar_button_margin));
10510 
10511           if (INTEGERP (XCDR (Vtool_bar_button_margin))
10512               && XINT (XCDR (Vtool_bar_button_margin)) > 0)
10513             vmargin += XFASTINT (XCDR (Vtool_bar_button_margin));
10514         }
10515 
10516       if (auto_raise_tool_bar_buttons_p)
10517         {
10518           /* Add a `:relief' property to the image spec if the item is
10519              selected.  */
10520           if (selected_p)
10521             {
10522               plist = Fplist_put (plist, QCrelief, make_number (-relief));
10523               hmargin -= relief;
10524               vmargin -= relief;
10525             }
10526         }
10527       else
10528         {
10529           /* If image is selected, display it pressed, i.e. with a
10530              negative relief.  If it's not selected, display it with a
10531              raised relief.  */
10532           plist = Fplist_put (plist, QCrelief,
10533                               (selected_p
10534                                ? make_number (-relief)
10535                                : make_number (relief)));
10536           hmargin -= relief;
10537           vmargin -= relief;
10538         }
10539 
10540       /* Put a margin around the image.  */
10541       if (hmargin || vmargin)
10542         {
10543           if (hmargin == vmargin)
10544             plist = Fplist_put (plist, QCmargin, make_number (hmargin));
10545           else
10546             plist = Fplist_put (plist, QCmargin,
10547                                 Fcons (make_number (hmargin),
10548                                        make_number (vmargin)));
10549         }
10550 
10551       /* If button is not enabled, and we don't have special images
10552          for the disabled state, make the image appear disabled by
10553          applying an appropriate algorithm to it.  */
10554       if (!enabled_p && idx < 0)
10555         plist = Fplist_put (plist, QCconversion, Qdisabled);
10556 
10557       /* Put a `display' text property on the string for the image to
10558          display.  Put a `menu-item' property on the string that gives
10559          the start of this item's properties in the tool-bar items
10560          vector.  */
10561       image = Fcons (Qimage, plist);
10562       props = list4 (Qdisplay, image,
10563                      Qmenu_item, make_number (i * TOOL_BAR_ITEM_NSLOTS));
10564 
10565       /* Let the last image hide all remaining spaces in the tool bar
10566          string.  The string can be longer than needed when we reuse a
10567          previous string.  */
10568       if (i + 1 == f->n_tool_bar_items)
10569         end = SCHARS (f->desired_tool_bar_string);
10570       else
10571         end = i + 1;
10572       Fadd_text_properties (make_number (i), make_number (end),
10573                             props, f->desired_tool_bar_string);
10574 #undef PROP
10575     }
10576 
10577   UNGCPRO;
10578 }
10579 
10580 
10581 /* Display one line of the tool-bar of frame IT->f.
10582 
10583    HEIGHT specifies the desired height of the tool-bar line.
10584    If the actual height of the glyph row is less than HEIGHT, the
10585    row's height is increased to HEIGHT, and the icons are centered
10586    vertically in the new height.
10587 
10588    If HEIGHT is -1, we are counting needed tool-bar lines, so don't
10589    count a final empty row in case the tool-bar width exactly matches
10590    the window width.
10591 */
10592 
10593 static void
10594 display_tool_bar_line (it, height)
10595      struct it *it;
10596      int height;
10597 {
10598   struct glyph_row *row = it->glyph_row;
10599   int max_x = it->last_visible_x;
10600   struct glyph *last;
10601 
10602   prepare_desired_row (row);
10603   row->y = it->current_y;
10604 
10605   /* Note that this isn't made use of if the face hasn't a box,
10606      so there's no need to check the face here.  */
10607   it->start_of_box_run_p = 1;
10608 
10609   while (it->current_x < max_x)
10610     {
10611       int x, n_glyphs_before, i, nglyphs;
10612       struct it it_before;
10613 
10614       /* Get the next display element.  */
10615       if (!get_next_display_element (it))
10616         {
10617           /* Don't count empty row if we are counting needed tool-bar lines.  */
10618           if (height < 0 && !it->hpos)
10619             return;
10620           break;
10621         }
10622 
10623       /* Produce glyphs.  */
10624       n_glyphs_before = row->used[TEXT_AREA];
10625       it_before = *it;
10626 
10627       PRODUCE_GLYPHS (it);
10628 
10629       nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
10630       i = 0;
10631       x = it_before.current_x;
10632       while (i < nglyphs)
10633         {
10634           struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
10635 
10636           if (x + glyph->pixel_width > max_x)
10637             {
10638               /* Glyph doesn't fit on line.  Backtrack.  */
10639               row->used[TEXT_AREA] = n_glyphs_before;
10640               *it = it_before;
10641               /* If this is the only glyph on this line, it will never fit on the
10642                  toolbar, so skip it.  But ensure there is at least one glyph,
10643                  so we don't accidentally disable the tool-bar.  */
10644               if (n_glyphs_before == 0
10645                   && (it->vpos > 0 || IT_STRING_CHARPOS (*it) < it->end_charpos-1))
10646                 break;
10647               goto out;
10648             }
10649 
10650           ++it->hpos;
10651           x += glyph->pixel_width;
10652           ++i;
10653         }
10654 
10655       /* Stop at line ends.  */
10656       if (ITERATOR_AT_END_OF_LINE_P (it))
10657         break;
10658 
10659       set_iterator_to_next (it, 1);
10660     }
10661 
10662  out:;
10663 
10664   row->displays_text_p = row->used[TEXT_AREA] != 0;
10665 
10666   /* Use default face for the border below the tool bar.
10667 
10668      FIXME: When auto-resize-tool-bars is grow-only, there is
10669      no additional border below the possibly empty tool-bar lines.
10670      So to make the extra empty lines look "normal", we have to
10671      use the tool-bar face for the border too.  */
10672   if (!row->displays_text_p && !EQ (Vauto_resize_tool_bars, Qgrow_only))
10673     it->face_id = DEFAULT_FACE_ID;
10674 
10675   extend_face_to_end_of_line (it);
10676   last = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
10677   last->right_box_line_p = 1;
10678   if (last == row->glyphs[TEXT_AREA])
10679     last->left_box_line_p = 1;
10680 
10681   /* Make line the desired height and center it vertically.  */
10682   if ((height -= it->max_ascent + it->max_descent) > 0)
10683     {
10684       /* Don't add more than one line height.  */
10685       height %= FRAME_LINE_HEIGHT (it->f);
10686       it->max_ascent += height / 2;
10687       it->max_descent += (height + 1) / 2;
10688     }
10689 
10690   compute_line_metrics (it);
10691 
10692   /* If line is empty, make it occupy the rest of the tool-bar.  */
10693   if (!row->displays_text_p)
10694     {
10695       row->height = row->phys_height = it->last_visible_y - row->y;
10696       row->visible_height = row->height;
10697       row->ascent = row->phys_ascent = 0;
10698       row->extra_line_spacing = 0;
10699     }
10700 
10701   row->full_width_p = 1;
10702   row->continued_p = 0;
10703   row->truncated_on_left_p = 0;
10704   row->truncated_on_right_p = 0;
10705 
10706   it->current_x = it->hpos = 0;
10707   it->current_y += row->height;
10708   ++it->vpos;
10709   ++it->glyph_row;
10710 }
10711 
10712 
10713 /* Max tool-bar height.  */
10714 
10715 #define MAX_FRAME_TOOL_BAR_HEIGHT(f) \
10716   ((FRAME_LINE_HEIGHT (f) * FRAME_LINES (f)))
10717 
10718 /* Value is the number of screen lines needed to make all tool-bar
10719    items of frame F visible.  The number of actual rows needed is
10720    returned in *N_ROWS if non-NULL.  */
10721 
10722 static int
10723 tool_bar_lines_needed (f, n_rows)
10724      struct frame *f;
10725      int *n_rows;
10726 {
10727   struct window *w = XWINDOW (f->tool_bar_window);
10728   struct it it;
10729   /* tool_bar_lines_needed is called from redisplay_tool_bar after building
10730      the desired matrix, so use (unused) mode-line row as temporary row to
10731      avoid destroying the first tool-bar row.  */
10732   struct glyph_row *temp_row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
10733 
10734   /* Initialize an iterator for iteration over
10735      F->desired_tool_bar_string in the tool-bar window of frame F.  */
10736   init_iterator (&it, w, -1, -1, temp_row, TOOL_BAR_FACE_ID);
10737   it.first_visible_x = 0;
10738   it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
10739   reseat_to_string (&it, NULL, f->desired_tool_bar_string, 0, 0, 0, -1);
10740 
10741   while (!ITERATOR_AT_END_P (&it))
10742     {
10743       clear_glyph_row (temp_row);
10744       it.glyph_row = temp_row;
10745       display_tool_bar_line (&it, -1);
10746     }
10747   clear_glyph_row (temp_row);
10748 
10749   /* f->n_tool_bar_rows == 0 means "unknown"; -1 means no tool-bar.  */
10750   if (n_rows)
10751     *n_rows = it.vpos > 0 ? it.vpos : -1;
10752 
10753   return (it.current_y + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
10754 }
10755 
10756 
10757 DEFUN ("tool-bar-lines-needed", Ftool_bar_lines_needed, Stool_bar_lines_needed,
10758        0, 1, 0,
10759        doc: /* Return the number of lines occupied by the tool bar of FRAME.  */)
10760      (frame)
10761      Lisp_Object frame;
10762 {
10763   struct frame *f;
10764   struct window *w;
10765   int nlines = 0;
10766 
10767   if (NILP (frame))
10768     frame = selected_frame;
10769   else
10770     CHECK_FRAME (frame);
10771   f = XFRAME (frame);
10772 
10773   if (WINDOWP (f->tool_bar_window)
10774       || (w = XWINDOW (f->tool_bar_window),
10775           WINDOW_TOTAL_LINES (w) > 0))
10776     {
10777       update_tool_bar (f, 1);
10778       if (f->n_tool_bar_items)
10779         {
10780           build_desired_tool_bar_string (f);
10781           nlines = tool_bar_lines_needed (f, NULL);
10782         }
10783     }
10784 
10785   return make_number (nlines);
10786 }
10787 
10788 
10789 /* Display the tool-bar of frame F.  Value is non-zero if tool-bar's
10790    height should be changed.  */
10791 
10792 static int
10793 redisplay_tool_bar (f)
10794      struct frame *f;
10795 {
10796   struct window *w;
10797   struct it it;
10798   struct glyph_row *row;
10799 
10800 #if defined (USE_GTK) || defined (HAVE_NS)
10801   if (FRAME_EXTERNAL_TOOL_BAR (f))
10802     update_frame_tool_bar (f);
10803   return 0;
10804 #endif
10805 
10806   /* If frame hasn't a tool-bar window or if it is zero-height, don't
10807      do anything.  This means you must start with tool-bar-lines
10808      non-zero to get the auto-sizing effect.  Or in other words, you
10809      can turn off tool-bars by specifying tool-bar-lines zero.  */
10810   if (!WINDOWP (f->tool_bar_window)
10811       || (w = XWINDOW (f->tool_bar_window),
10812           WINDOW_TOTAL_LINES (w) == 0))
10813     return 0;
10814 
10815   /* Set up an iterator for the tool-bar window.  */
10816   init_iterator (&it, w, -1, -1, w->desired_matrix->rows, TOOL_BAR_FACE_ID);
10817   it.first_visible_x = 0;
10818   it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
10819   row = it.glyph_row;
10820 
10821   /* Build a string that represents the contents of the tool-bar.  */
10822   build_desired_tool_bar_string (f);
10823   reseat_to_string (&it, NULL, f->desired_tool_bar_string, 0, 0, 0, -1);
10824 
10825   if (f->n_tool_bar_rows == 0)
10826     {
10827       int nlines;
10828 
10829       if ((nlines = tool_bar_lines_needed (f, &f->n_tool_bar_rows),
10830            nlines != WINDOW_TOTAL_LINES (w)))
10831         {
10832           extern Lisp_Object Qtool_bar_lines;
10833           Lisp_Object frame;
10834           int old_height = WINDOW_TOTAL_LINES (w);
10835 
10836           XSETFRAME (frame, f);
10837           Fmodify_frame_parameters (frame,
10838                                     Fcons (Fcons (Qtool_bar_lines,
10839                                                   make_number (nlines)),
10840                                            Qnil));
10841           if (WINDOW_TOTAL_LINES (w) != old_height)
10842             {
10843               clear_glyph_matrix (w->desired_matrix);
10844               fonts_changed_p = 1;
10845               return 1;
10846             }
10847         }
10848     }
10849 
10850   /* Display as many lines as needed to display all tool-bar items.  */
10851 
10852   if (f->n_tool_bar_rows > 0)
10853     {
10854       int border, rows, height, extra;
10855 
10856       if (INTEGERP (Vtool_bar_border))
10857         border = XINT (Vtool_bar_border);
10858       else if (EQ (Vtool_bar_border, Qinternal_border_width))
10859         border = FRAME_INTERNAL_BORDER_WIDTH (f);
10860       else if (EQ (Vtool_bar_border, Qborder_width))
10861         border = f->border_width;
10862       else
10863         border = 0;
10864       if (border < 0)
10865         border = 0;
10866 
10867       rows = f->n_tool_bar_rows;
10868       height = max (1, (it.last_visible_y - border) / rows);
10869       extra = it.last_visible_y - border - height * rows;
10870 
10871       while (it.current_y < it.last_visible_y)
10872         {
10873           int h = 0;
10874           if (extra > 0 && rows-- > 0)
10875             {
10876               h = (extra + rows - 1) / rows;
10877               extra -= h;
10878             }
10879           display_tool_bar_line (&it, height + h);
10880         }
10881     }
10882   else
10883     {
10884       while (it.current_y < it.last_visible_y)
10885         display_tool_bar_line (&it, 0);
10886     }
10887 
10888   /* It doesn't make much sense to try scrolling in the tool-bar
10889      window, so don't do it.  */
10890   w->desired_matrix->no_scrolling_p = 1;
10891   w->must_be_updated_p = 1;
10892 
10893   if (!NILP (Vauto_resize_tool_bars))
10894     {
10895       int max_tool_bar_height = MAX_FRAME_TOOL_BAR_HEIGHT (f);
10896       int change_height_p = 0;
10897 
10898       /* If we couldn't display everything, change the tool-bar's
10899          height if there is room for more.  */
10900       if (IT_STRING_CHARPOS (it) < it.end_charpos
10901           && it.current_y < max_tool_bar_height)
10902         change_height_p = 1;
10903 
10904       row = it.glyph_row - 1;
10905 
10906       /* If there are blank lines at the end, except for a partially
10907          visible blank line at the end that is smaller than
10908          FRAME_LINE_HEIGHT, change the tool-bar's height.  */
10909       if (!row->displays_text_p
10910           && row->height >= FRAME_LINE_HEIGHT (f))
10911         change_height_p = 1;
10912 
10913       /* If row displays tool-bar items, but is partially visible,
10914          change the tool-bar's height.  */
10915       if (row->displays_text_p
10916           && MATRIX_ROW_BOTTOM_Y (row) > it.last_visible_y
10917           && MATRIX_ROW_BOTTOM_Y (row) < max_tool_bar_height)
10918         change_height_p = 1;
10919 
10920       /* Resize windows as needed by changing the `tool-bar-lines'
10921          frame parameter.  */
10922       if (change_height_p)
10923         {
10924           extern Lisp_Object Qtool_bar_lines;
10925           Lisp_Object frame;
10926           int old_height = WINDOW_TOTAL_LINES (w);
10927           int nrows;
10928           int nlines = tool_bar_lines_needed (f, &nrows);
10929 
10930           change_height_p = ((EQ (Vauto_resize_tool_bars, Qgrow_only)
10931                               && !f->minimize_tool_bar_window_p)
10932                              ? (nlines > old_height)
10933                              : (nlines != old_height));
10934           f->minimize_tool_bar_window_p = 0;
10935 
10936           if (change_height_p)
10937             {
10938               XSETFRAME (frame, f);
10939               Fmodify_frame_parameters (frame,
10940                                         Fcons (Fcons (Qtool_bar_lines,
10941                                                       make_number (nlines)),
10942                                                Qnil));
10943               if (WINDOW_TOTAL_LINES (w) != old_height)
10944                 {
10945                   clear_glyph_matrix (w->desired_matrix);
10946                   f->n_tool_bar_rows = nrows;
10947                   fonts_changed_p = 1;
10948                   return 1;
10949                 }
10950             }
10951         }
10952     }
10953 
10954   f->minimize_tool_bar_window_p = 0;
10955   return 0;
10956 }
10957 
10958 
10959 /* Get information about the tool-bar item which is displayed in GLYPH
10960    on frame F.  Return in *PROP_IDX the index where tool-bar item
10961    properties start in F->tool_bar_items.  Value is zero if
10962    GLYPH doesn't display a tool-bar item.  */
10963 
10964 static int
10965 tool_bar_item_info (f, glyph, prop_idx)
10966      struct frame *f;
10967      struct glyph *glyph;
10968      int *prop_idx;
10969 {
10970   Lisp_Object prop;
10971   int success_p;
10972   int charpos;
10973 
10974   /* This function can be called asynchronously, which means we must
10975      exclude any possibility that Fget_text_property signals an
10976      error.  */
10977   charpos = min (SCHARS (f->current_tool_bar_string), glyph->charpos);
10978   charpos = max (0, charpos);
10979 
10980   /* Get the text property `menu-item' at pos. The value of that
10981      property is the start index of this item's properties in
10982      F->tool_bar_items.  */
10983   prop = Fget_text_property (make_number (charpos),
10984                              Qmenu_item, f->current_tool_bar_string);
10985   if (INTEGERP (prop))
10986     {
10987       *prop_idx = XINT (prop);
10988       success_p = 1;
10989     }
10990   else
10991     success_p = 0;
10992 
10993   return success_p;
10994 }
10995 
10996 
10997 /* Get information about the tool-bar item at position X/Y on frame F.
10998    Return in *GLYPH a pointer to the glyph of the tool-bar item in
10999    the current matrix of the tool-bar window of F, or NULL if not
11000    on a tool-bar item.  Return in *PROP_IDX the index of the tool-bar
11001    item in F->tool_bar_items.  Value is
11002 
11003    -1   if X/Y is not on a tool-bar item
11004    0    if X/Y is on the same item that was highlighted before.
11005    1    otherwise.  */
11006 
11007 static int
11008 get_tool_bar_item (f, x, y, glyph, hpos, vpos, prop_idx)
11009      struct frame *f;
11010      int x, y;
11011      struct glyph **glyph;
11012      int *hpos, *vpos, *prop_idx;
11013 {
11014   Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
11015   struct window *w = XWINDOW (f->tool_bar_window);
11016   int area;
11017 
11018   /* Find the glyph under X/Y.  */
11019   *glyph = x_y_to_hpos_vpos (w, x, y, hpos, vpos, 0, 0, &area);
11020   if (*glyph == NULL)
11021     return -1;
11022 
11023   /* Get the start of this tool-bar item's properties in
11024      f->tool_bar_items.  */
11025   if (!tool_bar_item_info (f, *glyph, prop_idx))
11026     return -1;
11027 
11028   /* Is mouse on the highlighted item?  */
11029   if (EQ (f->tool_bar_window, dpyinfo->mouse_face_window)
11030       && *vpos >= dpyinfo->mouse_face_beg_row
11031       && *vpos <= dpyinfo->mouse_face_end_row
11032       && (*vpos > dpyinfo->mouse_face_beg_row
11033           || *hpos >= dpyinfo->mouse_face_beg_col)
11034       && (*vpos < dpyinfo->mouse_face_end_row
11035           || *hpos < dpyinfo->mouse_face_end_col
11036           || dpyinfo->mouse_face_past_end))
11037     return 0;
11038 
11039   return 1;
11040 }
11041 
11042 
11043 /* EXPORT:
11044    Handle mouse button event on the tool-bar of frame F, at
11045    frame-relative coordinates X/Y.  DOWN_P is 1 for a button press,
11046    0 for button release.  MODIFIERS is event modifiers for button
11047    release.  */
11048 
11049 void
11050 handle_tool_bar_click (f, x, y, down_p, modifiers)
11051      struct frame *f;
11052      int x, y, down_p;
11053      unsigned int modifiers;
11054 {
11055   Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
11056   struct window *w = XWINDOW (f->tool_bar_window);
11057   int hpos, vpos, prop_idx;
11058   struct glyph *glyph;
11059   Lisp_Object enabled_p;
11060 
11061   /* If not on the highlighted tool-bar item, return.  */
11062   frame_to_window_pixel_xy (w, &x, &y);
11063   if (get_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx) != 0)
11064     return;
11065 
11066   /* If item is disabled, do nothing.  */
11067   enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
11068   if (NILP (enabled_p))
11069     return;
11070 
11071   if (down_p)
11072     {
11073       /* Show item in pressed state.  */
11074       show_mouse_face (dpyinfo, DRAW_IMAGE_SUNKEN);
11075       dpyinfo->mouse_face_image_state = DRAW_IMAGE_SUNKEN;
11076       last_tool_bar_item = prop_idx;
11077     }
11078   else
11079     {
11080       Lisp_Object key, frame;
11081       struct input_event event;
11082       EVENT_INIT (event);
11083 
11084       /* Show item in released state.  */
11085       show_mouse_face (dpyinfo, DRAW_IMAGE_RAISED);
11086       dpyinfo->mouse_face_image_state = DRAW_IMAGE_RAISED;
11087 
11088       key = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_KEY);
11089 
11090       XSETFRAME (frame, f);
11091       event.kind = TOOL_BAR_EVENT;
11092       event.frame_or_window = frame;
11093       event.arg = frame;
11094       kbd_buffer_store_event (&event);
11095 
11096       event.kind = TOOL_BAR_EVENT;
11097       event.frame_or_window = frame;
11098       event.arg = key;
11099       event.modifiers = modifiers;
11100       kbd_buffer_store_event (&event);
11101       last_tool_bar_item = -1;
11102     }
11103 }
11104 
11105 
11106 /* Possibly highlight a tool-bar item on frame F when mouse moves to
11107    tool-bar window-relative coordinates X/Y.  Called from
11108    note_mouse_highlight.  */
11109 
11110 static void
11111 note_tool_bar_highlight (f, x, y)
11112      struct frame *f;
11113      int x, y;
11114 {
11115   Lisp_Object window = f->tool_bar_window;
11116   struct window *w = XWINDOW (window);
11117   Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
11118   int hpos, vpos;
11119   struct glyph *glyph;
11120   struct glyph_row *row;
11121   int i;
11122   Lisp_Object enabled_p;
11123   int prop_idx;
11124   enum draw_glyphs_face draw = DRAW_IMAGE_RAISED;
11125   int mouse_down_p, rc;
11126 
11127   /* Function note_mouse_highlight is called with negative x(y
11128      values when mouse moves outside of the frame.  */
11129   if (x <= 0 || y <= 0)
11130     {
11131       clear_mouse_face (dpyinfo);
11132       return;
11133     }
11134 
11135   rc = get_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx);
11136   if (rc < 0)
11137     {
11138       /* Not on tool-bar item.  */
11139       clear_mouse_face (dpyinfo);
11140       return;
11141     }
11142   else if (rc == 0)
11143     /* On same tool-bar item as before.  */
11144     goto set_help_echo;
11145 
11146   clear_mouse_face (dpyinfo);
11147 
11148   /* Mouse is down, but on different tool-bar item?  */
11149   mouse_down_p = (dpyinfo->grabbed
11150                   && f == last_mouse_frame
11151                   && FRAME_LIVE_P (f));
11152   if (mouse_down_p
11153       && last_tool_bar_item != prop_idx)
11154     return;
11155 
11156   dpyinfo->mouse_face_image_state = DRAW_NORMAL_TEXT;
11157   draw = mouse_down_p ? DRAW_IMAGE_SUNKEN : DRAW_IMAGE_RAISED;
11158 
11159   /* If tool-bar item is not enabled, don't highlight it.  */
11160   enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
11161   if (!NILP (enabled_p))
11162     {
11163       /* Compute the x-position of the glyph.  In front and past the
11164          image is a space.  We include this in the highlighted area.  */
11165       row = MATRIX_ROW (w->current_matrix, vpos);
11166       for (i = x = 0; i < hpos; ++i)
11167         x += row->glyphs[TEXT_AREA][i].pixel_width;
11168 
11169       /* Record this as the current active region.  */
11170       dpyinfo->mouse_face_beg_col = hpos;
11171       dpyinfo->mouse_face_beg_row = vpos;
11172       dpyinfo->mouse_face_beg_x = x;
11173       dpyinfo->mouse_face_beg_y = row->y;
11174       dpyinfo->mouse_face_past_end = 0;
11175 
11176       dpyinfo->mouse_face_end_col = hpos + 1;
11177       dpyinfo->mouse_face_end_row = vpos;
11178       dpyinfo->mouse_face_end_x = x + glyph->pixel_width;
11179       dpyinfo->mouse_face_end_y = row->y;
11180       dpyinfo->mouse_face_window = window;
11181       dpyinfo->mouse_face_face_id = TOOL_BAR_FACE_ID;
11182 
11183       /* Display it as active.  */
11184       show_mouse_face (dpyinfo, draw);
11185       dpyinfo->mouse_face_image_state = draw;
11186     }
11187 
11188  set_help_echo:
11189 
11190   /* Set help_echo_string to a help string to display for this tool-bar item.
11191      XTread_socket does the rest.  */
11192   help_echo_object = help_echo_window = Qnil;
11193   help_echo_pos = -1;
11194   help_echo_string = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_HELP);
11195   if (NILP (help_echo_string))
11196     help_echo_string = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_CAPTION);
11197 }
11198 
11199 #endif /* HAVE_WINDOW_SYSTEM */
11200 
11201 
11202 
11203 /************************************************************************
11204                          Horizontal scrolling
11205  ************************************************************************/
11206 
11207 static int hscroll_window_tree P_ ((Lisp_Object));
11208 static int hscroll_windows P_ ((Lisp_Object));
11209 
11210 /* For all leaf windows in the window tree rooted at WINDOW, set their
11211    hscroll value so that PT is (i) visible in the window, and (ii) so
11212    that it is not within a certain margin at the window's left and
11213    right border.  Value is non-zero if any window's hscroll has been
11214    changed.  */
11215 
11216 static int
11217 hscroll_window_tree (window)
11218      Lisp_Object window;
11219 {
11220   int hscrolled_p = 0;
11221   int hscroll_relative_p = FLOATP (Vhscroll_step);
11222   int hscroll_step_abs = 0;
11223   double hscroll_step_rel = 0;
11224 
11225   if (hscroll_relative_p)
11226     {
11227       hscroll_step_rel = XFLOAT_DATA (Vhscroll_step);
11228       if (hscroll_step_rel < 0)
11229         {
11230           hscroll_relative_p = 0;
11231           hscroll_step_abs = 0;
11232         }
11233     }
11234   else if (INTEGERP (Vhscroll_step))
11235     {
11236       hscroll_step_abs = XINT (Vhscroll_step);
11237       if (hscroll_step_abs < 0)
11238         hscroll_step_abs = 0;
11239     }
11240   else
11241     hscroll_step_abs = 0;
11242 
11243   while (WINDOWP (window))
11244     {
11245       struct window *w = XWINDOW (window);
11246 
11247       if (WINDOWP (w->hchild))
11248         hscrolled_p |= hscroll_window_tree (w->hchild);
11249       else if (WINDOWP (w->vchild))
11250         hscrolled_p |= hscroll_window_tree (w->vchild);
11251       else if (w->cursor.vpos >= 0)
11252         {
11253           int h_margin;
11254           int text_area_width;
11255           struct glyph_row *current_cursor_row
11256             = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
11257           struct glyph_row *desired_cursor_row
11258             = MATRIX_ROW (w->desired_matrix, w->cursor.vpos);
11259           struct glyph_row *cursor_row
11260             = (desired_cursor_row->enabled_p
11261                ? desired_cursor_row
11262                : current_cursor_row);
11263 
11264           text_area_width = window_box_width (w, TEXT_AREA);
11265 
11266           /* Scroll when cursor is inside this scroll margin.  */
11267           h_margin = hscroll_margin * WINDOW_FRAME_COLUMN_WIDTH (w);
11268 
11269           if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode, w->buffer))
11270               && ((XFASTINT (w->hscroll)
11271                    && w->cursor.x <= h_margin)
11272                   || (cursor_row->enabled_p
11273                       && cursor_row->truncated_on_right_p
11274                       && (w->cursor.x >= text_area_width - h_margin))))
11275             {
11276               struct it it;
11277               int hscroll;
11278               struct buffer *saved_current_buffer;
11279               int pt;
11280               int wanted_x;
11281 
11282               /* Find point in a display of infinite width.  */
11283               saved_current_buffer = current_buffer;
11284               current_buffer = XBUFFER (w->buffer);
11285 
11286               if (w == XWINDOW (selected_window))
11287                 pt = BUF_PT (current_buffer);
11288               else
11289                 {
11290                   pt = marker_position (w->pointm);
11291                   pt = max (BEGV, pt);
11292                   pt = min (ZV, pt);
11293                 }
11294 
11295               /* Move iterator to pt starting at cursor_row->start in
11296                  a line with infinite width.  */
11297               init_to_row_start (&it, w, cursor_row);
11298               it.last_visible_x = INFINITY;
11299               move_it_in_display_line_to (&it, pt, -1, MOVE_TO_POS);
11300               current_buffer = saved_current_buffer;
11301 
11302               /* Position cursor in window.  */
11303               if (!hscroll_relative_p && hscroll_step_abs == 0)
11304                 hscroll = max (0, (it.current_x
11305                                    - (ITERATOR_AT_END_OF_LINE_P (&it)
11306                                       ? (text_area_width - 4 * FRAME_COLUMN_WIDTH (it.f))
11307                                       : (text_area_width / 2))))
11308                           / FRAME_COLUMN_WIDTH (it.f);
11309               else if (w->cursor.x >= text_area_width - h_margin)
11310                 {
11311                   if (hscroll_relative_p)
11312                     wanted_x = text_area_width * (1 - hscroll_step_rel)
11313                                - h_margin;
11314                   else
11315                     wanted_x = text_area_width
11316                                - hscroll_step_abs * FRAME_COLUMN_WIDTH (it.f)
11317                                - h_margin;
11318                   hscroll
11319                     = max (0, it.current_x - wanted_x) / FRAME_COLUMN_WIDTH (it.f);
11320                 }
11321               else
11322                 {
11323                   if (hscroll_relative_p)
11324                     wanted_x = text_area_width * hscroll_step_rel
11325                                + h_margin;
11326                   else
11327                     wanted_x = hscroll_step_abs * FRAME_COLUMN_WIDTH (it.f)
11328                                + h_margin;
11329                   hscroll
11330                     = max (0, it.current_x - wanted_x) / FRAME_COLUMN_WIDTH (it.f);
11331                 }
11332               hscroll = max (hscroll, XFASTINT (w->min_hscroll));
11333 
11334               /* Don't call Fset_window_hscroll if value hasn't
11335                  changed because it will prevent redisplay
11336                  optimizations.  */
11337               if (XFASTINT (w->hscroll) != hscroll)
11338                 {
11339                   XBUFFER (w->buffer)->prevent_redisplay_optimizations_p = 1;
11340                   w->hscroll = make_number (hscroll);
11341                   hscrolled_p = 1;
11342                 }
11343             }
11344         }
11345 
11346       window = w->next;
11347     }
11348 
11349   /* Value is non-zero if hscroll of any leaf window has been changed.  */
11350   return hscrolled_p;
11351 }
11352 
11353 
11354 /* Set hscroll so that cursor is visible and not inside horizontal
11355    scroll margins for all windows in the tree rooted at WINDOW.  See
11356    also hscroll_window_tree above.  Value is non-zero if any window's
11357    hscroll has been changed.  If it has, desired matrices on the frame
11358    of WINDOW are cleared.  */
11359 
11360 static int
11361 hscroll_windows (window)
11362      Lisp_Object window;
11363 {
11364   int hscrolled_p = hscroll_window_tree (window);
11365   if (hscrolled_p)
11366     clear_desired_matrices (XFRAME (WINDOW_FRAME (XWINDOW (window))));
11367   return hscrolled_p;
11368 }
11369 
11370 
11371 
11372 /************************************************************************
11373                                 Redisplay
11374  ************************************************************************/
11375 
11376 /* Variables holding some state of redisplay if GLYPH_DEBUG is defined
11377    to a non-zero value.  This is sometimes handy to have in a debugger
11378    session.  */
11379 
11380 #if GLYPH_DEBUG
11381 
11382 /* First and last unchanged row for try_window_id.  */
11383 
11384 int debug_first_unchanged_at_end_vpos;
11385 int debug_last_unchanged_at_beg_vpos;
11386 
11387 /* Delta vpos and y.  */
11388 
11389 int debug_dvpos, debug_dy;
11390 
11391 /* Delta in characters and bytes for try_window_id.  */
11392 
11393 int debug_delta, debug_delta_bytes;
11394 
11395 /* Values of window_end_pos and window_end_vpos at the end of
11396    try_window_id.  */
11397 
11398 EMACS_INT debug_end_pos, debug_end_vpos;
11399 
11400 /* Append a string to W->desired_matrix->method.  FMT is a printf
11401    format string.  A1...A9 are a supplement for a variable-length
11402    argument list.  If trace_redisplay_p is non-zero also printf the
11403    resulting string to stderr.  */
11404 
11405 static void
11406 debug_method_add (w, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9)
11407      struct window *w;
11408      char *fmt;
11409      int a1, a2, a3, a4, a5, a6, a7, a8, a9;
11410 {
11411   char buffer[512];
11412   char *method = w->desired_matrix->method;
11413   int len = strlen (method);
11414   int size = sizeof w->desired_matrix->method;
11415   int remaining = size - len - 1;
11416 
11417   sprintf (buffer, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9);
11418   if (len && remaining)
11419     {
11420       method[len] = '|';
11421       --remaining, ++len;
11422     }
11423 
11424   strncpy (method + len, buffer, remaining);
11425 
11426   if (trace_redisplay_p)
11427     fprintf (stderr, "%p (%s): %s\n",
11428              w,
11429              ((BUFFERP (w->buffer)
11430                && STRINGP (XBUFFER (w->buffer)->name))
11431               ? (char *) SDATA (XBUFFER (w->buffer)->name)
11432               : "no buffer"),
11433              buffer);
11434 }
11435 
11436 #endif /* GLYPH_DEBUG */
11437 
11438 
11439 /* Value is non-zero if all changes in window W, which displays
11440    current_buffer, are in the text between START and END.  START is a
11441    buffer position, END is given as a distance from Z.  Used in
11442    redisplay_internal for display optimization.  */
11443 
11444 static INLINE int
11445 text_outside_line_unchanged_p (w, start, end)
11446      struct window *w;
11447      int start, end;
11448 {
11449   int unchanged_p = 1;
11450 
11451   /* If text or overlays have changed, see where.  */
11452   if (XFASTINT (w->last_modified) < MODIFF
11453       || XFASTINT (w->last_overlay_modified) < OVERLAY_MODIFF)
11454     {
11455       /* Gap in the line?  */
11456       if (GPT < start || Z - GPT < end)
11457         unchanged_p = 0;
11458 
11459       /* Changes start in front of the line, or end after it?  */
11460       if (unchanged_p
11461           && (BEG_UNCHANGED < start - 1
11462               || END_UNCHANGED < end))
11463         unchanged_p = 0;
11464 
11465       /* If selective display, can't optimize if changes start at the
11466          beginning of the line.  */
11467       if (unchanged_p
11468           && INTEGERP (current_buffer->selective_display)
11469           && XINT (current_buffer->selective_display) > 0
11470           && (BEG_UNCHANGED < start || GPT <= start))
11471         unchanged_p = 0;
11472 
11473       /* If there are overlays at the start or end of the line, these
11474          may have overlay strings with newlines in them.  A change at
11475          START, for instance, may actually concern the display of such
11476          overlay strings as well, and they are displayed on different
11477          lines.  So, quickly rule out this case.  (For the future, it
11478          might be desirable to implement something more telling than
11479          just BEG/END_UNCHANGED.)  */
11480       if (unchanged_p)
11481         {
11482           if (BEG + BEG_UNCHANGED == start
11483               && overlay_touches_p (start))
11484             unchanged_p = 0;
11485           if (END_UNCHANGED == end
11486               && overlay_touches_p (Z - end))
11487             unchanged_p = 0;
11488         }
11489 
11490       /* Under bidi reordering, adding or deleting a character in the
11491          beginning of a paragraph, before the first strong directional
11492          character, can change the base direction of the paragraph (unless
11493          the buffer specifies a fixed paragraph direction), which will
11494          require to redisplay the whole paragraph.  It might be worthwhile
11495          to find the paragraph limits and widen the range of redisplayed
11496          lines to that, but for now just give up this optimization.  */
11497       if (!NILP (XBUFFER (w->buffer)->bidi_display_reordering)
11498           && NILP (XBUFFER (w->buffer)->bidi_paragraph_direction))
11499         unchanged_p = 0;
11500     }
11501 
11502   return unchanged_p;
11503 }
11504 
11505 
11506 /* Do a frame update, taking possible shortcuts into account.  This is
11507    the main external entry point for redisplay.
11508 
11509    If the last redisplay displayed an echo area message and that message
11510    is no longer requested, we clear the echo area or bring back the
11511    mini-buffer if that is in use.  */
11512 
11513 void
11514 redisplay ()
11515 {
11516   redisplay_internal (0);
11517 }
11518 
11519 
11520 static Lisp_Object
11521 overlay_arrow_string_or_property (var)
11522      Lisp_Object var;
11523 {
11524   Lisp_Object val;
11525 
11526   if (val = Fget (var, Qoverlay_arrow_string), STRINGP (val))
11527     return val;
11528 
11529   return Voverlay_arrow_string;
11530 }
11531 
11532 /* Return 1 if there are any overlay-arrows in current_buffer.  */
11533 static int
11534 overlay_arrow_in_current_buffer_p ()
11535 {
11536   Lisp_Object vlist;
11537 
11538   for (vlist = Voverlay_arrow_variable_list;
11539        CONSP (vlist);
11540        vlist = XCDR (vlist))
11541     {
11542       Lisp_Object var = XCAR (vlist);
11543       Lisp_Object val;
11544 
11545       if (!SYMBOLP (var))
11546         continue;
11547       val = find_symbol_value (var);
11548       if (MARKERP (val)
11549           && current_buffer == XMARKER (val)->buffer)
11550         return 1;
11551     }
11552   return 0;
11553 }
11554 
11555 
11556 /* Return 1 if any overlay_arrows have moved or overlay-arrow-string
11557    has changed.  */
11558 
11559 static int
11560 overlay_arrows_changed_p ()
11561 {
11562   Lisp_Object vlist;
11563 
11564   for (vlist = Voverlay_arrow_variable_list;
11565        CONSP (vlist);
11566        vlist = XCDR (vlist))
11567     {
11568       Lisp_Object var = XCAR (vlist);
11569       Lisp_Object val, pstr;
11570 
11571       if (!SYMBOLP (var))
11572         continue;
11573       val = find_symbol_value (var);
11574       if (!MARKERP (val))
11575         continue;
11576       if (! EQ (COERCE_MARKER (val),
11577                 Fget (var, Qlast_arrow_position))
11578           || ! (pstr = overlay_arrow_string_or_property (var),
11579                 EQ (pstr, Fget (var, Qlast_arrow_string))))
11580         return 1;
11581     }
11582   return 0;
11583 }
11584 
11585 /* Mark overlay arrows to be updated on next redisplay.  */
11586 
11587 static void
11588 update_overlay_arrows (up_to_date)
11589      int up_to_date;
11590 {
11591   Lisp_Object vlist;
11592 
11593   for (vlist = Voverlay_arrow_variable_list;
11594        CONSP (vlist);
11595        vlist = XCDR (vlist))
11596     {
11597       Lisp_Object var = XCAR (vlist);
11598 
11599       if (!SYMBOLP (var))
11600         continue;
11601 
11602       if (up_to_date > 0)
11603         {
11604           Lisp_Object val = find_symbol_value (var);
11605           Fput (var, Qlast_arrow_position,
11606                 COERCE_MARKER (val));
11607           Fput (var, Qlast_arrow_string,
11608                 overlay_arrow_string_or_property (var));
11609         }
11610       else if (up_to_date < 0
11611                || !NILP (Fget (var, Qlast_arrow_position)))
11612         {
11613           Fput (var, Qlast_arrow_position, Qt);
11614           Fput (var, Qlast_arrow_string, Qt);
11615         }
11616     }
11617 }
11618 
11619 
11620 /* Return overlay arrow string to display at row.
11621    Return integer (bitmap number) for arrow bitmap in left fringe.
11622    Return nil if no overlay arrow.  */
11623 
11624 static Lisp_Object
11625 overlay_arrow_at_row (it, row)
11626      struct it *it;
11627      struct glyph_row *row;
11628 {
11629   Lisp_Object vlist;
11630 
11631   for (vlist = Voverlay_arrow_variable_list;
11632        CONSP (vlist);
11633        vlist = XCDR (vlist))
11634     {
11635       Lisp_Object var = XCAR (vlist);
11636       Lisp_Object val;
11637 
11638       if (!SYMBOLP (var))
11639         continue;
11640 
11641       val = find_symbol_value (var);
11642 
11643       if (MARKERP (val)
11644           && current_buffer == XMARKER (val)->buffer
11645           && (MATRIX_ROW_START_CHARPOS (row) == marker_position (val)))
11646         {
11647           if (FRAME_WINDOW_P (it->f)
11648               && WINDOW_LEFT_FRINGE_WIDTH (it->w) > 0)
11649             {
11650 #ifdef HAVE_WINDOW_SYSTEM
11651               if (val = Fget (var, Qoverlay_arrow_bitmap), SYMBOLP (val))
11652                 {
11653                   int fringe_bitmap;
11654                   if ((fringe_bitmap = lookup_fringe_bitmap (val)) != 0)
11655                     return make_number (fringe_bitmap);
11656                 }
11657 #endif
11658               return make_number (-1); /* Use default arrow bitmap */
11659             }
11660           return overlay_arrow_string_or_property (var);
11661         }
11662     }
11663 
11664   return Qnil;
11665 }
11666 
11667 /* Return 1 if point moved out of or into a composition.  Otherwise
11668    return 0.  PREV_BUF and PREV_PT are the last point buffer and
11669    position.  BUF and PT are the current point buffer and position.  */
11670 
11671 int
11672 check_point_in_composition (prev_buf, prev_pt, buf, pt)
11673      struct buffer *prev_buf, *buf;
11674      int prev_pt, pt;
11675 {
11676   EMACS_INT start, end;
11677   Lisp_Object prop;
11678   Lisp_Object buffer;
11679 
11680   XSETBUFFER (buffer, buf);
11681   /* Check a composition at the last point if point moved within the
11682      same buffer.  */
11683   if (prev_buf == buf)
11684     {
11685       if (prev_pt == pt)
11686         /* Point didn't move.  */
11687         return 0;
11688 
11689       if (prev_pt > BUF_BEGV (buf) && prev_pt < BUF_ZV (buf)
11690           && find_composition (prev_pt, -1, &start, &end, &prop, buffer)
11691           && COMPOSITION_VALID_P (start, end, prop)
11692           && start < prev_pt && end > prev_pt)
11693         /* The last point was within the composition.  Return 1 iff
11694             point moved out of the composition.  */
11695         return (pt <= start || pt >= end);
11696     }
11697 
11698   /* Check a composition at the current point.  */
11699   return (pt > BUF_BEGV (buf) && pt < BUF_ZV (buf)
11700           && find_composition (pt, -1, &start, &end, &prop, buffer)
11701           && COMPOSITION_VALID_P (start, end, prop)
11702           && start < pt && end > pt);
11703 }
11704 
11705 
11706 /* Reconsider the setting of B->clip_changed which is displayed
11707    in window W.  */
11708 
11709 static INLINE void
11710 reconsider_clip_changes (w, b)
11711      struct window *w;
11712      struct buffer *b;
11713 {
11714   if (b->clip_changed
11715            && !NILP (w->window_end_valid)
11716            && w->current_matrix->buffer == b
11717            && w->current_matrix->zv == BUF_ZV (b)
11718            && w->current_matrix->begv == BUF_BEGV (b))
11719     b->clip_changed = 0;
11720 
11721   /* If display wasn't paused, and W is not a tool bar window, see if
11722      point has been moved into or out of a composition.  In that case,
11723      we set b->clip_changed to 1 to force updating the screen.  If
11724      b->clip_changed has already been set to 1, we can skip this
11725      check.  */
11726   if (!b->clip_changed
11727       && BUFFERP (w->buffer) && !NILP (w->window_end_valid))
11728     {
11729       int pt;
11730 
11731       if (w == XWINDOW (selected_window))
11732         pt = BUF_PT (current_buffer);
11733       else
11734         pt = marker_position (w->pointm);
11735 
11736       if ((w->current_matrix->buffer != XBUFFER (w->buffer)
11737            || pt != XINT (w->last_point))
11738           && check_point_in_composition (w->current_matrix->buffer,
11739                                          XINT (w->last_point),
11740                                          XBUFFER (w->buffer), pt))
11741         b->clip_changed = 1;
11742     }
11743 }
11744 
11745 
11746 /* Select FRAME to forward the values of frame-local variables into C
11747    variables so that the redisplay routines can access those values
11748    directly.  */
11749 
11750 static void
11751 select_frame_for_redisplay (frame)
11752      Lisp_Object frame;
11753 {
11754   Lisp_Object tail, tem;
11755   Lisp_Object old = selected_frame;
11756   struct Lisp_Symbol *sym;
11757 
11758   xassert (FRAMEP (frame) && FRAME_LIVE_P (XFRAME (frame)));
11759 
11760   selected_frame = frame;
11761 
11762   do {
11763     for (tail = XFRAME (frame)->param_alist; CONSP (tail); tail = XCDR (tail))
11764       if (CONSP (XCAR (tail))
11765           && (tem = XCAR (XCAR (tail)),
11766               SYMBOLP (tem))
11767           && (sym = indirect_variable (XSYMBOL (tem)),
11768               sym->redirect == SYMBOL_LOCALIZED)
11769           && sym->val.blv->frame_local)
11770         /* Use find_symbol_value rather than Fsymbol_value
11771            to avoid an error if it is void.  */
11772         find_symbol_value (tem);
11773   } while (!EQ (frame, old) && (frame = old, 1));
11774 }
11775 
11776 
11777 #define STOP_POLLING                                    \
11778 do { if (! polling_stopped_here) stop_polling ();       \
11779        polling_stopped_here = 1; } while (0)
11780 
11781 #define RESUME_POLLING                                  \
11782 do { if (polling_stopped_here) start_polling ();        \
11783        polling_stopped_here = 0; } while (0)
11784 
11785 
11786 /* If PRESERVE_ECHO_AREA is nonzero, it means this redisplay is not in
11787    response to any user action; therefore, we should preserve the echo
11788    area.  (Actually, our caller does that job.)  Perhaps in the future
11789    avoid recentering windows if it is not necessary; currently that
11790    causes some problems.  */
11791 
11792 static void
11793 redisplay_internal (preserve_echo_area)
11794      int preserve_echo_area;
11795 {
11796   struct window *w = XWINDOW (selected_window);
11797   struct frame *f;
11798   int pause;
11799   int must_finish = 0;
11800   struct text_pos tlbufpos, tlendpos;
11801   int number_of_visible_frames;
11802   int count, count1;
11803   struct frame *sf;
11804   int polling_stopped_here = 0;
11805   Lisp_Object old_frame = selected_frame;
11806 
11807   /* Non-zero means redisplay has to consider all windows on all
11808      frames.  Zero means, only selected_window is considered.  */
11809   int consider_all_windows_p;
11810 
11811   TRACE ((stderr, "redisplay_internal %d\n", redisplaying_p));
11812 
11813   /* No redisplay if running in batch mode or frame is not yet fully
11814      initialized, or redisplay is explicitly turned off by setting
11815      Vinhibit_redisplay.  */
11816   if (FRAME_INITIAL_P (SELECTED_FRAME ())
11817       || !NILP (Vinhibit_redisplay))
11818     return;
11819 
11820   /* Don't examine these until after testing Vinhibit_redisplay.
11821      When Emacs is shutting down, perhaps because its connection to
11822      X has dropped, we should not look at them at all.  */
11823   f = XFRAME (w->frame);
11824   sf = SELECTED_FRAME ();
11825 
11826   if (!f->glyphs_initialized_p)
11827     return;
11828 
11829 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS)
11830   if (popup_activated ())
11831     return;
11832 #endif
11833 
11834   /* I don't think this happens but let's be paranoid.  */
11835   if (redisplaying_p)
11836     return;
11837 
11838   /* Record a function that resets redisplaying_p to its old value
11839      when we leave this function.  */
11840   count = SPECPDL_INDEX ();
11841   record_unwind_protect (unwind_redisplay,
11842                          Fcons (make_number (redisplaying_p), selected_frame));
11843   ++redisplaying_p;
11844   specbind (Qinhibit_free_realized_faces, Qnil);
11845 
11846   {
11847     Lisp_Object tail, frame;
11848 
11849     FOR_EACH_FRAME (tail, frame)
11850       {
11851         struct frame *f = XFRAME (frame);
11852         f->already_hscrolled_p = 0;
11853       }
11854   }
11855 
11856  retry:
11857   if (!EQ (old_frame, selected_frame)
11858       && FRAME_LIVE_P (XFRAME (old_frame)))
11859     /* When running redisplay, we play a bit fast-and-loose and allow e.g.
11860        selected_frame and selected_window to be temporarily out-of-sync so
11861        when we come back here via `goto retry', we need to resync because we
11862        may need to run Elisp code (via prepare_menu_bars).  */
11863     select_frame_for_redisplay (old_frame);
11864 
11865   pause = 0;
11866   reconsider_clip_changes (w, current_buffer);
11867   last_escape_glyph_frame = NULL;
11868   last_escape_glyph_face_id = (1 << FACE_ID_BITS);
11869 
11870   /* If new fonts have been loaded that make a glyph matrix adjustment
11871      necessary, do it.  */
11872   if (fonts_changed_p)
11873     {
11874       adjust_glyphs (NULL);
11875       ++windows_or_buffers_changed;
11876       fonts_changed_p = 0;
11877     }
11878 
11879   /* If face_change_count is non-zero, init_iterator will free all
11880      realized faces, which includes the faces referenced from current
11881      matrices.  So, we can't reuse current matrices in this case.  */
11882   if (face_change_count)
11883     ++windows_or_buffers_changed;
11884 
11885   if ((FRAME_TERMCAP_P (sf) || FRAME_MSDOS_P (sf))
11886       && FRAME_TTY (sf)->previous_frame != sf)
11887     {
11888       /* Since frames on a single ASCII terminal share the same
11889          display area, displaying a different frame means redisplay
11890          the whole thing.  */
11891       windows_or_buffers_changed++;
11892       SET_FRAME_GARBAGED (sf);
11893 #ifndef DOS_NT
11894       set_tty_color_mode (FRAME_TTY (sf), sf);
11895 #endif
11896       FRAME_TTY (sf)->previous_frame = sf;
11897     }
11898 
11899   /* Set the visible flags for all frames.  Do this before checking
11900      for resized or garbaged frames; they want to know if their frames
11901      are visible.  See the comment in frame.h for
11902      FRAME_SAMPLE_VISIBILITY.  */
11903   {
11904     Lisp_Object tail, frame;
11905 
11906     number_of_visible_frames = 0;
11907 
11908     FOR_EACH_FRAME (tail, frame)
11909       {
11910         struct frame *f = XFRAME (frame);
11911 
11912         FRAME_SAMPLE_VISIBILITY (f);
11913         if (FRAME_VISIBLE_P (f))
11914           ++number_of_visible_frames;
11915         clear_desired_matrices (f);
11916       }
11917   }
11918 
11919   /* Notice any pending interrupt request to change frame size.  */
11920   do_pending_window_change (1);
11921 
11922   /* Clear frames marked as garbaged.  */
11923   if (frame_garbaged)
11924     clear_garbaged_frames ();
11925 
11926   /* Build menubar and tool-bar items.  */
11927   if (NILP (Vmemory_full))
11928     prepare_menu_bars ();
11929 
11930   if (windows_or_buffers_changed)
11931     update_mode_lines++;
11932 
11933   /* Detect case that we need to write or remove a star in the mode line.  */
11934   if ((SAVE_MODIFF < MODIFF) != !NILP (w->last_had_star))
11935     {
11936       w->update_mode_line = Qt;
11937       if (buffer_shared > 1)
11938         update_mode_lines++;
11939     }
11940 
11941   /* Avoid invocation of point motion hooks by `current_column' below.  */
11942   count1 = SPECPDL_INDEX ();
11943   specbind (Qinhibit_point_motion_hooks, Qt);
11944 
11945   /* If %c is in the mode line, update it if needed.  */
11946   if (!NILP (w->column_number_displayed)
11947       /* This alternative quickly identifies a common case
11948          where no change is needed.  */
11949       && !(PT == XFASTINT (w->last_point)
11950            && XFASTINT (w->last_modified) >= MODIFF
11951            && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF)
11952       && (XFASTINT (w->column_number_displayed)
11953           != (int) current_column ()))  /* iftc */
11954     w->update_mode_line = Qt;
11955 
11956   unbind_to (count1, Qnil);
11957 
11958   FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w->frame)) = -1;
11959 
11960   /* The variable buffer_shared is set in redisplay_window and
11961      indicates that we redisplay a buffer in different windows.  See
11962      there.  */
11963   consider_all_windows_p = (update_mode_lines || buffer_shared > 1
11964                             || cursor_type_changed);
11965 
11966   /* If specs for an arrow have changed, do thorough redisplay
11967      to ensure we remove any arrow that should no longer exist.  */
11968   if (overlay_arrows_changed_p ())
11969     consider_all_windows_p = windows_or_buffers_changed = 1;
11970 
11971   /* Normally the message* functions will have already displayed and
11972      updated the echo area, but the frame may have been trashed, or
11973      the update may have been preempted, so display the echo area
11974      again here.  Checking message_cleared_p captures the case that
11975      the echo area should be cleared.  */
11976   if ((!NILP (echo_area_buffer[0]) && !display_last_displayed_message_p)
11977       || (!NILP (echo_area_buffer[1]) && display_last_displayed_message_p)
11978       || (message_cleared_p
11979           && minibuf_level == 0
11980           /* If the mini-window is currently selected, this means the
11981              echo-area doesn't show through.  */
11982           && !MINI_WINDOW_P (XWINDOW (selected_window))))
11983     {
11984       int window_height_changed_p = echo_area_display (0);
11985       must_finish = 1;
11986 
11987       /* If we don't display the current message, don't clear the
11988          message_cleared_p flag, because, if we did, we wouldn't clear
11989          the echo area in the next redisplay which doesn't preserve
11990          the echo area.  */
11991       if (!display_last_displayed_message_p)
11992         message_cleared_p = 0;
11993 
11994       if (fonts_changed_p)
11995         goto retry;
11996       else if (window_height_changed_p)
11997         {
11998           consider_all_windows_p = 1;
11999           ++update_mode_lines;
12000           ++windows_or_buffers_changed;
12001 
12002           /* If window configuration was changed, frames may have been
12003              marked garbaged.  Clear them or we will experience
12004              surprises wrt scrolling.  */
12005           if (frame_garbaged)
12006             clear_garbaged_frames ();
12007         }
12008     }
12009   else if (EQ (selected_window, minibuf_window)
12010            && (current_buffer->clip_changed
12011                || XFASTINT (w->last_modified) < MODIFF
12012                || XFASTINT (w->last_overlay_modified) < OVERLAY_MODIFF)
12013            && resize_mini_window (w, 0))
12014     {
12015       /* Resized active mini-window to fit the size of what it is
12016          showing if its contents might have changed.  */
12017       must_finish = 1;
12018 /* FIXME: this causes all frames to be updated, which seems unnecessary
12019    since only the current frame needs to be considered.  This function needs
12020    to be rewritten with two variables, consider_all_windows and
12021    consider_all_frames. */
12022       consider_all_windows_p = 1;
12023       ++windows_or_buffers_changed;
12024       ++update_mode_lines;
12025 
12026       /* If window configuration was changed, frames may have been
12027          marked garbaged.  Clear them or we will experience
12028          surprises wrt scrolling.  */
12029       if (frame_garbaged)
12030         clear_garbaged_frames ();
12031     }
12032 
12033 
12034   /* If showing the region, and mark has changed, we must redisplay
12035      the whole window.  The assignment to this_line_start_pos prevents
12036      the optimization directly below this if-statement.  */
12037   if (((!NILP (Vtransient_mark_mode)
12038         && !NILP (XBUFFER (w->buffer)->mark_active))
12039        != !NILP (w->region_showing))
12040       || (!NILP (w->region_showing)
12041           && !EQ (w->region_showing,
12042                   Fmarker_position (XBUFFER (w->buffer)->mark))))
12043     CHARPOS (this_line_start_pos) = 0;
12044 
12045   /* Optimize the case that only the line containing the cursor in the
12046      selected window has changed.  Variables starting with this_ are
12047      set in display_line and record information about the line
12048      containing the cursor.  */
12049   tlbufpos = this_line_start_pos;
12050   tlendpos = this_line_end_pos;
12051   if (!consider_all_windows_p
12052       && CHARPOS (tlbufpos) > 0
12053       && NILP (w->update_mode_line)
12054       && !current_buffer->clip_changed
12055       && !current_buffer->prevent_redisplay_optimizations_p
12056       && FRAME_VISIBLE_P (XFRAME (w->frame))
12057       && !FRAME_OBSCURED_P (XFRAME (w->frame))
12058       /* Make sure recorded data applies to current buffer, etc.  */
12059       && this_line_buffer == current_buffer
12060       && current_buffer == XBUFFER (w->buffer)
12061       && NILP (w->force_start)
12062       && NILP (w->optional_new_start)
12063       /* Point must be on the line that we have info recorded about.  */
12064       && PT >= CHARPOS (tlbufpos)
12065       && PT <= Z - CHARPOS (tlendpos)
12066       /* All text outside that line, including its final newline,
12067          must be unchanged.  */
12068       && text_outside_line_unchanged_p (w, CHARPOS (tlbufpos),
12069                                         CHARPOS (tlendpos)))
12070     {
12071       if (CHARPOS (tlbufpos) > BEGV
12072           && FETCH_BYTE (BYTEPOS (tlbufpos) - 1) != '\n'
12073           && (CHARPOS (tlbufpos) == ZV
12074               || FETCH_BYTE (BYTEPOS (tlbufpos)) == '\n'))
12075         /* Former continuation line has disappeared by becoming empty.  */
12076         goto cancel;
12077       else if (XFASTINT (w->last_modified) < MODIFF
12078                || XFASTINT (w->last_overlay_modified) < OVERLAY_MODIFF
12079                || MINI_WINDOW_P (w))
12080         {
12081           /* We have to handle the case of continuation around a
12082              wide-column character (see the comment in indent.c around
12083              line 1340).
12084 
12085              For instance, in the following case:
12086 
12087              --------  Insert  --------
12088              K_A_N_\\   `a'    K_A_N_a\         `X_' are wide-column chars.
12089              J_I_       ==>    J_I_             `^^' are cursors.
12090              ^^                ^^
12091              --------          --------
12092 
12093              As we have to redraw the line above, we cannot use this
12094              optimization.  */
12095 
12096           struct it it;
12097           int line_height_before = this_line_pixel_height;
12098 
12099           /* Note that start_display will handle the case that the
12100              line starting at tlbufpos is a continuation line.  */
12101           start_display (&it, w, tlbufpos);
12102 
12103           /* Implementation note: It this still necessary?  */
12104           if (it.current_x != this_line_start_x)
12105             goto cancel;
12106 
12107           TRACE ((stderr, "trying display optimization 1\n"));
12108           w->cursor.vpos = -1;
12109           overlay_arrow_seen = 0;
12110           it.vpos = this_line_vpos;
12111           it.current_y = this_line_y;
12112           it.glyph_row = MATRIX_ROW (w->desired_matrix, this_line_vpos);
12113           display_line (&it);
12114 
12115           /* If line contains point, is not continued,
12116              and ends at same distance from eob as before, we win.  */
12117           if (w->cursor.vpos >= 0
12118               /* Line is not continued, otherwise this_line_start_pos
12119                  would have been set to 0 in display_line.  */
12120               && CHARPOS (this_line_start_pos)
12121               /* Line ends as before.  */
12122               && CHARPOS (this_line_end_pos) == CHARPOS (tlendpos)
12123               /* Line has same height as before.  Otherwise other lines
12124                  would have to be shifted up or down.  */
12125               && this_line_pixel_height == line_height_before)
12126             {
12127               /* If this is not the window's last line, we must adjust
12128                  the charstarts of the lines below.  */
12129               if (it.current_y < it.last_visible_y)
12130                 {
12131                   struct glyph_row *row
12132                     = MATRIX_ROW (w->current_matrix, this_line_vpos + 1);
12133                   int delta, delta_bytes;
12134 
12135                   /* We used to distinguish between two cases here,
12136                      conditioned by Z - CHARPOS (tlendpos) == ZV, for
12137                      when the line ends in a newline or the end of the
12138                      buffer's accessible portion.  But both cases did
12139                      the same, so they were collapsed.  */
12140                   delta = (Z
12141                            - CHARPOS (tlendpos)
12142                            - MATRIX_ROW_START_CHARPOS (row));
12143                   delta_bytes = (Z_BYTE
12144                                  - BYTEPOS (tlendpos)
12145                                  - MATRIX_ROW_START_BYTEPOS (row));
12146 
12147                   increment_matrix_positions (w->current_matrix,
12148                                               this_line_vpos + 1,
12149                                               w->current_matrix->nrows,
12150                                               delta, delta_bytes);
12151                 }
12152 
12153               /* If this row displays text now but previously didn't,
12154                  or vice versa, w->window_end_vpos may have to be
12155                  adjusted.  */
12156               if ((it.glyph_row - 1)->displays_text_p)
12157                 {
12158                   if (XFASTINT (w->window_end_vpos) < this_line_vpos)
12159                     XSETINT (w->window_end_vpos, this_line_vpos);
12160                 }
12161               else if (XFASTINT (w->window_end_vpos) == this_line_vpos
12162                        && this_line_vpos > 0)
12163                 XSETINT (w->window_end_vpos, this_line_vpos - 1);
12164               w->window_end_valid = Qnil;
12165 
12166               /* Update hint: No need to try to scroll in update_window.  */
12167               w->desired_matrix->no_scrolling_p = 1;
12168 
12169 #if GLYPH_DEBUG
12170               *w->desired_matrix->method = 0;
12171               debug_method_add (w, "optimization 1");
12172 #endif
12173 #ifdef HAVE_WINDOW_SYSTEM
12174               update_window_fringes (w, 0);
12175 #endif
12176               goto update;
12177             }
12178           else
12179             goto cancel;
12180         }
12181       else if (/* Cursor position hasn't changed.  */
12182                PT == XFASTINT (w->last_point)
12183                /* Make sure the cursor was last displayed
12184                   in this window.  Otherwise we have to reposition it.  */
12185                && 0 <= w->cursor.vpos
12186                && WINDOW_TOTAL_LINES (w) > w->cursor.vpos)
12187         {
12188           if (!must_finish)
12189             {
12190               do_pending_window_change (1);
12191 
12192               /* We used to always goto end_of_redisplay here, but this
12193                  isn't enough if we have a blinking cursor.  */
12194               if (w->cursor_off_p == w->last_cursor_off_p)
12195                 goto end_of_redisplay;
12196             }
12197           goto update;
12198         }
12199       /* If highlighting the region, or if the cursor is in the echo area,
12200          then we can't just move the cursor.  */
12201       else if (! (!NILP (Vtransient_mark_mode)
12202                   && !NILP (current_buffer->mark_active))
12203                && (EQ (selected_window, current_buffer->last_selected_window)
12204                    || highlight_nonselected_windows)
12205                && NILP (w->region_showing)
12206                && NILP (Vshow_trailing_whitespace)
12207                && !cursor_in_echo_area)
12208         {
12209           struct it it;
12210           struct glyph_row *row;
12211 
12212           /* Skip from tlbufpos to PT and see where it is.  Note that
12213              PT may be in invisible text.  If so, we will end at the
12214              next visible position.  */
12215           init_iterator (&it, w, CHARPOS (tlbufpos), BYTEPOS (tlbufpos),
12216                          NULL, DEFAULT_FACE_ID);
12217           it.current_x = this_line_start_x;
12218           it.current_y = this_line_y;
12219           it.vpos = this_line_vpos;
12220 
12221           /* The call to move_it_to stops in front of PT, but
12222              moves over before-strings.  */
12223           move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
12224 
12225           if (it.vpos == this_line_vpos
12226               && (row = MATRIX_ROW (w->current_matrix, this_line_vpos),
12227                   row->enabled_p))
12228             {
12229               xassert (this_line_vpos == it.vpos);
12230               xassert (this_line_y == it.current_y);
12231               set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
12232 #if GLYPH_DEBUG
12233               *w->desired_matrix->method = 0;
12234               debug_method_add (w, "optimization 3");
12235 #endif
12236               goto update;
12237             }
12238           else
12239             goto cancel;
12240         }
12241 
12242     cancel:
12243       /* Text changed drastically or point moved off of line.  */
12244       SET_MATRIX_ROW_ENABLED_P (w->desired_matrix, this_line_vpos, 0);
12245     }
12246 
12247   CHARPOS (this_line_start_pos) = 0;
12248   consider_all_windows_p |= buffer_shared > 1;
12249   ++clear_face_cache_count;
12250 #ifdef HAVE_WINDOW_SYSTEM
12251   ++clear_image_cache_count;
12252 #endif
12253 
12254   /* Build desired matrices, and update the display.  If
12255      consider_all_windows_p is non-zero, do it for all windows on all
12256      frames.  Otherwise do it for selected_window, only.  */
12257 
12258   if (consider_all_windows_p)
12259     {
12260       Lisp_Object tail, frame;
12261 
12262       FOR_EACH_FRAME (tail, frame)
12263         XFRAME (frame)->updated_p = 0;
12264 
12265       /* Recompute # windows showing selected buffer.  This will be
12266          incremented each time such a window is displayed.  */
12267       buffer_shared = 0;
12268 
12269       FOR_EACH_FRAME (tail, frame)
12270         {
12271           struct frame *f = XFRAME (frame);
12272 
12273           if (FRAME_WINDOW_P (f) || FRAME_TERMCAP_P (f) || f == sf)
12274             {
12275               if (! EQ (frame, selected_frame))
12276                 /* Select the frame, for the sake of frame-local
12277                    variables.  */
12278                 select_frame_for_redisplay (frame);
12279 
12280               /* Mark all the scroll bars to be removed; we'll redeem
12281                  the ones we want when we redisplay their windows.  */
12282               if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
12283                 FRAME_TERMINAL (f)->condemn_scroll_bars_hook (f);
12284 
12285               if (FRAME_VISIBLE_P (f) && !FRAME_OBSCURED_P (f))
12286                 redisplay_windows (FRAME_ROOT_WINDOW (f));
12287 
12288               /* The X error handler may have deleted that frame.  */
12289               if (!FRAME_LIVE_P (f))
12290                 continue;
12291 
12292               /* Any scroll bars which redisplay_windows should have
12293                  nuked should now go away.  */
12294               if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
12295                 FRAME_TERMINAL (f)->judge_scroll_bars_hook (f);
12296 
12297               /* If fonts changed, display again.  */
12298               /* ??? rms: I suspect it is a mistake to jump all the way
12299                  back to retry here.  It should just retry this frame.  */
12300               if (fonts_changed_p)
12301                 goto retry;
12302 
12303               if (FRAME_VISIBLE_P (f) && !FRAME_OBSCURED_P (f))
12304                 {
12305                   /* See if we have to hscroll.  */
12306                   if (!f->already_hscrolled_p)
12307                     {
12308                       f->already_hscrolled_p = 1;
12309                       if (hscroll_windows (f->root_window))
12310                         goto retry;
12311                     }
12312 
12313                   /* Prevent various kinds of signals during display
12314                      update.  stdio is not robust about handling
12315                      signals, which can cause an apparent I/O
12316                      error.  */
12317                   if (interrupt_input)
12318                     unrequest_sigio ();
12319                   STOP_POLLING;
12320 
12321                   /* Update the display.  */
12322                   set_window_update_flags (XWINDOW (f->root_window), 1);
12323                   pause |= update_frame (f, 0, 0);
12324                   f->updated_p = 1;
12325                 }
12326             }
12327         }
12328 
12329       if (!EQ (old_frame, selected_frame)
12330           && FRAME_LIVE_P (XFRAME (old_frame)))
12331         /* We played a bit fast-and-loose above and allowed selected_frame
12332            and selected_window to be temporarily out-of-sync but let's make
12333            sure this stays contained.  */
12334         select_frame_for_redisplay (old_frame);
12335       eassert (EQ (XFRAME (selected_frame)->selected_window, selected_window));
12336 
12337       if (!pause)
12338         {
12339           /* Do the mark_window_display_accurate after all windows have
12340              been redisplayed because this call resets flags in buffers
12341              which are needed for proper redisplay.  */
12342           FOR_EACH_FRAME (tail, frame)
12343             {
12344               struct frame *f = XFRAME (frame);
12345               if (f->updated_p)
12346                 {
12347                   mark_window_display_accurate (f->root_window, 1);
12348                   if (FRAME_TERMINAL (f)->frame_up_to_date_hook)
12349                     FRAME_TERMINAL (f)->frame_up_to_date_hook (f);
12350                 }
12351             }
12352         }
12353     }
12354   else if (FRAME_VISIBLE_P (sf) && !FRAME_OBSCURED_P (sf))
12355     {
12356       Lisp_Object mini_window;
12357       struct frame *mini_frame;
12358 
12359       displayed_buffer = XBUFFER (XWINDOW (selected_window)->buffer);
12360       /* Use list_of_error, not Qerror, so that
12361          we catch only errors and don't run the debugger.  */
12362       internal_condition_case_1 (redisplay_window_1, selected_window,
12363                                  list_of_error,
12364                                  redisplay_window_error);
12365 
12366       /* Compare desired and current matrices, perform output.  */
12367 
12368     update:
12369       /* If fonts changed, display again.  */
12370       if (fonts_changed_p)
12371         goto retry;
12372 
12373       /* Prevent various kinds of signals during display update.
12374          stdio is not robust about handling signals,
12375          which can cause an apparent I/O error.  */
12376       if (interrupt_input)
12377         unrequest_sigio ();
12378       STOP_POLLING;
12379 
12380       if (FRAME_VISIBLE_P (sf) && !FRAME_OBSCURED_P (sf))
12381         {
12382           if (hscroll_windows (selected_window))
12383             goto retry;
12384 
12385           XWINDOW (selected_window)->must_be_updated_p = 1;
12386           pause = update_frame (sf, 0, 0);
12387         }
12388 
12389       /* We may have called echo_area_display at the top of this
12390          function.  If the echo area is on another frame, that may
12391          have put text on a frame other than the selected one, so the
12392          above call to update_frame would not have caught it.  Catch
12393          it here.  */
12394       mini_window = FRAME_MINIBUF_WINDOW (sf);
12395       mini_frame = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
12396 
12397       if (mini_frame != sf && FRAME_WINDOW_P (mini_frame))
12398         {
12399           XWINDOW (mini_window)->must_be_updated_p = 1;
12400           pause |= update_frame (mini_frame, 0, 0);
12401           if (!pause && hscroll_windows (mini_window))
12402             goto retry;
12403         }
12404     }
12405 
12406   /* If display was paused because of pending input, make sure we do a
12407      thorough update the next time.  */
12408   if (pause)
12409     {
12410       /* Prevent the optimization at the beginning of
12411          redisplay_internal that tries a single-line update of the
12412          line containing the cursor in the selected window.  */
12413       CHARPOS (this_line_start_pos) = 0;
12414 
12415       /* Let the overlay arrow be updated the next time.  */
12416       update_overlay_arrows (0);
12417 
12418       /* If we pause after scrolling, some rows in the current
12419          matrices of some windows are not valid.  */
12420       if (!WINDOW_FULL_WIDTH_P (w)
12421           && !FRAME_WINDOW_P (XFRAME (w->frame)))
12422         update_mode_lines = 1;
12423     }
12424   else
12425     {
12426       if (!consider_all_windows_p)
12427         {
12428           /* This has already been done above if
12429              consider_all_windows_p is set.  */
12430           mark_window_display_accurate_1 (w, 1);
12431 
12432           /* Say overlay arrows are up to date.  */
12433           update_overlay_arrows (1);
12434 
12435           if (FRAME_TERMINAL (sf)->frame_up_to_date_hook != 0)
12436             FRAME_TERMINAL (sf)->frame_up_to_date_hook (sf);
12437         }
12438 
12439       update_mode_lines = 0;
12440       windows_or_buffers_changed = 0;
12441       cursor_type_changed = 0;
12442     }
12443 
12444   /* Start SIGIO interrupts coming again.  Having them off during the
12445      code above makes it less likely one will discard output, but not
12446      impossible, since there might be stuff in the system buffer here.
12447      But it is much hairier to try to do anything about that.  */
12448   if (interrupt_input)
12449     request_sigio ();
12450   RESUME_POLLING;
12451 
12452   /* If a frame has become visible which was not before, redisplay
12453      again, so that we display it.  Expose events for such a frame
12454      (which it gets when becoming visible) don't call the parts of
12455      redisplay constructing glyphs, so simply exposing a frame won't
12456      display anything in this case.  So, we have to display these
12457      frames here explicitly.  */
12458   if (!pause)
12459     {
12460       Lisp_Object tail, frame;
12461       int new_count = 0;
12462 
12463       FOR_EACH_FRAME (tail, frame)
12464         {
12465           int this_is_visible = 0;
12466 
12467           if (XFRAME (frame)->visible)
12468             this_is_visible = 1;
12469           FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
12470           if (XFRAME (frame)->visible)
12471             this_is_visible = 1;
12472 
12473           if (this_is_visible)
12474             new_count++;
12475         }
12476 
12477       if (new_count != number_of_visible_frames)
12478         windows_or_buffers_changed++;
12479     }
12480 
12481   /* Change frame size now if a change is pending.  */
12482   do_pending_window_change (1);
12483 
12484   /* If we just did a pending size change, or have additional
12485      visible frames, redisplay again.  */
12486   if (windows_or_buffers_changed && !pause)
12487     goto retry;
12488 
12489   /* Clear the face and image caches.
12490 
12491      We used to do this only if consider_all_windows_p.  But the cache
12492      needs to be cleared if a timer creates images in the current
12493      buffer (e.g. the test case in Bug#6230).  */
12494 
12495   if (clear_face_cache_count > CLEAR_FACE_CACHE_COUNT)
12496     {
12497       clear_face_cache (0);
12498       clear_face_cache_count = 0;
12499     }
12500 
12501 #ifdef HAVE_WINDOW_SYSTEM
12502   if (clear_image_cache_count > CLEAR_IMAGE_CACHE_COUNT)
12503     {
12504       clear_image_caches (Qnil);
12505       clear_image_cache_count = 0;
12506     }
12507 #endif /* HAVE_WINDOW_SYSTEM */
12508 
12509  end_of_redisplay:
12510   unbind_to (count, Qnil);
12511   RESUME_POLLING;
12512 }
12513 
12514 
12515 /* Redisplay, but leave alone any recent echo area message unless
12516    another message has been requested in its place.
12517 
12518    This is useful in situations where you need to redisplay but no
12519    user action has occurred, making it inappropriate for the message
12520    area to be cleared.  See tracking_off and
12521    wait_reading_process_output for examples of these situations.
12522 
12523    FROM_WHERE is an integer saying from where this function was
12524    called.  This is useful for debugging.  */
12525 
12526 void
12527 redisplay_preserve_echo_area (from_where)
12528      int from_where;
12529 {
12530   TRACE ((stderr, "redisplay_preserve_echo_area (%d)\n", from_where));
12531 
12532   if (!NILP (echo_area_buffer[1]))
12533     {
12534       /* We have a previously displayed message, but no current
12535          message.  Redisplay the previous message.  */
12536       display_last_displayed_message_p = 1;
12537       redisplay_internal (1);
12538       display_last_displayed_message_p = 0;
12539     }
12540   else
12541     redisplay_internal (1);
12542 
12543   if (FRAME_RIF (SELECTED_FRAME ()) != NULL
12544       && FRAME_RIF (SELECTED_FRAME ())->flush_display_optional)
12545     FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (NULL);
12546 }
12547 
12548 
12549 /* Function registered with record_unwind_protect in
12550    redisplay_internal.  Reset redisplaying_p to the value it had
12551    before redisplay_internal was called, and clear
12552    prevent_freeing_realized_faces_p.  It also selects the previously
12553    selected frame, unless it has been deleted (by an X connection
12554    failure during redisplay, for example).  */
12555 
12556 static Lisp_Object
12557 unwind_redisplay (val)
12558      Lisp_Object val;
12559 {
12560   Lisp_Object old_redisplaying_p, old_frame;
12561 
12562   old_redisplaying_p = XCAR (val);
12563   redisplaying_p = XFASTINT (old_redisplaying_p);
12564   old_frame = XCDR (val);
12565   if (! EQ (old_frame, selected_frame)
12566       && FRAME_LIVE_P (XFRAME (old_frame)))
12567     select_frame_for_redisplay (old_frame);
12568   return Qnil;
12569 }
12570 
12571 
12572 /* Mark the display of window W as accurate or inaccurate.  If
12573    ACCURATE_P is non-zero mark display of W as accurate.  If
12574    ACCURATE_P is zero, arrange for W to be redisplayed the next time
12575    redisplay_internal is called.  */
12576 
12577 static void
12578 mark_window_display_accurate_1 (w, accurate_p)
12579      struct window *w;
12580      int accurate_p;
12581 {
12582   if (BUFFERP (w->buffer))
12583     {
12584       struct buffer *b = XBUFFER (w->buffer);
12585 
12586       w->last_modified
12587         = make_number (accurate_p ? BUF_MODIFF (b) : 0);
12588       w->last_overlay_modified
12589         = make_number (accurate_p ? BUF_OVERLAY_MODIFF (b) : 0);
12590       w->last_had_star
12591         = BUF_MODIFF (b) > BUF_SAVE_MODIFF (b) ? Qt : Qnil;
12592 
12593       if (accurate_p)
12594         {
12595           b->clip_changed = 0;
12596           b->prevent_redisplay_optimizations_p = 0;
12597 
12598           BUF_UNCHANGED_MODIFIED (b) = BUF_MODIFF (b);
12599           BUF_OVERLAY_UNCHANGED_MODIFIED (b) = BUF_OVERLAY_MODIFF (b);
12600           BUF_BEG_UNCHANGED (b) = BUF_GPT (b) - BUF_BEG (b);
12601           BUF_END_UNCHANGED (b) = BUF_Z (b) - BUF_GPT (b);
12602 
12603           w->current_matrix->buffer = b;
12604           w->current_matrix->begv = BUF_BEGV (b);
12605           w->current_matrix->zv = BUF_ZV (b);
12606 
12607           w->last_cursor = w->cursor;
12608           w->last_cursor_off_p = w->cursor_off_p;
12609 
12610           if (w == XWINDOW (selected_window))
12611             w->last_point = make_number (BUF_PT (b));
12612           else
12613             w->last_point = make_number (XMARKER (w->pointm)->charpos);
12614         }
12615     }
12616 
12617   if (accurate_p)
12618     {
12619       w->window_end_valid = w->buffer;
12620       w->update_mode_line = Qnil;
12621     }
12622 }
12623 
12624 
12625 /* Mark the display of windows in the window tree rooted at WINDOW as
12626    accurate or inaccurate.  If ACCURATE_P is non-zero mark display of
12627    windows as accurate.  If ACCURATE_P is zero, arrange for windows to
12628    be redisplayed the next time redisplay_internal is called.  */
12629 
12630 void
12631 mark_window_display_accurate (window, accurate_p)
12632      Lisp_Object window;
12633      int accurate_p;
12634 {
12635   struct window *w;
12636 
12637   for (; !NILP (window); window = w->next)
12638     {
12639       w = XWINDOW (window);
12640       mark_window_display_accurate_1 (w, accurate_p);
12641 
12642       if (!NILP (w->vchild))
12643         mark_window_display_accurate (w->vchild, accurate_p);
12644       if (!NILP (w->hchild))
12645         mark_window_display_accurate (w->hchild, accurate_p);
12646     }
12647 
12648   if (accurate_p)
12649     {
12650       update_overlay_arrows (1);
12651     }
12652   else
12653     {
12654       /* Force a thorough redisplay the next time by setting
12655          last_arrow_position and last_arrow_string to t, which is
12656          unequal to any useful value of Voverlay_arrow_...  */
12657       update_overlay_arrows (-1);
12658     }
12659 }
12660 
12661 
12662 /* Return value in display table DP (Lisp_Char_Table *) for character
12663    C.  Since a display table doesn't have any parent, we don't have to
12664    follow parent.  Do not call this function directly but use the
12665    macro DISP_CHAR_VECTOR.  */
12666 
12667 Lisp_Object
12668 disp_char_vector (dp, c)
12669      struct Lisp_Char_Table *dp;
12670      int c;
12671 {
12672   Lisp_Object val;
12673 
12674   if (ASCII_CHAR_P (c))
12675     {
12676       val = dp->ascii;
12677       if (SUB_CHAR_TABLE_P (val))
12678         val = XSUB_CHAR_TABLE (val)->contents[c];
12679     }
12680   else
12681     {
12682       Lisp_Object table;
12683 
12684       XSETCHAR_TABLE (table, dp);
12685       val = char_table_ref (table, c);
12686     }
12687   if (NILP (val))
12688     val = dp->defalt;
12689   return val;
12690 }
12691 
12692 
12693 
12694 /***********************************************************************
12695                            Window Redisplay
12696  ***********************************************************************/
12697 
12698 /* Redisplay all leaf windows in the window tree rooted at WINDOW.  */
12699 
12700 static void
12701 redisplay_windows (window)
12702      Lisp_Object window;
12703 {
12704   while (!NILP (window))
12705     {
12706       struct window *w = XWINDOW (window);
12707 
12708       if (!NILP (w->hchild))
12709         redisplay_windows (w->hchild);
12710       else if (!NILP (w->vchild))
12711         redisplay_windows (w->vchild);
12712       else if (!NILP (w->buffer))
12713         {
12714           displayed_buffer = XBUFFER (w->buffer);
12715           /* Use list_of_error, not Qerror, so that
12716              we catch only errors and don't run the debugger.  */
12717           internal_condition_case_1 (redisplay_window_0, window,
12718                                      list_of_error,
12719                                      redisplay_window_error);
12720         }
12721 
12722       window = w->next;
12723     }
12724 }
12725 
12726 static Lisp_Object
12727 redisplay_window_error ()
12728 {
12729   displayed_buffer->display_error_modiff = BUF_MODIFF (displayed_buffer);
12730   return Qnil;
12731 }
12732 
12733 static Lisp_Object
12734 redisplay_window_0 (window)
12735      Lisp_Object window;
12736 {
12737   if (displayed_buffer->display_error_modiff < BUF_MODIFF (displayed_buffer))
12738     redisplay_window (window, 0);
12739   return Qnil;
12740 }
12741 
12742 static Lisp_Object
12743 redisplay_window_1 (window)
12744      Lisp_Object window;
12745 {
12746   if (displayed_buffer->display_error_modiff < BUF_MODIFF (displayed_buffer))
12747     redisplay_window (window, 1);
12748   return Qnil;
12749 }
12750 
12751 
12752 /* Increment GLYPH until it reaches END or CONDITION fails while
12753    adding (GLYPH)->pixel_width to X. */
12754 
12755 #define SKIP_GLYPHS(glyph, end, x, condition)   \
12756   do                                            \
12757     {                                           \
12758       (x) += (glyph)->pixel_width;              \
12759       ++(glyph);                                \
12760     }                                           \
12761   while ((glyph) < (end) && (condition))
12762 
12763 
12764 /* Set cursor position of W.  PT is assumed to be displayed in ROW.
12765    DELTA and DELTA_BYTES are the numbers of characters and bytes by
12766    which positions recorded in ROW differ from current buffer
12767    positions.
12768 
12769    Return 0 if cursor is not on this row, 1 otherwise.  */
12770 
12771 int
12772 set_cursor_from_row (w, row, matrix, delta, delta_bytes, dy, dvpos)
12773      struct window *w;
12774      struct glyph_row *row;
12775      struct glyph_matrix *matrix;
12776      int delta, delta_bytes, dy, dvpos;
12777 {
12778   struct glyph *glyph = row->glyphs[TEXT_AREA];
12779   struct glyph *end = glyph + row->used[TEXT_AREA];
12780   struct glyph *cursor = NULL;
12781   /* The last known character position in row.  */
12782   int last_pos = MATRIX_ROW_START_CHARPOS (row) + delta;
12783   int x = row->x;
12784   EMACS_INT pt_old = PT - delta;
12785   EMACS_INT pos_before = MATRIX_ROW_START_CHARPOS (row) + delta;
12786   EMACS_INT pos_after = MATRIX_ROW_END_CHARPOS (row) + delta;
12787   struct glyph *glyph_before = glyph - 1, *glyph_after = end;
12788   /* A glyph beyond the edge of TEXT_AREA which we should never
12789      touch.  */
12790   struct glyph *glyphs_end = end;
12791   /* Non-zero means we've found a match for cursor position, but that
12792      glyph has the avoid_cursor_p flag set.  */
12793   int match_with_avoid_cursor = 0;
12794   /* Non-zero means we've seen at least one glyph that came from a
12795      display string.  */
12796   int string_seen = 0;
12797   /* Largest buffer position seen so far during scan of glyph row.  */
12798   EMACS_INT bpos_max = last_pos;
12799   /* Last buffer position covered by an overlay string with an integer
12800      `cursor' property.  */
12801   EMACS_INT bpos_covered = 0;
12802 
12803   /* Skip over glyphs not having an object at the start and the end of
12804      the row.  These are special glyphs like truncation marks on
12805      terminal frames.  */
12806   if (row->displays_text_p)
12807     {
12808       if (!row->reversed_p)
12809         {
12810           while (glyph < end
12811                  && INTEGERP (glyph->object)
12812                  && glyph->charpos < 0)
12813             {
12814               x += glyph->pixel_width;
12815               ++glyph;
12816             }
12817           while (end > glyph
12818                  && INTEGERP ((end - 1)->object)
12819                  /* CHARPOS is zero for blanks and stretch glyphs
12820                     inserted by extend_face_to_end_of_line.  */
12821                  && (end - 1)->charpos <= 0)
12822             --end;
12823           glyph_before = glyph - 1;
12824           glyph_after = end;
12825         }
12826       else
12827         {
12828           struct glyph *g;
12829 
12830           /* If the glyph row is reversed, we need to process it from back
12831              to front, so swap the edge pointers.  */
12832           glyphs_end = end = glyph - 1;
12833           glyph += row->used[TEXT_AREA] - 1;
12834 
12835           while (glyph > end + 1
12836                  && INTEGERP (glyph->object)
12837                  && glyph->charpos < 0)
12838             {
12839               --glyph;
12840               x -= glyph->pixel_width;
12841             }
12842           if (INTEGERP (glyph->object) && glyph->charpos < 0)
12843             --glyph;
12844           /* By default, in reversed rows we put the cursor on the
12845              rightmost (first in the reading order) glyph.  */
12846           for (g = end + 1; g < glyph; g++)
12847             x += g->pixel_width;
12848           while (end < glyph
12849                  && INTEGERP ((end + 1)->object)
12850                  && (end + 1)->charpos <= 0)
12851             ++end;
12852           glyph_before = glyph + 1;
12853           glyph_after = end;
12854         }
12855     }
12856   else if (row->reversed_p)
12857     {
12858       /* In R2L rows that don't display text, put the cursor on the
12859          rightmost glyph.  Case in point: an empty last line that is
12860          part of an R2L paragraph.  */
12861       cursor = end - 1;
12862       /* Avoid placing the cursor on the last glyph of the row, where
12863          on terminal frames we hold the vertical border between
12864          adjacent windows.  */
12865       if (!FRAME_WINDOW_P (WINDOW_XFRAME (w))
12866           && !WINDOW_RIGHTMOST_P (w)
12867           && cursor == row->glyphs[LAST_AREA] - 1)
12868         cursor--;
12869       x = -1;   /* will be computed below, at label compute_x */
12870     }
12871 
12872   /* Step 1: Try to find the glyph whose character position
12873      corresponds to point.  If that's not possible, find 2 glyphs
12874      whose character positions are the closest to point, one before
12875      point, the other after it.  */
12876   if (!row->reversed_p)
12877     while (/* not marched to end of glyph row */
12878            glyph < end
12879            /* glyph was not inserted by redisplay for internal purposes */
12880            && !INTEGERP (glyph->object))
12881       {
12882         if (BUFFERP (glyph->object))
12883           {
12884             EMACS_INT dpos = glyph->charpos - pt_old;
12885 
12886             if (glyph->charpos > bpos_max)
12887               bpos_max = glyph->charpos;
12888             if (!glyph->avoid_cursor_p)
12889               {
12890                 /* If we hit point, we've found the glyph on which to
12891                    display the cursor.  */
12892                 if (dpos == 0)
12893                   {
12894                     match_with_avoid_cursor = 0;
12895                     break;
12896                   }
12897                 /* See if we've found a better approximation to
12898                    POS_BEFORE or to POS_AFTER.  Note that we want the
12899                    first (leftmost) glyph of all those that are the
12900                    closest from below, and the last (rightmost) of all
12901                    those from above.  */
12902                 if (0 > dpos && dpos > pos_before - pt_old)
12903                   {
12904                     pos_before = glyph->charpos;
12905                     glyph_before = glyph;
12906                   }
12907                 else if (0 < dpos && dpos <= pos_after - pt_old)
12908                   {
12909                     pos_after = glyph->charpos;
12910                     glyph_after = glyph;
12911                   }
12912               }
12913             else if (dpos == 0)
12914               match_with_avoid_cursor = 1;
12915           }
12916         else if (STRINGP (glyph->object))
12917           {
12918             Lisp_Object chprop;
12919             int glyph_pos = glyph->charpos;
12920 
12921             chprop = Fget_char_property (make_number (glyph_pos), Qcursor,
12922                                          glyph->object);
12923             if (INTEGERP (chprop))
12924               {
12925                 bpos_covered = bpos_max + XINT (chprop);
12926                 /* If the `cursor' property covers buffer positions up
12927                    to and including point, we should display cursor on
12928                    this glyph.  Note that overlays and text properties
12929                    with string values stop bidi reordering, so every
12930                    buffer position to the left of the string is always
12931                    smaller than any position to the right of the
12932                    string.  Therefore, if a `cursor' property on one
12933                    of the string's characters has an integer value, we
12934                    will break out of the loop below _before_ we get to
12935                    the position match above.  IOW, integer values of
12936                    the `cursor' property override the "exact match for
12937                    point" strategy of positioning the cursor.  */
12938                 /* Implementation note: bpos_max == pt_old when, e.g.,
12939                    we are in an empty line, where bpos_max is set to
12940                    MATRIX_ROW_START_CHARPOS, see above.  */
12941                 if (bpos_max <= pt_old && bpos_covered >= pt_old)
12942                   {
12943                     cursor = glyph;
12944                     break;
12945                   }
12946               }
12947 
12948             string_seen = 1;
12949           }
12950         x += glyph->pixel_width;
12951         ++glyph;
12952       }
12953   else if (glyph > end) /* row is reversed */
12954     while (!INTEGERP (glyph->object))
12955       {
12956         if (BUFFERP (glyph->object))
12957           {
12958             EMACS_INT dpos = glyph->charpos - pt_old;
12959 
12960             if (glyph->charpos > bpos_max)
12961               bpos_max = glyph->charpos;
12962             if (!glyph->avoid_cursor_p)
12963               {
12964                 if (dpos == 0)
12965                   {
12966                     match_with_avoid_cursor = 0;
12967                     break;
12968                   }
12969                 if (0 > dpos && dpos > pos_before - pt_old)
12970                   {
12971                     pos_before = glyph->charpos;
12972                     glyph_before = glyph;
12973                   }
12974                 else if (0 < dpos && dpos <= pos_after - pt_old)
12975                   {
12976                     pos_after = glyph->charpos;
12977                     glyph_after = glyph;
12978                   }
12979               }
12980             else if (dpos == 0)
12981               match_with_avoid_cursor = 1;
12982           }
12983         else if (STRINGP (glyph->object))
12984           {
12985             Lisp_Object chprop;
12986             int glyph_pos = glyph->charpos;
12987 
12988             chprop = Fget_char_property (make_number (glyph_pos), Qcursor,
12989                                          glyph->object);
12990             if (INTEGERP (chprop))
12991               {
12992                 bpos_covered = bpos_max + XINT (chprop);
12993                 /* If the `cursor' property covers buffer positions up
12994                    to and including point, we should display cursor on
12995                    this glyph.  */
12996                 if (bpos_max <= pt_old && bpos_covered >= pt_old)
12997                   {
12998                     cursor = glyph;
12999                     break;
13000                   }
13001               }
13002             string_seen = 1;
13003           }
13004         --glyph;
13005         if (glyph == glyphs_end) /* don't dereference outside TEXT_AREA */
13006           {
13007             x--;                /* can't use any pixel_width */
13008             break;
13009           }
13010         x -= glyph->pixel_width;
13011     }
13012 
13013   /* Step 2: If we didn't find an exact match for point, we need to
13014      look for a proper place to put the cursor among glyphs between
13015      GLYPH_BEFORE and GLYPH_AFTER.  */
13016   if (!((row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end)
13017         && BUFFERP (glyph->object) && glyph->charpos == pt_old)
13018       && bpos_covered < pt_old)
13019     {
13020       if (row->ends_in_ellipsis_p && pos_after == last_pos)
13021         {
13022           EMACS_INT ellipsis_pos;
13023 
13024           /* Scan back over the ellipsis glyphs.  */
13025           if (!row->reversed_p)
13026             {
13027               ellipsis_pos = (glyph - 1)->charpos;
13028               while (glyph > row->glyphs[TEXT_AREA]
13029                      && (glyph - 1)->charpos == ellipsis_pos)
13030                 glyph--, x -= glyph->pixel_width;
13031               /* That loop always goes one position too far, including
13032                  the glyph before the ellipsis.  So scan forward over
13033                  that one.  */
13034               x += glyph->pixel_width;
13035               glyph++;
13036             }
13037           else  /* row is reversed */
13038             {
13039               ellipsis_pos = (glyph + 1)->charpos;
13040               while (glyph < row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1
13041                      && (glyph + 1)->charpos == ellipsis_pos)
13042                 glyph++, x += glyph->pixel_width;
13043               x -= glyph->pixel_width;
13044               glyph--;
13045             }
13046         }
13047       else if (match_with_avoid_cursor
13048                /* zero-width characters produce no glyphs */
13049                || ((row->reversed_p
13050                     ? glyph_after > glyphs_end
13051                     : glyph_after < glyphs_end)
13052                    && eabs (glyph_after - glyph_before) == 1))
13053         {
13054           cursor = glyph_after;
13055           x = -1;
13056         }
13057       else if (string_seen)
13058         {
13059           int incr = row->reversed_p ? -1 : +1;
13060 
13061           /* Need to find the glyph that came out of a string which is
13062              present at point.  That glyph is somewhere between
13063              GLYPH_BEFORE and GLYPH_AFTER, and it came from a string
13064              positioned between POS_BEFORE and POS_AFTER in the
13065              buffer.  */
13066           struct glyph *stop = glyph_after;
13067           EMACS_INT pos = pos_before;
13068 
13069           x = -1;
13070           for (glyph = glyph_before + incr;
13071                row->reversed_p ? glyph > stop : glyph < stop; )
13072             {
13073 
13074               /* Any glyphs that come from the buffer are here because
13075                  of bidi reordering.  Skip them, and only pay
13076                  attention to glyphs that came from some string.  */
13077               if (STRINGP (glyph->object))
13078                 {
13079                   Lisp_Object str;
13080                   EMACS_INT tem;
13081 
13082                   str = glyph->object;
13083                   tem = string_buffer_position_lim (w, str, pos, pos_after, 0);
13084                   if (tem == 0  /* from overlay */
13085                       || pos <= tem)
13086                     {
13087                       /* If the string from which this glyph came is
13088                          found in the buffer at point, then we've
13089                          found the glyph we've been looking for.  If
13090                          it comes from an overlay (tem == 0), and it
13091                          has the `cursor' property on one of its
13092                          glyphs, record that glyph as a candidate for
13093                          displaying the cursor.  (As in the
13094                          unidirectional version, we will display the
13095                          cursor on the last candidate we find.)  */
13096                       if (tem == 0 || tem == pt_old)
13097                         {
13098                           /* The glyphs from this string could have
13099                              been reordered.  Find the one with the
13100                              smallest string position.  Or there could
13101                              be a character in the string with the
13102                              `cursor' property, which means display
13103                              cursor on that character's glyph.  */
13104                           int strpos = glyph->charpos;
13105 
13106                           cursor = glyph;
13107                           for (glyph += incr;
13108                                (row->reversed_p ? glyph > stop : glyph < stop)
13109                                  && EQ (glyph->object, str);
13110                                glyph += incr)
13111                             {
13112                               Lisp_Object cprop;
13113                               int gpos = glyph->charpos;
13114 
13115                               cprop = Fget_char_property (make_number (gpos),
13116                                                           Qcursor,
13117                                                           glyph->object);
13118                               if (!NILP (cprop))
13119                                 {
13120                                   cursor = glyph;
13121                                   break;
13122                                 }
13123                               if (glyph->charpos < strpos)
13124                                 {
13125                                   strpos = glyph->charpos;
13126                                   cursor = glyph;
13127                                 }
13128                             }
13129 
13130                           if (tem == pt_old)
13131                             goto compute_x;
13132                         }
13133                       if (tem)
13134                         pos = tem + 1; /* don't find previous instances */
13135                     }
13136                   /* This string is not what we want; skip all of the
13137                      glyphs that came from it.  */
13138                   do
13139                     glyph += incr;
13140                   while ((row->reversed_p ? glyph > stop : glyph < stop)
13141                          && EQ (glyph->object, str));
13142                 }
13143               else
13144                 glyph += incr;
13145             }
13146 
13147           /* If we reached the end of the line, and END was from a string,
13148              the cursor is not on this line.  */
13149           if (cursor == NULL
13150               && (row->reversed_p ? glyph <= end : glyph >= end)
13151               && STRINGP (end->object)
13152               && row->continued_p)
13153             return 0;
13154         }
13155     }
13156 
13157  compute_x:
13158   if (cursor != NULL)
13159     glyph = cursor;
13160   if (x < 0)
13161     {
13162       struct glyph *g;
13163 
13164       /* Need to compute x that corresponds to GLYPH.  */
13165       for (g = row->glyphs[TEXT_AREA], x = row->x; g < glyph; g++)
13166         {
13167           if (g >= row->glyphs[TEXT_AREA] + row->used[TEXT_AREA])
13168             abort ();
13169           x += g->pixel_width;
13170         }
13171     }
13172 
13173   /* ROW could be part of a continued line, which, under bidi
13174      reordering, might have other rows whose start and end charpos
13175      occlude point.  Only set w->cursor if we found a better
13176      approximation to the cursor position than we have from previously
13177      examined candidate rows belonging to the same continued line.  */
13178   if (/* we already have a candidate row */
13179       w->cursor.vpos >= 0
13180       /* that candidate is not the row we are processing */
13181       && MATRIX_ROW (matrix, w->cursor.vpos) != row
13182       /* the row we are processing is part of a continued line */
13183       && (row->continued_p || MATRIX_ROW_CONTINUATION_LINE_P (row))
13184       /* Make sure cursor.vpos specifies a row whose start and end
13185          charpos occlude point.  This is because some callers of this
13186          function leave cursor.vpos at the row where the cursor was
13187          displayed during the last redisplay cycle.  */
13188       && MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos)) <= pt_old
13189       && pt_old < MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos)))
13190     {
13191       struct glyph *g1 =
13192         MATRIX_ROW_GLYPH_START (matrix, w->cursor.vpos) + w->cursor.hpos;
13193 
13194       /* Don't consider glyphs that are outside TEXT_AREA.  */
13195       if (!(row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end))
13196         return 0;
13197       /* Keep the candidate whose buffer position is the closest to
13198          point.  */
13199       if (/* previous candidate is a glyph in TEXT_AREA of that row */
13200           w->cursor.hpos >= 0
13201           && w->cursor.hpos < MATRIX_ROW_USED(matrix, w->cursor.vpos)
13202           && BUFFERP (g1->object)
13203           && (g1->charpos == pt_old /* an exact match always wins */
13204               || (BUFFERP (glyph->object)
13205                   && eabs (g1->charpos - pt_old)
13206                    < eabs (glyph->charpos - pt_old))))
13207         return 0;
13208       /* If this candidate gives an exact match, use that.  */
13209       if (!(BUFFERP (glyph->object) && glyph->charpos == pt_old)
13210           /* Otherwise, keep the candidate that comes from a row
13211              spanning less buffer positions.  This may win when one or
13212              both candidate positions are on glyphs that came from
13213              display strings, for which we cannot compare buffer
13214              positions.  */
13215           && MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
13216              - MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
13217              < MATRIX_ROW_END_CHARPOS (row) - MATRIX_ROW_START_CHARPOS (row))
13218         return 0;
13219     }
13220   w->cursor.hpos = glyph - row->glyphs[TEXT_AREA];
13221   w->cursor.x = x;
13222   w->cursor.vpos = MATRIX_ROW_VPOS (row, matrix) + dvpos;
13223   w->cursor.y = row->y + dy;
13224 
13225   if (w == XWINDOW (selected_window))
13226     {
13227       if (!row->continued_p
13228           && !MATRIX_ROW_CONTINUATION_LINE_P (row)
13229           && row->x == 0)
13230         {
13231           this_line_buffer = XBUFFER (w->buffer);
13232 
13233           CHARPOS (this_line_start_pos)
13234             = MATRIX_ROW_START_CHARPOS (row) + delta;
13235           BYTEPOS (this_line_start_pos)
13236             = MATRIX_ROW_START_BYTEPOS (row) + delta_bytes;
13237 
13238           CHARPOS (this_line_end_pos)
13239             = Z - (MATRIX_ROW_END_CHARPOS (row) + delta);
13240           BYTEPOS (this_line_end_pos)
13241             = Z_BYTE - (MATRIX_ROW_END_BYTEPOS (row) + delta_bytes);
13242 
13243           this_line_y = w->cursor.y;
13244           this_line_pixel_height = row->height;
13245           this_line_vpos = w->cursor.vpos;
13246           this_line_start_x = row->x;
13247         }
13248       else
13249         CHARPOS (this_line_start_pos) = 0;
13250     }
13251 
13252   return 1;
13253 }
13254 
13255 
13256 /* Run window scroll functions, if any, for WINDOW with new window
13257    start STARTP.  Sets the window start of WINDOW to that position.
13258 
13259    We assume that the window's buffer is really current.  */
13260 
13261 static INLINE struct text_pos
13262 run_window_scroll_functions (window, startp)
13263      Lisp_Object window;
13264      struct text_pos startp;
13265 {
13266   struct window *w = XWINDOW (window);
13267   SET_MARKER_FROM_TEXT_POS (w->start, startp);
13268 
13269   if (current_buffer != XBUFFER (w->buffer))
13270     abort ();
13271 
13272   if (!NILP (Vwindow_scroll_functions))
13273     {
13274       run_hook_with_args_2 (Qwindow_scroll_functions, window,
13275                             make_number (CHARPOS (startp)));
13276       SET_TEXT_POS_FROM_MARKER (startp, w->start);
13277       /* In case the hook functions switch buffers.  */
13278       if (current_buffer != XBUFFER (w->buffer))
13279         set_buffer_internal_1 (XBUFFER (w->buffer));
13280     }
13281 
13282   return startp;
13283 }
13284 
13285 
13286 /* Make sure the line containing the cursor is fully visible.
13287    A value of 1 means there is nothing to be done.
13288    (Either the line is fully visible, or it cannot be made so,
13289    or we cannot tell.)
13290 
13291    If FORCE_P is non-zero, return 0 even if partial visible cursor row
13292    is higher than window.
13293 
13294    A value of 0 means the caller should do scrolling
13295    as if point had gone off the screen.  */
13296 
13297 static int
13298 cursor_row_fully_visible_p (w, force_p, current_matrix_p)
13299      struct window *w;
13300      int force_p;
13301      int current_matrix_p;
13302 {
13303   struct glyph_matrix *matrix;
13304   struct glyph_row *row;
13305   int window_height;
13306 
13307   if (!make_cursor_line_fully_visible_p)
13308     return 1;
13309 
13310   /* It's not always possible to find the cursor, e.g, when a window
13311      is full of overlay strings.  Don't do anything in that case.  */
13312   if (w->cursor.vpos < 0)
13313     return 1;
13314 
13315   matrix = current_matrix_p ? w->current_matrix : w->desired_matrix;
13316   row = MATRIX_ROW (matrix, w->cursor.vpos);
13317 
13318   /* If the cursor row is not partially visible, there's nothing to do.  */
13319   if (!MATRIX_ROW_PARTIALLY_VISIBLE_P (w, row))
13320     return 1;
13321 
13322   /* If the row the cursor is in is taller than the window's height,
13323      it's not clear what to do, so do nothing.  */
13324   window_height = window_box_height (w);
13325   if (row->height >= window_height)
13326     {
13327       if (!force_p || MINI_WINDOW_P (w)
13328           || w->vscroll || w->cursor.vpos == 0)
13329         return 1;
13330     }
13331   return 0;
13332 }
13333 
13334 
13335 /* Try scrolling PT into view in window WINDOW.  JUST_THIS_ONE_P
13336    non-zero means only WINDOW is redisplayed in redisplay_internal.
13337    TEMP_SCROLL_STEP has the same meaning as scroll_step, and is used
13338    in redisplay_window to bring a partially visible line into view in
13339    the case that only the cursor has moved.
13340 
13341    LAST_LINE_MISFIT should be nonzero if we're scrolling because the
13342    last screen line's vertical height extends past the end of the screen.
13343 
13344    Value is
13345 
13346    1    if scrolling succeeded
13347 
13348    0    if scrolling didn't find point.
13349 
13350    -1   if new fonts have been loaded so that we must interrupt
13351    redisplay, adjust glyph matrices, and try again.  */
13352 
13353 enum
13354 {
13355   SCROLLING_SUCCESS,
13356   SCROLLING_FAILED,
13357   SCROLLING_NEED_LARGER_MATRICES
13358 };
13359 
13360 static int
13361 try_scrolling (window, just_this_one_p, scroll_conservatively,
13362                scroll_step, temp_scroll_step, last_line_misfit)
13363      Lisp_Object window;
13364      int just_this_one_p;
13365      EMACS_INT scroll_conservatively, scroll_step;
13366      int temp_scroll_step;
13367      int last_line_misfit;
13368 {
13369   struct window *w = XWINDOW (window);
13370   struct frame *f = XFRAME (w->frame);
13371   struct text_pos pos, startp;
13372   struct it it;
13373   int this_scroll_margin, scroll_max, rc, height;
13374   int dy = 0, amount_to_scroll = 0, scroll_down_p = 0;
13375   int extra_scroll_margin_lines = last_line_misfit ? 1 : 0;
13376   Lisp_Object aggressive;
13377   int scroll_limit = INT_MAX / FRAME_LINE_HEIGHT (f);
13378 
13379 #if GLYPH_DEBUG
13380   debug_method_add (w, "try_scrolling");
13381 #endif
13382 
13383   SET_TEXT_POS_FROM_MARKER (startp, w->start);
13384 
13385   /* Compute scroll margin height in pixels.  We scroll when point is
13386      within this distance from the top or bottom of the window.  */
13387   if (scroll_margin > 0)
13388     this_scroll_margin = min (scroll_margin, WINDOW_TOTAL_LINES (w) / 4)
13389       * FRAME_LINE_HEIGHT (f);
13390   else
13391     this_scroll_margin = 0;
13392 
13393   /* Force scroll_conservatively to have a reasonable value, to avoid
13394      overflow while computing how much to scroll.  Note that the user
13395      can supply scroll-conservatively equal to `most-positive-fixnum',
13396      which can be larger than INT_MAX.  */
13397   if (scroll_conservatively > scroll_limit)
13398     {
13399       scroll_conservatively = scroll_limit;
13400       scroll_max = INT_MAX;
13401     }
13402   else if (scroll_step || scroll_conservatively || temp_scroll_step)
13403     /* Compute how much we should try to scroll maximally to bring
13404        point into view.  */
13405     scroll_max = (max (scroll_step,
13406                        max (scroll_conservatively, temp_scroll_step))
13407                   * FRAME_LINE_HEIGHT (f));
13408   else if (NUMBERP (current_buffer->scroll_down_aggressively)
13409            || NUMBERP (current_buffer->scroll_up_aggressively))
13410     /* We're trying to scroll because of aggressive scrolling but no
13411        scroll_step is set.  Choose an arbitrary one.  */
13412     scroll_max = 10 * FRAME_LINE_HEIGHT (f);
13413   else
13414     scroll_max = 0;
13415 
13416  too_near_end:
13417 
13418   /* Decide whether to scroll down.  */
13419   if (PT > CHARPOS (startp))
13420     {
13421       int scroll_margin_y;
13422 
13423       /* Compute the pixel ypos of the scroll margin, then move it to
13424          either that ypos or PT, whichever comes first.  */
13425       start_display (&it, w, startp);
13426       scroll_margin_y = it.last_visible_y - this_scroll_margin
13427         - FRAME_LINE_HEIGHT (f) * extra_scroll_margin_lines;
13428       move_it_to (&it, PT, -1, scroll_margin_y - 1, -1,
13429                   (MOVE_TO_POS | MOVE_TO_Y));
13430 
13431       if (PT > CHARPOS (it.current.pos))
13432         {
13433           int y0 = line_bottom_y (&it);
13434 
13435           /* Compute the distance from the scroll margin to PT
13436              (including the height of the cursor line).  Moving the
13437              iterator unconditionally to PT can be slow if PT is far
13438              away, so stop 10 lines past the window bottom (is there a
13439              way to do the right thing quickly?).  */
13440           move_it_to (&it, PT, -1,
13441                       it.last_visible_y + 10 * FRAME_LINE_HEIGHT (f),
13442                       -1, MOVE_TO_POS | MOVE_TO_Y);
13443           dy = line_bottom_y (&it) - y0;
13444 
13445           if (dy > scroll_max)
13446             return SCROLLING_FAILED;
13447 
13448           scroll_down_p = 1;
13449         }
13450     }
13451 
13452   if (scroll_down_p)
13453     {
13454       /* Point is in or below the bottom scroll margin, so move the
13455          window start down.  If scrolling conservatively, move it just
13456          enough down to make point visible.  If scroll_step is set,
13457          move it down by scroll_step.  */
13458       if (scroll_conservatively)
13459         amount_to_scroll
13460           = min (max (dy, FRAME_LINE_HEIGHT (f)),
13461                  FRAME_LINE_HEIGHT (f) * scroll_conservatively);
13462       else if (scroll_step || temp_scroll_step)
13463         amount_to_scroll = scroll_max;
13464       else
13465         {
13466           aggressive = current_buffer->scroll_up_aggressively;
13467           height = WINDOW_BOX_TEXT_HEIGHT (w);
13468           if (NUMBERP (aggressive))
13469             {
13470               double float_amount = XFLOATINT (aggressive) * height;
13471               amount_to_scroll = float_amount;
13472               if (amount_to_scroll == 0 && float_amount > 0)
13473                 amount_to_scroll = 1;
13474             }
13475         }
13476 
13477       if (amount_to_scroll <= 0)
13478         return SCROLLING_FAILED;
13479 
13480       start_display (&it, w, startp);
13481       move_it_vertically (&it, amount_to_scroll);
13482 
13483       /* If STARTP is unchanged, move it down another screen line.  */
13484       if (CHARPOS (it.current.pos) == CHARPOS (startp))
13485         move_it_by_lines (&it, 1, 1);
13486       startp = it.current.pos;
13487     }
13488   else
13489     {
13490       struct text_pos scroll_margin_pos = startp;
13491 
13492       /* See if point is inside the scroll margin at the top of the
13493          window.  */
13494       if (this_scroll_margin)
13495         {
13496           start_display (&it, w, startp);
13497           move_it_vertically (&it, this_scroll_margin);
13498           scroll_margin_pos = it.current.pos;
13499         }
13500 
13501       if (PT < CHARPOS (scroll_margin_pos))
13502         {
13503           /* Point is in the scroll margin at the top of the window or
13504              above what is displayed in the window.  */
13505           int y0;
13506 
13507           /* Compute the vertical distance from PT to the scroll
13508              margin position.  Give up if distance is greater than
13509              scroll_max.  */
13510           SET_TEXT_POS (pos, PT, PT_BYTE);
13511           start_display (&it, w, pos);
13512           y0 = it.current_y;
13513           move_it_to (&it, CHARPOS (scroll_margin_pos), 0,
13514                       it.last_visible_y, -1,
13515                       MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
13516           dy = it.current_y - y0;
13517           if (dy > scroll_max)
13518             return SCROLLING_FAILED;
13519 
13520           /* Compute new window start.  */
13521           start_display (&it, w, startp);
13522 
13523           if (scroll_conservatively)
13524             amount_to_scroll
13525               = max (dy, FRAME_LINE_HEIGHT (f) * max (scroll_step, temp_scroll_step));
13526           else if (scroll_step || temp_scroll_step)
13527             amount_to_scroll = scroll_max;
13528           else
13529             {
13530               aggressive = current_buffer->scroll_down_aggressively;
13531               height = WINDOW_BOX_TEXT_HEIGHT (w);
13532               if (NUMBERP (aggressive))
13533                 {
13534                   double float_amount = XFLOATINT (aggressive) * height;
13535                   amount_to_scroll = float_amount;
13536                   if (amount_to_scroll == 0 && float_amount > 0)
13537                     amount_to_scroll = 1;
13538                 }
13539             }
13540 
13541           if (amount_to_scroll <= 0)
13542             return SCROLLING_FAILED;
13543 
13544           move_it_vertically_backward (&it, amount_to_scroll);
13545           startp = it.current.pos;
13546         }
13547     }
13548 
13549   /* Run window scroll functions.  */
13550   startp = run_window_scroll_functions (window, startp);
13551 
13552   /* Display the window.  Give up if new fonts are loaded, or if point
13553      doesn't appear.  */
13554   if (!try_window (window, startp, 0))
13555     rc = SCROLLING_NEED_LARGER_MATRICES;
13556   else if (w->cursor.vpos < 0)
13557     {
13558       clear_glyph_matrix (w->desired_matrix);
13559       rc = SCROLLING_FAILED;
13560     }
13561   else
13562     {
13563       /* Maybe forget recorded base line for line number display.  */
13564       if (!just_this_one_p
13565           || current_buffer->clip_changed
13566           || BEG_UNCHANGED < CHARPOS (startp))
13567         w->base_line_number = Qnil;
13568 
13569       /* If cursor ends up on a partially visible line,
13570          treat that as being off the bottom of the screen.  */
13571       if (! cursor_row_fully_visible_p (w, extra_scroll_margin_lines <= 1, 0))
13572         {
13573           clear_glyph_matrix (w->desired_matrix);
13574           ++extra_scroll_margin_lines;
13575           goto too_near_end;
13576         }
13577       rc = SCROLLING_SUCCESS;
13578     }
13579 
13580   return rc;
13581 }
13582 
13583 
13584 /* Compute a suitable window start for window W if display of W starts
13585    on a continuation line.  Value is non-zero if a new window start
13586    was computed.
13587 
13588    The new window start will be computed, based on W's width, starting
13589    from the start of the continued line.  It is the start of the
13590    screen line with the minimum distance from the old start W->start.  */
13591 
13592 static int
13593 compute_window_start_on_continuation_line (w)
13594      struct window *w;
13595 {
13596   struct text_pos pos, start_pos;
13597   int window_start_changed_p = 0;
13598 
13599   SET_TEXT_POS_FROM_MARKER (start_pos, w->start);
13600 
13601   /* If window start is on a continuation line...  Window start may be
13602      < BEGV in case there's invisible text at the start of the
13603      buffer (M-x rmail, for example).  */
13604   if (CHARPOS (start_pos) > BEGV
13605       && FETCH_BYTE (BYTEPOS (start_pos) - 1) != '\n')
13606     {
13607       struct it it;
13608       struct glyph_row *row;
13609 
13610       /* Handle the case that the window start is out of range.  */
13611       if (CHARPOS (start_pos) < BEGV)
13612         SET_TEXT_POS (start_pos, BEGV, BEGV_BYTE);
13613       else if (CHARPOS (start_pos) > ZV)
13614         SET_TEXT_POS (start_pos, ZV, ZV_BYTE);
13615 
13616       /* Find the start of the continued line.  This should be fast
13617          because scan_buffer is fast (newline cache).  */
13618       row = w->desired_matrix->rows + (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0);
13619       init_iterator (&it, w, CHARPOS (start_pos), BYTEPOS (start_pos),
13620                      row, DEFAULT_FACE_ID);
13621       reseat_at_previous_visible_line_start (&it);
13622 
13623       /* If the line start is "too far" away from the window start,
13624          say it takes too much time to compute a new window start.  */
13625       if (CHARPOS (start_pos) - IT_CHARPOS (it)
13626           < WINDOW_TOTAL_LINES (w) * WINDOW_TOTAL_COLS (w))
13627         {
13628           int min_distance, distance;
13629 
13630           /* Move forward by display lines to find the new window
13631              start.  If window width was enlarged, the new start can
13632              be expected to be > the old start.  If window width was
13633              decreased, the new window start will be < the old start.
13634              So, we're looking for the display line start with the
13635              minimum distance from the old window start.  */
13636           pos = it.current.pos;
13637           min_distance = INFINITY;
13638           while ((distance = eabs (CHARPOS (start_pos) - IT_CHARPOS (it))),
13639                  distance < min_distance)
13640             {
13641               min_distance = distance;
13642               pos = it.current.pos;
13643               move_it_by_lines (&it, 1, 0);
13644             }
13645 
13646           /* Set the window start there.  */
13647           SET_MARKER_FROM_TEXT_POS (w->start, pos);
13648           window_start_changed_p = 1;
13649         }
13650     }
13651 
13652   return window_start_changed_p;
13653 }
13654 
13655 
13656 /* Try cursor movement in case text has not changed in window WINDOW,
13657    with window start STARTP.  Value is
13658 
13659    CURSOR_MOVEMENT_SUCCESS if successful
13660 
13661    CURSOR_MOVEMENT_CANNOT_BE_USED if this method cannot be used
13662 
13663    CURSOR_MOVEMENT_MUST_SCROLL if we know we have to scroll the
13664    display.  *SCROLL_STEP is set to 1, under certain circumstances, if
13665    we want to scroll as if scroll-step were set to 1.  See the code.
13666 
13667    CURSOR_MOVEMENT_NEED_LARGER_MATRICES if we need larger matrices, in
13668    which case we have to abort this redisplay, and adjust matrices
13669    first.  */
13670 
13671 enum
13672 {
13673   CURSOR_MOVEMENT_SUCCESS,
13674   CURSOR_MOVEMENT_CANNOT_BE_USED,
13675   CURSOR_MOVEMENT_MUST_SCROLL,
13676   CURSOR_MOVEMENT_NEED_LARGER_MATRICES
13677 };
13678 
13679 static int
13680 try_cursor_movement (window, startp, scroll_step)
13681      Lisp_Object window;
13682      struct text_pos startp;
13683      int *scroll_step;
13684 {
13685   struct window *w = XWINDOW (window);
13686   struct frame *f = XFRAME (w->frame);
13687   int rc = CURSOR_MOVEMENT_CANNOT_BE_USED;
13688 
13689 #if GLYPH_DEBUG
13690   if (inhibit_try_cursor_movement)
13691     return rc;
13692 #endif
13693 
13694   /* Handle case where text has not changed, only point, and it has
13695      not moved off the frame.  */
13696   if (/* Point may be in this window.  */
13697       PT >= CHARPOS (startp)
13698       /* Selective display hasn't changed.  */
13699       && !current_buffer->clip_changed
13700       /* Function force-mode-line-update is used to force a thorough
13701          redisplay.  It sets either windows_or_buffers_changed or
13702          update_mode_lines.  So don't take a shortcut here for these
13703          cases.  */
13704       && !update_mode_lines
13705       && !windows_or_buffers_changed
13706       && !cursor_type_changed
13707       /* Can't use this case if highlighting a region.  When a
13708          region exists, cursor movement has to do more than just
13709          set the cursor.  */
13710       && !(!NILP (Vtransient_mark_mode)
13711            && !NILP (current_buffer->mark_active))
13712       && NILP (w->region_showing)
13713       && NILP (Vshow_trailing_whitespace)
13714       /* Right after splitting windows, last_point may be nil.  */
13715       && INTEGERP (w->last_point)
13716       /* This code is not used for mini-buffer for the sake of the case
13717          of redisplaying to replace an echo area message; since in
13718          that case the mini-buffer contents per se are usually
13719          unchanged.  This code is of no real use in the mini-buffer
13720          since the handling of this_line_start_pos, etc., in redisplay
13721          handles the same cases.  */
13722       && !EQ (window, minibuf_window)
13723       /* When splitting windows or for new windows, it happens that
13724          redisplay is called with a nil window_end_vpos or one being
13725          larger than the window.  This should really be fixed in
13726          window.c.  I don't have this on my list, now, so we do
13727          approximately the same as the old redisplay code.  --gerd.  */
13728       && INTEGERP (w->window_end_vpos)
13729       && XFASTINT (w->window_end_vpos) < w->current_matrix->nrows
13730       && (FRAME_WINDOW_P (f)
13731           || !overlay_arrow_in_current_buffer_p ()))
13732     {
13733       int this_scroll_margin, top_scroll_margin;
13734       struct glyph_row *row = NULL;
13735 
13736 #if GLYPH_DEBUG
13737       debug_method_add (w, "cursor movement");
13738 #endif
13739 
13740       /* Scroll if point within this distance from the top or bottom
13741          of the window.  This is a pixel value.  */
13742       if (scroll_margin > 0)
13743         {
13744           this_scroll_margin = min (scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
13745           this_scroll_margin *= FRAME_LINE_HEIGHT (f);
13746         }
13747       else
13748         this_scroll_margin = 0;
13749 
13750       top_scroll_margin = this_scroll_margin;
13751       if (WINDOW_WANTS_HEADER_LINE_P (w))
13752         top_scroll_margin += CURRENT_HEADER_LINE_HEIGHT (w);
13753 
13754       /* Start with the row the cursor was displayed during the last
13755          not paused redisplay.  Give up if that row is not valid.  */
13756       if (w->last_cursor.vpos < 0
13757           || w->last_cursor.vpos >= w->current_matrix->nrows)
13758         rc = CURSOR_MOVEMENT_MUST_SCROLL;
13759       else
13760         {
13761           row = MATRIX_ROW (w->current_matrix, w->last_cursor.vpos);
13762           if (row->mode_line_p)
13763             ++row;
13764           if (!row->enabled_p)
13765             rc = CURSOR_MOVEMENT_MUST_SCROLL;
13766           /* If rows are bidi-reordered, back up until we find a row
13767              that does not belong to a continuation line.  This is
13768              because we must consider all rows of a continued line as
13769              candidates for cursor positioning, since row start and
13770              end positions change non-linearly with vertical position
13771              in such rows.  */
13772           /* FIXME: Revisit this when glyph ``spilling'' in
13773              continuation lines' rows is implemented for
13774              bidi-reordered rows.  */
13775           if (!NILP (XBUFFER (w->buffer)->bidi_display_reordering))
13776             {
13777               while (MATRIX_ROW_CONTINUATION_LINE_P (row))
13778                 {
13779                   xassert (row->enabled_p);
13780                   --row;
13781                   /* If we hit the beginning of the displayed portion
13782                      without finding the first row of a continued
13783                      line, give up.  */
13784                   if (row <= w->current_matrix->rows)
13785                     {
13786                       rc = CURSOR_MOVEMENT_MUST_SCROLL;
13787                       break;
13788                     }
13789 
13790                 }
13791             }
13792         }
13793 
13794       if (rc == CURSOR_MOVEMENT_CANNOT_BE_USED)
13795         {
13796           int scroll_p = 0;
13797           int last_y = window_text_bottom_y (w) - this_scroll_margin;
13798 
13799           if (PT > XFASTINT (w->last_point))
13800             {
13801               /* Point has moved forward.  */
13802               while (MATRIX_ROW_END_CHARPOS (row) < PT
13803                      && MATRIX_ROW_BOTTOM_Y (row) < last_y)
13804                 {
13805                   xassert (row->enabled_p);
13806                   ++row;
13807                 }
13808 
13809               /* If the end position of a row equals the start
13810                  position of the next row, and PT is at that position,
13811                  we would rather display cursor in the next line.  */
13812               while (MATRIX_ROW_BOTTOM_Y (row) < last_y
13813                      && MATRIX_ROW_END_CHARPOS (row) == PT
13814                      && row < w->current_matrix->rows
13815                                 + w->current_matrix->nrows - 1
13816                      && MATRIX_ROW_START_CHARPOS (row+1) == PT
13817                      && !cursor_row_p (w, row))
13818                 ++row;
13819 
13820               /* If within the scroll margin, scroll.  Note that
13821                  MATRIX_ROW_BOTTOM_Y gives the pixel position at which
13822                  the next line would be drawn, and that
13823                  this_scroll_margin can be zero.  */
13824               if (MATRIX_ROW_BOTTOM_Y (row) > last_y
13825                   || PT > MATRIX_ROW_END_CHARPOS (row)
13826                   /* Line is completely visible last line in window
13827                      and PT is to be set in the next line.  */
13828                   || (MATRIX_ROW_BOTTOM_Y (row) == last_y
13829                       && PT == MATRIX_ROW_END_CHARPOS (row)
13830                       && !row->ends_at_zv_p
13831                       && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
13832                 scroll_p = 1;
13833             }
13834           else if (PT < XFASTINT (w->last_point))
13835             {
13836               /* Cursor has to be moved backward.  Note that PT >=
13837                  CHARPOS (startp) because of the outer if-statement.  */
13838               while (!row->mode_line_p
13839                      && (MATRIX_ROW_START_CHARPOS (row) > PT
13840                          || (MATRIX_ROW_START_CHARPOS (row) == PT
13841                              && (MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row)
13842                                  || (/* STARTS_IN_MIDDLE_OF_STRING_P (row) */
13843                                      row > w->current_matrix->rows
13844                                      && (row-1)->ends_in_newline_from_string_p))))
13845                      && (row->y > top_scroll_margin
13846                          || CHARPOS (startp) == BEGV))
13847                 {
13848                   xassert (row->enabled_p);
13849                   --row;
13850                 }
13851 
13852               /* Consider the following case: Window starts at BEGV,
13853                  there is invisible, intangible text at BEGV, so that
13854                  display starts at some point START > BEGV.  It can
13855                  happen that we are called with PT somewhere between
13856                  BEGV and START.  Try to handle that case.  */
13857               if (row < w->current_matrix->rows
13858                   || row->mode_line_p)
13859                 {
13860                   row = w->current_matrix->rows;
13861                   if (row->mode_line_p)
13862                     ++row;
13863                 }
13864 
13865               /* Due to newlines in overlay strings, we may have to
13866                  skip forward over overlay strings.  */
13867               while (MATRIX_ROW_BOTTOM_Y (row) < last_y
13868                      && MATRIX_ROW_END_CHARPOS (row) == PT
13869                      && !cursor_row_p (w, row))
13870                 ++row;
13871 
13872               /* If within the scroll margin, scroll.  */
13873               if (row->y < top_scroll_margin
13874                   && CHARPOS (startp) != BEGV)
13875                 scroll_p = 1;
13876             }
13877           else
13878             {
13879               /* Cursor did not move.  So don't scroll even if cursor line
13880                  is partially visible, as it was so before.  */
13881                  rc = CURSOR_MOVEMENT_SUCCESS;
13882             }
13883 
13884           if (PT < MATRIX_ROW_START_CHARPOS (row)
13885               || PT > MATRIX_ROW_END_CHARPOS (row))
13886             {
13887               /* if PT is not in the glyph row, give up.  */
13888               rc = CURSOR_MOVEMENT_MUST_SCROLL;
13889             }
13890           else if (rc != CURSOR_MOVEMENT_SUCCESS
13891                    && MATRIX_ROW_PARTIALLY_VISIBLE_P (w, row)
13892                    && make_cursor_line_fully_visible_p)
13893             {
13894               if (PT == MATRIX_ROW_END_CHARPOS (row)
13895                   && !row->ends_at_zv_p
13896                   && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))
13897                 rc = CURSOR_MOVEMENT_MUST_SCROLL;
13898               else if (row->height > window_box_height (w))
13899                 {
13900                   /* If we end up in a partially visible line, let's
13901                      make it fully visible, except when it's taller
13902                      than the window, in which case we can't do much
13903                      about it.  */
13904                   *scroll_step = 1;
13905                   rc = CURSOR_MOVEMENT_MUST_SCROLL;
13906                 }
13907               else
13908                 {
13909                   set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
13910                   if (!cursor_row_fully_visible_p (w, 0, 1))
13911                     rc = CURSOR_MOVEMENT_MUST_SCROLL;
13912                   else
13913                     rc = CURSOR_MOVEMENT_SUCCESS;
13914                 }
13915             }
13916           else if (scroll_p)
13917             rc = CURSOR_MOVEMENT_MUST_SCROLL;
13918           else if (!NILP (XBUFFER (w->buffer)->bidi_display_reordering))
13919             {
13920               /* With bidi-reordered rows, there could be more than
13921                  one candidate row whose start and end positions
13922                  occlude point.  We need to let set_cursor_from_row
13923                  find the best candidate.  */
13924               /* FIXME: Revisit this when glyph ``spilling'' in
13925                  continuation lines' rows is implemented for
13926                  bidi-reordered rows.  */
13927               int rv = 0;
13928 
13929               do
13930                 {
13931                   rv |= set_cursor_from_row (w, row, w->current_matrix,
13932                                              0, 0, 0, 0);
13933                   /* As soon as we've found the first suitable row
13934                      whose ends_at_zv_p flag is set, we are done.  */
13935                   if (rv
13936                       && MATRIX_ROW (w->current_matrix, w->cursor.vpos)->ends_at_zv_p)
13937                     {
13938                       rc = CURSOR_MOVEMENT_SUCCESS;
13939                       break;
13940                     }
13941                   ++row;
13942                 }
13943               while (MATRIX_ROW_BOTTOM_Y (row) < last_y
13944                      && MATRIX_ROW_START_CHARPOS (row) <= PT
13945                      && PT <= MATRIX_ROW_END_CHARPOS (row)
13946                      && cursor_row_p (w, row));
13947               /* If we didn't find any candidate rows, or exited the
13948                  loop before all the candidates were examined, signal
13949                  to the caller that this method failed.  */
13950               if (rc != CURSOR_MOVEMENT_SUCCESS
13951                   && (!rv
13952                       || (MATRIX_ROW_START_CHARPOS (row) <= PT
13953                           && PT <= MATRIX_ROW_END_CHARPOS (row))))
13954                 rc = CURSOR_MOVEMENT_CANNOT_BE_USED;
13955               else
13956                 rc = CURSOR_MOVEMENT_SUCCESS;
13957             }
13958           else
13959             {
13960               do
13961                 {
13962                   if (set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0))
13963                     {
13964                       rc = CURSOR_MOVEMENT_SUCCESS;
13965                       break;
13966                     }
13967                   ++row;
13968                 }
13969               while (MATRIX_ROW_BOTTOM_Y (row) < last_y
13970                      && MATRIX_ROW_START_CHARPOS (row) == PT
13971                      && cursor_row_p (w, row));
13972             }
13973         }
13974     }
13975 
13976   return rc;
13977 }
13978 
13979 void
13980 set_vertical_scroll_bar (w)
13981      struct window *w;
13982 {
13983   int start, end, whole;
13984 
13985   /* Calculate the start and end positions for the current window.
13986      At some point, it would be nice to choose between scrollbars
13987      which reflect the whole buffer size, with special markers
13988      indicating narrowing, and scrollbars which reflect only the
13989      visible region.
13990 
13991      Note that mini-buffers sometimes aren't displaying any text.  */
13992   if (!MINI_WINDOW_P (w)
13993       || (w == XWINDOW (minibuf_window)
13994           && NILP (echo_area_buffer[0])))
13995     {
13996       struct buffer *buf = XBUFFER (w->buffer);
13997       whole = BUF_ZV (buf) - BUF_BEGV (buf);
13998       start = marker_position (w->start) - BUF_BEGV (buf);
13999       /* I don't think this is guaranteed to be right.  For the
14000          moment, we'll pretend it is.  */
14001       end = BUF_Z (buf) - XFASTINT (w->window_end_pos) - BUF_BEGV (buf);
14002 
14003       if (end < start)
14004         end = start;
14005       if (whole < (end - start))
14006         whole = end - start;
14007     }
14008   else
14009     start = end = whole = 0;
14010 
14011   /* Indicate what this scroll bar ought to be displaying now.  */
14012   if (FRAME_TERMINAL (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
14013     (*FRAME_TERMINAL (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
14014       (w, end - start, whole, start);
14015 }
14016 
14017 
14018 /* Redisplay leaf window WINDOW.  JUST_THIS_ONE_P non-zero means only
14019    selected_window is redisplayed.
14020 
14021    We can return without actually redisplaying the window if
14022    fonts_changed_p is nonzero.  In that case, redisplay_internal will
14023    retry.  */
14024 
14025 static void
14026 redisplay_window (window, just_this_one_p)
14027      Lisp_Object window;
14028      int just_this_one_p;
14029 {
14030   struct window *w = XWINDOW (window);
14031   struct frame *f = XFRAME (w->frame);
14032   struct buffer *buffer = XBUFFER (w->buffer);
14033   struct buffer *old = current_buffer;
14034   struct text_pos lpoint, opoint, startp;
14035   int update_mode_line;
14036   int tem;
14037   struct it it;
14038   /* Record it now because it's overwritten.  */
14039   int current_matrix_up_to_date_p = 0;
14040   int used_current_matrix_p = 0;
14041   /* This is less strict than current_matrix_up_to_date_p.
14042      It indictes that the buffer contents and narrowing are unchanged.  */
14043   int buffer_unchanged_p = 0;
14044   int temp_scroll_step = 0;
14045   int count = SPECPDL_INDEX ();
14046   int rc;
14047   int centering_position = -1;
14048   int last_line_misfit = 0;
14049   int beg_unchanged, end_unchanged;
14050 
14051   SET_TEXT_POS (lpoint, PT, PT_BYTE);
14052   opoint = lpoint;
14053 
14054   /* W must be a leaf window here.  */
14055   xassert (!NILP (w->buffer));
14056 #if GLYPH_DEBUG
14057   *w->desired_matrix->method = 0;
14058 #endif
14059 
14060  restart:
14061   reconsider_clip_changes (w, buffer);
14062 
14063   /* Has the mode line to be updated?  */
14064   update_mode_line = (!NILP (w->update_mode_line)
14065                       || update_mode_lines
14066                       || buffer->clip_changed
14067                       || buffer->prevent_redisplay_optimizations_p);
14068 
14069   if (MINI_WINDOW_P (w))
14070     {
14071       if (w == XWINDOW (echo_area_window)
14072           && !NILP (echo_area_buffer[0]))
14073         {
14074           if (update_mode_line)
14075             /* We may have to update a tty frame's menu bar or a
14076                tool-bar.  Example `M-x C-h C-h C-g'.  */
14077             goto finish_menu_bars;
14078           else
14079             /* We've already displayed the echo area glyphs in this window.  */
14080             goto finish_scroll_bars;
14081         }
14082       else if ((w != XWINDOW (minibuf_window)
14083                 || minibuf_level == 0)
14084                /* When buffer is nonempty, redisplay window normally. */
14085                && BUF_Z (XBUFFER (w->buffer)) == BUF_BEG (XBUFFER (w->buffer))
14086                /* Quail displays non-mini buffers in minibuffer window.
14087                   In that case, redisplay the window normally.  */
14088                && !NILP (Fmemq (w->buffer, Vminibuffer_list)))
14089         {
14090           /* W is a mini-buffer window, but it's not active, so clear
14091              it.  */
14092           int yb = window_text_bottom_y (w);
14093           struct glyph_row *row;
14094           int y;
14095 
14096           for (y = 0, row = w->desired_matrix->rows;
14097                y < yb;
14098                y += row->height, ++row)
14099             blank_row (w, row, y);
14100           goto finish_scroll_bars;
14101         }
14102 
14103       clear_glyph_matrix (w->desired_matrix);
14104     }
14105 
14106   /* Otherwise set up data on this window; select its buffer and point
14107      value.  */
14108   /* Really select the buffer, for the sake of buffer-local
14109      variables.  */
14110   set_buffer_internal_1 (XBUFFER (w->buffer));
14111 
14112   current_matrix_up_to_date_p
14113     = (!NILP (w->window_end_valid)
14114        && !current_buffer->clip_changed
14115        && !current_buffer->prevent_redisplay_optimizations_p
14116        && XFASTINT (w->last_modified) >= MODIFF
14117        && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF);
14118 
14119   /* Run the window-bottom-change-functions
14120      if it is possible that the text on the screen has changed
14121      (either due to modification of the text, or any other reason).  */
14122   if (!current_matrix_up_to_date_p
14123       && !NILP (Vwindow_text_change_functions))
14124     {
14125       safe_run_hooks (Qwindow_text_change_functions);
14126       goto restart;
14127     }
14128 
14129   beg_unchanged = BEG_UNCHANGED;
14130   end_unchanged = END_UNCHANGED;
14131 
14132   SET_TEXT_POS (opoint, PT, PT_BYTE);
14133 
14134   specbind (Qinhibit_point_motion_hooks, Qt);
14135 
14136   buffer_unchanged_p
14137     = (!NILP (w->window_end_valid)
14138        && !current_buffer->clip_changed
14139        && XFASTINT (w->last_modified) >= MODIFF
14140        && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF);
14141 
14142   /* When windows_or_buffers_changed is non-zero, we can't rely on
14143      the window end being valid, so set it to nil there.  */
14144   if (windows_or_buffers_changed)
14145     {
14146       /* If window starts on a continuation line, maybe adjust the
14147          window start in case the window's width changed.  */
14148       if (XMARKER (w->start)->buffer == current_buffer)
14149         compute_window_start_on_continuation_line (w);
14150 
14151       w->window_end_valid = Qnil;
14152     }
14153 
14154   /* Some sanity checks.  */
14155   CHECK_WINDOW_END (w);
14156   if (Z == Z_BYTE && CHARPOS (opoint) != BYTEPOS (opoint))
14157     abort ();
14158   if (BYTEPOS (opoint) < CHARPOS (opoint))
14159     abort ();
14160 
14161   /* If %c is in mode line, update it if needed.  */
14162   if (!NILP (w->column_number_displayed)
14163       /* This alternative quickly identifies a common case
14164          where no change is needed.  */
14165       && !(PT == XFASTINT (w->last_point)
14166            && XFASTINT (w->last_modified) >= MODIFF
14167            && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF)
14168       && (XFASTINT (w->column_number_displayed)
14169           != (int) current_column ()))  /* iftc */
14170     update_mode_line = 1;
14171 
14172   /* Count number of windows showing the selected buffer.  An indirect
14173      buffer counts as its base buffer.  */
14174   if (!just_this_one_p)
14175     {
14176       struct buffer *current_base, *window_base;
14177       current_base = current_buffer;
14178       window_base = XBUFFER (XWINDOW (selected_window)->buffer);
14179       if (current_base->base_buffer)
14180         current_base = current_base->base_buffer;
14181       if (window_base->base_buffer)
14182         window_base = window_base->base_buffer;
14183       if (current_base == window_base)
14184         buffer_shared++;
14185     }
14186 
14187   /* Point refers normally to the selected window.  For any other
14188      window, set up appropriate value.  */
14189   if (!EQ (window, selected_window))
14190     {
14191       int new_pt = XMARKER (w->pointm)->charpos;
14192       int new_pt_byte = marker_byte_position (w->pointm);
14193       if (new_pt < BEGV)
14194         {
14195           new_pt = BEGV;
14196           new_pt_byte = BEGV_BYTE;
14197           set_marker_both (w->pointm, Qnil, BEGV, BEGV_BYTE);
14198         }
14199       else if (new_pt > (ZV - 1))
14200         {
14201           new_pt = ZV;
14202           new_pt_byte = ZV_BYTE;
14203           set_marker_both (w->pointm, Qnil, ZV, ZV_BYTE);
14204         }
14205 
14206       /* We don't use SET_PT so that the point-motion hooks don't run.  */
14207       TEMP_SET_PT_BOTH (new_pt, new_pt_byte);
14208     }
14209 
14210   /* If any of the character widths specified in the display table
14211      have changed, invalidate the width run cache.  It's true that
14212      this may be a bit late to catch such changes, but the rest of
14213      redisplay goes (non-fatally) haywire when the display table is
14214      changed, so why should we worry about doing any better?  */
14215   if (current_buffer->width_run_cache)
14216     {
14217       struct Lisp_Char_Table *disptab = buffer_display_table ();
14218 
14219       if (! disptab_matches_widthtab (disptab,
14220                                       XVECTOR (current_buffer->width_table)))
14221         {
14222           invalidate_region_cache (current_buffer,
14223                                    current_buffer->width_run_cache,
14224                                    BEG, Z);
14225           recompute_width_table (current_buffer, disptab);
14226         }
14227     }
14228 
14229   /* If window-start is screwed up, choose a new one.  */
14230   if (XMARKER (w->start)->buffer != current_buffer)
14231     goto recenter;
14232 
14233   SET_TEXT_POS_FROM_MARKER (startp, w->start);
14234 
14235   /* If someone specified a new starting point but did not insist,
14236      check whether it can be used.  */
14237   if (!NILP (w->optional_new_start)
14238       && CHARPOS (startp) >= BEGV
14239       && CHARPOS (startp) <= ZV)
14240     {
14241       w->optional_new_start = Qnil;
14242       start_display (&it, w, startp);
14243       move_it_to (&it, PT, 0, it.last_visible_y, -1,
14244                   MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
14245       if (IT_CHARPOS (it) == PT)
14246         w->force_start = Qt;
14247       /* IT may overshoot PT if text at PT is invisible.  */
14248       else if (IT_CHARPOS (it) > PT && CHARPOS (startp) <= PT)
14249         w->force_start = Qt;
14250     }
14251 
14252  force_start:
14253 
14254   /* Handle case where place to start displaying has been specified,
14255      unless the specified location is outside the accessible range.  */
14256   if (!NILP (w->force_start)
14257       || w->frozen_window_start_p)
14258     {
14259       /* We set this later on if we have to adjust point.  */
14260       int new_vpos = -1;
14261 
14262       w->force_start = Qnil;
14263       w->vscroll = 0;
14264       w->window_end_valid = Qnil;
14265 
14266       /* Forget any recorded base line for line number display.  */
14267       if (!buffer_unchanged_p)
14268         w->base_line_number = Qnil;
14269 
14270       /* Redisplay the mode line.  Select the buffer properly for that.
14271          Also, run the hook window-scroll-functions
14272          because we have scrolled.  */
14273       /* Note, we do this after clearing force_start because
14274          if there's an error, it is better to forget about force_start
14275          than to get into an infinite loop calling the hook functions
14276          and having them get more errors.  */
14277       if (!update_mode_line
14278           || ! NILP (Vwindow_scroll_functions))
14279         {
14280           update_mode_line = 1;
14281           w->update_mode_line = Qt;
14282           startp = run_window_scroll_functions (window, startp);
14283         }
14284 
14285       w->last_modified = make_number (0);
14286       w->last_overlay_modified = make_number (0);
14287       if (CHARPOS (startp) < BEGV)
14288         SET_TEXT_POS (startp, BEGV, BEGV_BYTE);
14289       else if (CHARPOS (startp) > ZV)
14290         SET_TEXT_POS (startp, ZV, ZV_BYTE);
14291 
14292       /* Redisplay, then check if cursor has been set during the
14293          redisplay.  Give up if new fonts were loaded.  */
14294       /* We used to issue a CHECK_MARGINS argument to try_window here,
14295          but this causes scrolling to fail when point begins inside
14296          the scroll margin (bug#148) -- cyd  */
14297       if (!try_window (window, startp, 0))
14298         {
14299           w->force_start = Qt;
14300           clear_glyph_matrix (w->desired_matrix);
14301           goto need_larger_matrices;
14302         }
14303 
14304       if (w->cursor.vpos < 0 && !w->frozen_window_start_p)
14305         {
14306           /* If point does not appear, try to move point so it does
14307              appear. The desired matrix has been built above, so we
14308              can use it here.  */
14309           new_vpos = window_box_height (w) / 2;
14310         }
14311 
14312       if (!cursor_row_fully_visible_p (w, 0, 0))
14313         {
14314           /* Point does appear, but on a line partly visible at end of window.
14315              Move it back to a fully-visible line.  */
14316           new_vpos = window_box_height (w);
14317         }
14318 
14319       /* If we need to move point for either of the above reasons,
14320          now actually do it.  */
14321       if (new_vpos >= 0)
14322         {
14323           struct glyph_row *row;
14324 
14325           row = MATRIX_FIRST_TEXT_ROW (w->desired_matrix);
14326           while (MATRIX_ROW_BOTTOM_Y (row) < new_vpos)
14327             ++row;
14328 
14329           TEMP_SET_PT_BOTH (MATRIX_ROW_START_CHARPOS (row),
14330                             MATRIX_ROW_START_BYTEPOS (row));
14331 
14332           if (w != XWINDOW (selected_window))
14333             set_marker_both (w->pointm, Qnil, PT, PT_BYTE);
14334           else if (current_buffer == old)
14335             SET_TEXT_POS (lpoint, PT, PT_BYTE);
14336 
14337           set_cursor_from_row (w, row, w->desired_matrix, 0, 0, 0, 0);
14338 
14339           /* If we are highlighting the region, then we just changed
14340              the region, so redisplay to show it.  */
14341           if (!NILP (Vtransient_mark_mode)
14342               && !NILP (current_buffer->mark_active))
14343             {
14344               clear_glyph_matrix (w->desired_matrix);
14345               if (!try_window (window, startp, 0))
14346                 goto need_larger_matrices;
14347             }
14348         }
14349 
14350 #if GLYPH_DEBUG
14351       debug_method_add (w, "forced window start");
14352 #endif
14353       goto done;
14354     }
14355 
14356   /* Handle case where text has not changed, only point, and it has
14357      not moved off the frame, and we are not retrying after hscroll.
14358      (current_matrix_up_to_date_p is nonzero when retrying.)  */
14359   if (current_matrix_up_to_date_p
14360       && (rc = try_cursor_movement (window, startp, &temp_scroll_step),
14361           rc != CURSOR_MOVEMENT_CANNOT_BE_USED))
14362     {
14363       switch (rc)
14364         {
14365         case CURSOR_MOVEMENT_SUCCESS:
14366           used_current_matrix_p = 1;
14367           goto done;
14368 
14369         case CURSOR_MOVEMENT_MUST_SCROLL:
14370           goto try_to_scroll;
14371 
14372         default:
14373           abort ();
14374         }
14375     }
14376   /* If current starting point was originally the beginning of a line
14377      but no longer is, find a new starting point.  */
14378   else if (!NILP (w->start_at_line_beg)
14379            && !(CHARPOS (startp) <= BEGV
14380                 || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n'))
14381     {
14382 #if GLYPH_DEBUG
14383       debug_method_add (w, "recenter 1");
14384 #endif
14385       goto recenter;
14386     }
14387 
14388   /* Try scrolling with try_window_id.  Value is > 0 if update has
14389      been done, it is -1 if we know that the same window start will
14390      not work.  It is 0 if unsuccessful for some other reason.  */
14391   else if ((tem = try_window_id (w)) != 0)
14392     {
14393 #if GLYPH_DEBUG
14394       debug_method_add (w, "try_window_id %d", tem);
14395 #endif
14396 
14397       if (fonts_changed_p)
14398         goto need_larger_matrices;
14399       if (tem > 0)
14400         goto done;
14401 
14402       /* Otherwise try_window_id has returned -1 which means that we
14403          don't want the alternative below this comment to execute.  */
14404     }
14405   else if (CHARPOS (startp) >= BEGV
14406            && CHARPOS (startp) <= ZV
14407            && PT >= CHARPOS (startp)
14408            && (CHARPOS (startp) < ZV
14409                /* Avoid starting at end of buffer.  */
14410                || CHARPOS (startp) == BEGV
14411                || (XFASTINT (w->last_modified) >= MODIFF
14412                    && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF)))
14413     {
14414 
14415       /* If first window line is a continuation line, and window start
14416          is inside the modified region, but the first change is before
14417          current window start, we must select a new window start.
14418 
14419          However, if this is the result of a down-mouse event (e.g. by
14420          extending the mouse-drag-overlay), we don't want to select a
14421          new window start, since that would change the position under
14422          the mouse, resulting in an unwanted mouse-movement rather
14423          than a simple mouse-click.  */
14424       if (NILP (w->start_at_line_beg)
14425           && NILP (do_mouse_tracking)
14426           && CHARPOS (startp) > BEGV
14427           && CHARPOS (startp) > BEG + beg_unchanged
14428           && CHARPOS (startp) <= Z - end_unchanged
14429           /* Even if w->start_at_line_beg is nil, a new window may
14430              start at a line_beg, since that's how set_buffer_window
14431              sets it.  So, we need to check the return value of
14432              compute_window_start_on_continuation_line.  (See also
14433              bug#197).  */
14434           && XMARKER (w->start)->buffer == current_buffer
14435           && compute_window_start_on_continuation_line (w))
14436         {
14437           w->force_start = Qt;
14438           SET_TEXT_POS_FROM_MARKER (startp, w->start);
14439           goto force_start;
14440         }
14441 
14442 #if GLYPH_DEBUG
14443       debug_method_add (w, "same window start");
14444 #endif
14445 
14446       /* Try to redisplay starting at same place as before.
14447          If point has not moved off frame, accept the results.  */
14448       if (!current_matrix_up_to_date_p
14449           /* Don't use try_window_reusing_current_matrix in this case
14450              because a window scroll function can have changed the
14451              buffer.  */
14452           || !NILP (Vwindow_scroll_functions)
14453           || MINI_WINDOW_P (w)
14454           || !(used_current_matrix_p
14455                = try_window_reusing_current_matrix (w)))
14456         {
14457           IF_DEBUG (debug_method_add (w, "1"));
14458           if (try_window (window, startp, TRY_WINDOW_CHECK_MARGINS) < 0)
14459             /* -1 means we need to scroll.
14460                0 means we need new matrices, but fonts_changed_p
14461                is set in that case, so we will detect it below.  */
14462             goto try_to_scroll;
14463         }
14464 
14465       if (fonts_changed_p)
14466         goto need_larger_matrices;
14467 
14468       if (w->cursor.vpos >= 0)
14469         {
14470           if (!just_this_one_p
14471               || current_buffer->clip_changed
14472               || BEG_UNCHANGED < CHARPOS (startp))
14473             /* Forget any recorded base line for line number display.  */
14474             w->base_line_number = Qnil;
14475 
14476           if (!cursor_row_fully_visible_p (w, 1, 0))
14477             {
14478               clear_glyph_matrix (w->desired_matrix);
14479               last_line_misfit = 1;
14480             }
14481             /* Drop through and scroll.  */
14482           else
14483             goto done;
14484         }
14485       else
14486         clear_glyph_matrix (w->desired_matrix);
14487     }
14488 
14489  try_to_scroll:
14490 
14491   w->last_modified = make_number (0);
14492   w->last_overlay_modified = make_number (0);
14493 
14494   /* Redisplay the mode line.  Select the buffer properly for that.  */
14495   if (!update_mode_line)
14496     {
14497       update_mode_line = 1;
14498       w->update_mode_line = Qt;
14499     }
14500 
14501   /* Try to scroll by specified few lines.  */
14502   if ((scroll_conservatively
14503        || scroll_step
14504        || temp_scroll_step
14505        || NUMBERP (current_buffer->scroll_up_aggressively)
14506        || NUMBERP (current_buffer->scroll_down_aggressively))
14507       && !current_buffer->clip_changed
14508       && CHARPOS (startp) >= BEGV
14509       && CHARPOS (startp) <= ZV)
14510     {
14511       /* The function returns -1 if new fonts were loaded, 1 if
14512          successful, 0 if not successful.  */
14513       int rc = try_scrolling (window, just_this_one_p,
14514                               scroll_conservatively,
14515                               scroll_step,
14516                               temp_scroll_step, last_line_misfit);
14517       switch (rc)
14518         {
14519         case SCROLLING_SUCCESS:
14520           goto done;
14521 
14522         case SCROLLING_NEED_LARGER_MATRICES:
14523           goto need_larger_matrices;
14524 
14525         case SCROLLING_FAILED:
14526           break;
14527 
14528         default:
14529           abort ();
14530         }
14531     }
14532 
14533   /* Finally, just choose place to start which centers point */
14534 
14535  recenter:
14536   if (centering_position < 0)
14537     centering_position = window_box_height (w) / 2;
14538 
14539 #if GLYPH_DEBUG
14540   debug_method_add (w, "recenter");
14541 #endif
14542 
14543   /* w->vscroll = 0; */
14544 
14545   /* Forget any previously recorded base line for line number display.  */
14546   if (!buffer_unchanged_p)
14547     w->base_line_number = Qnil;
14548 
14549   /* Move backward half the height of the window.  */
14550   init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
14551   it.current_y = it.last_visible_y;
14552   move_it_vertically_backward (&it, centering_position);
14553   xassert (IT_CHARPOS (it) >= BEGV);
14554 
14555   /* The function move_it_vertically_backward may move over more
14556      than the specified y-distance.  If it->w is small, e.g. a
14557      mini-buffer window, we may end up in front of the window's
14558      display area.  Start displaying at the start of the line
14559      containing PT in this case.  */
14560   if (it.current_y <= 0)
14561     {
14562       init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
14563       move_it_vertically_backward (&it, 0);
14564       it.current_y = 0;
14565     }
14566 
14567   it.current_x = it.hpos = 0;
14568 
14569   /* Set startp here explicitly in case that helps avoid an infinite loop
14570      in case the window-scroll-functions functions get errors.  */
14571   set_marker_both (w->start, Qnil, IT_CHARPOS (it), IT_BYTEPOS (it));
14572 
14573   /* Run scroll hooks.  */
14574   startp = run_window_scroll_functions (window, it.current.pos);
14575 
14576   /* Redisplay the window.  */
14577   if (!current_matrix_up_to_date_p
14578       || windows_or_buffers_changed
14579       || cursor_type_changed
14580       /* Don't use try_window_reusing_current_matrix in this case
14581          because it can have changed the buffer.  */
14582       || !NILP (Vwindow_scroll_functions)
14583       || !just_this_one_p
14584       || MINI_WINDOW_P (w)
14585       || !(used_current_matrix_p
14586            = try_window_reusing_current_matrix (w)))
14587     try_window (window, startp, 0);
14588 
14589   /* If new fonts have been loaded (due to fontsets), give up.  We
14590      have to start a new redisplay since we need to re-adjust glyph
14591      matrices.  */
14592   if (fonts_changed_p)
14593     goto need_larger_matrices;
14594 
14595   /* If cursor did not appear assume that the middle of the window is
14596      in the first line of the window.  Do it again with the next line.
14597      (Imagine a window of height 100, displaying two lines of height
14598      60.  Moving back 50 from it->last_visible_y will end in the first
14599      line.)  */
14600   if (w->cursor.vpos < 0)
14601     {
14602       if (!NILP (w->window_end_valid)
14603           && PT >= Z - XFASTINT (w->window_end_pos))
14604         {
14605           clear_glyph_matrix (w->desired_matrix);
14606           move_it_by_lines (&it, 1, 0);
14607           try_window (window, it.current.pos, 0);
14608         }
14609       else if (PT < IT_CHARPOS (it))
14610         {
14611           clear_glyph_matrix (w->desired_matrix);
14612           move_it_by_lines (&it, -1, 0);
14613           try_window (window, it.current.pos, 0);
14614         }
14615       else
14616         {
14617           /* Not much we can do about it.  */
14618         }
14619     }
14620 
14621   /* Consider the following case: Window starts at BEGV, there is
14622      invisible, intangible text at BEGV, so that display starts at
14623      some point START > BEGV.  It can happen that we are called with
14624      PT somewhere between BEGV and START.  Try to handle that case.  */
14625   if (w->cursor.vpos < 0)
14626     {
14627       struct glyph_row *row = w->current_matrix->rows;
14628       if (row->mode_line_p)
14629         ++row;
14630       set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
14631     }
14632 
14633   if (!cursor_row_fully_visible_p (w, 0, 0))
14634     {
14635       /* If vscroll is enabled, disable it and try again.  */
14636       if (w->vscroll)
14637         {
14638           w->vscroll = 0;
14639           clear_glyph_matrix (w->desired_matrix);
14640           goto recenter;
14641         }
14642 
14643       /* If centering point failed to make the whole line visible,
14644          put point at the top instead.  That has to make the whole line
14645          visible, if it can be done.  */
14646       if (centering_position == 0)
14647         goto done;
14648 
14649       clear_glyph_matrix (w->desired_matrix);
14650       centering_position = 0;
14651       goto recenter;
14652     }
14653 
14654  done:
14655 
14656   SET_TEXT_POS_FROM_MARKER (startp, w->start);
14657   w->start_at_line_beg = ((CHARPOS (startp) == BEGV
14658                            || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n')
14659                           ? Qt : Qnil);
14660 
14661   /* Display the mode line, if we must.  */
14662   if ((update_mode_line
14663        /* If window not full width, must redo its mode line
14664           if (a) the window to its side is being redone and
14665           (b) we do a frame-based redisplay.  This is a consequence
14666           of how inverted lines are drawn in frame-based redisplay.  */
14667        || (!just_this_one_p
14668            && !FRAME_WINDOW_P (f)
14669            && !WINDOW_FULL_WIDTH_P (w))
14670        /* Line number to display.  */
14671        || INTEGERP (w->base_line_pos)
14672        /* Column number is displayed and different from the one displayed.  */
14673        || (!NILP (w->column_number_displayed)
14674            && (XFASTINT (w->column_number_displayed)
14675                != (int) current_column ()))) /* iftc */
14676        /* This means that the window has a mode line.  */
14677        && (WINDOW_WANTS_MODELINE_P (w)
14678            || WINDOW_WANTS_HEADER_LINE_P (w)))
14679     {
14680       display_mode_lines (w);
14681 
14682       /* If mode line height has changed, arrange for a thorough
14683          immediate redisplay using the correct mode line height.  */
14684       if (WINDOW_WANTS_MODELINE_P (w)
14685           && CURRENT_MODE_LINE_HEIGHT (w) != DESIRED_MODE_LINE_HEIGHT (w))
14686         {
14687           fonts_changed_p = 1;
14688           MATRIX_MODE_LINE_ROW (w->current_matrix)->height
14689             = DESIRED_MODE_LINE_HEIGHT (w);
14690         }
14691 
14692       /* If header line height has changed, arrange for a thorough
14693          immediate redisplay using the correct header line height.  */
14694       if (WINDOW_WANTS_HEADER_LINE_P (w)
14695           && CURRENT_HEADER_LINE_HEIGHT (w) != DESIRED_HEADER_LINE_HEIGHT (w))
14696         {
14697           fonts_changed_p = 1;
14698           MATRIX_HEADER_LINE_ROW (w->current_matrix)->height
14699             = DESIRED_HEADER_LINE_HEIGHT (w);
14700         }
14701 
14702       if (fonts_changed_p)
14703         goto need_larger_matrices;
14704     }
14705 
14706   if (!line_number_displayed
14707       && !BUFFERP (w->base_line_pos))
14708     {
14709       w->base_line_pos = Qnil;
14710       w->base_line_number = Qnil;
14711     }
14712 
14713  finish_menu_bars:
14714 
14715   /* When we reach a frame's selected window, redo the frame's menu bar.  */
14716   if (update_mode_line
14717       && EQ (FRAME_SELECTED_WINDOW (f), window))
14718     {
14719       int redisplay_menu_p = 0;
14720       int redisplay_tool_bar_p = 0;
14721 
14722       if (FRAME_WINDOW_P (f))
14723         {
14724 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
14725     || defined (HAVE_NS) || defined (USE_GTK)
14726           redisplay_menu_p = FRAME_EXTERNAL_MENU_BAR (f);
14727 #else
14728           redisplay_menu_p = FRAME_MENU_BAR_LINES (f) > 0;
14729 #endif
14730         }
14731       else
14732         redisplay_menu_p = FRAME_MENU_BAR_LINES (f) > 0;
14733 
14734       if (redisplay_menu_p)
14735         display_menu_bar (w);
14736 
14737 #ifdef HAVE_WINDOW_SYSTEM
14738       if (FRAME_WINDOW_P (f))
14739         {
14740 #if defined (USE_GTK) || defined (HAVE_NS)
14741           redisplay_tool_bar_p = FRAME_EXTERNAL_TOOL_BAR (f);
14742 #else
14743           redisplay_tool_bar_p = WINDOWP (f->tool_bar_window)
14744             && (FRAME_TOOL_BAR_LINES (f) > 0
14745                 || !NILP (Vauto_resize_tool_bars));
14746 #endif
14747 
14748           if (redisplay_tool_bar_p && redisplay_tool_bar (f))
14749             {
14750               extern int ignore_mouse_drag_p;
14751               ignore_mouse_drag_p = 1;
14752             }
14753         }
14754 #endif
14755     }
14756 
14757 #ifdef HAVE_WINDOW_SYSTEM
14758   if (FRAME_WINDOW_P (f)
14759       && update_window_fringes (w, (just_this_one_p
14760                                     || (!used_current_matrix_p && !overlay_arrow_seen)
14761                                     || w->pseudo_window_p)))
14762     {
14763       update_begin (f);
14764       BLOCK_INPUT;
14765       if (draw_window_fringes (w, 1))
14766         x_draw_vertical_border (w);
14767       UNBLOCK_INPUT;
14768       update_end (f);
14769     }
14770 #endif /* HAVE_WINDOW_SYSTEM */
14771 
14772   /* We go to this label, with fonts_changed_p nonzero,
14773      if it is necessary to try again using larger glyph matrices.
14774      We have to redeem the scroll bar even in this case,
14775      because the loop in redisplay_internal expects that.  */
14776  need_larger_matrices:
14777   ;
14778  finish_scroll_bars:
14779 
14780   if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
14781     {
14782       /* Set the thumb's position and size.  */
14783       set_vertical_scroll_bar (w);
14784 
14785       /* Note that we actually used the scroll bar attached to this
14786          window, so it shouldn't be deleted at the end of redisplay.  */
14787       if (FRAME_TERMINAL (f)->redeem_scroll_bar_hook)
14788         (*FRAME_TERMINAL (f)->redeem_scroll_bar_hook) (w);
14789     }
14790 
14791   /* Restore current_buffer and value of point in it.  */
14792   TEMP_SET_PT_BOTH (CHARPOS (opoint), BYTEPOS (opoint));
14793   set_buffer_internal_1 (old);
14794   /* Avoid an abort in TEMP_SET_PT_BOTH if the buffer has become
14795      shorter.  This can be caused by log truncation in *Messages*. */
14796   if (CHARPOS (lpoint) <= ZV)
14797     TEMP_SET_PT_BOTH (CHARPOS (lpoint), BYTEPOS (lpoint));
14798 
14799   unbind_to (count, Qnil);
14800 }
14801 
14802 
14803 /* Build the complete desired matrix of WINDOW with a window start
14804    buffer position POS.
14805 
14806    Value is 1 if successful.  It is zero if fonts were loaded during
14807    redisplay which makes re-adjusting glyph matrices necessary, and -1
14808    if point would appear in the scroll margins.
14809    (We check the former only if TRY_WINDOW_IGNORE_FONTS_CHANGE is
14810    unset in FLAGS, and the latter only if TRY_WINDOW_CHECK_MARGINS is
14811    set in FLAGS.)  */
14812 
14813 int
14814 try_window (window, pos, flags)
14815      Lisp_Object window;
14816      struct text_pos pos;
14817      int flags;
14818 {
14819   struct window *w = XWINDOW (window);
14820   struct it it;
14821   struct glyph_row *last_text_row = NULL;
14822   struct frame *f = XFRAME (w->frame);
14823 
14824   /* Make POS the new window start.  */
14825   set_marker_both (w->start, Qnil, CHARPOS (pos), BYTEPOS (pos));
14826 
14827   /* Mark cursor position as unknown.  No overlay arrow seen.  */
14828   w->cursor.vpos = -1;
14829   overlay_arrow_seen = 0;
14830 
14831   /* Initialize iterator and info to start at POS.  */
14832   start_display (&it, w, pos);
14833 
14834   /* Display all lines of W.  */
14835   while (it.current_y < it.last_visible_y)
14836     {
14837       if (display_line (&it))
14838         last_text_row = it.glyph_row - 1;
14839       if (fonts_changed_p && !(flags & TRY_WINDOW_IGNORE_FONTS_CHANGE))
14840         return 0;
14841     }
14842 
14843   /* Don't let the cursor end in the scroll margins.  */
14844   if ((flags & TRY_WINDOW_CHECK_MARGINS)
14845       && !MINI_WINDOW_P (w))
14846     {
14847       int this_scroll_margin;
14848 
14849       if (scroll_margin > 0)
14850         {
14851           this_scroll_margin = min (scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
14852           this_scroll_margin *= FRAME_LINE_HEIGHT (f);
14853         }
14854       else
14855         this_scroll_margin = 0;
14856 
14857       if ((w->cursor.y >= 0     /* not vscrolled */
14858            && w->cursor.y < this_scroll_margin
14859            && CHARPOS (pos) > BEGV
14860            && IT_CHARPOS (it) < ZV)
14861           /* rms: considering make_cursor_line_fully_visible_p here
14862              seems to give wrong results.  We don't want to recenter
14863              when the last line is partly visible, we want to allow
14864              that case to be handled in the usual way.  */
14865           || w->cursor.y > it.last_visible_y - this_scroll_margin - 1)
14866         {
14867           w->cursor.vpos = -1;
14868           clear_glyph_matrix (w->desired_matrix);
14869           return -1;
14870         }
14871     }
14872 
14873   /* If bottom moved off end of frame, change mode line percentage.  */
14874   if (XFASTINT (w->window_end_pos) <= 0
14875       && Z != IT_CHARPOS (it))
14876     w->update_mode_line = Qt;
14877 
14878   /* Set window_end_pos to the offset of the last character displayed
14879      on the window from the end of current_buffer.  Set
14880      window_end_vpos to its row number.  */
14881   if (last_text_row)
14882     {
14883       xassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row));
14884       w->window_end_bytepos
14885         = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
14886       w->window_end_pos
14887         = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
14888       w->window_end_vpos
14889         = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
14890       xassert (MATRIX_ROW (w->desired_matrix, XFASTINT (w->window_end_vpos))
14891                ->displays_text_p);
14892     }
14893   else
14894     {
14895       w->window_end_bytepos = Z_BYTE - ZV_BYTE;
14896       w->window_end_pos = make_number (Z - ZV);
14897       w->window_end_vpos = make_number (0);
14898     }
14899 
14900   /* But that is not valid info until redisplay finishes.  */
14901   w->window_end_valid = Qnil;
14902   return 1;
14903 }
14904 
14905 
14906 
14907 /************************************************************************
14908     Window redisplay reusing current matrix when buffer has not changed
14909  ************************************************************************/
14910 
14911 /* Try redisplay of window W showing an unchanged buffer with a
14912    different window start than the last time it was displayed by
14913    reusing its current matrix.  Value is non-zero if successful.
14914    W->start is the new window start.  */
14915 
14916 static int
14917 try_window_reusing_current_matrix (w)
14918      struct window *w;
14919 {
14920   struct frame *f = XFRAME (w->frame);
14921   struct glyph_row *row, *bottom_row;
14922   struct it it;
14923   struct run run;
14924   struct text_pos start, new_start;
14925   int nrows_scrolled, i;
14926   struct glyph_row *last_text_row;
14927   struct glyph_row *last_reused_text_row;
14928   struct glyph_row *start_row;
14929   int start_vpos, min_y, max_y;
14930 
14931 #if GLYPH_DEBUG
14932   if (inhibit_try_window_reusing)
14933     return 0;
14934 #endif
14935 
14936   if (/* This function doesn't handle terminal frames.  */
14937       !FRAME_WINDOW_P (f)
14938       /* Don't try to reuse the display if windows have been split
14939          or such.  */
14940       || windows_or_buffers_changed
14941       || cursor_type_changed)
14942     return 0;
14943 
14944   /* Can't do this if region may have changed.  */
14945   if ((!NILP (Vtransient_mark_mode)
14946        && !NILP (current_buffer->mark_active))
14947       || !NILP (w->region_showing)
14948       || !NILP (Vshow_trailing_whitespace))
14949     return 0;
14950 
14951   /* If top-line visibility has changed, give up.  */
14952   if (WINDOW_WANTS_HEADER_LINE_P (w)
14953       != MATRIX_HEADER_LINE_ROW (w->current_matrix)->mode_line_p)
14954     return 0;
14955 
14956   /* Give up if old or new display is scrolled vertically.  We could
14957      make this function handle this, but right now it doesn't.  */
14958   start_row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
14959   if (w->vscroll || MATRIX_ROW_PARTIALLY_VISIBLE_P (w, start_row))
14960     return 0;
14961 
14962   /* The variable new_start now holds the new window start.  The old
14963      start `start' can be determined from the current matrix.  */
14964   SET_TEXT_POS_FROM_MARKER (new_start, w->start);
14965   start = start_row->minpos;
14966   start_vpos = MATRIX_ROW_VPOS (start_row, w->current_matrix);
14967 
14968   /* Clear the desired matrix for the display below.  */
14969   clear_glyph_matrix (w->desired_matrix);
14970 
14971   if (CHARPOS (new_start) <= CHARPOS (start))
14972     {
14973       int first_row_y;
14974 
14975       /* Don't use this method if the display starts with an ellipsis
14976          displayed for invisible text.  It's not easy to handle that case
14977          below, and it's certainly not worth the effort since this is
14978          not a frequent case.  */
14979       if (in_ellipses_for_invisible_text_p (&start_row->start, w))
14980         return 0;
14981 
14982       IF_DEBUG (debug_method_add (w, "twu1"));
14983 
14984       /* Display up to a row that can be reused.  The variable
14985          last_text_row is set to the last row displayed that displays
14986          text.  Note that it.vpos == 0 if or if not there is a
14987          header-line; it's not the same as the MATRIX_ROW_VPOS!  */
14988       start_display (&it, w, new_start);
14989       first_row_y = it.current_y;
14990       w->cursor.vpos = -1;
14991       last_text_row = last_reused_text_row = NULL;
14992 
14993       while (it.current_y < it.last_visible_y
14994              && !fonts_changed_p)
14995         {
14996           /* If we have reached into the characters in the START row,
14997              that means the line boundaries have changed.  So we
14998              can't start copying with the row START.  Maybe it will
14999              work to start copying with the following row.  */
15000           while (IT_CHARPOS (it) > CHARPOS (start))
15001             {
15002               /* Advance to the next row as the "start".  */
15003               start_row++;
15004               start = start_row->minpos;
15005               /* If there are no more rows to try, or just one, give up.  */
15006               if (start_row == MATRIX_MODE_LINE_ROW (w->current_matrix) - 1
15007                   || w->vscroll || MATRIX_ROW_PARTIALLY_VISIBLE_P (w, start_row)
15008                   || CHARPOS (start) == ZV)
15009                 {
15010                   clear_glyph_matrix (w->desired_matrix);
15011                   return 0;
15012                 }
15013 
15014               start_vpos = MATRIX_ROW_VPOS (start_row, w->current_matrix);
15015             }
15016           /* If we have reached alignment,
15017              we can copy the rest of the rows.  */
15018           if (IT_CHARPOS (it) == CHARPOS (start))
15019             break;
15020 
15021           if (display_line (&it))
15022             last_text_row = it.glyph_row - 1;
15023         }
15024 
15025       /* A value of current_y < last_visible_y means that we stopped
15026          at the previous window start, which in turn means that we
15027          have at least one reusable row.  */
15028       if (it.current_y < it.last_visible_y)
15029         {
15030           /* IT.vpos always starts from 0; it counts text lines.  */
15031           nrows_scrolled = it.vpos - (start_row - MATRIX_FIRST_TEXT_ROW (w->current_matrix));
15032 
15033           /* Find PT if not already found in the lines displayed.  */
15034           if (w->cursor.vpos < 0)
15035             {
15036               int dy = it.current_y - start_row->y;
15037 
15038               row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
15039               row = row_containing_pos (w, PT, row, NULL, dy);
15040               if (row)
15041                 set_cursor_from_row (w, row, w->current_matrix, 0, 0,
15042                                      dy, nrows_scrolled);
15043               else
15044                 {
15045                   clear_glyph_matrix (w->desired_matrix);
15046                   return 0;
15047                 }
15048             }
15049 
15050           /* Scroll the display.  Do it before the current matrix is
15051              changed.  The problem here is that update has not yet
15052              run, i.e. part of the current matrix is not up to date.
15053              scroll_run_hook will clear the cursor, and use the
15054              current matrix to get the height of the row the cursor is
15055              in.  */
15056           run.current_y = start_row->y;
15057           run.desired_y = it.current_y;
15058           run.height = it.last_visible_y - it.current_y;
15059 
15060           if (run.height > 0 && run.current_y != run.desired_y)
15061             {
15062               update_begin (f);
15063               FRAME_RIF (f)->update_window_begin_hook (w);
15064               FRAME_RIF (f)->clear_window_mouse_face (w);
15065               FRAME_RIF (f)->scroll_run_hook (w, &run);
15066               FRAME_RIF (f)->update_window_end_hook (w, 0, 0);
15067               update_end (f);
15068             }
15069 
15070           /* Shift current matrix down by nrows_scrolled lines.  */
15071           bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
15072           rotate_matrix (w->current_matrix,
15073                          start_vpos,
15074                          MATRIX_ROW_VPOS (bottom_row, w->current_matrix),
15075                          nrows_scrolled);
15076 
15077           /* Disable lines that must be updated.  */
15078           for (i = 0; i < nrows_scrolled; ++i)
15079             (start_row + i)->enabled_p = 0;
15080 
15081           /* Re-compute Y positions.  */
15082           min_y = WINDOW_HEADER_LINE_HEIGHT (w);
15083           max_y = it.last_visible_y;
15084           for (row = start_row + nrows_scrolled;
15085                row < bottom_row;
15086                ++row)
15087             {
15088               row->y = it.current_y;
15089               row->visible_height = row->height;
15090 
15091               if (row->y < min_y)
15092                 row->visible_height -= min_y - row->y;
15093               if (row->y + row->height > max_y)
15094                 row->visible_height -= row->y + row->height - max_y;
15095               row->redraw_fringe_bitmaps_p = 1;
15096 
15097               it.current_y += row->height;
15098 
15099               if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
15100                 last_reused_text_row = row;
15101               if (MATRIX_ROW_BOTTOM_Y (row) >= it.last_visible_y)
15102                 break;
15103             }
15104 
15105           /* Disable lines in the current matrix which are now
15106              below the window.  */
15107           for (++row; row < bottom_row; ++row)
15108             row->enabled_p = row->mode_line_p = 0;
15109         }
15110 
15111       /* Update window_end_pos etc.; last_reused_text_row is the last
15112          reused row from the current matrix containing text, if any.
15113          The value of last_text_row is the last displayed line
15114          containing text.  */
15115       if (last_reused_text_row)
15116         {
15117           w->window_end_bytepos
15118             = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_reused_text_row);
15119           w->window_end_pos
15120             = make_number (Z - MATRIX_ROW_END_CHARPOS (last_reused_text_row));
15121           w->window_end_vpos
15122             = make_number (MATRIX_ROW_VPOS (last_reused_text_row,
15123                                             w->current_matrix));
15124         }
15125       else if (last_text_row)
15126         {
15127           w->window_end_bytepos
15128             = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
15129           w->window_end_pos
15130             = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
15131           w->window_end_vpos
15132             = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
15133         }
15134       else
15135         {
15136           /* This window must be completely empty.  */
15137           w->window_end_bytepos = Z_BYTE - ZV_BYTE;
15138           w->window_end_pos = make_number (Z - ZV);
15139           w->window_end_vpos = make_number (0);
15140         }
15141       w->window_end_valid = Qnil;
15142 
15143       /* Update hint: don't try scrolling again in update_window.  */
15144       w->desired_matrix->no_scrolling_p = 1;
15145 
15146 #if GLYPH_DEBUG
15147       debug_method_add (w, "try_window_reusing_current_matrix 1");
15148 #endif
15149       return 1;
15150     }
15151   else if (CHARPOS (new_start) > CHARPOS (start))
15152     {
15153       struct glyph_row *pt_row, *row;
15154       struct glyph_row *first_reusable_row;
15155       struct glyph_row *first_row_to_display;
15156       int dy;
15157       int yb = window_text_bottom_y (w);
15158 
15159       /* Find the row starting at new_start, if there is one.  Don't
15160          reuse a partially visible line at the end.  */
15161       first_reusable_row = start_row;
15162       while (first_reusable_row->enabled_p
15163              && MATRIX_ROW_BOTTOM_Y (first_reusable_row) < yb
15164              && (MATRIX_ROW_START_CHARPOS (first_reusable_row)
15165                  < CHARPOS (new_start)))
15166         ++first_reusable_row;
15167 
15168       /* Give up if there is no row to reuse.  */
15169       if (MATRIX_ROW_BOTTOM_Y (first_reusable_row) >= yb
15170           || !first_reusable_row->enabled_p
15171           || (MATRIX_ROW_START_CHARPOS (first_reusable_row)
15172               != CHARPOS (new_start)))
15173         return 0;
15174 
15175       /* We can reuse fully visible rows beginning with
15176          first_reusable_row to the end of the window.  Set
15177          first_row_to_display to the first row that cannot be reused.
15178          Set pt_row to the row containing point, if there is any.  */
15179       pt_row = NULL;
15180       for (first_row_to_display = first_reusable_row;
15181            MATRIX_ROW_BOTTOM_Y (first_row_to_display) < yb;
15182            ++first_row_to_display)
15183         {
15184           if (PT >= MATRIX_ROW_START_CHARPOS (first_row_to_display)
15185               && PT < MATRIX_ROW_END_CHARPOS (first_row_to_display))
15186             pt_row = first_row_to_display;
15187         }
15188 
15189       /* Start displaying at the start of first_row_to_display.  */
15190       xassert (first_row_to_display->y < yb);
15191       init_to_row_start (&it, w, first_row_to_display);
15192 
15193       nrows_scrolled = (MATRIX_ROW_VPOS (first_reusable_row, w->current_matrix)
15194                         - start_vpos);
15195       it.vpos = (MATRIX_ROW_VPOS (first_row_to_display, w->current_matrix)
15196                  - nrows_scrolled);
15197       it.current_y = (first_row_to_display->y - first_reusable_row->y
15198                       + WINDOW_HEADER_LINE_HEIGHT (w));
15199 
15200       /* Display lines beginning with first_row_to_display in the
15201          desired matrix.  Set last_text_row to the last row displayed
15202          that displays text.  */
15203       it.glyph_row = MATRIX_ROW (w->desired_matrix, it.vpos);
15204       if (pt_row == NULL)
15205         w->cursor.vpos = -1;
15206       last_text_row = NULL;
15207       while (it.current_y < it.last_visible_y && !fonts_changed_p)
15208         if (display_line (&it))
15209           last_text_row = it.glyph_row - 1;
15210 
15211       /* If point is in a reused row, adjust y and vpos of the cursor
15212          position.  */
15213       if (pt_row)
15214         {
15215           w->cursor.vpos -= nrows_scrolled;
15216           w->cursor.y -= first_reusable_row->y - start_row->y;
15217         }
15218 
15219       /* Give up if point isn't in a row displayed or reused.  (This
15220          also handles the case where w->cursor.vpos < nrows_scrolled
15221          after the calls to display_line, which can happen with scroll
15222          margins.  See bug#1295.)  */
15223       if (w->cursor.vpos < 0)
15224         {
15225           clear_glyph_matrix (w->desired_matrix);
15226           return 0;
15227         }
15228 
15229       /* Scroll the display.  */
15230       run.current_y = first_reusable_row->y;
15231       run.desired_y = WINDOW_HEADER_LINE_HEIGHT (w);
15232       run.height = it.last_visible_y - run.current_y;
15233       dy = run.current_y - run.desired_y;
15234 
15235       if (run.height)
15236         {
15237           update_begin (f);
15238           FRAME_RIF (f)->update_window_begin_hook (w);
15239           FRAME_RIF (f)->clear_window_mouse_face (w);
15240           FRAME_RIF (f)->scroll_run_hook (w, &run);
15241           FRAME_RIF (f)->update_window_end_hook (w, 0, 0);
15242           update_end (f);
15243         }
15244 
15245       /* Adjust Y positions of reused rows.  */
15246       bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
15247       min_y = WINDOW_HEADER_LINE_HEIGHT (w);
15248       max_y = it.last_visible_y;
15249       for (row = first_reusable_row; row < first_row_to_display; ++row)
15250         {
15251           row->y -= dy;
15252           row->visible_height = row->height;
15253           if (row->y < min_y)
15254             row->visible_height -= min_y - row->y;
15255           if (row->y + row->height > max_y)
15256             row->visible_height -= row->y + row->height - max_y;
15257           row->redraw_fringe_bitmaps_p = 1;
15258         }
15259 
15260       /* Scroll the current matrix.  */
15261       xassert (nrows_scrolled > 0);
15262       rotate_matrix (w->current_matrix,
15263                      start_vpos,
15264                      MATRIX_ROW_VPOS (bottom_row, w->current_matrix),
15265                      -nrows_scrolled);
15266 
15267       /* Disable rows not reused.  */
15268       for (row -= nrows_scrolled; row < bottom_row; ++row)
15269         row->enabled_p = 0;
15270 
15271       /* Point may have moved to a different line, so we cannot assume that
15272          the previous cursor position is valid; locate the correct row.  */
15273       if (pt_row)
15274         {
15275           for (row = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
15276                row < bottom_row && PT >= MATRIX_ROW_END_CHARPOS (row);
15277                row++)
15278             {
15279               w->cursor.vpos++;
15280               w->cursor.y = row->y;
15281             }
15282           if (row < bottom_row)
15283             {
15284               struct glyph *glyph = row->glyphs[TEXT_AREA] + w->cursor.hpos;
15285               struct glyph *end = glyph + row->used[TEXT_AREA];
15286 
15287               /* Can't use this optimization with bidi-reordered glyph
15288                  rows, unless cursor is already at point. */
15289               if (!NILP (XBUFFER (w->buffer)->bidi_display_reordering))
15290                 {
15291                   if (!(w->cursor.hpos >= 0
15292                         && w->cursor.hpos < row->used[TEXT_AREA]
15293                         && BUFFERP (glyph->object)
15294                         && glyph->charpos == PT))
15295                     return 0;
15296                 }
15297               else
15298                 for (; glyph < end
15299                        && (!BUFFERP (glyph->object)
15300                            || glyph->charpos < PT);
15301                      glyph++)
15302                   {
15303                     w->cursor.hpos++;
15304                     w->cursor.x += glyph->pixel_width;
15305                   }
15306             }
15307         }
15308 
15309       /* Adjust window end.  A null value of last_text_row means that
15310          the window end is in reused rows which in turn means that
15311          only its vpos can have changed.  */
15312       if (last_text_row)
15313         {
15314           w->window_end_bytepos
15315             = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
15316           w->window_end_pos
15317             = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
15318           w->window_end_vpos
15319             = make_number (MATRIX_ROW_VPOS (last_text_row, w->desired_matrix));
15320         }
15321       else
15322         {
15323           w->window_end_vpos
15324             = make_number (XFASTINT (w->window_end_vpos) - nrows_scrolled);
15325         }
15326 
15327       w->window_end_valid = Qnil;
15328       w->desired_matrix->no_scrolling_p = 1;
15329 
15330 #if GLYPH_DEBUG
15331       debug_method_add (w, "try_window_reusing_current_matrix 2");
15332 #endif
15333       return 1;
15334     }
15335 
15336   return 0;
15337 }
15338 
15339 
15340 
15341 /************************************************************************
15342    Window redisplay reusing current matrix when buffer has changed
15343  ************************************************************************/
15344 
15345 static struct glyph_row *find_last_unchanged_at_beg_row P_ ((struct window *));
15346 static struct glyph_row *find_first_unchanged_at_end_row P_ ((struct window *,
15347                                                              int *, int *));
15348 static struct glyph_row *
15349 find_last_row_displaying_text P_ ((struct glyph_matrix *, struct it *,
15350                                    struct glyph_row *));
15351 
15352 
15353 /* Return the last row in MATRIX displaying text.  If row START is
15354    non-null, start searching with that row.  IT gives the dimensions
15355    of the display.  Value is null if matrix is empty; otherwise it is
15356    a pointer to the row found.  */
15357 
15358 static struct glyph_row *
15359 find_last_row_displaying_text (matrix, it, start)
15360      struct glyph_matrix *matrix;
15361      struct it *it;
15362      struct glyph_row *start;
15363 {
15364   struct glyph_row *row, *row_found;
15365 
15366   /* Set row_found to the last row in IT->w's current matrix
15367      displaying text.  The loop looks funny but think of partially
15368      visible lines.  */
15369   row_found = NULL;
15370   row = start ? start : MATRIX_FIRST_TEXT_ROW (matrix);
15371   while (MATRIX_ROW_DISPLAYS_TEXT_P (row))
15372     {
15373       xassert (row->enabled_p);
15374       row_found = row;
15375       if (MATRIX_ROW_BOTTOM_Y (row) >= it->last_visible_y)
15376         break;
15377       ++row;
15378     }
15379 
15380   return row_found;
15381 }
15382 
15383 
15384 /* Return the last row in the current matrix of W that is not affected
15385    by changes at the start of current_buffer that occurred since W's
15386    current matrix was built.  Value is null if no such row exists.
15387 
15388    BEG_UNCHANGED us the number of characters unchanged at the start of
15389    current_buffer.  BEG + BEG_UNCHANGED is the buffer position of the
15390    first changed character in current_buffer.  Characters at positions <
15391    BEG + BEG_UNCHANGED are at the same buffer positions as they were
15392    when the current matrix was built.  */
15393 
15394 static struct glyph_row *
15395 find_last_unchanged_at_beg_row (w)
15396      struct window *w;
15397 {
15398   int first_changed_pos = BEG + BEG_UNCHANGED;
15399   struct glyph_row *row;
15400   struct glyph_row *row_found = NULL;
15401   int yb = window_text_bottom_y (w);
15402 
15403   /* Find the last row displaying unchanged text.  */
15404   for (row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
15405        MATRIX_ROW_DISPLAYS_TEXT_P (row)
15406          && MATRIX_ROW_START_CHARPOS (row) < first_changed_pos;
15407        ++row)
15408     {
15409       if (/* If row ends before first_changed_pos, it is unchanged,
15410              except in some case.  */
15411           MATRIX_ROW_END_CHARPOS (row) <= first_changed_pos
15412           /* When row ends in ZV and we write at ZV it is not
15413              unchanged.  */
15414           && !row->ends_at_zv_p
15415           /* When first_changed_pos is the end of a continued line,
15416              row is not unchanged because it may be no longer
15417              continued.  */
15418           && !(MATRIX_ROW_END_CHARPOS (row) == first_changed_pos
15419                && (row->continued_p
15420                    || row->exact_window_width_line_p)))
15421         row_found = row;
15422 
15423       /* Stop if last visible row.  */
15424       if (MATRIX_ROW_BOTTOM_Y (row) >= yb)
15425         break;
15426     }
15427 
15428   return row_found;
15429 }
15430 
15431 
15432 /* Find the first glyph row in the current matrix of W that is not
15433    affected by changes at the end of current_buffer since the
15434    time W's current matrix was built.
15435 
15436    Return in *DELTA the number of chars by which buffer positions in
15437    unchanged text at the end of current_buffer must be adjusted.
15438 
15439    Return in *DELTA_BYTES the corresponding number of bytes.
15440 
15441    Value is null if no such row exists, i.e. all rows are affected by
15442    changes.  */
15443 
15444 static struct glyph_row *
15445 find_first_unchanged_at_end_row (w, delta, delta_bytes)
15446      struct window *w;
15447      int *delta, *delta_bytes;
15448 {
15449   struct glyph_row *row;
15450   struct glyph_row *row_found = NULL;
15451 
15452   *delta = *delta_bytes = 0;
15453 
15454   /* Display must not have been paused, otherwise the current matrix
15455      is not up to date.  */
15456   eassert (!NILP (w->window_end_valid));
15457 
15458   /* A value of window_end_pos >= END_UNCHANGED means that the window
15459      end is in the range of changed text.  If so, there is no
15460      unchanged row at the end of W's current matrix.  */
15461   if (XFASTINT (w->window_end_pos) >= END_UNCHANGED)
15462     return NULL;
15463 
15464   /* Set row to the last row in W's current matrix displaying text.  */
15465   row = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
15466 
15467   /* If matrix is entirely empty, no unchanged row exists.  */
15468   if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
15469     {
15470       /* The value of row is the last glyph row in the matrix having a
15471          meaningful buffer position in it.  The end position of row
15472          corresponds to window_end_pos.  This allows us to translate
15473          buffer positions in the current matrix to current buffer
15474          positions for characters not in changed text.  */
15475       int Z_old = MATRIX_ROW_END_CHARPOS (row) + XFASTINT (w->window_end_pos);
15476       int Z_BYTE_old = MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
15477       int last_unchanged_pos, last_unchanged_pos_old;
15478       struct glyph_row *first_text_row
15479         = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
15480 
15481       *delta = Z - Z_old;
15482       *delta_bytes = Z_BYTE - Z_BYTE_old;
15483 
15484       /* Set last_unchanged_pos to the buffer position of the last
15485          character in the buffer that has not been changed.  Z is the
15486          index + 1 of the last character in current_buffer, i.e. by
15487          subtracting END_UNCHANGED we get the index of the last
15488          unchanged character, and we have to add BEG to get its buffer
15489          position.  */
15490       last_unchanged_pos = Z - END_UNCHANGED + BEG;
15491       last_unchanged_pos_old = last_unchanged_pos - *delta;
15492 
15493       /* Search backward from ROW for a row displaying a line that
15494          starts at a minimum position >= last_unchanged_pos_old.  */
15495       for (; row > first_text_row; --row)
15496         {
15497           /* This used to abort, but it can happen.
15498              It is ok to just stop the search instead here.  KFS.  */
15499           if (!row->enabled_p || !MATRIX_ROW_DISPLAYS_TEXT_P (row))
15500             break;
15501 
15502           if (MATRIX_ROW_START_CHARPOS (row) >= last_unchanged_pos_old)
15503             row_found = row;
15504         }
15505     }
15506 
15507   eassert (!row_found || MATRIX_ROW_DISPLAYS_TEXT_P (row_found));
15508 
15509   return row_found;
15510 }
15511 
15512 
15513 /* Make sure that glyph rows in the current matrix of window W
15514    reference the same glyph memory as corresponding rows in the
15515    frame's frame matrix.  This function is called after scrolling W's
15516    current matrix on a terminal frame in try_window_id and
15517    try_window_reusing_current_matrix.  */
15518 
15519 static void
15520 sync_frame_with_window_matrix_rows (w)
15521      struct window *w;
15522 {
15523   struct frame *f = XFRAME (w->frame);
15524   struct glyph_row *window_row, *window_row_end, *frame_row;
15525 
15526   /* Preconditions: W must be a leaf window and full-width.  Its frame
15527      must have a frame matrix.  */
15528   xassert (NILP (w->hchild) && NILP (w->vchild));
15529   xassert (WINDOW_FULL_WIDTH_P (w));
15530   xassert (!FRAME_WINDOW_P (f));
15531 
15532   /* If W is a full-width window, glyph pointers in W's current matrix
15533      have, by definition, to be the same as glyph pointers in the
15534      corresponding frame matrix.  Note that frame matrices have no
15535      marginal areas (see build_frame_matrix).  */
15536   window_row = w->current_matrix->rows;
15537   window_row_end = window_row + w->current_matrix->nrows;
15538   frame_row = f->current_matrix->rows + WINDOW_TOP_EDGE_LINE (w);
15539   while (window_row < window_row_end)
15540     {
15541       struct glyph *start = window_row->glyphs[LEFT_MARGIN_AREA];
15542       struct glyph *end = window_row->glyphs[LAST_AREA];
15543 
15544       frame_row->glyphs[LEFT_MARGIN_AREA] = start;
15545       frame_row->glyphs[TEXT_AREA] = start;
15546       frame_row->glyphs[RIGHT_MARGIN_AREA] = end;
15547       frame_row->glyphs[LAST_AREA] = end;
15548 
15549       /* Disable frame rows whose corresponding window rows have
15550          been disabled in try_window_id.  */
15551       if (!window_row->enabled_p)
15552         frame_row->enabled_p = 0;
15553 
15554       ++window_row, ++frame_row;
15555     }
15556 }
15557 
15558 
15559 /* Find the glyph row in window W containing CHARPOS.  Consider all
15560    rows between START and END (not inclusive).  END null means search
15561    all rows to the end of the display area of W.  Value is the row
15562    containing CHARPOS or null.  */
15563 
15564 struct glyph_row *
15565 row_containing_pos (w, charpos, start, end, dy)
15566      struct window *w;
15567      int charpos;
15568      struct glyph_row *start, *end;
15569      int dy;
15570 {
15571   struct glyph_row *row = start;
15572   struct glyph_row *best_row = NULL;
15573   EMACS_INT mindif = BUF_ZV (XBUFFER (w->buffer)) + 1;
15574   int last_y;
15575 
15576   /* If we happen to start on a header-line, skip that.  */
15577   if (row->mode_line_p)
15578     ++row;
15579 
15580   if ((end && row >= end) || !row->enabled_p)
15581     return NULL;
15582 
15583   last_y = window_text_bottom_y (w) - dy;
15584 
15585   while (1)
15586     {
15587       /* Give up if we have gone too far.  */
15588       if (end && row >= end)
15589         return NULL;
15590       /* This formerly returned if they were equal.
15591          I think that both quantities are of a "last plus one" type;
15592          if so, when they are equal, the row is within the screen. -- rms.  */
15593       if (MATRIX_ROW_BOTTOM_Y (row) > last_y)
15594         return NULL;
15595 
15596       /* If it is in this row, return this row.  */
15597       if (! (MATRIX_ROW_END_CHARPOS (row) < charpos
15598              || (MATRIX_ROW_END_CHARPOS (row) == charpos
15599                  /* The end position of a row equals the start
15600                     position of the next row.  If CHARPOS is there, we
15601                     would rather display it in the next line, except
15602                     when this line ends in ZV.  */
15603                  && !row->ends_at_zv_p
15604                  && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
15605           && charpos >= MATRIX_ROW_START_CHARPOS (row))
15606         {
15607           struct glyph *g;
15608 
15609           if (NILP (XBUFFER (w->buffer)->bidi_display_reordering))
15610             return row;
15611           /* In bidi-reordered rows, there could be several rows
15612              occluding point.  We need to find the one which fits
15613              CHARPOS the best.  */
15614           for (g = row->glyphs[TEXT_AREA];
15615                g < row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
15616                g++)
15617             {
15618               if (!STRINGP (g->object))
15619                 {
15620                   if (g->charpos > 0 && eabs (g->charpos - charpos) < mindif)
15621                     {
15622                       mindif = eabs (g->charpos - charpos);
15623                       best_row = row;
15624                     }
15625                 }
15626             }
15627         }
15628       else if (best_row)
15629         return best_row;
15630       ++row;
15631     }
15632 }
15633 
15634 
15635 /* Try to redisplay window W by reusing its existing display.  W's
15636    current matrix must be up to date when this function is called,
15637    i.e. window_end_valid must not be nil.
15638 
15639    Value is
15640 
15641    1    if display has been updated
15642    0    if otherwise unsuccessful
15643    -1   if redisplay with same window start is known not to succeed
15644 
15645    The following steps are performed:
15646 
15647    1. Find the last row in the current matrix of W that is not
15648    affected by changes at the start of current_buffer.  If no such row
15649    is found, give up.
15650 
15651    2. Find the first row in W's current matrix that is not affected by
15652    changes at the end of current_buffer.  Maybe there is no such row.
15653 
15654    3. Display lines beginning with the row + 1 found in step 1 to the
15655    row found in step 2 or, if step 2 didn't find a row, to the end of
15656    the window.
15657 
15658    4. If cursor is not known to appear on the window, give up.
15659 
15660    5. If display stopped at the row found in step 2, scroll the
15661    display and current matrix as needed.
15662 
15663    6. Maybe display some lines at the end of W, if we must.  This can
15664    happen under various circumstances, like a partially visible line
15665    becoming fully visible, or because newly displayed lines are displayed
15666    in smaller font sizes.
15667 
15668    7. Update W's window end information.  */
15669 
15670 static int
15671 try_window_id (w)
15672      struct window *w;
15673 {
15674   struct frame *f = XFRAME (w->frame);
15675   struct glyph_matrix *current_matrix = w->current_matrix;
15676   struct glyph_matrix *desired_matrix = w->desired_matrix;
15677   struct glyph_row *last_unchanged_at_beg_row;
15678   struct glyph_row *first_unchanged_at_end_row;
15679   struct glyph_row *row;
15680   struct glyph_row *bottom_row;
15681   int bottom_vpos;
15682   struct it it;
15683   int delta = 0, delta_bytes = 0, stop_pos, dvpos, dy;
15684   struct text_pos start_pos;
15685   struct run run;
15686   int first_unchanged_at_end_vpos = 0;
15687   struct glyph_row *last_text_row, *last_text_row_at_end;
15688   struct text_pos start;
15689   int first_changed_charpos, last_changed_charpos;
15690 
15691 #if GLYPH_DEBUG
15692   if (inhibit_try_window_id)
15693     return 0;
15694 #endif
15695 
15696   /* This is handy for debugging.  */
15697 #if 0
15698 #define GIVE_UP(X)                                              \
15699   do {                                                          \
15700     fprintf (stderr, "try_window_id give up %d\n", (X));        \
15701     return 0;                                                   \
15702   } while (0)
15703 #else
15704 #define GIVE_UP(X) return 0
15705 #endif
15706 
15707   SET_TEXT_POS_FROM_MARKER (start, w->start);
15708 
15709   /* Don't use this for mini-windows because these can show
15710      messages and mini-buffers, and we don't handle that here.  */
15711   if (MINI_WINDOW_P (w))
15712     GIVE_UP (1);
15713 
15714   /* This flag is used to prevent redisplay optimizations.  */
15715   if (windows_or_buffers_changed || cursor_type_changed)
15716     GIVE_UP (2);
15717 
15718   /* Verify that narrowing has not changed.
15719      Also verify that we were not told to prevent redisplay optimizations.
15720      It would be nice to further
15721      reduce the number of cases where this prevents try_window_id.  */
15722   if (current_buffer->clip_changed
15723       || current_buffer->prevent_redisplay_optimizations_p)
15724     GIVE_UP (3);
15725 
15726   /* Window must either use window-based redisplay or be full width.  */
15727   if (!FRAME_WINDOW_P (f)
15728       && (!FRAME_LINE_INS_DEL_OK (f)
15729           || !WINDOW_FULL_WIDTH_P (w)))
15730     GIVE_UP (4);
15731 
15732   /* Give up if point is known NOT to appear in W.  */
15733   if (PT < CHARPOS (start))
15734     GIVE_UP (5);
15735 
15736   /* Another way to prevent redisplay optimizations.  */
15737   if (XFASTINT (w->last_modified) == 0)
15738     GIVE_UP (6);
15739 
15740   /* Verify that window is not hscrolled.  */
15741   if (XFASTINT (w->hscroll) != 0)
15742     GIVE_UP (7);
15743 
15744   /* Verify that display wasn't paused.  */
15745   if (NILP (w->window_end_valid))
15746     GIVE_UP (8);
15747 
15748   /* Can't use this if highlighting a region because a cursor movement
15749      will do more than just set the cursor.  */
15750   if (!NILP (Vtransient_mark_mode)
15751       && !NILP (current_buffer->mark_active))
15752     GIVE_UP (9);
15753 
15754   /* Likewise if highlighting trailing whitespace.  */
15755   if (!NILP (Vshow_trailing_whitespace))
15756     GIVE_UP (11);
15757 
15758   /* Likewise if showing a region.  */
15759   if (!NILP (w->region_showing))
15760     GIVE_UP (10);
15761 
15762   /* Can't use this if overlay arrow position and/or string have
15763      changed.  */
15764   if (overlay_arrows_changed_p ())
15765     GIVE_UP (12);
15766 
15767   /* When word-wrap is on, adding a space to the first word of a
15768      wrapped line can change the wrap position, altering the line
15769      above it.  It might be worthwhile to handle this more
15770      intelligently, but for now just redisplay from scratch.  */
15771   if (!NILP (XBUFFER (w->buffer)->word_wrap))
15772     GIVE_UP (21);
15773 
15774   /* Under bidi reordering, adding or deleting a character in the
15775      beginning of a paragraph, before the first strong directional
15776      character, can change the base direction of the paragraph (unless
15777      the buffer specifies a fixed paragraph direction), which will
15778      require to redisplay the whole paragraph.  It might be worthwhile
15779      to find the paragraph limits and widen the range of redisplayed
15780      lines to that, but for now just give up this optimization and
15781      redisplay from scratch.  */
15782   if (!NILP (XBUFFER (w->buffer)->bidi_display_reordering)
15783       && NILP (XBUFFER (w->buffer)->bidi_paragraph_direction))
15784     GIVE_UP (22);
15785 
15786   /* Make sure beg_unchanged and end_unchanged are up to date.  Do it
15787      only if buffer has really changed.  The reason is that the gap is
15788      initially at Z for freshly visited files.  The code below would
15789      set end_unchanged to 0 in that case.  */
15790   if (MODIFF > SAVE_MODIFF
15791       /* This seems to happen sometimes after saving a buffer.  */
15792       || BEG_UNCHANGED + END_UNCHANGED > Z_BYTE)
15793     {
15794       if (GPT - BEG < BEG_UNCHANGED)
15795         BEG_UNCHANGED = GPT - BEG;
15796       if (Z - GPT < END_UNCHANGED)
15797         END_UNCHANGED = Z - GPT;
15798     }
15799 
15800   /* The position of the first and last character that has been changed.  */
15801   first_changed_charpos = BEG + BEG_UNCHANGED;
15802   last_changed_charpos  = Z - END_UNCHANGED;
15803 
15804   /* If window starts after a line end, and the last change is in
15805      front of that newline, then changes don't affect the display.
15806      This case happens with stealth-fontification.  Note that although
15807      the display is unchanged, glyph positions in the matrix have to
15808      be adjusted, of course.  */
15809   row = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
15810   if (MATRIX_ROW_DISPLAYS_TEXT_P (row)
15811       && ((last_changed_charpos < CHARPOS (start)
15812            && CHARPOS (start) == BEGV)
15813           || (last_changed_charpos < CHARPOS (start) - 1
15814               && FETCH_BYTE (BYTEPOS (start) - 1) == '\n')))
15815     {
15816       int Z_old, delta, Z_BYTE_old, delta_bytes;
15817       struct glyph_row *r0;
15818 
15819       /* Compute how many chars/bytes have been added to or removed
15820          from the buffer.  */
15821       Z_old = MATRIX_ROW_END_CHARPOS (row) + XFASTINT (w->window_end_pos);
15822       Z_BYTE_old = MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
15823       delta = Z - Z_old;
15824       delta_bytes = Z_BYTE - Z_BYTE_old;
15825 
15826       /* Give up if PT is not in the window.  Note that it already has
15827          been checked at the start of try_window_id that PT is not in
15828          front of the window start.  */
15829       if (PT >= MATRIX_ROW_END_CHARPOS (row) + delta)
15830         GIVE_UP (13);
15831 
15832       /* If window start is unchanged, we can reuse the whole matrix
15833          as is, after adjusting glyph positions.  No need to compute
15834          the window end again, since its offset from Z hasn't changed.  */
15835       r0 = MATRIX_FIRST_TEXT_ROW (current_matrix);
15836       if (CHARPOS (start) == MATRIX_ROW_START_CHARPOS (r0) + delta
15837           && BYTEPOS (start) == MATRIX_ROW_START_BYTEPOS (r0) + delta_bytes
15838           /* PT must not be in a partially visible line.  */
15839           && !(PT >= MATRIX_ROW_START_CHARPOS (row) + delta
15840                && MATRIX_ROW_BOTTOM_Y (row) > window_text_bottom_y (w)))
15841         {
15842           /* Adjust positions in the glyph matrix.  */
15843           if (delta || delta_bytes)
15844             {
15845               struct glyph_row *r1
15846                 = MATRIX_BOTTOM_TEXT_ROW (current_matrix, w);
15847               increment_matrix_positions (w->current_matrix,
15848                                           MATRIX_ROW_VPOS (r0, current_matrix),
15849                                           MATRIX_ROW_VPOS (r1, current_matrix),
15850                                           delta, delta_bytes);
15851             }
15852 
15853           /* Set the cursor.  */
15854           row = row_containing_pos (w, PT, r0, NULL, 0);
15855           if (row)
15856             set_cursor_from_row (w, row, current_matrix, 0, 0, 0, 0);
15857           else
15858             abort ();
15859           return 1;
15860         }
15861     }
15862 
15863   /* Handle the case that changes are all below what is displayed in
15864      the window, and that PT is in the window.  This shortcut cannot
15865      be taken if ZV is visible in the window, and text has been added
15866      there that is visible in the window.  */
15867   if (first_changed_charpos >= MATRIX_ROW_END_CHARPOS (row)
15868       /* ZV is not visible in the window, or there are no
15869          changes at ZV, actually.  */
15870       && (current_matrix->zv > MATRIX_ROW_END_CHARPOS (row)
15871           || first_changed_charpos == last_changed_charpos))
15872     {
15873       struct glyph_row *r0;
15874 
15875       /* Give up if PT is not in the window.  Note that it already has
15876          been checked at the start of try_window_id that PT is not in
15877          front of the window start.  */
15878       if (PT >= MATRIX_ROW_END_CHARPOS (row))
15879         GIVE_UP (14);
15880 
15881       /* If window start is unchanged, we can reuse the whole matrix
15882          as is, without changing glyph positions since no text has
15883          been added/removed in front of the window end.  */
15884       r0 = MATRIX_FIRST_TEXT_ROW (current_matrix);
15885       if (TEXT_POS_EQUAL_P (start, r0->minpos)
15886           /* PT must not be in a partially visible line.  */
15887           && !(PT >= MATRIX_ROW_START_CHARPOS (row)
15888                && MATRIX_ROW_BOTTOM_Y (row) > window_text_bottom_y (w)))
15889         {
15890           /* We have to compute the window end anew since text
15891              could have been added/removed after it.  */
15892           w->window_end_pos
15893             = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
15894           w->window_end_bytepos
15895             = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
15896 
15897           /* Set the cursor.  */
15898           row = row_containing_pos (w, PT, r0, NULL, 0);
15899           if (row)
15900             set_cursor_from_row (w, row, current_matrix, 0, 0, 0, 0);
15901           else
15902             abort ();
15903           return 2;
15904         }
15905     }
15906 
15907   /* Give up if window start is in the changed area.
15908 
15909      The condition used to read
15910 
15911      (BEG_UNCHANGED + END_UNCHANGED != Z - BEG && ...)
15912 
15913      but why that was tested escapes me at the moment.  */
15914   if (CHARPOS (start) >= first_changed_charpos
15915       && CHARPOS (start) <= last_changed_charpos)
15916     GIVE_UP (15);
15917 
15918   /* Check that window start agrees with the start of the first glyph
15919      row in its current matrix.  Check this after we know the window
15920      start is not in changed text, otherwise positions would not be
15921      comparable.  */
15922   row = MATRIX_FIRST_TEXT_ROW (current_matrix);
15923   if (!TEXT_POS_EQUAL_P (start, row->minpos))
15924     GIVE_UP (16);
15925 
15926   /* Give up if the window ends in strings.  Overlay strings
15927      at the end are difficult to handle, so don't try.  */
15928   row = MATRIX_ROW (current_matrix, XFASTINT (w->window_end_vpos));
15929   if (MATRIX_ROW_START_CHARPOS (row) == MATRIX_ROW_END_CHARPOS (row))
15930     GIVE_UP (20);
15931 
15932   /* Compute the position at which we have to start displaying new
15933      lines.  Some of the lines at the top of the window might be
15934      reusable because they are not displaying changed text.  Find the
15935      last row in W's current matrix not affected by changes at the
15936      start of current_buffer.  Value is null if changes start in the
15937      first line of window.  */
15938   last_unchanged_at_beg_row = find_last_unchanged_at_beg_row (w);
15939   if (last_unchanged_at_beg_row)
15940     {
15941       /* Avoid starting to display in the moddle of a character, a TAB
15942          for instance.  This is easier than to set up the iterator
15943          exactly, and it's not a frequent case, so the additional
15944          effort wouldn't really pay off.  */
15945       while ((MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row)
15946               || last_unchanged_at_beg_row->ends_in_newline_from_string_p)
15947              && last_unchanged_at_beg_row > w->current_matrix->rows)
15948         --last_unchanged_at_beg_row;
15949 
15950       if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row))
15951         GIVE_UP (17);
15952 
15953       if (init_to_row_end (&it, w, last_unchanged_at_beg_row) == 0)
15954         GIVE_UP (18);
15955       start_pos = it.current.pos;
15956 
15957       /* Start displaying new lines in the desired matrix at the same
15958          vpos we would use in the current matrix, i.e. below
15959          last_unchanged_at_beg_row.  */
15960       it.vpos = 1 + MATRIX_ROW_VPOS (last_unchanged_at_beg_row,
15961                                      current_matrix);
15962       it.glyph_row = MATRIX_ROW (desired_matrix, it.vpos);
15963       it.current_y = MATRIX_ROW_BOTTOM_Y (last_unchanged_at_beg_row);
15964 
15965       xassert (it.hpos == 0 && it.current_x == 0);
15966     }
15967   else
15968     {
15969       /* There are no reusable lines at the start of the window.
15970          Start displaying in the first text line.  */
15971       start_display (&it, w, start);
15972       it.vpos = it.first_vpos;
15973       start_pos = it.current.pos;
15974     }
15975 
15976   /* Find the first row that is not affected by changes at the end of
15977      the buffer.  Value will be null if there is no unchanged row, in
15978      which case we must redisplay to the end of the window.  delta
15979      will be set to the value by which buffer positions beginning with
15980      first_unchanged_at_end_row have to be adjusted due to text
15981      changes.  */
15982   first_unchanged_at_end_row
15983     = find_first_unchanged_at_end_row (w, &delta, &delta_bytes);
15984   IF_DEBUG (debug_delta = delta);
15985   IF_DEBUG (debug_delta_bytes = delta_bytes);
15986 
15987   /* Set stop_pos to the buffer position up to which we will have to
15988      display new lines.  If first_unchanged_at_end_row != NULL, this
15989      is the buffer position of the start of the line displayed in that
15990      row.  For first_unchanged_at_end_row == NULL, use 0 to indicate
15991      that we don't stop at a buffer position.  */
15992   stop_pos = 0;
15993   if (first_unchanged_at_end_row)
15994     {
15995       xassert (last_unchanged_at_beg_row == NULL
15996                || first_unchanged_at_end_row >= last_unchanged_at_beg_row);
15997 
15998       /* If this is a continuation line, move forward to the next one
15999          that isn't.  Changes in lines above affect this line.
16000          Caution: this may move first_unchanged_at_end_row to a row
16001          not displaying text.  */
16002       while (MATRIX_ROW_CONTINUATION_LINE_P (first_unchanged_at_end_row)
16003              && MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row)
16004              && (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row)
16005                  < it.last_visible_y))
16006         ++first_unchanged_at_end_row;
16007 
16008       if (!MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row)
16009           || (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row)
16010               >= it.last_visible_y))
16011         first_unchanged_at_end_row = NULL;
16012       else
16013         {
16014           stop_pos = (MATRIX_ROW_START_CHARPOS (first_unchanged_at_end_row)
16015                       + delta);
16016           first_unchanged_at_end_vpos
16017             = MATRIX_ROW_VPOS (first_unchanged_at_end_row, current_matrix);
16018           xassert (stop_pos >= Z - END_UNCHANGED);
16019         }
16020     }
16021   else if (last_unchanged_at_beg_row == NULL)
16022     GIVE_UP (19);
16023 
16024 
16025 #if GLYPH_DEBUG
16026 
16027   /* Either there is no unchanged row at the end, or the one we have
16028      now displays text.  This is a necessary condition for the window
16029      end pos calculation at the end of this function.  */
16030   xassert (first_unchanged_at_end_row == NULL
16031            || MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row));
16032 
16033   debug_last_unchanged_at_beg_vpos
16034     = (last_unchanged_at_beg_row
16035        ? MATRIX_ROW_VPOS (last_unchanged_at_beg_row, current_matrix)
16036        : -1);
16037   debug_first_unchanged_at_end_vpos = first_unchanged_at_end_vpos;
16038 
16039 #endif /* GLYPH_DEBUG != 0 */
16040 
16041 
16042   /* Display new lines.  Set last_text_row to the last new line
16043      displayed which has text on it, i.e. might end up as being the
16044      line where the window_end_vpos is.  */
16045   w->cursor.vpos = -1;
16046   last_text_row = NULL;
16047   overlay_arrow_seen = 0;
16048   while (it.current_y < it.last_visible_y
16049          && !fonts_changed_p
16050          && (first_unchanged_at_end_row == NULL
16051              || IT_CHARPOS (it) < stop_pos))
16052     {
16053       if (display_line (&it))
16054         last_text_row = it.glyph_row - 1;
16055     }
16056 
16057   if (fonts_changed_p)
16058     return -1;
16059 
16060 
16061   /* Compute differences in buffer positions, y-positions etc.  for
16062      lines reused at the bottom of the window.  Compute what we can
16063      scroll.  */
16064   if (first_unchanged_at_end_row
16065       /* No lines reused because we displayed everything up to the
16066          bottom of the window.  */
16067       && it.current_y < it.last_visible_y)
16068     {
16069       dvpos = (it.vpos
16070                - MATRIX_ROW_VPOS (first_unchanged_at_end_row,
16071                                   current_matrix));
16072       dy = it.current_y - first_unchanged_at_end_row->y;
16073       run.current_y = first_unchanged_at_end_row->y;
16074       run.desired_y = run.current_y + dy;
16075       run.height = it.last_visible_y - max (run.current_y, run.desired_y);
16076     }
16077   else
16078     {
16079       delta = delta_bytes = dvpos = dy
16080         = run.current_y = run.desired_y = run.height = 0;
16081       first_unchanged_at_end_row = NULL;
16082     }
16083   IF_DEBUG (debug_dvpos = dvpos; debug_dy = dy);
16084 
16085 
16086   /* Find the cursor if not already found.  We have to decide whether
16087      PT will appear on this window (it sometimes doesn't, but this is
16088      not a very frequent case.)  This decision has to be made before
16089      the current matrix is altered.  A value of cursor.vpos < 0 means
16090      that PT is either in one of the lines beginning at
16091      first_unchanged_at_end_row or below the window.  Don't care for
16092      lines that might be displayed later at the window end; as
16093      mentioned, this is not a frequent case.  */
16094   if (w->cursor.vpos < 0)
16095     {
16096       /* Cursor in unchanged rows at the top?  */
16097       if (PT < CHARPOS (start_pos)
16098           && last_unchanged_at_beg_row)
16099         {
16100           row = row_containing_pos (w, PT,
16101                                     MATRIX_FIRST_TEXT_ROW (w->current_matrix),
16102                                     last_unchanged_at_beg_row + 1, 0);
16103           if (row)
16104             set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
16105         }
16106 
16107       /* Start from first_unchanged_at_end_row looking for PT.  */
16108       else if (first_unchanged_at_end_row)
16109         {
16110           row = row_containing_pos (w, PT - delta,
16111                                     first_unchanged_at_end_row, NULL, 0);
16112           if (row)
16113             set_cursor_from_row (w, row, w->current_matrix, delta,
16114                                  delta_bytes, dy, dvpos);
16115         }
16116 
16117       /* Give up if cursor was not found.  */
16118       if (w->cursor.vpos < 0)
16119         {
16120           clear_glyph_matrix (w->desired_matrix);
16121           return -1;
16122         }
16123     }
16124 
16125   /* Don't let the cursor end in the scroll margins.  */
16126   {
16127     int this_scroll_margin, cursor_height;
16128 
16129     this_scroll_margin = max (0, scroll_margin);
16130     this_scroll_margin = min (this_scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
16131     this_scroll_margin *= FRAME_LINE_HEIGHT (it.f);
16132     cursor_height = MATRIX_ROW (w->desired_matrix, w->cursor.vpos)->height;
16133 
16134     if ((w->cursor.y < this_scroll_margin
16135          && CHARPOS (start) > BEGV)
16136         /* Old redisplay didn't take scroll margin into account at the bottom,
16137            but then global-hl-line-mode doesn't scroll.  KFS 2004-06-14 */
16138         || (w->cursor.y + (make_cursor_line_fully_visible_p
16139                            ? cursor_height + this_scroll_margin
16140                            : 1)) > it.last_visible_y)
16141       {
16142         w->cursor.vpos = -1;
16143         clear_glyph_matrix (w->desired_matrix);
16144         return -1;
16145       }
16146   }
16147 
16148   /* Scroll the display.  Do it before changing the current matrix so
16149      that xterm.c doesn't get confused about where the cursor glyph is
16150      found.  */
16151   if (dy && run.height)
16152     {
16153       update_begin (f);
16154 
16155       if (FRAME_WINDOW_P (f))
16156         {
16157           FRAME_RIF (f)->update_window_begin_hook (w);
16158           FRAME_RIF (f)->clear_window_mouse_face (w);
16159           FRAME_RIF (f)->scroll_run_hook (w, &run);
16160           FRAME_RIF (f)->update_window_end_hook (w, 0, 0);
16161         }
16162       else
16163         {
16164           /* Terminal frame.  In this case, dvpos gives the number of
16165              lines to scroll by; dvpos < 0 means scroll up.  */
16166           int first_unchanged_at_end_vpos
16167             = MATRIX_ROW_VPOS (first_unchanged_at_end_row, w->current_matrix);
16168           int from = WINDOW_TOP_EDGE_LINE (w) + first_unchanged_at_end_vpos;
16169           int end = (WINDOW_TOP_EDGE_LINE (w)
16170                      + (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0)
16171                      + window_internal_height (w));
16172 
16173           /* Perform the operation on the screen.  */
16174           if (dvpos > 0)
16175             {
16176               /* Scroll last_unchanged_at_beg_row to the end of the
16177                  window down dvpos lines.  */
16178               set_terminal_window (f, end);
16179 
16180               /* On dumb terminals delete dvpos lines at the end
16181                  before inserting dvpos empty lines.  */
16182               if (!FRAME_SCROLL_REGION_OK (f))
16183                 ins_del_lines (f, end - dvpos, -dvpos);
16184 
16185               /* Insert dvpos empty lines in front of
16186                  last_unchanged_at_beg_row.  */
16187               ins_del_lines (f, from, dvpos);
16188             }
16189           else if (dvpos < 0)
16190             {
16191               /* Scroll up last_unchanged_at_beg_vpos to the end of
16192                  the window to last_unchanged_at_beg_vpos - |dvpos|.  */
16193               set_terminal_window (f, end);
16194 
16195               /* Delete dvpos lines in front of
16196                  last_unchanged_at_beg_vpos.  ins_del_lines will set
16197                  the cursor to the given vpos and emit |dvpos| delete
16198                  line sequences.  */
16199               ins_del_lines (f, from + dvpos, dvpos);
16200 
16201               /* On a dumb terminal insert dvpos empty lines at the
16202                  end.  */
16203               if (!FRAME_SCROLL_REGION_OK (f))
16204                 ins_del_lines (f, end + dvpos, -dvpos);
16205             }
16206 
16207           set_terminal_window (f, 0);
16208         }
16209 
16210       update_end (f);
16211     }
16212 
16213   /* Shift reused rows of the current matrix to the right position.
16214      BOTTOM_ROW is the last + 1 row in the current matrix reserved for
16215      text.  */
16216   bottom_row = MATRIX_BOTTOM_TEXT_ROW (current_matrix, w);
16217   bottom_vpos = MATRIX_ROW_VPOS (bottom_row, current_matrix);
16218   if (dvpos < 0)
16219     {
16220       rotate_matrix (current_matrix, first_unchanged_at_end_vpos + dvpos,
16221                      bottom_vpos, dvpos);
16222       enable_glyph_matrix_rows (current_matrix, bottom_vpos + dvpos,
16223                                 bottom_vpos, 0);
16224     }
16225   else if (dvpos > 0)
16226     {
16227       rotate_matrix (current_matrix, first_unchanged_at_end_vpos,
16228                      bottom_vpos, dvpos);
16229       enable_glyph_matrix_rows (current_matrix, first_unchanged_at_end_vpos,
16230                                 first_unchanged_at_end_vpos + dvpos, 0);
16231     }
16232 
16233   /* For frame-based redisplay, make sure that current frame and window
16234      matrix are in sync with respect to glyph memory.  */
16235   if (!FRAME_WINDOW_P (f))
16236     sync_frame_with_window_matrix_rows (w);
16237 
16238   /* Adjust buffer positions in reused rows.  */
16239   if (delta || delta_bytes)
16240     increment_matrix_positions (current_matrix,
16241                                 first_unchanged_at_end_vpos + dvpos,
16242                                 bottom_vpos, delta, delta_bytes);
16243 
16244   /* Adjust Y positions.  */
16245   if (dy)
16246     shift_glyph_matrix (w, current_matrix,
16247                         first_unchanged_at_end_vpos + dvpos,
16248                         bottom_vpos, dy);
16249 
16250   if (first_unchanged_at_end_row)
16251     {
16252       first_unchanged_at_end_row += dvpos;
16253       if (first_unchanged_at_end_row->y >= it.last_visible_y
16254           || !MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row))
16255         first_unchanged_at_end_row = NULL;
16256     }
16257 
16258   /* If scrolling up, there may be some lines to display at the end of
16259      the window.  */
16260   last_text_row_at_end = NULL;
16261   if (dy < 0)
16262     {
16263       /* Scrolling up can leave for example a partially visible line
16264          at the end of the window to be redisplayed.  */
16265       /* Set last_row to the glyph row in the current matrix where the
16266          window end line is found.  It has been moved up or down in
16267          the matrix by dvpos.  */
16268       int last_vpos = XFASTINT (w->window_end_vpos) + dvpos;
16269       struct glyph_row *last_row = MATRIX_ROW (current_matrix, last_vpos);
16270 
16271       /* If last_row is the window end line, it should display text.  */
16272       xassert (last_row->displays_text_p);
16273 
16274       /* If window end line was partially visible before, begin
16275          displaying at that line.  Otherwise begin displaying with the
16276          line following it.  */
16277       if (MATRIX_ROW_BOTTOM_Y (last_row) - dy >= it.last_visible_y)
16278         {
16279           init_to_row_start (&it, w, last_row);
16280           it.vpos = last_vpos;
16281           it.current_y = last_row->y;
16282         }
16283       else
16284         {
16285           init_to_row_end (&it, w, last_row);
16286           it.vpos = 1 + last_vpos;
16287           it.current_y = MATRIX_ROW_BOTTOM_Y (last_row);
16288           ++last_row;
16289         }
16290 
16291       /* We may start in a continuation line.  If so, we have to
16292          get the right continuation_lines_width and current_x.  */
16293       it.continuation_lines_width = last_row->continuation_lines_width;
16294       it.hpos = it.current_x = 0;
16295 
16296       /* Display the rest of the lines at the window end.  */
16297       it.glyph_row = MATRIX_ROW (desired_matrix, it.vpos);
16298       while (it.current_y < it.last_visible_y
16299              && !fonts_changed_p)
16300         {
16301           /* Is it always sure that the display agrees with lines in
16302              the current matrix?  I don't think so, so we mark rows
16303              displayed invalid in the current matrix by setting their
16304              enabled_p flag to zero.  */
16305           MATRIX_ROW (w->current_matrix, it.vpos)->enabled_p = 0;
16306           if (display_line (&it))
16307             last_text_row_at_end = it.glyph_row - 1;
16308         }
16309     }
16310 
16311   /* Update window_end_pos and window_end_vpos.  */
16312   if (first_unchanged_at_end_row
16313       && !last_text_row_at_end)
16314     {
16315       /* Window end line if one of the preserved rows from the current
16316          matrix.  Set row to the last row displaying text in current
16317          matrix starting at first_unchanged_at_end_row, after
16318          scrolling.  */
16319       xassert (first_unchanged_at_end_row->displays_text_p);
16320       row = find_last_row_displaying_text (w->current_matrix, &it,
16321                                            first_unchanged_at_end_row);
16322       xassert (row && MATRIX_ROW_DISPLAYS_TEXT_P (row));
16323 
16324       w->window_end_pos = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
16325       w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
16326       w->window_end_vpos
16327         = make_number (MATRIX_ROW_VPOS (row, w->current_matrix));
16328       xassert (w->window_end_bytepos >= 0);
16329       IF_DEBUG (debug_method_add (w, "A"));
16330     }
16331   else if (last_text_row_at_end)
16332     {
16333       w->window_end_pos
16334         = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row_at_end));
16335       w->window_end_bytepos
16336         = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row_at_end);
16337       w->window_end_vpos
16338         = make_number (MATRIX_ROW_VPOS (last_text_row_at_end, desired_matrix));
16339       xassert (w->window_end_bytepos >= 0);
16340       IF_DEBUG (debug_method_add (w, "B"));
16341     }
16342   else if (last_text_row)
16343     {
16344       /* We have displayed either to the end of the window or at the
16345          end of the window, i.e. the last row with text is to be found
16346          in the desired matrix.  */
16347       w->window_end_pos
16348         = make_number (Z - MATRIX_ROW_END_CHARPOS (last_text_row));
16349       w->window_end_bytepos
16350         = Z_BYTE - MATRIX_ROW_END_BYTEPOS (last_text_row);
16351       w->window_end_vpos
16352         = make_number (MATRIX_ROW_VPOS (last_text_row, desired_matrix));
16353       xassert (w->window_end_bytepos >= 0);
16354     }
16355   else if (first_unchanged_at_end_row == NULL
16356            && last_text_row == NULL
16357            && last_text_row_at_end == NULL)
16358     {
16359       /* Displayed to end of window, but no line containing text was
16360          displayed.  Lines were deleted at the end of the window.  */
16361       int first_vpos = WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0;
16362       int vpos = XFASTINT (w->window_end_vpos);
16363       struct glyph_row *current_row = current_matrix->rows + vpos;
16364       struct glyph_row *desired_row = desired_matrix->rows + vpos;
16365 
16366       for (row = NULL;
16367            row == NULL && vpos >= first_vpos;
16368            --vpos, --current_row, --desired_row)
16369         {
16370           if (desired_row->enabled_p)
16371             {
16372               if (desired_row->displays_text_p)
16373                 row = desired_row;
16374             }
16375           else if (current_row->displays_text_p)
16376             row  = current_row;
16377         }
16378 
16379       xassert (row != NULL);
16380       w->window_end_vpos = make_number (vpos + 1);
16381       w->window_end_pos = make_number (Z - MATRIX_ROW_END_CHARPOS (row));
16382       w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
16383       xassert (w->window_end_bytepos >= 0);
16384       IF_DEBUG (debug_method_add (w, "C"));
16385     }
16386   else
16387     abort ();
16388 
16389   IF_DEBUG (debug_end_pos = XFASTINT (w->window_end_pos);
16390             debug_end_vpos = XFASTINT (w->window_end_vpos));
16391 
16392   /* Record that display has not been completed.  */
16393   w->window_end_valid = Qnil;
16394   w->desired_matrix->no_scrolling_p = 1;
16395   return 3;
16396 
16397 #undef GIVE_UP
16398 }
16399 
16400 
16401 
16402 /***********************************************************************
16403                         More debugging support
16404  ***********************************************************************/
16405 
16406 #if GLYPH_DEBUG
16407 
16408 void dump_glyph_row P_ ((struct glyph_row *, int, int));
16409 void dump_glyph_matrix P_ ((struct glyph_matrix *, int));
16410 void dump_glyph P_ ((struct glyph_row *, struct glyph *, int));
16411 
16412 
16413 /* Dump the contents of glyph matrix MATRIX on stderr.
16414 
16415    GLYPHS 0 means don't show glyph contents.
16416    GLYPHS 1 means show glyphs in short form
16417    GLYPHS > 1 means show glyphs in long form.  */
16418 
16419 void
16420 dump_glyph_matrix (matrix, glyphs)
16421      struct glyph_matrix *matrix;
16422      int glyphs;
16423 {
16424   int i;
16425   for (i = 0; i < matrix->nrows; ++i)
16426     dump_glyph_row (MATRIX_ROW (matrix, i), i, glyphs);
16427 }
16428 
16429 
16430 /* Dump contents of glyph GLYPH to stderr.  ROW and AREA are
16431    the glyph row and area where the glyph comes from.  */
16432 
16433 void
16434 dump_glyph (row, glyph, area)
16435      struct glyph_row *row;
16436      struct glyph *glyph;
16437      int area;
16438 {
16439   if (glyph->type == CHAR_GLYPH)
16440     {
16441       fprintf (stderr,
16442                "  %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
16443                glyph - row->glyphs[TEXT_AREA],
16444                'C',
16445                glyph->charpos,
16446                (BUFFERP (glyph->object)
16447                 ? 'B'
16448                 : (STRINGP (glyph->object)
16449                    ? 'S'
16450                    : '-')),
16451                glyph->pixel_width,
16452                glyph->u.ch,
16453                (glyph->u.ch < 0x80 && glyph->u.ch >= ' '
16454                 ? glyph->u.ch
16455                 : '.'),
16456                glyph->face_id,
16457                glyph->left_box_line_p,
16458                glyph->right_box_line_p);
16459     }
16460   else if (glyph->type == STRETCH_GLYPH)
16461     {
16462       fprintf (stderr,
16463                "  %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
16464                glyph - row->glyphs[TEXT_AREA],
16465                'S',
16466                glyph->charpos,
16467                (BUFFERP (glyph->object)
16468                 ? 'B'
16469                 : (STRINGP (glyph->object)
16470                    ? 'S'
16471                    : '-')),
16472                glyph->pixel_width,
16473                0,
16474                '.',
16475                glyph->face_id,
16476                glyph->left_box_line_p,
16477                glyph->right_box_line_p);
16478     }
16479   else if (glyph->type == IMAGE_GLYPH)
16480     {
16481       fprintf (stderr,
16482                "  %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
16483                glyph - row->glyphs[TEXT_AREA],
16484                'I',
16485                glyph->charpos,
16486                (BUFFERP (glyph->object)
16487                 ? 'B'
16488                 : (STRINGP (glyph->object)
16489                    ? 'S'
16490                    : '-')),
16491                glyph->pixel_width,
16492                glyph->u.img_id,
16493                '.',
16494                glyph->face_id,
16495                glyph->left_box_line_p,
16496                glyph->right_box_line_p);
16497     }
16498   else if (glyph->type == COMPOSITE_GLYPH)
16499     {
16500       fprintf (stderr,
16501                "  %5d %4c %6d %c %3d 0x%05x",
16502                glyph - row->glyphs[TEXT_AREA],
16503                '+',
16504                glyph->charpos,
16505                (BUFFERP (glyph->object)
16506                 ? 'B'
16507                 : (STRINGP (glyph->object)
16508                    ? 'S'
16509                    : '-')),
16510                glyph->pixel_width,
16511                glyph->u.cmp.id);
16512       if (glyph->u.cmp.automatic)
16513         fprintf (stderr,
16514                  "[%d-%d]",
16515                  glyph->u.cmp.from, glyph->u.cmp.to);
16516       fprintf (stderr, " . %4d %1.1d%1.1d\n",
16517                glyph->face_id,
16518                glyph->left_box_line_p,
16519                glyph->right_box_line_p);
16520     }
16521 }
16522 
16523 
16524 /* Dump the contents of glyph row at VPOS in MATRIX to stderr.
16525    GLYPHS 0 means don't show glyph contents.
16526    GLYPHS 1 means show glyphs in short form
16527    GLYPHS > 1 means show glyphs in long form.  */
16528 
16529 void
16530 dump_glyph_row (row, vpos, glyphs)
16531      struct glyph_row *row;
16532      int vpos, glyphs;
16533 {
16534   if (glyphs != 1)
16535     {
16536       fprintf (stderr, "Row Start   End Used oE><\\CTZFesm     X    Y    W    H    V    A    P\n");
16537       fprintf (stderr, "======================================================================\n");
16538 
16539       fprintf (stderr, "%3d %5d %5d %4d %1.1d%1.1d%1.1d%1.1d\
16540 %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d  %4d %4d %4d %4d %4d %4d %4d\n",
16541                vpos,
16542                MATRIX_ROW_START_CHARPOS (row),
16543                MATRIX_ROW_END_CHARPOS (row),
16544                row->used[TEXT_AREA],
16545                row->contains_overlapping_glyphs_p,
16546                row->enabled_p,
16547                row->truncated_on_left_p,
16548                row->truncated_on_right_p,
16549                row->continued_p,
16550                MATRIX_ROW_CONTINUATION_LINE_P (row),
16551                row->displays_text_p,
16552                row->ends_at_zv_p,
16553                row->fill_line_p,
16554                row->ends_in_middle_of_char_p,
16555                row->starts_in_middle_of_char_p,
16556                row->mouse_face_p,
16557                row->x,
16558                row->y,
16559                row->pixel_width,
16560                row->height,
16561                row->visible_height,
16562                row->ascent,
16563                row->phys_ascent);
16564       fprintf (stderr, "%9d %5d\t%5d\n", row->start.overlay_string_index,
16565                row->end.overlay_string_index,
16566                row->continuation_lines_width);
16567       fprintf (stderr, "%9d %5d\n",
16568                CHARPOS (row->start.string_pos),
16569                CHARPOS (row->end.string_pos));
16570       fprintf (stderr, "%9d %5d\n", row->start.dpvec_index,
16571                row->end.dpvec_index);
16572     }
16573 
16574   if (glyphs > 1)
16575     {
16576       int area;
16577 
16578       for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
16579         {
16580           struct glyph *glyph = row->glyphs[area];
16581           struct glyph *glyph_end = glyph + row->used[area];
16582 
16583           /* Glyph for a line end in text.  */
16584           if (area == TEXT_AREA && glyph == glyph_end && glyph->charpos > 0)
16585             ++glyph_end;
16586 
16587           if (glyph < glyph_end)
16588             fprintf (stderr, "  Glyph    Type Pos   O W    Code C Face LR\n");
16589 
16590           for (; glyph < glyph_end; ++glyph)
16591             dump_glyph (row, glyph, area);
16592         }
16593     }
16594   else if (glyphs == 1)
16595     {
16596       int area;
16597 
16598       for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
16599         {
16600           char *s = (char *) alloca (row->used[area] + 1);
16601           int i;
16602 
16603           for (i = 0; i < row->used[area]; ++i)
16604             {
16605               struct glyph *glyph = row->glyphs[area] + i;
16606               if (glyph->type == CHAR_GLYPH
16607                   && glyph->u.ch < 0x80
16608                   && glyph->u.ch >= ' ')
16609                 s[i] = glyph->u.ch;
16610               else
16611                 s[i] = '.';
16612             }
16613 
16614           s[i] = '\0';
16615           fprintf (stderr, "%3d: (%d) '%s'\n", vpos, row->enabled_p, s);
16616         }
16617     }
16618 }
16619 
16620 
16621 DEFUN ("dump-glyph-matrix", Fdump_glyph_matrix,
16622        Sdump_glyph_matrix, 0, 1, "p",
16623        doc: /* Dump the current matrix of the selected window to stderr.
16624 Shows contents of glyph row structures.  With non-nil
16625 parameter GLYPHS, dump glyphs as well.  If GLYPHS is 1 show
16626 glyphs in short form, otherwise show glyphs in long form.  */)
16627      (glyphs)
16628      Lisp_Object glyphs;
16629 {
16630   struct window *w = XWINDOW (selected_window);
16631   struct buffer *buffer = XBUFFER (w->buffer);
16632 
16633   fprintf (stderr, "PT = %d, BEGV = %d. ZV = %d\n",
16634            BUF_PT (buffer), BUF_BEGV (buffer), BUF_ZV (buffer));
16635   fprintf (stderr, "Cursor x = %d, y = %d, hpos = %d, vpos = %d\n",
16636            w->cursor.x, w->cursor.y, w->cursor.hpos, w->cursor.vpos);
16637   fprintf (stderr, "=============================================\n");
16638   dump_glyph_matrix (w->current_matrix,
16639                      NILP (glyphs) ? 0 : XINT (glyphs));
16640   return Qnil;
16641 }
16642 
16643 
16644 DEFUN ("dump-frame-glyph-matrix", Fdump_frame_glyph_matrix,
16645        Sdump_frame_glyph_matrix, 0, 0, "", doc: /* */)
16646      ()
16647 {
16648   struct frame *f = XFRAME (selected_frame);
16649   dump_glyph_matrix (f->current_matrix, 1);
16650   return Qnil;
16651 }
16652 
16653 
16654 DEFUN ("dump-glyph-row", Fdump_glyph_row, Sdump_glyph_row, 1, 2, "",
16655        doc: /* Dump glyph row ROW to stderr.
16656 GLYPH 0 means don't dump glyphs.
16657 GLYPH 1 means dump glyphs in short form.
16658 GLYPH > 1 or omitted means dump glyphs in long form.  */)
16659      (row, glyphs)
16660      Lisp_Object row, glyphs;
16661 {
16662   struct glyph_matrix *matrix;
16663   int vpos;
16664 
16665   CHECK_NUMBER (row);
16666   matrix = XWINDOW (selected_window)->current_matrix;
16667   vpos = XINT (row);
16668   if (vpos >= 0 && vpos < matrix->nrows)
16669     dump_glyph_row (MATRIX_ROW (matrix, vpos),
16670                     vpos,
16671                     INTEGERP (glyphs) ? XINT (glyphs) : 2);
16672   return Qnil;
16673 }
16674 
16675 
16676 DEFUN ("dump-tool-bar-row", Fdump_tool_bar_row, Sdump_tool_bar_row, 1, 2, "",
16677        doc: /* Dump glyph row ROW of the tool-bar of the current frame to stderr.
16678 GLYPH 0 means don't dump glyphs.
16679 GLYPH 1 means dump glyphs in short form.
16680 GLYPH > 1 or omitted means dump glyphs in long form.  */)
16681      (row, glyphs)
16682      Lisp_Object row, glyphs;
16683 {
16684   struct frame *sf = SELECTED_FRAME ();
16685   struct glyph_matrix *m = XWINDOW (sf->tool_bar_window)->current_matrix;
16686   int vpos;
16687 
16688   CHECK_NUMBER (row);
16689   vpos = XINT (row);
16690   if (vpos >= 0 && vpos < m->nrows)
16691     dump_glyph_row (MATRIX_ROW (m, vpos), vpos,
16692                     INTEGERP (glyphs) ? XINT (glyphs) : 2);
16693   return Qnil;
16694 }
16695 
16696 
16697 DEFUN ("trace-redisplay", Ftrace_redisplay, Strace_redisplay, 0, 1, "P",
16698        doc: /* Toggle tracing of redisplay.
16699 With ARG, turn tracing on if and only if ARG is positive.  */)
16700      (arg)
16701      Lisp_Object arg;
16702 {
16703   if (NILP (arg))
16704     trace_redisplay_p = !trace_redisplay_p;
16705   else
16706     {
16707       arg = Fprefix_numeric_value (arg);
16708       trace_redisplay_p = XINT (arg) > 0;
16709     }
16710 
16711   return Qnil;
16712 }
16713 
16714 
16715 DEFUN ("trace-to-stderr", Ftrace_to_stderr, Strace_to_stderr, 1, MANY, "",
16716        doc: /* Like `format', but print result to stderr.
16717 usage: (trace-to-stderr STRING &rest OBJECTS)  */)
16718      (nargs, args)
16719      int nargs;
16720      Lisp_Object *args;
16721 {
16722   Lisp_Object s = Fformat (nargs, args);
16723   fprintf (stderr, "%s", SDATA (s));
16724   return Qnil;
16725 }
16726 
16727 #endif /* GLYPH_DEBUG */
16728 
16729 
16730 
16731 /***********************************************************************
16732                      Building Desired Matrix Rows
16733  ***********************************************************************/
16734 
16735 /* Return a temporary glyph row holding the glyphs of an overlay arrow.
16736    Used for non-window-redisplay windows, and for windows w/o left fringe.  */
16737 
16738 static struct glyph_row *
16739 get_overlay_arrow_glyph_row (w, overlay_arrow_string)
16740      struct window *w;
16741      Lisp_Object overlay_arrow_string;
16742 {
16743   struct frame *f = XFRAME (WINDOW_FRAME (w));
16744   struct buffer *buffer = XBUFFER (w->buffer);
16745   struct buffer *old = current_buffer;
16746   const unsigned char *arrow_string = SDATA (overlay_arrow_string);
16747   int arrow_len = SCHARS (overlay_arrow_string);
16748   const unsigned char *arrow_end = arrow_string + arrow_len;
16749   const unsigned char *p;
16750   struct it it;
16751   int multibyte_p;
16752   int n_glyphs_before;
16753 
16754   set_buffer_temp (buffer);
16755   init_iterator (&it, w, -1, -1, &scratch_glyph_row, DEFAULT_FACE_ID);
16756   it.glyph_row->used[TEXT_AREA] = 0;
16757   SET_TEXT_POS (it.position, 0, 0);
16758 
16759   multibyte_p = !NILP (buffer->enable_multibyte_characters);
16760   p = arrow_string;
16761   while (p < arrow_end)
16762     {
16763       Lisp_Object face, ilisp;
16764 
16765       /* Get the next character.  */
16766       if (multibyte_p)
16767         it.c = string_char_and_length (p, &it.len);
16768       else
16769         it.c = *p, it.len = 1;
16770       p += it.len;
16771 
16772       /* Get its face.  */
16773       ilisp = make_number (p - arrow_string);
16774       face = Fget_text_property (ilisp, Qface, overlay_arrow_string);
16775       it.face_id = compute_char_face (f, it.c, face);
16776 
16777       /* Compute its width, get its glyphs.  */
16778       n_glyphs_before = it.glyph_row->used[TEXT_AREA];
16779       SET_TEXT_POS (it.position, -1, -1);
16780       PRODUCE_GLYPHS (&it);
16781 
16782       /* If this character doesn't fit any more in the line, we have
16783          to remove some glyphs.  */
16784       if (it.current_x > it.last_visible_x)
16785         {
16786           it.glyph_row->used[TEXT_AREA] = n_glyphs_before;
16787           break;
16788         }
16789     }
16790 
16791   set_buffer_temp (old);
16792   return it.glyph_row;
16793 }
16794 
16795 
16796 /* Insert truncation glyphs at the start of IT->glyph_row.  Truncation
16797    glyphs are only inserted for terminal frames since we can't really
16798    win with truncation glyphs when partially visible glyphs are
16799    involved.  Which glyphs to insert is determined by
16800    produce_special_glyphs.  */
16801 
16802 static void
16803 insert_left_trunc_glyphs (it)
16804      struct it *it;
16805 {
16806   struct it truncate_it;
16807   struct glyph *from, *end, *to, *toend;
16808 
16809   xassert (!FRAME_WINDOW_P (it->f));
16810 
16811   /* Get the truncation glyphs.  */
16812   truncate_it = *it;
16813   truncate_it.current_x = 0;
16814   truncate_it.face_id = DEFAULT_FACE_ID;
16815   truncate_it.glyph_row = &scratch_glyph_row;
16816   truncate_it.glyph_row->used[TEXT_AREA] = 0;
16817   CHARPOS (truncate_it.position) = BYTEPOS (truncate_it.position) = -1;
16818   truncate_it.object = make_number (0);
16819   produce_special_glyphs (&truncate_it, IT_TRUNCATION);
16820 
16821   /* Overwrite glyphs from IT with truncation glyphs.  */
16822   if (!it->glyph_row->reversed_p)
16823     {
16824       from = truncate_it.glyph_row->glyphs[TEXT_AREA];
16825       end = from + truncate_it.glyph_row->used[TEXT_AREA];
16826       to = it->glyph_row->glyphs[TEXT_AREA];
16827       toend = to + it->glyph_row->used[TEXT_AREA];
16828 
16829       while (from < end)
16830         *to++ = *from++;
16831 
16832       /* There may be padding glyphs left over.  Overwrite them too.  */
16833       while (to < toend && CHAR_GLYPH_PADDING_P (*to))
16834         {
16835           from = truncate_it.glyph_row->glyphs[TEXT_AREA];
16836           while (from < end)
16837             *to++ = *from++;
16838         }
16839 
16840       if (to > toend)
16841         it->glyph_row->used[TEXT_AREA] = to - it->glyph_row->glyphs[TEXT_AREA];
16842     }
16843   else
16844     {
16845       /* In R2L rows, overwrite the last (rightmost) glyphs, and do
16846          that back to front.  */
16847       end = truncate_it.glyph_row->glyphs[TEXT_AREA];
16848       from = end + truncate_it.glyph_row->used[TEXT_AREA] - 1;
16849       toend = it->glyph_row->glyphs[TEXT_AREA];
16850       to = toend + it->glyph_row->used[TEXT_AREA] - 1;
16851 
16852       while (from >= end && to >= toend)
16853         *to-- = *from--;
16854       while (to >= toend && CHAR_GLYPH_PADDING_P (*to))
16855         {
16856           from =
16857             truncate_it.glyph_row->glyphs[TEXT_AREA]
16858             + truncate_it.glyph_row->used[TEXT_AREA] - 1;
16859           while (from >= end && to >= toend)
16860             *to-- = *from--;
16861         }
16862       if (from >= end)
16863         {
16864           /* Need to free some room before prepending additional
16865              glyphs.  */
16866           int move_by = from - end + 1;
16867           struct glyph *g0 = it->glyph_row->glyphs[TEXT_AREA];
16868           struct glyph *g = g0 + it->glyph_row->used[TEXT_AREA] - 1;
16869 
16870           for ( ; g >= g0; g--)
16871             g[move_by] = *g;
16872           while (from >= end)
16873             *to-- = *from--;
16874           it->glyph_row->used[TEXT_AREA] += move_by;
16875         }
16876     }
16877 }
16878 
16879 
16880 /* Compute the pixel height and width of IT->glyph_row.
16881 
16882    Most of the time, ascent and height of a display line will be equal
16883    to the max_ascent and max_height values of the display iterator
16884    structure.  This is not the case if
16885 
16886    1. We hit ZV without displaying anything.  In this case, max_ascent
16887    and max_height will be zero.
16888 
16889    2. We have some glyphs that don't contribute to the line height.
16890    (The glyph row flag contributes_to_line_height_p is for future
16891    pixmap extensions).
16892 
16893    The first case is easily covered by using default values because in
16894    these cases, the line height does not really matter, except that it
16895    must not be zero.  */
16896 
16897 static void
16898 compute_line_metrics (it)
16899      struct it *it;
16900 {
16901   struct glyph_row *row = it->glyph_row;
16902   int area, i;
16903 
16904   if (FRAME_WINDOW_P (it->f))
16905     {
16906       int i, min_y, max_y;
16907 
16908       /* The line may consist of one space only, that was added to
16909          place the cursor on it.  If so, the row's height hasn't been
16910          computed yet.  */
16911       if (row->height == 0)
16912         {
16913           if (it->max_ascent + it->max_descent == 0)
16914             it->max_descent = it->max_phys_descent = FRAME_LINE_HEIGHT (it->f);
16915           row->ascent = it->max_ascent;
16916           row->height = it->max_ascent + it->max_descent;
16917           row->phys_ascent = it->max_phys_ascent;
16918           row->phys_height = it->max_phys_ascent + it->max_phys_descent;
16919           row->extra_line_spacing = it->max_extra_line_spacing;
16920         }
16921 
16922       /* Compute the width of this line.  */
16923       row->pixel_width = row->x;
16924       for (i = 0; i < row->used[TEXT_AREA]; ++i)
16925         row->pixel_width += row->glyphs[TEXT_AREA][i].pixel_width;
16926 
16927       xassert (row->pixel_width >= 0);
16928       xassert (row->ascent >= 0 && row->height > 0);
16929 
16930       row->overlapping_p = (MATRIX_ROW_OVERLAPS_SUCC_P (row)
16931                             || MATRIX_ROW_OVERLAPS_PRED_P (row));
16932 
16933       /* If first line's physical ascent is larger than its logical
16934          ascent, use the physical ascent, and make the row taller.
16935          This makes accented characters fully visible.  */
16936       if (row == MATRIX_FIRST_TEXT_ROW (it->w->desired_matrix)
16937           && row->phys_ascent > row->ascent)
16938         {
16939           row->height += row->phys_ascent - row->ascent;
16940           row->ascent = row->phys_ascent;
16941         }
16942 
16943       /* Compute how much of the line is visible.  */
16944       row->visible_height = row->height;
16945 
16946       min_y = WINDOW_HEADER_LINE_HEIGHT (it->w);
16947       max_y = WINDOW_BOX_HEIGHT_NO_MODE_LINE (it->w);
16948 
16949       if (row->y < min_y)
16950         row->visible_height -= min_y - row->y;
16951       if (row->y + row->height > max_y)
16952         row->visible_height -= row->y + row->height - max_y;
16953     }
16954   else
16955     {
16956       row->pixel_width = row->used[TEXT_AREA];
16957       if (row->continued_p)
16958         row->pixel_width -= it->continuation_pixel_width;
16959       else if (row->truncated_on_right_p)
16960         row->pixel_width -= it->truncation_pixel_width;
16961       row->ascent = row->phys_ascent = 0;
16962       row->height = row->phys_height = row->visible_height = 1;
16963       row->extra_line_spacing = 0;
16964     }
16965 
16966   /* Compute a hash code for this row.  */
16967   row->hash = 0;
16968   for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
16969     for (i = 0; i < row->used[area]; ++i)
16970       row->hash = ((((row->hash << 4) + (row->hash >> 24)) & 0x0fffffff)
16971                    + row->glyphs[area][i].u.val
16972                    + row->glyphs[area][i].face_id
16973                    + row->glyphs[area][i].padding_p
16974                    + (row->glyphs[area][i].type << 2));
16975 
16976   it->max_ascent = it->max_descent = 0;
16977   it->max_phys_ascent = it->max_phys_descent = 0;
16978 }
16979 
16980 
16981 /* Append one space to the glyph row of iterator IT if doing a
16982    window-based redisplay.  The space has the same face as
16983    IT->face_id.  Value is non-zero if a space was added.
16984 
16985    This function is called to make sure that there is always one glyph
16986    at the end of a glyph row that the cursor can be set on under
16987    window-systems.  (If there weren't such a glyph we would not know
16988    how wide and tall a box cursor should be displayed).
16989 
16990    At the same time this space let's a nicely handle clearing to the
16991    end of the line if the row ends in italic text.  */
16992 
16993 static int
16994 append_space_for_newline (it, default_face_p)
16995      struct it *it;
16996      int default_face_p;
16997 {
16998   if (FRAME_WINDOW_P (it->f))
16999     {
17000       int n = it->glyph_row->used[TEXT_AREA];
17001 
17002       if (it->glyph_row->glyphs[TEXT_AREA] + n
17003           < it->glyph_row->glyphs[1 + TEXT_AREA])
17004         {
17005           /* Save some values that must not be changed.
17006              Must save IT->c and IT->len because otherwise
17007              ITERATOR_AT_END_P wouldn't work anymore after
17008              append_space_for_newline has been called.  */
17009           enum display_element_type saved_what = it->what;
17010           int saved_c = it->c, saved_len = it->len;
17011           int saved_x = it->current_x;
17012           int saved_face_id = it->face_id;
17013           struct text_pos saved_pos;
17014           Lisp_Object saved_object;
17015           struct face *face;
17016 
17017           saved_object = it->object;
17018           saved_pos = it->position;
17019 
17020           it->what = IT_CHARACTER;
17021           bzero (&it->position, sizeof it->position);
17022           it->object = make_number (0);
17023           it->c = ' ';
17024           it->len = 1;
17025 
17026           if (default_face_p)
17027             it->face_id = DEFAULT_FACE_ID;
17028           else if (it->face_before_selective_p)
17029             it->face_id = it->saved_face_id;
17030           face = FACE_FROM_ID (it->f, it->face_id);
17031           it->face_id = FACE_FOR_CHAR (it->f, face, 0, -1, Qnil);
17032 
17033           PRODUCE_GLYPHS (it);
17034 
17035           it->override_ascent = -1;
17036           it->constrain_row_ascent_descent_p = 0;
17037           it->current_x = saved_x;
17038           it->object = saved_object;
17039           it->position = saved_pos;
17040           it->what = saved_what;
17041           it->face_id = saved_face_id;
17042           it->len = saved_len;
17043           it->c = saved_c;
17044           return 1;
17045         }
17046     }
17047 
17048   return 0;
17049 }
17050 
17051 
17052 /* Extend the face of the last glyph in the text area of IT->glyph_row
17053    to the end of the display line.  Called from display_line.  If the
17054    glyph row is empty, add a space glyph to it so that we know the
17055    face to draw.  Set the glyph row flag fill_line_p.  If the glyph
17056    row is R2L, prepend a stretch glyph to cover the empty space to the
17057    left of the leftmost glyph.  */
17058 
17059 static void
17060 extend_face_to_end_of_line (it)
17061      struct it *it;
17062 {
17063   struct face *face;
17064   struct frame *f = it->f;
17065 
17066   /* If line is already filled, do nothing.  Non window-system frames
17067      get a grace of one more ``pixel'' because their characters are
17068      1-``pixel'' wide, so they hit the equality too early.  This grace
17069      is needed only for R2L rows that are not continued, to produce
17070      one extra blank where we could display the cursor.  */
17071   if (it->current_x >= it->last_visible_x
17072       + (!FRAME_WINDOW_P (f)
17073          && it->glyph_row->reversed_p
17074          && !it->glyph_row->continued_p))
17075     return;
17076 
17077   /* Face extension extends the background and box of IT->face_id
17078      to the end of the line.  If the background equals the background
17079      of the frame, we don't have to do anything.  */
17080   if (it->face_before_selective_p)
17081     face = FACE_FROM_ID (f, it->saved_face_id);
17082   else
17083     face = FACE_FROM_ID (f, it->face_id);
17084 
17085   if (FRAME_WINDOW_P (f)
17086       && it->glyph_row->displays_text_p
17087       && face->box == FACE_NO_BOX
17088       && face->background == FRAME_BACKGROUND_PIXEL (f)
17089       && !face->stipple
17090       && !it->glyph_row->reversed_p)
17091     return;
17092 
17093   /* Set the glyph row flag indicating that the face of the last glyph
17094      in the text area has to be drawn to the end of the text area.  */
17095   it->glyph_row->fill_line_p = 1;
17096 
17097   /* If current character of IT is not ASCII, make sure we have the
17098      ASCII face.  This will be automatically undone the next time
17099      get_next_display_element returns a multibyte character.  Note
17100      that the character will always be single byte in unibyte
17101      text.  */
17102   if (!ASCII_CHAR_P (it->c))
17103     {
17104       it->face_id = FACE_FOR_CHAR (f, face, 0, -1, Qnil);
17105     }
17106 
17107   if (FRAME_WINDOW_P (f))
17108     {
17109       /* If the row is empty, add a space with the current face of IT,
17110          so that we know which face to draw.  */
17111       if (it->glyph_row->used[TEXT_AREA] == 0)
17112         {
17113           it->glyph_row->glyphs[TEXT_AREA][0] = space_glyph;
17114           it->glyph_row->glyphs[TEXT_AREA][0].face_id = it->face_id;
17115           it->glyph_row->used[TEXT_AREA] = 1;
17116         }
17117 #ifdef HAVE_WINDOW_SYSTEM
17118       if (it->glyph_row->reversed_p)
17119         {
17120           /* Prepend a stretch glyph to the row, such that the
17121              rightmost glyph will be drawn flushed all the way to the
17122              right margin of the window.  The stretch glyph that will
17123              occupy the empty space, if any, to the left of the
17124              glyphs.  */
17125           struct font *font = face->font ? face->font : FRAME_FONT (f);
17126           struct glyph *row_start = it->glyph_row->glyphs[TEXT_AREA];
17127           struct glyph *row_end = row_start + it->glyph_row->used[TEXT_AREA];
17128           struct glyph *g;
17129           int row_width, stretch_ascent, stretch_width;
17130           struct text_pos saved_pos;
17131           int saved_face_id, saved_avoid_cursor;
17132 
17133           for (row_width = 0, g = row_start; g < row_end; g++)
17134             row_width += g->pixel_width;
17135           stretch_width = window_box_width (it->w, TEXT_AREA) - row_width;
17136           if (stretch_width > 0)
17137             {
17138               stretch_ascent =
17139                 (((it->ascent + it->descent)
17140                   * FONT_BASE (font)) / FONT_HEIGHT (font));
17141               saved_pos = it->position;
17142               bzero (&it->position, sizeof it->position);
17143               saved_avoid_cursor = it->avoid_cursor_p;
17144               it->avoid_cursor_p = 1;
17145               saved_face_id = it->face_id;
17146               /* The last row's stretch glyph should get the default
17147                  face, to avoid painting the rest of the window with
17148                  the region face, if the region ends at ZV.  */
17149               if (it->glyph_row->ends_at_zv_p)
17150                 it->face_id = DEFAULT_FACE_ID;
17151               else
17152                 it->face_id = face->id;
17153               append_stretch_glyph (it, make_number (0), stretch_width,
17154                                     it->ascent + it->descent, stretch_ascent);
17155               it->position = saved_pos;
17156               it->avoid_cursor_p = saved_avoid_cursor;
17157               it->face_id = saved_face_id;
17158             }
17159         }
17160 #endif  /* HAVE_WINDOW_SYSTEM */
17161     }
17162   else
17163     {
17164       /* Save some values that must not be changed.  */
17165       int saved_x = it->current_x;
17166       struct text_pos saved_pos;
17167       Lisp_Object saved_object;
17168       enum display_element_type saved_what = it->what;
17169       int saved_face_id = it->face_id;
17170 
17171       saved_object = it->object;
17172       saved_pos = it->position;
17173 
17174       it->what = IT_CHARACTER;
17175       bzero (&it->position, sizeof it->position);
17176       it->object = make_number (0);
17177       it->c = ' ';
17178       it->len = 1;
17179       /* The last row's blank glyphs should get the default face, to
17180          avoid painting the rest of the window with the region face,
17181          if the region ends at ZV.  */
17182       if (it->glyph_row->ends_at_zv_p)
17183         it->face_id = DEFAULT_FACE_ID;
17184       else
17185         it->face_id = face->id;
17186 
17187       PRODUCE_GLYPHS (it);
17188 
17189       while (it->current_x <= it->last_visible_x)
17190         PRODUCE_GLYPHS (it);
17191 
17192       /* Don't count these blanks really.  It would let us insert a left
17193          truncation glyph below and make us set the cursor on them, maybe.  */
17194       it->current_x = saved_x;
17195       it->object = saved_object;
17196       it->position = saved_pos;
17197       it->what = saved_what;
17198       it->face_id = saved_face_id;
17199     }
17200 }
17201 
17202 
17203 /* Value is non-zero if text starting at CHARPOS in current_buffer is
17204    trailing whitespace.  */
17205 
17206 static int
17207 trailing_whitespace_p (charpos)
17208      int charpos;
17209 {
17210   int bytepos = CHAR_TO_BYTE (charpos);
17211   int c = 0;
17212 
17213   while (bytepos < ZV_BYTE
17214          && (c = FETCH_CHAR (bytepos),
17215              c == ' ' || c == '\t'))
17216     ++bytepos;
17217 
17218   if (bytepos >= ZV_BYTE || c == '\n' || c == '\r')
17219     {
17220       if (bytepos != PT_BYTE)
17221         return 1;
17222     }
17223   return 0;
17224 }
17225 
17226 
17227 /* Highlight trailing whitespace, if any, in ROW.  */
17228 
17229 void
17230 highlight_trailing_whitespace (f, row)
17231      struct frame *f;
17232      struct glyph_row *row;
17233 {
17234   int used = row->used[TEXT_AREA];
17235 
17236   if (used)
17237     {
17238       struct glyph *start = row->glyphs[TEXT_AREA];
17239       struct glyph *glyph = start + used - 1;
17240 
17241       if (row->reversed_p)
17242         {
17243           /* Right-to-left rows need to be processed in the opposite
17244              direction, so swap the edge pointers. */
17245           glyph = start;
17246           start = row->glyphs[TEXT_AREA] + used - 1;
17247         }
17248 
17249       /* Skip over glyphs inserted to display the cursor at the
17250          end of a line, for extending the face of the last glyph
17251          to the end of the line on terminals, and for truncation
17252          and continuation glyphs.  */
17253       if (!row->reversed_p)
17254         {
17255           while (glyph >= start
17256                  && glyph->type == CHAR_GLYPH
17257                  && INTEGERP (glyph->object))
17258             --glyph;
17259         }
17260       else
17261         {
17262           while (glyph <= start
17263                  && glyph->type == CHAR_GLYPH
17264                  && INTEGERP (glyph->object))
17265             ++glyph;
17266         }
17267 
17268       /* If last glyph is a space or stretch, and it's trailing
17269          whitespace, set the face of all trailing whitespace glyphs in
17270          IT->glyph_row to `trailing-whitespace'.  */
17271       if ((row->reversed_p ? glyph <= start : glyph >= start)
17272           && BUFFERP (glyph->object)
17273           && (glyph->type == STRETCH_GLYPH
17274               || (glyph->type == CHAR_GLYPH
17275                   && glyph->u.ch == ' '))
17276           && trailing_whitespace_p (glyph->charpos))
17277         {
17278           int face_id = lookup_named_face (f, Qtrailing_whitespace, 0);
17279           if (face_id < 0)
17280             return;
17281 
17282           if (!row->reversed_p)
17283             {
17284               while (glyph >= start
17285                      && BUFFERP (glyph->object)
17286                      && (glyph->type == STRETCH_GLYPH
17287                          || (glyph->type == CHAR_GLYPH
17288                              && glyph->u.ch == ' ')))
17289                 (glyph--)->face_id = face_id;
17290             }
17291           else
17292             {
17293               while (glyph <= start
17294                      && BUFFERP (glyph->object)
17295                      && (glyph->type == STRETCH_GLYPH
17296                          || (glyph->type == CHAR_GLYPH
17297                              && glyph->u.ch == ' ')))
17298                 (glyph++)->face_id = face_id;
17299             }
17300         }
17301     }
17302 }
17303 
17304 
17305 /* Value is non-zero if glyph row ROW in window W should be
17306    used to hold the cursor.  */
17307 
17308 static int
17309 cursor_row_p (w, row)
17310      struct window *w;
17311      struct glyph_row *row;
17312 {
17313   int cursor_row_p = 1;
17314 
17315   if (PT == CHARPOS (row->end.pos))
17316     {
17317       /* Suppose the row ends on a string.
17318          Unless the row is continued, that means it ends on a newline
17319          in the string.  If it's anything other than a display string
17320          (e.g. a before-string from an overlay), we don't want the
17321          cursor there.  (This heuristic seems to give the optimal
17322          behavior for the various types of multi-line strings.)  */
17323       if (CHARPOS (row->end.string_pos) >= 0)
17324         {
17325           if (row->continued_p)
17326             cursor_row_p = 1;
17327           else
17328             {
17329               /* Check for `display' property.  */
17330               struct glyph *beg = row->glyphs[TEXT_AREA];
17331               struct glyph *end = beg + row->used[TEXT_AREA] - 1;
17332               struct glyph *glyph;
17333 
17334               cursor_row_p = 0;
17335               for (glyph = end; glyph >= beg; --glyph)
17336                 if (STRINGP (glyph->object))
17337                   {
17338                     Lisp_Object prop
17339                       = Fget_char_property (make_number (PT),
17340                                             Qdisplay, Qnil);
17341                     cursor_row_p =
17342                       (!NILP (prop)
17343                        && display_prop_string_p (prop, glyph->object));
17344                     break;
17345                   }
17346             }
17347         }
17348       else if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))
17349         {
17350           /* If the row ends in middle of a real character,
17351              and the line is continued, we want the cursor here.
17352              That's because CHARPOS (ROW->end.pos) would equal
17353              PT if PT is before the character.  */
17354           if (!row->ends_in_ellipsis_p)
17355             cursor_row_p = row->continued_p;
17356           else
17357           /* If the row ends in an ellipsis, then
17358              CHARPOS (ROW->end.pos) will equal point after the
17359              invisible text.  We want that position to be displayed
17360              after the ellipsis.  */
17361             cursor_row_p = 0;
17362         }
17363       /* If the row ends at ZV, display the cursor at the end of that
17364          row instead of at the start of the row below.  */
17365       else if (row->ends_at_zv_p)
17366         cursor_row_p = 1;
17367       else
17368         cursor_row_p = 0;
17369     }
17370 
17371   return cursor_row_p;
17372 }
17373 
17374 
17375 
17376 /* Push the display property PROP so that it will be rendered at the
17377    current position in IT.  Return 1 if PROP was successfully pushed,
17378    0 otherwise.  */
17379 
17380 static int
17381 push_display_prop (struct it *it, Lisp_Object prop)
17382 {
17383   push_it (it);
17384 
17385   if (STRINGP (prop))
17386     {
17387       if (SCHARS (prop) == 0)
17388         {
17389           pop_it (it);
17390           return 0;
17391         }
17392 
17393       it->string = prop;
17394       it->multibyte_p = STRING_MULTIBYTE (it->string);
17395       it->current.overlay_string_index = -1;
17396       IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
17397       it->end_charpos = it->string_nchars = SCHARS (it->string);
17398       it->method = GET_FROM_STRING;
17399       it->stop_charpos = 0;
17400     }
17401   else if (CONSP (prop) && EQ (XCAR (prop), Qspace))
17402     {
17403       it->method = GET_FROM_STRETCH;
17404       it->object = prop;
17405     }
17406 #ifdef HAVE_WINDOW_SYSTEM
17407   else if (IMAGEP (prop))
17408     {
17409       it->what = IT_IMAGE;
17410       it->image_id = lookup_image (it->f, prop);
17411       it->method = GET_FROM_IMAGE;
17412     }
17413 #endif /* HAVE_WINDOW_SYSTEM */
17414   else
17415     {
17416       pop_it (it);              /* bogus display property, give up */
17417       return 0;
17418     }
17419 
17420   return 1;
17421 }
17422 
17423 /* Return the character-property PROP at the current position in IT.  */
17424 
17425 static Lisp_Object
17426 get_it_property (it, prop)
17427      struct it *it;
17428      Lisp_Object prop;
17429 {
17430   Lisp_Object position;
17431 
17432   if (STRINGP (it->object))
17433     position = make_number (IT_STRING_CHARPOS (*it));
17434   else if (BUFFERP (it->object))
17435     position = make_number (IT_CHARPOS (*it));
17436   else
17437     return Qnil;
17438 
17439   return Fget_char_property (position, prop, it->object);
17440 }
17441 
17442 /* See if there's a line- or wrap-prefix, and if so, push it on IT.  */
17443 
17444 static void
17445 handle_line_prefix (struct it *it)
17446 {
17447   Lisp_Object prefix;
17448   if (it->continuation_lines_width > 0)
17449     {
17450       prefix = get_it_property (it, Qwrap_prefix);
17451       if (NILP (prefix))
17452         prefix = Vwrap_prefix;
17453     }
17454   else
17455     {
17456       prefix = get_it_property (it, Qline_prefix);
17457       if (NILP (prefix))
17458         prefix = Vline_prefix;
17459     }
17460   if (! NILP (prefix) && push_display_prop (it, prefix))
17461     {
17462       /* If the prefix is wider than the window, and we try to wrap
17463          it, it would acquire its own wrap prefix, and so on till the
17464          iterator stack overflows.  So, don't wrap the prefix.  */
17465       it->line_wrap = TRUNCATE;
17466       it->avoid_cursor_p = 1;
17467     }
17468 }
17469 
17470 
17471 
17472 /* Remove N glyphs at the start of a reversed IT->glyph_row.  Called
17473    only for R2L lines from display_line, when it decides that too many
17474    glyphs were produced by PRODUCE_GLYPHS, and the line needs to be
17475    continued.  */
17476 static void
17477 unproduce_glyphs (it, n)
17478      struct it *it;
17479      int n;
17480 {
17481   struct glyph *glyph, *end;
17482 
17483   xassert (it->glyph_row);
17484   xassert (it->glyph_row->reversed_p);
17485   xassert (it->area == TEXT_AREA);
17486   xassert (n <= it->glyph_row->used[TEXT_AREA]);
17487 
17488   if (n > it->glyph_row->used[TEXT_AREA])
17489     n = it->glyph_row->used[TEXT_AREA];
17490   glyph = it->glyph_row->glyphs[TEXT_AREA] + n;
17491   end = it->glyph_row->glyphs[TEXT_AREA] + it->glyph_row->used[TEXT_AREA];
17492   for ( ; glyph < end; glyph++)
17493     glyph[-n] = *glyph;
17494 }
17495 
17496 /* Find the positions in a bidi-reordered ROW to serve as ROW->minpos
17497    and ROW->maxpos.  */
17498 static void
17499 find_row_edges (it, row, min_pos, min_bpos, max_pos, max_bpos)
17500      struct it *it;
17501      struct glyph_row *row;
17502      EMACS_INT min_pos, min_bpos, max_pos, max_bpos;
17503 {
17504   /* FIXME: Revisit this when glyph ``spilling'' in continuation
17505      lines' rows is implemented for bidi-reordered rows.  */
17506 
17507   /* ROW->minpos is the value of min_pos, the minimal buffer position
17508      we have in ROW.  */
17509   if (min_pos <= ZV)
17510     SET_TEXT_POS (row->minpos, min_pos, min_bpos);
17511   else
17512     {
17513       /* We didn't find _any_ valid buffer positions in any of the
17514          glyphs, so we must trust the iterator's computed
17515          positions.  */
17516       row->minpos = row->start.pos;
17517       max_pos = CHARPOS (it->current.pos);
17518       max_bpos = BYTEPOS (it->current.pos);
17519     }
17520 
17521   if (!max_pos)
17522     abort ();
17523 
17524   /* Here are the various use-cases for ending the row, and the
17525      corresponding values for ROW->maxpos:
17526 
17527      Line ends in a newline from buffer       eol_pos + 1
17528      Line is continued from buffer            max_pos + 1
17529      Line is truncated on right               it->current.pos
17530      Line ends in a newline from string       max_pos
17531      Line is continued from string            max_pos
17532      Line is continued from display vector    max_pos
17533      Line is entirely from a string           min_pos == max_pos
17534      Line is entirely from a display vector   min_pos == max_pos
17535      Line that ends at ZV                     ZV
17536 
17537      If you discover other use-cases, please add them here as
17538      appropriate.  */
17539   if (row->ends_at_zv_p)
17540     row->maxpos = it->current.pos;
17541   else if (row->used[TEXT_AREA])
17542     {
17543       if (row->ends_in_newline_from_string_p)
17544         SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
17545       else if (CHARPOS (it->eol_pos) > 0)
17546         SET_TEXT_POS (row->maxpos,
17547                       CHARPOS (it->eol_pos) + 1, BYTEPOS (it->eol_pos) + 1);
17548       else if (row->continued_p)
17549         {
17550           /* If max_pos is different from IT's current position, it
17551              means IT->method does not belong to the display element
17552              at max_pos.  However, it also means that the display
17553              element at max_pos was displayed in its entirety on this
17554              line, which is equivalent to saying that the next line
17555              starts at the next buffer position.  */
17556           if (IT_CHARPOS (*it) == max_pos && it->method != GET_FROM_BUFFER)
17557             SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
17558           else
17559             {
17560               INC_BOTH (max_pos, max_bpos);
17561               SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
17562             }
17563         }
17564       else if (row->truncated_on_right_p)
17565         /* display_line already called reseat_at_next_visible_line_start,
17566            which puts the iterator at the beginning of the next line, in
17567            the logical order. */
17568         row->maxpos = it->current.pos;
17569       else if (max_pos == min_pos && it->method != GET_FROM_BUFFER)
17570         /* A line that is entirely from a string/image/stretch...  */
17571         row->maxpos = row->minpos;
17572       else
17573         abort ();
17574     }
17575   else
17576     row->maxpos = it->current.pos;
17577 }
17578 
17579 /* Construct the glyph row IT->glyph_row in the desired matrix of
17580    IT->w from text at the current position of IT.  See dispextern.h
17581    for an overview of struct it.  Value is non-zero if
17582    IT->glyph_row displays text, as opposed to a line displaying ZV
17583    only.  */
17584 
17585 static int
17586 display_line (it)
17587      struct it *it;
17588 {
17589   struct glyph_row *row = it->glyph_row;
17590   Lisp_Object overlay_arrow_string;
17591   struct it wrap_it;
17592   int may_wrap = 0, wrap_x;
17593   int wrap_row_used = -1, wrap_row_ascent, wrap_row_height;
17594   int wrap_row_phys_ascent, wrap_row_phys_height;
17595   int wrap_row_extra_line_spacing;
17596   EMACS_INT wrap_row_min_pos, wrap_row_min_bpos;
17597   EMACS_INT wrap_row_max_pos, wrap_row_max_bpos;
17598   int cvpos;
17599   EMACS_INT min_pos = ZV + 1, min_bpos, max_pos = 0, max_bpos;
17600 
17601   /* We always start displaying at hpos zero even if hscrolled.  */
17602   xassert (it->hpos == 0 && it->current_x == 0);
17603 
17604   if (MATRIX_ROW_VPOS (row, it->w->desired_matrix)
17605       >= it->w->desired_matrix->nrows)
17606     {
17607       it->w->nrows_scale_factor++;
17608       fonts_changed_p = 1;
17609       return 0;
17610     }
17611 
17612   /* Is IT->w showing the region?  */
17613   it->w->region_showing = it->region_beg_charpos > 0 ? Qt : Qnil;
17614 
17615   /* Clear the result glyph row and enable it.  */
17616   prepare_desired_row (row);
17617 
17618   row->y = it->current_y;
17619   row->start = it->start;
17620   row->continuation_lines_width = it->continuation_lines_width;
17621   row->displays_text_p = 1;
17622   row->starts_in_middle_of_char_p = it->starts_in_middle_of_char_p;
17623   it->starts_in_middle_of_char_p = 0;
17624 
17625   /* Arrange the overlays nicely for our purposes.  Usually, we call
17626      display_line on only one line at a time, in which case this
17627      can't really hurt too much, or we call it on lines which appear
17628      one after another in the buffer, in which case all calls to
17629      recenter_overlay_lists but the first will be pretty cheap.  */
17630   recenter_overlay_lists (current_buffer, IT_CHARPOS (*it));
17631 
17632   /* Move over display elements that are not visible because we are
17633      hscrolled.  This may stop at an x-position < IT->first_visible_x
17634      if the first glyph is partially visible or if we hit a line end.  */
17635   if (it->current_x < it->first_visible_x)
17636     {
17637       move_it_in_display_line_to (it, ZV, it->first_visible_x,
17638                                   MOVE_TO_POS | MOVE_TO_X);
17639     }
17640   else
17641     {
17642       /* We only do this when not calling `move_it_in_display_line_to'
17643          above, because move_it_in_display_line_to calls
17644          handle_line_prefix itself.  */
17645       handle_line_prefix (it);
17646     }
17647 
17648   /* Get the initial row height.  This is either the height of the
17649      text hscrolled, if there is any, or zero.  */
17650   row->ascent = it->max_ascent;
17651   row->height = it->max_ascent + it->max_descent;
17652   row->phys_ascent = it->max_phys_ascent;
17653   row->phys_height = it->max_phys_ascent + it->max_phys_descent;
17654   row->extra_line_spacing = it->max_extra_line_spacing;
17655 
17656 /* Utility macro to record max and min buffer positions seen until now.  */
17657 #define RECORD_MAX_MIN_POS(IT)                                  \
17658   do                                                            \
17659     {                                                           \
17660       if (IT_CHARPOS (*(IT)) < min_pos)                         \
17661         {                                                       \
17662           min_pos = IT_CHARPOS (*(IT));                         \
17663           min_bpos = IT_BYTEPOS (*(IT));                        \
17664         }                                                       \
17665       if (IT_CHARPOS (*(IT)) > max_pos)                         \
17666         {                                                       \
17667           max_pos = IT_CHARPOS (*(IT));                         \
17668           max_bpos = IT_BYTEPOS (*(IT));                        \
17669         }                                                       \
17670     }                                                           \
17671   while (0)
17672 
17673   /* Loop generating characters.  The loop is left with IT on the next
17674      character to display.  */
17675   while (1)
17676     {
17677       int n_glyphs_before, hpos_before, x_before;
17678       int x, i, nglyphs;
17679       int ascent = 0, descent = 0, phys_ascent = 0, phys_descent = 0;
17680 
17681       /* Retrieve the next thing to display.  Value is zero if end of
17682          buffer reached.  */
17683       if (!get_next_display_element (it))
17684         {
17685           /* Maybe add a space at the end of this line that is used to
17686              display the cursor there under X.  Set the charpos of the
17687              first glyph of blank lines not corresponding to any text
17688              to -1.  */
17689           if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
17690             row->exact_window_width_line_p = 1;
17691           else if ((append_space_for_newline (it, 1) && row->used[TEXT_AREA] == 1)
17692                    || row->used[TEXT_AREA] == 0)
17693             {
17694               row->glyphs[TEXT_AREA]->charpos = -1;
17695               row->displays_text_p = 0;
17696 
17697               if (!NILP (XBUFFER (it->w->buffer)->indicate_empty_lines)
17698                   && (!MINI_WINDOW_P (it->w)
17699                       || (minibuf_level && EQ (it->window, minibuf_window))))
17700                 row->indicate_empty_line_p = 1;
17701             }
17702 
17703           it->continuation_lines_width = 0;
17704           row->ends_at_zv_p = 1;
17705           /* A row that displays right-to-left text must always have
17706              its last face extended all the way to the end of line,
17707              even if this row ends in ZV, because we still write to th
17708              screen left to right.  */
17709           if (row->reversed_p)
17710             extend_face_to_end_of_line (it);
17711           break;
17712         }
17713 
17714       /* Now, get the metrics of what we want to display.  This also
17715          generates glyphs in `row' (which is IT->glyph_row).  */
17716       n_glyphs_before = row->used[TEXT_AREA];
17717       x = it->current_x;
17718 
17719       /* Remember the line height so far in case the next element doesn't
17720          fit on the line.  */
17721       if (it->line_wrap != TRUNCATE)
17722         {
17723           ascent = it->max_ascent;
17724           descent = it->max_descent;
17725           phys_ascent = it->max_phys_ascent;
17726           phys_descent = it->max_phys_descent;
17727 
17728           if (it->line_wrap == WORD_WRAP && it->area == TEXT_AREA)
17729             {
17730               if (IT_DISPLAYING_WHITESPACE (it))
17731                 may_wrap = 1;
17732               else if (may_wrap)
17733                 {
17734                   wrap_it = *it;
17735                   wrap_x = x;
17736                   wrap_row_used = row->used[TEXT_AREA];
17737                   wrap_row_ascent = row->ascent;
17738                   wrap_row_height = row->height;
17739                   wrap_row_phys_ascent = row->phys_ascent;
17740                   wrap_row_phys_height = row->phys_height;
17741                   wrap_row_extra_line_spacing = row->extra_line_spacing;
17742                   wrap_row_min_pos = min_pos;
17743                   wrap_row_min_bpos = min_bpos;
17744                   wrap_row_max_pos = max_pos;
17745                   wrap_row_max_bpos = max_bpos;
17746                   may_wrap = 0;
17747                 }
17748             }
17749         }
17750 
17751       PRODUCE_GLYPHS (it);
17752 
17753       /* If this display element was in marginal areas, continue with
17754          the next one.  */
17755       if (it->area != TEXT_AREA)
17756         {
17757           row->ascent = max (row->ascent, it->max_ascent);
17758           row->height = max (row->height, it->max_ascent + it->max_descent);
17759           row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
17760           row->phys_height = max (row->phys_height,
17761                                   it->max_phys_ascent + it->max_phys_descent);
17762           row->extra_line_spacing = max (row->extra_line_spacing,
17763                                          it->max_extra_line_spacing);
17764           set_iterator_to_next (it, 1);
17765           continue;
17766         }
17767 
17768       /* Does the display element fit on the line?  If we truncate
17769          lines, we should draw past the right edge of the window.  If
17770          we don't truncate, we want to stop so that we can display the
17771          continuation glyph before the right margin.  If lines are
17772          continued, there are two possible strategies for characters
17773          resulting in more than 1 glyph (e.g. tabs): Display as many
17774          glyphs as possible in this line and leave the rest for the
17775          continuation line, or display the whole element in the next
17776          line.  Original redisplay did the former, so we do it also.  */
17777       nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
17778       hpos_before = it->hpos;
17779       x_before = x;
17780 
17781       if (/* Not a newline.  */
17782           nglyphs > 0
17783           /* Glyphs produced fit entirely in the line.  */
17784           && it->current_x < it->last_visible_x)
17785         {
17786           it->hpos += nglyphs;
17787           row->ascent = max (row->ascent, it->max_ascent);
17788           row->height = max (row->height, it->max_ascent + it->max_descent);
17789           row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
17790           row->phys_height = max (row->phys_height,
17791                                   it->max_phys_ascent + it->max_phys_descent);
17792           row->extra_line_spacing = max (row->extra_line_spacing,
17793                                          it->max_extra_line_spacing);
17794           if (it->current_x - it->pixel_width < it->first_visible_x)
17795             row->x = x - it->first_visible_x;
17796           /* Record the maximum and minimum buffer positions seen so
17797              far in glyphs that will be displayed by this row.  */
17798           if (it->bidi_p)
17799             RECORD_MAX_MIN_POS (it);
17800         }
17801       else
17802         {
17803           int new_x;
17804           struct glyph *glyph;
17805 
17806           for (i = 0; i < nglyphs; ++i, x = new_x)
17807             {
17808               glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
17809               new_x = x + glyph->pixel_width;
17810 
17811               if (/* Lines are continued.  */
17812                   it->line_wrap != TRUNCATE
17813                   && (/* Glyph doesn't fit on the line.  */
17814                       new_x > it->last_visible_x
17815                       /* Or it fits exactly on a window system frame.  */
17816                       || (new_x == it->last_visible_x
17817                           && FRAME_WINDOW_P (it->f))))
17818                 {
17819                   /* End of a continued line.  */
17820 
17821                   if (it->hpos == 0
17822                       || (new_x == it->last_visible_x
17823                           && FRAME_WINDOW_P (it->f)))
17824                     {
17825                       /* Current glyph is the only one on the line or
17826                          fits exactly on the line.  We must continue
17827                          the line because we can't draw the cursor
17828                          after the glyph.  */
17829                       row->continued_p = 1;
17830                       it->current_x = new_x;
17831                       it->continuation_lines_width += new_x;
17832                       ++it->hpos;
17833                       /* Record the maximum and minimum buffer
17834                          positions seen so far in glyphs that will be
17835                          displayed by this row.  */
17836                       if (it->bidi_p)
17837                         RECORD_MAX_MIN_POS (it);
17838                       if (i == nglyphs - 1)
17839                         {
17840                           /* If line-wrap is on, check if a previous
17841                              wrap point was found.  */
17842                           if (wrap_row_used > 0
17843                               /* Even if there is a previous wrap
17844                                  point, continue the line here as
17845                                  usual, if (i) the previous character
17846                                  was a space or tab AND (ii) the
17847                                  current character is not.  */
17848                               && (!may_wrap
17849                                   || IT_DISPLAYING_WHITESPACE (it)))
17850                             goto back_to_wrap;
17851 
17852                           set_iterator_to_next (it, 1);
17853                           if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
17854                             {
17855                               if (!get_next_display_element (it))
17856                                 {
17857                                   row->exact_window_width_line_p = 1;
17858                                   it->continuation_lines_width = 0;
17859                                   row->continued_p = 0;
17860                                   row->ends_at_zv_p = 1;
17861                                 }
17862                               else if (ITERATOR_AT_END_OF_LINE_P (it))
17863                                 {
17864                                   row->continued_p = 0;
17865                                   row->exact_window_width_line_p = 1;
17866                                 }
17867                             }
17868                         }
17869                     }
17870                   else if (CHAR_GLYPH_PADDING_P (*glyph)
17871                            && !FRAME_WINDOW_P (it->f))
17872                     {
17873                       /* A padding glyph that doesn't fit on this line.
17874                          This means the whole character doesn't fit
17875                          on the line.  */
17876                       if (row->reversed_p)
17877                         unproduce_glyphs (it, row->used[TEXT_AREA]
17878                                                - n_glyphs_before);
17879                       row->used[TEXT_AREA] = n_glyphs_before;
17880 
17881                       /* Fill the rest of the row with continuation
17882                          glyphs like in 20.x.  */
17883                       while (row->glyphs[TEXT_AREA] + row->used[TEXT_AREA]
17884                              < row->glyphs[1 + TEXT_AREA])
17885                         produce_special_glyphs (it, IT_CONTINUATION);
17886 
17887                       row->continued_p = 1;
17888                       it->current_x = x_before;
17889                       it->continuation_lines_width += x_before;
17890 
17891                       /* Restore the height to what it was before the
17892                          element not fitting on the line.  */
17893                       it->max_ascent = ascent;
17894                       it->max_descent = descent;
17895                       it->max_phys_ascent = phys_ascent;
17896                       it->max_phys_descent = phys_descent;
17897                     }
17898                   else if (wrap_row_used > 0)
17899                     {
17900                     back_to_wrap:
17901                       if (row->reversed_p)
17902                         unproduce_glyphs (it,
17903                                           row->used[TEXT_AREA] - wrap_row_used);
17904                       *it = wrap_it;
17905                       it->continuation_lines_width += wrap_x;
17906                       row->used[TEXT_AREA] = wrap_row_used;
17907                       row->ascent = wrap_row_ascent;
17908                       row->height = wrap_row_height;
17909                       row->phys_ascent = wrap_row_phys_ascent;
17910                       row->phys_height = wrap_row_phys_height;
17911                       row->extra_line_spacing = wrap_row_extra_line_spacing;
17912                       min_pos = wrap_row_min_pos;
17913                       min_bpos = wrap_row_min_bpos;
17914                       max_pos = wrap_row_max_pos;
17915                       max_bpos = wrap_row_max_bpos;
17916                       row->continued_p = 1;
17917                       row->ends_at_zv_p = 0;
17918                       row->exact_window_width_line_p = 0;
17919                       it->continuation_lines_width += x;
17920 
17921                       /* Make sure that a non-default face is extended
17922                          up to the right margin of the window.  */
17923                       extend_face_to_end_of_line (it);
17924                     }
17925                   else if (it->c == '\t' && FRAME_WINDOW_P (it->f))
17926                     {
17927                       /* A TAB that extends past the right edge of the
17928                          window.  This produces a single glyph on
17929                          window system frames.  We leave the glyph in
17930                          this row and let it fill the row, but don't
17931                          consume the TAB.  */
17932                       it->continuation_lines_width += it->last_visible_x;
17933                       row->ends_in_middle_of_char_p = 1;
17934                       row->continued_p = 1;
17935                       glyph->pixel_width = it->last_visible_x - x;
17936                       it->starts_in_middle_of_char_p = 1;
17937                     }
17938                   else
17939                     {
17940                       /* Something other than a TAB that draws past
17941                          the right edge of the window.  Restore
17942                          positions to values before the element.  */
17943                       if (row->reversed_p)
17944                         unproduce_glyphs (it, row->used[TEXT_AREA]
17945                                                - (n_glyphs_before + i));
17946                       row->used[TEXT_AREA] = n_glyphs_before + i;
17947 
17948                       /* Display continuation glyphs.  */
17949                       if (!FRAME_WINDOW_P (it->f))
17950                         produce_special_glyphs (it, IT_CONTINUATION);
17951                       row->continued_p = 1;
17952 
17953                       it->current_x = x_before;
17954                       it->continuation_lines_width += x;
17955                       extend_face_to_end_of_line (it);
17956 
17957                       if (nglyphs > 1 && i > 0)
17958                         {
17959                           row->ends_in_middle_of_char_p = 1;
17960                           it->starts_in_middle_of_char_p = 1;
17961                         }
17962 
17963                       /* Restore the height to what it was before the
17964                          element not fitting on the line.  */
17965                       it->max_ascent = ascent;
17966                       it->max_descent = descent;
17967                       it->max_phys_ascent = phys_ascent;
17968                       it->max_phys_descent = phys_descent;
17969                     }
17970 
17971                   break;
17972                 }
17973               else if (new_x > it->first_visible_x)
17974                 {
17975                   /* Increment number of glyphs actually displayed.  */
17976                   ++it->hpos;
17977 
17978                   /* Record the maximum and minimum buffer positions
17979                      seen so far in glyphs that will be displayed by
17980                      this row.  */
17981                   if (it->bidi_p)
17982                     RECORD_MAX_MIN_POS (it);
17983 
17984                   if (x < it->first_visible_x)
17985                     /* Glyph is partially visible, i.e. row starts at
17986                        negative X position.  */
17987                     row->x = x - it->first_visible_x;
17988                 }
17989               else
17990                 {
17991                   /* Glyph is completely off the left margin of the
17992                      window.  This should not happen because of the
17993                      move_it_in_display_line at the start of this
17994                      function, unless the text display area of the
17995                      window is empty.  */
17996                   xassert (it->first_visible_x <= it->last_visible_x);
17997                 }
17998             }
17999 
18000           row->ascent = max (row->ascent, it->max_ascent);
18001           row->height = max (row->height, it->max_ascent + it->max_descent);
18002           row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
18003           row->phys_height = max (row->phys_height,
18004                                   it->max_phys_ascent + it->max_phys_descent);
18005           row->extra_line_spacing = max (row->extra_line_spacing,
18006                                          it->max_extra_line_spacing);
18007 
18008           /* End of this display line if row is continued.  */
18009           if (row->continued_p || row->ends_at_zv_p)
18010             break;
18011         }
18012 
18013     at_end_of_line:
18014       /* Is this a line end?  If yes, we're also done, after making
18015          sure that a non-default face is extended up to the right
18016          margin of the window.  */
18017       if (ITERATOR_AT_END_OF_LINE_P (it))
18018         {
18019           int used_before = row->used[TEXT_AREA];
18020 
18021           row->ends_in_newline_from_string_p = STRINGP (it->object);
18022 
18023           /* Add a space at the end of the line that is used to
18024              display the cursor there.  */
18025           if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
18026             append_space_for_newline (it, 0);
18027 
18028           /* Extend the face to the end of the line.  */
18029           extend_face_to_end_of_line (it);
18030 
18031           /* Make sure we have the position.  */
18032           if (used_before == 0)
18033             row->glyphs[TEXT_AREA]->charpos = CHARPOS (it->position);
18034 
18035           /* Record the position of the newline, for use in
18036              find_row_edges.  */
18037           it->eol_pos = it->current.pos;
18038 
18039           /* Consume the line end.  This skips over invisible lines.  */
18040           set_iterator_to_next (it, 1);
18041           it->continuation_lines_width = 0;
18042           break;
18043         }
18044 
18045       /* Proceed with next display element.  Note that this skips
18046          over lines invisible because of selective display.  */
18047       set_iterator_to_next (it, 1);
18048 
18049       /* If we truncate lines, we are done when the last displayed
18050          glyphs reach past the right margin of the window.  */
18051       if (it->line_wrap == TRUNCATE
18052           && (FRAME_WINDOW_P (it->f)
18053               ? (it->current_x >= it->last_visible_x)
18054               : (it->current_x > it->last_visible_x)))
18055         {
18056           /* Maybe add truncation glyphs.  */
18057           if (!FRAME_WINDOW_P (it->f))
18058             {
18059               int i, n;
18060 
18061               if (!row->reversed_p)
18062                 {
18063                   for (i = row->used[TEXT_AREA] - 1; i > 0; --i)
18064                     if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
18065                       break;
18066                 }
18067               else
18068                 {
18069                   for (i = 0; i < row->used[TEXT_AREA]; i++)
18070                     if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
18071                       break;
18072                   /* Remove any padding glyphs at the front of ROW, to
18073                      make room for the truncation glyphs we will be
18074                      adding below.  The loop below always inserts at
18075                      least one truncation glyph, so also remove the
18076                      last glyph added to ROW.  */
18077                   unproduce_glyphs (it, i + 1);
18078                   /* Adjust i for the loop below.  */
18079                   i = row->used[TEXT_AREA] - (i + 1);
18080                 }
18081 
18082               for (n = row->used[TEXT_AREA]; i < n; ++i)
18083                 {
18084                   row->used[TEXT_AREA] = i;
18085                   produce_special_glyphs (it, IT_TRUNCATION);
18086                 }
18087             }
18088           else if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
18089             {
18090               /* Don't truncate if we can overflow newline into fringe.  */
18091               if (!get_next_display_element (it))
18092                 {
18093                   it->continuation_lines_width = 0;
18094                   row->ends_at_zv_p = 1;
18095                   row->exact_window_width_line_p = 1;
18096                   break;
18097                 }
18098               if (ITERATOR_AT_END_OF_LINE_P (it))
18099                 {
18100                   row->exact_window_width_line_p = 1;
18101                   goto at_end_of_line;
18102                 }
18103             }
18104 
18105           row->truncated_on_right_p = 1;
18106           it->continuation_lines_width = 0;
18107           reseat_at_next_visible_line_start (it, 0);
18108           row->ends_at_zv_p = FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n';
18109           it->hpos = hpos_before;
18110           it->current_x = x_before;
18111           break;
18112         }
18113     }
18114 
18115   /* If line is not empty and hscrolled, maybe insert truncation glyphs
18116      at the left window margin.  */
18117   if (it->first_visible_x
18118       && IT_CHARPOS (*it) != CHARPOS (row->start.pos))
18119     {
18120       if (!FRAME_WINDOW_P (it->f))
18121         insert_left_trunc_glyphs (it);
18122       row->truncated_on_left_p = 1;
18123     }
18124 
18125   /* If the start of this line is the overlay arrow-position, then
18126      mark this glyph row as the one containing the overlay arrow.
18127      This is clearly a mess with variable size fonts.  It would be
18128      better to let it be displayed like cursors under X.  */
18129   if ((row->displays_text_p || !overlay_arrow_seen)
18130       && (overlay_arrow_string = overlay_arrow_at_row (it, row),
18131           !NILP (overlay_arrow_string)))
18132     {
18133       /* Overlay arrow in window redisplay is a fringe bitmap.  */
18134       if (STRINGP (overlay_arrow_string))
18135         {
18136           struct glyph_row *arrow_row
18137             = get_overlay_arrow_glyph_row (it->w, overlay_arrow_string);
18138           struct glyph *glyph = arrow_row->glyphs[TEXT_AREA];
18139           struct glyph *arrow_end = glyph + arrow_row->used[TEXT_AREA];
18140           struct glyph *p = row->glyphs[TEXT_AREA];
18141           struct glyph *p2, *end;
18142 
18143           /* Copy the arrow glyphs.  */
18144           while (glyph < arrow_end)
18145             *p++ = *glyph++;
18146 
18147           /* Throw away padding glyphs.  */
18148           p2 = p;
18149           end = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
18150           while (p2 < end && CHAR_GLYPH_PADDING_P (*p2))
18151             ++p2;
18152           if (p2 > p)
18153             {
18154               while (p2 < end)
18155                 *p++ = *p2++;
18156               row->used[TEXT_AREA] = p2 - row->glyphs[TEXT_AREA];
18157             }
18158         }
18159       else
18160         {
18161           xassert (INTEGERP (overlay_arrow_string));
18162           row->overlay_arrow_bitmap = XINT (overlay_arrow_string);
18163         }
18164       overlay_arrow_seen = 1;
18165     }
18166 
18167   /* Compute pixel dimensions of this line.  */
18168   compute_line_metrics (it);
18169 
18170   /* Remember the position at which this line ends.  */
18171   row->end = it->current;
18172   if (!it->bidi_p)
18173     {
18174       row->minpos = row->start.pos;
18175       row->maxpos = row->end.pos;
18176     }
18177   else
18178     {
18179       /* ROW->minpos and ROW->maxpos must be the smallest and
18180          `1 + the largest' buffer positions in ROW.  But if ROW was
18181          bidi-reordered, these two positions can be anywhere in the
18182          row, so we must determine them now.  */
18183       find_row_edges (it, row, min_pos, min_bpos, max_pos, max_bpos);
18184     }
18185 
18186   /* Record whether this row ends inside an ellipsis.  */
18187   row->ends_in_ellipsis_p
18188     = (it->method == GET_FROM_DISPLAY_VECTOR
18189        && it->ellipsis_p);
18190 
18191   /* Save fringe bitmaps in this row.  */
18192   row->left_user_fringe_bitmap = it->left_user_fringe_bitmap;
18193   row->left_user_fringe_face_id = it->left_user_fringe_face_id;
18194   row->right_user_fringe_bitmap = it->right_user_fringe_bitmap;
18195   row->right_user_fringe_face_id = it->right_user_fringe_face_id;
18196 
18197   it->left_user_fringe_bitmap = 0;
18198   it->left_user_fringe_face_id = 0;
18199   it->right_user_fringe_bitmap = 0;
18200   it->right_user_fringe_face_id = 0;
18201 
18202   /* Maybe set the cursor.  */
18203   cvpos = it->w->cursor.vpos;
18204   if ((cvpos < 0
18205        /* In bidi-reordered rows, keep checking for proper cursor
18206           position even if one has been found already, because buffer
18207           positions in such rows change non-linearly with ROW->VPOS,
18208           when a line is continued.  One exception: when we are at ZV,
18209           display cursor on the first suitable glyph row, since all
18210           the empty rows after that also have their position set to ZV.  */
18211        /* FIXME: Revisit this when glyph ``spilling'' in continuation
18212           lines' rows is implemented for bidi-reordered rows.  */
18213        || (it->bidi_p
18214            && !MATRIX_ROW (it->w->desired_matrix, cvpos)->ends_at_zv_p))
18215       && PT >= MATRIX_ROW_START_CHARPOS (row)
18216       && PT <= MATRIX_ROW_END_CHARPOS (row)
18217       && cursor_row_p (it->w, row))
18218     set_cursor_from_row (it->w, row, it->w->desired_matrix, 0, 0, 0, 0);
18219 
18220   /* Highlight trailing whitespace.  */
18221   if (!NILP (Vshow_trailing_whitespace))
18222     highlight_trailing_whitespace (it->f, it->glyph_row);
18223 
18224   /* Prepare for the next line.  This line starts horizontally at (X
18225      HPOS) = (0 0).  Vertical positions are incremented.  As a
18226      convenience for the caller, IT->glyph_row is set to the next
18227      row to be used.  */
18228   it->current_x = it->hpos = 0;
18229   it->current_y += row->height;
18230   SET_TEXT_POS (it->eol_pos, 0, 0);
18231   ++it->vpos;
18232   ++it->glyph_row;
18233   /* The next row should by default use the same value of the
18234      reversed_p flag as this one.  set_iterator_to_next decides when
18235      it's a new paragraph, and PRODUCE_GLYPHS recomputes the value of
18236      the flag accordingly.  */
18237   if (it->glyph_row < MATRIX_BOTTOM_TEXT_ROW (it->w->desired_matrix, it->w))
18238     it->glyph_row->reversed_p = row->reversed_p;
18239   it->start = row->end;
18240   return row->displays_text_p;
18241 
18242 #undef RECORD_MAX_MIN_POS
18243 }
18244 
18245 DEFUN ("current-bidi-paragraph-direction", Fcurrent_bidi_paragraph_direction,
18246        Scurrent_bidi_paragraph_direction, 0, 1, 0,
18247        doc: /* Return paragraph direction at point in BUFFER.
18248 Value is either `left-to-right' or `right-to-left'.
18249 If BUFFER is omitted or nil, it defaults to the current buffer.
18250 
18251 Paragraph direction determines how the text in the paragraph is displayed.
18252 In left-to-right paragraphs, text begins at the left margin of the window
18253 and the reading direction is generally left to right.  In right-to-left
18254 paragraphs, text begins at the right margin and is read from right to left.
18255 
18256 See also `bidi-paragraph-direction'.  */)
18257      (buffer)
18258      Lisp_Object buffer;
18259 {
18260   struct buffer *buf;
18261   struct buffer *old;
18262 
18263   if (NILP (buffer))
18264     buf = current_buffer;
18265   else
18266     {
18267       CHECK_BUFFER (buffer);
18268       buf = XBUFFER (buffer);
18269       old = current_buffer;
18270     }
18271 
18272   if (NILP (buf->bidi_display_reordering))
18273     return Qleft_to_right;
18274   else if (!NILP (buf->bidi_paragraph_direction))
18275     return buf->bidi_paragraph_direction;
18276   else
18277     {
18278       /* Determine the direction from buffer text.  We could try to
18279          use current_matrix if it is up to date, but this seems fast
18280          enough as it is.  */
18281       struct bidi_it itb;
18282       EMACS_INT pos = BUF_PT (buf);
18283       EMACS_INT bytepos = BUF_PT_BYTE (buf);
18284 
18285       if (buf != current_buffer)
18286         set_buffer_temp (buf);
18287       /* Find previous non-empty line.  */
18288       if (pos >= ZV && pos > BEGV)
18289         {
18290           pos--;
18291           bytepos = CHAR_TO_BYTE (pos);
18292         }
18293       while (FETCH_BYTE (bytepos) == '\n')
18294         {
18295           if (bytepos <= BEGV_BYTE)
18296             break;
18297           bytepos--;
18298           pos--;
18299         }
18300       while (!CHAR_HEAD_P (FETCH_BYTE (bytepos)))
18301         bytepos--;
18302       itb.charpos = pos;
18303       itb.bytepos = bytepos;
18304       itb.first_elt = 1;
18305 
18306       bidi_paragraph_init (NEUTRAL_DIR, &itb);
18307       if (buf != current_buffer)
18308         set_buffer_temp (old);
18309       switch (itb.paragraph_dir)
18310         {
18311         case L2R:
18312           return Qleft_to_right;
18313           break;
18314         case R2L:
18315           return Qright_to_left;
18316           break;
18317         default:
18318           abort ();
18319         }
18320     }
18321 }
18322 
18323 
18324 
18325 /***********************************************************************
18326                                Menu Bar
18327  ***********************************************************************/
18328 
18329 /* Redisplay the menu bar in the frame for window W.
18330 
18331    The menu bar of X frames that don't have X toolkit support is
18332    displayed in a special window W->frame->menu_bar_window.
18333 
18334    The menu bar of terminal frames is treated specially as far as
18335    glyph matrices are concerned.  Menu bar lines are not part of
18336    windows, so the update is done directly on the frame matrix rows
18337    for the menu bar.  */
18338 
18339 static void
18340 display_menu_bar (w)
18341      struct window *w;
18342 {
18343   struct frame *f = XFRAME (WINDOW_FRAME (w));
18344   struct it it;
18345   Lisp_Object items;
18346   int i;
18347 
18348   /* Don't do all this for graphical frames.  */
18349 #ifdef HAVE_NTGUI
18350   if (FRAME_W32_P (f))
18351     return;
18352 #endif
18353 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
18354   if (FRAME_X_P (f))
18355     return;
18356 #endif
18357 
18358 #ifdef HAVE_NS
18359   if (FRAME_NS_P (f))
18360     return;
18361 #endif /* HAVE_NS */
18362 
18363 #ifdef USE_X_TOOLKIT
18364   xassert (!FRAME_WINDOW_P (f));
18365   init_iterator (&it, w, -1, -1, f->desired_matrix->rows, MENU_FACE_ID);
18366   it.first_visible_x = 0;
18367   it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
18368 #else /* not USE_X_TOOLKIT */
18369   if (FRAME_WINDOW_P (f))
18370     {
18371       /* Menu bar lines are displayed in the desired matrix of the
18372          dummy window menu_bar_window.  */
18373       struct window *menu_w;
18374       xassert (WINDOWP (f->menu_bar_window));
18375       menu_w = XWINDOW (f->menu_bar_window);
18376       init_iterator (&it, menu_w, -1, -1, menu_w->desired_matrix->rows,
18377                      MENU_FACE_ID);
18378       it.first_visible_x = 0;
18379       it.last_visible_x = FRAME_TOTAL_COLS (f) * FRAME_COLUMN_WIDTH (f);
18380     }
18381   else
18382     {
18383       /* This is a TTY frame, i.e. character hpos/vpos are used as
18384          pixel x/y.  */
18385       init_iterator (&it, w, -1, -1, f->desired_matrix->rows,
18386                      MENU_FACE_ID);
18387       it.first_visible_x = 0;
18388       it.last_visible_x = FRAME_COLS (f);
18389     }
18390 #endif /* not USE_X_TOOLKIT */
18391 
18392   if (! mode_line_inverse_video)
18393     /* Force the menu-bar to be displayed in the default face.  */
18394     it.base_face_id = it.face_id = DEFAULT_FACE_ID;
18395 
18396   /* Clear all rows of the menu bar.  */
18397   for (i = 0; i < FRAME_MENU_BAR_LINES (f); ++i)
18398     {
18399       struct glyph_row *row = it.glyph_row + i;
18400       clear_glyph_row (row);
18401       row->enabled_p = 1;
18402       row->full_width_p = 1;
18403     }
18404 
18405   /* Display all items of the menu bar.  */
18406   items = FRAME_MENU_BAR_ITEMS (it.f);
18407   for (i = 0; i < XVECTOR (items)->size; i += 4)
18408     {
18409       Lisp_Object string;
18410 
18411       /* Stop at nil string.  */
18412       string = AREF (items, i + 1);
18413       if (NILP (string))
18414         break;
18415 
18416       /* Remember where item was displayed.  */
18417       ASET (items, i + 3, make_number (it.hpos));
18418 
18419       /* Display the item, pad with one space.  */
18420       if (it.current_x < it.last_visible_x)
18421         display_string (NULL, string, Qnil, 0, 0, &it,
18422                         SCHARS (string) + 1, 0, 0, -1);
18423     }
18424 
18425   /* Fill out the line with spaces.  */
18426   if (it.current_x < it.last_visible_x)
18427     display_string ("", Qnil, Qnil, 0, 0, &it, -1, 0, 0, -1);
18428 
18429   /* Compute the total height of the lines.  */
18430   compute_line_metrics (&it);
18431 }
18432 
18433 
18434 
18435 /***********************************************************************
18436                               Mode Line
18437  ***********************************************************************/
18438 
18439 /* Redisplay mode lines in the window tree whose root is WINDOW.  If
18440    FORCE is non-zero, redisplay mode lines unconditionally.
18441    Otherwise, redisplay only mode lines that are garbaged.  Value is
18442    the number of windows whose mode lines were redisplayed.  */
18443 
18444 static int
18445 redisplay_mode_lines (window, force)
18446      Lisp_Object window;
18447      int force;
18448 {
18449   int nwindows = 0;
18450 
18451   while (!NILP (window))
18452     {
18453       struct window *w = XWINDOW (window);
18454 
18455       if (WINDOWP (w->hchild))
18456         nwindows += redisplay_mode_lines (w->hchild, force);
18457       else if (WINDOWP (w->vchild))
18458         nwindows += redisplay_mode_lines (w->vchild, force);
18459       else if (force
18460                || FRAME_GARBAGED_P (XFRAME (w->frame))
18461                || !MATRIX_MODE_LINE_ROW (w->current_matrix)->enabled_p)
18462         {
18463           struct text_pos lpoint;
18464           struct buffer *old = current_buffer;
18465 
18466           /* Set the window's buffer for the mode line display.  */
18467           SET_TEXT_POS (lpoint, PT, PT_BYTE);
18468           set_buffer_internal_1 (XBUFFER (w->buffer));
18469 
18470           /* Point refers normally to the selected window.  For any
18471              other window, set up appropriate value.  */
18472           if (!EQ (window, selected_window))
18473             {
18474               struct text_pos pt;
18475 
18476               SET_TEXT_POS_FROM_MARKER (pt, w->pointm);
18477               if (CHARPOS (pt) < BEGV)
18478                 TEMP_SET_PT_BOTH (BEGV, BEGV_BYTE);
18479               else if (CHARPOS (pt) > (ZV - 1))
18480                 TEMP_SET_PT_BOTH (ZV, ZV_BYTE);
18481               else
18482                 TEMP_SET_PT_BOTH (CHARPOS (pt), BYTEPOS (pt));
18483             }
18484 
18485           /* Display mode lines.  */
18486           clear_glyph_matrix (w->desired_matrix);
18487           if (display_mode_lines (w))
18488             {
18489               ++nwindows;
18490               w->must_be_updated_p = 1;
18491             }
18492 
18493           /* Restore old settings.  */
18494           set_buffer_internal_1 (old);
18495           TEMP_SET_PT_BOTH (CHARPOS (lpoint), BYTEPOS (lpoint));
18496         }
18497 
18498       window = w->next;
18499     }
18500 
18501   return nwindows;
18502 }
18503 
18504 
18505 /* Display the mode and/or header line of window W.  Value is the
18506    sum number of mode lines and header lines displayed.  */
18507 
18508 static int
18509 display_mode_lines (w)
18510      struct window *w;
18511 {
18512   Lisp_Object old_selected_window, old_selected_frame;
18513   int n = 0;
18514 
18515   old_selected_frame = selected_frame;
18516   selected_frame = w->frame;
18517   old_selected_window = selected_window;
18518   XSETWINDOW (selected_window, w);
18519 
18520   /* These will be set while the mode line specs are processed.  */
18521   line_number_displayed = 0;
18522   w->column_number_displayed = Qnil;
18523 
18524   if (WINDOW_WANTS_MODELINE_P (w))
18525     {
18526       struct window *sel_w = XWINDOW (old_selected_window);
18527 
18528       /* Select mode line face based on the real selected window.  */
18529       display_mode_line (w, CURRENT_MODE_LINE_FACE_ID_3 (sel_w, sel_w, w),
18530                          current_buffer->mode_line_format);
18531       ++n;
18532     }
18533 
18534   if (WINDOW_WANTS_HEADER_LINE_P (w))
18535     {
18536       display_mode_line (w, HEADER_LINE_FACE_ID,
18537                          current_buffer->header_line_format);
18538       ++n;
18539     }
18540 
18541   selected_frame = old_selected_frame;
18542   selected_window = old_selected_window;
18543   return n;
18544 }
18545 
18546 
18547 /* Display mode or header line of window W.  FACE_ID specifies which
18548    line to display; it is either MODE_LINE_FACE_ID or
18549    HEADER_LINE_FACE_ID.  FORMAT is the mode/header line format to
18550    display.  Value is the pixel height of the mode/header line
18551    displayed.  */
18552 
18553 static int
18554 display_mode_line (w, face_id, format)
18555      struct window *w;
18556      enum face_id face_id;
18557      Lisp_Object format;
18558 {
18559   struct it it;
18560   struct face *face;
18561   int count = SPECPDL_INDEX ();
18562 
18563   init_iterator (&it, w, -1, -1, NULL, face_id);
18564   /* Don't extend on a previously drawn mode-line.
18565      This may happen if called from pos_visible_p.  */
18566   it.glyph_row->enabled_p = 0;
18567   prepare_desired_row (it.glyph_row);
18568 
18569   it.glyph_row->mode_line_p = 1;
18570 
18571   if (! mode_line_inverse_video)
18572     /* Force the mode-line to be displayed in the default face.  */
18573     it.base_face_id = it.face_id = DEFAULT_FACE_ID;
18574 
18575   record_unwind_protect (unwind_format_mode_line,
18576                          format_mode_line_unwind_data (NULL, Qnil, 0));
18577 
18578   mode_line_target = MODE_LINE_DISPLAY;
18579 
18580   /* Temporarily make frame's keyboard the current kboard so that
18581      kboard-local variables in the mode_line_format will get the right
18582      values.  */
18583   push_kboard (FRAME_KBOARD (it.f));
18584   record_unwind_save_match_data ();
18585   display_mode_element (&it, 0, 0, 0, format, Qnil, 0);
18586   pop_kboard ();
18587 
18588   unbind_to (count, Qnil);
18589 
18590   /* Fill up with spaces.  */
18591   display_string (" ", Qnil, Qnil, 0, 0, &it, 10000, -1, -1, 0);
18592 
18593   compute_line_metrics (&it);
18594   it.glyph_row->full_width_p = 1;
18595   it.glyph_row->continued_p = 0;
18596   it.glyph_row->truncated_on_left_p = 0;
18597   it.glyph_row->truncated_on_right_p = 0;
18598 
18599   /* Make a 3D mode-line have a shadow at its right end.  */
18600   face = FACE_FROM_ID (it.f, face_id);
18601   extend_face_to_end_of_line (&it);
18602   if (face->box != FACE_NO_BOX)
18603     {
18604       struct glyph *last = (it.glyph_row->glyphs[TEXT_AREA]
18605                             + it.glyph_row->used[TEXT_AREA] - 1);
18606       last->right_box_line_p = 1;
18607     }
18608 
18609   return it.glyph_row->height;
18610 }
18611 
18612 /* Move element ELT in LIST to the front of LIST.
18613    Return the updated list.  */
18614 
18615 static Lisp_Object
18616 move_elt_to_front (elt, list)
18617      Lisp_Object elt, list;
18618 {
18619   register Lisp_Object tail, prev;
18620   register Lisp_Object tem;
18621 
18622   tail = list;
18623   prev = Qnil;
18624   while (CONSP (tail))
18625     {
18626       tem = XCAR (tail);
18627 
18628       if (EQ (elt, tem))
18629         {
18630           /* Splice out the link TAIL.  */
18631           if (NILP (prev))
18632             list = XCDR (tail);
18633           else
18634             Fsetcdr (prev, XCDR (tail));
18635 
18636           /* Now make it the first.  */
18637           Fsetcdr (tail, list);
18638           return tail;
18639         }
18640       else
18641         prev = tail;
18642       tail = XCDR (tail);
18643       QUIT;
18644     }
18645 
18646   /* Not found--return unchanged LIST.  */
18647   return list;
18648 }
18649 
18650 /* Contribute ELT to the mode line for window IT->w.  How it
18651    translates into text depends on its data type.
18652 
18653    IT describes the display environment in which we display, as usual.
18654 
18655    DEPTH is the depth in recursion.  It is used to prevent
18656    infinite recursion here.
18657 
18658    FIELD_WIDTH is the number of characters the display of ELT should
18659    occupy in the mode line, and PRECISION is the maximum number of
18660    characters to display from ELT's representation.  See
18661    display_string for details.
18662 
18663    Returns the hpos of the end of the text generated by ELT.
18664 
18665    PROPS is a property list to add to any string we encounter.
18666 
18667    If RISKY is nonzero, remove (disregard) any properties in any string
18668    we encounter, and ignore :eval and :propertize.
18669 
18670    The global variable `mode_line_target' determines whether the
18671    output is passed to `store_mode_line_noprop',
18672    `store_mode_line_string', or `display_string'.  */
18673 
18674 static int
18675 display_mode_element (it, depth, field_width, precision, elt, props, risky)
18676      struct it *it;
18677      int depth;
18678      int field_width, precision;
18679      Lisp_Object elt, props;
18680      int risky;
18681 {
18682   int n = 0, field, prec;
18683   int literal = 0;
18684 
18685  tail_recurse:
18686   if (depth > 100)
18687     elt = build_string ("*too-deep*");
18688 
18689   depth++;
18690 
18691   switch (SWITCH_ENUM_CAST (XTYPE (elt)))
18692     {
18693     case Lisp_String:
18694       {
18695         /* A string: output it and check for %-constructs within it.  */
18696         unsigned char c;
18697         int offset = 0;
18698 
18699         if (SCHARS (elt) > 0
18700             && (!NILP (props) || risky))
18701           {
18702             Lisp_Object oprops, aelt;
18703             oprops = Ftext_properties_at (make_number (0), elt);
18704 
18705             /* If the starting string's properties are not what
18706                we want, translate the string.  Also, if the string
18707                is risky, do that anyway.  */
18708 
18709             if (NILP (Fequal (props, oprops)) || risky)
18710               {
18711                 /* If the starting string has properties,
18712                    merge the specified ones onto the existing ones.  */
18713                 if (! NILP (oprops) && !risky)
18714                   {
18715                     Lisp_Object tem;
18716 
18717                     oprops = Fcopy_sequence (oprops);
18718                     tem = props;
18719                     while (CONSP (tem))
18720                       {
18721                         oprops = Fplist_put (oprops, XCAR (tem),
18722                                              XCAR (XCDR (tem)));
18723                         tem = XCDR (XCDR (tem));
18724                       }
18725                     props = oprops;
18726                   }
18727 
18728                 aelt = Fassoc (elt, mode_line_proptrans_alist);
18729                 if (! NILP (aelt) && !NILP (Fequal (props, XCDR (aelt))))
18730                   {
18731                     /* AELT is what we want.  Move it to the front
18732                        without consing.  */
18733                     elt = XCAR (aelt);
18734                     mode_line_proptrans_alist
18735                       = move_elt_to_front (aelt, mode_line_proptrans_alist);
18736                   }
18737                 else
18738                   {
18739                     Lisp_Object tem;
18740 
18741                     /* If AELT has the wrong props, it is useless.
18742                        so get rid of it.  */
18743                     if (! NILP (aelt))
18744                       mode_line_proptrans_alist
18745                         = Fdelq (aelt, mode_line_proptrans_alist);
18746 
18747                     elt = Fcopy_sequence (elt);
18748                     Fset_text_properties (make_number (0), Flength (elt),
18749                                           props, elt);
18750                     /* Add this item to mode_line_proptrans_alist.  */
18751                     mode_line_proptrans_alist
18752                       = Fcons (Fcons (elt, props),
18753                                mode_line_proptrans_alist);
18754                     /* Truncate mode_line_proptrans_alist
18755                        to at most 50 elements.  */
18756                     tem = Fnthcdr (make_number (50),
18757                                    mode_line_proptrans_alist);
18758                     if (! NILP (tem))
18759                       XSETCDR (tem, Qnil);
18760                   }
18761               }
18762           }
18763 
18764         offset = 0;
18765 
18766         if (literal)
18767           {
18768             prec = precision - n;
18769             switch (mode_line_target)
18770               {
18771               case MODE_LINE_NOPROP:
18772               case MODE_LINE_TITLE:
18773                 n += store_mode_line_noprop (SDATA (elt), -1, prec);
18774                 break;
18775               case MODE_LINE_STRING:
18776                 n += store_mode_line_string (NULL, elt, 1, 0, prec, Qnil);
18777                 break;
18778               case MODE_LINE_DISPLAY:
18779                 n += display_string (NULL, elt, Qnil, 0, 0, it,
18780                                      0, prec, 0, STRING_MULTIBYTE (elt));
18781                 break;
18782               }
18783 
18784             break;
18785           }
18786 
18787         /* Handle the non-literal case.  */
18788 
18789         while ((precision <= 0 || n < precision)
18790                && SREF (elt, offset) != 0
18791                && (mode_line_target != MODE_LINE_DISPLAY
18792                    || it->current_x < it->last_visible_x))
18793           {
18794             int last_offset = offset;
18795 
18796             /* Advance to end of string or next format specifier.  */
18797             while ((c = SREF (elt, offset++)) != '\0' && c != '%')
18798               ;
18799 
18800             if (offset - 1 != last_offset)
18801               {
18802                 int nchars, nbytes;
18803 
18804                 /* Output to end of string or up to '%'.  Field width
18805                    is length of string.  Don't output more than
18806                    PRECISION allows us.  */
18807                 offset--;
18808 
18809                 prec = c_string_width (SDATA (elt) + last_offset,
18810                                        offset - last_offset, precision - n,
18811                                        &nchars, &nbytes);
18812 
18813                 switch (mode_line_target)
18814                   {
18815                   case MODE_LINE_NOPROP:
18816                   case MODE_LINE_TITLE:
18817                     n += store_mode_line_noprop (SDATA (elt) + last_offset, 0, prec);
18818                     break;
18819                   case MODE_LINE_STRING:
18820                     {
18821                       int bytepos = last_offset;
18822                       int charpos = string_byte_to_char (elt, bytepos);
18823                       int endpos = (precision <= 0
18824                                     ? string_byte_to_char (elt, offset)
18825                                     : charpos + nchars);
18826 
18827                       n += store_mode_line_string (NULL,
18828                                                    Fsubstring (elt, make_number (charpos),
18829                                                                make_number (endpos)),
18830                                                    0, 0, 0, Qnil);
18831                     }
18832                     break;
18833                   case MODE_LINE_DISPLAY:
18834                     {
18835                       int bytepos = last_offset;
18836                       int charpos = string_byte_to_char (elt, bytepos);
18837 
18838                       if (precision <= 0)
18839                         nchars = string_byte_to_char (elt, offset) - charpos;
18840                       n += display_string (NULL, elt, Qnil, 0, charpos,
18841                                            it, 0, nchars, 0,
18842                                            STRING_MULTIBYTE (elt));
18843                     }
18844                     break;
18845                   }
18846               }
18847             else /* c == '%' */
18848               {
18849                 int percent_position = offset;
18850 
18851                 /* Get the specified minimum width.  Zero means
18852                    don't pad.  */
18853                 field = 0;
18854                 while ((c = SREF (elt, offset++)) >= '0' && c <= '9')
18855                   field = field * 10 + c - '0';
18856 
18857                 /* Don't pad beyond the total padding allowed.  */
18858                 if (field_width - n > 0 && field > field_width - n)
18859                   field = field_width - n;
18860 
18861                 /* Note that either PRECISION <= 0 or N < PRECISION.  */
18862                 prec = precision - n;
18863 
18864                 if (c == 'M')
18865                   n += display_mode_element (it, depth, field, prec,
18866                                              Vglobal_mode_string, props,
18867                                              risky);
18868                 else if (c != 0)
18869                   {
18870                     int multibyte;
18871                     int bytepos, charpos;
18872                     unsigned char *spec;
18873                     Lisp_Object string;
18874 
18875                     bytepos = percent_position;
18876                     charpos = (STRING_MULTIBYTE (elt)
18877                                ? string_byte_to_char (elt, bytepos)
18878                                : bytepos);
18879                     spec = decode_mode_spec (it->w, c, field, prec, &string);
18880                     multibyte = STRINGP (string) && STRING_MULTIBYTE (string);
18881 
18882                     switch (mode_line_target)
18883                       {
18884                       case MODE_LINE_NOPROP:
18885                       case MODE_LINE_TITLE:
18886                         n += store_mode_line_noprop (spec, field, prec);
18887                         break;
18888                       case MODE_LINE_STRING:
18889                         {
18890                           int len = strlen (spec);
18891                           Lisp_Object tem = make_string (spec, len);
18892                           props = Ftext_properties_at (make_number (charpos), elt);
18893                           /* Should only keep face property in props */
18894                           n += store_mode_line_string (NULL, tem, 0, field, prec, props);
18895                         }
18896                         break;
18897                       case MODE_LINE_DISPLAY:
18898                         {
18899                           int nglyphs_before, nwritten;
18900 
18901                           nglyphs_before = it->glyph_row->used[TEXT_AREA];
18902                           nwritten = display_string (spec, string, elt,
18903                                                      charpos, 0, it,
18904                                                      field, prec, 0,
18905                                                      multibyte);
18906 
18907                           /* Assign to the glyphs written above the
18908                              string where the `%x' came from, position
18909                              of the `%'.  */
18910                           if (nwritten > 0)
18911                             {
18912                               struct glyph *glyph
18913                                 = (it->glyph_row->glyphs[TEXT_AREA]
18914                                    + nglyphs_before);
18915                               int i;
18916 
18917                               for (i = 0; i < nwritten; ++i)
18918                                 {
18919                                   glyph[i].object = elt;
18920                                   glyph[i].charpos = charpos;
18921                                 }
18922 
18923                               n += nwritten;
18924                             }
18925                         }
18926                         break;
18927                       }
18928                   }
18929                 else /* c == 0 */
18930                   break;
18931               }
18932           }
18933       }
18934       break;
18935 
18936     case Lisp_Symbol:
18937       /* A symbol: process the value of the symbol recursively
18938          as if it appeared here directly.  Avoid error if symbol void.
18939          Special case: if value of symbol is a string, output the string
18940          literally.  */
18941       {
18942         register Lisp_Object tem;
18943 
18944         /* If the variable is not marked as risky to set
18945            then its contents are risky to use.  */
18946         if (NILP (Fget (elt, Qrisky_local_variable)))
18947           risky = 1;
18948 
18949         tem = Fboundp (elt);
18950         if (!NILP (tem))
18951           {
18952             tem = Fsymbol_value (elt);
18953             /* If value is a string, output that string literally:
18954                don't check for % within it.  */
18955             if (STRINGP (tem))
18956               literal = 1;
18957 
18958             if (!EQ (tem, elt))
18959               {
18960                 /* Give up right away for nil or t.  */
18961                 elt = tem;
18962                 goto tail_recurse;
18963               }
18964           }
18965       }
18966       break;
18967 
18968     case Lisp_Cons:
18969       {
18970         register Lisp_Object car, tem;
18971 
18972         /* A cons cell: five distinct cases.
18973            If first element is :eval or :propertize, do something special.
18974            If first element is a string or a cons, process all the elements
18975            and effectively concatenate them.
18976            If first element is a negative number, truncate displaying cdr to
18977            at most that many characters.  If positive, pad (with spaces)
18978            to at least that many characters.
18979            If first element is a symbol, process the cadr or caddr recursively
18980            according to whether the symbol's value is non-nil or nil.  */
18981         car = XCAR (elt);
18982         if (EQ (car, QCeval))
18983           {
18984             /* An element of the form (:eval FORM) means evaluate FORM
18985                and use the result as mode line elements.  */
18986 
18987             if (risky)
18988               break;
18989 
18990             if (CONSP (XCDR (elt)))
18991               {
18992                 Lisp_Object spec;
18993                 spec = safe_eval (XCAR (XCDR (elt)));
18994                 n += display_mode_element (it, depth, field_width - n,
18995                                            precision - n, spec, props,
18996                                            risky);
18997               }
18998           }
18999         else if (EQ (car, QCpropertize))
19000           {
19001             /* An element of the form (:propertize ELT PROPS...)
19002                means display ELT but applying properties PROPS.  */
19003 
19004             if (risky)
19005               break;
19006 
19007             if (CONSP (XCDR (elt)))
19008               n += display_mode_element (it, depth, field_width - n,
19009                                          precision - n, XCAR (XCDR (elt)),
19010                                          XCDR (XCDR (elt)), risky);
19011           }
19012         else if (SYMBOLP (car))
19013           {
19014             tem = Fboundp (car);
19015             elt = XCDR (elt);
19016             if (!CONSP (elt))
19017               goto invalid;
19018             /* elt is now the cdr, and we know it is a cons cell.
19019                Use its car if CAR has a non-nil value.  */
19020             if (!NILP (tem))
19021               {
19022                 tem = Fsymbol_value (car);
19023                 if (!NILP (tem))
19024                   {
19025                     elt = XCAR (elt);
19026                     goto tail_recurse;
19027                   }
19028               }
19029             /* Symbol's value is nil (or symbol is unbound)
19030                Get the cddr of the original list
19031                and if possible find the caddr and use that.  */
19032             elt = XCDR (elt);
19033             if (NILP (elt))
19034               break;
19035             else if (!CONSP (elt))
19036               goto invalid;
19037             elt = XCAR (elt);
19038             goto tail_recurse;
19039           }
19040         else if (INTEGERP (car))
19041           {
19042             register int lim = XINT (car);
19043             elt = XCDR (elt);
19044             if (lim < 0)
19045               {
19046                 /* Negative int means reduce maximum width.  */
19047                 if (precision <= 0)
19048                   precision = -lim;
19049                 else
19050                   precision = min (precision, -lim);
19051               }
19052             else if (lim > 0)
19053               {
19054                 /* Padding specified.  Don't let it be more than
19055                    current maximum.  */
19056                 if (precision > 0)
19057                   lim = min (precision, lim);
19058 
19059                 /* If that's more padding than already wanted, queue it.
19060                    But don't reduce padding already specified even if
19061                    that is beyond the current truncation point.  */
19062                 field_width = max (lim, field_width);
19063               }
19064             goto tail_recurse;
19065           }
19066         else if (STRINGP (car) || CONSP (car))
19067           {
19068             Lisp_Object halftail = elt;
19069             int len = 0;
19070 
19071             while (CONSP (elt)
19072                    && (precision <= 0 || n < precision))
19073               {
19074                 n += display_mode_element (it, depth,
19075                                            /* Do padding only after the last
19076                                               element in the list.  */
19077                                            (! CONSP (XCDR (elt))
19078                                             ? field_width - n
19079                                             : 0),
19080                                            precision - n, XCAR (elt),
19081                                            props, risky);
19082                 elt = XCDR (elt);
19083                 len++;
19084                 if ((len & 1) == 0)
19085                   halftail = XCDR (halftail);
19086                 /* Check for cycle.  */
19087                 if (EQ (halftail, elt))
19088                   break;
19089               }
19090           }
19091       }
19092       break;
19093 
19094     default:
19095     invalid:
19096       elt = build_string ("*invalid*");
19097       goto tail_recurse;
19098     }
19099 
19100   /* Pad to FIELD_WIDTH.  */
19101   if (field_width > 0 && n < field_width)
19102     {
19103       switch (mode_line_target)
19104         {
19105         case MODE_LINE_NOPROP:
19106         case MODE_LINE_TITLE:
19107           n += store_mode_line_noprop ("", field_width - n, 0);
19108           break;
19109         case MODE_LINE_STRING:
19110           n += store_mode_line_string ("", Qnil, 0, field_width - n, 0, Qnil);
19111           break;
19112         case MODE_LINE_DISPLAY:
19113           n += display_string ("", Qnil, Qnil, 0, 0, it, field_width - n,
19114                                0, 0, 0);
19115           break;
19116         }
19117     }
19118 
19119   return n;
19120 }
19121 
19122 /* Store a mode-line string element in mode_line_string_list.
19123 
19124    If STRING is non-null, display that C string.  Otherwise, the Lisp
19125    string LISP_STRING is displayed.
19126 
19127    FIELD_WIDTH is the minimum number of output glyphs to produce.
19128    If STRING has fewer characters than FIELD_WIDTH, pad to the right
19129    with spaces.  FIELD_WIDTH <= 0 means don't pad.
19130 
19131    PRECISION is the maximum number of characters to output from
19132    STRING.  PRECISION <= 0  means don't truncate the string.
19133 
19134    If COPY_STRING is non-zero, make a copy of LISP_STRING before adding
19135    properties to the string.
19136 
19137    PROPS are the properties to add to the string.
19138    The mode_line_string_face face property is always added to the string.
19139  */
19140 
19141 static int
19142 store_mode_line_string (string, lisp_string, copy_string, field_width, precision, props)
19143      char *string;
19144      Lisp_Object lisp_string;
19145      int copy_string;
19146      int field_width;
19147      int precision;
19148      Lisp_Object props;
19149 {
19150   int len;
19151   int n = 0;
19152 
19153   if (string != NULL)
19154     {
19155       len = strlen (string);
19156       if (precision > 0 && len > precision)
19157         len = precision;
19158       lisp_string = make_string (string, len);
19159       if (NILP (props))
19160         props = mode_line_string_face_prop;
19161       else if (!NILP (mode_line_string_face))
19162         {
19163           Lisp_Object face = Fplist_get (props, Qface);
19164           props = Fcopy_sequence (props);
19165           if (NILP (face))
19166             face = mode_line_string_face;
19167           else
19168             face = Fcons (face, Fcons (mode_line_string_face, Qnil));
19169           props = Fplist_put (props, Qface, face);
19170         }
19171       Fadd_text_properties (make_number (0), make_number (len),
19172                             props, lisp_string);
19173     }
19174   else
19175     {
19176       len = XFASTINT (Flength (lisp_string));
19177       if (precision > 0 && len > precision)
19178         {
19179           len = precision;
19180           lisp_string = Fsubstring (lisp_string, make_number (0), make_number (len));
19181           precision = -1;
19182         }
19183       if (!NILP (mode_line_string_face))
19184         {
19185           Lisp_Object face;
19186           if (NILP (props))
19187             props = Ftext_properties_at (make_number (0), lisp_string);
19188           face = Fplist_get (props, Qface);
19189           if (NILP (face))
19190             face = mode_line_string_face;
19191           else
19192             face = Fcons (face, Fcons (mode_line_string_face, Qnil));
19193           props = Fcons (Qface, Fcons (face, Qnil));
19194           if (copy_string)
19195             lisp_string = Fcopy_sequence (lisp_string);
19196         }
19197       if (!NILP (props))
19198         Fadd_text_properties (make_number (0), make_number (len),
19199                               props, lisp_string);
19200     }
19201 
19202   if (len > 0)
19203     {
19204       mode_line_string_list = Fcons (lisp_string, mode_line_string_list);
19205       n += len;
19206     }
19207 
19208   if (field_width > len)
19209     {
19210       field_width -= len;
19211       lisp_string = Fmake_string (make_number (field_width), make_number (' '));
19212       if (!NILP (props))
19213         Fadd_text_properties (make_number (0), make_number (field_width),
19214                               props, lisp_string);
19215       mode_line_string_list = Fcons (lisp_string, mode_line_string_list);
19216       n += field_width;
19217     }
19218 
19219   return n;
19220 }
19221 
19222 
19223 DEFUN ("format-mode-line", Fformat_mode_line, Sformat_mode_line,
19224        1, 4, 0,
19225        doc: /* Format a string out of a mode line format specification.
19226 First arg FORMAT specifies the mode line format (see `mode-line-format'
19227 for details) to use.
19228 
19229 Optional second arg FACE specifies the face property to put
19230 on all characters for which no face is specified.
19231 The value t means whatever face the window's mode line currently uses
19232 \(either `mode-line' or `mode-line-inactive', depending).
19233 A value of nil means the default is no face property.
19234 If FACE is an integer, the value string has no text properties.
19235 
19236 Optional third and fourth args WINDOW and BUFFER specify the window
19237 and buffer to use as the context for the formatting (defaults
19238 are the selected window and the window's buffer).  */)
19239      (format, face, window, buffer)
19240      Lisp_Object format, face, window, buffer;
19241 {
19242   struct it it;
19243   int len;
19244   struct window *w;
19245   struct buffer *old_buffer = NULL;
19246   int face_id = -1;
19247   int no_props = INTEGERP (face);
19248   int count = SPECPDL_INDEX ();
19249   Lisp_Object str;
19250   int string_start = 0;
19251 
19252   if (NILP (window))
19253     window = selected_window;
19254   CHECK_WINDOW (window);
19255   w = XWINDOW (window);
19256 
19257   if (NILP (buffer))
19258     buffer = w->buffer;
19259   CHECK_BUFFER (buffer);
19260 
19261   /* Make formatting the modeline a non-op when noninteractive, otherwise
19262      there will be problems later caused by a partially initialized frame.  */
19263   if (NILP (format) || noninteractive)
19264     return empty_unibyte_string;
19265 
19266   if (no_props)
19267     face = Qnil;
19268 
19269   if (!NILP (face))
19270     {
19271       if (EQ (face, Qt))
19272         face = (EQ (window, selected_window) ? Qmode_line : Qmode_line_inactive);
19273       face_id = lookup_named_face (XFRAME (WINDOW_FRAME (w)), face, 0);
19274     }
19275 
19276   if (face_id < 0)
19277     face_id = DEFAULT_FACE_ID;
19278 
19279   if (XBUFFER (buffer) != current_buffer)
19280     old_buffer = current_buffer;
19281 
19282   /* Save things including mode_line_proptrans_alist,
19283      and set that to nil so that we don't alter the outer value.  */
19284   record_unwind_protect (unwind_format_mode_line,
19285                          format_mode_line_unwind_data
19286                              (old_buffer, selected_window, 1));
19287   mode_line_proptrans_alist = Qnil;
19288 
19289   Fselect_window (window, Qt);
19290   if (old_buffer)
19291     set_buffer_internal_1 (XBUFFER (buffer));
19292 
19293   init_iterator (&it, w, -1, -1, NULL, face_id);
19294 
19295   if (no_props)
19296     {
19297       mode_line_target = MODE_LINE_NOPROP;
19298       mode_line_string_face_prop = Qnil;
19299       mode_line_string_list = Qnil;
19300       string_start = MODE_LINE_NOPROP_LEN (0);
19301     }
19302   else
19303     {
19304       mode_line_target = MODE_LINE_STRING;
19305       mode_line_string_list = Qnil;
19306       mode_line_string_face = face;
19307       mode_line_string_face_prop
19308         = (NILP (face) ? Qnil : Fcons (Qface, Fcons (face, Qnil)));
19309     }
19310 
19311   push_kboard (FRAME_KBOARD (it.f));
19312   display_mode_element (&it, 0, 0, 0, format, Qnil, 0);
19313   pop_kboard ();
19314 
19315   if (no_props)
19316     {
19317       len = MODE_LINE_NOPROP_LEN (string_start);
19318       str = make_string (mode_line_noprop_buf + string_start, len);
19319     }
19320   else
19321     {
19322       mode_line_string_list = Fnreverse (mode_line_string_list);
19323       str = Fmapconcat (intern ("identity"), mode_line_string_list,
19324                         empty_unibyte_string);
19325     }
19326 
19327   unbind_to (count, Qnil);
19328   return str;
19329 }
19330 
19331 /* Write a null-terminated, right justified decimal representation of
19332    the positive integer D to BUF using a minimal field width WIDTH.  */
19333 
19334 static void
19335 pint2str (buf, width, d)
19336      register char *buf;
19337      register int width;
19338      register int d;
19339 {
19340   register char *p = buf;
19341 
19342   if (d <= 0)
19343     *p++ = '0';
19344   else
19345     {
19346       while (d > 0)
19347         {
19348           *p++ = d % 10 + '0';
19349           d /= 10;
19350         }
19351     }
19352 
19353   for (width -= (int) (p - buf); width > 0; --width)
19354     *p++ = ' ';
19355   *p-- = '\0';
19356   while (p > buf)
19357     {
19358       d = *buf;
19359       *buf++ = *p;
19360       *p-- = d;
19361     }
19362 }
19363 
19364 /* Write a null-terminated, right justified decimal and "human
19365    readable" representation of the nonnegative integer D to BUF using
19366    a minimal field width WIDTH.  D should be smaller than 999.5e24. */
19367 
19368 static const char power_letter[] =
19369   {
19370     0,   /* not used */
19371     'k', /* kilo */
19372     'M', /* mega */
19373     'G', /* giga */
19374     'T', /* tera */
19375     'P', /* peta */
19376     'E', /* exa */
19377     'Z', /* zetta */
19378     'Y'  /* yotta */
19379   };
19380 
19381 static void
19382 pint2hrstr (buf, width, d)
19383      char *buf;
19384      int width;
19385      int d;
19386 {
19387   /* We aim to represent the nonnegative integer D as
19388      QUOTIENT.TENTHS * 10 ^ (3 * EXPONENT). */
19389   int quotient = d;
19390   int remainder = 0;
19391   /* -1 means: do not use TENTHS. */
19392   int tenths = -1;
19393   int exponent = 0;
19394 
19395   /* Length of QUOTIENT.TENTHS as a string. */
19396   int length;
19397 
19398   char * psuffix;
19399   char * p;
19400 
19401   if (1000 <= quotient)
19402     {
19403       /* Scale to the appropriate EXPONENT. */
19404       do
19405         {
19406           remainder = quotient % 1000;
19407           quotient /= 1000;
19408           exponent++;
19409         }
19410       while (1000 <= quotient);
19411 
19412       /* Round to nearest and decide whether to use TENTHS or not. */
19413       if (quotient <= 9)
19414         {
19415           tenths = remainder / 100;
19416           if (50 <= remainder % 100)
19417             {
19418               if (tenths < 9)
19419                 tenths++;
19420               else
19421                 {
19422                   quotient++;
19423                   if (quotient == 10)
19424                     tenths = -1;
19425                   else
19426                     tenths = 0;
19427                 }
19428             }
19429         }
19430       else
19431         if (500 <= remainder)
19432           {
19433             if (quotient < 999)
19434               quotient++;
19435             else
19436               {
19437                 quotient = 1;
19438                 exponent++;
19439                 tenths = 0;
19440               }
19441           }
19442     }
19443 
19444   /* Calculate the LENGTH of QUOTIENT.TENTHS as a string. */
19445   if (tenths == -1 && quotient <= 99)
19446     if (quotient <= 9)
19447       length = 1;
19448     else
19449       length = 2;
19450   else
19451     length = 3;
19452   p = psuffix = buf + max (width, length);
19453 
19454   /* Print EXPONENT. */
19455   if (exponent)
19456     *psuffix++ = power_letter[exponent];
19457   *psuffix = '\0';
19458 
19459   /* Print TENTHS. */
19460   if (tenths >= 0)
19461     {
19462       *--p = '0' + tenths;
19463       *--p = '.';
19464     }
19465 
19466   /* Print QUOTIENT. */
19467   do
19468     {
19469       int digit = quotient % 10;
19470       *--p =  '0' + digit;
19471     }
19472   while ((quotient /= 10) != 0);
19473 
19474   /* Print leading spaces. */
19475   while (buf < p)
19476     *--p = ' ';
19477 }
19478 
19479 /* Set a mnemonic character for coding_system (Lisp symbol) in BUF.
19480    If EOL_FLAG is 1, set also a mnemonic character for end-of-line
19481    type of CODING_SYSTEM.  Return updated pointer into BUF.  */
19482 
19483 static unsigned char invalid_eol_type[] = "(*invalid*)";
19484 
19485 static char *
19486 decode_mode_spec_coding (coding_system, buf, eol_flag)
19487      Lisp_Object coding_system;
19488      register char *buf;
19489      int eol_flag;
19490 {
19491   Lisp_Object val;
19492   int multibyte = !NILP (current_buffer->enable_multibyte_characters);
19493   const unsigned char *eol_str;
19494   int eol_str_len;
19495   /* The EOL conversion we are using.  */
19496   Lisp_Object eoltype;
19497 
19498   val = CODING_SYSTEM_SPEC (coding_system);
19499   eoltype = Qnil;
19500 
19501   if (!VECTORP (val))           /* Not yet decided.  */
19502     {
19503       if (multibyte)
19504         *buf++ = '-';
19505       if (eol_flag)
19506         eoltype = eol_mnemonic_undecided;
19507       /* Don't mention EOL conversion if it isn't decided.  */
19508     }
19509   else
19510     {
19511       Lisp_Object attrs;
19512       Lisp_Object eolvalue;
19513 
19514       attrs = AREF (val, 0);
19515       eolvalue = AREF (val, 2);
19516 
19517       if (multibyte)
19518         *buf++ = XFASTINT (CODING_ATTR_MNEMONIC (attrs));
19519 
19520       if (eol_flag)
19521         {
19522           /* The EOL conversion that is normal on this system.  */
19523 
19524           if (NILP (eolvalue))  /* Not yet decided.  */
19525             eoltype = eol_mnemonic_undecided;
19526           else if (VECTORP (eolvalue)) /* Not yet decided.  */
19527             eoltype = eol_mnemonic_undecided;
19528           else                  /* eolvalue is Qunix, Qdos, or Qmac.  */
19529             eoltype = (EQ (eolvalue, Qunix)
19530                        ? eol_mnemonic_unix
19531                        : (EQ (eolvalue, Qdos) == 1
19532                           ? eol_mnemonic_dos : eol_mnemonic_mac));
19533         }
19534     }
19535 
19536   if (eol_flag)
19537     {
19538       /* Mention the EOL conversion if it is not the usual one.  */
19539       if (STRINGP (eoltype))
19540         {
19541           eol_str = SDATA (eoltype);
19542           eol_str_len = SBYTES (eoltype);
19543         }
19544       else if (CHARACTERP (eoltype))
19545         {
19546           unsigned char *tmp = (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH);
19547           eol_str_len = CHAR_STRING (XINT (eoltype), tmp);
19548           eol_str = tmp;
19549         }
19550       else
19551         {
19552           eol_str = invalid_eol_type;
19553           eol_str_len = sizeof (invalid_eol_type) - 1;
19554         }
19555       bcopy (eol_str, buf, eol_str_len);
19556       buf += eol_str_len;
19557     }
19558 
19559   return buf;
19560 }
19561 
19562 /* Return a string for the output of a mode line %-spec for window W,
19563    generated by character C.  PRECISION >= 0 means don't return a
19564    string longer than that value.  FIELD_WIDTH > 0 means pad the
19565    string returned with spaces to that value.  Return a Lisp string in
19566    *STRING if the resulting string is taken from that Lisp string.
19567 
19568    Note we operate on the current buffer for most purposes,
19569    the exception being w->base_line_pos.  */
19570 
19571 static char lots_of_dashes[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
19572 
19573 static char *
19574 decode_mode_spec (w, c, field_width, precision, string)
19575      struct window *w;
19576      register int c;
19577      int field_width, precision;
19578      Lisp_Object *string;
19579 {
19580   Lisp_Object obj;
19581   struct frame *f = XFRAME (WINDOW_FRAME (w));
19582   char *decode_mode_spec_buf = f->decode_mode_spec_buffer;
19583   struct buffer *b = current_buffer;
19584 
19585   obj = Qnil;
19586   *string = Qnil;
19587 
19588   switch (c)
19589     {
19590     case '*':
19591       if (!NILP (b->read_only))
19592         return "%";
19593       if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
19594         return "*";
19595       return "-";
19596 
19597     case '+':
19598       /* This differs from %* only for a modified read-only buffer.  */
19599       if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
19600         return "*";
19601       if (!NILP (b->read_only))
19602         return "%";
19603       return "-";
19604 
19605     case '&':
19606       /* This differs from %* in ignoring read-only-ness.  */
19607       if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
19608         return "*";
19609       return "-";
19610 
19611     case '%':
19612       return "%";
19613 
19614     case '[':
19615       {
19616         int i;
19617         char *p;
19618 
19619         if (command_loop_level > 5)
19620           return "[[[... ";
19621         p = decode_mode_spec_buf;
19622         for (i = 0; i < command_loop_level; i++)
19623           *p++ = '[';
19624         *p = 0;
19625         return decode_mode_spec_buf;
19626       }
19627 
19628     case ']':
19629       {
19630         int i;
19631         char *p;
19632 
19633         if (command_loop_level > 5)
19634           return " ...]]]";
19635         p = decode_mode_spec_buf;
19636         for (i = 0; i < command_loop_level; i++)
19637           *p++ = ']';
19638         *p = 0;
19639         return decode_mode_spec_buf;
19640       }
19641 
19642     case '-':
19643       {
19644         register int i;
19645 
19646         /* Let lots_of_dashes be a string of infinite length.  */
19647         if (mode_line_target == MODE_LINE_NOPROP ||
19648             mode_line_target == MODE_LINE_STRING)
19649           return "--";
19650         if (field_width <= 0
19651             || field_width > sizeof (lots_of_dashes))
19652           {
19653             for (i = 0; i < FRAME_MESSAGE_BUF_SIZE (f) - 1; ++i)
19654               decode_mode_spec_buf[i] = '-';
19655             decode_mode_spec_buf[i] = '\0';
19656             return decode_mode_spec_buf;
19657           }
19658         else
19659           return lots_of_dashes;
19660       }
19661 
19662     case 'b':
19663       obj = b->name;
19664       break;
19665 
19666     case 'c':
19667       /* %c and %l are ignored in `frame-title-format'.
19668          (In redisplay_internal, the frame title is drawn _before_ the
19669          windows are updated, so the stuff which depends on actual
19670          window contents (such as %l) may fail to render properly, or
19671          even crash emacs.)  */
19672       if (mode_line_target == MODE_LINE_TITLE)
19673         return "";
19674       else
19675         {
19676           int col = (int) current_column (); /* iftc */
19677           w->column_number_displayed = make_number (col);
19678           pint2str (decode_mode_spec_buf, field_width, col);
19679           return decode_mode_spec_buf;
19680         }
19681 
19682     case 'e':
19683 #ifndef SYSTEM_MALLOC
19684       {
19685         if (NILP (Vmemory_full))
19686           return "";
19687         else
19688           return "!MEM FULL! ";
19689       }
19690 #else
19691       return "";
19692 #endif
19693 
19694     case 'F':
19695       /* %F displays the frame name.  */
19696       if (!NILP (f->title))
19697         return (char *) SDATA (f->title);
19698       if (f->explicit_name || ! FRAME_WINDOW_P (f))
19699         return (char *) SDATA (f->name);
19700       return "Emacs";
19701 
19702     case 'f':
19703       obj = b->filename;
19704       break;
19705 
19706     case 'i':
19707       {
19708         int size = ZV - BEGV;
19709         pint2str (decode_mode_spec_buf, field_width, size);
19710         return decode_mode_spec_buf;
19711       }
19712 
19713     case 'I':
19714       {
19715         int size = ZV - BEGV;
19716         pint2hrstr (decode_mode_spec_buf, field_width, size);
19717         return decode_mode_spec_buf;
19718       }
19719 
19720     case 'l':
19721       {
19722         int startpos, startpos_byte, line, linepos, linepos_byte;
19723         int topline, nlines, junk, height;
19724 
19725         /* %c and %l are ignored in `frame-title-format'.  */
19726         if (mode_line_target == MODE_LINE_TITLE)
19727           return "";
19728 
19729         startpos = XMARKER (w->start)->charpos;
19730         startpos_byte = marker_byte_position (w->start);
19731         height = WINDOW_TOTAL_LINES (w);
19732 
19733         /* If we decided that this buffer isn't suitable for line numbers,
19734            don't forget that too fast.  */
19735         if (EQ (w->base_line_pos, w->buffer))
19736           goto no_value;
19737         /* But do forget it, if the window shows a different buffer now.  */
19738         else if (BUFFERP (w->base_line_pos))
19739           w->base_line_pos = Qnil;
19740 
19741         /* If the buffer is very big, don't waste time.  */
19742         if (INTEGERP (Vline_number_display_limit)
19743             && BUF_ZV (b) - BUF_BEGV (b) > XINT (Vline_number_display_limit))
19744           {
19745             w->base_line_pos = Qnil;
19746             w->base_line_number = Qnil;
19747             goto no_value;
19748           }
19749 
19750         if (INTEGERP (w->base_line_number)
19751             && INTEGERP (w->base_line_pos)
19752             && XFASTINT (w->base_line_pos) <= startpos)
19753           {
19754             line = XFASTINT (w->base_line_number);
19755             linepos = XFASTINT (w->base_line_pos);
19756             linepos_byte = buf_charpos_to_bytepos (b, linepos);
19757           }
19758         else
19759           {
19760             line = 1;
19761             linepos = BUF_BEGV (b);
19762             linepos_byte = BUF_BEGV_BYTE (b);
19763           }
19764 
19765         /* Count lines from base line to window start position.  */
19766         nlines = display_count_lines (linepos, linepos_byte,
19767                                       startpos_byte,
19768                                       startpos, &junk);
19769 
19770         topline = nlines + line;
19771 
19772         /* Determine a new base line, if the old one is too close
19773            or too far away, or if we did not have one.
19774            "Too close" means it's plausible a scroll-down would
19775            go back past it.  */
19776         if (startpos == BUF_BEGV (b))
19777           {
19778             w->base_line_number = make_number (topline);
19779             w->base_line_pos = make_number (BUF_BEGV (b));
19780           }
19781         else if (nlines < height + 25 || nlines > height * 3 + 50
19782                  || linepos == BUF_BEGV (b))
19783           {
19784             int limit = BUF_BEGV (b);
19785             int limit_byte = BUF_BEGV_BYTE (b);
19786             int position;
19787             int distance = (height * 2 + 30) * line_number_display_limit_width;
19788 
19789             if (startpos - distance > limit)
19790               {
19791                 limit = startpos - distance;
19792                 limit_byte = CHAR_TO_BYTE (limit);
19793               }
19794 
19795             nlines = display_count_lines (startpos, startpos_byte,
19796                                           limit_byte,
19797                                           - (height * 2 + 30),
19798                                           &position);
19799             /* If we couldn't find the lines we wanted within
19800                line_number_display_limit_width chars per line,
19801                give up on line numbers for this window.  */
19802             if (position == limit_byte && limit == startpos - distance)
19803               {
19804                 w->base_line_pos = w->buffer;
19805                 w->base_line_number = Qnil;
19806                 goto no_value;
19807               }
19808 
19809             w->base_line_number = make_number (topline - nlines);
19810             w->base_line_pos = make_number (BYTE_TO_CHAR (position));
19811           }
19812 
19813         /* Now count lines from the start pos to point.  */
19814         nlines = display_count_lines (startpos, startpos_byte,
19815                                       PT_BYTE, PT, &junk);
19816 
19817         /* Record that we did display the line number.  */
19818         line_number_displayed = 1;
19819 
19820         /* Make the string to show.  */
19821         pint2str (decode_mode_spec_buf, field_width, topline + nlines);
19822         return decode_mode_spec_buf;
19823     no_value:
19824         {
19825           char* p = decode_mode_spec_buf;
19826           int pad = field_width - 2;
19827           while (pad-- > 0)
19828             *p++ = ' ';
19829           *p++ = '?';
19830           *p++ = '?';
19831           *p = '\0';
19832           return decode_mode_spec_buf;
19833         }
19834       }
19835       break;
19836 
19837     case 'm':
19838       obj = b->mode_name;
19839       break;
19840 
19841     case 'n':
19842       if (BUF_BEGV (b) > BUF_BEG (b) || BUF_ZV (b) < BUF_Z (b))
19843         return " Narrow";
19844       break;
19845 
19846     case 'p':
19847       {
19848         int pos = marker_position (w->start);
19849         int total = BUF_ZV (b) - BUF_BEGV (b);
19850 
19851         if (XFASTINT (w->window_end_pos) <= BUF_Z (b) - BUF_ZV (b))
19852           {
19853             if (pos <= BUF_BEGV (b))
19854               return "All";
19855             else
19856               return "Bottom";
19857           }
19858         else if (pos <= BUF_BEGV (b))
19859           return "Top";
19860         else
19861           {
19862             if (total > 1000000)
19863               /* Do it differently for a large value, to avoid overflow.  */
19864               total = ((pos - BUF_BEGV (b)) + (total / 100) - 1) / (total / 100);
19865             else
19866               total = ((pos - BUF_BEGV (b)) * 100 + total - 1) / total;
19867             /* We can't normally display a 3-digit number,
19868                so get us a 2-digit number that is close.  */
19869             if (total == 100)
19870               total = 99;
19871             sprintf (decode_mode_spec_buf, "%2d%%", total);
19872             return decode_mode_spec_buf;
19873           }
19874       }
19875 
19876       /* Display percentage of size above the bottom of the screen.  */
19877     case 'P':
19878       {
19879         int toppos = marker_position (w->start);
19880         int botpos = BUF_Z (b) - XFASTINT (w->window_end_pos);
19881         int total = BUF_ZV (b) - BUF_BEGV (b);
19882 
19883         if (botpos >= BUF_ZV (b))
19884           {
19885             if (toppos <= BUF_BEGV (b))
19886               return "All";
19887             else
19888               return "Bottom";
19889           }
19890         else
19891           {
19892             if (total > 1000000)
19893               /* Do it differently for a large value, to avoid overflow.  */
19894               total = ((botpos - BUF_BEGV (b)) + (total / 100) - 1) / (total / 100);
19895             else
19896               total = ((botpos - BUF_BEGV (b)) * 100 + total - 1) / total;
19897             /* We can't normally display a 3-digit number,
19898                so get us a 2-digit number that is close.  */
19899             if (total == 100)
19900               total = 99;
19901             if (toppos <= BUF_BEGV (b))
19902               sprintf (decode_mode_spec_buf, "Top%2d%%", total);
19903             else
19904               sprintf (decode_mode_spec_buf, "%2d%%", total);
19905             return decode_mode_spec_buf;
19906           }
19907       }
19908 
19909     case 's':
19910       /* status of process */
19911       obj = Fget_buffer_process (Fcurrent_buffer ());
19912       if (NILP (obj))
19913         return "no process";
19914 #ifdef subprocesses
19915       obj = Fsymbol_name (Fprocess_status (obj));
19916 #endif
19917       break;
19918 
19919     case '@':
19920       {
19921         int count = inhibit_garbage_collection ();
19922         Lisp_Object val = call1 (intern ("file-remote-p"),
19923                                  current_buffer->directory);
19924         unbind_to (count, Qnil);
19925 
19926         if (NILP (val))
19927           return "-";
19928         else
19929           return "@";
19930       }
19931 
19932     case 't':                   /* indicate TEXT or BINARY */
19933 #ifdef MODE_LINE_BINARY_TEXT
19934       return MODE_LINE_BINARY_TEXT (b);
19935 #else
19936       return "T";
19937 #endif
19938 
19939     case 'z':
19940       /* coding-system (not including end-of-line format) */
19941     case 'Z':
19942       /* coding-system (including end-of-line type) */
19943       {
19944         int eol_flag = (c == 'Z');
19945         char *p = decode_mode_spec_buf;
19946 
19947         if (! FRAME_WINDOW_P (f))
19948           {
19949             /* No need to mention EOL here--the terminal never needs
19950                to do EOL conversion.  */
19951             p = decode_mode_spec_coding (CODING_ID_NAME
19952                                          (FRAME_KEYBOARD_CODING (f)->id),
19953                                          p, 0);
19954             p = decode_mode_spec_coding (CODING_ID_NAME
19955                                          (FRAME_TERMINAL_CODING (f)->id),
19956                                          p, 0);
19957           }
19958         p = decode_mode_spec_coding (b->buffer_file_coding_system,
19959                                      p, eol_flag);
19960 
19961 #if 0 /* This proves to be annoying; I think we can do without.  -- rms.  */
19962 #ifdef subprocesses
19963         obj = Fget_buffer_process (Fcurrent_buffer ());
19964         if (PROCESSP (obj))
19965           {
19966             p = decode_mode_spec_coding (XPROCESS (obj)->decode_coding_system,
19967                                          p, eol_flag);
19968             p = decode_mode_spec_coding (XPROCESS (obj)->encode_coding_system,
19969                                          p, eol_flag);
19970           }
19971 #endif /* subprocesses */
19972 #endif /* 0 */
19973         *p = 0;
19974         return decode_mode_spec_buf;
19975       }
19976     }
19977 
19978   if (STRINGP (obj))
19979     {
19980       *string = obj;
19981       return (char *) SDATA (obj);
19982     }
19983   else
19984     return "";
19985 }
19986 
19987 
19988 /* Count up to COUNT lines starting from START / START_BYTE.
19989    But don't go beyond LIMIT_BYTE.
19990    Return the number of lines thus found (always nonnegative).
19991 
19992    Set *BYTE_POS_PTR to 1 if we found COUNT lines, 0 if we hit LIMIT.  */
19993 
19994 static int
19995 display_count_lines (start, start_byte, limit_byte, count, byte_pos_ptr)
19996      int start, start_byte, limit_byte, count;
19997      int *byte_pos_ptr;
19998 {
19999   register unsigned char *cursor;
20000   unsigned char *base;
20001 
20002   register int ceiling;
20003   register unsigned char *ceiling_addr;
20004   int orig_count = count;
20005 
20006   /* If we are not in selective display mode,
20007      check only for newlines.  */
20008   int selective_display = (!NILP (current_buffer->selective_display)
20009                            && !INTEGERP (current_buffer->selective_display));
20010 
20011   if (count > 0)
20012     {
20013       while (start_byte < limit_byte)
20014         {
20015           ceiling =  BUFFER_CEILING_OF (start_byte);
20016           ceiling = min (limit_byte - 1, ceiling);
20017           ceiling_addr = BYTE_POS_ADDR (ceiling) + 1;
20018           base = (cursor = BYTE_POS_ADDR (start_byte));
20019           while (1)
20020             {
20021               if (selective_display)
20022                 while (*cursor != '\n' && *cursor != 015 && ++cursor != ceiling_addr)
20023                   ;
20024               else
20025                 while (*cursor != '\n' && ++cursor != ceiling_addr)
20026                   ;
20027 
20028               if (cursor != ceiling_addr)
20029                 {
20030                   if (--count == 0)
20031                     {
20032                       start_byte += cursor - base + 1;
20033                       *byte_pos_ptr = start_byte;
20034                       return orig_count;
20035                     }
20036                   else
20037                     if (++cursor == ceiling_addr)
20038                       break;
20039                 }
20040               else
20041                 break;
20042             }
20043           start_byte += cursor - base;
20044         }
20045     }
20046   else
20047     {
20048       while (start_byte > limit_byte)
20049         {
20050           ceiling = BUFFER_FLOOR_OF (start_byte - 1);
20051           ceiling = max (limit_byte, ceiling);
20052           ceiling_addr = BYTE_POS_ADDR (ceiling) - 1;
20053           base = (cursor = BYTE_POS_ADDR (start_byte - 1) + 1);
20054           while (1)
20055             {
20056               if (selective_display)
20057                 while (--cursor != ceiling_addr
20058                        && *cursor != '\n' && *cursor != 015)
20059                   ;
20060               else
20061                 while (--cursor != ceiling_addr && *cursor != '\n')
20062                   ;
20063 
20064               if (cursor != ceiling_addr)
20065                 {
20066                   if (++count == 0)
20067                     {
20068                       start_byte += cursor - base + 1;
20069                       *byte_pos_ptr = start_byte;
20070                       /* When scanning backwards, we should
20071                          not count the newline posterior to which we stop.  */
20072                       return - orig_count - 1;
20073                     }
20074                 }
20075               else
20076                 break;
20077             }
20078           /* Here we add 1 to compensate for the last decrement
20079              of CURSOR, which took it past the valid range.  */
20080           start_byte += cursor - base + 1;
20081         }
20082     }
20083 
20084   *byte_pos_ptr = limit_byte;
20085 
20086   if (count < 0)
20087     return - orig_count + count;
20088   return orig_count - count;
20089 
20090 }
20091 
20092 
20093 
20094 /***********************************************************************
20095                          Displaying strings
20096  ***********************************************************************/
20097 
20098 /* Display a NUL-terminated string, starting with index START.
20099 
20100    If STRING is non-null, display that C string.  Otherwise, the Lisp
20101    string LISP_STRING is displayed.  There's a case that STRING is
20102    non-null and LISP_STRING is not nil.  It means STRING is a string
20103    data of LISP_STRING.  In that case, we display LISP_STRING while
20104    ignoring its text properties.
20105 
20106    If FACE_STRING is not nil, FACE_STRING_POS is a position in
20107    FACE_STRING.  Display STRING or LISP_STRING with the face at
20108    FACE_STRING_POS in FACE_STRING:
20109 
20110    Display the string in the environment given by IT, but use the
20111    standard display table, temporarily.
20112 
20113    FIELD_WIDTH is the minimum number of output glyphs to produce.
20114    If STRING has fewer characters than FIELD_WIDTH, pad to the right
20115    with spaces.  If STRING has more characters, more than FIELD_WIDTH
20116    glyphs will be produced.  FIELD_WIDTH <= 0 means don't pad.
20117 
20118    PRECISION is the maximum number of characters to output from
20119    STRING.  PRECISION < 0  means don't truncate the string.
20120 
20121    This is roughly equivalent to printf format specifiers:
20122 
20123    FIELD_WIDTH  PRECISION       PRINTF
20124    ----------------------------------------
20125    -1           -1              %s
20126    -1           10              %.10s
20127    10           -1              %10s
20128    20           10              %20.10s
20129 
20130    MULTIBYTE zero means do not display multibyte chars, > 0 means do
20131    display them, and < 0 means obey the current buffer's value of
20132    enable_multibyte_characters.
20133 
20134    Value is the number of columns displayed.  */
20135 
20136 static int
20137 display_string (string, lisp_string, face_string, face_string_pos,
20138                 start, it, field_width, precision, max_x, multibyte)
20139      unsigned char *string;
20140      Lisp_Object lisp_string;
20141      Lisp_Object face_string;
20142      EMACS_INT face_string_pos;
20143      EMACS_INT start;
20144      struct it *it;
20145      int field_width, precision, max_x;
20146      int multibyte;
20147 {
20148   int hpos_at_start = it->hpos;
20149   int saved_face_id = it->face_id;
20150   struct glyph_row *row = it->glyph_row;
20151 
20152   /* Initialize the iterator IT for iteration over STRING beginning
20153      with index START.  */
20154   reseat_to_string (it, NILP (lisp_string) ? string : NULL, lisp_string, start,
20155                     precision, field_width, multibyte);
20156   if (string && STRINGP (lisp_string)) 
20157     /* LISP_STRING is the one returned by decode_mode_spec.  We should
20158        ignore its text properties.  */
20159     it->stop_charpos = -1;
20160 
20161   /* If displaying STRING, set up the face of the iterator
20162      from LISP_STRING, if that's given.  */
20163   if (STRINGP (face_string))
20164     {
20165       EMACS_INT endptr;
20166       struct face *face;
20167 
20168       it->face_id
20169         = face_at_string_position (it->w, face_string, face_string_pos,
20170                                    0, it->region_beg_charpos,
20171                                    it->region_end_charpos,
20172                                    &endptr, it->base_face_id, 0);
20173       face = FACE_FROM_ID (it->f, it->face_id);
20174       it->face_box_p = face->box != FACE_NO_BOX;
20175     }
20176 
20177   /* Set max_x to the maximum allowed X position.  Don't let it go
20178      beyond the right edge of the window.  */
20179   if (max_x <= 0)
20180     max_x = it->last_visible_x;
20181   else
20182     max_x = min (max_x, it->last_visible_x);
20183 
20184   /* Skip over display elements that are not visible. because IT->w is
20185      hscrolled.  */
20186   if (it->current_x < it->first_visible_x)
20187     move_it_in_display_line_to (it, 100000, it->first_visible_x,
20188                                 MOVE_TO_POS | MOVE_TO_X);
20189 
20190   row->ascent = it->max_ascent;
20191   row->height = it->max_ascent + it->max_descent;
20192   row->phys_ascent = it->max_phys_ascent;
20193   row->phys_height = it->max_phys_ascent + it->max_phys_descent;
20194   row->extra_line_spacing = it->max_extra_line_spacing;
20195 
20196   /* This condition is for the case that we are called with current_x
20197      past last_visible_x.  */
20198   while (it->current_x < max_x)
20199     {
20200       int x_before, x, n_glyphs_before, i, nglyphs;
20201 
20202       /* Get the next display element.  */
20203       if (!get_next_display_element (it))
20204         break;
20205 
20206       /* Produce glyphs.  */
20207       x_before = it->current_x;
20208       n_glyphs_before = it->glyph_row->used[TEXT_AREA];
20209       PRODUCE_GLYPHS (it);
20210 
20211       nglyphs = it->glyph_row->used[TEXT_AREA] - n_glyphs_before;
20212       i = 0;
20213       x = x_before;
20214       while (i < nglyphs)
20215         {
20216           struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
20217 
20218           if (it->line_wrap != TRUNCATE
20219               && x + glyph->pixel_width > max_x)
20220             {
20221               /* End of continued line or max_x reached.  */
20222               if (CHAR_GLYPH_PADDING_P (*glyph))
20223                 {
20224                   /* A wide character is unbreakable.  */
20225                   it->glyph_row->used[TEXT_AREA] = n_glyphs_before;
20226                   it->current_x = x_before;
20227                 }
20228               else
20229                 {
20230                   it->glyph_row->used[TEXT_AREA] = n_glyphs_before + i;
20231                   it->current_x = x;
20232                 }
20233               break;
20234             }
20235           else if (x + glyph->pixel_width >= it->first_visible_x)
20236             {
20237               /* Glyph is at least partially visible.  */
20238               ++it->hpos;
20239               if (x < it->first_visible_x)
20240                 it->glyph_row->x = x - it->first_visible_x;
20241             }
20242           else
20243             {
20244               /* Glyph is off the left margin of the display area.
20245                  Should not happen.  */
20246               abort ();
20247             }
20248 
20249           row->ascent = max (row->ascent, it->max_ascent);
20250           row->height = max (row->height, it->max_ascent + it->max_descent);
20251           row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
20252           row->phys_height = max (row->phys_height,
20253                                   it->max_phys_ascent + it->max_phys_descent);
20254           row->extra_line_spacing = max (row->extra_line_spacing,
20255                                          it->max_extra_line_spacing);
20256           x += glyph->pixel_width;
20257           ++i;
20258         }
20259 
20260       /* Stop if max_x reached.  */
20261       if (i < nglyphs)
20262         break;
20263 
20264       /* Stop at line ends.  */
20265       if (ITERATOR_AT_END_OF_LINE_P (it))
20266         {
20267           it->continuation_lines_width = 0;
20268           break;
20269         }
20270 
20271       set_iterator_to_next (it, 1);
20272 
20273       /* Stop if truncating at the right edge.  */
20274       if (it->line_wrap == TRUNCATE
20275           && it->current_x >= it->last_visible_x)
20276         {
20277           /* Add truncation mark, but don't do it if the line is
20278              truncated at a padding space.  */
20279           if (IT_CHARPOS (*it) < it->string_nchars)
20280             {
20281               if (!FRAME_WINDOW_P (it->f))
20282                 {
20283                   int i, n;
20284 
20285                   if (it->current_x > it->last_visible_x)
20286                     {
20287                       for (i = row->used[TEXT_AREA] - 1; i > 0; --i)
20288                         if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
20289                           break;
20290                       for (n = row->used[TEXT_AREA]; i < n; ++i)
20291                         {
20292                           row->used[TEXT_AREA] = i;
20293                           produce_special_glyphs (it, IT_TRUNCATION);
20294                         }
20295                     }
20296                   produce_special_glyphs (it, IT_TRUNCATION);
20297                 }
20298               it->glyph_row->truncated_on_right_p = 1;
20299             }
20300           break;
20301         }
20302     }
20303 
20304   /* Maybe insert a truncation at the left.  */
20305   if (it->first_visible_x
20306       && IT_CHARPOS (*it) > 0)
20307     {
20308       if (!FRAME_WINDOW_P (it->f))
20309         insert_left_trunc_glyphs (it);
20310       it->glyph_row->truncated_on_left_p = 1;
20311     }
20312 
20313   it->face_id = saved_face_id;
20314 
20315   /* Value is number of columns displayed.  */
20316   return it->hpos - hpos_at_start;
20317 }
20318 
20319 
20320 
20321 /* This is like a combination of memq and assq.  Return 1/2 if PROPVAL
20322    appears as an element of LIST or as the car of an element of LIST.
20323    If PROPVAL is a list, compare each element against LIST in that
20324    way, and return 1/2 if any element of PROPVAL is found in LIST.
20325    Otherwise return 0.  This function cannot quit.
20326    The return value is 2 if the text is invisible but with an ellipsis
20327    and 1 if it's invisible and without an ellipsis.  */
20328 
20329 int
20330 invisible_p (propval, list)
20331      register Lisp_Object propval;
20332      Lisp_Object list;
20333 {
20334   register Lisp_Object tail, proptail;
20335 
20336   for (tail = list; CONSP (tail); tail = XCDR (tail))
20337     {
20338       register Lisp_Object tem;
20339       tem = XCAR (tail);
20340       if (EQ (propval, tem))
20341         return 1;
20342       if (CONSP (tem) && EQ (propval, XCAR (tem)))
20343         return NILP (XCDR (tem)) ? 1 : 2;
20344     }
20345 
20346   if (CONSP (propval))
20347     {
20348       for (proptail = propval; CONSP (proptail); proptail = XCDR (proptail))
20349         {
20350           Lisp_Object propelt;
20351           propelt = XCAR (proptail);
20352           for (tail = list; CONSP (tail); tail = XCDR (tail))
20353             {
20354               register Lisp_Object tem;
20355               tem = XCAR (tail);
20356               if (EQ (propelt, tem))
20357                 return 1;
20358               if (CONSP (tem) && EQ (propelt, XCAR (tem)))
20359                 return NILP (XCDR (tem)) ? 1 : 2;
20360             }
20361         }
20362     }
20363 
20364   return 0;
20365 }
20366 
20367 DEFUN ("invisible-p", Finvisible_p, Sinvisible_p, 1, 1, 0,
20368        doc: /* Non-nil if the property makes the text invisible.
20369 POS-OR-PROP can be a marker or number, in which case it is taken to be
20370 a position in the current buffer and the value of the `invisible' property
20371 is checked; or it can be some other value, which is then presumed to be the
20372 value of the `invisible' property of the text of interest.
20373 The non-nil value returned can be t for truly invisible text or something
20374 else if the text is replaced by an ellipsis.  */)
20375      (pos_or_prop)
20376      Lisp_Object pos_or_prop;
20377 {
20378   Lisp_Object prop
20379     = (NATNUMP (pos_or_prop) || MARKERP (pos_or_prop)
20380        ? Fget_char_property (pos_or_prop, Qinvisible, Qnil)
20381        : pos_or_prop);
20382   int invis = TEXT_PROP_MEANS_INVISIBLE (prop);
20383   return (invis == 0 ? Qnil
20384           : invis == 1 ? Qt
20385           : make_number (invis));
20386 }
20387 
20388 /* Calculate a width or height in pixels from a specification using
20389    the following elements:
20390 
20391    SPEC ::=
20392      NUM      - a (fractional) multiple of the default font width/height
20393      (NUM)    - specifies exactly NUM pixels
20394      UNIT     - a fixed number of pixels, see below.
20395      ELEMENT  - size of a display element in pixels, see below.
20396      (NUM . SPEC) - equals NUM * SPEC
20397      (+ SPEC SPEC ...)  - add pixel values
20398      (- SPEC SPEC ...)  - subtract pixel values
20399      (- SPEC)           - negate pixel value
20400 
20401    NUM ::=
20402      INT or FLOAT   - a number constant
20403      SYMBOL         - use symbol's (buffer local) variable binding.
20404 
20405    UNIT ::=
20406      in       - pixels per inch  *)
20407      mm       - pixels per 1/1000 meter  *)
20408      cm       - pixels per 1/100 meter   *)
20409      width    - width of current font in pixels.
20410      height   - height of current font in pixels.
20411 
20412      *) using the ratio(s) defined in display-pixels-per-inch.
20413 
20414    ELEMENT ::=
20415 
20416      left-fringe          - left fringe width in pixels
20417      right-fringe         - right fringe width in pixels
20418 
20419      left-margin          - left margin width in pixels
20420      right-margin         - right margin width in pixels
20421 
20422      scroll-bar           - scroll-bar area width in pixels
20423 
20424    Examples:
20425 
20426    Pixels corresponding to 5 inches:
20427      (5 . in)
20428 
20429    Total width of non-text areas on left side of window (if scroll-bar is on left):
20430      '(space :width (+ left-fringe left-margin scroll-bar))
20431 
20432    Align to first text column (in header line):
20433      '(space :align-to 0)
20434 
20435    Align to middle of text area minus half the width of variable `my-image'
20436    containing a loaded image:
20437      '(space :align-to (0.5 . (- text my-image)))
20438 
20439    Width of left margin minus width of 1 character in the default font:
20440      '(space :width (- left-margin 1))
20441 
20442    Width of left margin minus width of 2 characters in the current font:
20443      '(space :width (- left-margin (2 . width)))
20444 
20445    Center 1 character over left-margin (in header line):
20446      '(space :align-to (+ left-margin (0.5 . left-margin) -0.5))
20447 
20448    Different ways to express width of left fringe plus left margin minus one pixel:
20449      '(space :width (- (+ left-fringe left-margin) (1)))
20450      '(space :width (+ left-fringe left-margin (- (1))))
20451      '(space :width (+ left-fringe left-margin (-1)))
20452 
20453 */
20454 
20455 #define NUMVAL(X)                               \
20456      ((INTEGERP (X) || FLOATP (X))              \
20457       ? XFLOATINT (X)                           \
20458       : - 1)
20459 
20460 int
20461 calc_pixel_width_or_height (res, it, prop, font, width_p, align_to)
20462      double *res;
20463      struct it *it;
20464      Lisp_Object prop;
20465      struct font *font;
20466      int width_p, *align_to;
20467 {
20468   double pixels;
20469 
20470 #define OK_PIXELS(val) ((*res = (double)(val)), 1)
20471 #define OK_ALIGN_TO(val) ((*align_to = (int)(val)), 1)
20472 
20473   if (NILP (prop))
20474     return OK_PIXELS (0);
20475 
20476   xassert (FRAME_LIVE_P (it->f));
20477 
20478   if (SYMBOLP (prop))
20479     {
20480       if (SCHARS (SYMBOL_NAME (prop)) == 2)
20481         {
20482           char *unit =  SDATA (SYMBOL_NAME (prop));
20483 
20484           if (unit[0] == 'i' && unit[1] == 'n')
20485             pixels = 1.0;
20486           else if (unit[0] == 'm' && unit[1] == 'm')
20487             pixels = 25.4;
20488           else if (unit[0] == 'c' && unit[1] == 'm')
20489             pixels = 2.54;
20490           else
20491             pixels = 0;
20492           if (pixels > 0)
20493             {
20494               double ppi;
20495 #ifdef HAVE_WINDOW_SYSTEM
20496               if (FRAME_WINDOW_P (it->f)
20497                   && (ppi = (width_p
20498                              ? FRAME_X_DISPLAY_INFO (it->f)->resx
20499                              : FRAME_X_DISPLAY_INFO (it->f)->resy),
20500                       ppi > 0))
20501                 return OK_PIXELS (ppi / pixels);
20502 #endif
20503 
20504               if ((ppi = NUMVAL (Vdisplay_pixels_per_inch), ppi > 0)
20505                   || (CONSP (Vdisplay_pixels_per_inch)
20506                       && (ppi = (width_p
20507                                  ? NUMVAL (XCAR (Vdisplay_pixels_per_inch))
20508                                  : NUMVAL (XCDR (Vdisplay_pixels_per_inch))),
20509                           ppi > 0)))
20510                 return OK_PIXELS (ppi / pixels);
20511 
20512               return 0;
20513             }
20514         }
20515 
20516 #ifdef HAVE_WINDOW_SYSTEM
20517       if (EQ (prop, Qheight))
20518         return OK_PIXELS (font ? FONT_HEIGHT (font) : FRAME_LINE_HEIGHT (it->f));
20519       if (EQ (prop, Qwidth))
20520         return OK_PIXELS (font ? FONT_WIDTH (font) : FRAME_COLUMN_WIDTH (it->f));
20521 #else
20522       if (EQ (prop, Qheight) || EQ (prop, Qwidth))
20523         return OK_PIXELS (1);
20524 #endif
20525 
20526       if (EQ (prop, Qtext))
20527           return OK_PIXELS (width_p
20528                             ? window_box_width (it->w, TEXT_AREA)
20529                             : WINDOW_BOX_HEIGHT_NO_MODE_LINE (it->w));
20530 
20531       if (align_to && *align_to < 0)
20532         {
20533           *res = 0;
20534           if (EQ (prop, Qleft))
20535             return OK_ALIGN_TO (window_box_left_offset (it->w, TEXT_AREA));
20536           if (EQ (prop, Qright))
20537             return OK_ALIGN_TO (window_box_right_offset (it->w, TEXT_AREA));
20538           if (EQ (prop, Qcenter))
20539             return OK_ALIGN_TO (window_box_left_offset (it->w, TEXT_AREA)
20540                                 + window_box_width (it->w, TEXT_AREA) / 2);
20541           if (EQ (prop, Qleft_fringe))
20542             return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
20543                                 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (it->w)
20544                                 : window_box_right_offset (it->w, LEFT_MARGIN_AREA));
20545           if (EQ (prop, Qright_fringe))
20546             return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
20547                                 ? window_box_right_offset (it->w, RIGHT_MARGIN_AREA)
20548                                 : window_box_right_offset (it->w, TEXT_AREA));
20549           if (EQ (prop, Qleft_margin))
20550             return OK_ALIGN_TO (window_box_left_offset (it->w, LEFT_MARGIN_AREA));
20551           if (EQ (prop, Qright_margin))
20552             return OK_ALIGN_TO (window_box_left_offset (it->w, RIGHT_MARGIN_AREA));
20553           if (EQ (prop, Qscroll_bar))
20554             return OK_ALIGN_TO (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (it->w)
20555                                 ? 0
20556                                 : (window_box_right_offset (it->w, RIGHT_MARGIN_AREA)
20557                                    + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
20558                                       ? WINDOW_RIGHT_FRINGE_WIDTH (it->w)
20559                                       : 0)));
20560         }
20561       else
20562         {
20563           if (EQ (prop, Qleft_fringe))
20564             return OK_PIXELS (WINDOW_LEFT_FRINGE_WIDTH (it->w));
20565           if (EQ (prop, Qright_fringe))
20566             return OK_PIXELS (WINDOW_RIGHT_FRINGE_WIDTH (it->w));
20567           if (EQ (prop, Qleft_margin))
20568             return OK_PIXELS (WINDOW_LEFT_MARGIN_WIDTH (it->w));
20569           if (EQ (prop, Qright_margin))
20570             return OK_PIXELS (WINDOW_RIGHT_MARGIN_WIDTH (it->w));
20571           if (EQ (prop, Qscroll_bar))
20572             return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it->w));
20573         }
20574 
20575       prop = Fbuffer_local_value (prop, it->w->buffer);
20576     }
20577 
20578   if (INTEGERP (prop) || FLOATP (prop))
20579     {
20580       int base_unit = (width_p
20581                        ? FRAME_COLUMN_WIDTH (it->f)
20582                        : FRAME_LINE_HEIGHT (it->f));
20583       return OK_PIXELS (XFLOATINT (prop) * base_unit);
20584     }
20585 
20586   if (CONSP (prop))
20587     {
20588       Lisp_Object car = XCAR (prop);
20589       Lisp_Object cdr = XCDR (prop);
20590 
20591       if (SYMBOLP (car))
20592         {
20593 #ifdef HAVE_WINDOW_SYSTEM
20594           if (FRAME_WINDOW_P (it->f)
20595               && valid_image_p (prop))
20596             {
20597               int id = lookup_image (it->f, prop);
20598               struct image *img = IMAGE_FROM_ID (it->f, id);
20599 
20600               return OK_PIXELS (width_p ? img->width : img->height);
20601             }
20602 #endif
20603           if (EQ (car, Qplus) || EQ (car, Qminus))
20604             {
20605               int first = 1;
20606               double px;
20607 
20608               pixels = 0;
20609               while (CONSP (cdr))
20610                 {
20611                   if (!calc_pixel_width_or_height (&px, it, XCAR (cdr),
20612                                                    font, width_p, align_to))
20613                     return 0;
20614                   if (first)
20615                     pixels = (EQ (car, Qplus) ? px : -px), first = 0;
20616                   else
20617                     pixels += px;
20618                   cdr = XCDR (cdr);
20619                 }
20620               if (EQ (car, Qminus))
20621                 pixels = -pixels;
20622               return OK_PIXELS (pixels);
20623             }
20624 
20625           car = Fbuffer_local_value (car, it->w->buffer);
20626         }
20627 
20628       if (INTEGERP (car) || FLOATP (car))
20629         {
20630           double fact;
20631           pixels = XFLOATINT (car);
20632           if (NILP (cdr))
20633             return OK_PIXELS (pixels);
20634           if (calc_pixel_width_or_height (&fact, it, cdr,
20635                                           font, width_p, align_to))
20636             return OK_PIXELS (pixels * fact);
20637           return 0;
20638         }
20639 
20640       return 0;
20641     }
20642 
20643   return 0;
20644 }
20645 
20646 
20647 /***********************************************************************
20648                              Glyph Display
20649  ***********************************************************************/
20650 
20651 #ifdef HAVE_WINDOW_SYSTEM
20652 
20653 #if GLYPH_DEBUG
20654 
20655 void
20656 dump_glyph_string (s)
20657      struct glyph_string *s;
20658 {
20659   fprintf (stderr, "glyph string\n");
20660   fprintf (stderr, "  x, y, w, h = %d, %d, %d, %d\n",
20661            s->x, s->y, s->width, s->height);
20662   fprintf (stderr, "  ybase = %d\n", s->ybase);
20663   fprintf (stderr, "  hl = %d\n", s->hl);
20664   fprintf (stderr, "  left overhang = %d, right = %d\n",
20665            s->left_overhang, s->right_overhang);
20666   fprintf (stderr, "  nchars = %d\n", s->nchars);
20667   fprintf (stderr, "  extends to end of line = %d\n",
20668            s->extends_to_end_of_line_p);
20669   fprintf (stderr, "  font height = %d\n", FONT_HEIGHT (s->font));
20670   fprintf (stderr, "  bg width = %d\n", s->background_width);
20671 }
20672 
20673 #endif /* GLYPH_DEBUG */
20674 
20675 /* Initialize glyph string S.  CHAR2B is a suitably allocated vector
20676    of XChar2b structures for S; it can't be allocated in
20677    init_glyph_string because it must be allocated via `alloca'.  W
20678    is the window on which S is drawn.  ROW and AREA are the glyph row
20679    and area within the row from which S is constructed.  START is the
20680    index of the first glyph structure covered by S.  HL is a
20681    face-override for drawing S.  */
20682 
20683 #ifdef HAVE_NTGUI
20684 #define OPTIONAL_HDC(hdc)  hdc,
20685 #define DECLARE_HDC(hdc)   HDC hdc;
20686 #define ALLOCATE_HDC(hdc, f) hdc = get_frame_dc ((f))
20687 #define RELEASE_HDC(hdc, f)  release_frame_dc ((f), (hdc))
20688 #endif
20689 
20690 #ifndef OPTIONAL_HDC
20691 #define OPTIONAL_HDC(hdc)
20692 #define DECLARE_HDC(hdc)
20693 #define ALLOCATE_HDC(hdc, f)
20694 #define RELEASE_HDC(hdc, f)
20695 #endif
20696 
20697 static void
20698 init_glyph_string (s, OPTIONAL_HDC (hdc) char2b, w, row, area, start, hl)
20699      struct glyph_string *s;
20700      DECLARE_HDC (hdc)
20701      XChar2b *char2b;
20702      struct window *w;
20703      struct glyph_row *row;
20704      enum glyph_row_area area;
20705      int start;
20706      enum draw_glyphs_face hl;
20707 {
20708   bzero (s, sizeof *s);
20709   s->w = w;
20710   s->f = XFRAME (w->frame);
20711 #ifdef HAVE_NTGUI
20712   s->hdc = hdc;
20713 #endif
20714   s->display = FRAME_X_DISPLAY (s->f);
20715   s->window = FRAME_X_WINDOW (s->f);
20716   s->char2b = char2b;
20717   s->hl = hl;
20718   s->row = row;
20719   s->area = area;
20720   s->first_glyph = row->glyphs[area] + start;
20721   s->height = row->height;
20722   s->y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
20723   s->ybase = s->y + row->ascent;
20724 }
20725 
20726 
20727 /* Append the list of glyph strings with head H and tail T to the list
20728    with head *HEAD and tail *TAIL.  Set *HEAD and *TAIL to the result.  */
20729 
20730 static INLINE void
20731 append_glyph_string_lists (head, tail, h, t)
20732      struct glyph_string **head, **tail;
20733      struct glyph_string *h, *t;
20734 {
20735   if (h)
20736     {
20737       if (*head)
20738         (*tail)->next = h;
20739       else
20740         *head = h;
20741       h->prev = *tail;
20742       *tail = t;
20743     }
20744 }
20745 
20746 
20747 /* Prepend the list of glyph strings with head H and tail T to the
20748    list with head *HEAD and tail *TAIL.  Set *HEAD and *TAIL to the
20749    result.  */
20750 
20751 static INLINE void
20752 prepend_glyph_string_lists (head, tail, h, t)
20753      struct glyph_string **head, **tail;
20754      struct glyph_string *h, *t;
20755 {
20756   if (h)
20757     {
20758       if (*head)
20759         (*head)->prev = t;
20760       else
20761         *tail = t;
20762       t->next = *head;
20763       *head = h;
20764     }
20765 }
20766 
20767 
20768 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
20769    Set *HEAD and *TAIL to the resulting list.  */
20770 
20771 static INLINE void
20772 append_glyph_string (head, tail, s)
20773      struct glyph_string **head, **tail;
20774      struct glyph_string *s;
20775 {
20776   s->next = s->prev = NULL;
20777   append_glyph_string_lists (head, tail, s, s);
20778 }
20779 
20780 
20781 /* Get face and two-byte form of character C in face FACE_ID on frame
20782    F.  The encoding of C is returned in *CHAR2B.  MULTIBYTE_P non-zero
20783    means we want to display multibyte text.  DISPLAY_P non-zero means
20784    make sure that X resources for the face returned are allocated.
20785    Value is a pointer to a realized face that is ready for display if
20786    DISPLAY_P is non-zero.  */
20787 
20788 static INLINE struct face *
20789 get_char_face_and_encoding (f, c, face_id, char2b, multibyte_p, display_p)
20790      struct frame *f;
20791      int c, face_id;
20792      XChar2b *char2b;
20793      int multibyte_p, display_p;
20794 {
20795   struct face *face = FACE_FROM_ID (f, face_id);
20796 
20797   if (face->font)
20798     {
20799       unsigned code = face->font->driver->encode_char (face->font, c);
20800 
20801       if (code != FONT_INVALID_CODE)
20802         STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
20803       else
20804         STORE_XCHAR2B (char2b, 0, 0);
20805     }
20806 
20807   /* Make sure X resources of the face are allocated.  */
20808 #ifdef HAVE_X_WINDOWS
20809   if (display_p)
20810 #endif
20811     {
20812       xassert (face != NULL);
20813       PREPARE_FACE_FOR_DISPLAY (f, face);
20814     }
20815 
20816   return face;
20817 }
20818 
20819 
20820 /* Get face and two-byte form of character glyph GLYPH on frame F.
20821    The encoding of GLYPH->u.ch is returned in *CHAR2B.  Value is
20822    a pointer to a realized face that is ready for display.  */
20823 
20824 static INLINE struct face *
20825 get_glyph_face_and_encoding (f, glyph, char2b, two_byte_p)
20826      struct frame *f;
20827      struct glyph *glyph;
20828      XChar2b *char2b;
20829      int *two_byte_p;
20830 {
20831   struct face *face;
20832 
20833   xassert (glyph->type == CHAR_GLYPH);
20834   face = FACE_FROM_ID (f, glyph->face_id);
20835 
20836   if (two_byte_p)
20837     *two_byte_p = 0;
20838 
20839   if (face->font)
20840     {
20841       unsigned code = face->font->driver->encode_char (face->font, glyph->u.ch);
20842 
20843       if (code != FONT_INVALID_CODE)
20844         STORE_XCHAR2B (char2b, (code >> 8), (code & 0xFF));
20845       else
20846         STORE_XCHAR2B (char2b, 0, 0);
20847     }
20848 
20849   /* Make sure X resources of the face are allocated.  */
20850   xassert (face != NULL);
20851   PREPARE_FACE_FOR_DISPLAY (f, face);
20852   return face;
20853 }
20854 
20855 
20856 /* Fill glyph string S with composition components specified by S->cmp.
20857 
20858    BASE_FACE is the base face of the composition.
20859    S->cmp_from is the index of the first component for S.
20860 
20861    OVERLAPS non-zero means S should draw the foreground only, and use
20862    its physical height for clipping.  See also draw_glyphs.
20863 
20864    Value is the index of a component not in S.  */
20865 
20866 static int
20867 fill_composite_glyph_string (s, base_face, overlaps)
20868      struct glyph_string *s;
20869      struct face *base_face;
20870      int overlaps;
20871 {
20872   int i;
20873   /* For all glyphs of this composition, starting at the offset
20874      S->cmp_from, until we reach the end of the definition or encounter a
20875      glyph that requires the different face, add it to S.  */
20876   struct face *face;
20877 
20878   xassert (s);
20879 
20880   s->for_overlaps = overlaps;
20881   s->face = NULL;
20882   s->font = NULL;
20883   for (i = s->cmp_from; i < s->cmp->glyph_len; i++)
20884     {
20885       int c = COMPOSITION_GLYPH (s->cmp, i);
20886 
20887       if (c != '\t')
20888         {
20889           int face_id = FACE_FOR_CHAR (s->f, base_face->ascii_face, c,
20890                                        -1, Qnil);
20891 
20892           face = get_char_face_and_encoding (s->f, c, face_id,
20893                                              s->char2b + i, 1, 1);
20894           if (face)
20895             {
20896               if (! s->face)
20897                 {
20898                   s->face = face;
20899                   s->font = s->face->font;
20900                 }
20901               else if (s->face != face)
20902                 break;
20903             }
20904         }
20905       ++s->nchars;
20906     }
20907   s->cmp_to = i;
20908 
20909   /* All glyph strings for the same composition has the same width,
20910      i.e. the width set for the first component of the composition.  */
20911   s->width = s->first_glyph->pixel_width;
20912 
20913   /* If the specified font could not be loaded, use the frame's
20914      default font, but record the fact that we couldn't load it in
20915      the glyph string so that we can draw rectangles for the
20916      characters of the glyph string.  */
20917   if (s->font == NULL)
20918     {
20919       s->font_not_found_p = 1;
20920       s->font = FRAME_FONT (s->f);
20921     }
20922 
20923   /* Adjust base line for subscript/superscript text.  */
20924   s->ybase += s->first_glyph->voffset;
20925 
20926   /* This glyph string must always be drawn with 16-bit functions.  */
20927   s->two_byte_p = 1;
20928 
20929   return s->cmp_to;
20930 }
20931 
20932 static int
20933 fill_gstring_glyph_string (s, face_id, start, end, overlaps)
20934      struct glyph_string *s;
20935      int face_id;
20936      int start, end, overlaps;
20937 {
20938   struct glyph *glyph, *last;
20939   Lisp_Object lgstring;
20940   int i;
20941 
20942   s->for_overlaps = overlaps;
20943   glyph = s->row->glyphs[s->area] + start;
20944   last = s->row->glyphs[s->area] + end;
20945   s->cmp_id = glyph->u.cmp.id;
20946   s->cmp_from = glyph->u.cmp.from;
20947   s->cmp_to = glyph->u.cmp.to + 1;
20948   s->face = FACE_FROM_ID (s->f, face_id);
20949   lgstring = composition_gstring_from_id (s->cmp_id);
20950   s->font = XFONT_OBJECT (LGSTRING_FONT (lgstring));
20951   glyph++;
20952   while (glyph < last
20953          && glyph->u.cmp.automatic
20954          && glyph->u.cmp.id == s->cmp_id
20955          && s->cmp_to == glyph->u.cmp.from)
20956     s->cmp_to = (glyph++)->u.cmp.to + 1;
20957 
20958   for (i = s->cmp_from; i < s->cmp_to; i++)
20959     {
20960       Lisp_Object lglyph = LGSTRING_GLYPH (lgstring, i);
20961       unsigned code = LGLYPH_CODE (lglyph);
20962 
20963       STORE_XCHAR2B ((s->char2b + i), code >> 8, code & 0xFF);
20964     }
20965   s->width = composition_gstring_width (lgstring, s->cmp_from, s->cmp_to, NULL);
20966   return glyph - s->row->glyphs[s->area];
20967 }
20968 
20969 
20970 /* Fill glyph string S from a sequence of character glyphs.
20971 
20972    FACE_ID is the face id of the string.  START is the index of the
20973    first glyph to consider, END is the index of the last + 1.
20974    OVERLAPS non-zero means S should draw the foreground only, and use
20975    its physical height for clipping.  See also draw_glyphs.
20976 
20977    Value is the index of the first glyph not in S.  */
20978 
20979 static int
20980 fill_glyph_string (s, face_id, start, end, overlaps)
20981      struct glyph_string *s;
20982      int face_id;
20983      int start, end, overlaps;
20984 {
20985   struct glyph *glyph, *last;
20986   int voffset;
20987   int glyph_not_available_p;
20988 
20989   xassert (s->f == XFRAME (s->w->frame));
20990   xassert (s->nchars == 0);
20991   xassert (start >= 0 && end > start);
20992 
20993   s->for_overlaps = overlaps;
20994   glyph = s->row->glyphs[s->area] + start;
20995   last = s->row->glyphs[s->area] + end;
20996   voffset = glyph->voffset;
20997   s->padding_p = glyph->padding_p;
20998   glyph_not_available_p = glyph->glyph_not_available_p;
20999 
21000   while (glyph < last
21001          && glyph->type == CHAR_GLYPH
21002          && glyph->voffset == voffset
21003          /* Same face id implies same font, nowadays.  */
21004          && glyph->face_id == face_id
21005          && glyph->glyph_not_available_p == glyph_not_available_p)
21006     {
21007       int two_byte_p;
21008 
21009       s->face = get_glyph_face_and_encoding (s->f, glyph,
21010                                                s->char2b + s->nchars,
21011                                                &two_byte_p);
21012       s->two_byte_p = two_byte_p;
21013       ++s->nchars;
21014       xassert (s->nchars <= end - start);
21015       s->width += glyph->pixel_width;
21016       if (glyph++->padding_p != s->padding_p)
21017         break;
21018     }
21019 
21020   s->font = s->face->font;
21021 
21022   /* If the specified font could not be loaded, use the frame's font,
21023      but record the fact that we couldn't load it in
21024      S->font_not_found_p so that we can draw rectangles for the
21025      characters of the glyph string.  */
21026   if (s->font == NULL || glyph_not_available_p)
21027     {
21028       s->font_not_found_p = 1;
21029       s->font = FRAME_FONT (s->f);
21030     }
21031 
21032   /* Adjust base line for subscript/superscript text.  */
21033   s->ybase += voffset;
21034 
21035   xassert (s->face && s->face->gc);
21036   return glyph - s->row->glyphs[s->area];
21037 }
21038 
21039 
21040 /* Fill glyph string S from image glyph S->first_glyph.  */
21041 
21042 static void
21043 fill_image_glyph_string (s)
21044      struct glyph_string *s;
21045 {
21046   xassert (s->first_glyph->type == IMAGE_GLYPH);
21047   s->img = IMAGE_FROM_ID (s->f, s->first_glyph->u.img_id);
21048   xassert (s->img);
21049   s->slice = s->first_glyph->slice;
21050   s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
21051   s->font = s->face->font;
21052   s->width = s->first_glyph->pixel_width;
21053 
21054   /* Adjust base line for subscript/superscript text.  */
21055   s->ybase += s->first_glyph->voffset;
21056 }
21057 
21058 
21059 /* Fill glyph string S from a sequence of stretch glyphs.
21060 
21061    ROW is the glyph row in which the glyphs are found, AREA is the
21062    area within the row.  START is the index of the first glyph to
21063    consider, END is the index of the last + 1.
21064 
21065    Value is the index of the first glyph not in S.  */
21066 
21067 static int
21068 fill_stretch_glyph_string (s, row, area, start, end)
21069      struct glyph_string *s;
21070      struct glyph_row *row;
21071      enum glyph_row_area area;
21072      int start, end;
21073 {
21074   struct glyph *glyph, *last;
21075   int voffset, face_id;
21076 
21077   xassert (s->first_glyph->type == STRETCH_GLYPH);
21078 
21079   glyph = s->row->glyphs[s->area] + start;
21080   last = s->row->glyphs[s->area] + end;
21081   face_id = glyph->face_id;
21082   s->face = FACE_FROM_ID (s->f, face_id);
21083   s->font = s->face->font;
21084   s->width = glyph->pixel_width;
21085   s->nchars = 1;
21086   voffset = glyph->voffset;
21087 
21088   for (++glyph;
21089        (glyph < last
21090         && glyph->type == STRETCH_GLYPH
21091         && glyph->voffset == voffset
21092         && glyph->face_id == face_id);
21093        ++glyph)
21094     s->width += glyph->pixel_width;
21095 
21096   /* Adjust base line for subscript/superscript text.  */
21097   s->ybase += voffset;
21098 
21099   /* The case that face->gc == 0 is handled when drawing the glyph
21100      string by calling PREPARE_FACE_FOR_DISPLAY.  */
21101   xassert (s->face);
21102   return glyph - s->row->glyphs[s->area];
21103 }
21104 
21105 static struct font_metrics *
21106 get_per_char_metric (f, font, char2b)
21107      struct frame *f;
21108      struct font *font;
21109      XChar2b *char2b;
21110 {
21111   static struct font_metrics metrics;
21112   unsigned code = (XCHAR2B_BYTE1 (char2b) << 8) | XCHAR2B_BYTE2 (char2b);
21113 
21114   if (! font || code == FONT_INVALID_CODE)
21115     return NULL;
21116   font->driver->text_extents (font, &code, 1, &metrics);
21117   return &metrics;
21118 }
21119 
21120 /* EXPORT for RIF:
21121    Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
21122    frame F.  Overhangs of glyphs other than type CHAR_GLYPH are
21123    assumed to be zero.  */
21124 
21125 void
21126 x_get_glyph_overhangs (glyph, f, left, right)
21127      struct glyph *glyph;
21128      struct frame *f;
21129      int *left, *right;
21130 {
21131   *left = *right = 0;
21132 
21133   if (glyph->type == CHAR_GLYPH)
21134     {
21135       struct face *face;
21136       XChar2b char2b;
21137       struct font_metrics *pcm;
21138 
21139       face = get_glyph_face_and_encoding (f, glyph, &char2b, NULL);
21140       if (face->font && (pcm = get_per_char_metric (f, face->font, &char2b)))
21141         {
21142           if (pcm->rbearing > pcm->width)
21143             *right = pcm->rbearing - pcm->width;
21144           if (pcm->lbearing < 0)
21145             *left = -pcm->lbearing;
21146         }
21147     }
21148   else if (glyph->type == COMPOSITE_GLYPH)
21149     {
21150       if (! glyph->u.cmp.automatic)
21151         {
21152           struct composition *cmp = composition_table[glyph->u.cmp.id];
21153 
21154           if (cmp->rbearing > cmp->pixel_width)
21155             *right = cmp->rbearing - cmp->pixel_width;
21156           if (cmp->lbearing < 0)
21157             *left = - cmp->lbearing;
21158         }
21159       else
21160         {
21161           Lisp_Object gstring = composition_gstring_from_id (glyph->u.cmp.id);
21162           struct font_metrics metrics;
21163 
21164           composition_gstring_width (gstring, glyph->u.cmp.from,
21165                                      glyph->u.cmp.to + 1, &metrics);
21166           if (metrics.rbearing > metrics.width)
21167             *right = metrics.rbearing - metrics.width;
21168           if (metrics.lbearing < 0)
21169             *left = - metrics.lbearing;
21170         }
21171     }
21172 }
21173 
21174 
21175 /* Return the index of the first glyph preceding glyph string S that
21176    is overwritten by S because of S's left overhang.  Value is -1
21177    if no glyphs are overwritten.  */
21178 
21179 static int
21180 left_overwritten (s)
21181      struct glyph_string *s;
21182 {
21183   int k;
21184 
21185   if (s->left_overhang)
21186     {
21187       int x = 0, i;
21188       struct glyph *glyphs = s->row->glyphs[s->area];
21189       int first = s->first_glyph - glyphs;
21190 
21191       for (i = first - 1; i >= 0 && x > -s->left_overhang; --i)
21192         x -= glyphs[i].pixel_width;
21193 
21194       k = i + 1;
21195     }
21196   else
21197     k = -1;
21198 
21199   return k;
21200 }
21201 
21202 
21203 /* Return the index of the first glyph preceding glyph string S that
21204    is overwriting S because of its right overhang.  Value is -1 if no
21205    glyph in front of S overwrites S.  */
21206 
21207 static int
21208 left_overwriting (s)
21209      struct glyph_string *s;
21210 {
21211   int i, k, x;
21212   struct glyph *glyphs = s->row->glyphs[s->area];
21213   int first = s->first_glyph - glyphs;
21214 
21215   k = -1;
21216   x = 0;
21217   for (i = first - 1; i >= 0; --i)
21218     {
21219       int left, right;
21220       x_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
21221       if (x + right > 0)
21222         k = i;
21223       x -= glyphs[i].pixel_width;
21224     }
21225 
21226   return k;
21227 }
21228 
21229 
21230 /* Return the index of the last glyph following glyph string S that is
21231    overwritten by S because of S's right overhang.  Value is -1 if
21232    no such glyph is found.  */
21233 
21234 static int
21235 right_overwritten (s)
21236      struct glyph_string *s;
21237 {
21238   int k = -1;
21239 
21240   if (s->right_overhang)
21241     {
21242       int x = 0, i;
21243       struct glyph *glyphs = s->row->glyphs[s->area];
21244       int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
21245       int end = s->row->used[s->area];
21246 
21247       for (i = first; i < end && s->right_overhang > x; ++i)
21248         x += glyphs[i].pixel_width;
21249 
21250       k = i;
21251     }
21252 
21253   return k;
21254 }
21255 
21256 
21257 /* Return the index of the last glyph following glyph string S that
21258    overwrites S because of its left overhang.  Value is negative
21259    if no such glyph is found.  */
21260 
21261 static int
21262 right_overwriting (s)
21263      struct glyph_string *s;
21264 {
21265   int i, k, x;
21266   int end = s->row->used[s->area];
21267   struct glyph *glyphs = s->row->glyphs[s->area];
21268   int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
21269 
21270   k = -1;
21271   x = 0;
21272   for (i = first; i < end; ++i)
21273     {
21274       int left, right;
21275       x_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
21276       if (x - left < 0)
21277         k = i;
21278       x += glyphs[i].pixel_width;
21279     }
21280 
21281   return k;
21282 }
21283 
21284 
21285 /* Set background width of glyph string S.  START is the index of the
21286    first glyph following S.  LAST_X is the right-most x-position + 1
21287    in the drawing area.  */
21288 
21289 static INLINE void
21290 set_glyph_string_background_width (s, start, last_x)
21291      struct glyph_string *s;
21292      int start;
21293      int last_x;
21294 {
21295   /* If the face of this glyph string has to be drawn to the end of
21296      the drawing area, set S->extends_to_end_of_line_p.  */
21297 
21298   if (start == s->row->used[s->area]
21299       && s->area == TEXT_AREA
21300       && ((s->row->fill_line_p
21301            && (s->hl == DRAW_NORMAL_TEXT
21302                || s->hl == DRAW_IMAGE_RAISED
21303                || s->hl == DRAW_IMAGE_SUNKEN))
21304           || s->hl == DRAW_MOUSE_FACE))
21305     s->extends_to_end_of_line_p = 1;
21306 
21307   /* If S extends its face to the end of the line, set its
21308      background_width to the distance to the right edge of the drawing
21309      area.  */
21310   if (s->extends_to_end_of_line_p)
21311     s->background_width = last_x - s->x + 1;
21312   else
21313     s->background_width = s->width;
21314 }
21315 
21316 
21317 /* Compute overhangs and x-positions for glyph string S and its
21318    predecessors, or successors.  X is the starting x-position for S.
21319    BACKWARD_P non-zero means process predecessors.  */
21320 
21321 static void
21322 compute_overhangs_and_x (s, x, backward_p)
21323      struct glyph_string *s;
21324      int x;
21325      int backward_p;
21326 {
21327   if (backward_p)
21328     {
21329       while (s)
21330         {
21331           if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
21332             FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
21333           x -= s->width;
21334           s->x = x;
21335           s = s->prev;
21336         }
21337     }
21338   else
21339     {
21340       while (s)
21341         {
21342           if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
21343             FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
21344           s->x = x;
21345           x += s->width;
21346           s = s->next;
21347         }
21348     }
21349 }
21350 
21351 
21352 
21353 /* The following macros are only called from draw_glyphs below.
21354    They reference the following parameters of that function directly:
21355      `w', `row', `area', and `overlap_p'
21356    as well as the following Local Variables:
21357      `s', `f', and `hdc' (in W32)  */
21358 
21359 #ifdef HAVE_NTGUI
21360 /* On W32, silently add local `hdc' variable to argument list of
21361    init_glyph_string.  */
21362 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
21363   init_glyph_string (s, hdc, char2b, w, row, area, start, hl)
21364 #else
21365 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
21366   init_glyph_string (s, char2b, w, row, area, start, hl)
21367 #endif
21368 
21369 /* Add a glyph string for a stretch glyph to the list of strings
21370    between HEAD and TAIL.  START is the index of the stretch glyph in
21371    row area AREA of glyph row ROW.  END is the index of the last glyph
21372    in that glyph row area.  X is the current output position assigned
21373    to the new glyph string constructed.  HL overrides that face of the
21374    glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn.  LAST_X
21375    is the right-most x-position of the drawing area.  */
21376 
21377 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
21378    and below -- keep them on one line.  */
21379 #define BUILD_STRETCH_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X)   \
21380      do                                                                     \
21381        {                                                                    \
21382          s = (struct glyph_string *) alloca (sizeof *s);                    \
21383          INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL);              \
21384          START = fill_stretch_glyph_string (s, row, area, START, END);      \
21385          append_glyph_string (&HEAD, &TAIL, s);                             \
21386          s->x = (X);                                                        \
21387        }                                                                    \
21388      while (0)
21389 
21390 
21391 /* Add a glyph string for an image glyph to the list of strings
21392    between HEAD and TAIL.  START is the index of the image glyph in
21393    row area AREA of glyph row ROW.  END is the index of the last glyph
21394    in that glyph row area.  X is the current output position assigned
21395    to the new glyph string constructed.  HL overrides that face of the
21396    glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn.  LAST_X
21397    is the right-most x-position of the drawing area.  */
21398 
21399 #define BUILD_IMAGE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
21400      do                                                                 \
21401        {                                                                \
21402          s = (struct glyph_string *) alloca (sizeof *s);                \
21403          INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL);          \
21404          fill_image_glyph_string (s);                                   \
21405          append_glyph_string (&HEAD, &TAIL, s);                         \
21406          ++START;                                                       \
21407          s->x = (X);                                                    \
21408        }                                                                \
21409      while (0)
21410 
21411 
21412 /* Add a glyph string for a sequence of character glyphs to the list
21413    of strings between HEAD and TAIL.  START is the index of the first
21414    glyph in row area AREA of glyph row ROW that is part of the new
21415    glyph string.  END is the index of the last glyph in that glyph row
21416    area.  X is the current output position assigned to the new glyph
21417    string constructed.  HL overrides that face of the glyph; e.g. it
21418    is DRAW_CURSOR if a cursor has to be drawn.  LAST_X is the
21419    right-most x-position of the drawing area.  */
21420 
21421 #define BUILD_CHAR_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X)    \
21422      do                                                                    \
21423        {                                                                   \
21424          int face_id;                                                      \
21425          XChar2b *char2b;                                                  \
21426                                                                            \
21427          face_id = (row)->glyphs[area][START].face_id;                     \
21428                                                                            \
21429          s = (struct glyph_string *) alloca (sizeof *s);                   \
21430          char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b);     \
21431          INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL);           \
21432          append_glyph_string (&HEAD, &TAIL, s);                            \
21433          s->x = (X);                                                       \
21434          START = fill_glyph_string (s, face_id, START, END, overlaps);     \
21435        }                                                                   \
21436      while (0)
21437 
21438 
21439 /* Add a glyph string for a composite sequence to the list of strings
21440    between HEAD and TAIL.  START is the index of the first glyph in
21441    row area AREA of glyph row ROW that is part of the new glyph
21442    string.  END is the index of the last glyph in that glyph row area.
21443    X is the current output position assigned to the new glyph string
21444    constructed.  HL overrides that face of the glyph; e.g. it is
21445    DRAW_CURSOR if a cursor has to be drawn.  LAST_X is the right-most
21446    x-position of the drawing area.  */
21447 
21448 #define BUILD_COMPOSITE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
21449   do {                                                                      \
21450     int face_id = (row)->glyphs[area][START].face_id;                       \
21451     struct face *base_face = FACE_FROM_ID (f, face_id);                     \
21452     int cmp_id = (row)->glyphs[area][START].u.cmp.id;                       \
21453     struct composition *cmp = composition_table[cmp_id];                    \
21454     XChar2b *char2b;                                                        \
21455     struct glyph_string *first_s;                                           \
21456     int n;                                                                  \
21457                                                                             \
21458     char2b = (XChar2b *) alloca ((sizeof *char2b) * cmp->glyph_len);        \
21459                                                                             \
21460     /* Make glyph_strings for each glyph sequence that is drawable by       \
21461        the same face, and append them to HEAD/TAIL.  */                     \
21462     for (n = 0; n < cmp->glyph_len;)                                        \
21463       {                                                                     \
21464         s = (struct glyph_string *) alloca (sizeof *s);                     \
21465         INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL);             \
21466         append_glyph_string (&(HEAD), &(TAIL), s);                          \
21467         s->cmp = cmp;                                                       \
21468         s->cmp_from = n;                                                    \
21469         s->x = (X);                                                         \
21470         if (n == 0)                                                         \
21471           first_s = s;                                                      \
21472         n = fill_composite_glyph_string (s, base_face, overlaps);           \
21473       }                                                                     \
21474                                                                             \
21475     ++START;                                                                \
21476     s = first_s;                                                            \
21477   } while (0)
21478 
21479 
21480 /* Add a glyph string for a glyph-string sequence to the list of strings
21481    between HEAD and TAIL.  */
21482 
21483 #define BUILD_GSTRING_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
21484   do {                                                                    \
21485     int face_id;                                                          \
21486     XChar2b *char2b;                                                      \
21487     Lisp_Object gstring;                                                  \
21488                                                                           \
21489     face_id = (row)->glyphs[area][START].face_id;                         \
21490     gstring = (composition_gstring_from_id                                \
21491                ((row)->glyphs[area][START].u.cmp.id));                    \
21492     s = (struct glyph_string *) alloca (sizeof *s);                       \
21493     char2b = (XChar2b *) alloca ((sizeof *char2b)                         \
21494                                  * LGSTRING_GLYPH_LEN (gstring));         \
21495     INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL);               \
21496     append_glyph_string (&(HEAD), &(TAIL), s);                            \
21497     s->x = (X);                                                           \
21498     START = fill_gstring_glyph_string (s, face_id, START, END, overlaps); \
21499   } while (0)
21500 
21501 
21502 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
21503    of AREA of glyph row ROW on window W between indices START and END.
21504    HL overrides the face for drawing glyph strings, e.g. it is
21505    DRAW_CURSOR to draw a cursor.  X and LAST_X are start and end
21506    x-positions of the drawing area.
21507 
21508    This is an ugly monster macro construct because we must use alloca
21509    to allocate glyph strings (because draw_glyphs can be called
21510    asynchronously).  */
21511 
21512 #define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X)      \
21513   do                                                                    \
21514     {                                                                   \
21515       HEAD = TAIL = NULL;                                               \
21516       while (START < END)                                               \
21517         {                                                               \
21518           struct glyph *first_glyph = (row)->glyphs[area] + START;      \
21519           switch (first_glyph->type)                                    \
21520             {                                                           \
21521             case CHAR_GLYPH:                                            \
21522               BUILD_CHAR_GLYPH_STRINGS (START, END, HEAD, TAIL,         \
21523                                         HL, X, LAST_X);                 \
21524               break;                                                    \
21525                                                                         \
21526             case COMPOSITE_GLYPH:                                       \
21527               if (first_glyph->u.cmp.automatic)                         \
21528                 BUILD_GSTRING_GLYPH_STRING (START, END, HEAD, TAIL,     \
21529                                             HL, X, LAST_X);             \
21530               else                                                      \
21531                 BUILD_COMPOSITE_GLYPH_STRING (START, END, HEAD, TAIL,   \
21532                                               HL, X, LAST_X);           \
21533               break;                                                    \
21534                                                                         \
21535             case STRETCH_GLYPH:                                         \
21536               BUILD_STRETCH_GLYPH_STRING (START, END, HEAD, TAIL,       \
21537                                           HL, X, LAST_X);               \
21538               break;                                                    \
21539                                                                         \
21540             case IMAGE_GLYPH:                                           \
21541               BUILD_IMAGE_GLYPH_STRING (START, END, HEAD, TAIL,         \
21542                                         HL, X, LAST_X);                 \
21543               break;                                                    \
21544                                                                         \
21545             default:                                                    \
21546               abort ();                                                 \
21547             }                                                           \
21548                                                                         \
21549           if (s)                                                        \
21550             {                                                           \
21551               set_glyph_string_background_width (s, START, LAST_X);     \
21552               (X) += s->width;                                          \
21553             }                                                           \
21554         }                                                               \
21555     } while (0)
21556 
21557 
21558 /* Draw glyphs between START and END in AREA of ROW on window W,
21559    starting at x-position X.  X is relative to AREA in W.  HL is a
21560    face-override with the following meaning:
21561 
21562    DRAW_NORMAL_TEXT     draw normally
21563    DRAW_CURSOR          draw in cursor face
21564    DRAW_MOUSE_FACE      draw in mouse face.
21565    DRAW_INVERSE_VIDEO   draw in mode line face
21566    DRAW_IMAGE_SUNKEN    draw an image with a sunken relief around it
21567    DRAW_IMAGE_RAISED    draw an image with a raised relief around it
21568 
21569    If OVERLAPS is non-zero, draw only the foreground of characters and
21570    clip to the physical height of ROW.  Non-zero value also defines
21571    the overlapping part to be drawn:
21572 
21573    OVERLAPS_PRED                overlap with preceding rows
21574    OVERLAPS_SUCC                overlap with succeeding rows
21575    OVERLAPS_BOTH                overlap with both preceding/succeeding rows
21576    OVERLAPS_ERASED_CURSOR       overlap with erased cursor area
21577 
21578    Value is the x-position reached, relative to AREA of W.  */
21579 
21580 static int
21581 draw_glyphs (w, x, row, area, start, end, hl, overlaps)
21582      struct window *w;
21583      int x;
21584      struct glyph_row *row;
21585      enum glyph_row_area area;
21586      EMACS_INT start, end;
21587      enum draw_glyphs_face hl;
21588      int overlaps;
21589 {
21590   struct glyph_string *head, *tail;
21591   struct glyph_string *s;
21592   struct glyph_string *clip_head = NULL, *clip_tail = NULL;
21593   int i, j, x_reached, last_x, area_left = 0;
21594   struct frame *f = XFRAME (WINDOW_FRAME (w));
21595   DECLARE_HDC (hdc);
21596 
21597   ALLOCATE_HDC (hdc, f);
21598 
21599   /* Let's rather be paranoid than getting a SEGV.  */
21600   end = min (end, row->used[area]);
21601   start = max (0, start);
21602   start = min (end, start);
21603 
21604   /* Translate X to frame coordinates.  Set last_x to the right
21605      end of the drawing area.  */
21606   if (row->full_width_p)
21607     {
21608       /* X is relative to the left edge of W, without scroll bars
21609          or fringes.  */
21610       area_left = WINDOW_LEFT_EDGE_X (w);
21611       last_x = WINDOW_LEFT_EDGE_X (w) + WINDOW_TOTAL_WIDTH (w);
21612     }
21613   else
21614     {
21615       area_left = window_box_left (w, area);
21616       last_x = area_left + window_box_width (w, area);
21617     }
21618   x += area_left;
21619 
21620   /* Build a doubly-linked list of glyph_string structures between
21621      head and tail from what we have to draw.  Note that the macro
21622      BUILD_GLYPH_STRINGS will modify its start parameter.  That's
21623      the reason we use a separate variable `i'.  */
21624   i = start;
21625   BUILD_GLYPH_STRINGS (i, end, head, tail, hl, x, last_x);
21626   if (tail)
21627     x_reached = tail->x + tail->background_width;
21628   else
21629     x_reached = x;
21630 
21631   /* If there are any glyphs with lbearing < 0 or rbearing > width in
21632      the row, redraw some glyphs in front or following the glyph
21633      strings built above.  */
21634   if (head && !overlaps && row->contains_overlapping_glyphs_p)
21635     {
21636       struct glyph_string *h, *t;
21637       Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
21638       int mouse_beg_col, mouse_end_col, check_mouse_face = 0;
21639       int dummy_x = 0;
21640 
21641       /* If mouse highlighting is on, we may need to draw adjacent
21642          glyphs using mouse-face highlighting.  */
21643       if (area == TEXT_AREA && row->mouse_face_p)
21644         {
21645           struct glyph_row *mouse_beg_row, *mouse_end_row;
21646 
21647           mouse_beg_row = MATRIX_ROW (w->current_matrix, dpyinfo->mouse_face_beg_row);
21648           mouse_end_row = MATRIX_ROW (w->current_matrix, dpyinfo->mouse_face_end_row);
21649 
21650           if (row >= mouse_beg_row && row <= mouse_end_row)
21651             {
21652               check_mouse_face = 1;
21653               mouse_beg_col = (row == mouse_beg_row)
21654                 ? dpyinfo->mouse_face_beg_col : 0;
21655               mouse_end_col = (row == mouse_end_row)
21656                 ? dpyinfo->mouse_face_end_col
21657                 : row->used[TEXT_AREA];
21658             }
21659         }
21660 
21661       /* Compute overhangs for all glyph strings.  */
21662       if (FRAME_RIF (f)->compute_glyph_string_overhangs)
21663         for (s = head; s; s = s->next)
21664           FRAME_RIF (f)->compute_glyph_string_overhangs (s);
21665 
21666       /* Prepend glyph strings for glyphs in front of the first glyph
21667          string that are overwritten because of the first glyph
21668          string's left overhang.  The background of all strings
21669          prepended must be drawn because the first glyph string
21670          draws over it.  */
21671       i = left_overwritten (head);
21672       if (i >= 0)
21673         {
21674           enum draw_glyphs_face overlap_hl;
21675 
21676           /* If this row contains mouse highlighting, attempt to draw
21677              the overlapped glyphs with the correct highlight.  This
21678              code fails if the overlap encompasses more than one glyph
21679              and mouse-highlight spans only some of these glyphs.
21680              However, making it work perfectly involves a lot more
21681              code, and I don't know if the pathological case occurs in
21682              practice, so we'll stick to this for now.  --- cyd  */
21683           if (check_mouse_face
21684               && mouse_beg_col < start && mouse_end_col > i)
21685             overlap_hl = DRAW_MOUSE_FACE;
21686           else
21687             overlap_hl = DRAW_NORMAL_TEXT;
21688 
21689           j = i;
21690           BUILD_GLYPH_STRINGS (j, start, h, t,
21691                                overlap_hl, dummy_x, last_x);
21692           start = i;
21693           compute_overhangs_and_x (t, head->x, 1);
21694           prepend_glyph_string_lists (&head, &tail, h, t);
21695           clip_head = head;
21696         }
21697 
21698       /* Prepend glyph strings for glyphs in front of the first glyph
21699          string that overwrite that glyph string because of their
21700          right overhang.  For these strings, only the foreground must
21701          be drawn, because it draws over the glyph string at `head'.
21702          The background must not be drawn because this would overwrite
21703          right overhangs of preceding glyphs for which no glyph
21704          strings exist.  */
21705       i = left_overwriting (head);
21706       if (i >= 0)
21707         {
21708           enum draw_glyphs_face overlap_hl;
21709 
21710           if (check_mouse_face
21711               && mouse_beg_col < start && mouse_end_col > i)
21712             overlap_hl = DRAW_MOUSE_FACE;
21713           else
21714             overlap_hl = DRAW_NORMAL_TEXT;
21715 
21716           clip_head = head;
21717           BUILD_GLYPH_STRINGS (i, start, h, t,
21718                                overlap_hl, dummy_x, last_x);
21719           for (s = h; s; s = s->next)
21720             s->background_filled_p = 1;
21721           compute_overhangs_and_x (t, head->x, 1);
21722           prepend_glyph_string_lists (&head, &tail, h, t);
21723         }
21724 
21725       /* Append glyphs strings for glyphs following the last glyph
21726          string tail that are overwritten by tail.  The background of
21727          these strings has to be drawn because tail's foreground draws
21728          over it.  */
21729       i = right_overwritten (tail);
21730       if (i >= 0)
21731         {
21732           enum draw_glyphs_face overlap_hl;
21733 
21734           if (check_mouse_face
21735               && mouse_beg_col < i && mouse_end_col > end)
21736             overlap_hl = DRAW_MOUSE_FACE;
21737           else
21738             overlap_hl = DRAW_NORMAL_TEXT;
21739 
21740           BUILD_GLYPH_STRINGS (end, i, h, t,
21741                                overlap_hl, x, last_x);
21742           /* Because BUILD_GLYPH_STRINGS updates the first argument,
21743              we don't have `end = i;' here.  */
21744           compute_overhangs_and_x (h, tail->x + tail->width, 0);
21745           append_glyph_string_lists (&head, &tail, h, t);
21746           clip_tail = tail;
21747         }
21748 
21749       /* Append glyph strings for glyphs following the last glyph
21750          string tail that overwrite tail.  The foreground of such
21751          glyphs has to be drawn because it writes into the background
21752          of tail.  The background must not be drawn because it could
21753          paint over the foreground of following glyphs.  */
21754       i = right_overwriting (tail);
21755       if (i >= 0)
21756         {
21757           enum draw_glyphs_face overlap_hl;
21758           if (check_mouse_face
21759               && mouse_beg_col < i && mouse_end_col > end)
21760             overlap_hl = DRAW_MOUSE_FACE;
21761           else
21762             overlap_hl = DRAW_NORMAL_TEXT;
21763 
21764           clip_tail = tail;
21765           i++;                  /* We must include the Ith glyph.  */
21766           BUILD_GLYPH_STRINGS (end, i, h, t,
21767                                overlap_hl, x, last_x);
21768           for (s = h; s; s = s->next)
21769             s->background_filled_p = 1;
21770           compute_overhangs_and_x (h, tail->x + tail->width, 0);
21771           append_glyph_string_lists (&head, &tail, h, t);
21772         }
21773       if (clip_head || clip_tail)
21774         for (s = head; s; s = s->next)
21775           {
21776             s->clip_head = clip_head;
21777             s->clip_tail = clip_tail;
21778           }
21779     }
21780 
21781   /* Draw all strings.  */
21782   for (s = head; s; s = s->next)
21783     FRAME_RIF (f)->draw_glyph_string (s);
21784 
21785 #ifndef HAVE_NS
21786   /* When focus a sole frame and move horizontally, this sets on_p to 0
21787      causing a failure to erase prev cursor position. */
21788   if (area == TEXT_AREA
21789       && !row->full_width_p
21790       /* When drawing overlapping rows, only the glyph strings'
21791          foreground is drawn, which doesn't erase a cursor
21792          completely. */
21793       && !overlaps)
21794     {
21795       int x0 = clip_head ? clip_head->x : (head ? head->x : x);
21796       int x1 = (clip_tail ? clip_tail->x + clip_tail->background_width
21797                 : (tail ? tail->x + tail->background_width : x));
21798       x0 -= area_left;
21799       x1 -= area_left;
21800 
21801       notice_overwritten_cursor (w, TEXT_AREA, x0, x1,
21802                                  row->y, MATRIX_ROW_BOTTOM_Y (row));
21803     }
21804 #endif
21805 
21806   /* Value is the x-position up to which drawn, relative to AREA of W.
21807      This doesn't include parts drawn because of overhangs.  */
21808   if (row->full_width_p)
21809     x_reached = FRAME_TO_WINDOW_PIXEL_X (w, x_reached);
21810   else
21811     x_reached -= area_left;
21812 
21813   RELEASE_HDC (hdc, f);
21814 
21815   return x_reached;
21816 }
21817 
21818 /* Expand row matrix if too narrow.  Don't expand if area
21819    is not present.  */
21820 
21821 #define IT_EXPAND_MATRIX_WIDTH(it, area)                \
21822   {                                                     \
21823     if (!fonts_changed_p                                \
21824         && (it->glyph_row->glyphs[area]                 \
21825             < it->glyph_row->glyphs[area + 1]))         \
21826       {                                                 \
21827         it->w->ncols_scale_factor++;                    \
21828         fonts_changed_p = 1;                            \
21829       }                                                 \
21830   }
21831 
21832 /* Store one glyph for IT->char_to_display in IT->glyph_row.
21833    Called from x_produce_glyphs when IT->glyph_row is non-null.  */
21834 
21835 static INLINE void
21836 append_glyph (it)
21837      struct it *it;
21838 {
21839   struct glyph *glyph;
21840   enum glyph_row_area area = it->area;
21841 
21842   xassert (it->glyph_row);
21843   xassert (it->char_to_display != '\n' && it->char_to_display != '\t');
21844 
21845   glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
21846   if (glyph < it->glyph_row->glyphs[area + 1])
21847     {
21848       /* If the glyph row is reversed, we need to prepend the glyph
21849          rather than append it.  */
21850       if (it->glyph_row->reversed_p && area == TEXT_AREA)
21851         {
21852           struct glyph *g;
21853 
21854           /* Make room for the additional glyph.  */
21855           for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
21856             g[1] = *g;
21857           glyph = it->glyph_row->glyphs[area];
21858         }
21859       glyph->charpos = CHARPOS (it->position);
21860       glyph->object = it->object;
21861       if (it->pixel_width > 0)
21862         {
21863           glyph->pixel_width = it->pixel_width;
21864           glyph->padding_p = 0;
21865         }
21866       else
21867         {
21868           /* Assure at least 1-pixel width.  Otherwise, cursor can't
21869              be displayed correctly.  */
21870           glyph->pixel_width = 1;
21871           glyph->padding_p = 1;
21872         }
21873       glyph->ascent = it->ascent;
21874       glyph->descent = it->descent;
21875       glyph->voffset = it->voffset;
21876       glyph->type = CHAR_GLYPH;
21877       glyph->avoid_cursor_p = it->avoid_cursor_p;
21878       glyph->multibyte_p = it->multibyte_p;
21879       glyph->left_box_line_p = it->start_of_box_run_p;
21880       glyph->right_box_line_p = it->end_of_box_run_p;
21881       glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
21882                                       || it->phys_descent > it->descent);
21883       glyph->glyph_not_available_p = it->glyph_not_available_p;
21884       glyph->face_id = it->face_id;
21885       glyph->u.ch = it->char_to_display;
21886       glyph->slice = null_glyph_slice;
21887       glyph->font_type = FONT_TYPE_UNKNOWN;
21888       if (it->bidi_p)
21889         {
21890           glyph->resolved_level = it->bidi_it.resolved_level;
21891           if ((it->bidi_it.type & 7) != it->bidi_it.type)
21892             abort ();
21893           glyph->bidi_type = it->bidi_it.type;
21894         }
21895       else
21896         {
21897           glyph->resolved_level = 0;
21898           glyph->bidi_type = UNKNOWN_BT;
21899         }
21900       ++it->glyph_row->used[area];
21901     }
21902   else
21903     IT_EXPAND_MATRIX_WIDTH (it, area);
21904 }
21905 
21906 /* Store one glyph for the composition IT->cmp_it.id in
21907    IT->glyph_row.  Called from x_produce_glyphs when IT->glyph_row is
21908    non-null.  */
21909 
21910 static INLINE void
21911 append_composite_glyph (it)
21912      struct it *it;
21913 {
21914   struct glyph *glyph;
21915   enum glyph_row_area area = it->area;
21916 
21917   xassert (it->glyph_row);
21918 
21919   glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
21920   if (glyph < it->glyph_row->glyphs[area + 1])
21921     {
21922       /* If the glyph row is reversed, we need to prepend the glyph
21923          rather than append it.  */
21924       if (it->glyph_row->reversed_p && it->area == TEXT_AREA)
21925         {
21926           struct glyph *g;
21927 
21928           /* Make room for the new glyph.  */
21929           for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
21930             g[1] = *g;
21931           glyph = it->glyph_row->glyphs[it->area];
21932         }
21933       glyph->charpos = it->cmp_it.charpos;
21934       glyph->object = it->object;
21935       glyph->pixel_width = it->pixel_width;
21936       glyph->ascent = it->ascent;
21937       glyph->descent = it->descent;
21938       glyph->voffset = it->voffset;
21939       glyph->type = COMPOSITE_GLYPH;
21940       if (it->cmp_it.ch < 0)
21941         {
21942           glyph->u.cmp.automatic = 0;
21943           glyph->u.cmp.id = it->cmp_it.id;
21944         }
21945       else
21946         {
21947           glyph->u.cmp.automatic = 1;
21948           glyph->u.cmp.id = it->cmp_it.id;
21949           glyph->u.cmp.from = it->cmp_it.from;
21950           glyph->u.cmp.to = it->cmp_it.to - 1;
21951         }
21952       glyph->avoid_cursor_p = it->avoid_cursor_p;
21953       glyph->multibyte_p = it->multibyte_p;
21954       glyph->left_box_line_p = it->start_of_box_run_p;
21955       glyph->right_box_line_p = it->end_of_box_run_p;
21956       glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
21957                                       || it->phys_descent > it->descent);
21958       glyph->padding_p = 0;
21959       glyph->glyph_not_available_p = 0;
21960       glyph->face_id = it->face_id;
21961       glyph->slice = null_glyph_slice;
21962       glyph->font_type = FONT_TYPE_UNKNOWN;
21963       if (it->bidi_p)
21964         {
21965           glyph->resolved_level = it->bidi_it.resolved_level;
21966           if ((it->bidi_it.type & 7) != it->bidi_it.type)
21967             abort ();
21968           glyph->bidi_type = it->bidi_it.type;
21969         }
21970       ++it->glyph_row->used[area];
21971     }
21972   else
21973     IT_EXPAND_MATRIX_WIDTH (it, area);
21974 }
21975 
21976 
21977 /* Change IT->ascent and IT->height according to the setting of
21978    IT->voffset.  */
21979 
21980 static INLINE void
21981 take_vertical_position_into_account (it)
21982      struct it *it;
21983 {
21984   if (it->voffset)
21985     {
21986       if (it->voffset < 0)
21987         /* Increase the ascent so that we can display the text higher
21988            in the line.  */
21989         it->ascent -= it->voffset;
21990       else
21991         /* Increase the descent so that we can display the text lower
21992            in the line.  */
21993         it->descent += it->voffset;
21994     }
21995 }
21996 
21997 
21998 /* Produce glyphs/get display metrics for the image IT is loaded with.
21999    See the description of struct display_iterator in dispextern.h for
22000    an overview of struct display_iterator.  */
22001 
22002 static void
22003 produce_image_glyph (it)
22004      struct it *it;
22005 {
22006   struct image *img;
22007   struct face *face;
22008   int glyph_ascent, crop;
22009   struct glyph_slice slice;
22010 
22011   xassert (it->what == IT_IMAGE);
22012 
22013   face = FACE_FROM_ID (it->f, it->face_id);
22014   xassert (face);
22015   /* Make sure X resources of the face is loaded.  */
22016   PREPARE_FACE_FOR_DISPLAY (it->f, face);
22017 
22018   if (it->image_id < 0)
22019     {
22020       /* Fringe bitmap.  */
22021       it->ascent = it->phys_ascent = 0;
22022       it->descent = it->phys_descent = 0;
22023       it->pixel_width = 0;
22024       it->nglyphs = 0;
22025       return;
22026     }
22027 
22028   img = IMAGE_FROM_ID (it->f, it->image_id);
22029   xassert (img);
22030   /* Make sure X resources of the image is loaded.  */
22031   prepare_image_for_display (it->f, img);
22032 
22033   slice.x = slice.y = 0;
22034   slice.width = img->width;
22035   slice.height = img->height;
22036 
22037   if (INTEGERP (it->slice.x))
22038     slice.x = XINT (it->slice.x);
22039   else if (FLOATP (it->slice.x))
22040     slice.x = XFLOAT_DATA (it->slice.x) * img->width;
22041 
22042   if (INTEGERP (it->slice.y))
22043     slice.y = XINT (it->slice.y);
22044   else if (FLOATP (it->slice.y))
22045     slice.y = XFLOAT_DATA (it->slice.y) * img->height;
22046 
22047   if (INTEGERP (it->slice.width))
22048     slice.width = XINT (it->slice.width);
22049   else if (FLOATP (it->slice.width))
22050     slice.width = XFLOAT_DATA (it->slice.width) * img->width;
22051 
22052   if (INTEGERP (it->slice.height))
22053     slice.height = XINT (it->slice.height);
22054   else if (FLOATP (it->slice.height))
22055     slice.height = XFLOAT_DATA (it->slice.height) * img->height;
22056 
22057   if (slice.x >= img->width)
22058     slice.x = img->width;
22059   if (slice.y >= img->height)
22060     slice.y = img->height;
22061   if (slice.x + slice.width >= img->width)
22062     slice.width = img->width - slice.x;
22063   if (slice.y + slice.height > img->height)
22064     slice.height = img->height - slice.y;
22065 
22066   if (slice.width == 0 || slice.height == 0)
22067     return;
22068 
22069   it->ascent = it->phys_ascent = glyph_ascent = image_ascent (img, face, &slice);
22070 
22071   it->descent = slice.height - glyph_ascent;
22072   if (slice.y == 0)
22073     it->descent += img->vmargin;
22074   if (slice.y + slice.height == img->height)
22075     it->descent += img->vmargin;
22076   it->phys_descent = it->descent;
22077 
22078   it->pixel_width = slice.width;
22079   if (slice.x == 0)
22080     it->pixel_width += img->hmargin;
22081   if (slice.x + slice.width == img->width)
22082     it->pixel_width += img->hmargin;
22083 
22084   /* It's quite possible for images to have an ascent greater than
22085      their height, so don't get confused in that case.  */
22086   if (it->descent < 0)
22087     it->descent = 0;
22088 
22089   it->nglyphs = 1;
22090 
22091   if (face->box != FACE_NO_BOX)
22092     {
22093       if (face->box_line_width > 0)
22094         {
22095           if (slice.y == 0)
22096             it->ascent += face->box_line_width;
22097           if (slice.y + slice.height == img->height)
22098             it->descent += face->box_line_width;
22099         }
22100 
22101       if (it->start_of_box_run_p && slice.x == 0)
22102         it->pixel_width += eabs (face->box_line_width);
22103       if (it->end_of_box_run_p && slice.x + slice.width == img->width)
22104         it->pixel_width += eabs (face->box_line_width);
22105     }
22106 
22107   take_vertical_position_into_account (it);
22108 
22109   /* Automatically crop wide image glyphs at right edge so we can
22110      draw the cursor on same display row.  */
22111   if ((crop = it->pixel_width - (it->last_visible_x - it->current_x), crop > 0)
22112       && (it->hpos == 0 || it->pixel_width > it->last_visible_x / 4))
22113     {
22114       it->pixel_width -= crop;
22115       slice.width -= crop;
22116     }
22117 
22118   if (it->glyph_row)
22119     {
22120       struct glyph *glyph;
22121       enum glyph_row_area area = it->area;
22122 
22123       glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
22124       if (glyph < it->glyph_row->glyphs[area + 1])
22125         {
22126           glyph->charpos = CHARPOS (it->position);
22127           glyph->object = it->object;
22128           glyph->pixel_width = it->pixel_width;
22129           glyph->ascent = glyph_ascent;
22130           glyph->descent = it->descent;
22131           glyph->voffset = it->voffset;
22132           glyph->type = IMAGE_GLYPH;
22133           glyph->avoid_cursor_p = it->avoid_cursor_p;
22134           glyph->multibyte_p = it->multibyte_p;
22135           glyph->left_box_line_p = it->start_of_box_run_p;
22136           glyph->right_box_line_p = it->end_of_box_run_p;
22137           glyph->overlaps_vertically_p = 0;
22138           glyph->padding_p = 0;
22139           glyph->glyph_not_available_p = 0;
22140           glyph->face_id = it->face_id;
22141           glyph->u.img_id = img->id;
22142           glyph->slice = slice;
22143           glyph->font_type = FONT_TYPE_UNKNOWN;
22144           if (it->bidi_p)
22145             {
22146               glyph->resolved_level = it->bidi_it.resolved_level;
22147               if ((it->bidi_it.type & 7) != it->bidi_it.type)
22148                 abort ();
22149               glyph->bidi_type = it->bidi_it.type;
22150             }
22151           ++it->glyph_row->used[area];
22152         }
22153       else
22154         IT_EXPAND_MATRIX_WIDTH (it, area);
22155     }
22156 }
22157 
22158 
22159 /* Append a stretch glyph to IT->glyph_row.  OBJECT is the source
22160    of the glyph, WIDTH and HEIGHT are the width and height of the
22161    stretch.  ASCENT is the ascent of the glyph (0 <= ASCENT <= HEIGHT).  */
22162 
22163 static void
22164 append_stretch_glyph (it, object, width, height, ascent)
22165      struct it *it;
22166      Lisp_Object object;
22167      int width, height;
22168      int ascent;
22169 {
22170   struct glyph *glyph;
22171   enum glyph_row_area area = it->area;
22172 
22173   xassert (ascent >= 0 && ascent <= height);
22174 
22175   glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
22176   if (glyph < it->glyph_row->glyphs[area + 1])
22177     {
22178       /* If the glyph row is reversed, we need to prepend the glyph
22179          rather than append it.  */
22180       if (it->glyph_row->reversed_p && area == TEXT_AREA)
22181         {
22182           struct glyph *g;
22183 
22184           /* Make room for the additional glyph.  */
22185           for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
22186             g[1] = *g;
22187           glyph = it->glyph_row->glyphs[area];
22188         }
22189       glyph->charpos = CHARPOS (it->position);
22190       glyph->object = object;
22191       glyph->pixel_width = width;
22192       glyph->ascent = ascent;
22193       glyph->descent = height - ascent;
22194       glyph->voffset = it->voffset;
22195       glyph->type = STRETCH_GLYPH;
22196       glyph->avoid_cursor_p = it->avoid_cursor_p;
22197       glyph->multibyte_p = it->multibyte_p;
22198       glyph->left_box_line_p = it->start_of_box_run_p;
22199       glyph->right_box_line_p = it->end_of_box_run_p;
22200       glyph->overlaps_vertically_p = 0;
22201       glyph->padding_p = 0;
22202       glyph->glyph_not_available_p = 0;
22203       glyph->face_id = it->face_id;
22204       glyph->u.stretch.ascent = ascent;
22205       glyph->u.stretch.height = height;
22206       glyph->slice = null_glyph_slice;
22207       glyph->font_type = FONT_TYPE_UNKNOWN;
22208       if (it->bidi_p)
22209         {
22210           glyph->resolved_level = it->bidi_it.resolved_level;
22211           if ((it->bidi_it.type & 7) != it->bidi_it.type)
22212             abort ();
22213           glyph->bidi_type = it->bidi_it.type;
22214         }
22215       else
22216         {
22217           glyph->resolved_level = 0;
22218           glyph->bidi_type = UNKNOWN_BT;
22219         }
22220       ++it->glyph_row->used[area];
22221     }
22222   else
22223     IT_EXPAND_MATRIX_WIDTH (it, area);
22224 }
22225 
22226 
22227 /* Produce a stretch glyph for iterator IT.  IT->object is the value
22228    of the glyph property displayed.  The value must be a list
22229    `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
22230    being recognized:
22231 
22232    1. `:width WIDTH' specifies that the space should be WIDTH *
22233    canonical char width wide.  WIDTH may be an integer or floating
22234    point number.
22235 
22236    2. `:relative-width FACTOR' specifies that the width of the stretch
22237    should be computed from the width of the first character having the
22238    `glyph' property, and should be FACTOR times that width.
22239 
22240    3. `:align-to HPOS' specifies that the space should be wide enough
22241    to reach HPOS, a value in canonical character units.
22242 
22243    Exactly one of the above pairs must be present.
22244 
22245    4. `:height HEIGHT' specifies that the height of the stretch produced
22246    should be HEIGHT, measured in canonical character units.
22247 
22248    5. `:relative-height FACTOR' specifies that the height of the
22249    stretch should be FACTOR times the height of the characters having
22250    the glyph property.
22251 
22252    Either none or exactly one of 4 or 5 must be present.
22253 
22254    6. `:ascent ASCENT'  specifies that ASCENT percent of the height
22255    of the stretch should be used for the ascent of the stretch.
22256    ASCENT must be in the range 0 <= ASCENT <= 100.  */
22257 
22258 static void
22259 produce_stretch_glyph (it)
22260      struct it *it;
22261 {
22262   /* (space :width WIDTH :height HEIGHT ...)  */
22263   Lisp_Object prop, plist;
22264   int width = 0, height = 0, align_to = -1;
22265   int zero_width_ok_p = 0, zero_height_ok_p = 0;
22266   int ascent = 0;
22267   double tem;
22268   struct face *face = FACE_FROM_ID (it->f, it->face_id);
22269   struct font *font = face->font ? face->font : FRAME_FONT (it->f);
22270 
22271   PREPARE_FACE_FOR_DISPLAY (it->f, face);
22272 
22273   /* List should start with `space'.  */
22274   xassert (CONSP (it->object) && EQ (XCAR (it->object), Qspace));
22275   plist = XCDR (it->object);
22276 
22277   /* Compute the width of the stretch.  */
22278   if ((prop = Fplist_get (plist, QCwidth), !NILP (prop))
22279       && calc_pixel_width_or_height (&tem, it, prop, font, 1, 0))
22280     {
22281       /* Absolute width `:width WIDTH' specified and valid.  */
22282       zero_width_ok_p = 1;
22283       width = (int)tem;
22284     }
22285   else if (prop = Fplist_get (plist, QCrelative_width),
22286            NUMVAL (prop) > 0)
22287     {
22288       /* Relative width `:relative-width FACTOR' specified and valid.
22289          Compute the width of the characters having the `glyph'
22290          property.  */
22291       struct it it2;
22292       unsigned char *p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
22293 
22294       it2 = *it;
22295       if (it->multibyte_p)
22296         {
22297           int maxlen = ((IT_BYTEPOS (*it) >= GPT ? ZV : GPT)
22298                         - IT_BYTEPOS (*it));
22299           it2.c = STRING_CHAR_AND_LENGTH (p, it2.len);
22300         }
22301       else
22302         it2.c = *p, it2.len = 1;
22303 
22304       it2.glyph_row = NULL;
22305       it2.what = IT_CHARACTER;
22306       x_produce_glyphs (&it2);
22307       width = NUMVAL (prop) * it2.pixel_width;
22308     }
22309   else if ((prop = Fplist_get (plist, QCalign_to), !NILP (prop))
22310            && calc_pixel_width_or_height (&tem, it, prop, font, 1, &align_to))
22311     {
22312       if (it->glyph_row == NULL || !it->glyph_row->mode_line_p)
22313         align_to = (align_to < 0
22314                     ? 0
22315                     : align_to - window_box_left_offset (it->w, TEXT_AREA));
22316       else if (align_to < 0)
22317         align_to = window_box_left_offset (it->w, TEXT_AREA);
22318       width = max (0, (int)tem + align_to - it->current_x);
22319       zero_width_ok_p = 1;
22320     }
22321   else
22322     /* Nothing specified -> width defaults to canonical char width.  */
22323     width = FRAME_COLUMN_WIDTH (it->f);
22324 
22325   if (width <= 0 && (width < 0 || !zero_width_ok_p))
22326     width = 1;
22327 
22328   /* Compute height.  */
22329   if ((prop = Fplist_get (plist, QCheight), !NILP (prop))
22330       && calc_pixel_width_or_height (&tem, it, prop, font, 0, 0))
22331     {
22332       height = (int)tem;
22333       zero_height_ok_p = 1;
22334     }
22335   else if (prop = Fplist_get (plist, QCrelative_height),
22336            NUMVAL (prop) > 0)
22337     height = FONT_HEIGHT (font) * NUMVAL (prop);
22338   else
22339     height = FONT_HEIGHT (font);
22340 
22341   if (height <= 0 && (height < 0 || !zero_height_ok_p))
22342     height = 1;
22343 
22344   /* Compute percentage of height used for ascent.  If
22345      `:ascent ASCENT' is present and valid, use that.  Otherwise,
22346      derive the ascent from the font in use.  */
22347   if (prop = Fplist_get (plist, QCascent),
22348       NUMVAL (prop) > 0 && NUMVAL (prop) <= 100)
22349     ascent = height * NUMVAL (prop) / 100.0;
22350   else if (!NILP (prop)
22351            && calc_pixel_width_or_height (&tem, it, prop, font, 0, 0))
22352     ascent = min (max (0, (int)tem), height);
22353   else
22354     ascent = (height * FONT_BASE (font)) / FONT_HEIGHT (font);
22355 
22356   if (width > 0 && it->line_wrap != TRUNCATE
22357       && it->current_x + width > it->last_visible_x)
22358     width = it->last_visible_x - it->current_x - 1;
22359 
22360   if (width > 0 && height > 0 && it->glyph_row)
22361     {
22362       Lisp_Object object = it->stack[it->sp - 1].string;
22363       if (!STRINGP (object))
22364         object = it->w->buffer;
22365       append_stretch_glyph (it, object, width, height, ascent);
22366     }
22367 
22368   it->pixel_width = width;
22369   it->ascent = it->phys_ascent = ascent;
22370   it->descent = it->phys_descent = height - it->ascent;
22371   it->nglyphs = width > 0 && height > 0 ? 1 : 0;
22372 
22373   take_vertical_position_into_account (it);
22374 }
22375 
22376 /* Calculate line-height and line-spacing properties.
22377    An integer value specifies explicit pixel value.
22378    A float value specifies relative value to current face height.
22379    A cons (float . face-name) specifies relative value to
22380    height of specified face font.
22381 
22382    Returns height in pixels, or nil.  */
22383 
22384 
22385 static Lisp_Object
22386 calc_line_height_property (it, val, font, boff, override)
22387      struct it *it;
22388      Lisp_Object val;
22389      struct font *font;
22390      int boff, override;
22391 {
22392   Lisp_Object face_name = Qnil;
22393   int ascent, descent, height;
22394 
22395   if (NILP (val) || INTEGERP (val) || (override && EQ (val, Qt)))
22396     return val;
22397 
22398   if (CONSP (val))
22399     {
22400       face_name = XCAR (val);
22401       val = XCDR (val);
22402       if (!NUMBERP (val))
22403         val = make_number (1);
22404       if (NILP (face_name))
22405         {
22406           height = it->ascent + it->descent;
22407           goto scale;
22408         }
22409     }
22410 
22411   if (NILP (face_name))
22412     {
22413       font = FRAME_FONT (it->f);
22414       boff = FRAME_BASELINE_OFFSET (it->f);
22415     }
22416   else if (EQ (face_name, Qt))
22417     {
22418       override = 0;
22419     }
22420   else
22421     {
22422       int face_id;
22423       struct face *face;
22424 
22425       face_id = lookup_named_face (it->f, face_name, 0);
22426       if (face_id < 0)
22427         return make_number (-1);
22428 
22429       face = FACE_FROM_ID (it->f, face_id);
22430       font = face->font;
22431       if (font == NULL)
22432         return make_number (-1);
22433       boff = font->baseline_offset;
22434       if (font->vertical_centering)
22435         boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
22436     }
22437 
22438   ascent = FONT_BASE (font) + boff;
22439   descent = FONT_DESCENT (font) - boff;
22440 
22441   if (override)
22442     {
22443       it->override_ascent = ascent;
22444       it->override_descent = descent;
22445       it->override_boff = boff;
22446     }
22447 
22448   height = ascent + descent;
22449 
22450  scale:
22451   if (FLOATP (val))
22452     height = (int)(XFLOAT_DATA (val) * height);
22453   else if (INTEGERP (val))
22454     height *= XINT (val);
22455 
22456   return make_number (height);
22457 }
22458 
22459 
22460 /* RIF:
22461    Produce glyphs/get display metrics for the display element IT is
22462    loaded with.  See the description of struct it in dispextern.h
22463    for an overview of struct it.  */
22464 
22465 void
22466 x_produce_glyphs (it)
22467      struct it *it;
22468 {
22469   int extra_line_spacing = it->extra_line_spacing;
22470 
22471   it->glyph_not_available_p = 0;
22472 
22473   if (it->what == IT_CHARACTER)
22474     {
22475       XChar2b char2b;
22476       struct font *font;
22477       struct face *face = FACE_FROM_ID (it->f, it->face_id);
22478       struct font_metrics *pcm;
22479       int font_not_found_p;
22480       int boff;                 /* baseline offset */
22481       /* We may change it->multibyte_p upon unibyte<->multibyte
22482          conversion.  So, save the current value now and restore it
22483          later.
22484 
22485          Note: It seems that we don't have to record multibyte_p in
22486          struct glyph because the character code itself tells whether
22487          or not the character is multibyte.  Thus, in the future, we
22488          must consider eliminating the field `multibyte_p' in the
22489          struct glyph.  */
22490       int saved_multibyte_p = it->multibyte_p;
22491 
22492       /* Maybe translate single-byte characters to multibyte, or the
22493          other way.  */
22494       it->char_to_display = it->c;
22495       if (!ASCII_BYTE_P (it->c)
22496           && ! it->multibyte_p)
22497         {
22498           if (SINGLE_BYTE_CHAR_P (it->c)
22499               && unibyte_display_via_language_environment)
22500             {
22501               struct charset *unibyte = CHARSET_FROM_ID (charset_unibyte);
22502 
22503               /* get_next_display_element assures that this decoding
22504                  never fails.  */
22505               it->char_to_display = DECODE_CHAR (unibyte, it->c);
22506               it->multibyte_p = 1;
22507               it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display,
22508                                            -1, Qnil);
22509               face = FACE_FROM_ID (it->f, it->face_id);
22510             }
22511         }
22512 
22513       /* Get font to use.  Encode IT->char_to_display.  */
22514       get_char_face_and_encoding (it->f, it->char_to_display, it->face_id,
22515                                   &char2b, it->multibyte_p, 0);
22516       font = face->font;
22517 
22518       font_not_found_p = font == NULL;
22519       if (font_not_found_p)
22520         {
22521           /* When no suitable font found, display an empty box based
22522              on the metrics of the font of the default face (or what
22523              remapped).  */
22524           struct face *no_font_face
22525             = FACE_FROM_ID (it->f,
22526                             NILP (Vface_remapping_alist) ? DEFAULT_FACE_ID
22527                             : lookup_basic_face (it->f, DEFAULT_FACE_ID));
22528           font = no_font_face->font;
22529           boff = font->baseline_offset;
22530         }
22531       else
22532         {
22533           boff = font->baseline_offset;
22534           if (font->vertical_centering)
22535             boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
22536         }
22537 
22538       if (it->char_to_display >= ' '
22539           && (!it->multibyte_p || it->char_to_display < 128))
22540         {
22541           /* Either unibyte or ASCII.  */
22542           int stretched_p;
22543 
22544           it->nglyphs = 1;
22545 
22546           pcm = get_per_char_metric (it->f, font, &char2b);
22547 
22548           if (it->override_ascent >= 0)
22549             {
22550               it->ascent = it->override_ascent;
22551               it->descent = it->override_descent;
22552               boff = it->override_boff;
22553             }
22554           else
22555             {
22556               it->ascent = FONT_BASE (font) + boff;
22557               it->descent = FONT_DESCENT (font) - boff;
22558             }
22559 
22560           if (pcm)
22561             {
22562               it->phys_ascent = pcm->ascent + boff;
22563               it->phys_descent = pcm->descent - boff;
22564               it->pixel_width = pcm->width;
22565             }
22566           else
22567             {
22568               it->glyph_not_available_p = 1;
22569               it->phys_ascent = it->ascent;
22570               it->phys_descent = it->descent;
22571               it->pixel_width = FONT_WIDTH (font);
22572             }
22573 
22574           if (it->constrain_row_ascent_descent_p)
22575             {
22576               if (it->descent > it->max_descent)
22577                 {
22578                   it->ascent += it->descent - it->max_descent;
22579                   it->descent = it->max_descent;
22580                 }
22581               if (it->ascent > it->max_ascent)
22582                 {
22583                   it->descent = min (it->max_descent, it->descent + it->ascent - it->max_ascent);
22584                   it->ascent = it->max_ascent;
22585                 }
22586               it->phys_ascent = min (it->phys_ascent, it->ascent);
22587               it->phys_descent = min (it->phys_descent, it->descent);
22588               extra_line_spacing = 0;
22589             }
22590 
22591           /* If this is a space inside a region of text with
22592              `space-width' property, change its width.  */
22593           stretched_p = it->char_to_display == ' ' && !NILP (it->space_width);
22594           if (stretched_p)
22595             it->pixel_width *= XFLOATINT (it->space_width);
22596 
22597           /* If face has a box, add the box thickness to the character
22598              height.  If character has a box line to the left and/or
22599              right, add the box line width to the character's width.  */
22600           if (face->box != FACE_NO_BOX)
22601             {
22602               int thick = face->box_line_width;
22603 
22604               if (thick > 0)
22605                 {
22606                   it->ascent += thick;
22607                   it->descent += thick;
22608                 }
22609               else
22610                 thick = -thick;
22611 
22612               if (it->start_of_box_run_p)
22613                 it->pixel_width += thick;
22614               if (it->end_of_box_run_p)
22615                 it->pixel_width += thick;
22616             }
22617 
22618           /* If face has an overline, add the height of the overline
22619              (1 pixel) and a 1 pixel margin to the character height.  */
22620           if (face->overline_p)
22621             it->ascent += overline_margin;
22622 
22623           if (it->constrain_row_ascent_descent_p)
22624             {
22625               if (it->ascent > it->max_ascent)
22626                 it->ascent = it->max_ascent;
22627               if (it->descent > it->max_descent)
22628                 it->descent = it->max_descent;
22629             }
22630 
22631           take_vertical_position_into_account (it);
22632 
22633           /* If we have to actually produce glyphs, do it.  */
22634           if (it->glyph_row)
22635             {
22636               if (stretched_p)
22637                 {
22638                   /* Translate a space with a `space-width' property
22639                      into a stretch glyph.  */
22640                   int ascent = (((it->ascent + it->descent) * FONT_BASE (font))
22641                                 / FONT_HEIGHT (font));
22642                   append_stretch_glyph (it, it->object, it->pixel_width,
22643                                         it->ascent + it->descent, ascent);
22644                 }
22645               else
22646                 append_glyph (it);
22647 
22648               /* If characters with lbearing or rbearing are displayed
22649                  in this line, record that fact in a flag of the
22650                  glyph row.  This is used to optimize X output code.  */
22651               if (pcm && (pcm->lbearing < 0 || pcm->rbearing > pcm->width))
22652                 it->glyph_row->contains_overlapping_glyphs_p = 1;
22653             }
22654           if (! stretched_p && it->pixel_width == 0)
22655             /* We assure that all visible glyphs have at least 1-pixel
22656                width.  */
22657             it->pixel_width = 1;
22658         }
22659       else if (it->char_to_display == '\n')
22660         {
22661           /* A newline has no width, but we need the height of the
22662              line.  But if previous part of the line sets a height,
22663              don't increase that height */
22664 
22665           Lisp_Object height;
22666           Lisp_Object total_height = Qnil;
22667 
22668           it->override_ascent = -1;
22669           it->pixel_width = 0;
22670           it->nglyphs = 0;
22671 
22672           height = get_it_property(it, Qline_height);
22673           /* Split (line-height total-height) list */
22674           if (CONSP (height)
22675               && CONSP (XCDR (height))
22676               && NILP (XCDR (XCDR (height))))
22677             {
22678               total_height = XCAR (XCDR (height));
22679               height = XCAR (height);
22680             }
22681           height = calc_line_height_property(it, height, font, boff, 1);
22682 
22683           if (it->override_ascent >= 0)
22684             {
22685               it->ascent = it->override_ascent;
22686               it->descent = it->override_descent;
22687               boff = it->override_boff;
22688             }
22689           else
22690             {
22691               it->ascent = FONT_BASE (font) + boff;
22692               it->descent = FONT_DESCENT (font) - boff;
22693             }
22694 
22695           if (EQ (height, Qt))
22696             {
22697               if (it->descent > it->max_descent)
22698                 {
22699                   it->ascent += it->descent - it->max_descent;
22700                   it->descent = it->max_descent;
22701                 }
22702               if (it->ascent > it->max_ascent)
22703                 {
22704                   it->descent = min (it->max_descent, it->descent + it->ascent - it->max_ascent);
22705                   it->ascent = it->max_ascent;
22706                 }
22707               it->phys_ascent = min (it->phys_ascent, it->ascent);
22708               it->phys_descent = min (it->phys_descent, it->descent);
22709               it->constrain_row_ascent_descent_p = 1;
22710               extra_line_spacing = 0;
22711             }
22712           else
22713             {
22714               Lisp_Object spacing;
22715 
22716               it->phys_ascent = it->ascent;
22717               it->phys_descent = it->descent;
22718 
22719               if ((it->max_ascent > 0 || it->max_descent > 0)
22720                   && face->box != FACE_NO_BOX
22721                   && face->box_line_width > 0)
22722                 {
22723                   it->ascent += face->box_line_width;
22724                   it->descent += face->box_line_width;
22725                 }
22726               if (!NILP (height)
22727                   && XINT (height) > it->ascent + it->descent)
22728                 it->ascent = XINT (height) - it->descent;
22729 
22730               if (!NILP (total_height))
22731                 spacing = calc_line_height_property(it, total_height, font, boff, 0);
22732               else
22733                 {
22734                   spacing = get_it_property(it, Qline_spacing);
22735                   spacing = calc_line_height_property(it, spacing, font, boff, 0);
22736                 }
22737               if (INTEGERP (spacing))
22738                 {
22739                   extra_line_spacing = XINT (spacing);
22740                   if (!NILP (total_height))
22741                     extra_line_spacing -= (it->phys_ascent + it->phys_descent);
22742                 }
22743             }
22744         }
22745       else if (it->char_to_display == '\t')
22746         {
22747           if (font->space_width > 0)
22748             {
22749               int tab_width = it->tab_width * font->space_width;
22750               int x = it->current_x + it->continuation_lines_width;
22751               int next_tab_x = ((1 + x + tab_width - 1) / tab_width) * tab_width;
22752 
22753               /* If the distance from the current position to the next tab
22754                  stop is less than a space character width, use the
22755                  tab stop after that.  */
22756               if (next_tab_x - x < font->space_width)
22757                 next_tab_x += tab_width;
22758 
22759               it->pixel_width = next_tab_x - x;
22760               it->nglyphs = 1;
22761               it->ascent = it->phys_ascent = FONT_BASE (font) + boff;
22762               it->descent = it->phys_descent = FONT_DESCENT (font) - boff;
22763 
22764               if (it->glyph_row)
22765                 {
22766                   append_stretch_glyph (it, it->object, it->pixel_width,
22767                                         it->ascent + it->descent, it->ascent);
22768                 }
22769             }
22770           else
22771             {
22772               it->pixel_width = 0;
22773               it->nglyphs = 1;
22774             }
22775         }
22776       else
22777         {
22778           /* A multi-byte character.  Assume that the display width of the
22779              character is the width of the character multiplied by the
22780              width of the font.  */
22781 
22782           /* If we found a font, this font should give us the right
22783              metrics.  If we didn't find a font, use the frame's
22784              default font and calculate the width of the character by
22785              multiplying the width of font by the width of the
22786              character.  */
22787 
22788           pcm = get_per_char_metric (it->f, font, &char2b);
22789 
22790           if (font_not_found_p || !pcm)
22791             {
22792               int char_width = CHAR_WIDTH (it->char_to_display);
22793 
22794               if (char_width == 0)
22795                 /* This is a non spacing character.  But, as we are
22796                    going to display an empty box, the box must occupy
22797                    at least one column.  */
22798                 char_width = 1;
22799               it->glyph_not_available_p = 1;
22800               it->pixel_width = font->space_width * char_width;
22801               it->phys_ascent = FONT_BASE (font) + boff;
22802               it->phys_descent = FONT_DESCENT (font) - boff;
22803             }
22804           else
22805             {
22806               it->pixel_width = pcm->width;
22807               it->phys_ascent = pcm->ascent + boff;
22808               it->phys_descent = pcm->descent - boff;
22809               if (it->glyph_row
22810                   && (pcm->lbearing < 0
22811                       || pcm->rbearing > pcm->width))
22812                 it->glyph_row->contains_overlapping_glyphs_p = 1;
22813             }
22814           it->nglyphs = 1;
22815           it->ascent = FONT_BASE (font) + boff;
22816           it->descent = FONT_DESCENT (font) - boff;
22817           if (face->box != FACE_NO_BOX)
22818             {
22819               int thick = face->box_line_width;
22820 
22821               if (thick > 0)
22822                 {
22823                   it->ascent += thick;
22824                   it->descent += thick;
22825                 }
22826               else
22827                 thick = - thick;
22828 
22829               if (it->start_of_box_run_p)
22830                 it->pixel_width += thick;
22831               if (it->end_of_box_run_p)
22832                 it->pixel_width += thick;
22833             }
22834 
22835           /* If face has an overline, add the height of the overline
22836              (1 pixel) and a 1 pixel margin to the character height.  */
22837           if (face->overline_p)
22838             it->ascent += overline_margin;
22839 
22840           take_vertical_position_into_account (it);
22841 
22842           if (it->ascent < 0)
22843             it->ascent = 0;
22844           if (it->descent < 0)
22845             it->descent = 0;
22846 
22847           if (it->glyph_row)
22848             append_glyph (it);
22849           if (it->pixel_width == 0)
22850             /* We assure that all visible glyphs have at least 1-pixel
22851                width.  */
22852             it->pixel_width = 1;
22853         }
22854       it->multibyte_p = saved_multibyte_p;
22855     }
22856   else if (it->what == IT_COMPOSITION && it->cmp_it.ch < 0)
22857     {
22858       /* A static composition.
22859 
22860          Note: A composition is represented as one glyph in the
22861          glyph matrix.  There are no padding glyphs.
22862 
22863          Important note: pixel_width, ascent, and descent are the
22864          values of what is drawn by draw_glyphs (i.e. the values of
22865          the overall glyphs composed).  */
22866       struct face *face = FACE_FROM_ID (it->f, it->face_id);
22867       int boff;                 /* baseline offset */
22868       struct composition *cmp = composition_table[it->cmp_it.id];
22869       int glyph_len = cmp->glyph_len;
22870       struct font *font = face->font;
22871 
22872       it->nglyphs = 1;
22873 
22874       /* If we have not yet calculated pixel size data of glyphs of
22875          the composition for the current face font, calculate them
22876          now.  Theoretically, we have to check all fonts for the
22877          glyphs, but that requires much time and memory space.  So,
22878          here we check only the font of the first glyph.  This may
22879          lead to incorrect display, but it's very rare, and C-l
22880          (recenter-top-bottom) can correct the display anyway.  */
22881       if (! cmp->font || cmp->font != font)
22882         {
22883           /* Ascent and descent of the font of the first character
22884              of this composition (adjusted by baseline offset).
22885              Ascent and descent of overall glyphs should not be less
22886              than these, respectively.  */
22887           int font_ascent, font_descent, font_height;
22888           /* Bounding box of the overall glyphs.  */
22889           int leftmost, rightmost, lowest, highest;
22890           int lbearing, rbearing;
22891           int i, width, ascent, descent;
22892           int left_padded = 0, right_padded = 0;
22893           int c;
22894           XChar2b char2b;
22895           struct font_metrics *pcm;
22896           int font_not_found_p;
22897           int pos;
22898 
22899           for (glyph_len = cmp->glyph_len; glyph_len > 0; glyph_len--)
22900             if ((c = COMPOSITION_GLYPH (cmp, glyph_len - 1)) != '\t')
22901               break;
22902           if (glyph_len < cmp->glyph_len)
22903             right_padded = 1;
22904           for (i = 0; i < glyph_len; i++)
22905             {
22906               if ((c = COMPOSITION_GLYPH (cmp, i)) != '\t')
22907                 break;
22908               cmp->offsets[i * 2] = cmp->offsets[i * 2 + 1] = 0;
22909             }
22910           if (i > 0)
22911             left_padded = 1;
22912 
22913           pos = (STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
22914                  : IT_CHARPOS (*it));
22915           /* If no suitable font is found, use the default font.  */
22916           font_not_found_p = font == NULL;
22917           if (font_not_found_p)
22918             {
22919               face = face->ascii_face;
22920               font = face->font;
22921             }
22922           boff = font->baseline_offset;
22923           if (font->vertical_centering)
22924             boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
22925           font_ascent = FONT_BASE (font) + boff;
22926           font_descent = FONT_DESCENT (font) - boff;
22927           font_height = FONT_HEIGHT (font);
22928 
22929           cmp->font = (void *) font;
22930 
22931           pcm = NULL;
22932           if (! font_not_found_p)
22933             {
22934               get_char_face_and_encoding (it->f, c, it->face_id,
22935                                           &char2b, it->multibyte_p, 0);
22936               pcm = get_per_char_metric (it->f, font, &char2b);
22937             }
22938 
22939           /* Initialize the bounding box.  */
22940           if (pcm)
22941             {
22942               width = pcm->width;
22943               ascent = pcm->ascent;
22944               descent = pcm->descent;
22945               lbearing = pcm->lbearing;
22946               rbearing = pcm->rbearing;
22947             }
22948           else
22949             {
22950               width = FONT_WIDTH (font);
22951               ascent = FONT_BASE (font);
22952               descent = FONT_DESCENT (font);
22953               lbearing = 0;
22954               rbearing = width;
22955             }
22956 
22957           rightmost = width;
22958           leftmost = 0;
22959           lowest = - descent + boff;
22960           highest = ascent + boff;
22961 
22962           if (! font_not_found_p
22963               && font->default_ascent
22964               && CHAR_TABLE_P (Vuse_default_ascent)
22965               && !NILP (Faref (Vuse_default_ascent,
22966                                make_number (it->char_to_display))))
22967             highest = font->default_ascent + boff;
22968 
22969           /* Draw the first glyph at the normal position.  It may be
22970              shifted to right later if some other glyphs are drawn
22971              at the left.  */
22972           cmp->offsets[i * 2] = 0;
22973           cmp->offsets[i * 2 + 1] = boff;
22974           cmp->lbearing = lbearing;
22975           cmp->rbearing = rbearing;
22976 
22977           /* Set cmp->offsets for the remaining glyphs.  */
22978           for (i++; i < glyph_len; i++)
22979             {
22980               int left, right, btm, top;
22981               int ch = COMPOSITION_GLYPH (cmp, i);
22982               int face_id;
22983               struct face *this_face;
22984               int this_boff;
22985 
22986               if (ch == '\t')
22987                 ch = ' ';
22988               face_id = FACE_FOR_CHAR (it->f, face, ch, pos, it->string);
22989               this_face = FACE_FROM_ID (it->f, face_id);
22990               font = this_face->font;
22991 
22992               if (font == NULL)
22993                 pcm = NULL;
22994               else
22995                 {
22996                   this_boff = font->baseline_offset;
22997                   if (font->vertical_centering)
22998                     this_boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
22999                   get_char_face_and_encoding (it->f, ch, face_id,
23000                                               &char2b, it->multibyte_p, 0);
23001                   pcm = get_per_char_metric (it->f, font, &char2b);
23002                 }
23003               if (! pcm)
23004                 cmp->offsets[i * 2] = cmp->offsets[i * 2 + 1] = 0;
23005               else
23006                 {
23007                   width = pcm->width;
23008                   ascent = pcm->ascent;
23009                   descent = pcm->descent;
23010                   lbearing = pcm->lbearing;
23011                   rbearing = pcm->rbearing;
23012                   if (cmp->method != COMPOSITION_WITH_RULE_ALTCHARS)
23013                     {
23014                       /* Relative composition with or without
23015                          alternate chars.  */
23016                       left = (leftmost + rightmost - width) / 2;
23017                       btm = - descent + boff;
23018                       if (font->relative_compose
23019                           && (! CHAR_TABLE_P (Vignore_relative_composition)
23020                               || NILP (Faref (Vignore_relative_composition,
23021                                               make_number (ch)))))
23022                         {
23023 
23024                           if (- descent >= font->relative_compose)
23025                             /* One extra pixel between two glyphs.  */
23026                             btm = highest + 1;
23027                           else if (ascent <= 0)
23028                             /* One extra pixel between two glyphs.  */
23029                             btm = lowest - 1 - ascent - descent;
23030                         }
23031                     }
23032                   else
23033                     {
23034                       /* A composition rule is specified by an integer
23035                          value that encodes global and new reference
23036                          points (GREF and NREF).  GREF and NREF are
23037                          specified by numbers as below:
23038 
23039                          0---1---2 -- ascent
23040                          |       |
23041                          |       |
23042                          |       |
23043                          9--10--11 -- center
23044                          |       |
23045                          ---3---4---5--- baseline
23046                          |       |
23047                          6---7---8 -- descent
23048                       */
23049                       int rule = COMPOSITION_RULE (cmp, i);
23050                       int gref, nref, grefx, grefy, nrefx, nrefy, xoff, yoff;
23051 
23052                       COMPOSITION_DECODE_RULE (rule, gref, nref, xoff, yoff);
23053                       grefx = gref % 3, nrefx = nref % 3;
23054                       grefy = gref / 3, nrefy = nref / 3;
23055                       if (xoff)
23056                         xoff = font_height * (xoff - 128) / 256;
23057                       if (yoff)
23058                         yoff = font_height * (yoff - 128) / 256;
23059 
23060                       left = (leftmost
23061                               + grefx * (rightmost - leftmost) / 2
23062                               - nrefx * width / 2
23063                               + xoff);
23064 
23065                       btm = ((grefy == 0 ? highest
23066                               : grefy == 1 ? 0
23067                               : grefy == 2 ? lowest
23068                               : (highest + lowest) / 2)
23069                              - (nrefy == 0 ? ascent + descent
23070                                 : nrefy == 1 ? descent - boff
23071                                 : nrefy == 2 ? 0
23072                                 : (ascent + descent) / 2)
23073                              + yoff);
23074                     }
23075 
23076                   cmp->offsets[i * 2] = left;
23077                   cmp->offsets[i * 2 + 1] = btm + descent;
23078 
23079                   /* Update the bounding box of the overall glyphs. */
23080                   if (width > 0)
23081                     {
23082                       right = left + width;
23083                       if (left < leftmost)
23084                         leftmost = left;
23085                       if (right > rightmost)
23086                         rightmost = right;
23087                     }
23088                   top = btm + descent + ascent;
23089                   if (top > highest)
23090                     highest = top;
23091                   if (btm < lowest)
23092                     lowest = btm;
23093 
23094                   if (cmp->lbearing > left + lbearing)
23095                     cmp->lbearing = left + lbearing;
23096                   if (cmp->rbearing < left + rbearing)
23097                     cmp->rbearing = left + rbearing;
23098                 }
23099             }
23100 
23101           /* If there are glyphs whose x-offsets are negative,
23102              shift all glyphs to the right and make all x-offsets
23103              non-negative.  */
23104           if (leftmost < 0)
23105             {
23106               for (i = 0; i < cmp->glyph_len; i++)
23107                 cmp->offsets[i * 2] -= leftmost;
23108               rightmost -= leftmost;
23109               cmp->lbearing -= leftmost;
23110               cmp->rbearing -= leftmost;
23111             }
23112 
23113           if (left_padded && cmp->lbearing < 0)
23114             {
23115               for (i = 0; i < cmp->glyph_len; i++)
23116                 cmp->offsets[i * 2] -= cmp->lbearing;
23117               rightmost -= cmp->lbearing;
23118               cmp->rbearing -= cmp->lbearing;
23119               cmp->lbearing = 0;
23120             }
23121           if (right_padded && rightmost < cmp->rbearing)
23122             {
23123               rightmost = cmp->rbearing;
23124             }
23125 
23126           cmp->pixel_width = rightmost;
23127           cmp->ascent = highest;
23128           cmp->descent = - lowest;
23129           if (cmp->ascent < font_ascent)
23130             cmp->ascent = font_ascent;
23131           if (cmp->descent < font_descent)
23132             cmp->descent = font_descent;
23133         }
23134 
23135       if (it->glyph_row
23136           && (cmp->lbearing < 0
23137               || cmp->rbearing > cmp->pixel_width))
23138         it->glyph_row->contains_overlapping_glyphs_p = 1;
23139 
23140       it->pixel_width = cmp->pixel_width;
23141       it->ascent = it->phys_ascent = cmp->ascent;
23142       it->descent = it->phys_descent = cmp->descent;
23143       if (face->box != FACE_NO_BOX)
23144         {
23145           int thick = face->box_line_width;
23146 
23147           if (thick > 0)
23148             {
23149               it->ascent += thick;
23150               it->descent += thick;
23151             }
23152           else
23153             thick = - thick;
23154 
23155           if (it->start_of_box_run_p)
23156             it->pixel_width += thick;
23157           if (it->end_of_box_run_p)
23158             it->pixel_width += thick;
23159         }
23160 
23161       /* If face has an overline, add the height of the overline
23162          (1 pixel) and a 1 pixel margin to the character height.  */
23163       if (face->overline_p)
23164         it->ascent += overline_margin;
23165 
23166       take_vertical_position_into_account (it);
23167       if (it->ascent < 0)
23168         it->ascent = 0;
23169       if (it->descent < 0)
23170         it->descent = 0;
23171 
23172       if (it->glyph_row)
23173         append_composite_glyph (it);
23174     }
23175   else if (it->what == IT_COMPOSITION)
23176     {
23177       /* A dynamic (automatic) composition.  */
23178       struct face *face = FACE_FROM_ID (it->f, it->face_id);
23179       Lisp_Object gstring;
23180       struct font_metrics metrics;
23181 
23182       gstring = composition_gstring_from_id (it->cmp_it.id);
23183       it->pixel_width
23184         = composition_gstring_width (gstring, it->cmp_it.from, it->cmp_it.to,
23185                                      &metrics);
23186       if (it->glyph_row
23187           && (metrics.lbearing < 0 || metrics.rbearing > metrics.width))
23188         it->glyph_row->contains_overlapping_glyphs_p = 1;
23189       it->ascent = it->phys_ascent = metrics.ascent;
23190       it->descent = it->phys_descent = metrics.descent;
23191       if (face->box != FACE_NO_BOX)
23192         {
23193           int thick = face->box_line_width;
23194 
23195           if (thick > 0)
23196             {
23197               it->ascent += thick;
23198               it->descent += thick;
23199             }
23200           else
23201             thick = - thick;
23202 
23203           if (it->start_of_box_run_p)
23204             it->pixel_width += thick;
23205           if (it->end_of_box_run_p)
23206             it->pixel_width += thick;
23207         }
23208       /* If face has an overline, add the height of the overline
23209          (1 pixel) and a 1 pixel margin to the character height.  */
23210       if (face->overline_p)
23211         it->ascent += overline_margin;
23212       take_vertical_position_into_account (it);
23213       if (it->ascent < 0)
23214         it->ascent = 0;
23215       if (it->descent < 0)
23216         it->descent = 0;
23217 
23218       if (it->glyph_row)
23219         append_composite_glyph (it);
23220     }
23221   else if (it->what == IT_IMAGE)
23222     produce_image_glyph (it);
23223   else if (it->what == IT_STRETCH)
23224     produce_stretch_glyph (it);
23225 
23226   /* Accumulate dimensions.  Note: can't assume that it->descent > 0
23227      because this isn't true for images with `:ascent 100'.  */
23228   xassert (it->ascent >= 0 && it->descent >= 0);
23229   if (it->area == TEXT_AREA)
23230     it->current_x += it->pixel_width;
23231 
23232   if (extra_line_spacing > 0)
23233     {
23234       it->descent += extra_line_spacing;
23235       if (extra_line_spacing > it->max_extra_line_spacing)
23236         it->max_extra_line_spacing = extra_line_spacing;
23237     }
23238 
23239   it->max_ascent = max (it->max_ascent, it->ascent);
23240   it->max_descent = max (it->max_descent, it->descent);
23241   it->max_phys_ascent = max (it->max_phys_ascent, it->phys_ascent);
23242   it->max_phys_descent = max (it->max_phys_descent, it->phys_descent);
23243 }
23244 
23245 /* EXPORT for RIF:
23246    Output LEN glyphs starting at START at the nominal cursor position.
23247    Advance the nominal cursor over the text.  The global variable
23248    updated_window contains the window being updated, updated_row is
23249    the glyph row being updated, and updated_area is the area of that
23250    row being updated.  */
23251 
23252 void
23253 x_write_glyphs (start, len)
23254      struct glyph *start;
23255      int len;
23256 {
23257   int x, hpos;
23258 
23259   xassert (updated_window && updated_row);
23260   BLOCK_INPUT;
23261 
23262   /* Write glyphs.  */
23263 
23264   hpos = start - updated_row->glyphs[updated_area];
23265   x = draw_glyphs (updated_window, output_cursor.x,
23266                    updated_row, updated_area,
23267                    hpos, hpos + len,
23268                    DRAW_NORMAL_TEXT, 0);
23269 
23270   /* Invalidate old phys cursor if the glyph at its hpos is redrawn.  */
23271   if (updated_area == TEXT_AREA
23272       && updated_window->phys_cursor_on_p
23273       && updated_window->phys_cursor.vpos == output_cursor.vpos
23274       && updated_window->phys_cursor.hpos >= hpos
23275       && updated_window->phys_cursor.hpos < hpos + len)
23276     updated_window->phys_cursor_on_p = 0;
23277 
23278   UNBLOCK_INPUT;
23279 
23280   /* Advance the output cursor.  */
23281   output_cursor.hpos += len;
23282   output_cursor.x = x;
23283 }
23284 
23285 
23286 /* EXPORT for RIF:
23287    Insert LEN glyphs from START at the nominal cursor position.  */
23288 
23289 void
23290 x_insert_glyphs (start, len)
23291      struct glyph *start;
23292      int len;
23293 {
23294   struct frame *f;
23295   struct window *w;
23296   int line_height, shift_by_width, shifted_region_width;
23297   struct glyph_row *row;
23298   struct glyph *glyph;
23299   int frame_x, frame_y;
23300   EMACS_INT hpos;
23301 
23302   xassert (updated_window && updated_row);
23303   BLOCK_INPUT;
23304   w = updated_window;
23305   f = XFRAME (WINDOW_FRAME (w));
23306 
23307   /* Get the height of the line we are in.  */
23308   row = updated_row;
23309   line_height = row->height;
23310 
23311   /* Get the width of the glyphs to insert.  */
23312   shift_by_width = 0;
23313   for (glyph = start; glyph < start + len; ++glyph)
23314     shift_by_width += glyph->pixel_width;
23315 
23316   /* Get the width of the region to shift right.  */
23317   shifted_region_width = (window_box_width (w, updated_area)
23318                           - output_cursor.x
23319                           - shift_by_width);
23320 
23321   /* Shift right.  */
23322   frame_x = window_box_left (w, updated_area) + output_cursor.x;
23323   frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, output_cursor.y);
23324 
23325   FRAME_RIF (f)->shift_glyphs_for_insert (f, frame_x, frame_y, shifted_region_width,
23326                                           line_height, shift_by_width);
23327 
23328   /* Write the glyphs.  */
23329   hpos = start - row->glyphs[updated_area];
23330   draw_glyphs (w, output_cursor.x, row, updated_area,
23331                hpos, hpos + len,
23332                DRAW_NORMAL_TEXT, 0);
23333 
23334   /* Advance the output cursor.  */
23335   output_cursor.hpos += len;
23336   output_cursor.x += shift_by_width;
23337   UNBLOCK_INPUT;
23338 }
23339 
23340 
23341 /* EXPORT for RIF:
23342    Erase the current text line from the nominal cursor position
23343    (inclusive) to pixel column TO_X (exclusive).  The idea is that
23344    everything from TO_X onward is already erased.
23345 
23346    TO_X is a pixel position relative to updated_area of
23347    updated_window.  TO_X == -1 means clear to the end of this area.  */
23348 
23349 void
23350 x_clear_end_of_line (to_x)
23351      int to_x;
23352 {
23353   struct frame *f;
23354   struct window *w = updated_window;
23355   int max_x, min_y, max_y;
23356   int from_x, from_y, to_y;
23357 
23358   xassert (updated_window && updated_row);
23359   f = XFRAME (w->frame);
23360 
23361   if (updated_row->full_width_p)
23362     max_x = WINDOW_TOTAL_WIDTH (w);
23363   else
23364     max_x = window_box_width (w, updated_area);
23365   max_y = window_text_bottom_y (w);
23366 
23367   /* TO_X == 0 means don't do anything.  TO_X < 0 means clear to end
23368      of window.  For TO_X > 0, truncate to end of drawing area.  */
23369   if (to_x == 0)
23370     return;
23371   else if (to_x < 0)
23372     to_x = max_x;
23373   else
23374     to_x = min (to_x, max_x);
23375 
23376   to_y = min (max_y, output_cursor.y + updated_row->height);
23377 
23378   /* Notice if the cursor will be cleared by this operation.  */
23379   if (!updated_row->full_width_p)
23380     notice_overwritten_cursor (w, updated_area,
23381                                output_cursor.x, -1,
23382                                updated_row->y,
23383                                MATRIX_ROW_BOTTOM_Y (updated_row));
23384 
23385   from_x = output_cursor.x;
23386 
23387   /* Translate to frame coordinates.  */
23388   if (updated_row->full_width_p)
23389     {
23390       from_x = WINDOW_TO_FRAME_PIXEL_X (w, from_x);
23391       to_x = WINDOW_TO_FRAME_PIXEL_X (w, to_x);
23392     }
23393   else
23394     {
23395       int area_left = window_box_left (w, updated_area);
23396       from_x += area_left;
23397       to_x += area_left;
23398     }
23399 
23400   min_y = WINDOW_HEADER_LINE_HEIGHT (w);
23401   from_y = WINDOW_TO_FRAME_PIXEL_Y (w, max (min_y, output_cursor.y));
23402   to_y = WINDOW_TO_FRAME_PIXEL_Y (w, to_y);
23403 
23404   /* Prevent inadvertently clearing to end of the X window.  */
23405   if (to_x > from_x && to_y > from_y)
23406     {
23407       BLOCK_INPUT;
23408       FRAME_RIF (f)->clear_frame_area (f, from_x, from_y,
23409                                        to_x - from_x, to_y - from_y);
23410       UNBLOCK_INPUT;
23411     }
23412 }
23413 
23414 #endif /* HAVE_WINDOW_SYSTEM */
23415 
23416 
23417 
23418 /***********************************************************************
23419                              Cursor types
23420  ***********************************************************************/
23421 
23422 /* Value is the internal representation of the specified cursor type
23423    ARG.  If type is BAR_CURSOR, return in *WIDTH the specified width
23424    of the bar cursor.  */
23425 
23426 static enum text_cursor_kinds
23427 get_specified_cursor_type (arg, width)
23428      Lisp_Object arg;
23429      int *width;
23430 {
23431   enum text_cursor_kinds type;
23432 
23433   if (NILP (arg))
23434     return NO_CURSOR;
23435 
23436   if (EQ (arg, Qbox))
23437     return FILLED_BOX_CURSOR;
23438 
23439   if (EQ (arg, Qhollow))
23440     return HOLLOW_BOX_CURSOR;
23441 
23442   if (EQ (arg, Qbar))
23443     {
23444       *width = 2;
23445       return BAR_CURSOR;
23446     }
23447 
23448   if (CONSP (arg)
23449       && EQ (XCAR (arg), Qbar)
23450       && INTEGERP (XCDR (arg))
23451       && XINT (XCDR (arg)) >= 0)
23452     {
23453       *width = XINT (XCDR (arg));
23454       return BAR_CURSOR;
23455     }
23456 
23457   if (EQ (arg, Qhbar))
23458     {
23459       *width = 2;
23460       return HBAR_CURSOR;
23461     }
23462 
23463   if (CONSP (arg)
23464       && EQ (XCAR (arg), Qhbar)
23465       && INTEGERP (XCDR (arg))
23466       && XINT (XCDR (arg)) >= 0)
23467     {
23468       *width = XINT (XCDR (arg));
23469       return HBAR_CURSOR;
23470     }
23471 
23472   /* Treat anything unknown as "hollow box cursor".
23473      It was bad to signal an error; people have trouble fixing
23474      .Xdefaults with Emacs, when it has something bad in it.  */
23475   type = HOLLOW_BOX_CURSOR;
23476 
23477   return type;
23478 }
23479 
23480 /* Set the default cursor types for specified frame.  */
23481 void
23482 set_frame_cursor_types (f, arg)
23483      struct frame *f;
23484      Lisp_Object arg;
23485 {
23486   int width;
23487   Lisp_Object tem;
23488 
23489   FRAME_DESIRED_CURSOR (f) = get_specified_cursor_type (arg, &width);
23490   FRAME_CURSOR_WIDTH (f) = width;
23491 
23492   /* By default, set up the blink-off state depending on the on-state.  */
23493 
23494   tem = Fassoc (arg, Vblink_cursor_alist);
23495   if (!NILP (tem))
23496     {
23497       FRAME_BLINK_OFF_CURSOR (f)
23498         = get_specified_cursor_type (XCDR (tem), &width);
23499       FRAME_BLINK_OFF_CURSOR_WIDTH (f) = width;
23500     }
23501   else
23502     FRAME_BLINK_OFF_CURSOR (f) = DEFAULT_CURSOR;
23503 }
23504 
23505 
23506 /* Return the cursor we want to be displayed in window W.  Return
23507    width of bar/hbar cursor through WIDTH arg.  Return with
23508    ACTIVE_CURSOR arg set to 1 if cursor in window W is `active'
23509    (i.e. if the `system caret' should track this cursor).
23510 
23511    In a mini-buffer window, we want the cursor only to appear if we
23512    are reading input from this window.  For the selected window, we
23513    want the cursor type given by the frame parameter or buffer local
23514    setting of cursor-type.  If explicitly marked off, draw no cursor.
23515    In all other cases, we want a hollow box cursor.  */
23516 
23517 static enum text_cursor_kinds
23518 get_window_cursor_type (w, glyph, width, active_cursor)
23519      struct window *w;
23520      struct glyph *glyph;
23521      int *width;
23522      int *active_cursor;
23523 {
23524   struct frame *f = XFRAME (w->frame);
23525   struct buffer *b = XBUFFER (w->buffer);
23526   int cursor_type = DEFAULT_CURSOR;
23527   Lisp_Object alt_cursor;
23528   int non_selected = 0;
23529 
23530   *active_cursor = 1;
23531 
23532   /* Echo area */
23533   if (cursor_in_echo_area
23534       && FRAME_HAS_MINIBUF_P (f)
23535       && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
23536     {
23537       if (w == XWINDOW (echo_area_window))
23538         {
23539           if (EQ (b->cursor_type, Qt) || NILP (b->cursor_type))
23540             {
23541               *width = FRAME_CURSOR_WIDTH (f);
23542               return FRAME_DESIRED_CURSOR (f);
23543             }
23544           else
23545             return get_specified_cursor_type (b->cursor_type, width);
23546         }
23547 
23548       *active_cursor = 0;
23549       non_selected = 1;
23550     }
23551 
23552   /* Detect a nonselected window or nonselected frame.  */
23553   else if (w != XWINDOW (f->selected_window)
23554 #ifdef HAVE_WINDOW_SYSTEM
23555            || f != FRAME_X_DISPLAY_INFO (f)->x_highlight_frame
23556 #endif
23557            )
23558     {
23559       *active_cursor = 0;
23560 
23561       if (MINI_WINDOW_P (w) && minibuf_level == 0)
23562         return NO_CURSOR;
23563 
23564       non_selected = 1;
23565     }
23566 
23567   /* Never display a cursor in a window in which cursor-type is nil.  */
23568   if (NILP (b->cursor_type))
23569     return NO_CURSOR;
23570 
23571   /* Get the normal cursor type for this window.  */
23572   if (EQ (b->cursor_type, Qt))
23573     {
23574       cursor_type = FRAME_DESIRED_CURSOR (f);
23575       *width = FRAME_CURSOR_WIDTH (f);
23576     }
23577   else
23578     cursor_type = get_specified_cursor_type (b->cursor_type, width);
23579 
23580   /* Use cursor-in-non-selected-windows instead
23581      for non-selected window or frame.  */
23582   if (non_selected)
23583     {
23584       alt_cursor = b->cursor_in_non_selected_windows;
23585       if (!EQ (Qt, alt_cursor))
23586         return get_specified_cursor_type (alt_cursor, width);
23587       /* t means modify the normal cursor type.  */
23588       if (cursor_type == FILLED_BOX_CURSOR)
23589         cursor_type = HOLLOW_BOX_CURSOR;
23590       else if (cursor_type == BAR_CURSOR && *width > 1)
23591         --*width;
23592       return cursor_type;
23593     }
23594 
23595   /* Use normal cursor if not blinked off.  */
23596   if (!w->cursor_off_p)
23597     {
23598 #ifdef HAVE_WINDOW_SYSTEM
23599       if (glyph != NULL && glyph->type == IMAGE_GLYPH)
23600         {
23601           if (cursor_type == FILLED_BOX_CURSOR)
23602             {
23603               /* Using a block cursor on large images can be very annoying.
23604                  So use a hollow cursor for "large" images.
23605                  If image is not transparent (no mask), also use hollow cursor.  */
23606               struct image *img = IMAGE_FROM_ID (f, glyph->u.img_id);
23607               if (img != NULL && IMAGEP (img->spec))
23608                 {
23609                   /* Arbitrarily, interpret "Large" as >32x32 and >NxN
23610                      where N = size of default frame font size.
23611                      This should cover most of the "tiny" icons people may use.  */
23612                   if (!img->mask
23613                       || img->width > max (32, WINDOW_FRAME_COLUMN_WIDTH (w))
23614                       || img->height > max (32, WINDOW_FRAME_LINE_HEIGHT (w)))
23615                     cursor_type = HOLLOW_BOX_CURSOR;
23616                 }
23617             }
23618           else if (cursor_type != NO_CURSOR)
23619             {
23620               /* Display current only supports BOX and HOLLOW cursors for images.
23621                  So for now, unconditionally use a HOLLOW cursor when cursor is
23622                  not a solid box cursor.  */
23623               cursor_type = HOLLOW_BOX_CURSOR;
23624             }
23625       }
23626 #endif
23627       return cursor_type;
23628     }
23629 
23630   /* Cursor is blinked off, so determine how to "toggle" it.  */
23631 
23632   /* First look for an entry matching the buffer's cursor-type in blink-cursor-alist.  */
23633   if ((alt_cursor = Fassoc (b->cursor_type, Vblink_cursor_alist), !NILP (alt_cursor)))
23634     return get_specified_cursor_type (XCDR (alt_cursor), width);
23635 
23636   /* Then see if frame has specified a specific blink off cursor type.  */
23637   if (FRAME_BLINK_OFF_CURSOR (f) != DEFAULT_CURSOR)
23638     {
23639       *width = FRAME_BLINK_OFF_CURSOR_WIDTH (f);
23640       return FRAME_BLINK_OFF_CURSOR (f);
23641     }
23642 
23643 #if 0
23644   /* Some people liked having a permanently visible blinking cursor,
23645      while others had very strong opinions against it.  So it was
23646      decided to remove it.  KFS 2003-09-03 */
23647 
23648   /* Finally perform built-in cursor blinking:
23649        filled box      <->   hollow box
23650        wide [h]bar     <->   narrow [h]bar
23651        narrow [h]bar   <->   no cursor
23652        other type      <->   no cursor  */
23653 
23654   if (cursor_type == FILLED_BOX_CURSOR)
23655     return HOLLOW_BOX_CURSOR;
23656 
23657   if ((cursor_type == BAR_CURSOR || cursor_type == HBAR_CURSOR) && *width > 1)
23658     {
23659       *width = 1;
23660       return cursor_type;
23661     }
23662 #endif
23663 
23664   return NO_CURSOR;
23665 }
23666 
23667 
23668 #ifdef HAVE_WINDOW_SYSTEM
23669 
23670 /* Notice when the text cursor of window W has been completely
23671    overwritten by a drawing operation that outputs glyphs in AREA
23672    starting at X0 and ending at X1 in the line starting at Y0 and
23673    ending at Y1.  X coordinates are area-relative.  X1 < 0 means all
23674    the rest of the line after X0 has been written.  Y coordinates
23675    are window-relative.  */
23676 
23677 static void
23678 notice_overwritten_cursor (w, area, x0, x1, y0, y1)
23679      struct window *w;
23680      enum glyph_row_area area;
23681      int x0, y0, x1, y1;
23682 {
23683   int cx0, cx1, cy0, cy1;
23684   struct glyph_row *row;
23685 
23686   if (!w->phys_cursor_on_p)
23687     return;
23688   if (area != TEXT_AREA)
23689     return;
23690 
23691   if (w->phys_cursor.vpos < 0
23692       || w->phys_cursor.vpos >= w->current_matrix->nrows
23693       || (row = w->current_matrix->rows + w->phys_cursor.vpos,
23694           !(row->enabled_p && row->displays_text_p)))
23695     return;
23696 
23697   if (row->cursor_in_fringe_p)
23698     {
23699       row->cursor_in_fringe_p = 0;
23700       draw_fringe_bitmap (w, row, row->reversed_p);
23701       w->phys_cursor_on_p = 0;
23702       return;
23703     }
23704 
23705   cx0 = w->phys_cursor.x;
23706   cx1 = cx0 + w->phys_cursor_width;
23707   if (x0 > cx0 || (x1 >= 0 && x1 < cx1))
23708     return;
23709 
23710   /* The cursor image will be completely removed from the
23711      screen if the output area intersects the cursor area in
23712      y-direction.  When we draw in [y0 y1[, and some part of
23713      the cursor is at y < y0, that part must have been drawn
23714      before.  When scrolling, the cursor is erased before
23715      actually scrolling, so we don't come here.  When not
23716      scrolling, the rows above the old cursor row must have
23717      changed, and in this case these rows must have written
23718      over the cursor image.
23719 
23720      Likewise if part of the cursor is below y1, with the
23721      exception of the cursor being in the first blank row at
23722      the buffer and window end because update_text_area
23723      doesn't draw that row.  (Except when it does, but
23724      that's handled in update_text_area.)  */
23725 
23726   cy0 = w->phys_cursor.y;
23727   cy1 = cy0 + w->phys_cursor_height;
23728   if ((y0 < cy0 || y0 >= cy1) && (y1 <= cy0 || y1 >= cy1))
23729     return;
23730 
23731   w->phys_cursor_on_p = 0;
23732 }
23733 
23734 #endif /* HAVE_WINDOW_SYSTEM */
23735 
23736 
23737 /************************************************************************
23738                               Mouse Face
23739  ************************************************************************/
23740 
23741 #ifdef HAVE_WINDOW_SYSTEM
23742 
23743 /* EXPORT for RIF:
23744    Fix the display of area AREA of overlapping row ROW in window W
23745    with respect to the overlapping part OVERLAPS.  */
23746 
23747 void
23748 x_fix_overlapping_area (w, row, area, overlaps)
23749      struct window *w;
23750      struct glyph_row *row;
23751      enum glyph_row_area area;
23752      int overlaps;
23753 {
23754   int i, x;
23755 
23756   BLOCK_INPUT;
23757 
23758   x = 0;
23759   for (i = 0; i < row->used[area];)
23760     {
23761       if (row->glyphs[area][i].overlaps_vertically_p)
23762         {
23763           int start = i, start_x = x;
23764 
23765           do
23766             {
23767               x += row->glyphs[area][i].pixel_width;
23768               ++i;
23769             }
23770           while (i < row->used[area]
23771                  && row->glyphs[area][i].overlaps_vertically_p);
23772 
23773           draw_glyphs (w, start_x, row, area,
23774                        start, i,
23775                        DRAW_NORMAL_TEXT, overlaps);
23776         }
23777       else
23778         {
23779           x += row->glyphs[area][i].pixel_width;
23780           ++i;
23781         }
23782     }
23783 
23784   UNBLOCK_INPUT;
23785 }
23786 
23787 
23788 /* EXPORT:
23789    Draw the cursor glyph of window W in glyph row ROW.  See the
23790    comment of draw_glyphs for the meaning of HL.  */
23791 
23792 void
23793 draw_phys_cursor_glyph (w, row, hl)
23794      struct window *w;
23795      struct glyph_row *row;
23796      enum draw_glyphs_face hl;
23797 {
23798   /* If cursor hpos is out of bounds, don't draw garbage.  This can
23799      happen in mini-buffer windows when switching between echo area
23800      glyphs and mini-buffer.  */
23801   if ((row->reversed_p
23802        ? (w->phys_cursor.hpos >= 0)
23803        : (w->phys_cursor.hpos < row->used[TEXT_AREA])))
23804     {
23805       int on_p = w->phys_cursor_on_p;
23806       int x1;
23807       x1 = draw_glyphs (w, w->phys_cursor.x, row, TEXT_AREA,
23808                         w->phys_cursor.hpos, w->phys_cursor.hpos + 1,
23809                         hl, 0);
23810       w->phys_cursor_on_p = on_p;
23811 
23812       if (hl == DRAW_CURSOR)
23813         w->phys_cursor_width = x1 - w->phys_cursor.x;
23814       /* When we erase the cursor, and ROW is overlapped by other
23815          rows, make sure that these overlapping parts of other rows
23816          are redrawn.  */
23817       else if (hl == DRAW_NORMAL_TEXT && row->overlapped_p)
23818         {
23819           w->phys_cursor_width = x1 - w->phys_cursor.x;
23820 
23821           if (row > w->current_matrix->rows
23822               && MATRIX_ROW_OVERLAPS_SUCC_P (row - 1))
23823             x_fix_overlapping_area (w, row - 1, TEXT_AREA,
23824                                     OVERLAPS_ERASED_CURSOR);
23825 
23826           if (MATRIX_ROW_BOTTOM_Y (row) < window_text_bottom_y (w)
23827               && MATRIX_ROW_OVERLAPS_PRED_P (row + 1))
23828             x_fix_overlapping_area (w, row + 1, TEXT_AREA,
23829                                     OVERLAPS_ERASED_CURSOR);
23830         }
23831     }
23832 }
23833 
23834 
23835 /* EXPORT:
23836    Erase the image of a cursor of window W from the screen.  */
23837 
23838 void
23839 erase_phys_cursor (w)
23840      struct window *w;
23841 {
23842   struct frame *f = XFRAME (w->frame);
23843   Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
23844   int hpos = w->phys_cursor.hpos;
23845   int vpos = w->phys_cursor.vpos;
23846   int mouse_face_here_p = 0;
23847   struct glyph_matrix *active_glyphs = w->current_matrix;
23848   struct glyph_row *cursor_row;
23849   struct glyph *cursor_glyph;
23850   enum draw_glyphs_face hl;
23851 
23852   /* No cursor displayed or row invalidated => nothing to do on the
23853      screen.  */
23854   if (w->phys_cursor_type == NO_CURSOR)
23855     goto mark_cursor_off;
23856 
23857   /* VPOS >= active_glyphs->nrows means that window has been resized.
23858      Don't bother to erase the cursor.  */
23859   if (vpos >= active_glyphs->nrows)
23860     goto mark_cursor_off;
23861 
23862   /* If row containing cursor is marked invalid, there is nothing we
23863      can do.  */
23864   cursor_row = MATRIX_ROW (active_glyphs, vpos);
23865   if (!cursor_row->enabled_p)
23866     goto mark_cursor_off;
23867 
23868   /* If line spacing is > 0, old cursor may only be partially visible in
23869      window after split-window.  So adjust visible height.  */
23870   cursor_row->visible_height = min (cursor_row->visible_height,
23871                                     window_text_bottom_y (w) - cursor_row->y);
23872 
23873   /* If row is completely invisible, don't attempt to delete a cursor which
23874      isn't there.  This can happen if cursor is at top of a window, and
23875      we switch to a buffer with a header line in that window.  */
23876   if (cursor_row->visible_height <= 0)
23877     goto mark_cursor_off;
23878 
23879   /* If cursor is in the fringe, erase by drawing actual bitmap there.  */
23880   if (cursor_row->cursor_in_fringe_p)
23881     {
23882       cursor_row->cursor_in_fringe_p = 0;
23883       draw_fringe_bitmap (w, cursor_row, cursor_row->reversed_p);
23884       goto mark_cursor_off;
23885     }
23886 
23887   /* This can happen when the new row is shorter than the old one.
23888      In this case, either draw_glyphs or clear_end_of_line
23889      should have cleared the cursor.  Note that we wouldn't be
23890      able to erase the cursor in this case because we don't have a
23891      cursor glyph at hand.  */
23892   if ((cursor_row->reversed_p
23893        ? (w->phys_cursor.hpos < 0)
23894        : (w->phys_cursor.hpos >= cursor_row->used[TEXT_AREA])))
23895     goto mark_cursor_off;
23896 
23897   /* If the cursor is in the mouse face area, redisplay that when
23898      we clear the cursor.  */
23899   if (! NILP (dpyinfo->mouse_face_window)
23900       && w == XWINDOW (dpyinfo->mouse_face_window)
23901       && (vpos > dpyinfo->mouse_face_beg_row
23902           || (vpos == dpyinfo->mouse_face_beg_row
23903               && hpos >= dpyinfo->mouse_face_beg_col))
23904       && (vpos < dpyinfo->mouse_face_end_row
23905           || (vpos == dpyinfo->mouse_face_end_row
23906               && hpos < dpyinfo->mouse_face_end_col))
23907       /* Don't redraw the cursor's spot in mouse face if it is at the
23908          end of a line (on a newline).  The cursor appears there, but
23909          mouse highlighting does not.  */
23910       && cursor_row->used[TEXT_AREA] > hpos && hpos >= 0)
23911     mouse_face_here_p = 1;
23912 
23913   /* Maybe clear the display under the cursor.  */
23914   if (w->phys_cursor_type == HOLLOW_BOX_CURSOR)
23915     {
23916       int x, y, left_x;
23917       int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
23918       int width;
23919 
23920       cursor_glyph = get_phys_cursor_glyph (w);
23921       if (cursor_glyph == NULL)
23922         goto mark_cursor_off;
23923 
23924       width = cursor_glyph->pixel_width;
23925       left_x = window_box_left_offset (w, TEXT_AREA);
23926       x = w->phys_cursor.x;
23927       if (x < left_x)
23928         width -= left_x - x;
23929       width = min (width, window_box_width (w, TEXT_AREA) - x);
23930       y = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height, cursor_row->y));
23931       x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, max (x, left_x));
23932 
23933       if (width > 0)
23934         FRAME_RIF (f)->clear_frame_area (f, x, y, width, cursor_row->visible_height);
23935     }
23936 
23937   /* Erase the cursor by redrawing the character underneath it.  */
23938   if (mouse_face_here_p)
23939     hl = DRAW_MOUSE_FACE;
23940   else
23941     hl = DRAW_NORMAL_TEXT;
23942   draw_phys_cursor_glyph (w, cursor_row, hl);
23943 
23944  mark_cursor_off:
23945   w->phys_cursor_on_p = 0;
23946   w->phys_cursor_type = NO_CURSOR;
23947 }
23948 
23949 
23950 /* EXPORT:
23951    Display or clear cursor of window W.  If ON is zero, clear the
23952    cursor.  If it is non-zero, display the cursor.  If ON is nonzero,
23953    where to put the cursor is specified by HPOS, VPOS, X and Y.  */
23954 
23955 void
23956 display_and_set_cursor (w, on, hpos, vpos, x, y)
23957      struct window *w;
23958      int on, hpos, vpos, x, y;
23959 {
23960   struct frame *f = XFRAME (w->frame);
23961   int new_cursor_type;
23962   int new_cursor_width;
23963   int active_cursor;
23964   struct glyph_row *glyph_row;
23965   struct glyph *glyph;
23966 
23967   /* This is pointless on invisible frames, and dangerous on garbaged
23968      windows and frames; in the latter case, the frame or window may
23969      be in the midst of changing its size, and x and y may be off the
23970      window.  */
23971   if (! FRAME_VISIBLE_P (f)
23972       || FRAME_GARBAGED_P (f)
23973       || vpos >= w->current_matrix->nrows
23974       || hpos >= w->current_matrix->matrix_w)
23975     return;
23976 
23977   /* If cursor is off and we want it off, return quickly.  */
23978   if (!on && !w->phys_cursor_on_p)
23979     return;
23980 
23981   glyph_row = MATRIX_ROW (w->current_matrix, vpos);
23982   /* If cursor row is not enabled, we don't really know where to
23983      display the cursor.  */
23984   if (!glyph_row->enabled_p)
23985     {
23986       w->phys_cursor_on_p = 0;
23987       return;
23988     }
23989 
23990   glyph = NULL;
23991   if (!glyph_row->exact_window_width_line_p
23992       || (0 <= hpos && hpos < glyph_row->used[TEXT_AREA]))
23993     glyph = glyph_row->glyphs[TEXT_AREA] + hpos;
23994 
23995   xassert (interrupt_input_blocked);
23996 
23997   /* Set new_cursor_type to the cursor we want to be displayed.  */
23998   new_cursor_type = get_window_cursor_type (w, glyph,
23999                                             &new_cursor_width, &active_cursor);
24000 
24001   /* If cursor is currently being shown and we don't want it to be or
24002      it is in the wrong place, or the cursor type is not what we want,
24003      erase it.  */
24004   if (w->phys_cursor_on_p
24005       && (!on
24006           || w->phys_cursor.x != x
24007           || w->phys_cursor.y != y
24008           || new_cursor_type != w->phys_cursor_type
24009           || ((new_cursor_type == BAR_CURSOR || new_cursor_type == HBAR_CURSOR)
24010               && new_cursor_width != w->phys_cursor_width)))
24011     erase_phys_cursor (w);
24012 
24013   /* Don't check phys_cursor_on_p here because that flag is only set
24014      to zero in some cases where we know that the cursor has been
24015      completely erased, to avoid the extra work of erasing the cursor
24016      twice.  In other words, phys_cursor_on_p can be 1 and the cursor
24017      still not be visible, or it has only been partly erased.  */
24018   if (on)
24019     {
24020       w->phys_cursor_ascent = glyph_row->ascent;
24021       w->phys_cursor_height = glyph_row->height;
24022 
24023       /* Set phys_cursor_.* before x_draw_.* is called because some
24024          of them may need the information.  */
24025       w->phys_cursor.x = x;
24026       w->phys_cursor.y = glyph_row->y;
24027       w->phys_cursor.hpos = hpos;
24028       w->phys_cursor.vpos = vpos;
24029     }
24030 
24031   FRAME_RIF (f)->draw_window_cursor (w, glyph_row, x, y,
24032                                      new_cursor_type, new_cursor_width,
24033                                      on, active_cursor);
24034 }
24035 
24036 
24037 /* Switch the display of W's cursor on or off, according to the value
24038    of ON.  */
24039 
24040 void
24041 update_window_cursor (w, on)
24042      struct window *w;
24043      int on;
24044 {
24045   /* Don't update cursor in windows whose frame is in the process
24046      of being deleted.  */
24047   if (w->current_matrix)
24048     {
24049       BLOCK_INPUT;
24050       display_and_set_cursor (w, on, w->phys_cursor.hpos, w->phys_cursor.vpos,
24051                               w->phys_cursor.x, w->phys_cursor.y);
24052       UNBLOCK_INPUT;
24053     }
24054 }
24055 
24056 
24057 /* Call update_window_cursor with parameter ON_P on all leaf windows
24058    in the window tree rooted at W.  */
24059 
24060 static void
24061 update_cursor_in_window_tree (w, on_p)
24062      struct window *w;
24063      int on_p;
24064 {
24065   while (w)
24066     {
24067       if (!NILP (w->hchild))
24068         update_cursor_in_window_tree (XWINDOW (w->hchild), on_p);
24069       else if (!NILP (w->vchild))
24070         update_cursor_in_window_tree (XWINDOW (w->vchild), on_p);
24071       else
24072         update_window_cursor (w, on_p);
24073 
24074       w = NILP (w->next) ? 0 : XWINDOW (w->next);
24075     }
24076 }
24077 
24078 
24079 /* EXPORT:
24080    Display the cursor on window W, or clear it, according to ON_P.
24081    Don't change the cursor's position.  */
24082 
24083 void
24084 x_update_cursor (f, on_p)
24085      struct frame *f;
24086      int on_p;
24087 {
24088   update_cursor_in_window_tree (XWINDOW (f->root_window), on_p);
24089 }
24090 
24091 
24092 /* EXPORT:
24093    Clear the cursor of window W to background color, and mark the
24094    cursor as not shown.  This is used when the text where the cursor
24095    is about to be rewritten.  */
24096 
24097 void
24098 x_clear_cursor (w)
24099      struct window *w;
24100 {
24101   if (FRAME_VISIBLE_P (XFRAME (w->frame)) && w->phys_cursor_on_p)
24102     update_window_cursor (w, 0);
24103 }
24104 
24105 
24106 /* EXPORT:
24107    Display the active region described by mouse_face_* according to DRAW.  */
24108 
24109 void
24110 show_mouse_face (dpyinfo, draw)
24111      Display_Info *dpyinfo;
24112      enum draw_glyphs_face draw;
24113 {
24114   struct window *w = XWINDOW (dpyinfo->mouse_face_window);
24115   struct frame *f = XFRAME (WINDOW_FRAME (w));
24116 
24117   if (/* If window is in the process of being destroyed, don't bother
24118          to do anything.  */
24119       w->current_matrix != NULL
24120       /* Don't update mouse highlight if hidden */
24121       && (draw != DRAW_MOUSE_FACE || !dpyinfo->mouse_face_hidden)
24122       /* Recognize when we are called to operate on rows that don't exist
24123          anymore.  This can happen when a window is split.  */
24124       && dpyinfo->mouse_face_end_row < w->current_matrix->nrows)
24125     {
24126       int phys_cursor_on_p = w->phys_cursor_on_p;
24127       struct glyph_row *row, *first, *last;
24128 
24129       first = MATRIX_ROW (w->current_matrix, dpyinfo->mouse_face_beg_row);
24130       last = MATRIX_ROW (w->current_matrix, dpyinfo->mouse_face_end_row);
24131 
24132       for (row = first; row <= last && row->enabled_p; ++row)
24133         {
24134           int start_hpos, end_hpos, start_x;
24135 
24136           /* For all but the first row, the highlight starts at column 0.  */
24137           if (row == first)
24138             {
24139               start_hpos = dpyinfo->mouse_face_beg_col;
24140               start_x = dpyinfo->mouse_face_beg_x;
24141             }
24142           else
24143             {
24144               start_hpos = 0;
24145               start_x = 0;
24146             }
24147 
24148           if (row == last)
24149             end_hpos = dpyinfo->mouse_face_end_col;
24150           else
24151             {
24152               end_hpos = row->used[TEXT_AREA];
24153               if (draw == DRAW_NORMAL_TEXT)
24154                 row->fill_line_p = 1; /* Clear to end of line */
24155             }
24156 
24157           if (end_hpos > start_hpos)
24158             {
24159               draw_glyphs (w, start_x, row, TEXT_AREA,
24160                            start_hpos, end_hpos,
24161                            draw, 0);
24162 
24163               row->mouse_face_p
24164                 = draw == DRAW_MOUSE_FACE || draw == DRAW_IMAGE_RAISED;
24165             }
24166         }
24167 
24168       /* When we've written over the cursor, arrange for it to
24169          be displayed again.  */
24170       if (phys_cursor_on_p && !w->phys_cursor_on_p)
24171         {
24172           BLOCK_INPUT;
24173           display_and_set_cursor (w, 1,
24174                                   w->phys_cursor.hpos, w->phys_cursor.vpos,
24175                                   w->phys_cursor.x, w->phys_cursor.y);
24176           UNBLOCK_INPUT;
24177         }
24178     }
24179 
24180   /* Change the mouse cursor.  */
24181   if (draw == DRAW_NORMAL_TEXT && !EQ (dpyinfo->mouse_face_window, f->tool_bar_window))
24182     FRAME_RIF (f)->define_frame_cursor (f, FRAME_X_OUTPUT (f)->text_cursor);
24183   else if (draw == DRAW_MOUSE_FACE)
24184     FRAME_RIF (f)->define_frame_cursor (f, FRAME_X_OUTPUT (f)->hand_cursor);
24185   else
24186     FRAME_RIF (f)->define_frame_cursor (f, FRAME_X_OUTPUT (f)->nontext_cursor);
24187 }
24188 
24189 /* EXPORT:
24190    Clear out the mouse-highlighted active region.
24191    Redraw it un-highlighted first.  Value is non-zero if mouse
24192    face was actually drawn unhighlighted.  */
24193 
24194 int
24195 clear_mouse_face (dpyinfo)
24196      Display_Info *dpyinfo;
24197 {
24198   int cleared = 0;
24199 
24200   if (!dpyinfo->mouse_face_hidden && !NILP (dpyinfo->mouse_face_window))
24201     {
24202       show_mouse_face (dpyinfo, DRAW_NORMAL_TEXT);
24203       cleared = 1;
24204     }
24205 
24206   dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
24207   dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
24208   dpyinfo->mouse_face_window = Qnil;
24209   dpyinfo->mouse_face_overlay = Qnil;
24210   return cleared;
24211 }
24212 
24213 
24214 /* EXPORT:
24215    Non-zero if physical cursor of window W is within mouse face.  */
24216 
24217 int
24218 cursor_in_mouse_face_p (w)
24219      struct window *w;
24220 {
24221   Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
24222   int in_mouse_face = 0;
24223 
24224   if (WINDOWP (dpyinfo->mouse_face_window)
24225       && XWINDOW (dpyinfo->mouse_face_window) == w)
24226     {
24227       int hpos = w->phys_cursor.hpos;
24228       int vpos = w->phys_cursor.vpos;
24229 
24230       if (vpos >= dpyinfo->mouse_face_beg_row
24231           && vpos <= dpyinfo->mouse_face_end_row
24232           && (vpos > dpyinfo->mouse_face_beg_row
24233               || hpos >= dpyinfo->mouse_face_beg_col)
24234           && (vpos < dpyinfo->mouse_face_end_row
24235               || hpos < dpyinfo->mouse_face_end_col
24236               || dpyinfo->mouse_face_past_end))
24237         in_mouse_face = 1;
24238     }
24239 
24240   return in_mouse_face;
24241 }
24242 
24243 
24244 
24245 
24246 /* This function sets the mouse_face_* elements of DPYINFO, assuming
24247    the mouse cursor is on a glyph with buffer charpos MOUSE_CHARPOS in
24248    window WINDOW.  START_CHARPOS and END_CHARPOS are buffer positions
24249    for the overlay or run of text properties specifying the mouse
24250    face.  BEFORE_STRING and AFTER_STRING, if non-nil, are a
24251    before-string and after-string that must also be highlighted.
24252    DISPLAY_STRING, if non-nil, is a display string that may cover some
24253    or all of the highlighted text.  */
24254 
24255 static void
24256 mouse_face_from_buffer_pos (Lisp_Object window,
24257                             Display_Info *dpyinfo,
24258                             EMACS_INT mouse_charpos,
24259                             EMACS_INT start_charpos,
24260                             EMACS_INT end_charpos,
24261                             Lisp_Object before_string,
24262                             Lisp_Object after_string,
24263                             Lisp_Object display_string)
24264 {
24265   struct window *w = XWINDOW (window);
24266   struct glyph_row *first = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
24267   struct glyph_row *row;
24268   struct glyph *glyph, *end;
24269   EMACS_INT ignore;
24270   int x;
24271 
24272   xassert (NILP (display_string) || STRINGP (display_string));
24273   xassert (NILP (before_string) || STRINGP (before_string));
24274   xassert (NILP (after_string) || STRINGP (after_string));
24275 
24276   /* Find the first highlighted glyph.  */
24277   if (start_charpos < MATRIX_ROW_START_CHARPOS (first))
24278     {
24279       dpyinfo->mouse_face_beg_col = 0;
24280       dpyinfo->mouse_face_beg_row = MATRIX_ROW_VPOS (first, w->current_matrix);
24281       dpyinfo->mouse_face_beg_x = first->x;
24282       dpyinfo->mouse_face_beg_y = first->y;
24283     }
24284   else
24285     {
24286       row = row_containing_pos (w, start_charpos, first, NULL, 0);
24287       if (row == NULL)
24288         row = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
24289 
24290       /* If the before-string or display-string contains newlines,
24291          row_containing_pos skips to its last row.  Move back.  */
24292       if (!NILP (before_string) || !NILP (display_string))
24293         {
24294           struct glyph_row *prev;
24295           while ((prev = row - 1, prev >= first)
24296                  && MATRIX_ROW_END_CHARPOS (prev) == start_charpos
24297                  && prev->used[TEXT_AREA] > 0)
24298             {
24299               struct glyph *beg = prev->glyphs[TEXT_AREA];
24300               glyph = beg + prev->used[TEXT_AREA];
24301               while (--glyph >= beg && INTEGERP (glyph->object));
24302               if (glyph < beg
24303                   || !(EQ (glyph->object, before_string)
24304                        || EQ (glyph->object, display_string)))
24305                 break;
24306               row = prev;
24307             }
24308         }
24309 
24310       glyph = row->glyphs[TEXT_AREA];
24311       end = glyph + row->used[TEXT_AREA];
24312       x = row->x;
24313       dpyinfo->mouse_face_beg_y = row->y;
24314       dpyinfo->mouse_face_beg_row = MATRIX_ROW_VPOS (row, w->current_matrix);
24315 
24316       /* Skip truncation glyphs at the start of the glyph row.  */
24317       if (row->displays_text_p)
24318         for (; glyph < end
24319                && INTEGERP (glyph->object)
24320                && glyph->charpos < 0;
24321              ++glyph)
24322           x += glyph->pixel_width;
24323 
24324       /* Scan the glyph row, stopping before BEFORE_STRING or
24325          DISPLAY_STRING or START_CHARPOS.  */
24326       for (; glyph < end
24327              && !INTEGERP (glyph->object)
24328              && !EQ (glyph->object, before_string)
24329              && !EQ (glyph->object, display_string)
24330              && !(BUFFERP (glyph->object)
24331                   && glyph->charpos >= start_charpos);
24332            ++glyph)
24333         x += glyph->pixel_width;
24334 
24335       dpyinfo->mouse_face_beg_x = x;
24336       dpyinfo->mouse_face_beg_col = glyph - row->glyphs[TEXT_AREA];
24337     }
24338 
24339   /* Find the last highlighted glyph.  */
24340   row = row_containing_pos (w, end_charpos, first, NULL, 0);
24341   if (row == NULL)
24342     {
24343       row = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
24344       dpyinfo->mouse_face_past_end = 1;
24345     }
24346   else if (!NILP (after_string))
24347     {
24348       /* If the after-string has newlines, advance to its last row.  */
24349       struct glyph_row *next;
24350       struct glyph_row *last
24351         = MATRIX_ROW (w->current_matrix, XFASTINT (w->window_end_vpos));
24352 
24353       for (next = row + 1;
24354            next <= last
24355              && next->used[TEXT_AREA] > 0
24356              && EQ (next->glyphs[TEXT_AREA]->object, after_string);
24357            ++next)
24358         row = next;
24359     }
24360 
24361   glyph = row->glyphs[TEXT_AREA];
24362   end = glyph + row->used[TEXT_AREA];
24363   x = row->x;
24364   dpyinfo->mouse_face_end_y = row->y;
24365   dpyinfo->mouse_face_end_row = MATRIX_ROW_VPOS (row, w->current_matrix);
24366 
24367   /* Skip truncation glyphs at the start of the row.  */
24368   if (row->displays_text_p)
24369     for (; glyph < end
24370            && INTEGERP (glyph->object)
24371            && glyph->charpos < 0;
24372          ++glyph)
24373       x += glyph->pixel_width;
24374 
24375   /* Scan the glyph row, stopping at END_CHARPOS or when we encounter
24376      AFTER_STRING.  */
24377   for (; glyph < end
24378          && !INTEGERP (glyph->object)
24379          && !EQ (glyph->object, after_string)
24380          && !(BUFFERP (glyph->object) && glyph->charpos >= end_charpos);
24381        ++glyph)
24382     x += glyph->pixel_width;
24383 
24384   /* If we found AFTER_STRING, consume it and stop.  */
24385   if (EQ (glyph->object, after_string))
24386     {
24387       for (; EQ (glyph->object, after_string) && glyph < end; ++glyph)
24388         x += glyph->pixel_width;
24389     }
24390   else
24391     {
24392       /* If there's no after-string, we must check if we overshot,
24393          which might be the case if we stopped after a string glyph.
24394          That glyph may belong to a before-string or display-string
24395          associated with the end position, which must not be
24396          highlighted.  */
24397       Lisp_Object prev_object;
24398       EMACS_INT pos;
24399 
24400       while (glyph > row->glyphs[TEXT_AREA])
24401         {
24402           prev_object = (glyph - 1)->object;
24403           if (!STRINGP (prev_object) || EQ (prev_object, display_string))
24404             break;
24405 
24406           pos = string_buffer_position (w, prev_object, end_charpos);
24407           if (pos && pos < end_charpos)
24408             break;
24409 
24410           for (; glyph > row->glyphs[TEXT_AREA]
24411                  && EQ ((glyph - 1)->object, prev_object);
24412                --glyph)
24413             x -= (glyph - 1)->pixel_width;
24414         }
24415     }
24416 
24417   dpyinfo->mouse_face_end_x = x;
24418   dpyinfo->mouse_face_end_col = glyph - row->glyphs[TEXT_AREA];
24419   dpyinfo->mouse_face_window = window;
24420   dpyinfo->mouse_face_face_id
24421     = face_at_buffer_position (w, mouse_charpos, 0, 0, &ignore,
24422                                mouse_charpos + 1,
24423                                !dpyinfo->mouse_face_hidden, -1);
24424   show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
24425 }
24426 
24427 
24428 /* Find the position of the glyph for position POS in OBJECT in
24429    window W's current matrix, and return in *X, *Y the pixel
24430    coordinates, and return in *HPOS, *VPOS the column/row of the glyph.
24431 
24432    RIGHT_P non-zero means return the position of the right edge of the
24433    glyph, RIGHT_P zero means return the left edge position.
24434 
24435    If no glyph for POS exists in the matrix, return the position of
24436    the glyph with the next smaller position that is in the matrix, if
24437    RIGHT_P is zero.  If RIGHT_P is non-zero, and no glyph for POS
24438    exists in the matrix, return the position of the glyph with the
24439    next larger position in OBJECT.
24440 
24441    Value is non-zero if a glyph was found.  */
24442 
24443 static int
24444 fast_find_string_pos (w, pos, object, hpos, vpos, x, y, right_p)
24445      struct window *w;
24446      EMACS_INT pos;
24447      Lisp_Object object;
24448      int *hpos, *vpos, *x, *y;
24449      int right_p;
24450 {
24451   int yb = window_text_bottom_y (w);
24452   struct glyph_row *r;
24453   struct glyph *best_glyph = NULL;
24454   struct glyph_row *best_row = NULL;
24455   int best_x = 0;
24456 
24457   for (r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
24458        r->enabled_p && r->y < yb;
24459        ++r)
24460     {
24461       struct glyph *g = r->glyphs[TEXT_AREA];
24462       struct glyph *e = g + r->used[TEXT_AREA];
24463       int gx;
24464 
24465       for (gx = r->x; g < e; gx += g->pixel_width, ++g)
24466         if (EQ (g->object, object))
24467           {
24468             if (g->charpos == pos)
24469               {
24470                 best_glyph = g;
24471                 best_x = gx;
24472                 best_row = r;
24473                 goto found;
24474               }
24475             else if (best_glyph == NULL
24476                      || ((eabs (g->charpos - pos)
24477                          < eabs (best_glyph->charpos - pos))
24478                          && (right_p
24479                              ? g->charpos < pos
24480                              : g->charpos > pos)))
24481               {
24482                 best_glyph = g;
24483                 best_x = gx;
24484                 best_row = r;
24485               }
24486           }
24487     }
24488 
24489  found:
24490 
24491   if (best_glyph)
24492     {
24493       *x = best_x;
24494       *hpos = best_glyph - best_row->glyphs[TEXT_AREA];
24495 
24496       if (right_p)
24497         {
24498           *x += best_glyph->pixel_width;
24499           ++*hpos;
24500         }
24501 
24502       *y = best_row->y;
24503       *vpos = best_row - w->current_matrix->rows;
24504     }
24505 
24506   return best_glyph != NULL;
24507 }
24508 
24509 
24510 /* See if position X, Y is within a hot-spot of an image.  */
24511 
24512 static int
24513 on_hot_spot_p (hot_spot, x, y)
24514      Lisp_Object hot_spot;
24515      int x, y;
24516 {
24517   if (!CONSP (hot_spot))
24518     return 0;
24519 
24520   if (EQ (XCAR (hot_spot), Qrect))
24521     {
24522       /* CDR is (Top-Left . Bottom-Right) = ((x0 . y0) . (x1 . y1))  */
24523       Lisp_Object rect = XCDR (hot_spot);
24524       Lisp_Object tem;
24525       if (!CONSP (rect))
24526         return 0;
24527       if (!CONSP (XCAR (rect)))
24528         return 0;
24529       if (!CONSP (XCDR (rect)))
24530         return 0;
24531       if (!(tem = XCAR (XCAR (rect)), INTEGERP (tem) && x >= XINT (tem)))
24532         return 0;
24533       if (!(tem = XCDR (XCAR (rect)), INTEGERP (tem) && y >= XINT (tem)))
24534         return 0;
24535       if (!(tem = XCAR (XCDR (rect)), INTEGERP (tem) && x <= XINT (tem)))
24536         return 0;
24537       if (!(tem = XCDR (XCDR (rect)), INTEGERP (tem) && y <= XINT (tem)))
24538         return 0;
24539       return 1;
24540     }
24541   else if (EQ (XCAR (hot_spot), Qcircle))
24542     {
24543       /* CDR is (Center . Radius) = ((x0 . y0) . r) */
24544       Lisp_Object circ = XCDR (hot_spot);
24545       Lisp_Object lr, lx0, ly0;
24546       if (CONSP (circ)
24547           && CONSP (XCAR (circ))
24548           && (lr = XCDR (circ), INTEGERP (lr) || FLOATP (lr))
24549           && (lx0 = XCAR (XCAR (circ)), INTEGERP (lx0))
24550           && (ly0 = XCDR (XCAR (circ)), INTEGERP (ly0)))
24551         {
24552           double r = XFLOATINT (lr);
24553           double dx = XINT (lx0) - x;
24554           double dy = XINT (ly0) - y;
24555           return (dx * dx + dy * dy <= r * r);
24556         }
24557     }
24558   else if (EQ (XCAR (hot_spot), Qpoly))
24559     {
24560       /* CDR is [x0 y0 x1 y1 x2 y2 ...x(n-1) y(n-1)] */
24561       if (VECTORP (XCDR (hot_spot)))
24562         {
24563           struct Lisp_Vector *v = XVECTOR (XCDR (hot_spot));
24564           Lisp_Object *poly = v->contents;
24565           int n = v->size;
24566           int i;
24567           int inside = 0;
24568           Lisp_Object lx, ly;
24569           int x0, y0;
24570 
24571           /* Need an even number of coordinates, and at least 3 edges.  */
24572           if (n < 6 || n & 1)
24573             return 0;
24574 
24575           /* Count edge segments intersecting line from (X,Y) to (X,infinity).
24576              If count is odd, we are inside polygon.  Pixels on edges
24577              may or may not be included depending on actual geometry of the
24578              polygon.  */
24579           if ((lx = poly[n-2], !INTEGERP (lx))
24580               || (ly = poly[n-1], !INTEGERP (lx)))
24581             return 0;
24582           x0 = XINT (lx), y0 = XINT (ly);
24583           for (i = 0; i < n; i += 2)
24584             {
24585               int x1 = x0, y1 = y0;
24586               if ((lx = poly[i], !INTEGERP (lx))
24587                   || (ly = poly[i+1], !INTEGERP (ly)))
24588                 return 0;
24589               x0 = XINT (lx), y0 = XINT (ly);
24590 
24591               /* Does this segment cross the X line?  */
24592               if (x0 >= x)
24593                 {
24594                   if (x1 >= x)
24595                     continue;
24596                 }
24597               else if (x1 < x)
24598                 continue;
24599               if (y > y0 && y > y1)
24600                 continue;
24601               if (y < y0 + ((y1 - y0) * (x - x0)) / (x1 - x0))
24602                 inside = !inside;
24603             }
24604           return inside;
24605         }
24606     }
24607   return 0;
24608 }
24609 
24610 Lisp_Object
24611 find_hot_spot (map, x, y)
24612      Lisp_Object map;
24613      int x, y;
24614 {
24615   while (CONSP (map))
24616     {
24617       if (CONSP (XCAR (map))
24618           && on_hot_spot_p (XCAR (XCAR (map)), x, y))
24619         return XCAR (map);
24620       map = XCDR (map);
24621     }
24622 
24623   return Qnil;
24624 }
24625 
24626 DEFUN ("lookup-image-map", Flookup_image_map, Slookup_image_map,
24627        3, 3, 0,
24628        doc: /* Lookup in image map MAP coordinates X and Y.
24629 An image map is an alist where each element has the format (AREA ID PLIST).
24630 An AREA is specified as either a rectangle, a circle, or a polygon:
24631 A rectangle is a cons (rect . ((x0 . y0) . (x1 . y1))) specifying the
24632 pixel coordinates of the upper left and bottom right corners.
24633 A circle is a cons (circle . ((x0 . y0) . r)) specifying the center
24634 and the radius of the circle; r may be a float or integer.
24635 A polygon is a cons (poly . [x0 y0 x1 y1 ...]) where each pair in the
24636 vector describes one corner in the polygon.
24637 Returns the alist element for the first matching AREA in MAP.  */)
24638      (map, x, y)
24639      Lisp_Object map;
24640      Lisp_Object x, y;
24641 {
24642   if (NILP (map))
24643     return Qnil;
24644 
24645   CHECK_NUMBER (x);
24646   CHECK_NUMBER (y);
24647 
24648   return find_hot_spot (map, XINT (x), XINT (y));
24649 }
24650 
24651 
24652 /* Display frame CURSOR, optionally using shape defined by POINTER.  */
24653 static void
24654 define_frame_cursor1 (f, cursor, pointer)
24655      struct frame *f;
24656      Cursor cursor;
24657      Lisp_Object pointer;
24658 {
24659   /* Do not change cursor shape while dragging mouse.  */
24660   if (!NILP (do_mouse_tracking))
24661     return;
24662 
24663   if (!NILP (pointer))
24664     {
24665       if (EQ (pointer, Qarrow))
24666         cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
24667       else if (EQ (pointer, Qhand))
24668         cursor = FRAME_X_OUTPUT (f)->hand_cursor;
24669       else if (EQ (pointer, Qtext))
24670         cursor = FRAME_X_OUTPUT (f)->text_cursor;
24671       else if (EQ (pointer, intern ("hdrag")))
24672         cursor = FRAME_X_OUTPUT (f)->horizontal_drag_cursor;
24673 #ifdef HAVE_X_WINDOWS
24674       else if (EQ (pointer, intern ("vdrag")))
24675         cursor = FRAME_X_DISPLAY_INFO (f)->vertical_scroll_bar_cursor;
24676 #endif
24677       else if (EQ (pointer, intern ("hourglass")))
24678         cursor = FRAME_X_OUTPUT (f)->hourglass_cursor;
24679       else if (EQ (pointer, Qmodeline))
24680         cursor = FRAME_X_OUTPUT (f)->modeline_cursor;
24681       else
24682         cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
24683     }
24684 
24685   if (cursor != No_Cursor)
24686     FRAME_RIF (f)->define_frame_cursor (f, cursor);
24687 }
24688 
24689 /* Take proper action when mouse has moved to the mode or header line
24690    or marginal area AREA of window W, x-position X and y-position Y.
24691    X is relative to the start of the text display area of W, so the
24692    width of bitmap areas and scroll bars must be subtracted to get a
24693    position relative to the start of the mode line.  */
24694 
24695 static void
24696 note_mode_line_or_margin_highlight (window, x, y, area)
24697      Lisp_Object window;
24698      int x, y;
24699      enum window_part area;
24700 {
24701   struct window *w = XWINDOW (window);
24702   struct frame *f = XFRAME (w->frame);
24703   Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
24704   Cursor cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
24705   Lisp_Object pointer = Qnil;
24706   int charpos, dx, dy, width, height;
24707   Lisp_Object string, object = Qnil;
24708   Lisp_Object pos, help;
24709 
24710   Lisp_Object mouse_face;
24711   int original_x_pixel = x;
24712   struct glyph * glyph = NULL, * row_start_glyph = NULL;
24713   struct glyph_row *row;
24714 
24715   if (area == ON_MODE_LINE || area == ON_HEADER_LINE)
24716     {
24717       int x0;
24718       struct glyph *end;
24719 
24720       string = mode_line_string (w, area, &x, &y, &charpos,
24721                                  &object, &dx, &dy, &width, &height);
24722 
24723       row = (area == ON_MODE_LINE
24724              ? MATRIX_MODE_LINE_ROW (w->current_matrix)
24725              : MATRIX_HEADER_LINE_ROW (w->current_matrix));
24726 
24727       /* Find glyph */
24728       if (row->mode_line_p && row->enabled_p)
24729         {
24730           glyph = row_start_glyph = row->glyphs[TEXT_AREA];
24731           end = glyph + row->used[TEXT_AREA];
24732 
24733           for (x0 = original_x_pixel;
24734                glyph < end && x0 >= glyph->pixel_width;
24735                ++glyph)
24736             x0 -= glyph->pixel_width;
24737 
24738           if (glyph >= end)
24739             glyph = NULL;
24740         }
24741     }
24742   else
24743     {
24744       x -= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w);
24745       string = marginal_area_string (w, area, &x, &y, &charpos,
24746                                      &object, &dx, &dy, &width, &height);
24747     }
24748 
24749   help = Qnil;
24750 
24751   if (IMAGEP (object))
24752     {
24753       Lisp_Object image_map, hotspot;
24754       if ((image_map = Fplist_get (XCDR (object), QCmap),
24755            !NILP (image_map))
24756           && (hotspot = find_hot_spot (image_map, dx, dy),
24757               CONSP (hotspot))
24758           && (hotspot = XCDR (hotspot), CONSP (hotspot)))
24759         {
24760           Lisp_Object area_id, plist;
24761 
24762           area_id = XCAR (hotspot);
24763           /* Could check AREA_ID to see if we enter/leave this hot-spot.
24764              If so, we could look for mouse-enter, mouse-leave
24765              properties in PLIST (and do something...).  */
24766           hotspot = XCDR (hotspot);
24767           if (CONSP (hotspot)
24768               && (plist = XCAR (hotspot), CONSP (plist)))
24769             {
24770               pointer = Fplist_get (plist, Qpointer);
24771               if (NILP (pointer))
24772                 pointer = Qhand;
24773               help = Fplist_get (plist, Qhelp_echo);
24774               if (!NILP (help))
24775                 {
24776                   help_echo_string = help;
24777                   /* Is this correct?  ++kfs */
24778                   XSETWINDOW (help_echo_window, w);
24779                   help_echo_object = w->buffer;
24780                   help_echo_pos = charpos;
24781                 }
24782             }
24783         }
24784       if (NILP (pointer))
24785         pointer = Fplist_get (XCDR (object), QCpointer);
24786     }
24787 
24788   if (STRINGP (string))
24789     {
24790       pos = make_number (charpos);
24791       /* If we're on a string with `help-echo' text property, arrange
24792          for the help to be displayed.  This is done by setting the
24793          global variable help_echo_string to the help string.  */
24794       if (NILP (help))
24795         {
24796           help = Fget_text_property (pos, Qhelp_echo, string);
24797           if (!NILP (help))
24798             {
24799               help_echo_string = help;
24800               XSETWINDOW (help_echo_window, w);
24801               help_echo_object = string;
24802               help_echo_pos = charpos;
24803             }
24804         }
24805 
24806       if (NILP (pointer))
24807         pointer = Fget_text_property (pos, Qpointer, string);
24808 
24809      /* Change the mouse pointer according to what is under X/Y.  */
24810       if (NILP (pointer) && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE)))
24811         {
24812           Lisp_Object map;
24813           map = Fget_text_property (pos, Qlocal_map, string);
24814           if (!KEYMAPP (map))
24815             map = Fget_text_property (pos, Qkeymap, string);
24816           if (!KEYMAPP (map))
24817             cursor = dpyinfo->vertical_scroll_bar_cursor;
24818         }
24819 
24820      /* Change the mouse face according to what is under X/Y.  */
24821       mouse_face = Fget_text_property (pos, Qmouse_face, string);
24822       if (!NILP (mouse_face)
24823           && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE))
24824           && glyph)
24825         {
24826           Lisp_Object b, e;
24827 
24828           struct glyph * tmp_glyph;
24829 
24830           int gpos;
24831           int gseq_length;
24832           int total_pixel_width;
24833           EMACS_INT ignore;
24834 
24835           int vpos, hpos;
24836 
24837           b = Fprevious_single_property_change (make_number (charpos + 1),
24838                                                 Qmouse_face, string, Qnil);
24839           if (NILP (b))
24840             b = make_number (0);
24841 
24842           e = Fnext_single_property_change (pos, Qmouse_face, string, Qnil);
24843           if (NILP (e))
24844             e = make_number (SCHARS (string));
24845 
24846           /* Calculate the position(glyph position: GPOS) of GLYPH in
24847              displayed string. GPOS is different from CHARPOS.
24848 
24849              CHARPOS is the position of glyph in internal string
24850              object. A mode line string format has structures which
24851              is converted to a flatten by emacs lisp interpreter.
24852              The internal string is an element of the structures.
24853              The displayed string is the flatten string. */
24854           gpos = 0;
24855           if (glyph > row_start_glyph)
24856             {
24857               tmp_glyph = glyph - 1;
24858               while (tmp_glyph >= row_start_glyph
24859                      && tmp_glyph->charpos >= XINT (b)
24860                      && EQ (tmp_glyph->object, glyph->object))
24861                 {
24862                   tmp_glyph--;
24863                   gpos++;
24864                 }
24865             }
24866 
24867           /* Calculate the lenght(glyph sequence length: GSEQ_LENGTH) of
24868              displayed string holding GLYPH.
24869 
24870              GSEQ_LENGTH is different from SCHARS (STRING).
24871              SCHARS (STRING) returns the length of the internal string. */
24872           for (tmp_glyph = glyph, gseq_length = gpos;
24873                tmp_glyph->charpos < XINT (e);
24874                tmp_glyph++, gseq_length++)
24875               {
24876                 if (!EQ (tmp_glyph->object, glyph->object))
24877                   break;
24878               }
24879 
24880           total_pixel_width = 0;
24881           for (tmp_glyph = glyph - gpos; tmp_glyph != glyph; tmp_glyph++)
24882             total_pixel_width += tmp_glyph->pixel_width;
24883 
24884           /* Pre calculation of re-rendering position */
24885           vpos = (x - gpos);
24886           hpos = (area == ON_MODE_LINE
24887                   ? (w->current_matrix)->nrows - 1
24888                   : 0);
24889 
24890           /* If the re-rendering position is included in the last
24891              re-rendering area, we should do nothing. */
24892           if ( EQ (window, dpyinfo->mouse_face_window)
24893                && dpyinfo->mouse_face_beg_col <= vpos
24894                && vpos < dpyinfo->mouse_face_end_col
24895                && dpyinfo->mouse_face_beg_row == hpos )
24896             return;
24897 
24898           if (clear_mouse_face (dpyinfo))
24899             cursor = No_Cursor;
24900 
24901           dpyinfo->mouse_face_beg_col = vpos;
24902           dpyinfo->mouse_face_beg_row = hpos;
24903 
24904           dpyinfo->mouse_face_beg_x   = original_x_pixel - (total_pixel_width + dx);
24905           dpyinfo->mouse_face_beg_y   = 0;
24906 
24907           dpyinfo->mouse_face_end_col = vpos + gseq_length;
24908           dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_beg_row;
24909 
24910           dpyinfo->mouse_face_end_x   = 0;
24911           dpyinfo->mouse_face_end_y   = 0;
24912 
24913           dpyinfo->mouse_face_past_end = 0;
24914           dpyinfo->mouse_face_window  = window;
24915 
24916           dpyinfo->mouse_face_face_id = face_at_string_position (w, string,
24917                                                                  charpos,
24918                                                                  0, 0, 0, &ignore,
24919                                                                  glyph->face_id, 1);
24920           show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
24921 
24922           if (NILP (pointer))
24923             pointer = Qhand;
24924         }
24925       else if ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE))
24926         clear_mouse_face (dpyinfo);
24927     }
24928   define_frame_cursor1 (f, cursor, pointer);
24929 }
24930 
24931 
24932 /* EXPORT:
24933    Take proper action when the mouse has moved to position X, Y on
24934    frame F as regards highlighting characters that have mouse-face
24935    properties.  Also de-highlighting chars where the mouse was before.
24936    X and Y can be negative or out of range.  */
24937 
24938 void
24939 note_mouse_highlight (f, x, y)
24940      struct frame *f;
24941      int x, y;
24942 {
24943   Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
24944   enum window_part part;
24945   Lisp_Object window;
24946   struct window *w;
24947   Cursor cursor = No_Cursor;
24948   Lisp_Object pointer = Qnil;  /* Takes precedence over cursor!  */
24949   struct buffer *b;
24950 
24951   /* When a menu is active, don't highlight because this looks odd.  */
24952 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS)
24953   if (popup_activated ())
24954     return;
24955 #endif
24956 
24957   if (NILP (Vmouse_highlight)
24958       || !f->glyphs_initialized_p
24959       || f->pointer_invisible)
24960     return;
24961 
24962   dpyinfo->mouse_face_mouse_x = x;
24963   dpyinfo->mouse_face_mouse_y = y;
24964   dpyinfo->mouse_face_mouse_frame = f;
24965 
24966   if (dpyinfo->mouse_face_defer)
24967     return;
24968 
24969   if (gc_in_progress)
24970     {
24971       dpyinfo->mouse_face_deferred_gc = 1;
24972       return;
24973     }
24974 
24975   /* Which window is that in?  */
24976   window = window_from_coordinates (f, x, y, &part, 0, 0, 1);
24977 
24978   /* If we were displaying active text in another window, clear that.
24979      Also clear if we move out of text area in same window.  */
24980   if (! EQ (window, dpyinfo->mouse_face_window)
24981       || (part != ON_TEXT && part != ON_MODE_LINE && part != ON_HEADER_LINE
24982           && !NILP (dpyinfo->mouse_face_window)))
24983     clear_mouse_face (dpyinfo);
24984 
24985   /* Not on a window -> return.  */
24986   if (!WINDOWP (window))
24987     return;
24988 
24989   /* Reset help_echo_string. It will get recomputed below.  */
24990   help_echo_string = Qnil;
24991 
24992   /* Convert to window-relative pixel coordinates.  */
24993   w = XWINDOW (window);
24994   frame_to_window_pixel_xy (w, &x, &y);
24995 
24996   /* Handle tool-bar window differently since it doesn't display a
24997      buffer.  */
24998   if (EQ (window, f->tool_bar_window))
24999     {
25000       note_tool_bar_highlight (f, x, y);
25001       return;
25002     }
25003 
25004   /* Mouse is on the mode, header line or margin?  */
25005   if (part == ON_MODE_LINE || part == ON_HEADER_LINE
25006       || part == ON_LEFT_MARGIN || part == ON_RIGHT_MARGIN)
25007     {
25008       note_mode_line_or_margin_highlight (window, x, y, part);
25009       return;
25010     }
25011 
25012   if (part == ON_VERTICAL_BORDER)
25013     {
25014       cursor = FRAME_X_OUTPUT (f)->horizontal_drag_cursor;
25015       help_echo_string = build_string ("drag-mouse-1: resize");
25016     }
25017   else if (part == ON_LEFT_FRINGE || part == ON_RIGHT_FRINGE
25018            || part == ON_SCROLL_BAR)
25019     cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
25020   else
25021     cursor = FRAME_X_OUTPUT (f)->text_cursor;
25022 
25023   /* Are we in a window whose display is up to date?
25024      And verify the buffer's text has not changed.  */
25025   b = XBUFFER (w->buffer);
25026   if (part == ON_TEXT
25027       && EQ (w->window_end_valid, w->buffer)
25028       && XFASTINT (w->last_modified) == BUF_MODIFF (b)
25029       && XFASTINT (w->last_overlay_modified) == BUF_OVERLAY_MODIFF (b))
25030     {
25031       int hpos, vpos, i, dx, dy, area;
25032       EMACS_INT pos;
25033       struct glyph *glyph;
25034       Lisp_Object object;
25035       Lisp_Object mouse_face = Qnil, overlay = Qnil, position;
25036       Lisp_Object *overlay_vec = NULL;
25037       int noverlays;
25038       struct buffer *obuf;
25039       int obegv, ozv, same_region;
25040 
25041       /* Find the glyph under X/Y.  */
25042       glyph = x_y_to_hpos_vpos (w, x, y, &hpos, &vpos, &dx, &dy, &area);
25043 
25044       /* Look for :pointer property on image.  */
25045       if (glyph != NULL && glyph->type == IMAGE_GLYPH)
25046         {
25047           struct image *img = IMAGE_FROM_ID (f, glyph->u.img_id);
25048           if (img != NULL && IMAGEP (img->spec))
25049             {
25050               Lisp_Object image_map, hotspot;
25051               if ((image_map = Fplist_get (XCDR (img->spec), QCmap),
25052                    !NILP (image_map))
25053                   && (hotspot = find_hot_spot (image_map,
25054                                                glyph->slice.x + dx,
25055                                                glyph->slice.y + dy),
25056                       CONSP (hotspot))
25057                   && (hotspot = XCDR (hotspot), CONSP (hotspot)))
25058                 {
25059                   Lisp_Object area_id, plist;
25060 
25061                   area_id = XCAR (hotspot);
25062                   /* Could check AREA_ID to see if we enter/leave this hot-spot.
25063                      If so, we could look for mouse-enter, mouse-leave
25064                      properties in PLIST (and do something...).  */
25065                   hotspot = XCDR (hotspot);
25066                   if (CONSP (hotspot)
25067                       && (plist = XCAR (hotspot), CONSP (plist)))
25068                     {
25069                       pointer = Fplist_get (plist, Qpointer);
25070                       if (NILP (pointer))
25071                         pointer = Qhand;
25072                       help_echo_string = Fplist_get (plist, Qhelp_echo);
25073                       if (!NILP (help_echo_string))
25074                         {
25075                           help_echo_window = window;
25076                           help_echo_object = glyph->object;
25077                           help_echo_pos = glyph->charpos;
25078                         }
25079                     }
25080                 }
25081               if (NILP (pointer))
25082                 pointer = Fplist_get (XCDR (img->spec), QCpointer);
25083             }
25084         }
25085 
25086       /* Clear mouse face if X/Y not over text.  */
25087       if (glyph == NULL
25088           || area != TEXT_AREA
25089           || !MATRIX_ROW (w->current_matrix, vpos)->displays_text_p)
25090         {
25091           if (clear_mouse_face (dpyinfo))
25092             cursor = No_Cursor;
25093           if (NILP (pointer))
25094             {
25095               if (area != TEXT_AREA)
25096                 cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
25097               else
25098                 pointer = Vvoid_text_area_pointer;
25099             }
25100           goto set_cursor;
25101         }
25102 
25103       pos = glyph->charpos;
25104       object = glyph->object;
25105       if (!STRINGP (object) && !BUFFERP (object))
25106         goto set_cursor;
25107 
25108       /* If we get an out-of-range value, return now; avoid an error.  */
25109       if (BUFFERP (object) && pos > BUF_Z (b))
25110         goto set_cursor;
25111 
25112       /* Make the window's buffer temporarily current for
25113          overlays_at and compute_char_face.  */
25114       obuf = current_buffer;
25115       current_buffer = b;
25116       obegv = BEGV;
25117       ozv = ZV;
25118       BEGV = BEG;
25119       ZV = Z;
25120 
25121       /* Is this char mouse-active or does it have help-echo?  */
25122       position = make_number (pos);
25123 
25124       if (BUFFERP (object))
25125         {
25126           /* Put all the overlays we want in a vector in overlay_vec.  */
25127           GET_OVERLAYS_AT (pos, overlay_vec, noverlays, NULL, 0);
25128           /* Sort overlays into increasing priority order.  */
25129           noverlays = sort_overlays (overlay_vec, noverlays, w);
25130         }
25131       else
25132         noverlays = 0;
25133 
25134       same_region = (EQ (window, dpyinfo->mouse_face_window)
25135                      && vpos >= dpyinfo->mouse_face_beg_row
25136                      && vpos <= dpyinfo->mouse_face_end_row
25137                      && (vpos > dpyinfo->mouse_face_beg_row
25138                          || hpos >= dpyinfo->mouse_face_beg_col)
25139                      && (vpos < dpyinfo->mouse_face_end_row
25140                          || hpos < dpyinfo->mouse_face_end_col
25141                          || dpyinfo->mouse_face_past_end));
25142 
25143       if (same_region)
25144         cursor = No_Cursor;
25145 
25146       /* Check mouse-face highlighting.  */
25147       if (! same_region
25148           /* If there exists an overlay with mouse-face overlapping
25149              the one we are currently highlighting, we have to
25150              check if we enter the overlapping overlay, and then
25151              highlight only that.  */
25152           || (OVERLAYP (dpyinfo->mouse_face_overlay)
25153               && mouse_face_overlay_overlaps (dpyinfo->mouse_face_overlay)))
25154         {
25155           /* Find the highest priority overlay with a mouse-face.  */
25156           overlay = Qnil;
25157           for (i = noverlays - 1; i >= 0 && NILP (overlay); --i)
25158             {
25159               mouse_face = Foverlay_get (overlay_vec[i], Qmouse_face);
25160               if (!NILP (mouse_face))
25161                 overlay = overlay_vec[i];
25162             }
25163 
25164           /* If we're highlighting the same overlay as before, there's
25165              no need to do that again.  */
25166           if (!NILP (overlay) && EQ (overlay, dpyinfo->mouse_face_overlay))
25167             goto check_help_echo;
25168           dpyinfo->mouse_face_overlay = overlay;
25169 
25170           /* Clear the display of the old active region, if any.  */
25171           if (clear_mouse_face (dpyinfo))
25172             cursor = No_Cursor;
25173 
25174           /* If no overlay applies, get a text property.  */
25175           if (NILP (overlay))
25176             mouse_face = Fget_text_property (position, Qmouse_face, object);
25177 
25178           /* Next, compute the bounds of the mouse highlighting and
25179              display it.  */
25180           if (!NILP (mouse_face) && STRINGP (object))
25181             {
25182               /* The mouse-highlighting comes from a display string
25183                  with a mouse-face.  */
25184               Lisp_Object b, e;
25185               EMACS_INT ignore;
25186 
25187               b = Fprevious_single_property_change
25188                 (make_number (pos + 1), Qmouse_face, object, Qnil);
25189               e = Fnext_single_property_change
25190                 (position, Qmouse_face, object, Qnil);
25191               if (NILP (b))
25192                 b = make_number (0);
25193               if (NILP (e))
25194                 e = make_number (SCHARS (object) - 1);
25195 
25196               fast_find_string_pos (w, XINT (b), object,
25197                                     &dpyinfo->mouse_face_beg_col,
25198                                     &dpyinfo->mouse_face_beg_row,
25199                                     &dpyinfo->mouse_face_beg_x,
25200                                     &dpyinfo->mouse_face_beg_y, 0);
25201               fast_find_string_pos (w, XINT (e), object,
25202                                     &dpyinfo->mouse_face_end_col,
25203                                     &dpyinfo->mouse_face_end_row,
25204                                     &dpyinfo->mouse_face_end_x,
25205                                     &dpyinfo->mouse_face_end_y, 1);
25206               dpyinfo->mouse_face_past_end = 0;
25207               dpyinfo->mouse_face_window = window;
25208               dpyinfo->mouse_face_face_id
25209                 = face_at_string_position (w, object, pos, 0, 0, 0, &ignore,
25210                                            glyph->face_id, 1);
25211               show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
25212               cursor = No_Cursor;
25213             }
25214           else
25215             {
25216               /* The mouse-highlighting, if any, comes from an overlay
25217                  or text property in the buffer.  */
25218               Lisp_Object buffer, display_string;
25219 
25220               if (STRINGP (object))
25221                 {
25222                   /* If we are on a display string with no mouse-face,
25223                      check if the text under it has one.  */
25224                   struct glyph_row *r = MATRIX_ROW (w->current_matrix, vpos);
25225                   int start = MATRIX_ROW_START_CHARPOS (r);
25226                   pos = string_buffer_position (w, object, start);
25227                   if (pos > 0)
25228                     {
25229                       mouse_face = get_char_property_and_overlay
25230                         (make_number (pos), Qmouse_face, w->buffer, &overlay);
25231                       buffer = w->buffer;
25232                       display_string = object;
25233                     }
25234                 }
25235               else
25236                 {
25237                   buffer = object;
25238                   display_string = Qnil;
25239                 }
25240 
25241               if (!NILP (mouse_face))
25242                 {
25243                   Lisp_Object before, after;
25244                   Lisp_Object before_string, after_string;
25245 
25246                   if (NILP (overlay))
25247                     {
25248                       /* Handle the text property case.  */
25249                       before = Fprevious_single_property_change
25250                         (make_number (pos + 1), Qmouse_face, buffer,
25251                          Fmarker_position (w->start));
25252                       after = Fnext_single_property_change
25253                         (make_number (pos), Qmouse_face, buffer,
25254                          make_number (BUF_Z (XBUFFER (buffer))
25255                                       - XFASTINT (w->window_end_pos)));
25256                       before_string = after_string = Qnil;
25257                     }
25258                   else
25259                     {
25260                       /* Handle the overlay case.  */
25261                       before = Foverlay_start (overlay);
25262                       after = Foverlay_end (overlay);
25263                       before_string = Foverlay_get (overlay, Qbefore_string);
25264                       after_string = Foverlay_get (overlay, Qafter_string);
25265 
25266                       if (!STRINGP (before_string)) before_string = Qnil;
25267                       if (!STRINGP (after_string))  after_string = Qnil;
25268                     }
25269 
25270                   mouse_face_from_buffer_pos (window, dpyinfo, pos,
25271                                               XFASTINT (before),
25272                                               XFASTINT (after),
25273                                               before_string, after_string,
25274                                               display_string);
25275                   cursor = No_Cursor;
25276                 }
25277             }
25278         }
25279 
25280     check_help_echo:
25281 
25282       /* Look for a `help-echo' property.  */
25283       if (NILP (help_echo_string)) {
25284         Lisp_Object help, overlay;
25285 
25286         /* Check overlays first.  */
25287         help = overlay = Qnil;
25288         for (i = noverlays - 1; i >= 0 && NILP (help); --i)
25289           {
25290             overlay = overlay_vec[i];
25291             help = Foverlay_get (overlay, Qhelp_echo);
25292           }
25293 
25294         if (!NILP (help))
25295           {
25296             help_echo_string = help;
25297             help_echo_window = window;
25298             help_echo_object = overlay;
25299             help_echo_pos = pos;
25300           }
25301         else
25302           {
25303             Lisp_Object object = glyph->object;
25304             int charpos = glyph->charpos;
25305 
25306             /* Try text properties.  */
25307             if (STRINGP (object)
25308                 && charpos >= 0
25309                 && charpos < SCHARS (object))
25310               {
25311                 help = Fget_text_property (make_number (charpos),
25312                                            Qhelp_echo, object);
25313                 if (NILP (help))
25314                   {
25315                     /* If the string itself doesn't specify a help-echo,
25316                        see if the buffer text ``under'' it does.  */
25317                     struct glyph_row *r
25318                       = MATRIX_ROW (w->current_matrix, vpos);
25319                     int start = MATRIX_ROW_START_CHARPOS (r);
25320                     EMACS_INT pos = string_buffer_position (w, object, start);
25321                     if (pos > 0)
25322                       {
25323                         help = Fget_char_property (make_number (pos),
25324                                                    Qhelp_echo, w->buffer);
25325                         if (!NILP (help))
25326                           {
25327                             charpos = pos;
25328                             object = w->buffer;
25329                           }
25330                       }
25331                   }
25332               }
25333             else if (BUFFERP (object)
25334                      && charpos >= BEGV
25335                      && charpos < ZV)
25336               help = Fget_text_property (make_number (charpos), Qhelp_echo,
25337                                          object);
25338 
25339             if (!NILP (help))
25340               {
25341                 help_echo_string = help;
25342                 help_echo_window = window;
25343                 help_echo_object = object;
25344                 help_echo_pos = charpos;
25345               }
25346           }
25347       }
25348 
25349       /* Look for a `pointer' property.  */
25350       if (NILP (pointer))
25351         {
25352           /* Check overlays first.  */
25353           for (i = noverlays - 1; i >= 0 && NILP (pointer); --i)
25354             pointer = Foverlay_get (overlay_vec[i], Qpointer);
25355 
25356           if (NILP (pointer))
25357             {
25358               Lisp_Object object = glyph->object;
25359               int charpos = glyph->charpos;
25360 
25361               /* Try text properties.  */
25362               if (STRINGP (object)
25363                   && charpos >= 0
25364                   && charpos < SCHARS (object))
25365                 {
25366                   pointer = Fget_text_property (make_number (charpos),
25367                                                 Qpointer, object);
25368                   if (NILP (pointer))
25369                     {
25370                       /* If the string itself doesn't specify a pointer,
25371                          see if the buffer text ``under'' it does.  */
25372                       struct glyph_row *r
25373                         = MATRIX_ROW (w->current_matrix, vpos);
25374                       int start = MATRIX_ROW_START_CHARPOS (r);
25375                       EMACS_INT pos = string_buffer_position (w, object,
25376                                                               start);
25377                       if (pos > 0)
25378                         pointer = Fget_char_property (make_number (pos),
25379                                                       Qpointer, w->buffer);
25380                     }
25381                 }
25382               else if (BUFFERP (object)
25383                        && charpos >= BEGV
25384                        && charpos < ZV)
25385                 pointer = Fget_text_property (make_number (charpos),
25386                                               Qpointer, object);
25387             }
25388         }
25389 
25390       BEGV = obegv;
25391       ZV = ozv;
25392       current_buffer = obuf;
25393     }
25394 
25395  set_cursor:
25396 
25397   define_frame_cursor1 (f, cursor, pointer);
25398 }
25399 
25400 
25401 /* EXPORT for RIF:
25402    Clear any mouse-face on window W.  This function is part of the
25403    redisplay interface, and is called from try_window_id and similar
25404    functions to ensure the mouse-highlight is off.  */
25405 
25406 void
25407 x_clear_window_mouse_face (w)
25408      struct window *w;
25409 {
25410   Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
25411   Lisp_Object window;
25412 
25413   BLOCK_INPUT;
25414   XSETWINDOW (window, w);
25415   if (EQ (window, dpyinfo->mouse_face_window))
25416     clear_mouse_face (dpyinfo);
25417   UNBLOCK_INPUT;
25418 }
25419 
25420 
25421 /* EXPORT:
25422    Just discard the mouse face information for frame F, if any.
25423    This is used when the size of F is changed.  */
25424 
25425 void
25426 cancel_mouse_face (f)
25427      struct frame *f;
25428 {
25429   Lisp_Object window;
25430   Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
25431 
25432   window = dpyinfo->mouse_face_window;
25433   if (! NILP (window) && XFRAME (XWINDOW (window)->frame) == f)
25434     {
25435       dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
25436       dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
25437       dpyinfo->mouse_face_window = Qnil;
25438     }
25439 }
25440 
25441 
25442 #endif /* HAVE_WINDOW_SYSTEM */
25443 
25444 
25445 /***********************************************************************
25446                            Exposure Events
25447  ***********************************************************************/
25448 
25449 #ifdef HAVE_WINDOW_SYSTEM
25450 
25451 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
25452    which intersects rectangle R.  R is in window-relative coordinates.  */
25453 
25454 static void
25455 expose_area (w, row, r, area)
25456      struct window *w;
25457      struct glyph_row *row;
25458      XRectangle *r;
25459      enum glyph_row_area area;
25460 {
25461   struct glyph *first = row->glyphs[area];
25462   struct glyph *end = row->glyphs[area] + row->used[area];
25463   struct glyph *last;
25464   int first_x, start_x, x;
25465 
25466   if (area == TEXT_AREA && row->fill_line_p)
25467     /* If row extends face to end of line write the whole line.  */
25468     draw_glyphs (w, 0, row, area,
25469                  0, row->used[area],
25470                  DRAW_NORMAL_TEXT, 0);
25471   else
25472     {
25473       /* Set START_X to the window-relative start position for drawing glyphs of
25474          AREA.  The first glyph of the text area can be partially visible.
25475          The first glyphs of other areas cannot.  */
25476       start_x = window_box_left_offset (w, area);
25477       x = start_x;
25478       if (area == TEXT_AREA)
25479         x += row->x;
25480 
25481       /* Find the first glyph that must be redrawn.  */
25482       while (first < end
25483              && x + first->pixel_width < r->x)
25484         {
25485           x += first->pixel_width;
25486           ++first;
25487         }
25488 
25489       /* Find the last one.  */
25490       last = first;
25491       first_x = x;
25492       while (last < end
25493              && x < r->x + r->width)
25494         {
25495           x += last->pixel_width;
25496           ++last;
25497         }
25498 
25499       /* Repaint.  */
25500       if (last > first)
25501         draw_glyphs (w, first_x - start_x, row, area,
25502                      first - row->glyphs[area], last - row->glyphs[area],
25503                      DRAW_NORMAL_TEXT, 0);
25504     }
25505 }
25506 
25507 
25508 /* Redraw the parts of the glyph row ROW on window W intersecting
25509    rectangle R.  R is in window-relative coordinates.  Value is
25510    non-zero if mouse-face was overwritten.  */
25511 
25512 static int
25513 expose_line (w, row, r)
25514      struct window *w;
25515      struct glyph_row *row;
25516      XRectangle *r;
25517 {
25518   xassert (row->enabled_p);
25519 
25520   if (row->mode_line_p || w->pseudo_window_p)
25521     draw_glyphs (w, 0, row, TEXT_AREA,
25522                  0, row->used[TEXT_AREA],
25523                  DRAW_NORMAL_TEXT, 0);
25524   else
25525     {
25526       if (row->used[LEFT_MARGIN_AREA])
25527         expose_area (w, row, r, LEFT_MARGIN_AREA);
25528       if (row->used[TEXT_AREA])
25529         expose_area (w, row, r, TEXT_AREA);
25530       if (row->used[RIGHT_MARGIN_AREA])
25531         expose_area (w, row, r, RIGHT_MARGIN_AREA);
25532       draw_row_fringe_bitmaps (w, row);
25533     }
25534 
25535   return row->mouse_face_p;
25536 }
25537 
25538 
25539 /* Redraw those parts of glyphs rows during expose event handling that
25540    overlap other rows.  Redrawing of an exposed line writes over parts
25541    of lines overlapping that exposed line; this function fixes that.
25542 
25543    W is the window being exposed.  FIRST_OVERLAPPING_ROW is the first
25544    row in W's current matrix that is exposed and overlaps other rows.
25545    LAST_OVERLAPPING_ROW is the last such row.  */
25546 
25547 static void
25548 expose_overlaps (w, first_overlapping_row, last_overlapping_row, r)
25549      struct window *w;
25550      struct glyph_row *first_overlapping_row;
25551      struct glyph_row *last_overlapping_row;
25552      XRectangle *r;
25553 {
25554   struct glyph_row *row;
25555 
25556   for (row = first_overlapping_row; row <= last_overlapping_row; ++row)
25557     if (row->overlapping_p)
25558       {
25559         xassert (row->enabled_p && !row->mode_line_p);
25560 
25561         row->clip = r;
25562         if (row->used[LEFT_MARGIN_AREA])
25563           x_fix_overlapping_area (w, row, LEFT_MARGIN_AREA, OVERLAPS_BOTH);
25564 
25565         if (row->used[TEXT_AREA])
25566           x_fix_overlapping_area (w, row, TEXT_AREA, OVERLAPS_BOTH);
25567 
25568         if (row->used[RIGHT_MARGIN_AREA])
25569           x_fix_overlapping_area (w, row, RIGHT_MARGIN_AREA, OVERLAPS_BOTH);
25570         row->clip = NULL;
25571       }
25572 }
25573 
25574 
25575 /* Return non-zero if W's cursor intersects rectangle R.  */
25576 
25577 static int
25578 phys_cursor_in_rect_p (w, r)
25579      struct window *w;
25580      XRectangle *r;
25581 {
25582   XRectangle cr, result;
25583   struct glyph *cursor_glyph;
25584   struct glyph_row *row;
25585 
25586   if (w->phys_cursor.vpos >= 0
25587       && w->phys_cursor.vpos < w->current_matrix->nrows
25588       && (row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos),
25589           row->enabled_p)
25590       && row->cursor_in_fringe_p)
25591     {
25592       /* Cursor is in the fringe.  */
25593       cr.x = window_box_right_offset (w,
25594                                       (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
25595                                        ? RIGHT_MARGIN_AREA
25596                                        : TEXT_AREA));
25597       cr.y = row->y;
25598       cr.width = WINDOW_RIGHT_FRINGE_WIDTH (w);
25599       cr.height = row->height;
25600       return x_intersect_rectangles (&cr, r, &result);
25601     }
25602 
25603   cursor_glyph = get_phys_cursor_glyph (w);
25604   if (cursor_glyph)
25605     {
25606       /* r is relative to W's box, but w->phys_cursor.x is relative
25607          to left edge of W's TEXT area.  Adjust it.  */
25608       cr.x = window_box_left_offset (w, TEXT_AREA) + w->phys_cursor.x;
25609       cr.y = w->phys_cursor.y;
25610       cr.width = cursor_glyph->pixel_width;
25611       cr.height = w->phys_cursor_height;
25612       /* ++KFS: W32 version used W32-specific IntersectRect here, but
25613          I assume the effect is the same -- and this is portable.  */
25614       return x_intersect_rectangles (&cr, r, &result);
25615     }
25616   /* If we don't understand the format, pretend we're not in the hot-spot.  */
25617   return 0;
25618 }
25619 
25620 
25621 /* EXPORT:
25622    Draw a vertical window border to the right of window W if W doesn't
25623    have vertical scroll bars.  */
25624 
25625 void
25626 x_draw_vertical_border (w)
25627      struct window *w;
25628 {
25629   struct frame *f = XFRAME (WINDOW_FRAME (w));
25630 
25631   /* We could do better, if we knew what type of scroll-bar the adjacent
25632      windows (on either side) have...  But we don't :-(
25633      However, I think this works ok.  ++KFS 2003-04-25 */
25634 
25635   /* Redraw borders between horizontally adjacent windows.  Don't
25636      do it for frames with vertical scroll bars because either the
25637      right scroll bar of a window, or the left scroll bar of its
25638      neighbor will suffice as a border.  */
25639   if (FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (w->frame)))
25640     return;
25641 
25642   if (!WINDOW_RIGHTMOST_P (w)
25643       && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
25644     {
25645       int x0, x1, y0, y1;
25646 
25647       window_box_edges (w, -1, &x0, &y0, &x1, &y1);
25648       y1 -= 1;
25649 
25650       if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
25651         x1 -= 1;
25652 
25653       FRAME_RIF (f)->draw_vertical_window_border (w, x1, y0, y1);
25654     }
25655   else if (!WINDOW_LEFTMOST_P (w)
25656            && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
25657     {
25658       int x0, x1, y0, y1;
25659 
25660       window_box_edges (w, -1, &x0, &y0, &x1, &y1);
25661       y1 -= 1;
25662 
25663       if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
25664         x0 -= 1;
25665 
25666       FRAME_RIF (f)->draw_vertical_window_border (w, x0, y0, y1);
25667     }
25668 }
25669 
25670 
25671 /* Redraw the part of window W intersection rectangle FR.  Pixel
25672    coordinates in FR are frame-relative.  Call this function with
25673    input blocked.  Value is non-zero if the exposure overwrites
25674    mouse-face.  */
25675 
25676 static int
25677 expose_window (w, fr)
25678      struct window *w;
25679      XRectangle *fr;
25680 {
25681   struct frame *f = XFRAME (w->frame);
25682   XRectangle wr, r;
25683   int mouse_face_overwritten_p = 0;
25684 
25685   /* If window is not yet fully initialized, do nothing.  This can
25686      happen when toolkit scroll bars are used and a window is split.
25687      Reconfiguring the scroll bar will generate an expose for a newly
25688      created window.  */
25689   if (w->current_matrix == NULL)
25690     return 0;
25691 
25692   /* When we're currently updating the window, display and current
25693      matrix usually don't agree.  Arrange for a thorough display
25694      later.  */
25695   if (w == updated_window)
25696     {
25697       SET_FRAME_GARBAGED (f);
25698       return 0;
25699     }
25700 
25701   /* Frame-relative pixel rectangle of W.  */
25702   wr.x = WINDOW_LEFT_EDGE_X (w);
25703   wr.y = WINDOW_TOP_EDGE_Y (w);
25704   wr.width = WINDOW_TOTAL_WIDTH (w);
25705   wr.height = WINDOW_TOTAL_HEIGHT (w);
25706 
25707   if (x_intersect_rectangles (fr, &wr, &r))
25708     {
25709       int yb = window_text_bottom_y (w);
25710       struct glyph_row *row;
25711       int cursor_cleared_p;
25712       struct glyph_row *first_overlapping_row, *last_overlapping_row;
25713 
25714       TRACE ((stderr, "expose_window (%d, %d, %d, %d)\n",
25715               r.x, r.y, r.width, r.height));
25716 
25717       /* Convert to window coordinates.  */
25718       r.x -= WINDOW_LEFT_EDGE_X (w);
25719       r.y -= WINDOW_TOP_EDGE_Y (w);
25720 
25721       /* Turn off the cursor.  */
25722       if (!w->pseudo_window_p
25723           && phys_cursor_in_rect_p (w, &r))
25724         {
25725           x_clear_cursor (w);
25726           cursor_cleared_p = 1;
25727         }
25728       else
25729         cursor_cleared_p = 0;
25730 
25731       /* Update lines intersecting rectangle R.  */
25732       first_overlapping_row = last_overlapping_row = NULL;
25733       for (row = w->current_matrix->rows;
25734            row->enabled_p;
25735            ++row)
25736         {
25737           int y0 = row->y;
25738           int y1 = MATRIX_ROW_BOTTOM_Y (row);
25739 
25740           if ((y0 >= r.y && y0 < r.y + r.height)
25741               || (y1 > r.y && y1 < r.y + r.height)
25742               || (r.y >= y0 && r.y < y1)
25743               || (r.y + r.height > y0 && r.y + r.height < y1))
25744             {
25745               /* A header line may be overlapping, but there is no need
25746                  to fix overlapping areas for them.  KFS 2005-02-12 */
25747               if (row->overlapping_p && !row->mode_line_p)
25748                 {
25749                   if (first_overlapping_row == NULL)
25750                     first_overlapping_row = row;
25751                   last_overlapping_row = row;
25752                 }
25753 
25754               row->clip = fr;
25755               if (expose_line (w, row, &r))
25756                 mouse_face_overwritten_p = 1;
25757               row->clip = NULL;
25758             }
25759           else if (row->overlapping_p)
25760             {
25761               /* We must redraw a row overlapping the exposed area.  */
25762               if (y0 < r.y
25763                   ? y0 + row->phys_height > r.y
25764                   : y0 + row->ascent - row->phys_ascent < r.y +r.height)
25765                 {
25766                   if (first_overlapping_row == NULL)
25767                     first_overlapping_row = row;
25768                   last_overlapping_row = row;
25769                 }
25770             }
25771 
25772           if (y1 >= yb)
25773             break;
25774         }
25775 
25776       /* Display the mode line if there is one.  */
25777       if (WINDOW_WANTS_MODELINE_P (w)
25778           && (row = MATRIX_MODE_LINE_ROW (w->current_matrix),
25779               row->enabled_p)
25780           && row->y < r.y + r.height)
25781         {
25782           if (expose_line (w, row, &r))
25783             mouse_face_overwritten_p = 1;
25784         }
25785 
25786       if (!w->pseudo_window_p)
25787         {
25788           /* Fix the display of overlapping rows.  */
25789           if (first_overlapping_row)
25790             expose_overlaps (w, first_overlapping_row, last_overlapping_row,
25791                              fr);
25792 
25793           /* Draw border between windows.  */
25794           x_draw_vertical_border (w);
25795 
25796           /* Turn the cursor on again.  */
25797           if (cursor_cleared_p)
25798             update_window_cursor (w, 1);
25799         }
25800     }
25801 
25802   return mouse_face_overwritten_p;
25803 }
25804 
25805 
25806 
25807 /* Redraw (parts) of all windows in the window tree rooted at W that
25808    intersect R.  R contains frame pixel coordinates.  Value is
25809    non-zero if the exposure overwrites mouse-face.  */
25810 
25811 static int
25812 expose_window_tree (w, r)
25813      struct window *w;
25814      XRectangle *r;
25815 {
25816   struct frame *f = XFRAME (w->frame);
25817   int mouse_face_overwritten_p = 0;
25818 
25819   while (w && !FRAME_GARBAGED_P (f))
25820     {
25821       if (!NILP (w->hchild))
25822         mouse_face_overwritten_p
25823           |= expose_window_tree (XWINDOW (w->hchild), r);
25824       else if (!NILP (w->vchild))
25825         mouse_face_overwritten_p
25826           |= expose_window_tree (XWINDOW (w->vchild), r);
25827       else
25828         mouse_face_overwritten_p |= expose_window (w, r);
25829 
25830       w = NILP (w->next) ? NULL : XWINDOW (w->next);
25831     }
25832 
25833   return mouse_face_overwritten_p;
25834 }
25835 
25836 
25837 /* EXPORT:
25838    Redisplay an exposed area of frame F.  X and Y are the upper-left
25839    corner of the exposed rectangle.  W and H are width and height of
25840    the exposed area.  All are pixel values.  W or H zero means redraw
25841    the entire frame.  */
25842 
25843 void
25844 expose_frame (f, x, y, w, h)
25845      struct frame *f;
25846      int x, y, w, h;
25847 {
25848   XRectangle r;
25849   int mouse_face_overwritten_p = 0;
25850 
25851   TRACE ((stderr, "expose_frame "));
25852 
25853   /* No need to redraw if frame will be redrawn soon.  */
25854   if (FRAME_GARBAGED_P (f))
25855     {
25856       TRACE ((stderr, " garbaged\n"));
25857       return;
25858     }
25859 
25860   /* If basic faces haven't been realized yet, there is no point in
25861      trying to redraw anything.  This can happen when we get an expose
25862      event while Emacs is starting, e.g. by moving another window.  */
25863   if (FRAME_FACE_CACHE (f) == NULL
25864       || FRAME_FACE_CACHE (f)->used < BASIC_FACE_ID_SENTINEL)
25865     {
25866       TRACE ((stderr, " no faces\n"));
25867       return;
25868     }
25869 
25870   if (w == 0 || h == 0)
25871     {
25872       r.x = r.y = 0;
25873       r.width = FRAME_COLUMN_WIDTH (f) * FRAME_COLS (f);
25874       r.height = FRAME_LINE_HEIGHT (f) * FRAME_LINES (f);
25875     }
25876   else
25877     {
25878       r.x = x;
25879       r.y = y;
25880       r.width = w;
25881       r.height = h;
25882     }
25883 
25884   TRACE ((stderr, "(%d, %d, %d, %d)\n", r.x, r.y, r.width, r.height));
25885   mouse_face_overwritten_p = expose_window_tree (XWINDOW (f->root_window), &r);
25886 
25887   if (WINDOWP (f->tool_bar_window))
25888     mouse_face_overwritten_p
25889       |= expose_window (XWINDOW (f->tool_bar_window), &r);
25890 
25891 #ifdef HAVE_X_WINDOWS
25892 #ifndef MSDOS
25893 #ifndef USE_X_TOOLKIT
25894   if (WINDOWP (f->menu_bar_window))
25895     mouse_face_overwritten_p
25896       |= expose_window (XWINDOW (f->menu_bar_window), &r);
25897 #endif /* not USE_X_TOOLKIT */
25898 #endif
25899 #endif
25900 
25901   /* Some window managers support a focus-follows-mouse style with
25902      delayed raising of frames.  Imagine a partially obscured frame,
25903      and moving the mouse into partially obscured mouse-face on that
25904      frame.  The visible part of the mouse-face will be highlighted,
25905      then the WM raises the obscured frame.  With at least one WM, KDE
25906      2.1, Emacs is not getting any event for the raising of the frame
25907      (even tried with SubstructureRedirectMask), only Expose events.
25908      These expose events will draw text normally, i.e. not
25909      highlighted.  Which means we must redo the highlight here.
25910      Subsume it under ``we love X''.  --gerd 2001-08-15  */
25911   /* Included in Windows version because Windows most likely does not
25912      do the right thing if any third party tool offers
25913      focus-follows-mouse with delayed raise.  --jason 2001-10-12  */
25914   if (mouse_face_overwritten_p && !FRAME_GARBAGED_P (f))
25915     {
25916       Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
25917       if (f == dpyinfo->mouse_face_mouse_frame)
25918         {
25919           int x = dpyinfo->mouse_face_mouse_x;
25920           int y = dpyinfo->mouse_face_mouse_y;
25921           clear_mouse_face (dpyinfo);
25922           note_mouse_highlight (f, x, y);
25923         }
25924     }
25925 }
25926 
25927 
25928 /* EXPORT:
25929    Determine the intersection of two rectangles R1 and R2.  Return
25930    the intersection in *RESULT.  Value is non-zero if RESULT is not
25931    empty.  */
25932 
25933 int
25934 x_intersect_rectangles (r1, r2, result)
25935      XRectangle *r1, *r2, *result;
25936 {
25937   XRectangle *left, *right;
25938   XRectangle *upper, *lower;
25939   int intersection_p = 0;
25940 
25941   /* Rearrange so that R1 is the left-most rectangle.  */
25942   if (r1->x < r2->x)
25943     left = r1, right = r2;
25944   else
25945     left = r2, right = r1;
25946 
25947   /* X0 of the intersection is right.x0, if this is inside R1,
25948      otherwise there is no intersection.  */
25949   if (right->x <= left->x + left->width)
25950     {
25951       result->x = right->x;
25952 
25953       /* The right end of the intersection is the minimum of the
25954          the right ends of left and right.  */
25955       result->width = (min (left->x + left->width, right->x + right->width)
25956                        - result->x);
25957 
25958       /* Same game for Y.  */
25959       if (r1->y < r2->y)
25960         upper = r1, lower = r2;
25961       else
25962         upper = r2, lower = r1;
25963 
25964       /* The upper end of the intersection is lower.y0, if this is inside
25965          of upper.  Otherwise, there is no intersection.  */
25966       if (lower->y <= upper->y + upper->height)
25967         {
25968           result->y = lower->y;
25969 
25970           /* The lower end of the intersection is the minimum of the lower
25971              ends of upper and lower.  */
25972           result->height = (min (lower->y + lower->height,
25973                                  upper->y + upper->height)
25974                             - result->y);
25975           intersection_p = 1;
25976         }
25977     }
25978 
25979   return intersection_p;
25980 }
25981 
25982 #endif /* HAVE_WINDOW_SYSTEM */
25983 
25984 
25985 /***********************************************************************
25986                             Initialization
25987  ***********************************************************************/
25988 
25989 void
25990 syms_of_xdisp ()
25991 {
25992   Vwith_echo_area_save_vector = Qnil;
25993   staticpro (&Vwith_echo_area_save_vector);
25994 
25995   Vmessage_stack = Qnil;
25996   staticpro (&Vmessage_stack);
25997 
25998   Qinhibit_redisplay = intern_c_string ("inhibit-redisplay");
25999   staticpro (&Qinhibit_redisplay);
26000 
26001   message_dolog_marker1 = Fmake_marker ();
26002   staticpro (&message_dolog_marker1);
26003   message_dolog_marker2 = Fmake_marker ();
26004   staticpro (&message_dolog_marker2);
26005   message_dolog_marker3 = Fmake_marker ();
26006   staticpro (&message_dolog_marker3);
26007 
26008 #if GLYPH_DEBUG
26009   defsubr (&Sdump_frame_glyph_matrix);
26010   defsubr (&Sdump_glyph_matrix);
26011   defsubr (&Sdump_glyph_row);
26012   defsubr (&Sdump_tool_bar_row);
26013   defsubr (&Strace_redisplay);
26014   defsubr (&Strace_to_stderr);
26015 #endif
26016 #ifdef HAVE_WINDOW_SYSTEM
26017   defsubr (&Stool_bar_lines_needed);
26018   defsubr (&Slookup_image_map);
26019 #endif
26020   defsubr (&Sformat_mode_line);
26021   defsubr (&Sinvisible_p);
26022   defsubr (&Scurrent_bidi_paragraph_direction);
26023 
26024   staticpro (&Qmenu_bar_update_hook);
26025   Qmenu_bar_update_hook = intern_c_string ("menu-bar-update-hook");
26026 
26027   staticpro (&Qoverriding_terminal_local_map);
26028   Qoverriding_terminal_local_map = intern_c_string ("overriding-terminal-local-map");
26029 
26030   staticpro (&Qoverriding_local_map);
26031   Qoverriding_local_map = intern_c_string ("overriding-local-map");
26032 
26033   staticpro (&Qwindow_scroll_functions);
26034   Qwindow_scroll_functions = intern_c_string ("window-scroll-functions");
26035 
26036   staticpro (&Qwindow_text_change_functions);
26037   Qwindow_text_change_functions = intern_c_string ("window-text-change-functions");
26038 
26039   staticpro (&Qredisplay_end_trigger_functions);
26040   Qredisplay_end_trigger_functions = intern_c_string ("redisplay-end-trigger-functions");
26041 
26042   staticpro (&Qinhibit_point_motion_hooks);
26043   Qinhibit_point_motion_hooks = intern_c_string ("inhibit-point-motion-hooks");
26044 
26045   Qeval = intern_c_string ("eval");
26046   staticpro (&Qeval);
26047 
26048   QCdata = intern_c_string (":data");
26049   staticpro (&QCdata);
26050   Qdisplay = intern_c_string ("display");
26051   staticpro (&Qdisplay);
26052   Qspace_width = intern_c_string ("space-width");
26053   staticpro (&Qspace_width);
26054   Qraise = intern_c_string ("raise");
26055   staticpro (&Qraise);
26056   Qslice = intern_c_string ("slice");
26057   staticpro (&Qslice);
26058   Qspace = intern_c_string ("space");
26059   staticpro (&Qspace);
26060   Qmargin = intern_c_string ("margin");
26061   staticpro (&Qmargin);
26062   Qpointer = intern_c_string ("pointer");
26063   staticpro (&Qpointer);
26064   Qleft_margin = intern_c_string ("left-margin");
26065   staticpro (&Qleft_margin);
26066   Qright_margin = intern_c_string ("right-margin");
26067   staticpro (&Qright_margin);
26068   Qcenter = intern_c_string ("center");
26069   staticpro (&Qcenter);
26070   Qline_height = intern_c_string ("line-height");
26071   staticpro (&Qline_height);
26072   QCalign_to = intern_c_string (":align-to");
26073   staticpro (&QCalign_to);
26074   QCrelative_width = intern_c_string (":relative-width");
26075   staticpro (&QCrelative_width);
26076   QCrelative_height = intern_c_string (":relative-height");
26077   staticpro (&QCrelative_height);
26078   QCeval = intern_c_string (":eval");
26079   staticpro (&QCeval);
26080   QCpropertize = intern_c_string (":propertize");
26081   staticpro (&QCpropertize);
26082   QCfile = intern_c_string (":file");
26083   staticpro (&QCfile);
26084   Qfontified = intern_c_string ("fontified");
26085   staticpro (&Qfontified);
26086   Qfontification_functions = intern_c_string ("fontification-functions");
26087   staticpro (&Qfontification_functions);
26088   Qtrailing_whitespace = intern_c_string ("trailing-whitespace");
26089   staticpro (&Qtrailing_whitespace);
26090   Qescape_glyph = intern_c_string ("escape-glyph");
26091   staticpro (&Qescape_glyph);
26092   Qnobreak_space = intern_c_string ("nobreak-space");
26093   staticpro (&Qnobreak_space);
26094   Qimage = intern_c_string ("image");
26095   staticpro (&Qimage);
26096   Qtext = intern_c_string ("text");
26097   staticpro (&Qtext);
26098   Qboth = intern_c_string ("both");
26099   staticpro (&Qboth);
26100   Qboth_horiz = intern_c_string ("both-horiz");
26101   staticpro (&Qboth_horiz);
26102   QCmap = intern_c_string (":map");
26103   staticpro (&QCmap);
26104   QCpointer = intern_c_string (":pointer");
26105   staticpro (&QCpointer);
26106   Qrect = intern_c_string ("rect");
26107   staticpro (&Qrect);
26108   Qcircle = intern_c_string ("circle");
26109   staticpro (&Qcircle);
26110   Qpoly = intern_c_string ("poly");
26111   staticpro (&Qpoly);
26112   Qmessage_truncate_lines = intern_c_string ("message-truncate-lines");
26113   staticpro (&Qmessage_truncate_lines);
26114   Qgrow_only = intern_c_string ("grow-only");
26115   staticpro (&Qgrow_only);
26116   Qinhibit_menubar_update = intern_c_string ("inhibit-menubar-update");
26117   staticpro (&Qinhibit_menubar_update);
26118   Qinhibit_eval_during_redisplay = intern_c_string ("inhibit-eval-during-redisplay");
26119   staticpro (&Qinhibit_eval_during_redisplay);
26120   Qposition = intern_c_string ("position");
26121   staticpro (&Qposition);
26122   Qbuffer_position = intern_c_string ("buffer-position");
26123   staticpro (&Qbuffer_position);
26124   Qobject = intern_c_string ("object");
26125   staticpro (&Qobject);
26126   Qbar = intern_c_string ("bar");
26127   staticpro (&Qbar);
26128   Qhbar = intern_c_string ("hbar");
26129   staticpro (&Qhbar);
26130   Qbox = intern_c_string ("box");
26131   staticpro (&Qbox);
26132   Qhollow = intern_c_string ("hollow");
26133   staticpro (&Qhollow);
26134   Qhand = intern_c_string ("hand");
26135   staticpro (&Qhand);
26136   Qarrow = intern_c_string ("arrow");
26137   staticpro (&Qarrow);
26138   Qtext = intern_c_string ("text");
26139   staticpro (&Qtext);
26140   Qrisky_local_variable = intern_c_string ("risky-local-variable");
26141   staticpro (&Qrisky_local_variable);
26142   Qinhibit_free_realized_faces = intern_c_string ("inhibit-free-realized-faces");
26143   staticpro (&Qinhibit_free_realized_faces);
26144 
26145   list_of_error = Fcons (Fcons (intern_c_string ("error"),
26146                                 Fcons (intern_c_string ("void-variable"), Qnil)),
26147                          Qnil);
26148   staticpro (&list_of_error);
26149 
26150   Qlast_arrow_position = intern_c_string ("last-arrow-position");
26151   staticpro (&Qlast_arrow_position);
26152   Qlast_arrow_string = intern_c_string ("last-arrow-string");
26153   staticpro (&Qlast_arrow_string);
26154 
26155   Qoverlay_arrow_string = intern_c_string ("overlay-arrow-string");
26156   staticpro (&Qoverlay_arrow_string);
26157   Qoverlay_arrow_bitmap = intern_c_string ("overlay-arrow-bitmap");
26158   staticpro (&Qoverlay_arrow_bitmap);
26159 
26160   echo_buffer[0] = echo_buffer[1] = Qnil;
26161   staticpro (&echo_buffer[0]);
26162   staticpro (&echo_buffer[1]);
26163 
26164   echo_area_buffer[0] = echo_area_buffer[1] = Qnil;
26165   staticpro (&echo_area_buffer[0]);
26166   staticpro (&echo_area_buffer[1]);
26167 
26168   Vmessages_buffer_name = make_pure_c_string ("*Messages*");
26169   staticpro (&Vmessages_buffer_name);
26170 
26171   mode_line_proptrans_alist = Qnil;
26172   staticpro (&mode_line_proptrans_alist);
26173   mode_line_string_list = Qnil;
26174   staticpro (&mode_line_string_list);
26175   mode_line_string_face = Qnil;
26176   staticpro (&mode_line_string_face);
26177   mode_line_string_face_prop = Qnil;
26178   staticpro (&mode_line_string_face_prop);
26179   Vmode_line_unwind_vector = Qnil;
26180   staticpro (&Vmode_line_unwind_vector);
26181 
26182   help_echo_string = Qnil;
26183   staticpro (&help_echo_string);
26184   help_echo_object = Qnil;
26185   staticpro (&help_echo_object);
26186   help_echo_window = Qnil;
26187   staticpro (&help_echo_window);
26188   previous_help_echo_string = Qnil;
26189   staticpro (&previous_help_echo_string);
26190   help_echo_pos = -1;
26191 
26192   Qright_to_left = intern_c_string ("right-to-left");
26193   staticpro (&Qright_to_left);
26194   Qleft_to_right = intern_c_string ("left-to-right");
26195   staticpro (&Qleft_to_right);
26196 
26197 #ifdef HAVE_WINDOW_SYSTEM
26198   DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p,
26199     doc: /* *Non-nil means draw block cursor as wide as the glyph under it.
26200 For example, if a block cursor is over a tab, it will be drawn as
26201 wide as that tab on the display.  */);
26202   x_stretch_cursor_p = 0;
26203 #endif
26204 
26205   DEFVAR_LISP ("show-trailing-whitespace", &Vshow_trailing_whitespace,
26206     doc: /* *Non-nil means highlight trailing whitespace.
26207 The face used for trailing whitespace is `trailing-whitespace'.  */);
26208   Vshow_trailing_whitespace = Qnil;
26209 
26210   DEFVAR_LISP ("nobreak-char-display", &Vnobreak_char_display,
26211     doc: /* *Control highlighting of nobreak space and soft hyphen.
26212 A value of t means highlight the character itself (for nobreak space,
26213 use face `nobreak-space').
26214 A value of nil means no highlighting.
26215 Other values mean display the escape glyph followed by an ordinary
26216 space or ordinary hyphen.  */);
26217   Vnobreak_char_display = Qt;
26218 
26219   DEFVAR_LISP ("void-text-area-pointer", &Vvoid_text_area_pointer,
26220     doc: /* *The pointer shape to show in void text areas.
26221 A value of nil means to show the text pointer.  Other options are `arrow',
26222 `text', `hand', `vdrag', `hdrag', `modeline', and `hourglass'.  */);
26223   Vvoid_text_area_pointer = Qarrow;
26224 
26225   DEFVAR_LISP ("inhibit-redisplay", &Vinhibit_redisplay,
26226     doc: /* Non-nil means don't actually do any redisplay.
26227 This is used for internal purposes.  */);
26228   Vinhibit_redisplay = Qnil;
26229 
26230   DEFVAR_LISP ("global-mode-string", &Vglobal_mode_string,
26231     doc: /* String (or mode line construct) included (normally) in `mode-line-format'.  */);
26232   Vglobal_mode_string = Qnil;
26233 
26234   DEFVAR_LISP ("overlay-arrow-position", &Voverlay_arrow_position,
26235     doc: /* Marker for where to display an arrow on top of the buffer text.
26236 This must be the beginning of a line in order to work.
26237 See also `overlay-arrow-string'.  */);
26238   Voverlay_arrow_position = Qnil;
26239 
26240   DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string,
26241     doc: /* String to display as an arrow in non-window frames.
26242 See also `overlay-arrow-position'.  */);
26243   Voverlay_arrow_string = make_pure_c_string ("=>");
26244 
26245   DEFVAR_LISP ("overlay-arrow-variable-list", &Voverlay_arrow_variable_list,
26246     doc: /* List of variables (symbols) which hold markers for overlay arrows.
26247 The symbols on this list are examined during redisplay to determine
26248 where to display overlay arrows.  */);
26249   Voverlay_arrow_variable_list
26250     = Fcons (intern_c_string ("overlay-arrow-position"), Qnil);
26251 
26252   DEFVAR_INT ("scroll-step", &scroll_step,
26253     doc: /* *The number of lines to try scrolling a window by when point moves out.
26254 If that fails to bring point back on frame, point is centered instead.
26255 If this is zero, point is always centered after it moves off frame.
26256 If you want scrolling to always be a line at a time, you should set
26257 `scroll-conservatively' to a large value rather than set this to 1.  */);
26258 
26259   DEFVAR_INT ("scroll-conservatively", &scroll_conservatively,
26260     doc: /* *Scroll up to this many lines, to bring point back on screen.
26261 If point moves off-screen, redisplay will scroll by up to
26262 `scroll-conservatively' lines in order to bring point just barely
26263 onto the screen again.  If that cannot be done, then redisplay
26264 recenters point as usual.
26265 
26266 A value of zero means always recenter point if it moves off screen.  */);
26267   scroll_conservatively = 0;
26268 
26269   DEFVAR_INT ("scroll-margin", &scroll_margin,
26270     doc: /* *Number of lines of margin at the top and bottom of a window.
26271 Recenter the window whenever point gets within this many lines
26272 of the top or bottom of the window.  */);
26273   scroll_margin = 0;
26274 
26275   DEFVAR_LISP ("display-pixels-per-inch",  &Vdisplay_pixels_per_inch,
26276     doc: /* Pixels per inch value for non-window system displays.
26277 Value is a number or a cons (WIDTH-DPI . HEIGHT-DPI).  */);
26278   Vdisplay_pixels_per_inch = make_float (72.0);
26279 
26280 #if GLYPH_DEBUG
26281   DEFVAR_INT ("debug-end-pos", &debug_end_pos, doc: /* Don't ask.  */);
26282 #endif
26283 
26284   DEFVAR_LISP ("truncate-partial-width-windows",
26285                &Vtruncate_partial_width_windows,
26286     doc: /* Non-nil means truncate lines in windows narrower than the frame.
26287 For an integer value, truncate lines in each window narrower than the
26288 full frame width, provided the window width is less than that integer;
26289 otherwise, respect the value of `truncate-lines'.
26290 
26291 For any other non-nil value, truncate lines in all windows that do
26292 not span the full frame width.
26293 
26294 A value of nil means to respect the value of `truncate-lines'.
26295 
26296 If `word-wrap' is enabled, you might want to reduce this.  */);
26297   Vtruncate_partial_width_windows = make_number (50);
26298 
26299   DEFVAR_BOOL ("mode-line-inverse-video", &mode_line_inverse_video,
26300     doc: /* When nil, display the mode-line/header-line/menu-bar in the default face.
26301 Any other value means to use the appropriate face, `mode-line',
26302 `header-line', or `menu' respectively.  */);
26303   mode_line_inverse_video = 1;
26304 
26305   DEFVAR_LISP ("line-number-display-limit", &Vline_number_display_limit,
26306     doc: /* *Maximum buffer size for which line number should be displayed.
26307 If the buffer is bigger than this, the line number does not appear
26308 in the mode line.  A value of nil means no limit.  */);
26309   Vline_number_display_limit = Qnil;
26310 
26311   DEFVAR_INT ("line-number-display-limit-width",
26312               &line_number_display_limit_width,
26313     doc: /* *Maximum line width (in characters) for line number display.
26314 If the average length of the lines near point is bigger than this, then the
26315 line number may be omitted from the mode line.  */);
26316   line_number_display_limit_width = 200;
26317 
26318   DEFVAR_BOOL ("highlight-nonselected-windows", &highlight_nonselected_windows,
26319     doc: /* *Non-nil means highlight region even in nonselected windows.  */);
26320   highlight_nonselected_windows = 0;
26321 
26322   DEFVAR_BOOL ("multiple-frames", &multiple_frames,
26323     doc: /* Non-nil if more than one frame is visible on this display.
26324 Minibuffer-only frames don't count, but iconified frames do.
26325 This variable is not guaranteed to be accurate except while processing
26326 `frame-title-format' and `icon-title-format'.  */);
26327 
26328   DEFVAR_LISP ("frame-title-format", &Vframe_title_format,
26329     doc: /* Template for displaying the title bar of visible frames.
26330 \(Assuming the window manager supports this feature.)
26331 
26332 This variable has the same structure as `mode-line-format', except that
26333 the %c and %l constructs are ignored.  It is used only on frames for
26334 which no explicit name has been set \(see `modify-frame-parameters').  */);
26335 
26336   DEFVAR_LISP ("icon-title-format", &Vicon_title_format,
26337     doc: /* Template for displaying the title bar of an iconified frame.
26338 \(Assuming the window manager supports this feature.)
26339 This variable has the same structure as `mode-line-format' (which see),
26340 and is used only on frames for which no explicit name has been set
26341 \(see `modify-frame-parameters').  */);
26342   Vicon_title_format
26343     = Vframe_title_format
26344     = pure_cons (intern_c_string ("multiple-frames"),
26345                  pure_cons (make_pure_c_string ("%b"),
26346                             pure_cons (pure_cons (empty_unibyte_string,
26347                                                   pure_cons (intern_c_string ("invocation-name"),
26348                                                              pure_cons (make_pure_c_string ("@"),
26349                                                                         pure_cons (intern_c_string ("system-name"),
26350                                                                                    Qnil)))),
26351                                        Qnil)));
26352 
26353   DEFVAR_LISP ("message-log-max", &Vmessage_log_max,
26354     doc: /* Maximum number of lines to keep in the message log buffer.
26355 If nil, disable message logging.  If t, log messages but don't truncate
26356 the buffer when it becomes large.  */);
26357   Vmessage_log_max = make_number (100);
26358 
26359   DEFVAR_LISP ("window-size-change-functions", &Vwindow_size_change_functions,
26360     doc: /* Functions called before redisplay, if window sizes have changed.
26361 The value should be a list of functions that take one argument.
26362 Just before redisplay, for each frame, if any of its windows have changed
26363 size since the last redisplay, or have been split or deleted,
26364 all the functions in the list are called, with the frame as argument.  */);
26365   Vwindow_size_change_functions = Qnil;
26366 
26367   DEFVAR_LISP ("window-scroll-functions", &Vwindow_scroll_functions,
26368     doc: /* List of functions to call before redisplaying a window with scrolling.
26369 Each function is called with two arguments, the window and its new
26370 display-start position.  Note that these functions are also called by
26371 `set-window-buffer'.  Also note that the value of `window-end' is not
26372 valid when these functions are called.  */);
26373   Vwindow_scroll_functions = Qnil;
26374 
26375   DEFVAR_LISP ("window-text-change-functions",
26376                &Vwindow_text_change_functions,
26377     doc: /* Functions to call in redisplay when text in the window might change.  */);
26378   Vwindow_text_change_functions = Qnil;
26379 
26380   DEFVAR_LISP ("redisplay-end-trigger-functions", &Vredisplay_end_trigger_functions,
26381     doc: /* Functions called when redisplay of a window reaches the end trigger.
26382 Each function is called with two arguments, the window and the end trigger value.
26383 See `set-window-redisplay-end-trigger'.  */);
26384   Vredisplay_end_trigger_functions = Qnil;
26385 
26386   DEFVAR_LISP ("mouse-autoselect-window", &Vmouse_autoselect_window,
26387      doc: /* *Non-nil means autoselect window with mouse pointer.
26388 If nil, do not autoselect windows.
26389 A positive number means delay autoselection by that many seconds: a
26390 window is autoselected only after the mouse has remained in that
26391 window for the duration of the delay.
26392 A negative number has a similar effect, but causes windows to be
26393 autoselected only after the mouse has stopped moving.  \(Because of
26394 the way Emacs compares mouse events, you will occasionally wait twice
26395 that time before the window gets selected.\)
26396 Any other value means to autoselect window instantaneously when the
26397 mouse pointer enters it.
26398 
26399 Autoselection selects the minibuffer only if it is active, and never
26400 unselects the minibuffer if it is active.
26401 
26402 When customizing this variable make sure that the actual value of
26403 `focus-follows-mouse' matches the behavior of your window manager.  */);
26404   Vmouse_autoselect_window = Qnil;
26405 
26406   DEFVAR_LISP ("auto-resize-tool-bars", &Vauto_resize_tool_bars,
26407     doc: /* *Non-nil means automatically resize tool-bars.
26408 This dynamically changes the tool-bar's height to the minimum height
26409 that is needed to make all tool-bar items visible.
26410 If value is `grow-only', the tool-bar's height is only increased
26411 automatically; to decrease the tool-bar height, use \\[recenter].  */);
26412   Vauto_resize_tool_bars = Qt;
26413 
26414   DEFVAR_BOOL ("auto-raise-tool-bar-buttons", &auto_raise_tool_bar_buttons_p,
26415     doc: /* *Non-nil means raise tool-bar buttons when the mouse moves over them.  */);
26416   auto_raise_tool_bar_buttons_p = 1;
26417 
26418   DEFVAR_BOOL ("make-cursor-line-fully-visible", &make_cursor_line_fully_visible_p,
26419     doc: /* *Non-nil means to scroll (recenter) cursor line if it is not fully visible.  */);
26420   make_cursor_line_fully_visible_p = 1;
26421 
26422   DEFVAR_LISP ("tool-bar-border", &Vtool_bar_border,
26423     doc: /* *Border below tool-bar in pixels.
26424 If an integer, use it as the height of the border.
26425 If it is one of `internal-border-width' or `border-width', use the
26426 value of the corresponding frame parameter.
26427 Otherwise, no border is added below the tool-bar.  */);
26428   Vtool_bar_border = Qinternal_border_width;
26429 
26430   DEFVAR_LISP ("tool-bar-button-margin", &Vtool_bar_button_margin,
26431     doc: /* *Margin around tool-bar buttons in pixels.
26432 If an integer, use that for both horizontal and vertical margins.
26433 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
26434 HORZ specifying the horizontal margin, and VERT specifying the
26435 vertical margin.  */);
26436   Vtool_bar_button_margin = make_number (DEFAULT_TOOL_BAR_BUTTON_MARGIN);
26437 
26438   DEFVAR_INT ("tool-bar-button-relief", &tool_bar_button_relief,
26439     doc: /* *Relief thickness of tool-bar buttons.  */);
26440   tool_bar_button_relief = DEFAULT_TOOL_BAR_BUTTON_RELIEF;
26441 
26442   DEFVAR_LISP ("tool-bar-style", &Vtool_bar_style,
26443     doc: /* *Tool bar style to use.
26444 It can be one of
26445  image      - show images only
26446  text       - show text only
26447  both       - show both, text under image
26448  both-horiz - show text to the right of the image
26449  any other  - use system default or image if no system default.  */);
26450   Vtool_bar_style = Qnil;
26451 
26452   DEFVAR_INT ("tool-bar-max-label-size", &tool_bar_max_label_size,
26453     doc: /* *Maximum number of characters a label can have to be shown.
26454 The tool bar style must also show labels for this to have any effect, see
26455 `tool-bar-style'.  */);
26456   tool_bar_max_label_size = DEFAULT_TOOL_BAR_LABEL_SIZE;
26457 
26458   DEFVAR_LISP ("fontification-functions", &Vfontification_functions,
26459     doc: /* List of functions to call to fontify regions of text.
26460 Each function is called with one argument POS.  Functions must
26461 fontify a region starting at POS in the current buffer, and give
26462 fontified regions the property `fontified'.  */);
26463   Vfontification_functions = Qnil;
26464   Fmake_variable_buffer_local (Qfontification_functions);
26465 
26466   DEFVAR_BOOL ("unibyte-display-via-language-environment",
26467                &unibyte_display_via_language_environment,
26468     doc: /* *Non-nil means display unibyte text according to language environment.
26469 Specifically, this means that raw bytes in the range 160-255 decimal
26470 are displayed by converting them to the equivalent multibyte characters
26471 according to the current language environment.  As a result, they are
26472 displayed according to the current fontset.
26473 
26474 Note that this variable affects only how these bytes are displayed,
26475 but does not change the fact they are interpreted as raw bytes.  */);
26476   unibyte_display_via_language_environment = 0;
26477 
26478   DEFVAR_LISP ("max-mini-window-height", &Vmax_mini_window_height,
26479     doc: /* *Maximum height for resizing mini-windows.
26480 If a float, it specifies a fraction of the mini-window frame's height.
26481 If an integer, it specifies a number of lines.  */);
26482   Vmax_mini_window_height = make_float (0.25);
26483 
26484   DEFVAR_LISP ("resize-mini-windows", &Vresize_mini_windows,
26485     doc: /* *How to resize mini-windows.
26486 A value of nil means don't automatically resize mini-windows.
26487 A value of t means resize them to fit the text displayed in them.
26488 A value of `grow-only', the default, means let mini-windows grow
26489 only, until their display becomes empty, at which point the windows
26490 go back to their normal size.  */);
26491   Vresize_mini_windows = Qgrow_only;
26492 
26493   DEFVAR_LISP ("blink-cursor-alist", &Vblink_cursor_alist,
26494     doc: /* Alist specifying how to blink the cursor off.
26495 Each element has the form (ON-STATE . OFF-STATE).  Whenever the
26496 `cursor-type' frame-parameter or variable equals ON-STATE,
26497 comparing using `equal', Emacs uses OFF-STATE to specify
26498 how to blink it off.  ON-STATE and OFF-STATE are values for
26499 the `cursor-type' frame parameter.
26500 
26501 If a frame's ON-STATE has no entry in this list,
26502 the frame's other specifications determine how to blink the cursor off.  */);
26503   Vblink_cursor_alist = Qnil;
26504 
26505   DEFVAR_BOOL ("auto-hscroll-mode", &automatic_hscrolling_p,
26506     doc: /* *Non-nil means scroll the display automatically to make point visible.  */);
26507   automatic_hscrolling_p = 1;
26508   Qauto_hscroll_mode = intern_c_string ("auto-hscroll-mode");
26509   staticpro (&Qauto_hscroll_mode);
26510 
26511   DEFVAR_INT ("hscroll-margin", &hscroll_margin,
26512     doc: /* *How many columns away from the window edge point is allowed to get
26513 before automatic hscrolling will horizontally scroll the window.  */);
26514   hscroll_margin = 5;
26515 
26516   DEFVAR_LISP ("hscroll-step", &Vhscroll_step,
26517     doc: /* *How many columns to scroll the window when point gets too close to the edge.
26518 When point is less than `hscroll-margin' columns from the window
26519 edge, automatic hscrolling will scroll the window by the amount of columns
26520 determined by this variable.  If its value is a positive integer, scroll that
26521 many columns.  If it's a positive floating-point number, it specifies the
26522 fraction of the window's width to scroll.  If it's nil or zero, point will be
26523 centered horizontally after the scroll.  Any other value, including negative
26524 numbers, are treated as if the value were zero.
26525 
26526 Automatic hscrolling always moves point outside the scroll margin, so if
26527 point was more than scroll step columns inside the margin, the window will
26528 scroll more than the value given by the scroll step.
26529 
26530 Note that the lower bound for automatic hscrolling specified by `scroll-left'
26531 and `scroll-right' overrides this variable's effect.  */);
26532   Vhscroll_step = make_number (0);
26533 
26534   DEFVAR_BOOL ("message-truncate-lines", &message_truncate_lines,
26535     doc: /* If non-nil, messages are truncated instead of resizing the echo area.
26536 Bind this around calls to `message' to let it take effect.  */);
26537   message_truncate_lines = 0;
26538 
26539   DEFVAR_LISP ("menu-bar-update-hook",  &Vmenu_bar_update_hook,
26540     doc: /* Normal hook run to update the menu bar definitions.
26541 Redisplay runs this hook before it redisplays the menu bar.
26542 This is used to update submenus such as Buffers,
26543 whose contents depend on various data.  */);
26544   Vmenu_bar_update_hook = Qnil;
26545 
26546   DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame,
26547                doc: /* Frame for which we are updating a menu.
26548 The enable predicate for a menu binding should check this variable.  */);
26549   Vmenu_updating_frame = Qnil;
26550 
26551   DEFVAR_BOOL ("inhibit-menubar-update", &inhibit_menubar_update,
26552     doc: /* Non-nil means don't update menu bars.  Internal use only.  */);
26553   inhibit_menubar_update = 0;
26554 
26555   DEFVAR_LISP ("wrap-prefix", &Vwrap_prefix,
26556     doc: /* Prefix prepended to all continuation lines at display time.
26557 The value may be a string, an image, or a stretch-glyph; it is
26558 interpreted in the same way as the value of a `display' text property.
26559 
26560 This variable is overridden by any `wrap-prefix' text or overlay
26561 property.
26562 
26563 To add a prefix to non-continuation lines, use `line-prefix'.  */);
26564   Vwrap_prefix = Qnil;
26565   staticpro (&Qwrap_prefix);
26566   Qwrap_prefix = intern_c_string ("wrap-prefix");
26567   Fmake_variable_buffer_local (Qwrap_prefix);
26568 
26569   DEFVAR_LISP ("line-prefix", &Vline_prefix,
26570     doc: /* Prefix prepended to all non-continuation lines at display time.
26571 The value may be a string, an image, or a stretch-glyph; it is
26572 interpreted in the same way as the value of a `display' text property.
26573 
26574 This variable is overridden by any `line-prefix' text or overlay
26575 property.
26576 
26577 To add a prefix to continuation lines, use `wrap-prefix'.  */);
26578   Vline_prefix = Qnil;
26579   staticpro (&Qline_prefix);
26580   Qline_prefix = intern_c_string ("line-prefix");
26581   Fmake_variable_buffer_local (Qline_prefix);
26582 
26583   DEFVAR_BOOL ("inhibit-eval-during-redisplay", &inhibit_eval_during_redisplay,
26584     doc: /* Non-nil means don't eval Lisp during redisplay.  */);
26585   inhibit_eval_during_redisplay = 0;
26586 
26587   DEFVAR_BOOL ("inhibit-free-realized-faces", &inhibit_free_realized_faces,
26588     doc: /* Non-nil means don't free realized faces.  Internal use only.  */);
26589   inhibit_free_realized_faces = 0;
26590 
26591 #if GLYPH_DEBUG
26592   DEFVAR_BOOL ("inhibit-try-window-id", &inhibit_try_window_id,
26593                doc: /* Inhibit try_window_id display optimization.  */);
26594   inhibit_try_window_id = 0;
26595 
26596   DEFVAR_BOOL ("inhibit-try-window-reusing", &inhibit_try_window_reusing,
26597                doc: /* Inhibit try_window_reusing display optimization.  */);
26598   inhibit_try_window_reusing = 0;
26599 
26600   DEFVAR_BOOL ("inhibit-try-cursor-movement", &inhibit_try_cursor_movement,
26601                doc: /* Inhibit try_cursor_movement display optimization.  */);
26602   inhibit_try_cursor_movement = 0;
26603 #endif /* GLYPH_DEBUG */
26604 
26605   DEFVAR_INT ("overline-margin", &overline_margin,
26606                doc: /* *Space between overline and text, in pixels.
26607 The default value is 2: the height of the overline (1 pixel) plus 1 pixel
26608 margin to the caracter height.  */);
26609   overline_margin = 2;
26610 
26611   DEFVAR_INT ("underline-minimum-offset",
26612                &underline_minimum_offset,
26613      doc: /* Minimum distance between baseline and underline.
26614 This can improve legibility of underlined text at small font sizes,
26615 particularly when using variable `x-use-underline-position-properties'
26616 with fonts that specify an UNDERLINE_POSITION relatively close to the
26617 baseline.  The default value is 1.  */);
26618   underline_minimum_offset = 1;
26619 
26620   DEFVAR_BOOL ("display-hourglass", &display_hourglass_p,
26621                doc: /* Non-zero means Emacs displays an hourglass pointer on window systems.  */);
26622   display_hourglass_p = 1;
26623 
26624   DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay,
26625                doc: /* *Seconds to wait before displaying an hourglass pointer.
26626 Value must be an integer or float.  */);
26627   Vhourglass_delay = make_number (DEFAULT_HOURGLASS_DELAY);
26628 
26629   hourglass_atimer = NULL;
26630   hourglass_shown_p = 0;
26631 }
26632 
26633 
26634 /* Initialize this module when Emacs starts.  */
26635 
26636 void
26637 init_xdisp ()
26638 {
26639   Lisp_Object root_window;
26640   struct window *mini_w;
26641 
26642   current_header_line_height = current_mode_line_height = -1;
26643 
26644   CHARPOS (this_line_start_pos) = 0;
26645 
26646   mini_w = XWINDOW (minibuf_window);
26647   root_window = FRAME_ROOT_WINDOW (XFRAME (WINDOW_FRAME (mini_w)));
26648 
26649   if (!noninteractive)
26650     {
26651       struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (root_window)));
26652       int i;
26653 
26654       XWINDOW (root_window)->top_line = make_number (FRAME_TOP_MARGIN (f));
26655       set_window_height (root_window,
26656                          FRAME_LINES (f) - 1 - FRAME_TOP_MARGIN (f),
26657                          0);
26658       mini_w->top_line = make_number (FRAME_LINES (f) - 1);
26659       set_window_height (minibuf_window, 1, 0);
26660 
26661       XWINDOW (root_window)->total_cols = make_number (FRAME_COLS (f));
26662       mini_w->total_cols = make_number (FRAME_COLS (f));
26663 
26664       scratch_glyph_row.glyphs[TEXT_AREA] = scratch_glyphs;
26665       scratch_glyph_row.glyphs[TEXT_AREA + 1]
26666         = scratch_glyphs + MAX_SCRATCH_GLYPHS;
26667 
26668       /* The default ellipsis glyphs `...'.  */
26669       for (i = 0; i < 3; ++i)
26670         default_invis_vector[i] = make_number ('.');
26671     }
26672 
26673   {
26674     /* Allocate the buffer for frame titles.
26675        Also used for `format-mode-line'.  */
26676     int size = 100;
26677     mode_line_noprop_buf = (char *) xmalloc (size);
26678     mode_line_noprop_buf_end = mode_line_noprop_buf + size;
26679     mode_line_noprop_ptr = mode_line_noprop_buf;
26680     mode_line_target = MODE_LINE_DISPLAY;
26681   }
26682 
26683   help_echo_showing_p = 0;
26684 }
26685 
26686 /* Since w32 does not support atimers, it defines its own implementation of
26687    the following three functions in w32fns.c.  */
26688 #ifndef WINDOWSNT
26689 
26690 /* Platform-independent portion of hourglass implementation. */
26691 
26692 /* Return non-zero if houglass timer has been started or hourglass is shown.  */
26693 int
26694 hourglass_started ()
26695 {
26696   return hourglass_shown_p || hourglass_atimer != NULL;
26697 }
26698 
26699 /* Cancel a currently active hourglass timer, and start a new one.  */
26700 void
26701 start_hourglass ()
26702 {
26703 #if defined (HAVE_WINDOW_SYSTEM)
26704   EMACS_TIME delay;
26705   int secs, usecs = 0;
26706 
26707   cancel_hourglass ();
26708 
26709   if (INTEGERP (Vhourglass_delay)
26710       && XINT (Vhourglass_delay) > 0)
26711     secs = XFASTINT (Vhourglass_delay);
26712   else if (FLOATP (Vhourglass_delay)
26713            && XFLOAT_DATA (Vhourglass_delay) > 0)
26714     {
26715       Lisp_Object tem;
26716       tem = Ftruncate (Vhourglass_delay, Qnil);
26717       secs = XFASTINT (tem);
26718       usecs = (XFLOAT_DATA (Vhourglass_delay) - secs) * 1000000;
26719     }
26720   else
26721     secs = DEFAULT_HOURGLASS_DELAY;
26722 
26723   EMACS_SET_SECS_USECS (delay, secs, usecs);
26724   hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
26725                                    show_hourglass, NULL);
26726 #endif
26727 }
26728 
26729 
26730 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
26731    shown.  */
26732 void
26733 cancel_hourglass ()
26734 {
26735 #if defined (HAVE_WINDOW_SYSTEM)
26736   if (hourglass_atimer)
26737     {
26738       cancel_atimer (hourglass_atimer);
26739       hourglass_atimer = NULL;
26740     }
26741 
26742   if (hourglass_shown_p)
26743     hide_hourglass ();
26744 #endif
26745 }
26746 #endif /* ! WINDOWSNT  */
26747 
26748 /* arch-tag: eacc864d-bb6a-4b74-894a-1a4399a1358b
26749    (do not change this comment) */