You will find a lot of redisplay optimizations when you start
looking at the innards of redisplay. The overall goal of all these
optimizations is to make redisplay fast because it is done
- frequently.
+ frequently. Some of these optimizations are implemented by the
+ following functions:
+
+ . try_cursor_movement
+
+ This function tries to update the display if the text in the
+ window did not change and did not scroll, only point moved, and
+ it did not move off the displayed portion of the text.
+
+ . try_window_reusing_current_matrix
+
+ This function reuses the current matrix of a window when text
+ has not changed, but the window start changed (e.g., due to
+ scrolling).
+
+ . try_window_id
+
+ This function attempts to redisplay a window by reusing parts of
+ its existing display. It finds and reuses the part that was not
+ changed, and redraws the rest.
+
+ . try_window
+
+ This function performs the full redisplay of a single window
+ assuming that its fonts were not changed and that the cursor
+ will not end up in the scroll margins. (Loading fonts requires
+ re-adjustment of dimensions of glyph matrices, which makes this
+ method impossible to use.)
+
+ These optimizations are tried in sequence (some can be skipped if
+ it is known that they are not applicable). If none of the
+ optimizations were successful, redisplay calls redisplay_windows,
+ which performs a full redisplay of all windows.
Desired matrices.
see in dispextern.h.
Glyphs in a desired matrix are normally constructed in a loop
- calling get_next_display_element and then produce_glyphs. The call
- to produce_glyphs will fill the iterator structure with pixel
+ calling get_next_display_element and then PRODUCE_GLYPHS. The call
+ to PRODUCE_GLYPHS will fill the iterator structure with pixel
information about the element being displayed and at the same time
produce glyphs for it. If the display element fits on the line
being displayed, set_iterator_to_next is called next, otherwise the
- glyphs produced are discarded.
-
+ glyphs produced are discarded. The function display_line is the
+ workhorse of filling glyph rows in the desired matrix with glyphs.
+ In addition to producing glyphs, it also handles line truncation
+ and continuation, word wrap, and cursor positioning (for the
+ latter, see also set_cursor_from_row).
Frame matrices.
wanted to have without having to move many bytes around. To be
honest, there is a little bit more done, but not much more. If you
plan to extend that code, take a look at dispnew.c. The function
- build_frame_matrix is a good starting point. */
+ build_frame_matrix is a good starting point.
+
+ Bidirectional display.
+
+ Bidirectional display adds quite some hair to this already complex
+ design. The good news are that a large portion of that hairy stuff
+ is hidden in bidi.c behind only 3 interfaces. bidi.c implements a
+ reordering engine which is called by set_iterator_to_next and
+ returns the next character to display in the visual order. See
+ commentary on bidi.c for more details. As far as redisplay is
+ concerned, the effect of calling bidi_get_next_char_visually, the
+ main interface of the reordering engine, is that the iterator gets
+ magically placed on the buffer or string position that is to be
+ displayed next. In other words, a linear iteration through the
+ buffer/string is replaced with a non-linear one. All the rest of
+ the redisplay is oblivious to the bidi reordering.
+
+ Well, almost oblivious---there are still complications, most of
+ them due to the fact that buffer and string positions no longer
+ change monotonously with glyph indices in a glyph row. Moreover,
+ for continued lines, the buffer positions may not even be
+ monotonously changing with vertical positions. Also, accounting
+ for face changes, overlays, etc. becomes more complex because
+ non-linear iteration could potentially skip many positions with
+ changes, and then cross them again on the way back...
+
+ One other prominent effect of bidirectional display is that some
+ paragraphs of text need to be displayed starting at the right
+ margin of the window---the so-called right-to-left, or R2L
+ paragraphs. R2L paragraphs are displayed with R2L glyph rows,
+ which have their reversed_p flag set. The bidi reordering engine
+ produces characters in such rows starting from the character which
+ should be the rightmost on display. PRODUCE_GLYPHS then reverses
+ the order, when it fills up the glyph row whose reversed_p flag is
+ set, by prepending each new glyph to what is already there, instead
+ of appending it. When the glyph row is complete, the function
+ extend_face_to_end_of_line fills the empty space to the left of the
+ leftmost character with special glyphs, which will display as,
+ well, empty. On text terminals, these special glyphs are simply
+ blank characters. On graphics terminals, there's a single stretch
+ glyph with suitably computed width. Both the blanks and the
+ stretch glyph are given the face of the background of the line.
+ This way, the terminal-specific back-end can still draw the glyphs
+ left to right, even for R2L lines. */
#include <config.h>
#include <stdio.h>
if (m)
{
int len;
-#ifdef NO_ARG_ARRAY
char *a[3];
a[0] = (char *) a1;
a[1] = (char *) a2;
len = doprnt (FRAME_MESSAGE_BUF (f),
FRAME_MESSAGE_BUF_SIZE (f), m, (char *)0, 3, a);
-#else
- len = doprnt (FRAME_MESSAGE_BUF (f),
- FRAME_MESSAGE_BUF_SIZE (f), m, (char *)0, 3,
- (char **) &a1);
-#endif /* NO_ARG_ARRAY */
message2 (FRAME_MESSAGE_BUF (f), len, 0);
}
update_tool_bar (f, 0);
#endif
#ifdef HAVE_NS
- if (windows_or_buffers_changed)
+ if (windows_or_buffers_changed
+ && FRAME_NS_P (f))
ns_set_doc_edited (f, Fbuffer_modified_p
(XWINDOW (f->selected_window)->buffer));
#endif
select_frame_for_redisplay (frame)
Lisp_Object frame;
{
- Lisp_Object tail, symbol, val;
+ Lisp_Object tail, tem;
Lisp_Object old = selected_frame;
struct Lisp_Symbol *sym;
selected_frame = frame;
- do
- {
- for (tail = XFRAME (frame)->param_alist; CONSP (tail); tail = XCDR (tail))
- if (CONSP (XCAR (tail))
- && (symbol = XCAR (XCAR (tail)),
- SYMBOLP (symbol))
- && (sym = indirect_variable (XSYMBOL (symbol)),
- val = sym->value,
- (BUFFER_LOCAL_VALUEP (val)))
- && XBUFFER_LOCAL_VALUE (val)->check_frame)
- /* Use find_symbol_value rather than Fsymbol_value
- to avoid an error if it is void. */
- find_symbol_value (symbol);
- } while (!EQ (frame, old) && (frame = old, 1));
+ do {
+ for (tail = XFRAME (frame)->param_alist; CONSP (tail); tail = XCDR (tail))
+ if (CONSP (XCAR (tail))
+ && (tem = XCAR (XCAR (tail)),
+ SYMBOLP (tem))
+ && (sym = indirect_variable (XSYMBOL (tem)),
+ sym->redirect == SYMBOL_LOCALIZED)
+ && sym->val.blv->frame_local)
+ /* Use find_symbol_value rather than Fsymbol_value
+ to avoid an error if it is void. */
+ find_symbol_value (tem);
+ } while (!EQ (frame, old) && (frame = old, 1));
}
= try_window_reusing_current_matrix (w)))
{
IF_DEBUG (debug_method_add (w, "1"));
- if (try_window (window, startp, 1) < 0)
+ if (try_window (window, startp, TRY_WINDOW_CHECK_MARGINS) < 0)
/* -1 means we need to scroll.
0 means we need new matrices, but fonts_changed_p
is set in that case, so we will detect it below. */
Value is 1 if successful. It is zero if fonts were loaded during
redisplay which makes re-adjusting glyph matrices necessary, and -1
if point would appear in the scroll margins.
- (We check that only if CHECK_MARGINS is nonzero. */
+ (We check the former only if TRY_WINDOW_IGNORE_FONTS_CHANGE is
+ unset in FLAGS, and the latter only if TRY_WINDOW_CHECK_MARGINS is
+ set in FLAGS.) */
int
-try_window (window, pos, check_margins)
+try_window (window, pos, flags)
Lisp_Object window;
struct text_pos pos;
- int check_margins;
+ int flags;
{
struct window *w = XWINDOW (window);
struct it it;
{
if (display_line (&it))
last_text_row = it.glyph_row - 1;
- if (fonts_changed_p)
+ if (fonts_changed_p && !(flags & TRY_WINDOW_IGNORE_FONTS_CHANGE))
return 0;
}
/* Don't let the cursor end in the scroll margins. */
- if (check_margins
+ if ((flags & TRY_WINDOW_CHECK_MARGINS)
&& !MINI_WINDOW_P (w))
{
int this_scroll_margin;
it->current_y += row->height;
++it->vpos;
++it->glyph_row;
- /* The next row should use same value of the reversed_p flag as this
- one. set_iterator_to_next decides when it's a new paragraph, and
- PRODUCE_GLYPHS recomputes the value of the flag accordingly. */
+ /* The next row should by default use the same value of the
+ reversed_p flag as this one. set_iterator_to_next decides when
+ it's a new paragraph, and PRODUCE_GLYPHS recomputes the value of
+ the flag accordingly. */
if (it->glyph_row < MATRIX_BOTTOM_TEXT_ROW (it->w->desired_matrix, it->w))
it->glyph_row->reversed_p = row->reversed_p;
it->start = row_end;
HCoop / bpt / emacs.git / blobdiff