mirror of
https://github.com/vim/vim
synced 2025-03-16 06:47:52 +01:00
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>
3385 lines
86 KiB
C
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);
|
|
}
|
|
}
|