vim/src/drawscreen.c
Luuk van Baal 7bbb0f357e
patch 9.1.1136: Match highlighting marks a buffer region as changed
Problem:  Match highlighting marks a buffer region to be redrawn as if
          its buffer text was changed, unnecessarily invoking syntax code.
Solution: Set the `w_redraw_top/bot` variables instead of the b_mod_* ones
          (Luuk van Baal)

closes: #16697

Signed-off-by: Luuk van Baal <luukvbaal@gmail.com>
Signed-off-by: Christian Brabandt <cb@256bit.org>
2025-02-22 09:19:04 +01:00

3385 lines
86 KiB
C

/* vi:set ts=8 sts=4 sw=4 noet:
*
* VIM - Vi IMproved by Bram Moolenaar
*
* Do ":help uganda" in Vim to read copying and usage conditions.
* Do ":help credits" in Vim to see a list of people who contributed.
* See README.txt for an overview of the Vim source code.
*/
/*
* drawscreen.c: Code for updating all the windows on the screen.
* This is the top level, drawline.c is the middle and screen.c the lower
* level.
*
* update_screen() is the function that updates all windows and status lines.
* It is called form the main loop when must_redraw is non-zero. It may be
* called from other places when an immediate screen update is needed.
*
* The part of the buffer that is displayed in a window is set with:
* - w_topline (first buffer line in window)
* - w_topfill (filler lines above the first line)
* - w_leftcol (leftmost window cell in window),
* - w_skipcol (skipped window cells of first line)
*
* Commands that only move the cursor around in a window, do not need to take
* action to update the display. The main loop will check if w_topline is
* valid and update it (scroll the window) when needed.
*
* Commands that scroll a window change w_topline and must call
* check_cursor() to move the cursor into the visible part of the window, and
* call redraw_later(UPD_VALID) to have the window displayed by update_screen()
* later.
*
* Commands that change text in the buffer must call changed_bytes() or
* changed_lines() to mark the area that changed and will require updating
* later. The main loop will call update_screen(), which will update each
* window that shows the changed buffer. This assumes text above the change
* can remain displayed as it is. Text after the change may need updating for
* scrolling, folding and syntax highlighting.
*
* Commands that change how a window is displayed (e.g., setting 'list') or
* invalidate the contents of a window in another way (e.g., change fold
* settings), must call redraw_later(UPD_NOT_VALID) to have the whole window
* redisplayed by update_screen() later.
*
* Commands that change how a buffer is displayed (e.g., setting 'tabstop')
* must call redraw_curbuf_later(UPD_NOT_VALID) to have all the windows for the
* buffer redisplayed by update_screen() later.
*
* Commands that change highlighting and possibly cause a scroll too must call
* redraw_later(UPD_SOME_VALID) to update the whole window but still use
* scrolling to avoid redrawing everything. But the length of displayed lines
* must not change, use UPD_NOT_VALID then.
*
* Commands that move the window position must call redraw_later(UPD_NOT_VALID).
* TODO: should minimize redrawing by scrolling when possible.
*
* Commands that change everything (e.g., resizing the screen) must call
* redraw_all_later(UPD_NOT_VALID) or redraw_all_later(UPD_CLEAR).
*
* Things that are handled indirectly:
* - When messages scroll the screen up, msg_scrolled will be set and
* update_screen() called to redraw.
*/
#include "vim.h"
static void win_update(win_T *wp);
#ifdef FEAT_STL_OPT
static void redraw_custom_statusline(win_T *wp);
#endif
#if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_CLIPBOARD)
static int did_update_one_window;
#endif
/*
* Based on the current value of curwin->w_topline, transfer a screenfull
* of stuff from Filemem to ScreenLines[], and update curwin->w_botline.
* Return OK when the screen was updated, FAIL if it was not done.
*/
int
update_screen(int type_arg)
{
int type = type_arg;
win_T *wp;
static int did_intro = FALSE;
#ifdef FEAT_GUI
int did_one = FALSE;
int did_undraw = FALSE;
int gui_cursor_col = 0;
int gui_cursor_row = 0;
#endif
int no_update = FALSE;
int save_pum_will_redraw = pum_will_redraw;
// Don't do anything if the screen structures are (not yet) valid.
if (!screen_valid(TRUE))
return FAIL;
if (type == UPD_VALID_NO_UPDATE)
{
no_update = TRUE;
type = 0;
}
#ifdef FEAT_EVAL
{
buf_T *buf;
// Before updating the screen, notify any listeners of changed text.
FOR_ALL_BUFFERS(buf)
invoke_listeners(buf);
}
#endif
#ifdef FEAT_DIFF
// May have postponed updating diffs.
if (need_diff_redraw)
diff_redraw(TRUE);
#endif
if (must_redraw)
{
if (type < must_redraw) // use maximal type
type = must_redraw;
// must_redraw is reset here, so that when we run into some weird
// reason to redraw while busy redrawing (e.g., asynchronous
// scrolling), or update_topline() in win_update() will cause a
// scroll, the screen will be redrawn later or in win_update().
must_redraw = 0;
}
// May need to update w_lines[].
if (curwin->w_lines_valid == 0 && type < UPD_NOT_VALID
#ifdef FEAT_TERMINAL
&& !term_do_update_window(curwin)
#endif
)
type = UPD_NOT_VALID;
// Postpone the redrawing when it's not needed and when being called
// recursively.
if (!redrawing() || updating_screen)
{
redraw_later(type); // remember type for next time
must_redraw = type;
if (type > UPD_INVERTED_ALL)
curwin->w_lines_valid = 0; // don't use w_lines[].wl_size now
return FAIL;
}
updating_screen = TRUE;
#ifdef FEAT_PROP_POPUP
// Update popup_mask if needed. This may set w_redraw_top and w_redraw_bot
// in some windows.
may_update_popup_mask(type);
#endif
#ifdef FEAT_SYN_HL
++display_tick; // let syntax code know we're in a next round of
// display updating
#endif
if (no_update)
++no_win_do_lines_ins;
// if the screen was scrolled up when displaying a message, scroll it down
if (msg_scrolled)
{
clear_cmdline = TRUE;
if (type != UPD_CLEAR)
{
if (msg_scrolled > Rows - 5) // redrawing is faster
{
type = UPD_NOT_VALID;
redraw_as_cleared();
}
else
{
check_for_delay(FALSE);
if (screen_ins_lines(0, 0, msg_scrolled, (int)Rows, 0, NULL)
== FAIL)
{
type = UPD_NOT_VALID;
redraw_as_cleared();
}
FOR_ALL_WINDOWS(wp)
{
if (wp->w_winrow < msg_scrolled)
{
if (W_WINROW(wp) + wp->w_height > msg_scrolled
&& wp->w_redr_type < UPD_REDRAW_TOP
&& wp->w_lines_valid > 0
&& wp->w_topline == wp->w_lines[0].wl_lnum)
{
wp->w_upd_rows = msg_scrolled - W_WINROW(wp);
wp->w_redr_type = UPD_REDRAW_TOP;
}
else
{
wp->w_redr_type = UPD_NOT_VALID;
if (W_WINROW(wp) + wp->w_height
+ wp->w_status_height <= msg_scrolled)
wp->w_redr_status = TRUE;
}
}
}
if (!no_update)
redraw_cmdline = TRUE;
redraw_tabline = TRUE;
}
}
msg_scrolled = 0;
need_wait_return = FALSE;
}
// reset cmdline_row now (may have been changed temporarily)
compute_cmdrow();
// Check for changed highlighting
if (need_highlight_changed)
highlight_changed();
if (type == UPD_CLEAR) // first clear screen
{
screenclear(); // will reset clear_cmdline
type = UPD_NOT_VALID;
// must_redraw may be set indirectly, avoid another redraw later
must_redraw = 0;
}
if (clear_cmdline) // going to clear cmdline (done below)
check_for_delay(FALSE);
#ifdef FEAT_LINEBREAK
// Force redraw when width of 'number' or 'relativenumber' column
// changes.
if (curwin->w_redr_type < UPD_NOT_VALID
&& curwin->w_nrwidth != ((curwin->w_p_nu || curwin->w_p_rnu)
? number_width(curwin) : 0))
curwin->w_redr_type = UPD_NOT_VALID;
#endif
// Only start redrawing if there is really something to do.
if (type == UPD_INVERTED)
update_curswant();
if (curwin->w_redr_type < type
&& !((type == UPD_VALID
&& curwin->w_lines[0].wl_valid
#ifdef FEAT_DIFF
&& curwin->w_topfill == curwin->w_old_topfill
&& curwin->w_botfill == curwin->w_old_botfill
#endif
&& curwin->w_topline == curwin->w_lines[0].wl_lnum)
|| (type == UPD_INVERTED
&& VIsual_active
&& curwin->w_old_cursor_lnum == curwin->w_cursor.lnum
&& curwin->w_old_visual_mode == VIsual_mode
&& (curwin->w_valid & VALID_VIRTCOL)
&& curwin->w_old_curswant == curwin->w_curswant)
))
curwin->w_redr_type = type;
// Redraw the tab pages line if needed.
if (redraw_tabline || type >= UPD_NOT_VALID)
draw_tabline();
#ifdef FEAT_SYN_HL
// Correct stored syntax highlighting info for changes in each displayed
// buffer. Each buffer must only be done once.
FOR_ALL_WINDOWS(wp)
{
if (wp->w_buffer->b_mod_set)
{
win_T *wwp;
// Check if we already did this buffer.
for (wwp = firstwin; wwp != wp; wwp = wwp->w_next)
if (wwp->w_buffer == wp->w_buffer)
break;
if (wwp == wp && syntax_present(wp))
syn_stack_apply_changes(wp->w_buffer);
}
}
#endif
if (pum_redraw_in_same_position())
// Avoid flicker if the popup menu is going to be redrawn in the same
// position.
pum_will_redraw = TRUE;
// Go from top to bottom through the windows, redrawing the ones that need
// it.
#if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_CLIPBOARD)
did_update_one_window = FALSE;
#endif
#ifdef FEAT_SEARCH_EXTRA
screen_search_hl.rm.regprog = NULL;
#endif
FOR_ALL_WINDOWS(wp)
{
if (wp->w_redr_type != 0)
{
cursor_off();
#ifdef FEAT_GUI
if (!did_one)
{
did_one = TRUE;
// Remove the cursor before starting to do anything, because
// scrolling may make it difficult to redraw the text under
// it.
// Also remove the cursor if it needs to be hidden due to an
// ongoing cursor-less sleep.
if (gui.in_use && (wp == curwin || cursor_is_sleeping()))
{
gui_cursor_col = gui.cursor_col;
gui_cursor_row = gui.cursor_row;
gui_undraw_cursor();
did_undraw = TRUE;
}
}
#endif
win_update(wp);
}
// redraw status line after the window to minimize cursor movement
if (wp->w_redr_status)
{
cursor_off();
win_redr_status(wp, TRUE); // any popup menu will be redrawn below
}
}
#if defined(FEAT_SEARCH_EXTRA)
end_search_hl();
#endif
// May need to redraw the popup menu.
pum_will_redraw = save_pum_will_redraw;
pum_may_redraw();
// Reset b_mod_set flags. Going through all windows is probably faster
// than going through all buffers (there could be many buffers).
FOR_ALL_WINDOWS(wp)
wp->w_buffer->b_mod_set = FALSE;
#ifdef FEAT_PROP_POPUP
// Display popup windows on top of the windows and command line.
update_popups(win_update);
#endif
#ifdef FEAT_TERMINAL
FOR_ALL_WINDOWS(wp)
// If this window contains a terminal, after redrawing all windows, the
// dirty row range can be reset.
term_did_update_window(wp);
#endif
after_updating_screen(TRUE);
// Clear or redraw the command line. Done last, because scrolling may
// mess up the command line.
if (clear_cmdline || redraw_cmdline || redraw_mode)
showmode();
if (no_update)
--no_win_do_lines_ins;
// May put up an introductory message when not editing a file
if (!did_intro)
maybe_intro_message();
did_intro = TRUE;
#ifdef FEAT_GUI
// Redraw the cursor and update the scrollbars when all screen updating is
// done.
if (gui.in_use)
{
if (did_undraw && !gui_mch_is_blink_off())
{
mch_disable_flush();
out_flush(); // required before updating the cursor
mch_enable_flush();
// Put the GUI position where the cursor was, gui_update_cursor()
// uses that.
gui.col = gui_cursor_col;
gui.row = gui_cursor_row;
gui.col = mb_fix_col(gui.col, gui.row);
gui_update_cursor(FALSE, FALSE);
gui_may_flush();
screen_cur_col = gui.col;
screen_cur_row = gui.row;
}
else
out_flush();
gui_update_scrollbars(FALSE);
}
#endif
return OK;
}
/*
* Return the row for drawing the statusline and the ruler of window "wp".
*/
int
statusline_row(win_T *wp)
{
#if defined(FEAT_PROP_POPUP)
// If the window is really zero height the winbar isn't displayed.
if (wp->w_frame->fr_height == wp->w_status_height && !popup_is_popup(wp))
return wp->w_winrow;
#endif
return W_WINROW(wp) + wp->w_height;
}
/*
* Redraw the status line of window wp.
*
* If inversion is possible we use it. Else '=' characters are used.
* If "ignore_pum" is TRUE, also redraw statusline when the popup menu is
* displayed.
*/
void
win_redr_status(win_T *wp, int ignore_pum UNUSED)
{
int row;
int fillchar;
int attr;
static int busy = FALSE;
// It's possible to get here recursively when 'statusline' (indirectly)
// invokes ":redrawstatus". Simply ignore the call then.
if (busy)
return;
busy = TRUE;
row = statusline_row(wp);
wp->w_redr_status = FALSE;
if (wp->w_status_height == 0)
{
// no status line, can only be last window
redraw_cmdline = TRUE;
}
else if (!redrawing()
// don't update status line when popup menu is visible and may be
// drawn over it, unless it will be redrawn later
|| (!ignore_pum && pum_visible()))
{
// Don't redraw right now, do it later.
wp->w_redr_status = TRUE;
}
#ifdef FEAT_STL_OPT
else if (*p_stl != NUL || *wp->w_p_stl != NUL)
{
// redraw custom status line
redraw_custom_statusline(wp);
}
#endif
else
{
char_u *p;
int plen;
int NameBufflen;
int this_ru_col;
int n; // scratch value
fillchar = fillchar_status(&attr, wp);
get_trans_bufname(wp->w_buffer);
p = NameBuff;
plen = (int)STRLEN(p);
if ((bt_help(wp->w_buffer)
#ifdef FEAT_QUICKFIX
|| wp->w_p_pvw
#endif
|| bufIsChanged(wp->w_buffer)
|| wp->w_buffer->b_p_ro)
&& plen < MAXPATHL - 1)
{
*(p + plen++) = ' '; // replace NUL with space
*(p + plen) = NUL; // NUL terminate the string
}
if (bt_help(wp->w_buffer))
plen += vim_snprintf((char *)p + plen, MAXPATHL - plen, "%s", _("[Help]"));
#ifdef FEAT_QUICKFIX
if (wp->w_p_pvw)
plen += vim_snprintf((char *)p + plen, MAXPATHL - plen, "%s", _("[Preview]"));
#endif
if (bufIsChanged(wp->w_buffer) && !bt_terminal(wp->w_buffer))
plen += vim_snprintf((char *)p + plen, MAXPATHL - plen, "%s", "[+]");
if (wp->w_buffer->b_p_ro)
plen += vim_snprintf((char *)p + plen, MAXPATHL - plen, "%s", _("[RO]"));
this_ru_col = ru_col - (Columns - wp->w_width);
n = (wp->w_width + 1) / 2;
if (this_ru_col < n)
this_ru_col = n;
if (this_ru_col <= 1)
{
p = (char_u *)"<"; // No room for file name!
plen = 1;
}
else if (has_mbyte)
{
int i;
// Count total number of display cells.
plen = mb_string2cells(p, -1);
// Find first character that will fit.
// Going from start to end is much faster for DBCS.
for (i = 0; p[i] != NUL && plen >= this_ru_col - 1;
i += (*mb_ptr2len)(p + i))
plen -= (*mb_ptr2cells)(p + i);
if (i > 0)
{
p = p + i - 1;
*p = '<';
++plen;
}
}
else if (plen > this_ru_col - 1)
{
p += plen - (this_ru_col - 1);
*p = '<';
plen = this_ru_col - 1;
}
screen_puts(p, row, wp->w_wincol, attr);
screen_fill(row, row + 1, plen + wp->w_wincol,
this_ru_col + wp->w_wincol, fillchar, fillchar, attr);
if ((NameBufflen = get_keymap_str(wp, (char_u *)"<%s>", NameBuff, MAXPATHL)) > 0
&& (this_ru_col - plen) > (NameBufflen + 1))
screen_puts(NameBuff, row, (int)(this_ru_col - NameBufflen
- 1 + wp->w_wincol), attr);
win_redr_ruler(wp, TRUE, ignore_pum);
// Draw the 'showcmd' information if 'showcmdloc' == "statusline".
if (p_sc && *p_sloc == 's')
{
n = this_ru_col - plen - 2; // perform the calculation here so we only do it once
int width = MIN(10, n);
if (width > 0)
screen_puts_len(showcmd_buf, width, row,
wp->w_wincol + this_ru_col - width - 1, attr);
}
}
/*
* May need to draw the character below the vertical separator.
*/
if (wp->w_vsep_width != 0 && wp->w_status_height != 0 && redrawing())
{
if (stl_connected(wp))
fillchar = fillchar_status(&attr, wp);
else
fillchar = fillchar_vsep(&attr, wp);
screen_putchar(fillchar, row, W_ENDCOL(wp), attr);
}
busy = FALSE;
}
#ifdef FEAT_STL_OPT
/*
* Redraw the status line according to 'statusline' and take care of any
* errors encountered.
*/
static void
redraw_custom_statusline(win_T *wp)
{
static int entered = FALSE;
// When called recursively return. This can happen when the statusline
// contains an expression that triggers a redraw.
if (entered)
return;
entered = TRUE;
win_redr_custom(wp, FALSE);
entered = FALSE;
}
#endif
/*
* Show current status info in ruler and various other places
* If always is FALSE, only show ruler if position has changed.
*/
void
showruler(int always)
{
if (!always && !redrawing())
return;
if (pum_visible())
{
// Don't redraw right now, do it later.
curwin->w_redr_status = TRUE;
return;
}
#if defined(FEAT_STL_OPT)
if ((*p_stl != NUL || *curwin->w_p_stl != NUL) && curwin->w_status_height)
redraw_custom_statusline(curwin);
else
#endif
win_redr_ruler(curwin, always, FALSE);
if (need_maketitle
#ifdef FEAT_STL_OPT
|| (p_icon && (stl_syntax & STL_IN_ICON))
|| (p_title && (stl_syntax & STL_IN_TITLE))
#endif
)
maketitle();
// Redraw the tab pages line if needed.
if (redraw_tabline)
draw_tabline();
}
void
win_redr_ruler(win_T *wp, int always, int ignore_pum)
{
int empty_line = FALSE;
// If 'ruler' off don't do anything
if (!p_ru)
return;
/*
* Check if cursor.lnum is valid, since win_redr_ruler() may be called
* after deleting lines, before cursor.lnum is corrected.
*/
if (wp->w_cursor.lnum > wp->w_buffer->b_ml.ml_line_count)
return;
// Don't draw the ruler while doing insert-completion, it might overwrite
// the (long) mode message.
if (wp == lastwin && lastwin->w_status_height == 0)
if (edit_submode != NULL)
return;
// Don't draw the ruler when the popup menu is visible, it may overlap.
// Except when the popup menu will be redrawn anyway.
if (!ignore_pum && pum_visible())
return;
#ifdef FEAT_STL_OPT
if (*p_ruf)
{
win_redr_custom(wp, TRUE);
return;
}
#endif
/*
* Check if not in Insert mode and the line is empty (will show "0-1").
*/
if ((State & MODE_INSERT) == 0
&& *ml_get_buf(wp->w_buffer, wp->w_cursor.lnum, FALSE) == NUL)
empty_line = TRUE;
/*
* Only draw the ruler when something changed.
*/
validate_virtcol_win(wp);
if ( redraw_cmdline
|| always
|| wp->w_cursor.lnum != wp->w_ru_cursor.lnum
|| wp->w_cursor.col != wp->w_ru_cursor.col
|| wp->w_virtcol != wp->w_ru_virtcol
|| wp->w_cursor.coladd != wp->w_ru_cursor.coladd
|| wp->w_topline != wp->w_ru_topline
|| wp->w_buffer->b_ml.ml_line_count != wp->w_ru_line_count
#ifdef FEAT_DIFF
|| wp->w_topfill != wp->w_ru_topfill
#endif
|| empty_line != wp->w_ru_empty)
{
int row;
int fillchar;
int attr;
int off;
int width;
colnr_T virtcol;
#define RULER_BUF_LEN 70
char_u buffer[RULER_BUF_LEN];
int bufferlen;
char_u rel_pos[RULER_BUF_LEN];
int rel_poslen;
int this_ru_col;
int n1; // scratch value
int n2; // scratch value
cursor_off();
if (wp->w_status_height)
{
row = statusline_row(wp);
fillchar = fillchar_status(&attr, wp);
off = wp->w_wincol;
width = wp->w_width;
}
else
{
row = Rows - 1;
fillchar = ' ';
attr = 0;
width = Columns;
off = 0;
}
// In list mode virtcol needs to be recomputed
virtcol = wp->w_virtcol;
if (wp->w_p_list && wp->w_lcs_chars.tab1 == NUL)
{
wp->w_p_list = FALSE;
getvvcol(wp, &wp->w_cursor, NULL, &virtcol, NULL);
wp->w_p_list = TRUE;
}
bufferlen = vim_snprintf((char *)buffer, RULER_BUF_LEN, "%ld,",
(wp->w_buffer->b_ml.ml_flags & ML_EMPTY)
? 0L
: (long)(wp->w_cursor.lnum));
bufferlen += col_print(buffer + bufferlen, RULER_BUF_LEN - bufferlen,
empty_line ? 0 : (int)wp->w_cursor.col + 1,
(int)virtcol + 1);
/*
* Add a "50%" if there is room for it.
* On the last line, don't print in the last column (scrolls the
* screen up on some terminals).
*/
rel_poslen = get_rel_pos(wp, rel_pos, RULER_BUF_LEN);
n1 = bufferlen + vim_strsize(rel_pos);
if (wp->w_status_height == 0) // can't use last char of screen
++n1;
this_ru_col = ru_col - (Columns - width);
// Never use more than half the window/screen width, leave the other
// half for the filename.
n2 = (width + 1) / 2;
if (this_ru_col < n2)
this_ru_col = n2;
if (this_ru_col + n1 < width)
{
// need at least space for rel_pos + NUL
while (this_ru_col + n1 < width
&& RULER_BUF_LEN > bufferlen + rel_poslen + 1) // +1 for NUL
{
if (has_mbyte)
bufferlen += (*mb_char2bytes)(fillchar, buffer + bufferlen);
else
buffer[bufferlen++] = fillchar;
++n1;
}
bufferlen += vim_snprintf((char *)buffer + bufferlen, RULER_BUF_LEN - bufferlen,
"%s", rel_pos);
}
// Truncate at window boundary.
if (has_mbyte)
{
for (n1 = 0, n2 = 0; buffer[n1] != NUL; n1 += (*mb_ptr2len)(buffer + n1))
{
n2 += (*mb_ptr2cells)(buffer + n1);
if (this_ru_col + n2 > width)
{
bufferlen = n1;
buffer[bufferlen] = NUL;
break;
}
}
}
else if (this_ru_col + bufferlen > width)
{
bufferlen = width - this_ru_col;
buffer[bufferlen] = NUL;
}
screen_puts(buffer, row, this_ru_col + off, attr);
n1 = redraw_cmdline;
screen_fill(row, row + 1,
this_ru_col + off + bufferlen,
(off + width),
fillchar, fillchar, attr);
// don't redraw the cmdline because of showing the ruler
redraw_cmdline = n1;
wp->w_ru_cursor = wp->w_cursor;
wp->w_ru_virtcol = wp->w_virtcol;
wp->w_ru_empty = empty_line;
wp->w_ru_topline = wp->w_topline;
wp->w_ru_line_count = wp->w_buffer->b_ml.ml_line_count;
#ifdef FEAT_DIFF
wp->w_ru_topfill = wp->w_topfill;
#endif
}
}
/*
* To be called when "updating_screen" was set before and now the postponed
* side effects may take place.
*/
void
after_updating_screen(int may_resize_shell UNUSED)
{
updating_screen = FALSE;
#ifdef FEAT_GUI
if (may_resize_shell)
gui_may_resize_shell();
#endif
#ifdef FEAT_TERMINAL
term_check_channel_closed_recently();
#endif
#ifdef HAVE_DROP_FILE
// If handle_drop() was called while updating_screen was TRUE need to
// handle the drop now.
handle_any_postponed_drop();
#endif
}
/*
* Update all windows that are editing the current buffer.
*/
void
update_curbuf(int type)
{
redraw_curbuf_later(type);
update_screen(type);
}
#if defined(FEAT_MENU) || defined(FEAT_FOLDING)
/*
* Copy "text" to ScreenLines using "attr".
* Returns the next screen column.
*/
static int
text_to_screenline(win_T *wp, char_u *text, int col)
{
int off = (int)(current_ScreenLine - ScreenLines);
if (has_mbyte)
{
int cells;
int u8c, u8cc[MAX_MCO];
int i;
int idx;
int c_len;
char_u *p;
# ifdef FEAT_ARABIC
int prev_c = 0; // previous Arabic character
int prev_c1 = 0; // first composing char for prev_c
# endif
# ifdef FEAT_RIGHTLEFT
if (wp->w_p_rl)
idx = off;
else
# endif
idx = off + col;
// Store multibyte characters in ScreenLines[] et al. correctly.
for (p = text; *p != NUL; )
{
cells = (*mb_ptr2cells)(p);
c_len = (*mb_ptr2len)(p);
if (col + cells > wp->w_width
# ifdef FEAT_RIGHTLEFT
- (wp->w_p_rl ? col : 0)
# endif
)
break;
ScreenLines[idx] = *p;
if (enc_utf8)
{
u8c = utfc_ptr2char(p, u8cc);
if (*p < 0x80 && u8cc[0] == 0)
{
ScreenLinesUC[idx] = 0;
#ifdef FEAT_ARABIC
prev_c = u8c;
#endif
}
else
{
#ifdef FEAT_ARABIC
if (p_arshape && !p_tbidi && ARABIC_CHAR(u8c))
{
// Do Arabic shaping.
int pc, pc1, nc;
int pcc[MAX_MCO];
int firstbyte = *p;
// The idea of what is the previous and next
// character depends on 'rightleft'.
if (wp->w_p_rl)
{
pc = prev_c;
pc1 = prev_c1;
nc = utf_ptr2char(p + c_len);
prev_c1 = u8cc[0];
}
else
{
pc = utfc_ptr2char(p + c_len, pcc);
nc = prev_c;
pc1 = pcc[0];
}
prev_c = u8c;
u8c = arabic_shape(u8c, &firstbyte, &u8cc[0],
pc, pc1, nc);
ScreenLines[idx] = firstbyte;
}
else
prev_c = u8c;
#endif
// Non-BMP character: display as ? or fullwidth ?.
ScreenLinesUC[idx] = u8c;
for (i = 0; i < Screen_mco; ++i)
{
ScreenLinesC[i][idx] = u8cc[i];
if (u8cc[i] == 0)
break;
}
}
if (cells > 1)
ScreenLines[idx + 1] = 0;
}
else if (enc_dbcs == DBCS_JPNU && *p == 0x8e)
// double-byte single width character
ScreenLines2[idx] = p[1];
else if (cells > 1)
// double-width character
ScreenLines[idx + 1] = p[1];
col += cells;
idx += cells;
p += c_len;
}
}
else
{
int len = (int)STRLEN(text);
int n = wp->w_width - col;
if (len > n)
len = n;
if (len > 0)
{
#ifdef FEAT_RIGHTLEFT
if (wp->w_p_rl)
mch_memmove(current_ScreenLine, text, len);
else
#endif
mch_memmove(current_ScreenLine + col, text, len);
col += len;
}
}
return col;
}
#endif
#ifdef FEAT_MENU
/*
* Draw the window toolbar.
*/
static void
redraw_win_toolbar(win_T *wp)
{
vimmenu_T *menu;
int item_idx = 0;
int item_count = 0;
int col = 0;
int next_col;
int off = (int)(current_ScreenLine - ScreenLines);
int fill_attr = syn_name2attr((char_u *)"ToolbarLine");
int button_attr = syn_name2attr((char_u *)"ToolbarButton");
vim_free(wp->w_winbar_items);
FOR_ALL_CHILD_MENUS(wp->w_winbar, menu)
++item_count;
wp->w_winbar_items = ALLOC_CLEAR_MULT(winbar_item_T, item_count + 1);
// TODO: use fewer spaces if there is not enough room
for (menu = wp->w_winbar->children;
menu != NULL && col < wp->w_width; menu = menu->next)
{
space_to_screenline(off + col, fill_attr);
if (++col >= wp->w_width)
break;
if (col > 1)
{
space_to_screenline(off + col, fill_attr);
if (++col >= wp->w_width)
break;
}
wp->w_winbar_items[item_idx].wb_startcol = col;
space_to_screenline(off + col, button_attr);
if (++col >= wp->w_width)
break;
next_col = text_to_screenline(wp, menu->name, col);
while (col < next_col)
{
ScreenAttrs[off + col] = button_attr;
++col;
}
wp->w_winbar_items[item_idx].wb_endcol = col;
wp->w_winbar_items[item_idx].wb_menu = menu;
++item_idx;
if (col >= wp->w_width)
break;
space_to_screenline(off + col, button_attr);
++col;
}
while (col < wp->w_width)
{
space_to_screenline(off + col, fill_attr);
++col;
}
wp->w_winbar_items[item_idx].wb_menu = NULL; // end marker
screen_line(wp, wp->w_winrow, wp->w_wincol, wp->w_width, wp->w_width, -1,
0);
}
#endif
#if defined(FEAT_FOLDING) || defined(PROTO)
/*
* Copy "buf[len]" to ScreenLines["off"] and set attributes to "attr".
*/
static void
copy_text_attr(
int off,
char_u *buf,
int len,
int attr)
{
int i;
mch_memmove(ScreenLines + off, buf, (size_t)len);
if (enc_utf8)
vim_memset(ScreenLinesUC + off, 0, sizeof(u8char_T) * (size_t)len);
for (i = 0; i < len; ++i)
ScreenAttrs[off + i] = attr;
}
/*
* Display one folded line.
*/
static void
fold_line(
win_T *wp,
long fold_count,
foldinfo_T *foldinfo,
linenr_T lnum,
int row)
{
// Max value of 'foldcolumn' is 12 and maximum number of bytes in a
// multi-byte character is MAX_MCO.
char_u buf[MAX_MCO * 12 + 1];
pos_T *top, *bot;
linenr_T lnume = lnum + fold_count - 1;
int len;
char_u *text;
int fdc;
int col;
int txtcol;
int off = (int)(current_ScreenLine - ScreenLines);
int ri;
// Build the fold line:
// 1. Add the cmdwin_type for the command-line window
// 2. Add the 'foldcolumn'
// 3. Add the 'number' or 'relativenumber' column
// 4. Compose the text
// 5. Add the text
// 6. set highlighting for the Visual area an other text
col = 0;
// 1. Add the cmdwin_type for the command-line window
// Ignores 'rightleft', this window is never right-left.
if (wp == cmdwin_win)
{
ScreenLines[off] = cmdwin_type;
ScreenAttrs[off] = HL_ATTR(HLF_AT);
if (enc_utf8)
ScreenLinesUC[off] = 0;
++col;
}
#ifdef FEAT_RIGHTLEFT
# define RL_MEMSET(p, v, l) \
do { \
if (wp->w_p_rl) \
for (ri = 0; ri < (l); ++ri) \
ScreenAttrs[off + (wp->w_width - (p) - (l)) + ri] = v; \
else \
for (ri = 0; ri < (l); ++ri) \
ScreenAttrs[off + (p) + ri] = v; \
} while (0)
#else
# define RL_MEMSET(p, v, l) \
do { \
for (ri = 0; ri < l; ++ri) \
ScreenAttrs[off + (p) + ri] = v; \
} while (0)
#endif
// 2. Add the 'foldcolumn'
// Reduce the width when there is not enough space.
fdc = compute_foldcolumn(wp, col);
if (fdc > 0)
{
char_u *p;
int i;
int idx;
fill_foldcolumn(buf, wp, TRUE, lnum);
p = buf;
for (i = 0; i < fdc; i++)
{
int ch;
if (has_mbyte)
ch = mb_ptr2char_adv(&p);
else
ch = *p++;
#ifdef FEAT_RIGHTLEFT
if (wp->w_p_rl)
idx = off + wp->w_width - i - 1 - col;
else
#endif
idx = off + col + i;
if (enc_utf8)
{
if (ch >= 0x80)
{
ScreenLinesUC[idx] = ch;
ScreenLinesC[0][idx] = 0;
ScreenLines[idx] = 0x80;
}
else
{
ScreenLines[idx] = ch;
ScreenLinesUC[idx] = 0;
}
}
else
ScreenLines[idx] = ch;
}
RL_MEMSET(col, HL_ATTR(HLF_FC), fdc);
col += fdc;
}
// Set all attributes of the 'number' or 'relativenumber' column and the
// text
RL_MEMSET(col, HL_ATTR(HLF_FL), wp->w_width - col);
#ifdef FEAT_SIGNS
// If signs are being displayed, add two spaces.
if (signcolumn_on(wp))
{
len = wp->w_width - col;
if (len > 0)
{
if (len > 2)
len = 2;
# ifdef FEAT_RIGHTLEFT
if (wp->w_p_rl)
// the line number isn't reversed
copy_text_attr(off + wp->w_width - len - col,
(char_u *)" ", len, HL_ATTR(HLF_FL));
else
# endif
copy_text_attr(off + col, (char_u *)" ", len, HL_ATTR(HLF_FL));
col += len;
}
}
#endif
// 3. Add the 'number' or 'relativenumber' column
if (wp->w_p_nu || wp->w_p_rnu)
{
len = wp->w_width - col;
if (len > 0)
{
int w = number_width(wp);
long num;
char *fmt = "%*ld ";
if (len > w + 1)
len = w + 1;
if (wp->w_p_nu && !wp->w_p_rnu)
// 'number' + 'norelativenumber'
num = (long)lnum;
else
{
// 'relativenumber', don't use negative numbers
num = labs((long)get_cursor_rel_lnum(wp, lnum));
if (num == 0 && wp->w_p_nu && wp->w_p_rnu)
{
// 'number' + 'relativenumber': cursor line shows absolute
// line number
num = lnum;
fmt = "%-*ld ";
}
}
vim_snprintf((char *)buf, sizeof(buf), fmt, w, num);
#ifdef FEAT_RIGHTLEFT
if (wp->w_p_rl)
// the line number isn't reversed
copy_text_attr(off + wp->w_width - len - col, buf, len,
HL_ATTR(HLF_FL));
else
#endif
copy_text_attr(off + col, buf, len, HL_ATTR(HLF_FL));
col += len;
}
}
// 4. Compose the folded-line string with 'foldtext', if set.
text = get_foldtext(wp, lnum, lnume, foldinfo, buf);
txtcol = col; // remember where text starts
// 5. move the text to current_ScreenLine. Fill up with "fold" from
// 'fillchars'.
// Right-left text is put in columns 0 - number-col, normal text is put
// in columns number-col - window-width.
col = text_to_screenline(wp, text, col);
// Fill the rest of the line with the fold filler
#ifdef FEAT_RIGHTLEFT
if (wp->w_p_rl)
col -= txtcol;
#endif
while (col < wp->w_width
#ifdef FEAT_RIGHTLEFT
- (wp->w_p_rl ? txtcol : 0)
#endif
)
{
int c = wp->w_fill_chars.fold;
if (enc_utf8)
{
if (c >= 0x80)
{
ScreenLinesUC[off + col] = c;
ScreenLinesC[0][off + col] = 0;
ScreenLines[off + col] = 0x80; // avoid storing zero
}
else
{
ScreenLinesUC[off + col] = 0;
ScreenLines[off + col] = c;
}
col++;
}
else
ScreenLines[off + col++] = c;
}
if (text != buf)
vim_free(text);
// 6. set highlighting for the Visual area an other text.
// If all folded lines are in the Visual area, highlight the line.
if (VIsual_active && wp->w_buffer == curwin->w_buffer)
{
if (LTOREQ_POS(curwin->w_cursor, VIsual))
{
// Visual is after curwin->w_cursor
top = &curwin->w_cursor;
bot = &VIsual;
}
else
{
// Visual is before curwin->w_cursor
top = &VIsual;
bot = &curwin->w_cursor;
}
if (lnum >= top->lnum
&& lnume <= bot->lnum
&& (VIsual_mode != 'v'
|| ((lnum > top->lnum
|| (lnum == top->lnum
&& top->col == 0))
&& (lnume < bot->lnum
|| (lnume == bot->lnum
&& (bot->col - (*p_sel == 'e'))
>= ml_get_buf_len(wp->w_buffer, lnume))))))
{
if (VIsual_mode == Ctrl_V)
{
// Visual block mode: highlight the chars part of the block
if (wp->w_old_cursor_fcol + txtcol < (colnr_T)wp->w_width)
{
if (wp->w_old_cursor_lcol != MAXCOL
&& wp->w_old_cursor_lcol + txtcol
< (colnr_T)wp->w_width)
len = wp->w_old_cursor_lcol;
else
len = wp->w_width - txtcol;
RL_MEMSET(wp->w_old_cursor_fcol + txtcol, HL_ATTR(HLF_V),
len - (int)wp->w_old_cursor_fcol);
}
}
else
{
// Set all attributes of the text
RL_MEMSET(txtcol, HL_ATTR(HLF_V), wp->w_width - txtcol);
}
}
}
#ifdef FEAT_SYN_HL
// Show colorcolumn in the fold line, but let cursorcolumn override it.
if (wp->w_p_cc_cols)
{
int i = 0;
int j = wp->w_p_cc_cols[i];
int old_txtcol = txtcol;
while (j > -1)
{
txtcol += j;
if (wp->w_p_wrap)
txtcol -= wp->w_skipcol;
else
txtcol -= wp->w_leftcol;
if (txtcol >= 0 && txtcol < wp->w_width)
ScreenAttrs[off + txtcol] = hl_combine_attr(
ScreenAttrs[off + txtcol], HL_ATTR(HLF_MC));
txtcol = old_txtcol;
j = wp->w_p_cc_cols[++i];
}
}
// Show 'cursorcolumn' in the fold line.
if (wp->w_p_cuc)
{
txtcol += wp->w_virtcol;
if (wp->w_p_wrap)
txtcol -= wp->w_skipcol;
else
txtcol -= wp->w_leftcol;
if (txtcol >= 0 && txtcol < wp->w_width)
ScreenAttrs[off + txtcol] = hl_combine_attr(
ScreenAttrs[off + txtcol], HL_ATTR(HLF_CUC));
}
#endif
screen_line(wp, row + W_WINROW(wp), wp->w_wincol,
wp->w_width, wp->w_width, -1, 0);
// Update w_cline_height and w_cline_folded if the cursor line was
// updated (saves a call to plines() later).
if (wp == curwin
&& lnum <= curwin->w_cursor.lnum
&& lnume >= curwin->w_cursor.lnum)
{
curwin->w_cline_row = row;
curwin->w_cline_height = 1;
curwin->w_cline_folded = TRUE;
curwin->w_valid |= (VALID_CHEIGHT|VALID_CROW);
}
# ifdef FEAT_CONCEAL
// When the line was not folded w_wrow may have been set, recompute it.
if (wp == curwin
&& wp->w_cursor.lnum >= lnum
&& wp->w_cursor.lnum <= lnume
&& conceal_cursor_line(wp))
curs_columns(TRUE);
# endif
}
#endif
/*
* Update a single window.
*
* This may cause the windows below it also to be redrawn (when clearing the
* screen or scrolling lines).
*
* How the window is redrawn depends on wp->w_redr_type. Each type also
* implies the one below it.
* UPD_NOT_VALID redraw the whole window
* UPD_SOME_VALID redraw the whole window but do scroll when possible
* UPD_REDRAW_TOP redraw the top w_upd_rows window lines, otherwise like
* UPD_VALID
* UPD_INVERTED redraw the changed part of the Visual area
* UPD_INVERTED_ALL redraw the whole Visual area
* UPD_VALID 1. scroll up/down to adjust for a changed w_topline
* 2. update lines at the top when scrolled down
* 3. redraw changed text:
* - if wp->w_buffer->b_mod_set set, update lines between
* b_mod_top and b_mod_bot.
* - if wp->w_redraw_top non-zero, redraw lines between
* wp->w_redraw_top and wp->w_redraw_bot.
* - continue redrawing when syntax status is invalid.
* 4. if scrolled up, update lines at the bottom.
* This results in three areas that may need updating:
* top: from first row to top_end (when scrolled down)
* mid: from mid_start to mid_end (update inversion or changed text)
* bot: from bot_start to last row (when scrolled up)
*/
static void
win_update(win_T *wp)
{
buf_T *buf = wp->w_buffer;
int type;
int top_end = 0; // Below last row of the top area that needs
// updating. 0 when no top area updating.
int mid_start = 999;// first row of the mid area that needs
// updating. 999 when no mid area updating.
int mid_end = 0; // Below last row of the mid area that needs
// updating. 0 when no mid area updating.
int bot_start = 999;// first row of the bot area that needs
// updating. 999 when no bot area updating
int scrolled_down = FALSE; // TRUE when scrolled down when
// w_topline got smaller a bit
#ifdef FEAT_SEARCH_EXTRA
int top_to_mod = FALSE; // redraw above mod_top
#endif
int row; // current window row to display
linenr_T lnum; // current buffer lnum to display
int idx; // current index in w_lines[]
int srow; // starting row of the current line
int eof = FALSE; // if TRUE, we hit the end of the file
int didline = FALSE; // if TRUE, we finished the last line
int i;
long j;
static int recursive = FALSE; // being called recursively
linenr_T old_botline = wp->w_botline;
#ifdef FEAT_CONCEAL
int old_wrow = wp->w_wrow;
int old_wcol = wp->w_wcol;
#endif
#ifdef FEAT_FOLDING
long fold_count;
#endif
#ifdef FEAT_SYN_HL
// remember what happened to the previous line, to know if
// check_visual_highlight() can be used
# define DID_NONE 1 // didn't update a line
# define DID_LINE 2 // updated a normal line
# define DID_FOLD 3 // updated a folded line
int did_update = DID_NONE;
linenr_T syntax_last_parsed = 0; // last parsed text line
#endif
linenr_T mod_top = 0;
linenr_T mod_bot = 0;
#if defined(FEAT_SYN_HL) || defined(FEAT_SEARCH_EXTRA)
int save_got_int;
#endif
#if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_CLIPBOARD)
// This needs to be done only for the first window when update_screen() is
// called.
if (!did_update_one_window)
{
did_update_one_window = TRUE;
# ifdef FEAT_SEARCH_EXTRA
start_search_hl();
# endif
# ifdef FEAT_CLIPBOARD
// When Visual area changed, may have to update selection.
if (clip_star.available && clip_isautosel_star())
clip_update_selection(&clip_star);
if (clip_plus.available && clip_isautosel_plus())
clip_update_selection(&clip_plus);
# endif
}
#endif
type = wp->w_redr_type;
if (type == UPD_NOT_VALID)
{
wp->w_redr_status = TRUE;
wp->w_lines_valid = 0;
}
// Window frame is zero-height: nothing to draw.
if (wp->w_height + WINBAR_HEIGHT(wp) == 0
|| (wp->w_frame->fr_height == wp->w_status_height
#if defined(FEAT_PROP_POPUP)
&& !popup_is_popup(wp)
#endif
))
{
wp->w_redr_type = 0;
return;
}
// Window is zero-width: Only need to draw the separator.
if (wp->w_width == 0)
{
// draw the vertical separator right of this window
draw_vsep_win(wp, 0);
wp->w_redr_type = 0;
return;
}
#ifdef FEAT_TERMINAL
// If this window contains a terminal, redraw works completely differently.
if (term_do_update_window(wp))
{
term_update_window(wp);
# ifdef FEAT_MENU
// Draw the window toolbar, if there is one.
if (winbar_height(wp) > 0)
redraw_win_toolbar(wp);
# endif
wp->w_redr_type = 0;
return;
}
#endif
#ifdef FEAT_SEARCH_EXTRA
init_search_hl(wp, &screen_search_hl);
#endif
// Make sure skipcol is valid, it depends on various options and the window
// width.
if (wp->w_skipcol > 0 && wp->w_width > win_col_off(wp))
{
int w = 0;
int width1 = wp->w_width - win_col_off(wp);
int width2 = width1 + win_col_off2(wp);
int add = width1;
while (w < wp->w_skipcol)
{
if (w > 0)
add = width2;
w += add;
}
if (w != wp->w_skipcol)
// always round down, the higher value may not be valid
wp->w_skipcol = w - add;
}
#ifdef FEAT_LINEBREAK
// Force redraw when width of 'number' or 'relativenumber' column
// changes.
i = (wp->w_p_nu || wp->w_p_rnu) ? number_width(wp) : 0;
if (wp->w_nrwidth != i)
{
type = UPD_NOT_VALID;
wp->w_nrwidth = i;
}
else
#endif
{
// Set mod_top to the first line that needs displaying because of
// changes. Set mod_bot to the first line after the changes.
mod_top = wp->w_redraw_top;
if (wp->w_redraw_bot != 0)
mod_bot = wp->w_redraw_bot + 1;
else
mod_bot = 0;
if (buf->b_mod_set)
{
if (mod_top == 0 || mod_top > buf->b_mod_top)
{
mod_top = buf->b_mod_top;
#ifdef FEAT_SYN_HL
// Need to redraw lines above the change that may be included
// in a pattern match.
if (syntax_present(wp))
{
mod_top -= buf->b_s.b_syn_sync_linebreaks;
if (mod_top < 1)
mod_top = 1;
}
#endif
}
if (mod_bot == 0 || mod_bot < buf->b_mod_bot)
mod_bot = buf->b_mod_bot;
#ifdef FEAT_SEARCH_EXTRA
// When 'hlsearch' is on and using a multi-line search pattern, a
// change in one line may make the Search highlighting in a
// previous line invalid. Simple solution: redraw all visible
// lines above the change.
// Same for a match pattern.
if (screen_search_hl.rm.regprog != NULL
&& re_multiline(screen_search_hl.rm.regprog))
top_to_mod = TRUE;
else
{
matchitem_T *cur = wp->w_match_head;
while (cur != NULL)
{
if (cur->mit_match.regprog != NULL
&& re_multiline(cur->mit_match.regprog))
{
top_to_mod = TRUE;
break;
}
cur = cur->mit_next;
}
}
#endif
}
#ifdef FEAT_SEARCH_EXTRA
if (search_hl_has_cursor_lnum > 0)
{
// CurSearch was used last time, need to redraw the line with it to
// avoid having two matches highlighted with CurSearch.
if (mod_top == 0 || mod_top > search_hl_has_cursor_lnum)
mod_top = search_hl_has_cursor_lnum;
if (mod_bot == 0 || mod_bot < search_hl_has_cursor_lnum + 1)
mod_bot = search_hl_has_cursor_lnum + 1;
}
#endif
#ifdef FEAT_FOLDING
if (mod_top != 0 && hasAnyFolding(wp))
{
linenr_T lnumt, lnumb;
// A change in a line can cause lines above it to become folded or
// unfolded. Find the top most buffer line that may be affected.
// If the line was previously folded and displayed, get the first
// line of that fold. If the line is folded now, get the first
// folded line. Use the minimum of these two.
// Find last valid w_lines[] entry above mod_top. Set lnumt to
// the line below it. If there is no valid entry, use w_topline.
// Find the first valid w_lines[] entry below mod_bot. Set lnumb
// to this line. If there is no valid entry, use MAXLNUM.
lnumt = wp->w_topline;
lnumb = MAXLNUM;
for (i = 0; i < wp->w_lines_valid; ++i)
if (wp->w_lines[i].wl_valid)
{
if (wp->w_lines[i].wl_lastlnum < mod_top)
lnumt = wp->w_lines[i].wl_lastlnum + 1;
if (lnumb == MAXLNUM && wp->w_lines[i].wl_lnum >= mod_bot)
{
lnumb = wp->w_lines[i].wl_lnum;
// When there is a fold column it might need updating
// in the next line ("J" just above an open fold).
if (compute_foldcolumn(wp, 0) > 0)
++lnumb;
}
}
(void)hasFoldingWin(wp, mod_top, &mod_top, NULL, TRUE, NULL);
if (mod_top > lnumt)
mod_top = lnumt;
// Now do the same for the bottom line (one above mod_bot).
--mod_bot;
(void)hasFoldingWin(wp, mod_bot, NULL, &mod_bot, TRUE, NULL);
++mod_bot;
if (mod_bot < lnumb)
mod_bot = lnumb;
}
#endif
// When a change starts above w_topline and the end is below
// w_topline, start redrawing at w_topline.
// If the end of the change is above w_topline: do like no change was
// made, but redraw the first line to find changes in syntax.
if (mod_top != 0 && mod_top < wp->w_topline)
{
if (mod_bot > wp->w_topline)
mod_top = wp->w_topline;
#ifdef FEAT_SYN_HL
else if (syntax_present(wp))
top_end = 1;
#endif
}
}
wp->w_redraw_top = 0; // reset for next time
wp->w_redraw_bot = 0;
#ifdef FEAT_SEARCH_EXTRA
search_hl_has_cursor_lnum = 0;
#endif
// When only displaying the lines at the top, set top_end. Used when
// window has scrolled down for msg_scrolled.
if (type == UPD_REDRAW_TOP)
{
j = 0;
for (i = 0; i < wp->w_lines_valid; ++i)
{
j += wp->w_lines[i].wl_size;
if (j >= wp->w_upd_rows)
{
top_end = j;
break;
}
}
if (top_end == 0)
// not found (cannot happen?): redraw everything
type = UPD_NOT_VALID;
else
// top area defined, the rest is UPD_VALID
type = UPD_VALID;
}
// Trick: we want to avoid clearing the screen twice. screenclear() will
// set "screen_cleared" to TRUE. The special value MAYBE (which is still
// non-zero and thus not FALSE) will indicate that screenclear() was not
// called.
if (screen_cleared)
screen_cleared = MAYBE;
// If there are no changes on the screen that require a complete redraw,
// handle three cases:
// 1: we are off the top of the screen by a few lines: scroll down
// 2: wp->w_topline is below wp->w_lines[0].wl_lnum: may scroll up
// 3: wp->w_topline is wp->w_lines[0].wl_lnum: find first entry in
// w_lines[] that needs updating.
if ((type == UPD_VALID || type == UPD_SOME_VALID
|| type == UPD_INVERTED || type == UPD_INVERTED_ALL)
#ifdef FEAT_DIFF
&& !wp->w_botfill && !wp->w_old_botfill
#endif
)
{
if (mod_top != 0
&& wp->w_topline == mod_top
&& (!wp->w_lines[0].wl_valid
|| wp->w_topline == wp->w_lines[0].wl_lnum))
{
// w_topline is the first changed line and window is not scrolled,
// the scrolling from changed lines will be done further down.
}
else if (wp->w_lines[0].wl_valid
&& (wp->w_topline < wp->w_lines[0].wl_lnum
#ifdef FEAT_DIFF
|| (wp->w_topline == wp->w_lines[0].wl_lnum
&& wp->w_topfill > wp->w_old_topfill)
#endif
))
{
// New topline is above old topline: May scroll down.
#ifdef FEAT_FOLDING
if (hasAnyFolding(wp))
{
linenr_T ln;
// count the number of lines we are off, counting a sequence
// of folded lines as one
j = 0;
for (ln = wp->w_topline; ln < wp->w_lines[0].wl_lnum; ++ln)
{
++j;
if (j >= wp->w_height - 2)
break;
(void)hasFoldingWin(wp, ln, NULL, &ln, TRUE, NULL);
}
}
else
#endif
j = wp->w_lines[0].wl_lnum - wp->w_topline;
if (j < wp->w_height - 2) // not too far off
{
i = plines_m_win(wp, wp->w_topline, wp->w_lines[0].wl_lnum - 1,
wp->w_height);
#ifdef FEAT_DIFF
// insert extra lines for previously invisible filler lines
if (wp->w_lines[0].wl_lnum != wp->w_topline)
i += diff_check_fill(wp, wp->w_lines[0].wl_lnum)
- wp->w_old_topfill;
#endif
if (i < wp->w_height - 2) // less than a screen off
{
// Try to insert the correct number of lines.
// If not the last window, delete the lines at the bottom.
// win_ins_lines may fail when the terminal can't do it.
if (i > 0)
check_for_delay(FALSE);
if (win_ins_lines(wp, 0, i, FALSE, wp == firstwin) == OK)
{
if (wp->w_lines_valid != 0)
{
// Need to update rows that are new, stop at the
// first one that scrolled down.
top_end = i;
scrolled_down = TRUE;
// Move the entries that were scrolled, disable
// the entries for the lines to be redrawn.
if ((wp->w_lines_valid += j) > wp->w_height)
wp->w_lines_valid = wp->w_height;
for (idx = wp->w_lines_valid; idx - j >= 0; idx--)
wp->w_lines[idx] = wp->w_lines[idx - j];
while (idx >= 0)
wp->w_lines[idx--].wl_valid = FALSE;
}
}
else
mid_start = 0; // redraw all lines
}
else
mid_start = 0; // redraw all lines
}
else
mid_start = 0; // redraw all lines
}
else
{
// New topline is at or below old topline: May scroll up.
// When topline didn't change, find first entry in w_lines[] that
// needs updating.
// Try to find wp->w_topline in wp->w_lines[].wl_lnum. The check
// for "Rows" is in case "wl_size" is incorrect somehow.
j = -1;
row = 0;
for (i = 0; i < wp->w_lines_valid && i < Rows; i++)
{
if (wp->w_lines[i].wl_valid
&& wp->w_lines[i].wl_lnum == wp->w_topline)
{
j = i;
break;
}
row += wp->w_lines[i].wl_size;
}
if (j == -1)
{
// if wp->w_topline is not in wp->w_lines[].wl_lnum redraw all
// lines
mid_start = 0;
}
else
{
// Try to delete the correct number of lines.
// wp->w_topline is at wp->w_lines[i].wl_lnum.
#ifdef FEAT_DIFF
// If the topline didn't change, delete old filler lines,
// otherwise delete filler lines of the new topline...
if (wp->w_lines[0].wl_lnum == wp->w_topline)
row += wp->w_old_topfill;
else
row += diff_check_fill(wp, wp->w_topline);
// ... but don't delete new filler lines.
row -= wp->w_topfill;
#endif
if (row > Rows) // just in case
row = Rows;
if (row > 0)
{
check_for_delay(FALSE);
if (win_del_lines(wp, 0, row, FALSE, wp == firstwin, 0)
== OK)
bot_start = wp->w_height - row;
else
mid_start = 0; // redraw all lines
}
if ((row == 0 || bot_start < 999) && wp->w_lines_valid != 0)
{
// Skip the lines (below the deleted lines) that are still
// valid and don't need redrawing. Copy their info
// upwards, to compensate for the deleted lines. Set
// bot_start to the first row that needs redrawing.
bot_start = 0;
idx = 0;
for (;;)
{
wp->w_lines[idx] = wp->w_lines[j];
// stop at line that didn't fit, unless it is still
// valid (no lines deleted)
if (row > 0 && bot_start + row
+ (int)wp->w_lines[j].wl_size > wp->w_height)
{
wp->w_lines_valid = idx + 1;
break;
}
bot_start += wp->w_lines[idx++].wl_size;
// stop at the last valid entry in w_lines[].wl_size
if (++j >= wp->w_lines_valid)
{
wp->w_lines_valid = idx;
break;
}
}
#ifdef FEAT_DIFF
// Correct the first entry for filler lines at the top
// when it won't get updated below.
if (wp->w_p_diff && bot_start > 0)
{
int n = plines_win_nofill(wp, wp->w_topline, FALSE)
+ wp->w_topfill - adjust_plines_for_skipcol(wp);
if (n > wp->w_height)
n = wp->w_height;
wp->w_lines[0].wl_size = n;
}
#endif
}
}
}
// When starting redraw in the first line, redraw all lines.
if (mid_start == 0)
mid_end = wp->w_height;
// When win_del_lines() or win_ins_lines() caused the screen to be
// cleared (only happens for the first window) or when screenclear()
// was called directly above, "must_redraw" will have been set to
// UPD_NOT_VALID, need to reset it here to avoid redrawing twice.
if (screen_cleared == TRUE)
must_redraw = 0;
}
else
{
// Not UPD_VALID or UPD_INVERTED: redraw all lines.
mid_start = 0;
mid_end = wp->w_height;
}
if (type == UPD_SOME_VALID)
{
// UPD_SOME_VALID: redraw all lines.
mid_start = 0;
mid_end = wp->w_height;
type = UPD_NOT_VALID;
}
// check if we are updating or removing the inverted part
if ((VIsual_active && buf == curwin->w_buffer)
|| (wp->w_old_cursor_lnum != 0 && type != UPD_NOT_VALID))
{
linenr_T from, to;
if (VIsual_active)
{
if (VIsual_mode != wp->w_old_visual_mode
|| type == UPD_INVERTED_ALL)
{
// If the type of Visual selection changed, redraw the whole
// selection. Also when the ownership of the X selection is
// gained or lost.
if (curwin->w_cursor.lnum < VIsual.lnum)
{
from = curwin->w_cursor.lnum;
to = VIsual.lnum;
}
else
{
from = VIsual.lnum;
to = curwin->w_cursor.lnum;
}
// redraw more when the cursor moved as well
if (wp->w_old_cursor_lnum < from)
from = wp->w_old_cursor_lnum;
if (wp->w_old_cursor_lnum > to)
to = wp->w_old_cursor_lnum;
if (wp->w_old_visual_lnum < from)
from = wp->w_old_visual_lnum;
if (wp->w_old_visual_lnum > to)
to = wp->w_old_visual_lnum;
}
else
{
// Find the line numbers that need to be updated: The lines
// between the old cursor position and the current cursor
// position. Also check if the Visual position changed.
if (curwin->w_cursor.lnum < wp->w_old_cursor_lnum)
{
from = curwin->w_cursor.lnum;
to = wp->w_old_cursor_lnum;
}
else
{
from = wp->w_old_cursor_lnum;
to = curwin->w_cursor.lnum;
if (from == 0) // Visual mode just started
from = to;
}
if (VIsual.lnum != wp->w_old_visual_lnum
|| VIsual.col != wp->w_old_visual_col)
{
if (wp->w_old_visual_lnum < from
&& wp->w_old_visual_lnum != 0)
from = wp->w_old_visual_lnum;
if (wp->w_old_visual_lnum > to)
to = wp->w_old_visual_lnum;
if (VIsual.lnum < from)
from = VIsual.lnum;
if (VIsual.lnum > to)
to = VIsual.lnum;
}
}
// If in block mode and changed column or curwin->w_curswant:
// update all lines.
// First compute the actual start and end column.
if (VIsual_mode == Ctrl_V)
{
colnr_T fromc, toc;
#if defined(FEAT_LINEBREAK)
int save_ve_flags = curwin->w_ve_flags;
if (curwin->w_p_lbr)
curwin->w_ve_flags = VE_ALL;
#endif
getvcols(wp, &VIsual, &curwin->w_cursor, &fromc, &toc);
++toc;
#if defined(FEAT_LINEBREAK)
curwin->w_ve_flags = save_ve_flags;
#endif
// Highlight to the end of the line, unless 'virtualedit' has
// "block".
if (curwin->w_curswant == MAXCOL)
{
if (get_ve_flags() & VE_BLOCK)
{
pos_T pos;
int cursor_above =
curwin->w_cursor.lnum < VIsual.lnum;
// Need to find the longest line.
toc = 0;
pos.coladd = 0;
for (pos.lnum = curwin->w_cursor.lnum; cursor_above
? pos.lnum <= VIsual.lnum
: pos.lnum >= VIsual.lnum;
pos.lnum += cursor_above ? 1 : -1)
{
colnr_T t;
pos.col = (int)ml_get_buf_len(wp->w_buffer, pos.lnum);
getvvcol(wp, &pos, NULL, NULL, &t);
if (toc < t)
toc = t;
}
++toc;
}
else
toc = MAXCOL;
}
if (fromc != wp->w_old_cursor_fcol
|| toc != wp->w_old_cursor_lcol)
{
if (from > VIsual.lnum)
from = VIsual.lnum;
if (to < VIsual.lnum)
to = VIsual.lnum;
}
wp->w_old_cursor_fcol = fromc;
wp->w_old_cursor_lcol = toc;
}
}
else
{
// Use the line numbers of the old Visual area.
if (wp->w_old_cursor_lnum < wp->w_old_visual_lnum)
{
from = wp->w_old_cursor_lnum;
to = wp->w_old_visual_lnum;
}
else
{
from = wp->w_old_visual_lnum;
to = wp->w_old_cursor_lnum;
}
}
// There is no need to update lines above the top of the window.
if (from < wp->w_topline)
from = wp->w_topline;
// If we know the value of w_botline, use it to restrict the update to
// the lines that are visible in the window.
if (wp->w_valid & VALID_BOTLINE)
{
if (from >= wp->w_botline)
from = wp->w_botline - 1;
if (to >= wp->w_botline)
to = wp->w_botline - 1;
}
// Find the minimal part to be updated.
// Watch out for scrolling that made entries in w_lines[] invalid.
// E.g., CTRL-U makes the first half of w_lines[] invalid and sets
// top_end; need to redraw from top_end to the "to" line.
// A middle mouse click with a Visual selection may change the text
// above the Visual area and reset wl_valid, do count these for
// mid_end (in srow).
if (mid_start > 0)
{
lnum = wp->w_topline;
idx = 0;
srow = 0;
if (scrolled_down)
mid_start = top_end;
else
mid_start = 0;
while (lnum < from && idx < wp->w_lines_valid) // find start
{
if (wp->w_lines[idx].wl_valid)
mid_start += wp->w_lines[idx].wl_size;
else if (!scrolled_down)
srow += wp->w_lines[idx].wl_size;
++idx;
# ifdef FEAT_FOLDING
if (idx < wp->w_lines_valid && wp->w_lines[idx].wl_valid)
lnum = wp->w_lines[idx].wl_lnum;
else
# endif
++lnum;
}
srow += mid_start;
mid_end = wp->w_height;
for ( ; idx < wp->w_lines_valid; ++idx) // find end
{
if (wp->w_lines[idx].wl_valid
&& wp->w_lines[idx].wl_lnum >= to + 1)
{
// Only update until first row of this line
mid_end = srow;
break;
}
srow += wp->w_lines[idx].wl_size;
}
}
}
if (VIsual_active && buf == curwin->w_buffer)
{
wp->w_old_visual_mode = VIsual_mode;
wp->w_old_cursor_lnum = curwin->w_cursor.lnum;
wp->w_old_visual_lnum = VIsual.lnum;
wp->w_old_visual_col = VIsual.col;
wp->w_old_curswant = curwin->w_curswant;
}
else
{
wp->w_old_visual_mode = 0;
wp->w_old_cursor_lnum = 0;
wp->w_old_visual_lnum = 0;
wp->w_old_visual_col = 0;
}
#if defined(FEAT_SYN_HL) || defined(FEAT_SEARCH_EXTRA)
// reset got_int, otherwise regexp won't work
save_got_int = got_int;
got_int = 0;
#endif
#ifdef SYN_TIME_LIMIT
// Set the time limit to 'redrawtime'.
redrawtime_limit_set = TRUE;
init_regexp_timeout(p_rdt);
#endif
#ifdef FEAT_FOLDING
win_foldinfo.fi_level = 0;
#endif
#ifdef FEAT_MENU
// Draw the window toolbar, if there is one.
// TODO: only when needed.
if (winbar_height(wp) > 0)
redraw_win_toolbar(wp);
#endif
lnum = wp->w_topline; // first line shown in window
spellvars_T spv;
#ifdef FEAT_SPELL
// Initialize spell related variables for the first drawn line.
CLEAR_FIELD(spv);
if (spell_check_window(wp))
{
spv.spv_has_spell = TRUE;
spv.spv_unchanged = mod_top == 0;
}
#endif
// Update all the window rows.
idx = 0; // first entry in w_lines[].wl_size
row = 0;
srow = 0;
for (;;)
{
// stop updating when reached the end of the window (check for _past_
// the end of the window is at the end of the loop)
if (row == wp->w_height)
{
didline = TRUE;
break;
}
// stop updating when hit the end of the file
if (lnum > buf->b_ml.ml_line_count)
{
eof = TRUE;
break;
}
// Remember the starting row of the line that is going to be dealt
// with. It is used further down when the line doesn't fit.
srow = row;
// Update a line when it is in an area that needs updating, when it
// has changes or w_lines[idx] is invalid.
// "bot_start" may be halfway a wrapped line after using
// win_del_lines(), check if the current line includes it.
// When syntax folding is being used, the saved syntax states will
// already have been updated, we can't see where the syntax state is
// the same again, just update until the end of the window.
if (row < top_end
|| (row >= mid_start && row < mid_end)
#ifdef FEAT_SEARCH_EXTRA
|| top_to_mod
#endif
|| idx >= wp->w_lines_valid
|| (row + wp->w_lines[idx].wl_size > bot_start)
|| (mod_top != 0
&& (lnum == mod_top
|| (lnum >= mod_top
&& (lnum < mod_bot
#ifdef FEAT_SYN_HL
|| did_update == DID_FOLD
|| (did_update == DID_LINE
&& syntax_present(wp)
&& (
# ifdef FEAT_FOLDING
(foldmethodIsSyntax(wp)
&& hasAnyFolding(wp)) ||
# endif
syntax_check_changed(lnum)))
#endif
#ifdef FEAT_SEARCH_EXTRA
// match in fixed position might need redraw
// if lines were inserted or deleted
|| (wp->w_match_head != NULL
&& buf->b_mod_set
&& buf->b_mod_xlines != 0)
#endif
))))
#ifdef FEAT_SYN_HL
|| (wp->w_p_cul && lnum == wp->w_cursor.lnum)
|| lnum == wp->w_last_cursorline
#endif
)
{
#ifdef FEAT_SEARCH_EXTRA
if (lnum == mod_top)
top_to_mod = FALSE;
#endif
// When at start of changed lines: May scroll following lines
// up or down to minimize redrawing.
// Don't do this when the change continues until the end.
// Don't scroll when dollar_vcol >= 0, keep the "$".
// Don't scroll when redrawing the top, scrolled already above.
if (lnum == mod_top
&& mod_bot != MAXLNUM
&& !(dollar_vcol >= 0 && mod_bot == mod_top + 1)
&& row >= top_end)
{
int old_rows = 0;
int new_rows = 0;
int xtra_rows;
linenr_T l;
// Count the old number of window rows, using w_lines[], which
// should still contain the sizes for the lines as they are
// currently displayed.
for (i = idx; i < wp->w_lines_valid; ++i)
{
// Only valid lines have a meaningful wl_lnum. Invalid
// lines are part of the changed area.
if (wp->w_lines[i].wl_valid
&& wp->w_lines[i].wl_lnum == mod_bot)
break;
old_rows += wp->w_lines[i].wl_size;
#ifdef FEAT_FOLDING
if (wp->w_lines[i].wl_valid
&& wp->w_lines[i].wl_lastlnum + 1 == mod_bot)
{
// Must have found the last valid entry above mod_bot.
// Add following invalid entries.
++i;
while (i < wp->w_lines_valid
&& !wp->w_lines[i].wl_valid)
old_rows += wp->w_lines[i++].wl_size;
break;
}
#endif
}
if (i >= wp->w_lines_valid)
{
// We can't find a valid line below the changed lines,
// need to redraw until the end of the window.
// Inserting/deleting lines has no use.
bot_start = 0;
}
else
{
// Able to count old number of rows: Count new window
// rows, and may insert/delete lines
j = idx;
for (l = lnum; l < mod_bot; ++l)
{
#ifdef FEAT_FOLDING
if (hasFoldingWin(wp, l, NULL, &l, TRUE, NULL))
++new_rows;
else
#endif
{
#ifdef FEAT_DIFF
if (l == wp->w_topline)
{
int n = plines_win_nofill(wp, l, FALSE)
+ wp->w_topfill;
n -= adjust_plines_for_skipcol(wp);
if (n > wp->w_height)
n = wp->w_height;
new_rows += n;
}
else
#endif
new_rows += plines_win(wp, l, TRUE);
}
++j;
if (new_rows > wp->w_height - row - 2)
{
// it's getting too much, must redraw the rest
new_rows = 9999;
break;
}
}
xtra_rows = new_rows - old_rows;
if (xtra_rows < 0)
{
// May scroll text up. If there is not enough
// remaining text or scrolling fails, must redraw the
// rest. If scrolling works, must redraw the text
// below the scrolled text.
if (row - xtra_rows >= wp->w_height - 2)
mod_bot = MAXLNUM;
else
{
check_for_delay(FALSE);
if (win_del_lines(wp, row,
-xtra_rows, FALSE, FALSE, 0) == FAIL)
mod_bot = MAXLNUM;
else
bot_start = wp->w_height + xtra_rows;
}
}
else if (xtra_rows > 0)
{
// May scroll text down. If there is not enough
// remaining text of scrolling fails, must redraw the
// rest.
if (row + xtra_rows >= wp->w_height - 2)
mod_bot = MAXLNUM;
else
{
check_for_delay(FALSE);
if (win_ins_lines(wp, row + old_rows,
xtra_rows, FALSE, FALSE) == FAIL)
mod_bot = MAXLNUM;
else if (top_end > row + old_rows)
// Scrolled the part at the top that requires
// updating down.
top_end += xtra_rows;
}
}
// When not updating the rest, may need to move w_lines[]
// entries.
if (mod_bot != MAXLNUM && i != j)
{
if (j < i)
{
int x = row + new_rows;
// move entries in w_lines[] upwards
for (;;)
{
// stop at last valid entry in w_lines[]
if (i >= wp->w_lines_valid)
{
wp->w_lines_valid = j;
break;
}
wp->w_lines[j] = wp->w_lines[i];
// stop at a line that won't fit
if (x + (int)wp->w_lines[j].wl_size
> wp->w_height)
{
wp->w_lines_valid = j + 1;
break;
}
x += wp->w_lines[j++].wl_size;
++i;
}
if (bot_start > x)
bot_start = x;
}
else // j > i
{
// move entries in w_lines[] downwards
j -= i;
wp->w_lines_valid += j;
if (wp->w_lines_valid > wp->w_height)
wp->w_lines_valid = wp->w_height;
for (i = wp->w_lines_valid; i - j >= idx; --i)
wp->w_lines[i] = wp->w_lines[i - j];
// The w_lines[] entries for inserted lines are
// now invalid, but wl_size may be used above.
// Reset to zero.
while (i >= idx)
{
wp->w_lines[i].wl_size = 0;
wp->w_lines[i--].wl_valid = FALSE;
}
}
}
}
}
#ifdef FEAT_FOLDING
// When lines are folded, display one line for all of them.
// Otherwise, display normally (can be several display lines when
// 'wrap' is on).
fold_count = foldedCount(wp, lnum, &win_foldinfo);
if (fold_count != 0)
{
fold_line(wp, fold_count, &win_foldinfo, lnum, row);
++row;
--fold_count;
wp->w_lines[idx].wl_folded = TRUE;
wp->w_lines[idx].wl_lastlnum = lnum + fold_count;
# ifdef FEAT_SYN_HL
did_update = DID_FOLD;
# endif
# ifdef FEAT_SPELL
spv.spv_capcol_lnum = 0;
# endif
}
else
#endif
if (idx < wp->w_lines_valid
&& wp->w_lines[idx].wl_valid
&& wp->w_lines[idx].wl_lnum == lnum
&& lnum > wp->w_topline
&& !(dy_flags & (DY_LASTLINE | DY_TRUNCATE))
&& !WIN_IS_POPUP(wp)
&& srow + wp->w_lines[idx].wl_size > wp->w_height
#ifdef FEAT_DIFF
&& diff_check_fill(wp, lnum) == 0
#endif
)
{
// This line is not going to fit. Don't draw anything here,
// will draw "@ " lines below.
row = wp->w_height + 1;
}
else
{
#ifdef FEAT_SEARCH_EXTRA
prepare_search_hl(wp, &screen_search_hl, lnum);
#endif
#ifdef FEAT_SYN_HL
// Let the syntax stuff know we skipped a few lines.
if (syntax_last_parsed != 0 && syntax_last_parsed + 1 < lnum
&& syntax_present(wp))
syntax_end_parsing(wp, syntax_last_parsed + 1);
#endif
// Display one line.
row = win_line(wp, lnum, srow, wp->w_height, 0, &spv);
#ifdef FEAT_FOLDING
wp->w_lines[idx].wl_folded = FALSE;
wp->w_lines[idx].wl_lastlnum = lnum;
#endif
#ifdef FEAT_SYN_HL
did_update = DID_LINE;
syntax_last_parsed = lnum;
#endif
}
wp->w_lines[idx].wl_lnum = lnum;
wp->w_lines[idx].wl_valid = TRUE;
// Past end of the window or end of the screen. Note that after
// resizing wp->w_height may be end up too big. That's a problem
// elsewhere, but prevent a crash here.
if (row > wp->w_height || row + wp->w_winrow >= Rows)
{
// we may need the size of that too long line later on
if (dollar_vcol == -1)
wp->w_lines[idx].wl_size = plines_win(wp, lnum, TRUE);
++idx;
break;
}
if (dollar_vcol == -1)
wp->w_lines[idx].wl_size = row - srow;
++idx;
#ifdef FEAT_FOLDING
lnum += fold_count + 1;
#else
++lnum;
#endif
}
else
{
// If:
// - 'number' is set and below inserted/deleted lines, or
// - 'relativenumber' is set and cursor moved vertically,
// the text doesn't need to be redrawn, but the number column does.
if ((wp->w_p_nu && mod_top != 0 && lnum >= mod_bot
&& buf->b_mod_set && buf->b_mod_xlines != 0)
|| (wp->w_p_rnu
&& wp->w_last_cursor_lnum_rnu != wp->w_cursor.lnum))
{
#ifdef FEAT_FOLDING
fold_count = foldedCount(wp, lnum, &win_foldinfo);
if (fold_count != 0)
fold_line(wp, fold_count, &win_foldinfo, lnum, row);
else
#endif
(void)win_line(wp, lnum, srow, wp->w_height,
wp->w_lines[idx].wl_size, &spv);
}
// This line does not need to be drawn, advance to the next one.
row += wp->w_lines[idx++].wl_size;
if (row > wp->w_height) // past end of screen
break;
#ifdef FEAT_FOLDING
lnum = wp->w_lines[idx - 1].wl_lastlnum + 1;
#else
++lnum;
#endif
#ifdef FEAT_SYN_HL
did_update = DID_NONE;
#endif
#ifdef FEAT_SPELL
spv.spv_capcol_lnum = 0;
#endif
}
if (lnum > buf->b_ml.ml_line_count)
{
eof = TRUE;
break;
}
// Safety check: if any of the wl_size values is wrong we might go over
// the end of w_lines[].
if (idx >= Rows)
break;
}
// End of loop over all window lines.
#ifdef FEAT_SYN_HL
// Now that the window has been redrawn with the old and new cursor line,
// update w_last_cursorline.
wp->w_last_cursorline = wp->w_p_cul ? wp->w_cursor.lnum : 0;
#endif
wp->w_last_cursor_lnum_rnu = wp->w_p_rnu ? wp->w_cursor.lnum : 0;
#ifdef FEAT_VTP
// Rewrite the character at the end of the screen line.
// See the version that was fixed.
if (use_vtp() && get_conpty_fix_type() < 1)
{
int k;
for (k = 0; k < Rows; ++k)
if (enc_utf8)
if ((*mb_off2cells)(LineOffset[k] + Columns - 2,
LineOffset[k] + screen_Columns) > 1)
screen_draw_rectangle(k, Columns - 2, 1, 2, FALSE);
else
screen_draw_rectangle(k, Columns - 1, 1, 1, FALSE);
else
screen_char(LineOffset[k] + Columns - 1, k, Columns - 1);
}
#endif
if (idx > wp->w_lines_valid)
wp->w_lines_valid = idx;
#ifdef FEAT_SYN_HL
// Let the syntax stuff know we stop parsing here.
if (syntax_last_parsed != 0 && syntax_present(wp))
syntax_end_parsing(wp, syntax_last_parsed + 1);
#endif
// If we didn't hit the end of the file, and we didn't finish the last
// line we were working on, then the line didn't fit.
wp->w_empty_rows = 0;
#ifdef FEAT_DIFF
wp->w_filler_rows = 0;
#endif
if (!eof && !didline)
{
if (lnum == wp->w_topline)
{
// Single line that does not fit!
// Don't overwrite it, it can be edited.
wp->w_botline = lnum + 1;
}
#ifdef FEAT_DIFF
else if (diff_check_fill(wp, lnum) >= wp->w_height - srow)
{
// Window ends in filler lines.
wp->w_botline = lnum;
wp->w_filler_rows = wp->w_height - srow;
}
#endif
#ifdef FEAT_PROP_POPUP
else if (WIN_IS_POPUP(wp))
{
// popup line that doesn't fit is left as-is
wp->w_botline = lnum;
}
#endif
else if (dy_flags & DY_TRUNCATE) // 'display' has "truncate"
{
int scr_row = W_WINROW(wp) + wp->w_height - 1;
int symbol = wp->w_fill_chars.lastline;
int charlen;
char_u fillbuf[12]; // 2 characters of 6 bytes
charlen = mb_char2bytes(symbol, &fillbuf[0]);
mb_char2bytes(symbol, &fillbuf[charlen]);
// Last line isn't finished: Display "@@@" in the last screen line.
screen_puts_len(fillbuf,
(wp->w_width > 2 ? 2 : wp->w_width) * charlen,
scr_row, wp->w_wincol, HL_ATTR(HLF_AT));
screen_fill(scr_row, scr_row + 1,
(int)wp->w_wincol + 2, (int)W_ENDCOL(wp),
symbol, ' ', HL_ATTR(HLF_AT));
set_empty_rows(wp, srow);
wp->w_botline = lnum;
}
else if (dy_flags & DY_LASTLINE) // 'display' has "lastline"
{
int start_col = (int)W_ENDCOL(wp) - 3;
int symbol = wp->w_fill_chars.lastline;
// Last line isn't finished: Display "@@@" at the end.
screen_fill(W_WINROW(wp) + wp->w_height - 1,
W_WINROW(wp) + wp->w_height,
start_col < wp->w_wincol ? wp->w_wincol : start_col,
(int)W_ENDCOL(wp),
symbol, symbol, HL_ATTR(HLF_AT));
set_empty_rows(wp, srow);
wp->w_botline = lnum;
}
else
{
win_draw_end(wp, wp->w_fill_chars.lastline, ' ', TRUE,
srow, wp->w_height, HLF_AT);
wp->w_botline = lnum;
}
}
else
{
draw_vsep_win(wp, row);
if (eof) // we hit the end of the file
{
wp->w_botline = buf->b_ml.ml_line_count + 1;
#ifdef FEAT_DIFF
j = diff_check_fill(wp, wp->w_botline);
if (j > 0 && !wp->w_botfill)
{
// Display filler lines at the end of the file.
if (char2cells(wp->w_fill_chars.diff) > 1)
i = '-';
else
i = wp->w_fill_chars.diff;
if (row + j > wp->w_height)
j = wp->w_height - row;
win_draw_end(wp, i, i, TRUE, row, row + (int)j, HLF_DED);
row += j;
}
#endif
}
else if (dollar_vcol == -1)
wp->w_botline = lnum;
// Make sure the rest of the screen is blank.
// write the "eob" character from 'fillchars' to rows that aren't part
// of the file.
if (WIN_IS_POPUP(wp))
win_draw_end(wp, ' ', ' ', FALSE, row, wp->w_height, HLF_AT);
else
win_draw_end(wp, wp->w_fill_chars.eob, ' ', FALSE,
row, wp->w_height, HLF_EOB);
}
#ifdef SYN_TIME_LIMIT
disable_regexp_timeout();
redrawtime_limit_set = FALSE;
#endif
// Reset the type of redrawing required, the window has been updated.
wp->w_redr_type = 0;
#ifdef FEAT_DIFF
wp->w_old_topfill = wp->w_topfill;
wp->w_old_botfill = wp->w_botfill;
#endif
if (dollar_vcol == -1)
{
// There is a trick with w_botline. If we invalidate it on each
// change that might modify it, this will cause a lot of expensive
// calls to plines() in update_topline() each time. Therefore the
// value of w_botline is often approximated, and this value is used to
// compute the value of w_topline. If the value of w_botline was
// wrong, check that the value of w_topline is correct (cursor is on
// the visible part of the text). If it's not, we need to redraw
// again. Mostly this just means scrolling up a few lines, so it
// doesn't look too bad. Only do this for the current window (where
// changes are relevant).
wp->w_valid |= VALID_BOTLINE;
if (wp == curwin && wp->w_botline != old_botline && !recursive)
{
win_T *wwp;
#if defined(FEAT_CONCEAL)
linenr_T old_topline = wp->w_topline;
int new_wcol = wp->w_wcol;
#endif
recursive = TRUE;
curwin->w_valid &= ~VALID_TOPLINE;
update_topline(); // may invalidate w_botline again
#if defined(FEAT_CONCEAL)
if (old_wcol != new_wcol && (wp->w_valid & (VALID_WCOL|VALID_WROW))
!= (VALID_WCOL|VALID_WROW))
{
// A win_line() call applied a fix to screen cursor column to
// accommodate concealment of cursor line, but in this call to
// update_topline() the cursor's row or column got invalidated.
// If they are left invalid, setcursor() will recompute them
// but there won't be any further win_line() call to re-fix the
// column and the cursor will end up misplaced. So we call
// cursor validation now and reapply the fix again (or call
// win_line() to do it for us).
validate_cursor();
if (wp->w_wcol == old_wcol && wp->w_wrow == old_wrow
&& old_topline == wp->w_topline)
wp->w_wcol = new_wcol;
else
redrawWinline(wp, wp->w_cursor.lnum);
}
#endif
// New redraw either due to updated topline, wcol fix or reset skipcol.
if (wp->w_redr_type != 0)
{
// Don't update for changes in buffer again.
i = curbuf->b_mod_set;
curbuf->b_mod_set = FALSE;
j = curbuf->b_mod_xlines;
curbuf->b_mod_xlines = 0;
curs_columns(TRUE);
win_update(curwin);
curbuf->b_mod_set = i;
curbuf->b_mod_xlines = j;
}
// Other windows might have w_redr_type raised in update_topline().
must_redraw = 0;
FOR_ALL_WINDOWS(wwp)
if (wwp->w_redr_type > must_redraw)
must_redraw = wwp->w_redr_type;
recursive = FALSE;
}
}
#if defined(FEAT_SYN_HL) || defined(FEAT_SEARCH_EXTRA)
// restore got_int, unless CTRL-C was hit while redrawing
if (!got_int)
got_int = save_got_int;
#endif
}
#if defined(FEAT_NETBEANS_INTG) || defined(FEAT_GUI)
/*
* Prepare for updating one or more windows.
* Caller must check for "updating_screen" already set to avoid recursiveness.
*/
static void
update_prepare(void)
{
cursor_off();
updating_screen = TRUE;
#ifdef FEAT_GUI
// Remove the cursor before starting to do anything, because scrolling may
// make it difficult to redraw the text under it.
if (gui.in_use)
gui_undraw_cursor();
#endif
#ifdef FEAT_SEARCH_EXTRA
start_search_hl();
#endif
#ifdef FEAT_PROP_POPUP
// Update popup_mask if needed.
may_update_popup_mask(must_redraw);
#endif
}
/*
* Finish updating one or more windows.
*/
static void
update_finish(void)
{
if (redraw_cmdline || redraw_mode)
showmode();
# ifdef FEAT_SEARCH_EXTRA
end_search_hl();
# endif
after_updating_screen(TRUE);
# ifdef FEAT_GUI
// Redraw the cursor and update the scrollbars when all screen updating is
// done.
if (gui.in_use)
{
out_flush_cursor(FALSE, FALSE);
gui_update_scrollbars(FALSE);
}
# endif
}
#endif
#if defined(FEAT_NETBEANS_INTG) || defined(PROTO)
void
update_debug_sign(buf_T *buf, linenr_T lnum)
{
win_T *wp;
int doit = FALSE;
# ifdef FEAT_FOLDING
win_foldinfo.fi_level = 0;
# endif
// update/delete a specific sign
redraw_buf_line_later(buf, lnum);
// check if it resulted in the need to redraw a window
FOR_ALL_WINDOWS(wp)
if (wp->w_redr_type != 0)
doit = TRUE;
// Return when there is nothing to do, screen updating is already
// happening (recursive call), messages on the screen or still starting up.
if (!doit || updating_screen
|| State == MODE_ASKMORE || State == MODE_HITRETURN
|| msg_scrolled
#ifdef FEAT_GUI
|| gui.starting
#endif
|| starting)
return;
// update all windows that need updating
update_prepare();
FOR_ALL_WINDOWS(wp)
{
if (wp->w_redr_type != 0)
win_update(wp);
if (wp->w_redr_status)
win_redr_status(wp, FALSE);
}
update_finish();
}
#endif
#if defined(FEAT_GUI) || defined(PROTO)
/*
* Update a single window, its status line and maybe the command line msg.
* Used for the GUI scrollbar.
*/
void
updateWindow(win_T *wp)
{
// return if already busy updating
if (updating_screen)
return;
update_prepare();
#ifdef FEAT_CLIPBOARD
// When Visual area changed, may have to update selection.
if (clip_star.available && clip_isautosel_star())
clip_update_selection(&clip_star);
if (clip_plus.available && clip_isautosel_plus())
clip_update_selection(&clip_plus);
#endif
win_update(wp);
// When the screen was cleared redraw the tab pages line.
if (redraw_tabline)
draw_tabline();
if (wp->w_redr_status || p_ru
# ifdef FEAT_STL_OPT
|| *p_stl != NUL || *wp->w_p_stl != NUL
# endif
)
win_redr_status(wp, FALSE);
#ifdef FEAT_PROP_POPUP
// Display popup windows on top of everything.
update_popups(win_update);
#endif
update_finish();
}
#endif
/*
* Redraw as soon as possible. When the command line is not scrolled redraw
* right away and restore what was on the command line.
* Return a code indicating what happened.
*/
int
redraw_asap(int type)
{
int rows;
int cols = screen_Columns;
int r;
int ret = 0;
schar_T *screenline; // copy from ScreenLines[]
sattr_T *screenattr; // copy from ScreenAttrs[]
int i;
u8char_T *screenlineUC = NULL; // copy from ScreenLinesUC[]
u8char_T *screenlineC[MAX_MCO]; // copy from ScreenLinesC[][]
schar_T *screenline2 = NULL; // copy from ScreenLines2[]
redraw_later(type);
if (msg_scrolled
|| (State != MODE_NORMAL && State != MODE_NORMAL_BUSY)
|| exiting)
return ret;
// Allocate space to save the text displayed in the command line area.
rows = screen_Rows - cmdline_row;
screenline = LALLOC_MULT(schar_T, rows * cols);
screenattr = LALLOC_MULT(sattr_T, rows * cols);
if (screenline == NULL || screenattr == NULL)
ret = 2;
if (enc_utf8)
{
screenlineUC = LALLOC_MULT(u8char_T, rows * cols);
if (screenlineUC == NULL)
ret = 2;
for (i = 0; i < p_mco; ++i)
{
screenlineC[i] = LALLOC_MULT(u8char_T, rows * cols);
if (screenlineC[i] == NULL)
ret = 2;
}
}
if (enc_dbcs == DBCS_JPNU)
{
screenline2 = LALLOC_MULT(schar_T, rows * cols);
if (screenline2 == NULL)
ret = 2;
}
if (ret != 2)
{
// Save the text displayed in the command line area.
for (r = 0; r < rows; ++r)
{
mch_memmove(screenline + r * cols,
ScreenLines + LineOffset[cmdline_row + r],
(size_t)cols * sizeof(schar_T));
mch_memmove(screenattr + r * cols,
ScreenAttrs + LineOffset[cmdline_row + r],
(size_t)cols * sizeof(sattr_T));
if (enc_utf8)
{
mch_memmove(screenlineUC + r * cols,
ScreenLinesUC + LineOffset[cmdline_row + r],
(size_t)cols * sizeof(u8char_T));
for (i = 0; i < p_mco; ++i)
mch_memmove(screenlineC[i] + r * cols,
ScreenLinesC[i] + LineOffset[cmdline_row + r],
(size_t)cols * sizeof(u8char_T));
}
if (enc_dbcs == DBCS_JPNU)
mch_memmove(screenline2 + r * cols,
ScreenLines2 + LineOffset[cmdline_row + r],
(size_t)cols * sizeof(schar_T));
}
update_screen(0);
ret = 3;
if (must_redraw == 0)
{
int off = (int)(current_ScreenLine - ScreenLines);
// Restore the text displayed in the command line area.
for (r = 0; r < rows; ++r)
{
mch_memmove(current_ScreenLine,
screenline + r * cols,
(size_t)cols * sizeof(schar_T));
mch_memmove(ScreenAttrs + off,
screenattr + r * cols,
(size_t)cols * sizeof(sattr_T));
if (enc_utf8)
{
mch_memmove(ScreenLinesUC + off,
screenlineUC + r * cols,
(size_t)cols * sizeof(u8char_T));
for (i = 0; i < p_mco; ++i)
mch_memmove(ScreenLinesC[i] + off,
screenlineC[i] + r * cols,
(size_t)cols * sizeof(u8char_T));
}
if (enc_dbcs == DBCS_JPNU)
mch_memmove(ScreenLines2 + off,
screenline2 + r * cols,
(size_t)cols * sizeof(schar_T));
screen_line(curwin, cmdline_row + r, 0, cols, cols, -1, 0);
}
ret = 4;
}
}
vim_free(screenline);
vim_free(screenattr);
if (enc_utf8)
{
vim_free(screenlineUC);
for (i = 0; i < p_mco; ++i)
vim_free(screenlineC[i]);
}
if (enc_dbcs == DBCS_JPNU)
vim_free(screenline2);
// Show the intro message when appropriate.
maybe_intro_message();
setcursor();
return ret;
}
/*
* Invoked after an asynchronous callback is called.
* If an echo command was used the cursor needs to be put back where
* it belongs. If highlighting was changed a redraw is needed.
* If "call_update_screen" is FALSE don't call update_screen() when at the
* command line.
* If "redraw_message" is TRUE.
*/
void
redraw_after_callback(int call_update_screen, int do_message)
{
++redrawing_for_callback;
if (State == MODE_HITRETURN || State == MODE_ASKMORE
|| State == MODE_SETWSIZE || State == MODE_EXTERNCMD
|| State == MODE_CONFIRM || exmode_active)
{
if (do_message)
repeat_message();
}
else if (State & MODE_CMDLINE)
{
if (pum_visible())
cmdline_pum_display();
// Don't redraw when in prompt_for_number().
if (cmdline_row > 0)
{
// Redrawing only works when the screen didn't scroll. Don't clear
// wildmenu entries.
if (msg_scrolled == 0
&& wild_menu_showing == 0
&& call_update_screen)
update_screen(0);
// Redraw in the same position, so that the user can continue
// editing the command.
redrawcmdline_ex(FALSE);
}
}
else if (State & (MODE_NORMAL | MODE_INSERT | MODE_TERMINAL))
{
update_topline();
validate_cursor();
// keep the command line if possible
update_screen(UPD_VALID_NO_UPDATE);
setcursor();
if (msg_scrolled == 0)
{
// don't want a hit-enter prompt when something else is displayed
msg_didany = FALSE;
need_wait_return = FALSE;
}
}
cursor_on();
#ifdef FEAT_GUI
if (gui.in_use && !gui_mch_is_blink_off())
// Don't update the cursor when it is blinking and off to avoid
// flicker.
out_flush_cursor(FALSE, FALSE);
else
#endif
out_flush();
--redrawing_for_callback;
}
/*
* Redraw the current window later, with update_screen(type).
* Set must_redraw only if not already set to a higher value.
* E.g. if must_redraw is UPD_CLEAR, type UPD_NOT_VALID will do nothing.
*/
void
redraw_later(int type)
{
redraw_win_later(curwin, type);
}
void
redraw_win_later(
win_T *wp,
int type)
{
if (!exiting && !redraw_not_allowed && wp->w_redr_type < type)
{
wp->w_redr_type = type;
if (type >= UPD_NOT_VALID)
wp->w_lines_valid = 0;
if (must_redraw < type) // must_redraw is the maximum of all windows
must_redraw = type;
}
}
/*
* Force a complete redraw later. Also resets the highlighting. To be used
* after executing a shell command that messes up the screen.
*/
void
redraw_later_clear(void)
{
redraw_all_later(UPD_CLEAR);
reset_screen_attr();
}
/*
* Mark all windows to be redrawn later. Except popup windows.
*/
void
redraw_all_later(int type)
{
win_T *wp;
FOR_ALL_WINDOWS(wp)
redraw_win_later(wp, type);
// This may be needed when switching tabs.
set_must_redraw(type);
}
#if 0 // not actually used yet, it probably should
/*
* Mark all windows, including popup windows, to be redrawn.
*/
void
redraw_all_windows_later(int type)
{
redraw_all_later(type);
#ifdef FEAT_PROP_POPUP
popup_redraw_all(); // redraw all popup windows
#endif
}
#endif
/*
* Set "must_redraw" to "type" unless it already has a higher value
* or it is currently not allowed.
*/
void
set_must_redraw(int type)
{
if (!redraw_not_allowed && must_redraw < type)
must_redraw = type;
}
/*
* Mark all windows that are editing the current buffer to be updated later.
*/
void
redraw_curbuf_later(int type)
{
redraw_buf_later(curbuf, type);
}
void
redraw_buf_later(buf_T *buf, int type)
{
win_T *wp;
FOR_ALL_WINDOWS(wp)
{
if (wp->w_buffer == buf)
redraw_win_later(wp, type);
}
#if defined(FEAT_TERMINAL) && defined(FEAT_PROP_POPUP)
// terminal in popup window is not in list of windows
if (curwin->w_buffer == buf)
redraw_win_later(curwin, type);
#endif
}
#if defined(FEAT_SIGNS) || defined(PROTO)
void
redraw_buf_line_later(buf_T *buf, linenr_T lnum)
{
win_T *wp;
FOR_ALL_WINDOWS(wp)
if (wp->w_buffer == buf && lnum >= wp->w_topline
&& lnum < wp->w_botline)
redrawWinline(wp, lnum);
}
#endif
#if defined(FEAT_JOB_CHANNEL) || defined(PROTO)
void
redraw_buf_and_status_later(buf_T *buf, int type)
{
win_T *wp;
if (wild_menu_showing != 0)
// Don't redraw while the command line completion is displayed, it
// would disappear.
return;
FOR_ALL_WINDOWS(wp)
{
if (wp->w_buffer == buf)
{
redraw_win_later(wp, type);
wp->w_redr_status = TRUE;
}
}
}
#endif
/*
* mark all status lines for redraw; used after first :cd
*/
void
status_redraw_all(void)
{
win_T *wp;
FOR_ALL_WINDOWS(wp)
if (wp->w_status_height)
{
wp->w_redr_status = TRUE;
redraw_later(UPD_VALID);
}
}
/*
* mark all status lines of the current buffer for redraw
*/
void
status_redraw_curbuf(void)
{
win_T *wp;
FOR_ALL_WINDOWS(wp)
if (wp->w_status_height != 0 && wp->w_buffer == curbuf)
{
wp->w_redr_status = TRUE;
redraw_later(UPD_VALID);
}
}
/*
* Redraw all status lines that need to be redrawn.
*/
void
redraw_statuslines(void)
{
win_T *wp;
FOR_ALL_WINDOWS(wp)
if (wp->w_redr_status)
win_redr_status(wp, FALSE);
if (redraw_tabline)
draw_tabline();
}
/*
* Redraw all status lines at the bottom of frame "frp".
*/
void
win_redraw_last_status(frame_T *frp)
{
if (frp->fr_layout == FR_LEAF)
frp->fr_win->w_redr_status = TRUE;
else if (frp->fr_layout == FR_ROW)
{
FOR_ALL_FRAMES(frp, frp->fr_child)
win_redraw_last_status(frp);
}
else // frp->fr_layout == FR_COL
{
frp = frp->fr_child;
while (frp->fr_next != NULL)
frp = frp->fr_next;
win_redraw_last_status(frp);
}
}
/*
* Changed something in the current window, at buffer line "lnum", that
* requires that line and possibly other lines to be redrawn.
* Used when entering/leaving Insert mode with the cursor on a folded line.
* Used to remove the "$" from a change command.
* Note that when also inserting/deleting lines w_redraw_top and w_redraw_bot
* may become invalid and the whole window will have to be redrawn.
*/
void
redrawWinline(
win_T *wp,
linenr_T lnum)
{
redraw_win_range_later(wp, lnum, lnum);
}
void
redraw_win_range_later(
win_T *wp,
linenr_T first,
linenr_T last)
{
if (last >= wp->w_topline && first < wp->w_botline)
{
if (wp->w_redraw_top == 0 || wp->w_redraw_top > first)
wp->w_redraw_top = first;
if (wp->w_redraw_bot == 0 || wp->w_redraw_bot < last)
wp->w_redraw_bot = last;
redraw_win_later(wp, UPD_VALID);
}
}