Problem: Redraw flags are not named specifically.
Solution: Prefix "UPD_" to the flags, for UPDate_screen().
curbuf->b_last_used = vim_time();
#endif
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
}
#if defined(FEAT_AUTOCHDIR) || defined(PROTO)
linenr_T last = lnume + xtra - 1; // last line after the change
#endif
// Mark this window to be redrawn later.
- if (wp->w_redr_type < VALID)
- wp->w_redr_type = VALID;
+ if (wp->w_redr_type < UPD_VALID)
+ wp->w_redr_type = UPD_VALID;
// Check if a change in the buffer has invalidated the cached
// values for the cursor.
if (wp->w_p_rnu && xtra != 0)
{
wp->w_last_cursor_lnum_rnu = 0;
- redraw_win_later(wp, VALID);
+ redraw_win_later(wp, UPD_VALID);
}
#ifdef FEAT_SYN_HL
// Cursor line highlighting probably need to be updated with
- // "VALID" if it's below the change.
+ // "UPD_VALID" if it's below the change.
// If the cursor line is inside the change we need to redraw more.
if (wp->w_p_cul)
{
if (xtra == 0)
- redraw_win_later(wp, VALID);
+ redraw_win_later(wp, UPD_VALID);
else if (lnum <= wp->w_last_cursorline)
- redraw_win_later(wp, SOME_VALID);
+ redraw_win_later(wp, UPD_SOME_VALID);
}
#endif
}
// Call update_screen() later, which checks out what needs to be redrawn,
// since it notices b_mod_set and then uses b_mod_*.
- if (must_redraw < VALID)
- must_redraw = VALID;
+ if (must_redraw < UPD_VALID)
+ must_redraw = UPD_VALID;
// when the cursor line is changed always trigger CursorMoved
if (lnum <= curwin->w_cursor.lnum
FOR_ALL_WINDOWS(wp)
if (wp->w_p_diff && wp != curwin)
{
- redraw_win_later(wp, VALID);
+ redraw_win_later(wp, UPD_VALID);
wlnum = diff_lnum_win(lnum, wp);
if (wlnum > 0)
changedOneline(wp->w_buffer, wlnum);
FOR_ALL_WINDOWS(wp)
if (wp->w_p_diff && wp != curwin)
{
- redraw_win_later(wp, VALID);
+ redraw_win_later(wp, UPD_VALID);
wlnum = diff_lnum_win(lnum, wp);
if (wlnum > 0)
changed_lines_buf(wp->w_buffer, wlnum,
}
}
}
- redraw_buf_and_status_later(buffer, VALID);
+ redraw_buf_and_status_later(buffer, UPD_VALID);
channel_need_redraw = TRUE;
}
&& (cbd == &clip_star ? clip_isautosel_star()
: clip_isautosel_plus())
&& HL_ATTR(HLF_V) != HL_ATTR(HLF_VNC))
- redraw_curbuf_later(INVERTED_ALL);
+ redraw_curbuf_later(UPD_INVERTED_ALL);
}
}
#else
&& HL_ATTR(HLF_V) != HL_ATTR(HLF_VNC)
&& !exiting)
{
- update_curbuf(INVERTED_ALL);
+ update_curbuf(UPD_INVERTED_ALL);
setcursor();
cursor_on();
out_flush_cursor(TRUE, FALSE);
p_ls = save_p_ls;
p_wmh = save_p_wmh;
last_status(FALSE);
- update_screen(VALID); // redraw the screen NOW
+ update_screen(UPD_VALID); // redraw the screen NOW
redrawcmd();
save_p_ls = -1;
}
--RedrawingDisabled;
--no_wait_return;
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
need_wait_return = FALSE;
msg_scroll = save_msg_scroll;
lines_left = Rows - 1;
// don't redraw right away, more might change or buffer state
// is invalid right now
need_diff_redraw = TRUE;
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
}
}
}
if (!wp->w_p_diff || !buf_valid(wp->w_buffer))
continue;
- redraw_win_later(wp, SOME_VALID);
+ redraw_win_later(wp, UPD_SOME_VALID);
if (wp != curwin)
wp_other = wp;
#ifdef FEAT_FOLDING
#endif
// patch probably has written over the screen
- redraw_later(CLEAR);
+ redraw_later(UPD_CLEAR);
// Delete any .orig or .rej file created.
STRCPY(buf, tmp_new);
if (addbuf)
diff_buf_add(wp->w_buffer);
- redraw_win_later(wp, NOT_VALID);
+ redraw_win_later(wp, UPD_NOT_VALID);
}
/*
ui_breakcheck();
++dp;
}
- must_redraw = CLEAR; // clear screen, because some digraphs may be
- // wrong, in which case we messed up ScreenLines
+
+ // clear screen, because some digraphs may be wrong, in which case we
+ // messed up ScreenLines
+ must_redraw = UPD_CLEAR;
}
static void
*
* 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(VALID) to have the window displayed by update_screen()
+ * 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
*
* 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(NOT_VALID) to have the whole window
+ * 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(NOT_VALID) to have all the windows for the
+ * 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(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 NOT_VALID then.
+ * 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(NOT_VALID).
+ * 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(NOT_VALID) or redraw_all_later(CLEAR).
+ * 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
if (!screen_valid(TRUE))
return FAIL;
- if (type == VALID_NO_UPDATE)
+ if (type == UPD_VALID_NO_UPDATE)
{
no_update = TRUE;
type = 0;
}
// May need to update w_lines[].
- if (curwin->w_lines_valid == 0 && type < NOT_VALID
+ if (curwin->w_lines_valid == 0 && type < UPD_NOT_VALID
#ifdef FEAT_TERMINAL
&& !term_do_update_window(curwin)
#endif
)
- type = NOT_VALID;
+ type = UPD_NOT_VALID;
// Postpone the redrawing when it's not needed and when being called
// recursively.
{
redraw_later(type); // remember type for next time
must_redraw = type;
- if (type > INVERTED_ALL)
+ if (type > UPD_INVERTED_ALL)
curwin->w_lines_valid = 0; // don't use w_lines[].wl_size now
return FAIL;
}
{
clear_cmdline = TRUE;
if (msg_scrolled > Rows - 5) // clearing is faster
- type = CLEAR;
- else if (type != CLEAR)
+ type = UPD_CLEAR;
+ else if (type != UPD_CLEAR)
{
check_for_delay(FALSE);
if (screen_ins_lines(0, 0, msg_scrolled, (int)Rows, 0, NULL)
== FAIL)
- type = CLEAR;
+ type = UPD_CLEAR;
FOR_ALL_WINDOWS(wp)
{
if (wp->w_winrow < msg_scrolled)
{
if (W_WINROW(wp) + wp->w_height > msg_scrolled
- && wp->w_redr_type < REDRAW_TOP
+ && 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 = REDRAW_TOP;
+ wp->w_redr_type = UPD_REDRAW_TOP;
}
else
{
- wp->w_redr_type = NOT_VALID;
+ 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 (need_highlight_changed)
highlight_changed();
- if (type == CLEAR) // first clear screen
+ if (type == UPD_CLEAR) // first clear screen
{
screenclear(); // will reset clear_cmdline
- type = NOT_VALID;
+ type = UPD_NOT_VALID;
// must_redraw may be set indirectly, avoid another redraw later
must_redraw = 0;
}
#ifdef FEAT_LINEBREAK
// Force redraw when width of 'number' or 'relativenumber' column
// changes.
- if (curwin->w_redr_type < NOT_VALID
+ 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 = NOT_VALID;
+ curwin->w_redr_type = UPD_NOT_VALID;
#endif
// Only start redrawing if there is really something to do.
- if (type == INVERTED)
+ if (type == UPD_INVERTED)
update_curswant();
if (curwin->w_redr_type < type
- && !((type == VALID
+ && !((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 == INVERTED
+ || (type == UPD_INVERTED
&& VIsual_active
&& curwin->w_old_cursor_lnum == curwin->w_cursor.lnum
&& curwin->w_old_visual_mode == VIsual_mode
curwin->w_redr_type = type;
// Redraw the tab pages line if needed.
- if (redraw_tabline || type >= NOT_VALID)
+ if (redraw_tabline || type >= UPD_NOT_VALID)
draw_tabline();
#ifdef FEAT_SYN_HL
*
* How the window is redrawn depends on wp->w_redr_type. Each type also
* implies the one below it.
- * NOT_VALID redraw the whole window
- * SOME_VALID redraw the whole window but do scroll when possible
- * REDRAW_TOP redraw the top w_upd_rows window lines, otherwise like VALID
- * INVERTED redraw the changed part of the Visual area
- * INVERTED_ALL redraw the whole Visual area
- * VALID 1. scroll up/down to adjust for a changed w_topline
+ * 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
type = wp->w_redr_type;
- if (type == NOT_VALID)
+ if (type == UPD_NOT_VALID)
{
wp->w_redr_status = TRUE;
wp->w_lines_valid = 0;
i = (wp->w_p_nu || wp->w_p_rnu) ? number_width(wp) : 0;
if (wp->w_nrwidth != i)
{
- type = NOT_VALID;
+ type = UPD_NOT_VALID;
wp->w_nrwidth = i;
}
else
// When there are both inserted/deleted lines and specific lines to be
// redrawn, w_redraw_top and w_redraw_bot may be invalid, just redraw
// everything (only happens when redrawing is off for while).
- type = NOT_VALID;
+ type = UPD_NOT_VALID;
}
else
{
// When only displaying the lines at the top, set top_end. Used when
// window has scrolled down for msg_scrolled.
- if (type == REDRAW_TOP)
+ if (type == UPD_REDRAW_TOP)
{
j = 0;
for (i = 0; i < wp->w_lines_valid; ++i)
}
if (top_end == 0)
// not found (cannot happen?): redraw everything
- type = NOT_VALID;
+ type = UPD_NOT_VALID;
else
- // top area defined, the rest is VALID
- type = VALID;
+ // top area defined, the rest is UPD_VALID
+ type = UPD_VALID;
}
// Trick: we want to avoid clearing the screen twice. screenclear() will
// 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 == VALID || type == SOME_VALID
- || type == INVERTED || type == INVERTED_ALL)
+ 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
// 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
- // NOT_VALID, need to reset it here to avoid redrawing twice.
+ // UPD_NOT_VALID, need to reset it here to avoid redrawing twice.
if (screen_cleared == TRUE)
must_redraw = 0;
}
else
{
- // Not VALID or INVERTED: redraw all lines.
+ // Not UPD_VALID or UPD_INVERTED: redraw all lines.
mid_start = 0;
mid_end = wp->w_height;
}
- if (type == SOME_VALID)
+ if (type == UPD_SOME_VALID)
{
- // SOME_VALID: redraw all lines.
+ // UPD_SOME_VALID: redraw all lines.
mid_start = 0;
mid_end = wp->w_height;
- type = NOT_VALID;
+ 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 != NOT_VALID))
+ || (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 == INVERTED_ALL)
+ || type == UPD_INVERTED_ALL)
{
// If the type of Visual selection changed, redraw the whole
// selection. Also when the ownership of the X selection is
validate_cursor();
// keep the command line if possible
- update_screen(VALID_NO_UPDATE);
+ update_screen(UPD_VALID_NO_UPDATE);
setcursor();
if (msg_scrolled == 0)
/*
* 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 CLEAR, type NOT_VALID will do nothing.
+ * E.g. if must_redraw is UPD_CLEAR, type UPD_NOT_VALID will do nothing.
*/
void
redraw_later(int type)
if (!exiting && wp->w_redr_type < type)
{
wp->w_redr_type = type;
- if (type >= NOT_VALID)
+ 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;
void
redraw_later_clear(void)
{
- redraw_all_later(CLEAR);
+ redraw_all_later(UPD_CLEAR);
reset_screen_attr();
}
if (wp->w_status_height)
{
wp->w_redr_status = TRUE;
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
}
}
if (wp->w_status_height != 0 && wp->w_buffer == curbuf)
{
wp->w_redr_status = TRUE;
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
}
}
wp->w_redraw_top = lnum;
if (wp->w_redraw_bot == 0 || wp->w_redraw_bot < lnum)
wp->w_redraw_bot = lnum;
- redraw_win_later(wp, VALID);
+ redraw_win_later(wp, UPD_VALID);
}
|| old_topfill != curwin->w_topfill
#endif
)
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
start_arrow(&tpos);
can_cindent = TRUE;
}
|| old_topfill != curwin->w_topfill
#endif
)
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
start_arrow(&tpos);
can_cindent = TRUE;
}
scrolldown_clamp();
else
scrollup_clamp();
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
}
else
{
else if (STRCMP(varname, "hlsearch") == 0)
{
no_hlsearch = !di->di_tv.vval.v_number;
- redraw_all_later(SOME_VALID);
+ redraw_all_later(UPD_SOME_VALID);
}
#endif
goto failed;
vim_free(cmd_buf);
goto error;
}
- redraw_curbuf_later(VALID);
+ redraw_curbuf_later(UPD_VALID);
}
read_linecount = curbuf->b_ml.ml_line_count;
update_topline();
curwin->w_scbind_pos = curwin->w_topline;
*so_ptr = n;
- redraw_curbuf_later(NOT_VALID); // redraw this buffer later
+ redraw_curbuf_later(UPD_NOT_VALID); // redraw this buffer later
}
if (p_im && (State & MODE_INSERT) == 0)
update_topline();
validate_cursor();
- update_screen(SOME_VALID);
+ update_screen(UPD_SOME_VALID);
highlight_match = FALSE;
- redraw_later(SOME_VALID);
+ redraw_later(UPD_SOME_VALID);
#ifdef FEAT_FOLDING
curwin->w_p_fen = save_p_fen;
popup_hide(wp);
// When the popup moves or resizes it may reveal part of
// another window. TODO: can this be done more efficiently?
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
}
}
else
#endif
--RedrawingDisabled;
--no_wait_return;
- update_screen(CLEAR);
+ update_screen(UPD_CLEAR);
need_wait_return = FALSE;
msg_scroll = save_msg_scroll;
}
else if (has_vtp_working())
{
// background color change requires clear + redraw
- update_screen(CLEAR);
+ update_screen(UPD_CLEAR);
redrawcmd();
}
#endif
#ifdef FEAT_GUI
hold_gui_events = 0;
#endif
- must_redraw = CLEAR;
+ must_redraw = UPD_CLEAR;
pending_exmode_active = TRUE;
main_loop(FALSE, TRUE);
else
scrolldown(-y, TRUE);
curwin->w_scbind_pos = topline;
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
cursor_correct();
curwin->w_redr_status = TRUE;
}
deleted_lines_mark(lnum, 1L);
}
}
- redraw_curbuf_later(VALID);
+ redraw_curbuf_later(UPD_VALID);
}
}
}
p_lz = FALSE;
validate_cursor();
update_topline();
- update_screen(eap->forceit ? CLEAR : VIsual_active ? INVERTED : 0);
+ update_screen(eap->forceit ? UPD_CLEAR : VIsual_active ? UPD_INVERTED : 0);
if (need_maketitle)
maketitle();
#if defined(MSWIN) && (!defined(FEAT_GUI_MSWIN) || defined(VIMDLL))
status_redraw_all();
else
status_redraw_curbuf();
- update_screen(VIsual_active ? INVERTED : 0);
+ update_screen(VIsual_active ? UPD_INVERTED : 0);
RedrawingDisabled = r;
p_lz = p;
out_flush();
{
// Return cursor to where we were
validate_cursor();
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
win_enter(curwin_save, TRUE);
}
# ifdef FEAT_PROP_POPUP
ex_nohlsearch(exarg_T *eap UNUSED)
{
set_no_hlsearch(TRUE);
- redraw_all_later(SOME_VALID);
+ redraw_all_later(UPD_SOME_VALID);
}
#endif
magic_overruled = is_state->magic_overruled_save;
validate_cursor(); // needed for TAB
- redraw_all_later(SOME_VALID);
+ redraw_all_later(UPD_SOME_VALID);
if (call_update_screen)
- update_screen(SOME_VALID);
+ update_screen(UPD_SOME_VALID);
}
}
{
found = 0;
set_no_hlsearch(TRUE); // turn off previous highlight
- redraw_all_later(SOME_VALID);
+ redraw_all_later(UPD_SOME_VALID);
}
else
{
if (empty_pattern(ccline.cmdbuff + skiplen, search_delim)
&& !no_hlsearch)
{
- redraw_all_later(SOME_VALID);
+ redraw_all_later(UPD_SOME_VALID);
set_no_hlsearch(TRUE);
}
ccline.cmdbuff[skiplen + patlen] = next_char;
if (p_ru && curwin->w_status_height > 0)
curwin->w_redr_status = TRUE;
- update_screen(SOME_VALID);
+ update_screen(UPD_SOME_VALID);
highlight_match = FALSE;
restore_last_search_pattern();
validate_cursor();
highlight_match = TRUE;
save_viewstate(&is_state->old_viewstate);
- update_screen(NOT_VALID);
+ update_screen(UPD_NOT_VALID);
highlight_match = FALSE;
redrawcmdline();
curwin->w_cursor = is_state->match_end;
made_cmdheight_nonzero = TRUE;
lastwin->w_p_so = 0;
set_option_value((char_u *)"ch", 1L, NULL, 0);
- update_screen(VALID); // redraw the screen NOW
+ update_screen(UPD_VALID); // redraw the screen NOW
made_cmdheight_nonzero = FALSE;
lastwin->w_p_so = save_so;
}
made_cmdheight_nonzero = TRUE;
set_option_value((char_u *)"ch", 0L, NULL, 0);
// Redraw is needed for command line completion
- redraw_all_later(CLEAR);
+ redraw_all_later(UPD_CLEAR);
made_cmdheight_nonzero = FALSE;
}
curwin->w_cursor.col = ccline.cmdpos;
changed_line_abv_curs();
invalidate_botline();
- redraw_later(SOME_VALID);
+ redraw_later(UPD_SOME_VALID);
// No Ex mode here!
exmode_active = 0;
linecnt = 0;
if (newfile || read_buffer)
{
- redraw_curbuf_later(NOT_VALID);
+ redraw_curbuf_later(UPD_NOT_VALID);
#ifdef FEAT_DIFF
// After reading the text into the buffer the diff info needs to
// be updated.
emsg(_(e_no_fold_found));
// Force a redraw to remove the Visual highlighting.
if (had_visual)
- redraw_curbuf_later(INVERTED);
+ redraw_curbuf_later(UPD_INVERTED);
}
// openFold() {{{2
emsg(_(e_no_fold_found));
// Force a redraw to remove the Visual highlighting.
if (had_visual)
- redraw_curbuf_later(INVERTED);
+ redraw_curbuf_later(UPD_INVERTED);
}
else
// Deleting markers may make cursor column invalid.
foldUpdateAll(win_T *win)
{
win->w_foldinvalid = TRUE;
- redraw_win_later(win, NOT_VALID);
+ redraw_win_later(win, UPD_NOT_VALID);
}
// foldMoveTo() {{{2
// redraw the screen after getchar()
if (p_ch == 0)
- update_screen(CLEAR);
+ update_screen(UPD_CLEAR);
set_vim_var_nr(VV_MOUSE_WIN, 0);
set_vim_var_nr(VV_MOUSE_WINID, 0);
#endif
)
{
- int type = VALID;
+ int type = UPD_VALID;
if (pum_visible())
{
- type = NOT_VALID;
+ type = UPD_NOT_VALID;
wp->w_lines_valid = 0;
}
}
// Update the screen display
- update_screen(NOT_VALID);
+ update_screen(UPD_NOT_VALID);
# ifdef FEAT_MENU
gui_update_menus(0);
# endif
// TODO here we could handle going to a specific position in the dropped
// file (see src/gui_mac.c, deleted in 8.2.1422)
// Update the screen display
- update_screen(NOT_VALID);
+ update_screen(UPD_NOT_VALID);
}
// Really handle dropped files and folders.
hlgroup->sg_script_ctx.sc_lnum += SOURCING_LNUM;
#endif
hlgroup->sg_cleared = FALSE;
- redraw_all_later(SOME_VALID);
+ redraw_all_later(UPD_SOME_VALID);
// Only call highlight_changed() once after multiple changes.
need_highlight_changed = TRUE;
if (!gui.in_use && !gui.starting)
#endif
{
- must_redraw = CLEAR;
+ must_redraw = UPD_CLEAR;
if (termcap_active && color >= 0)
term_fg_color(color);
}
if (!gui.in_use && !gui.starting)
#endif
{
- must_redraw = CLEAR;
+ must_redraw = UPD_CLEAR;
if (color >= 0)
{
int dark = -1;
if (!gui.in_use && !gui.starting)
#endif
{
- must_redraw = CLEAR;
+ must_redraw = UPD_CLEAR;
if (termcap_active && color >= 0)
term_ul_color(color);
}
{
highlight_gui_started();
did_highlight_changed = TRUE;
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
}
#endif
#ifdef FEAT_VTP
// redrawing. This may happen when evaluating 'statusline' changes the
// StatusLine group.
if (!updating_screen)
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
need_highlight_changed = TRUE;
}
}
FALSE, TRUE, FALSE))
{
gui_mch_new_colors();
- must_redraw = CLEAR;
+ must_redraw = UPD_CLEAR;
}
# ifdef FEAT_GUI_X11
if (set_group_colors((char_u *)"Menu",
# ifdef FEAT_MENU
gui_mch_new_menu_colors();
# endif
- must_redraw = CLEAR;
+ must_redraw = UPD_CLEAR;
}
# ifdef FEAT_BEVAL_GUI
if (set_group_colors((char_u *)"Tooltip",
# ifdef FEAT_TOOLBAR
gui_mch_new_tooltip_colors();
# endif
- must_redraw = CLEAR;
+ must_redraw = UPD_CLEAR;
}
# endif
if (set_group_colors((char_u *)"Scrollbar",
FALSE, FALSE, FALSE))
{
gui_new_scrollbar_colors();
- must_redraw = CLEAR;
+ must_redraw = UPD_CLEAR;
}
# endif
}
// color
cterm_normal_fg_gui_color = HL_TABLE()[idx].sg_gui_fg;
cterm_normal_bg_gui_color = HL_TABLE()[idx].sg_gui_bg;
- must_redraw = CLEAR;
+ must_redraw = UPD_CLEAR;
}
}
}
clear_hl_tables();
- must_redraw = CLEAR;
+ must_redraw = UPD_CLEAR;
for (i = 0; i < highlight_ga.ga_len; ++i)
set_hl_attr(i);
else
appended_lines_mark(n, 1L);
curbuf = buf;
- update_screen(VALID);
+ update_screen(UPD_VALID);
return 0;
}
if (v < 1 || v > w->w_buffer->b_ml.ml_line_count)
luaL_error(L, "line out of range");
w->w_cursor.lnum = v;
- update_screen(VALID);
+ update_screen(UPD_VALID);
}
else if (strncmp(s, "col", 3) == 0)
{
#endif
w->w_cursor.col = v - 1;
w->w_set_curswant = TRUE;
- update_screen(VALID);
+ update_screen(UPD_VALID);
}
else if (strncmp(s, "width", 5) == 0)
{
execute_cmds_from_string(s);
vim_free(s);
- update_screen(VALID);
+ update_screen(UPD_VALID);
return 0;
}
}
lua_pop(L, 1); // function
check_cursor();
- update_screen(NOT_VALID);
+ update_screen(UPD_NOT_VALID);
}
void
// may be use do_cmdline_cmd?
do_cmdline(BYTE_STRING_VALUE(cmd), NULL, NULL, DOCMD_NOWAIT|DOCMD_VERBOSE);
- update_screen(VALID);
+ update_screen(UPD_VALID);
MZ_GC_UNREG();
raise_if_error();
MZ_GC_UNREG();
do_set(command, scope);
vim_free(command);
- update_screen(NOT_VALID);
+ update_screen(UPD_NOT_VALID);
curbuf = save_curb;
curwin = save_curw;
raise_if_error();
win->win->w_cursor.lnum = lnum;
win->win->w_cursor.col = col;
win->win->w_set_curswant = TRUE;
- update_screen(VALID);
+ update_screen(UPD_VALID);
raise_if_error();
return scheme_void;
}
curbuf = savebuf;
- update_screen(VALID);
+ update_screen(UPD_VALID);
MZ_GC_UNREG();
raise_if_error();
free_array(array);
MZ_GC_UNREG();
curbuf = savebuf;
- update_screen(VALID);
+ update_screen(UPD_VALID);
}
MZ_GC_UNREG();
FREETMPS;
LEAVE;
check_cursor();
- update_screen(NOT_VALID);
+ update_screen(UPD_NOT_VALID);
if (!length)
return;
PPCODE:
if (line != NULL)
do_set((char_u *)line, 0);
- update_screen(NOT_VALID);
+ update_screen(UPD_NOT_VALID);
void
DoCommand(line)
win->w_cursor.col = col;
win->w_set_curswant = TRUE;
check_cursor(); /* put cursor on an existing line */
- update_screen(NOT_VALID);
+ update_screen(UPD_NOT_VALID);
}
MODULE = VIM PACKAGE = VIBUF
aucmd_restbuf(&aco);
/* Careful: autocommands may have made "vimbuf" invalid! */
- update_curbuf(VALID);
+ update_curbuf(UPD_VALID);
}
}
}
aucmd_restbuf(&aco);
/* Careful: autocommands may have made "vimbuf" invalid! */
- update_curbuf(VALID);
+ update_curbuf(UPD_VALID);
}
}
}
VimTryStart();
do_cmdline_cmd(cmd);
- update_screen(VALID);
+ update_screen(UPD_VALID);
Python_Release_Vim();
Py_END_ALLOW_THREADS
// When column is out of range silently correct it.
check_cursor_col_win(self->win);
- update_screen(VALID);
+ update_screen(UPD_VALID);
return 0;
}
else if (strcmp(name, "height") == 0)
vim_free(str);
restore_win_for_buf(&switchwin, &save_curbuf);
- update_screen(VALID);
+ update_screen(UPD_VALID);
if (VimTryEnd())
return FAIL;
PyMem_Free(array);
restore_win_for_buf(&switchwin, &save_curbuf);
- update_screen(VALID);
+ update_screen(UPD_VALID);
if (VimTryEnd())
return FAIL;
if (status)
return;
check_cursor();
- update_curbuf(NOT_VALID);
+ update_curbuf(UPD_NOT_VALID);
}
static void
}
}
check_cursor();
- update_curbuf(NOT_VALID);
+ update_curbuf(UPD_NOT_VALID);
}
}
vim_set_option(VALUE self UNUSED, VALUE str)
{
do_set((char_u *)StringValuePtr(str), 0);
- update_screen(NOT_VALID);
+ update_screen(UPD_NOT_VALID);
return Qnil;
}
aucmd_restbuf(&aco);
// Careful: autocommands may have made "buf" invalid!
- update_curbuf(NOT_VALID);
+ update_curbuf(UPD_NOT_VALID);
}
else
{
aucmd_restbuf(&aco);
// Careful: autocommands may have made "buf" invalid!
- update_curbuf(NOT_VALID);
+ update_curbuf(UPD_NOT_VALID);
}
else
{
aucmd_restbuf(&aco);
// Careful: autocommands may have made "buf" invalid!
- update_curbuf(NOT_VALID);
+ update_curbuf(UPD_NOT_VALID);
}
else
{
win->w_cursor.col = NUM2UINT(col);
win->w_set_curswant = TRUE;
check_cursor(); // put cursor on an existing line
- update_screen(NOT_VALID);
+ update_screen(UPD_NOT_VALID);
return Qnil;
}
}
if (flags & FL_UPDATE_CURBUF)
- redraw_curbuf_later(NOT_VALID);
+ redraw_curbuf_later(UPD_NOT_VALID);
curbuf = savebuf;
curwin = savewin;
if (flags & FL_ADJUST_CURSOR)
check_cursor();
if (flags & (FL_UPDATE_SCREEN | FL_UPDATE_CURBUF))
- update_screen(NOT_VALID);
+ update_screen(UPD_NOT_VALID);
return err;
}
curwin = savewin;
curbuf = savebuf;
if (flags & FL_UPDATE_SCREEN)
- update_screen(NOT_VALID);
+ update_screen(UPD_NOT_VALID);
return err;
}
int err;
err = tcldoexcommand(interp, objc, objv, 1);
- update_screen(VALID);
+ update_screen(UPD_VALID);
return err;
}
int err;
err = tclsetoption(interp, objc, objv, 1);
- update_screen(VALID);
+ update_screen(UPD_VALID);
return err;
}
oap->is_VIsual ? start_lnum + oap->line_count :
last_changed + 1, 0L);
else if (oap->is_VIsual)
- redraw_curbuf_later(INVERTED);
+ redraw_curbuf_later(UPD_INVERTED);
if (oap->line_count > p_report)
{
&& tabstop_eq(curbuf->b_p_vts_array, new_vts_array))
; // not changed
else
- redraw_curbuf_later(NOT_VALID);
+ redraw_curbuf_later(UPD_NOT_VALID);
#else
if (curbuf->b_p_ts != new_ts)
- redraw_curbuf_later(NOT_VALID);
+ redraw_curbuf_later(UPD_NOT_VALID);
#endif
if (first_line != 0)
changed_lines(first_line, 0, last_line + 1, 0L);
&& !gui.in_use
#endif
)
- must_redraw = CLEAR;
+ must_redraw = UPD_CLEAR;
else
{
screenclear(); // clear screen
#endif
RedrawingDisabled = 0;
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
no_wait_return = FALSE;
// 'autochdir' has been postponed
validate_cursor();
if (VIsual_active)
- update_curbuf(INVERTED); // update inverted part
+ update_curbuf(UPD_INVERTED); // update inverted part
else if (must_redraw)
{
mch_disable_flush(); // Stop issuing gui_mch_flush().
matchitem_T *m;
int hlg_id;
regprog_T *regprog = NULL;
- int rtype = SOME_VALID;
+ int rtype = UPD_SOME_VALID;
if (*grp == NUL || (pat != NULL && *pat == NUL))
return -1;
}
m->pos.toplnum = toplnum;
m->pos.botlnum = botlnum;
- rtype = VALID;
+ rtype = UPD_VALID;
}
}
{
matchitem_T *cur = wp->w_match_head;
matchitem_T *prev = cur;
- int rtype = SOME_VALID;
+ int rtype = UPD_SOME_VALID;
if (id < 1)
{
wp->w_buffer->b_mod_bot = cur->pos.botlnum;
wp->w_buffer->b_mod_xlines = 0;
}
- rtype = VALID;
+ rtype = UPD_VALID;
}
vim_free(cur);
redraw_win_later(wp, rtype);
vim_free(wp->w_match_head);
wp->w_match_head = m;
}
- redraw_win_later(wp, SOME_VALID);
+ redraw_win_later(wp, UPD_SOME_VALID);
}
/*
set_option_value_give_err((char_u *)"key", 0L, buf->b_p_key, OPT_LOCAL);
}
#endif
- redraw_curbuf_later(NOT_VALID);
+ redraw_curbuf_later(UPD_NOT_VALID);
theend:
vim_free(fname_used);
*/
if (lines_moved)
{
- /*
- */
dp_right->db_txt_start -= data_moved;
dp_right->db_free -= total_moved;
mch_memmove((char *)dp_right + dp_right->db_txt_start,
* Do not use it after calling ml_replace().
*
* Check: The caller of this function should probably also call
- * changed_lines(), unless update_screen(NOT_VALID) is used.
+ * changed_lines(), unless update_screen(UPD_NOT_VALID) is used.
*
* return FAIL for failure, OK otherwise
*/
// pretend screen didn't scroll, need redraw anyway
msg_scrolled = 0;
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
}
#endif
root_menu_ptr = get_root_menu(menu_path);
if (root_menu_ptr == &curwin->w_winbar)
// Assume the window toolbar menu will change.
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
if (enable != MAYBE)
{
FILE *save_scriptout;
if (redraw == TRUE)
- must_redraw = CLEAR;
+ must_redraw = UPD_CLEAR;
// If using ":silent cmd", don't wait for a return. Also don't set
// need_wait_return to do it later.
&& (redraw == TRUE || (msg_scrolled != 0 && redraw != -1)))
{
starttermcap(); // start termcap before redrawing
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
}
}
}
#endif
++msg_scrolled;
- if (must_redraw < VALID)
- must_redraw = VALID;
+ if (must_redraw < UPD_VALID)
+ must_redraw = UPD_VALID;
}
/*
if (wp->w_buffer == buf && wp->w_status_height)
{
wp->w_redr_status = TRUE;
- if (must_redraw < VALID)
- must_redraw = VALID;
+ if (must_redraw < UPD_VALID)
+ must_redraw = UPD_VALID;
}
}
# endif
)
{
- redraw_later(CLEAR);
+ redraw_later(UPD_CLEAR);
update_screen(0);
redrawcmd();
}
if (retval)
curwin->w_set_curswant = TRUE;
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
return retval;
}
if (jump_flags)
{
jump_flags = jump_to_mouse(jump_flags, NULL, which_button);
- update_curbuf(VIsual_active ? INVERTED : VALID);
+ update_curbuf(VIsual_active ? UPD_INVERTED : UPD_VALID);
setcursor();
out_flush(); // Update before showing popup menu
}
curwin->w_set_curswant = TRUE;
}
if (is_click)
- redraw_curbuf_later(INVERTED); // update the inversion
+ redraw_curbuf_later(UPD_INVERTED); // update the inversion
}
else if (VIsual_active && !old_active)
{
// overlapped by the popup menu.
if (pum_visible() && did_scroll)
{
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
ins_compl_show_pum();
}
if (flags & MOUSE_MAY_STOP_VIS)
{
end_visual_mode_keep_button();
- redraw_curbuf_later(INVERTED); // delete the inversion
+ redraw_curbuf_later(UPD_INVERTED); // delete the inversion
}
#if defined(FEAT_CMDWIN) && defined(FEAT_CLIPBOARD)
// Continue a modeless selection in another window.
&& (flags & MOUSE_MAY_STOP_VIS))))
{
end_visual_mode_keep_button();
- redraw_curbuf_later(INVERTED); // delete the inversion
+ redraw_curbuf_later(UPD_INVERTED); // delete the inversion
}
#ifdef FEAT_CMDWIN
if (cmdwin_type != 0 && wp != curwin)
if (flags & MOUSE_MAY_STOP_VIS)
{
end_visual_mode_keep_button();
- redraw_curbuf_later(INVERTED); // delete the inversion
+ redraw_curbuf_later(UPD_INVERTED); // delete the inversion
}
#if defined(FEAT_CMDWIN) && defined(FEAT_CLIPBOARD)
#endif
curwin->w_valid &=
~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
row = 0;
}
else if (row >= curwin->w_height)
#ifdef FEAT_DIFF
check_topfill(curwin, FALSE);
#endif
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
curwin->w_valid &=
~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
row = curwin->w_height - 1;
// Only use ScreenCols[] after the window was redrawn. Mainly matters
// for tests, a user would not click before redrawing.
// Do not use when 'virtualedit' is active.
- if (curwin->w_redr_type <= VALID_NO_UPDATE && !virtual_active())
+ if (curwin->w_redr_type <= UPD_VALID_NO_UPDATE && !virtual_active())
col_from_screen = ScreenCols[off];
#ifdef FEAT_FOLDING
// Remember the character under the mouse, it might be a '-' or '+' in
&& !pum_visible())
{
// win_line() will redraw the number column and cursorline only.
- redraw_win_later(wp, VALID);
+ redraw_win_later(wp, UPD_VALID);
}
}
{
if ((wp->w_valid & VALID_VIRTCOL) == 0 && !pum_visible())
{
- // When 'cursorcolumn' is set need to redraw with SOME_VALID.
+ // When 'cursorcolumn' is set need to redraw with UPD_SOME_VALID.
if (wp->w_p_cuc)
- redraw_win_later(wp, SOME_VALID);
- // When 'cursorlineopt' contains "screenline" need to redraw with VALID.
+ redraw_win_later(wp, UPD_SOME_VALID);
+ // When 'cursorlineopt' contains "screenline" need to redraw with
+ // UPD_VALID.
else if (wp->w_p_cul && (wp->w_p_culopt_flags & CULOPT_SCRLINE))
- redraw_win_later(wp, VALID);
+ redraw_win_later(wp, UPD_VALID);
}
}
#endif
if (BUFEMPTY()) // special case - file is empty
{
if (curwin->w_topline != 1)
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
curwin->w_topline = 1;
curwin->w_botline = 2;
curwin->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
if (curwin->w_skipcol != 0)
{
curwin->w_skipcol = 0;
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
}
else
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
// May need to set w_skipcol when cursor in w_topline.
if (curwin->w_cursor.lnum == curwin->w_topline)
validate_cursor();
wp->w_lines_valid = 0;
changed_line_abv_curs_win(wp);
wp->w_valid &= ~(VALID_BOTLINE|VALID_BOTLINE_AP|VALID_TOPLINE);
- redraw_win_later(wp, NOT_VALID);
+ redraw_win_later(wp, UPD_NOT_VALID);
}
/*
#endif
wp->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_TOPLINE);
// Don't set VALID_TOPLINE here, 'scrolloff' needs to be checked.
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
}
/*
{
curwin->w_leftcol = new_leftcol;
// screen has to be redrawn with new curwin->w_leftcol
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
}
}
curwin->w_wcol -= curwin->w_leftcol;
else
curwin->w_skipcol = 0;
if (prev_skipcol != curwin->w_skipcol)
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
#ifdef FEAT_SYN_HL
redraw_for_cursorcolumn(curwin);
#endif
}
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
return retval;
}
#endif
cursor_correct();
beginline(BL_SOL | BL_FIX);
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
}
void
// Correct cursor for multi-byte character.
if (has_mbyte)
mb_adjust_cursor();
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
// Only scroll when 'scrollbind' hasn't done this.
if (!curwin->w_p_scb)
// remove all signs and update the screen after gutter removal
coloncmd(":sign unplace *");
changed_window_setting();
- update_screen(CLEAR);
+ update_screen(UPD_CLEAR);
setcursor();
cursor_on();
out_flush_cursor(TRUE, FALSE);
}
// gui_update_cursor(TRUE, FALSE);
- // update_curbuf(NOT_VALID);
+ // update_curbuf(UPD_NOT_VALID);
update_topline(); // scroll to show the line
- update_screen(VALID);
+ update_screen(UPD_VALID);
setcursor();
cursor_on();
out_flush_cursor(TRUE, FALSE);
args = (char_u *)cp;
coloncmd(":sign unplace %d buffer=%d",
serNum, buf->bufp->b_fnum);
- redraw_buf_later(buf->bufp, NOT_VALID);
+ redraw_buf_later(buf->bufp, UPD_NOT_VALID);
#endif
// =====================================================================
}
}
}
#endif
- redraw_buf_later(buf->bufp, NOT_VALID);
+ redraw_buf_later(buf->bufp, UPD_NOT_VALID);
}
}
// =====================================================================
*/
if (buf != NULL && buf->initDone && do_update)
{
- update_screen(NOT_VALID);
+ update_screen(UPD_NOT_VALID);
setcursor();
cursor_on();
out_flush_cursor(TRUE, FALSE);
// update the screen after having added the gutter
changed_window_setting();
- update_screen(CLEAR);
+ update_screen(UPD_CLEAR);
setcursor();
cursor_on();
out_flush_cursor(TRUE, FALSE);
&& !(mod_mask & MOD_MASK_SHIFT))
{
end_visual_mode();
- redraw_curbuf_later(INVERTED);
+ redraw_curbuf_later(UPD_INVERTED);
}
// Keys that work different when 'keymodel' contains "startsel"
if (VIsual_active)
{
end_visual_mode();
- redraw_curbuf_later(INVERTED); // delete the inversion later
+ redraw_curbuf_later(UPD_INVERTED); // delete the inversion later
}
VIsual_reselect = FALSE;
}
if (VIsual_active)
{
end_visual_mode();
- redraw_curbuf_later(INVERTED); // delete the inversion later
+ redraw_curbuf_later(UPD_INVERTED); // delete the inversion later
VIsual_reselect = FALSE;
}
}
scrolldown(-y, FALSE);
}
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
cursor_correct();
curwin->w_redr_status = TRUE;
}
}
if (curwin->w_cursor.lnum != prev_lnum)
coladvance(curwin->w_curswant);
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
}
/*
// FALLTHROUGH
case 't': scroll_cursor_top(0, TRUE);
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
set_fraction(curwin);
break;
// FALLTHROUGH
case 'z': scroll_cursor_halfway(TRUE);
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
set_fraction(curwin);
break;
// FALLTHROUGH
case 'b': scroll_cursor_bot(0, TRUE);
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
set_fraction(curwin);
break;
if (curwin->w_leftcol != col)
{
curwin->w_leftcol = col;
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
}
}
break;
if (curwin->w_leftcol != col)
{
curwin->w_leftcol = col;
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
}
}
break;
}
# endif
#endif
- redraw_later(CLEAR);
+ redraw_later(UPD_CLEAR);
#if defined(MSWIN) && (!defined(FEAT_GUI_MSWIN) || defined(VIMDLL))
# ifdef VIMDLL
if (!gui.in_use)
#ifdef FEAT_SEARCH_EXTRA
// Redraw the window to refresh the highlighted matches.
if (i > 0 && p_hls && !no_hlsearch)
- redraw_later(SOME_VALID);
+ redraw_later(UPD_SOME_VALID);
#endif
}
#ifdef FEAT_SEARCH_EXTRA
// Redraw the window to refresh the highlighted matches.
if (!EQUAL_POS(curwin->w_cursor, prev_cursor) && p_hls && !no_hlsearch)
- redraw_later(SOME_VALID);
+ redraw_later(UPD_SOME_VALID);
#endif
// "/$" will put the cursor after the end of the line, may need to
showmode();
may_trigger_modechanged();
}
- redraw_curbuf_later(INVERTED); // update the inversion
+ redraw_curbuf_later(UPD_INVERTED); // update the inversion
}
else // start Visual mode
{
}
else
curwin->w_set_curswant = TRUE;
- redraw_curbuf_later(INVERTED); // show the inversion
+ redraw_curbuf_later(UPD_INVERTED); // show the inversion
}
else
{
// Only need to redraw this line, unless still need to redraw an old
// Visual area (when 'lazyredraw' is set).
- if (curwin->w_redr_type < INVERTED)
+ if (curwin->w_redr_type < UPD_INVERTED)
{
curwin->w_old_cursor_lnum = curwin->w_cursor.lnum;
curwin->w_old_visual_lnum = curwin->w_cursor.lnum;
// end are still the same, and the selection needs to be owned
clip_star.vmode = NUL;
#endif
- redraw_curbuf_later(INVERTED);
+ redraw_curbuf_later(UPD_INVERTED);
showmode();
}
if (VIsual_active)
{
end_visual_mode(); // stop Visual
- redraw_curbuf_later(INVERTED);
+ redraw_curbuf_later(UPD_INVERTED);
}
// CTRL-\ CTRL-G restarts Insert mode when 'insertmode' is set.
if (cap->nchar == Ctrl_G && p_im)
end_visual_mode(); // stop Visual
check_cursor_col(); // make sure cursor is not beyond EOL
curwin->w_set_curswant = TRUE;
- redraw_curbuf_later(INVERTED);
+ redraw_curbuf_later(UPD_INVERTED);
}
else if (no_reason)
vim_beep(BO_ESC);
if (!did_change && oap->is_VIsual)
// No change: need to remove the Visual selection
- redraw_curbuf_later(INVERTED);
+ redraw_curbuf_later(UPD_INVERTED);
if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0)
{
// vis block is still marked. Get rid of it now.
curwin->w_cursor.lnum = oap->start.lnum;
- update_screen(INVERTED);
+ update_screen(UPD_INVERTED);
if (oap->block_mode)
{
if (!change_cnt && oap->is_VIsual)
// No change: need to remove the Visual selection
- redraw_curbuf_later(INVERTED);
+ redraw_curbuf_later(UPD_INVERTED);
// Set '[ mark if something changed. Keep the last end
// position from do_addsub().
// make sure redrawing is correct
curwin->w_p_lbr = lbr_saved;
#endif
- redraw_curbuf_later(INVERTED);
+ redraw_curbuf_later(UPD_INVERTED);
}
}
}
#ifdef FEAT_LINEBREAK
curwin->w_p_lbr = lbr_saved;
#endif
- redraw_curbuf_later(INVERTED);
+ redraw_curbuf_later(UPD_INVERTED);
}
// If the end of an operator is in column one while oap->motion_type
set_options_default(OPT_FREE | opt_flags);
didset_options();
didset_options2();
- redraw_all_later(CLEAR);
+ redraw_all_later(UPD_CLEAR);
}
else
{
}
if (full_screen)
ttest(FALSE);
- redraw_all_later(CLEAR);
+ redraw_all_later(UPD_CLEAR);
}
}
// when 'ignorecase' is set or reset and 'hlsearch' is set, redraw
else if ((int *)varp == &p_ic && p_hls)
{
- redraw_all_later(SOME_VALID);
+ redraw_all_later(UPD_SOME_VALID);
}
#ifdef FEAT_SEARCH_EXTRA
// 'relativenumber' option is toggled, then don't refresh the screen
// (optimization).
if (!(curwin->w_p_nu && ((int *)varp == &curwin->w_p_rnu)))
- redraw_all_later(CLEAR);
+ redraw_all_later(UPD_CLEAR);
}
#endif
if ((flags & P_RBUF) || (flags & P_RWIN) || all)
changed_window_setting();
if (flags & P_RBUF)
- redraw_curbuf_later(NOT_VALID);
+ redraw_curbuf_later(UPD_NOT_VALID);
if (flags & P_RWINONLY)
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
if (doclear)
- redraw_all_later(CLEAR);
+ redraw_all_later(UPD_CLEAR);
else if (all)
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
}
/*
add_termcode(key_name, string, FALSE);
if (full_screen)
ttest(FALSE);
- redraw_all_later(CLEAR);
+ redraw_all_later(UPD_CLEAR);
return NULL;
}
case PV_LCS:
clear_string_option(&((win_T *)from)->w_p_lcs);
set_chars_option((win_T *)from, &((win_T *)from)->w_p_lcs, TRUE);
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
break;
case PV_FCS:
clear_string_option(&((win_T *)from)->w_p_fcs);
set_chars_option((win_T *)from, &((win_T *)from)->w_p_fcs, TRUE);
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
break;
case PV_VE:
clear_string_option(&((win_T *)from)->w_p_ve);
errmsg = e_invalid_argument;
// list setting requires a redraw
if (curwin->w_briopt_list)
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
}
#endif
// Redraw needed when switching to/from "mac": a CR in the text
// will be displayed differently.
if (get_fileformat(curbuf) == EOL_MAC || *oldval == 'm')
- redraw_curbuf_later(NOT_VALID);
+ redraw_curbuf_later(UPD_NOT_VALID);
}
}
(void)set_chars_option(wp, local_ptr, TRUE);
}
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
}
}
// local 'listchars'
if (varp == &T_ME)
{
out_str(T_ME);
- redraw_later(CLEAR);
+ redraw_later(UPD_CLEAR);
#if defined(MSWIN) && (!defined(FEAT_GUI_MSWIN) || defined(VIMDLL))
// Since t_me has been set, this probably means that the user
// wants to use this as default colors. Need to reset default
if (curwin->w_status_height)
{
curwin->w_redr_status = TRUE;
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
}
curbuf->b_help = (curbuf->b_p_bt[0] == 'h');
redraw_titles();
// redraw
if ((varp == &p_flp || varp == &(curbuf->b_p_flp))
&& curwin->w_briopt_list)
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
#endif
if (curwin->w_curswant != MAXCOL
// back to a sane mode. We should redraw, but we can't really do that
// in a signal handler, do a redraw later.
after_sigcont();
- redraw_later(CLEAR);
+ redraw_later(UPD_CLEAR);
cursor_on_force();
out_flush();
}
{
// The screen is now messed up, must redraw the command
// line and later all the windows.
- redraw_all_later(CLEAR);
+ redraw_all_later(UPD_CLEAR);
compute_cmdrow();
redrawcmd();
}
// sequence may be inserted asynchronously.
if (len < 0)
{
- redraw_all_later(CLEAR);
+ redraw_all_later(UPD_CLEAR);
return;
}
{
pum_position_info_popup(curwin);
if (win_valid(curwin_save))
- redraw_win_later(curwin_save, SOME_VALID);
+ redraw_win_later(curwin_save, UPD_SOME_VALID);
}
# endif
if ((curwin != curwin_save && win_valid(curwin_save))
// Return cursor to where we were
validate_cursor();
- redraw_later(SOME_VALID);
+ redraw_later(UPD_SOME_VALID);
// When the preview window was resized we need to
// update the view on the buffer. Only go back to
pum_undisplay(void)
{
pum_array = NULL;
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
redraw_tabline = TRUE;
status_redraw_all();
#if defined(FEAT_PROP_POPUP) && defined(FEAT_QUICKFIX)
}
}
popup_set_firstline(wp);
- redraw_win_later(wp, NOT_VALID);
+ redraw_win_later(wp, UPD_NOT_VALID);
}
}
}
sign_place(&sign_id, (char_u *)"PopUpMenu", sign_name,
wp->w_buffer, wp->w_cursor.lnum, SIGN_DEF_PRIO);
- redraw_win_later(wp, NOT_VALID);
+ redraw_win_later(wp, UPD_NOT_VALID);
}
else
sign_undefine_by_name(sign_name, FALSE);
{
wp->w_popup_flags |= POPF_HIDDEN;
if (win_valid(wp->w_popup_prop_win))
- redraw_win_later(wp->w_popup_prop_win, SOME_VALID);
+ redraw_win_later(wp->w_popup_prop_win, UPD_SOME_VALID);
}
return;
}
|| org_width != wp->w_width
|| org_height != wp->w_height)
{
- redraw_win_later(wp, NOT_VALID);
+ redraw_win_later(wp, UPD_NOT_VALID);
if (wp->w_popup_flags & POPF_ON_CMDLINE)
clear_cmdline = TRUE;
popup_mask_refresh = TRUE;
wp->w_vsep_width = 0;
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
popup_mask_refresh = TRUE;
#ifdef FEAT_TERMINAL
{
wp->w_popup_flags |= POPF_HIDDEN;
// Do not decrement b_nwindows, we still reference the buffer.
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
popup_mask_refresh = TRUE;
}
}
if ((wp->w_popup_flags & POPF_HIDDEN) != 0)
{
wp->w_popup_flags &= ~POPF_HIDDEN;
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
popup_mask_refresh = TRUE;
}
}
else
{
popup_set_buffer_text(wp->w_buffer, argvars[1]);
- redraw_win_later(wp, NOT_VALID);
+ redraw_win_later(wp, UPD_NOT_VALID);
popup_adjust_position(wp);
}
}
clear_cmdline = TRUE;
win_free_popup(wp);
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
popup_mask_refresh = TRUE;
}
apply_options(wp, dict, FALSE);
if (old_firstline != wp->w_firstline)
- redraw_win_later(wp, NOT_VALID);
+ redraw_win_later(wp, UPD_NOT_VALID);
popup_adjust_position(wp);
}
int redrawing_all_win;
// Need to recompute when switching tabs.
- // Also recompute when the type is CLEAR or NOT_VALID, something basic
- // (such as the screen size) must have changed.
- if (popup_mask_tab != curtab || type >= NOT_VALID)
+ // Also recompute when the type is UPD_CLEAR or UPD_NOT_VALID, something
+ // basic (such as the screen size) must have changed.
+ if (popup_mask_tab != curtab || type >= UPD_NOT_VALID)
{
popup_mask_refresh = TRUE;
redraw_all_popups = TRUE;
// compare with "popup_mask" to see what changed.
redrawing_all_win = TRUE;
FOR_ALL_WINDOWS(wp)
- if (wp->w_redr_type < SOME_VALID)
+ if (wp->w_redr_type < UPD_SOME_VALID)
redrawing_all_win = FALSE;
if (redrawing_all_win)
mask = popup_mask;
#if defined(FEAT_TERMINAL)
// A terminal window needs to be redrawn.
if (bt_terminal(wp->w_buffer))
- redraw_win_later(wp, NOT_VALID);
+ redraw_win_later(wp, UPD_NOT_VALID);
else
#endif
{
if (wp->w_popup_title != NULL)
vim_snprintf((char *)wp->w_popup_title, len, " %s ",
wp->w_buffer->b_fname);
- redraw_win_later(wp, VALID);
+ redraw_win_later(wp, UPD_VALID);
}
}
curwin->w_cursor.coladd = 0;
curwin->w_curswant = 0;
update_topline(); // scroll to show the line
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
curwin->w_redr_status = TRUE; // update ruler
curwin = old_curwin;
curbuf = curwin->w_buffer;
// Only redraw when added lines are visible. This avoids flickering
// when the added lines are not visible.
if ((win = qf_find_win(qi)) != NULL && old_line_count < win->w_botline)
- redraw_buf_later(buf, NOT_VALID);
+ redraw_buf_later(buf, UPD_NOT_VALID);
}
}
--curbuf_lock;
// make sure it will be redrawn
- redraw_curbuf_later(NOT_VALID);
+ redraw_curbuf_later(UPD_NOT_VALID);
}
// Restore KeyTyped, setting 'filetype' may reset it.
#ifdef FEAT_FOLDING
foldUpdateAll(curwin);
#else
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
#endif
}
{
// Enable macro indicator temporarily
set_option_value((char_u *)"ch", 1L, NULL, 0);
- update_screen(VALID);
+ update_screen(UPD_VALID);
changed_cmdheight = TRUE;
}
{
// Restore cmdheight
set_option_value((char_u *)"ch", 0L, NULL, 0);
- redraw_all_later(CLEAR);
+ redraw_all_later(UPD_CLEAR);
}
}
return retval;
screen_Rows = Rows;
screen_Columns = Columns;
- must_redraw = CLEAR; // need to clear the screen later
+ must_redraw = UPD_CLEAR; // need to clear the screen later
if (doclear)
screenclear2();
#ifdef FEAT_GUI
win_rest_invalid(firstwin);
redraw_cmdline = TRUE;
redraw_tabline = TRUE;
- if (must_redraw == CLEAR) // no need to clear again
- must_redraw = NOT_VALID;
+ if (must_redraw == UPD_CLEAR) // no need to clear again
+ must_redraw = UPD_NOT_VALID;
compute_cmdrow();
msg_row = cmdline_row; // put cursor on last line for messages
msg_col = 0;
{
while (wp != NULL)
{
- redraw_win_later(wp, NOT_VALID);
+ redraw_win_later(wp, UPD_NOT_VALID);
wp->w_redr_status = TRUE;
wp = wp->w_next;
}
#ifdef FEAT_SEARCH_EXTRA
// If 'hlsearch' set and search pat changed: need redraw.
if (p_hls)
- redraw_all_later(SOME_VALID);
+ redraw_all_later(UPD_SOME_VALID);
set_no_hlsearch(FALSE);
#endif
}
# ifdef FEAT_SEARCH_EXTRA
// If 'hlsearch' set and search pat changed: need redraw.
if (p_hls && idx == last_idx && !no_hlsearch)
- redraw_all_later(SOME_VALID);
+ redraw_all_later(UPD_SOME_VALID);
# endif
}
#endif
*/
if (no_hlsearch && !(options & SEARCH_KEEP))
{
- redraw_all_later(SOME_VALID);
+ redraw_all_later(UPD_SOME_VALID);
set_no_hlsearch(FALSE);
}
#endif
if (dollar_vcol >= 0 && dollar_vcol == curwin->w_virtcol)
dollar_vcol = -1;
++curwin->w_virtcol; // do display ')' just before "$"
- update_screen(VALID); // show the new char first
+ update_screen(UPD_VALID); // show the new char first
save_dollar_vcol = dollar_vcol;
#ifdef CURSOR_SHAPE
// end are still the same, and the selection needs to be owned
clip_star.vmode = NUL;
#endif
- redraw_curbuf_later(INVERTED);
+ redraw_curbuf_later(UPD_INVERTED);
showmode();
return OK;
{
// Return cursor to where we were
validate_cursor();
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
win_enter(curwin_save, TRUE);
}
# ifdef FEAT_PROP_POPUP
// column for signs.
if (buf->b_signlist == NULL)
{
- redraw_buf_later(buf, NOT_VALID);
+ redraw_buf_later(buf, UPD_NOT_VALID);
changed_line_abv_curs();
}
// sign columns no longer shows. And the 'signcolumn' may be hidden.
if (buf->b_signlist == NULL)
{
- redraw_buf_later(buf, NOT_VALID);
+ redraw_buf_later(buf, UPD_NOT_VALID);
changed_line_abv_curs();
}
// sign column. Not when curwin is NULL (this means we're exiting).
if (buf->b_signlist != NULL && curwin != NULL)
{
- redraw_buf_later(buf, NOT_VALID);
+ redraw_buf_later(buf, UPD_NOT_VALID);
changed_line_abv_curs();
}
// non-empty sign list.
FOR_ALL_WINDOWS(wp)
if (wp->w_buffer->b_signlist != NULL)
- redraw_buf_later(wp->w_buffer, NOT_VALID);
+ redraw_buf_later(wp->w_buffer, UPD_NOT_VALID);
}
// set values for a defined sign.
if (sign_id == 0)
{
// Delete all the signs in the specified buffer
- redraw_buf_later(buf, NOT_VALID);
+ redraw_buf_later(buf, UPD_NOT_VALID);
buf_delete_signs(buf, sign_group);
}
else
}
}
}
- redraw_win_later(wp, NOT_VALID);
+ redraw_win_later(wp, UPD_NOT_VALID);
theend:
vim_free(spl_copy);
if (curbuf->b_ml.ml_line_count > 1)
ml_delete(curbuf->b_ml.ml_line_count);
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
}
/*
if (spell_load_file(fname, NULL, slang, FALSE) == NULL)
// reloading failed, clear the language
slang_clear(slang);
- redraw_all_later(SOME_VALID);
+ redraw_all_later(UPD_SOME_VALID);
didit = TRUE;
}
}
if (buf != NULL)
buf_reload(buf, buf->b_orig_mode, FALSE);
- redraw_all_later(SOME_VALID);
+ redraw_all_later(UPD_SOME_VALID);
}
vim_free(fnamebuf);
}
int w_redr_type; // type of redraw to be performed on win
int w_upd_rows; // number of window lines to update when
- // w_redr_type is REDRAW_TOP
+ // w_redr_type is UPD_REDRAW_TOP
linenr_T w_redraw_top; // when != 0: first line needing redraw
linenr_T w_redraw_bot; // when != 0: last line needing redraw
int w_redr_status; // if TRUE status line must be redrawn
}
// assume spell checking changed, force a redraw
- redraw_win_later(curwin, NOT_VALID);
+ redraw_win_later(curwin, UPD_NOT_VALID);
}
/*
curbuf->b_p_isk = save_isk;
}
}
- redraw_win_later(curwin, NOT_VALID);
+ redraw_win_later(curwin, UPD_NOT_VALID);
}
/*
arg = skipwhite(arg_end);
}
}
- redraw_curbuf_later(SOME_VALID);
+ redraw_curbuf_later(UPD_SOME_VALID);
syn_stack_free_all(curwin->w_s); // Need to recompute all syntax.
}
else
semsg(_(e_invalid_argument_str), arg);
- redraw_curbuf_later(SOME_VALID);
+ redraw_curbuf_later(UPD_SOME_VALID);
syn_stack_free_all(curwin->w_s); // Need to recompute all syntax.
}
++curwin->w_s->b_syn_folditems;
#endif
- redraw_curbuf_later(SOME_VALID);
+ redraw_curbuf_later(UPD_SOME_VALID);
syn_stack_free_all(curwin->w_s); // Need to recompute all syntax.
return; // don't free the progs and patterns now
}
}
}
- redraw_curbuf_later(SOME_VALID);
+ redraw_curbuf_later(UPD_SOME_VALID);
syn_stack_free_all(curwin->w_s); // Need to recompute all syntax.
success = TRUE; // don't free the progs and patterns now
}
if (got_clstr)
{
- redraw_curbuf_later(SOME_VALID);
+ redraw_curbuf_later(UPD_SOME_VALID);
syn_stack_free_all(curwin->w_s); // Need to recompute all.
}
}
else if (!finished)
{
set_nextcmd(eap, arg_start);
- redraw_curbuf_later(SOME_VALID);
+ redraw_curbuf_later(UPD_SOME_VALID);
syn_stack_free_all(curwin->w_s); // Need to recompute all syntax.
}
}
{
// Return cursor to where we were
validate_cursor();
- redraw_later(VALID);
+ redraw_later(UPD_VALID);
win_enter(curwin_save, TRUE);
}
#endif
init_highlight(TRUE, FALSE);
# ifdef DEBUG_TERMRESPONSE
{
- int r = redraw_asap(CLEAR);
+ int r = redraw_asap(UPD_CLEAR);
log_tr("Received t_Co, redraw_asap(): %d", r);
}
# else
- redraw_asap(CLEAR);
+ redraw_asap(UPD_CLEAR);
# endif
}
}
do_check_scrollbind(TRUE);
if (State & MODE_CMDLINE)
{
- update_screen(NOT_VALID);
+ update_screen(UPD_NOT_VALID);
redrawcmdline();
}
else
update_topline();
if (pum_visible())
{
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
ins_compl_show_pum();
}
- update_screen(NOT_VALID);
+ update_screen(UPD_NOT_VALID);
if (redrawing())
setcursor();
}
now = start;
profile_end(&now);
fprintf(fd_tr, "%s: %s ", profile_msg(&now),
- must_redraw == NOT_VALID ? "NV"
- : must_redraw == CLEAR ? "CL" : " ");
+ must_redraw == UPD_NOT_VALID ? "NV"
+ : must_redraw == UPD_CLEAR ? "CL" : " ");
va_start(ap, fmt);
vfprintf(fd_tr, fmt, ap);
va_end(ap);
set_option_value_give_err((char_u *)"ambw", 0L, (char_u *)aw, 0);
# ifdef DEBUG_TERMRESPONSE
{
- int r = redraw_asap(CLEAR);
+ int r = redraw_asap(UPD_CLEAR);
log_tr("set 'ambiwidth', redraw_asap(): %d", r);
}
# else
- redraw_asap(CLEAR);
+ redraw_asap(UPD_CLEAR);
# endif
# ifdef FEAT_EVAL
set_vim_var_string(VV_TERMU7RESP, tp, csi_len);
set_option_value_give_err((char_u *)"bg",
0L, (char_u *)new_bg_val, 0);
reset_option_was_set((char_u *)"bg");
- redraw_asap(CLEAR);
+ redraw_asap(UPD_CLEAR);
}
}
# ifdef FEAT_TERMINAL
ch_log(term->tl_job->jv_channel, "updating screen");
if (buffer == curbuf && (State & MODE_CMDLINE) == 0)
{
- update_screen(VALID_NO_UPDATE);
+ update_screen(UPD_VALID_NO_UPDATE);
// update_screen() can be slow, check the terminal wasn't closed
// already
if (buffer == curbuf && curbuf->b_term != NULL)
if (wp->w_topline < min_topline)
wp->w_topline = min_topline;
}
- redraw_win_later(wp, NOT_VALID);
+ redraw_win_later(wp, UPD_NOT_VALID);
}
}
}
if (term->tl_channel_closed)
cleanup_vterm(term);
- redraw_buf_and_status_later(curbuf, NOT_VALID);
+ redraw_buf_and_status_later(curbuf, UPD_NOT_VALID);
#ifdef FEAT_PROP_POPUP
if (WIN_IS_POPUP(curwin))
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
#endif
}
term->tl_dirty_row_start = MIN(term->tl_dirty_row_start, rect.start_row);
term->tl_dirty_row_end = MAX(term->tl_dirty_row_end, rect.end_row);
set_dirty_snapshot(term);
- redraw_buf_later(term->tl_buffer, SOME_VALID);
+ redraw_buf_later(term->tl_buffer, UPD_SOME_VALID);
return 1;
}
// Note sure if the scrolling will work correctly, let's do a complete
// redraw later.
- redraw_buf_later(term->tl_buffer, NOT_VALID);
+ redraw_buf_later(term->tl_buffer, UPD_NOT_VALID);
return 1;
}
win_setwidth_win(cols, wp);
}
}
- redraw_buf_later(term->tl_buffer, NOT_VALID);
+ redraw_buf_later(term->tl_buffer, UPD_NOT_VALID);
}
return 1;
}
ch_log(NULL, "terminal job finished");
}
- redraw_buf_and_status_later(term->tl_buffer, NOT_VALID);
+ redraw_buf_and_status_later(term->tl_buffer, UPD_NOT_VALID);
return FALSE;
}
screen = vterm_obtain_screen(vterm);
state = vterm_obtain_state(vterm);
- // We use NOT_VALID on a resize or scroll, redraw everything then. With
- // SOME_VALID only redraw what was marked dirty.
- if (wp->w_redr_type > SOME_VALID)
+ // We use UPD_NOT_VALID on a resize or scroll, redraw everything then.
+ // With UPD_SOME_VALID only redraw what was marked dirty.
+ if (wp->w_redr_type > UPD_SOME_VALID)
{
term->tl_dirty_row_start = 0;
term->tl_dirty_row_end = MAX_ROW;
if (term_is_finished(curbuf) && term->tl_scrollback.ga_len > 0)
{
free_scrollback(term);
- redraw_buf_later(term->tl_buffer, NOT_VALID);
+ redraw_buf_later(term->tl_buffer, UPD_NOT_VALID);
// The buffer is now like a normal buffer, it cannot be easily
// abandoned when changed.
while (!(curbuf->b_ml.ml_flags & ML_EMPTY))
ml_delete((linenr_T)1);
free_scrollback(curbuf->b_term);
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
}
}
else
term->tl_top_diff_rows = bot_rows;
term->tl_bot_diff_rows = top_rows;
- update_screen(NOT_VALID);
+ update_screen(UPD_NOT_VALID);
return OK;
}
if (!format_only && haveto_redraw)
{
update_topline();
- redraw_curbuf_later(VALID);
+ redraw_curbuf_later(UPD_VALID);
}
}
if (oap->is_VIsual)
// When there is no change: need to remove the Visual selection
- redraw_curbuf_later(INVERTED);
+ redraw_curbuf_later(UPD_INVERTED);
if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0)
// Set '[ mark at the start of the formatted area
{
if (oap->is_VIsual)
// When there is no change: need to remove the Visual selection
- redraw_curbuf_later(INVERTED);
+ redraw_curbuf_later(UPD_INVERTED);
if (fex_format(oap->start.lnum, oap->line_count, NUL) != 0)
// As documented: when 'formatexpr' returns non-zero fall back to
{
// should do something when inclusive == FALSE !
VIsual = start_pos;
- redraw_curbuf_later(INVERTED); // update the inversion
+ redraw_curbuf_later(UPD_INVERTED); // update the inversion
}
else
{
VIsual = start_pos;
VIsual_mode = 'v';
redraw_cmdline = TRUE; // show mode later
- redraw_curbuf_later(INVERTED); // update the inversion
+ redraw_curbuf_later(UPD_INVERTED); // update the inversion
}
else
{
inc(&curwin->w_cursor); // include the line break
VIsual = start_pos;
VIsual_mode = 'v';
- redraw_curbuf_later(INVERTED); // update the inversion
+ redraw_curbuf_later(UPD_INVERTED); // update the inversion
showmode();
}
else
inc_cursor();
VIsual = start_pos;
VIsual_mode = 'v';
- redraw_curbuf_later(INVERTED); // update the inversion
+ redraw_curbuf_later(UPD_INVERTED); // update the inversion
showmode();
}
else
VIsual.col = 0;
}
VIsual_mode = 'V';
- redraw_curbuf_later(INVERTED); // update the inversion
+ redraw_curbuf_later(UPD_INVERTED); // update the inversion
showmode();
}
else
|| line[VIsual.col - 1] != quotechar)))))
{
VIsual = curwin->w_cursor;
- redraw_curbuf_later(INVERTED);
+ redraw_curbuf_later(UPD_INVERTED);
}
}
else
return;
}
- redraw_buf_later(buf, VALID);
+ redraw_buf_later(buf, UPD_VALID);
}
/*
start_lnum, end_lnum, start_col, end_col);
text = NULL;
- redraw_buf_later(buf, VALID);
+ redraw_buf_later(buf, UPD_VALID);
theend:
vim_free(text);
}
}
if (did_clear)
- redraw_buf_later(buf, NOT_VALID);
+ redraw_buf_later(buf, UPD_NOT_VALID);
}
/*
{
changed_line_display_buf(buf);
changed_lines_buf(buf, first_changed, last_changed + 1, 0);
- redraw_buf_later(buf, VALID);
+ redraw_buf_later(buf, UPD_VALID);
}
if (did_remove_text)
FOR_ALL_WINDOWS(wp)
{
if (wp->w_buffer == curbuf && wp->w_p_cole > 0)
- redraw_win_later(wp, NOT_VALID);
+ redraw_win_later(wp, UPD_NOT_VALID);
}
}
#endif
static int included_patches[] =
{ /* Add new patch number below this line */
+/**/
+ 206,
/**/
205,
/**/
#endif
/*
- * flags for update_screen()
- * The higher the value, the higher the priority
+ * Flags for update_screen().
+ * The higher the value, the higher the priority.
*/
-#define VALID_NO_UPDATE 5 // no new changes, keep the command line if
+#define UPD_VALID_NO_UPDATE 5 // no new changes, keep the command line if
// possible
-#define VALID 10 // buffer not changed, or changes marked
+#define UPD_VALID 10 // buffer not changed, or changes marked
// with b_mod_*
-#define INVERTED 20 // redisplay inverted part that changed
-#define INVERTED_ALL 25 // redisplay whole inverted part
-#define REDRAW_TOP 30 // display first w_upd_rows screen lines
-#define SOME_VALID 35 // like NOT_VALID but may scroll
-#define NOT_VALID 40 // buffer needs complete redraw
-#define CLEAR 50 // screen messed up, clear it
+#define UPD_INVERTED 20 // redisplay inverted part that changed
+#define UPD_INVERTED_ALL 25 // redisplay whole inverted part
+#define UPD_REDRAW_TOP 30 // display first w_upd_rows screen lines
+#define UPD_SOME_VALID 35 // like UPD_NOT_VALID but may scroll
+#define UPD_NOT_VALID 40 // buffer needs complete redraw
+#define UPD_CLEAR 50 // screen messed up, clear it
// flags for screen_line()
#define SLF_RIGHTLEFT 1
// Both windows need redrawing. Update all status lines, in case they
// show something related to the window count or position.
- redraw_win_later(wp, NOT_VALID);
- redraw_win_later(oldwin, NOT_VALID);
+ redraw_win_later(wp, UPD_NOT_VALID);
+ redraw_win_later(oldwin, UPD_NOT_VALID);
status_redraw_all();
if (need_status)
wp->w_cursor = curwin->w_cursor;
win_enter(wp, TRUE);
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
}
/*
(void)win_comp_pos();
}
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
}
/*
frame_append(win2->w_frame, win1->w_frame);
(void)win_comp_pos(); // recompute w_winrow for all windows
- redraw_later(NOT_VALID);
+ redraw_later(UPD_NOT_VALID);
}
win_enter(win1, FALSE);
}
frame_new_height(topfr, height, FALSE, FALSE);
topfr->fr_win->w_wincol = col;
frame_new_width(topfr, width, FALSE, FALSE);
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
}
}
else if (topfr->fr_layout == FR_ROW)
static void
win_init_empty(win_T *wp)
{
- redraw_win_later(wp, NOT_VALID);
+ redraw_win_later(wp, UPD_NOT_VALID);
wp->w_lines_valid = 0;
wp->w_cursor.lnum = 1;
wp->w_curswant = wp->w_cursor.col = 0;
gui_init_which_components(NULL);
#endif
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
return OK;
}
entering_window(curwin);
#endif
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
apply_autocmds(EVENT_WINNEW, NULL, NULL, FALSE, curbuf);
apply_autocmds(EVENT_WINENTER, NULL, NULL, FALSE, curbuf);
apply_autocmds(EVENT_TABNEW, NULL, NULL, FALSE, curbuf);
apply_autocmds(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf);
}
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
}
/*
#endif
redraw_tabline = TRUE;
if (restart_edit)
- redraw_later(VALID); // causes status line redraw
+ redraw_later(UPD_VALID); // causes status line redraw
// set window height to desired minimal value
if (curwin->w_height < p_wh && !curwin->w_p_wfh
// position changed, redraw
wp->w_winrow = *row;
wp->w_wincol = *col;
- redraw_win_later(wp, NOT_VALID);
+ redraw_win_later(wp, UPD_NOT_VALID);
wp->w_redr_status = TRUE;
}
// WinBar will not show if the window height is zero
msg_row = row;
msg_col = 0;
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
}
/*
// recompute the window positions
(void)win_comp_pos();
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
}
/*
cmdline_row = row;
p_ch = MAX(Rows - cmdline_row, p_ch_was_zero ? 0 : 1);
curtab->tp_ch_used = p_ch;
- redraw_all_later(SOME_VALID);
+ redraw_all_later(UPD_SOME_VALID);
showmode();
}
fr = fr->fr_next;
}
(void)win_comp_pos();
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
}
#define FRACTION_MULT 16384L
wp->w_prev_fraction_row = wp->w_wrow;
win_comp_scroll(wp);
- redraw_win_later(wp, SOME_VALID);
+ redraw_win_later(wp, UPD_SOME_VALID);
wp->w_redr_status = TRUE;
invalidate_botline_win(wp);
}
update_topline();
curs_columns(TRUE); // validate w_wrow
}
- redraw_win_later(wp, NOT_VALID);
+ redraw_win_later(wp, UPD_NOT_VALID);
wp->w_redr_status = TRUE;
}
else
win_new_height(wp, wp->w_height - 1);
comp_col();
- redraw_all_later(SOME_VALID);
+ redraw_all_later(UPD_SOME_VALID);
}
}
else if (fr->fr_layout == FR_ROW)
win_comp_pos();
if (wp != NULL && close_curwin)
win_goto(wp);
- redraw_all_later(NOT_VALID);
+ redraw_all_later(UPD_NOT_VALID);
}
clear_snapshot(curtab, idx);
}
projects / vim / commitdiff