/* 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 static void win_redr_status(win_T *wp, int ignore_pum); /* * 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. */ static void win_redr_status(win_T *wp, int ignore_pum UNUSED) { int row; char_u *p; int len; int fillchar; int attr; int this_ru_col; 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 { fillchar = fillchar_status(&attr, wp); get_trans_bufname(wp->w_buffer); p = NameBuff; len = (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) && len < MAXPATHL - 1) *(p + len++) = ' '; if (bt_help(wp->w_buffer)) { vim_snprintf((char *)p + len, MAXPATHL - len, "%s", _("[Help]")); len += (int)STRLEN(p + len); } #ifdef FEAT_QUICKFIX if (wp->w_p_pvw) { vim_snprintf((char *)p + len, MAXPATHL - len, "%s", _("[Preview]")); len += (int)STRLEN(p + len); } #endif if (bufIsChanged(wp->w_buffer) && !bt_terminal(wp->w_buffer)) { vim_snprintf((char *)p + len, MAXPATHL - len, "%s", "[+]"); len += (int)STRLEN(p + len); } if (wp->w_buffer->b_p_ro) { vim_snprintf((char *)p + len, MAXPATHL - len, "%s", _("[RO]")); len += (int)STRLEN(p + len); } this_ru_col = ru_col - (Columns - wp->w_width); if (this_ru_col < (wp->w_width + 1) / 2) this_ru_col = (wp->w_width + 1) / 2; if (this_ru_col <= 1) { p = (char_u *)"<"; // No room for file name! len = 1; } else if (has_mbyte) { int clen = 0, i; // Count total number of display cells. clen = 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 && clen >= this_ru_col - 1; i += (*mb_ptr2len)(p + i)) clen -= (*mb_ptr2cells)(p + i); len = clen; if (i > 0) { p = p + i - 1; *p = '<'; ++len; } } else if (len > this_ru_col - 1) { p += len - (this_ru_col - 1); *p = '<'; len = this_ru_col - 1; } screen_puts(p, row, wp->w_wincol, attr); screen_fill(row, row + 1, len + wp->w_wincol, this_ru_col + wp->w_wincol, fillchar, fillchar, attr); if (get_keymap_str(wp, (char_u *)"<%s>", NameBuff, MAXPATHL) && (this_ru_col - len) > (int)(STRLEN(NameBuff) + 1)) screen_puts(NameBuff, row, (int)(this_ru_col - STRLEN(NameBuff) - 1 + wp->w_wincol), attr); #ifdef FEAT_CMDL_INFO win_redr_ruler(wp, TRUE, ignore_pum); #endif } /* * 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; int saved_did_emsg = did_emsg; // When called recursively return. This can happen when the statusline // contains an expression that triggers a redraw. if (entered) return; entered = TRUE; did_emsg = FALSE; win_redr_custom(wp, FALSE); if (did_emsg) { // When there is an error disable the statusline, otherwise the // display is messed up with errors and a redraw triggers the problem // again and again. set_string_option_direct((char_u *)"statusline", -1, (char_u *)"", OPT_FREE | (*wp->w_p_stl != NUL ? OPT_LOCAL : OPT_GLOBAL), SID_ERROR); } did_emsg |= saved_did_emsg; 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 #ifdef FEAT_CMDL_INFO win_redr_ruler(curwin, always, FALSE); #endif 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(); } #if defined(FEAT_CMDL_INFO) || defined(PROTO) void win_redr_ruler(win_T *wp, int always, int ignore_pum) { #define RULER_BUF_LEN 70 char_u buffer[RULER_BUF_LEN]; int row; int fillchar; int attr; int empty_line = FALSE; colnr_T virtcol; int i; size_t len; int o; int this_ru_col; int off = 0; int width; // If 'ruler' off or messages area disabled, don't do anything if (!p_ru || (wp->w_status_height == 0 && p_ch == 0)) 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 && p_ch > 0) { int called_emsg_before = called_emsg; win_redr_custom(wp, TRUE); if (called_emsg > called_emsg_before) set_string_option_direct((char_u *)"rulerformat", -1, (char_u *)"", OPT_FREE, SID_ERROR); 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) { 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; } /* * Some sprintfs return the length, some return a pointer. * To avoid portability problems we use strlen() here. */ vim_snprintf((char *)buffer, RULER_BUF_LEN, "%ld,", (wp->w_buffer->b_ml.ml_flags & ML_EMPTY) ? 0L : (long)(wp->w_cursor.lnum)); len = STRLEN(buffer); col_print(buffer + len, RULER_BUF_LEN - len, 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). */ i = (int)STRLEN(buffer); get_rel_pos(wp, buffer + i + 1, RULER_BUF_LEN - i - 1); o = i + vim_strsize(buffer + i + 1); if (wp->w_status_height == 0) // can't use last char of screen ++o; this_ru_col = ru_col - (Columns - width); if (this_ru_col < 0) this_ru_col = 0; // Never use more than half the window/screen width, leave the other // half for the filename. if (this_ru_col < (width + 1) / 2) this_ru_col = (width + 1) / 2; if (this_ru_col + o < width) { // need at least 3 chars left for get_rel_pos() + NUL while (this_ru_col + o < width && RULER_BUF_LEN > i + 4) { if (has_mbyte) i += (*mb_char2bytes)(fillchar, buffer + i); else buffer[i++] = fillchar; ++o; } get_rel_pos(wp, buffer + i, RULER_BUF_LEN - i); } // Truncate at window boundary. if (has_mbyte) { o = 0; for (i = 0; buffer[i] != NUL; i += (*mb_ptr2len)(buffer + i)) { o += (*mb_ptr2cells)(buffer + i); if (this_ru_col + o > width) { buffer[i] = NUL; break; } } } else if (this_ru_col + (int)STRLEN(buffer) > width) buffer[width - this_ru_col] = NUL; screen_puts(buffer, row, this_ru_col + off, attr); i = redraw_cmdline; screen_fill(row, row + 1, this_ru_col + off + (int)STRLEN(buffer), (off + width), fillchar, fillchar, attr); // don't redraw the cmdline because of showing the ruler redraw_cmdline = i; 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 } } #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 if (p_ch == 0) // in case it was changed in dont_use_message_window() cmdline_row = Rows; } /* * 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); if (len > wp->w_width - col) len = wp->w_width - col; 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, 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. #ifdef FEAT_CMDWIN if (cmdwin_type != 0 && wp == curwin) { ScreenLines[off] = cmdwin_type; ScreenAttrs[off] = HL_ATTR(HLF_AT); if (enc_utf8) ScreenLinesUC[off] = 0; ++col; } #endif #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 "; } } sprintf((char *)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')) >= (colnr_T)STRLEN(ml_get_buf(wp->w_buffer, lnume, FALSE))))))) { 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, 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_redr_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 #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 if (buf->b_mod_set && buf->b_mod_xlines != 0 && wp->w_redraw_top != 0) { // 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 = UPD_NOT_VALID; } else { // 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->match.regprog != NULL && re_multiline(cur->match.regprog)) { top_to_mod = TRUE; break; } cur = cur->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 } // When line numbers are displayed need to redraw all lines below // inserted/deleted lines. if (mod_top != 0 && buf->b_mod_xlines != 0 && wp->w_p_nu) mod_bot = MAXLNUM; } 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); #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. // Avoid using a wrong index when 'cmdheight' is // zero and wp->w_height == Rows. if ((wp->w_lines_valid += j) > wp->w_height) wp->w_lines_valid = wp->w_height; for (idx = wp->w_lines_valid >= wp->w_height ? wp->w_height - 1 : 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) wp->w_lines[0].wl_size = plines_win_nofill(wp, wp->w_topline, TRUE) + wp->w_topfill; #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)STRLEN(ml_get_buf(wp->w_buffer, pos.lnum, FALSE)); 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 // Update all the window rows. idx = 0; // first entry in w_lines[].wl_size row = 0; srow = 0; lnum = wp->w_topline; // first line shown in window 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_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) new_rows += plines_win_nofill(wp, l, TRUE) + wp->w_topfill; 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) if (i < Rows) 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 } 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(syntax_last_parsed + 1); #endif // Display one line. row = win_line(wp, lnum, srow, wp->w_height, mod_top == 0, FALSE); #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 >= (p_ch > 0 ? Rows : Rows + 1)) { // 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 (wp->w_p_rnu && wp->w_last_cursor_lnum_rnu != wp->w_cursor.lnum) { #ifdef FEAT_FOLDING // 'relativenumber' set and the cursor moved vertically: The // text doesn't need to be drawn, but the number column does. 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, TRUE, TRUE); } // 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 } 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 >= (p_ch > 0 ? Rows : Rows + 1)) 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(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; // Last line isn't finished: Display "@@@" in the last screen line. screen_puts_len((char_u *)"@@", wp->w_width > 2 ? 2 : wp->w_width, 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), '@', ' ', 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; // 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), '@', '@', HL_ATTR(HLF_AT)); set_empty_rows(wp, srow); wp->w_botline = lnum; } else { win_draw_end(wp, '@', ' ', 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 or due to wcol fix. 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; 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 # ifdef FEAT_CMDL_INFO || p_ru # endif # 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 #if defined(FEAT_TERMRESPONSE) || defined(PROTO) /* * 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 || p_ch == 0) 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, 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; } #endif /* * 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) { if (wp->w_redraw_top == 0 || wp->w_redraw_top > lnum) 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, UPD_VALID); }