1 /* vi:set ts=8 sts=4 sw=4: 2 * 3 * VIM - Vi IMproved by Bram Moolenaar 4 * 5 * Do ":help uganda" in Vim to read copying and usage conditions. 6 * Do ":help credits" in Vim to see a list of people who contributed. 7 * See README.txt for an overview of the Vim source code. 8 */ 9 10 /* 11 * screen.c: code for displaying on the screen 12 * 13 * Output to the screen (console, terminal emulator or GUI window) is minimized 14 * by remembering what is already on the screen, and only updating the parts 15 * that changed. 16 * 17 * ScreenLines[off] Contains a copy of the whole screen, as it is currently 18 * displayed (excluding text written by external commands). 19 * ScreenAttrs[off] Contains the associated attributes. 20 * LineOffset[row] Contains the offset into ScreenLines*[] and ScreenAttrs[] 21 * for each line. 22 * LineWraps[row] Flag for each line whether it wraps to the next line. 23 * 24 * For double-byte characters, two consecutive bytes in ScreenLines[] can form 25 * one character which occupies two display cells. 26 * For UTF-8 a multi-byte character is converted to Unicode and stored in 27 * ScreenLinesUC[]. ScreenLines[] contains the first byte only. For an ASCII 28 * character without composing chars ScreenLinesUC[] will be 0. When the 29 * character occupies two display cells the next byte in ScreenLines[] is 0. 30 * ScreenLinesC[][] contain up to 'maxcombine' composing characters 31 * (drawn on top of the first character). They are 0 when not used. 32 * ScreenLines2[] is only used for euc-jp to store the second byte if the 33 * first byte is 0x8e (single-width character). 34 * 35 * The screen_*() functions write to the screen and handle updating 36 * ScreenLines[]. 37 * 38 * update_screen() is the function that updates all windows and status lines. 39 * It is called form the main loop when must_redraw is non-zero. It may be 40 * called from other places when an immediated screen update is needed. 41 * 42 * The part of the buffer that is displayed in a window is set with: 43 * - w_topline (first buffer line in window) 44 * - w_topfill (filler line above the first line) 45 * - w_leftcol (leftmost window cell in window), 46 * - w_skipcol (skipped window cells of first line) 47 * 48 * Commands that only move the cursor around in a window, do not need to take 49 * action to update the display. The main loop will check if w_topline is 50 * valid and update it (scroll the window) when needed. 51 * 52 * Commands that scroll a window change w_topline and must call 53 * check_cursor() to move the cursor into the visible part of the window, and 54 * call redraw_later(VALID) to have the window displayed by update_screen() 55 * later. 56 * 57 * Commands that change text in the buffer must call changed_bytes() or 58 * changed_lines() to mark the area that changed and will require updating 59 * later. The main loop will call update_screen(), which will update each 60 * window that shows the changed buffer. This assumes text above the change 61 * can remain displayed as it is. Text after the change may need updating for 62 * scrolling, folding and syntax highlighting. 63 * 64 * Commands that change how a window is displayed (e.g., setting 'list') or 65 * invalidate the contents of a window in another way (e.g., change fold 66 * settings), must call redraw_later(NOT_VALID) to have the whole window 67 * redisplayed by update_screen() later. 68 * 69 * Commands that change how a buffer is displayed (e.g., setting 'tabstop') 70 * must call redraw_curbuf_later(NOT_VALID) to have all the windows for the 71 * buffer redisplayed by update_screen() later. 72 * 73 * Commands that change highlighting and possibly cause a scroll too must call 74 * redraw_later(SOME_VALID) to update the whole window but still use scrolling 75 * to avoid redrawing everything. But the length of displayed lines must not 76 * change, use NOT_VALID then. 77 * 78 * Commands that move the window position must call redraw_later(NOT_VALID). 79 * TODO: should minimize redrawing by scrolling when possible. 80 * 81 * Commands that change everything (e.g., resizing the screen) must call 82 * redraw_all_later(NOT_VALID) or redraw_all_later(CLEAR). 83 * 84 * Things that are handled indirectly: 85 * - When messages scroll the screen up, msg_scrolled will be set and 86 * update_screen() called to redraw. 87 */ 88 89 #include "vim.h" 90 91 /* 92 * The attributes that are actually active for writing to the screen. 93 */ 94 static int screen_attr = 0; 95 96 /* 97 * Positioning the cursor is reduced by remembering the last position. 98 * Mostly used by windgoto() and screen_char(). 99 */ 100 static int screen_cur_row, screen_cur_col; /* last known cursor position */ 101 102 #ifdef FEAT_SEARCH_EXTRA 103 /* 104 * Struct used for highlighting 'hlsearch' matches for the last use search 105 * pattern or a ":match" item. 106 * For 'hlsearch' there is one pattern for all windows. For ":match" there is 107 * a different pattern for each window. 108 */ 109 typedef struct 110 { 111 regmmatch_T rm; /* points to the regexp program; contains last found 112 match (may continue in next line) */ 113 buf_T *buf; /* the buffer to search for a match */ 114 linenr_T lnum; /* the line to search for a match */ 115 int attr; /* attributes to be used for a match */ 116 int attr_cur; /* attributes currently active in win_line() */ 117 linenr_T first_lnum; /* first lnum to search for multi-line pat */ 118 colnr_T startcol; /* in win_line() points to char where HL starts */ 119 colnr_T endcol; /* in win_line() points to char where HL ends */ 120 } match_T; 121 122 static match_T search_hl; /* used for 'hlsearch' highlight matching */ 123 static match_T match_hl[3]; /* used for ":match" highlight matching */ 124 #endif 125 126 #ifdef FEAT_FOLDING 127 static foldinfo_T win_foldinfo; /* info for 'foldcolumn' */ 128 #endif 129 130 /* 131 * Buffer for one screen line (characters and attributes). 132 */ 133 static schar_T *current_ScreenLine; 134 135 static void win_update __ARGS((win_T *wp)); 136 static void win_draw_end __ARGS((win_T *wp, int c1, int c2, int row, int endrow, hlf_T hl)); 137 #ifdef FEAT_FOLDING 138 static void fold_line __ARGS((win_T *wp, long fold_count, foldinfo_T *foldinfo, linenr_T lnum, int row)); 139 static void fill_foldcolumn __ARGS((char_u *p, win_T *wp, int closed, linenr_T lnum)); 140 static void copy_text_attr __ARGS((int off, char_u *buf, int len, int attr)); 141 #endif 142 static int win_line __ARGS((win_T *, linenr_T, int, int, int nochange)); 143 static int char_needs_redraw __ARGS((int off_from, int off_to, int cols)); 144 #ifdef FEAT_RIGHTLEFT 145 static void screen_line __ARGS((int row, int coloff, int endcol, int clear_width, int rlflag)); 146 # define SCREEN_LINE(r, o, e, c, rl) screen_line((r), (o), (e), (c), (rl)) 147 #else 148 static void screen_line __ARGS((int row, int coloff, int endcol, int clear_width)); 149 # define SCREEN_LINE(r, o, e, c, rl) screen_line((r), (o), (e), (c)) 150 #endif 151 #ifdef FEAT_VERTSPLIT 152 static void draw_vsep_win __ARGS((win_T *wp, int row)); 153 #endif 154 #ifdef FEAT_STL_OPT 155 static void redraw_custum_statusline __ARGS((win_T *wp)); 156 #endif 157 #ifdef FEAT_SEARCH_EXTRA 158 static void start_search_hl __ARGS((void)); 159 static void end_search_hl __ARGS((void)); 160 static void prepare_search_hl __ARGS((win_T *wp, linenr_T lnum)); 161 static void next_search_hl __ARGS((win_T *win, match_T *shl, linenr_T lnum, colnr_T mincol)); 162 #endif 163 static void screen_start_highlight __ARGS((int attr)); 164 static void screen_char __ARGS((unsigned off, int row, int col)); 165 #ifdef FEAT_MBYTE 166 static void screen_char_2 __ARGS((unsigned off, int row, int col)); 167 #endif 168 static void screenclear2 __ARGS((void)); 169 static void lineclear __ARGS((unsigned off, int width)); 170 static void lineinvalid __ARGS((unsigned off, int width)); 171 #ifdef FEAT_VERTSPLIT 172 static void linecopy __ARGS((int to, int from, win_T *wp)); 173 static void redraw_block __ARGS((int row, int end, win_T *wp)); 174 #endif 175 static int win_do_lines __ARGS((win_T *wp, int row, int line_count, int mayclear, int del)); 176 static void win_rest_invalid __ARGS((win_T *wp)); 177 static void msg_pos_mode __ARGS((void)); 178 #if defined(FEAT_WINDOWS) 179 static void draw_tabline __ARGS((void)); 180 #endif 181 #if defined(FEAT_WINDOWS) || defined(FEAT_WILDMENU) || defined(FEAT_STL_OPT) 182 static int fillchar_status __ARGS((int *attr, int is_curwin)); 183 #endif 184 #ifdef FEAT_VERTSPLIT 185 static int fillchar_vsep __ARGS((int *attr)); 186 #endif 187 #ifdef FEAT_STL_OPT 188 static void win_redr_custom __ARGS((win_T *wp, int draw_ruler)); 189 #endif 190 #ifdef FEAT_CMDL_INFO 191 static void win_redr_ruler __ARGS((win_T *wp, int always)); 192 #endif 193 194 #if defined(FEAT_CLIPBOARD) || defined(FEAT_VERTSPLIT) 195 /* Ugly global: overrule attribute used by screen_char() */ 196 static int screen_char_attr = 0; 197 #endif 198 199 /* 200 * Redraw the current window later, with update_screen(type). 201 * Set must_redraw only if not already set to a higher value. 202 * e.g. if must_redraw is CLEAR, type NOT_VALID will do nothing. 203 */ 204 void 205 redraw_later(type) 206 int type; 207 { 208 redraw_win_later(curwin, type); 209 } 210 211 void 212 redraw_win_later(wp, type) 213 win_T *wp; 214 int type; 215 { 216 if (wp->w_redr_type < type) 217 { 218 wp->w_redr_type = type; 219 if (type >= NOT_VALID) 220 wp->w_lines_valid = 0; 221 if (must_redraw < type) /* must_redraw is the maximum of all windows */ 222 must_redraw = type; 223 } 224 } 225 226 /* 227 * Force a complete redraw later. Also resets the highlighting. To be used 228 * after executing a shell command that messes up the screen. 229 */ 230 void 231 redraw_later_clear() 232 { 233 redraw_all_later(CLEAR); 234 #ifdef FEAT_GUI 235 if (gui.in_use) 236 /* Use a code that will reset gui.highlight_mask in 237 * gui_stop_highlight(). */ 238 screen_attr = HL_ALL + 1; 239 else 240 #endif 241 /* Use attributes that is very unlikely to appear in text. */ 242 screen_attr = HL_BOLD | HL_UNDERLINE | HL_INVERSE; 243 } 244 245 /* 246 * Mark all windows to be redrawn later. 247 */ 248 void 249 redraw_all_later(type) 250 int type; 251 { 252 win_T *wp; 253 254 FOR_ALL_WINDOWS(wp) 255 { 256 redraw_win_later(wp, type); 257 } 258 } 259 260 /* 261 * Mark all windows that are editing the current buffer to be updated later. 262 */ 263 void 264 redraw_curbuf_later(type) 265 int type; 266 { 267 redraw_buf_later(curbuf, type); 268 } 269 270 void 271 redraw_buf_later(buf, type) 272 buf_T *buf; 273 int type; 274 { 275 win_T *wp; 276 277 FOR_ALL_WINDOWS(wp) 278 { 279 if (wp->w_buffer == buf) 280 redraw_win_later(wp, type); 281 } 282 } 283 284 /* 285 * Changed something in the current window, at buffer line "lnum", that 286 * requires that line and possibly other lines to be redrawn. 287 * Used when entering/leaving Insert mode with the cursor on a folded line. 288 * Used to remove the "$" from a change command. 289 * Note that when also inserting/deleting lines w_redraw_top and w_redraw_bot 290 * may become invalid and the whole window will have to be redrawn. 291 */ 292 /*ARGSUSED*/ 293 void 294 redrawWinline(lnum, invalid) 295 linenr_T lnum; 296 int invalid; /* window line height is invalid now */ 297 { 298 #ifdef FEAT_FOLDING 299 int i; 300 #endif 301 302 if (curwin->w_redraw_top == 0 || curwin->w_redraw_top > lnum) 303 curwin->w_redraw_top = lnum; 304 if (curwin->w_redraw_bot == 0 || curwin->w_redraw_bot < lnum) 305 curwin->w_redraw_bot = lnum; 306 redraw_later(VALID); 307 308 #ifdef FEAT_FOLDING 309 if (invalid) 310 { 311 /* A w_lines[] entry for this lnum has become invalid. */ 312 i = find_wl_entry(curwin, lnum); 313 if (i >= 0) 314 curwin->w_lines[i].wl_valid = FALSE; 315 } 316 #endif 317 } 318 319 /* 320 * update all windows that are editing the current buffer 321 */ 322 void 323 update_curbuf(type) 324 int type; 325 { 326 redraw_curbuf_later(type); 327 update_screen(type); 328 } 329 330 /* 331 * update_screen() 332 * 333 * Based on the current value of curwin->w_topline, transfer a screenfull 334 * of stuff from Filemem to ScreenLines[], and update curwin->w_botline. 335 */ 336 void 337 update_screen(type) 338 int type; 339 { 340 win_T *wp; 341 static int did_intro = FALSE; 342 #if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_CLIPBOARD) 343 int did_one; 344 #endif 345 346 if (!screen_valid(TRUE)) 347 return; 348 349 if (must_redraw) 350 { 351 if (type < must_redraw) /* use maximal type */ 352 type = must_redraw; 353 must_redraw = 0; 354 } 355 356 /* Need to update w_lines[]. */ 357 if (curwin->w_lines_valid == 0 && type < NOT_VALID) 358 type = NOT_VALID; 359 360 if (!redrawing()) 361 { 362 redraw_later(type); /* remember type for next time */ 363 must_redraw = type; 364 if (type > INVERTED_ALL) 365 curwin->w_lines_valid = 0; /* don't use w_lines[].wl_size now */ 366 return; 367 } 368 369 updating_screen = TRUE; 370 #ifdef FEAT_SYN_HL 371 ++display_tick; /* let syntax code know we're in a next round of 372 * display updating */ 373 #endif 374 375 /* 376 * if the screen was scrolled up when displaying a message, scroll it down 377 */ 378 if (msg_scrolled) 379 { 380 clear_cmdline = TRUE; 381 if (msg_scrolled > Rows - 5) /* clearing is faster */ 382 type = CLEAR; 383 else if (type != CLEAR) 384 { 385 check_for_delay(FALSE); 386 if (screen_ins_lines(0, 0, msg_scrolled, (int)Rows, NULL) == FAIL) 387 type = CLEAR; 388 FOR_ALL_WINDOWS(wp) 389 { 390 if (W_WINROW(wp) < msg_scrolled) 391 { 392 if (W_WINROW(wp) + wp->w_height > msg_scrolled 393 && wp->w_redr_type < REDRAW_TOP 394 && wp->w_lines_valid > 0 395 && wp->w_topline == wp->w_lines[0].wl_lnum) 396 { 397 wp->w_upd_rows = msg_scrolled - W_WINROW(wp); 398 wp->w_redr_type = REDRAW_TOP; 399 } 400 else 401 { 402 wp->w_redr_type = NOT_VALID; 403 #ifdef FEAT_WINDOWS 404 if (W_WINROW(wp) + wp->w_height + W_STATUS_HEIGHT(wp) 405 <= msg_scrolled) 406 wp->w_redr_status = TRUE; 407 #endif 408 } 409 } 410 } 411 redraw_cmdline = TRUE; 412 #ifdef FEAT_WINDOWS 413 redraw_tabline = TRUE; 414 #endif 415 } 416 msg_scrolled = 0; 417 need_wait_return = FALSE; 418 } 419 420 /* reset cmdline_row now (may have been changed temporarily) */ 421 compute_cmdrow(); 422 423 /* Check for changed highlighting */ 424 if (need_highlight_changed) 425 highlight_changed(); 426 427 if (type == CLEAR) /* first clear screen */ 428 { 429 screenclear(); /* will reset clear_cmdline */ 430 type = NOT_VALID; 431 } 432 433 if (clear_cmdline) /* going to clear cmdline (done below) */ 434 check_for_delay(FALSE); 435 436 #ifdef FEAT_LINEBREAK 437 /* Force redraw when width of 'number' column changes. */ 438 if (curwin->w_redr_type < NOT_VALID 439 && curwin->w_nrwidth != (curwin->w_p_nu ? number_width(curwin) : 0)) 440 curwin->w_redr_type = NOT_VALID; 441 #endif 442 443 /* 444 * Only start redrawing if there is really something to do. 445 */ 446 if (type == INVERTED) 447 update_curswant(); 448 if (curwin->w_redr_type < type 449 && !((type == VALID 450 && curwin->w_lines[0].wl_valid 451 #ifdef FEAT_DIFF 452 && curwin->w_topfill == curwin->w_old_topfill 453 && curwin->w_botfill == curwin->w_old_botfill 454 #endif 455 && curwin->w_topline == curwin->w_lines[0].wl_lnum) 456 #ifdef FEAT_VISUAL 457 || (type == INVERTED 458 && VIsual_active 459 && curwin->w_old_cursor_lnum == curwin->w_cursor.lnum 460 && curwin->w_old_visual_mode == VIsual_mode 461 && (curwin->w_valid & VALID_VIRTCOL) 462 && curwin->w_old_curswant == curwin->w_curswant) 463 #endif 464 )) 465 curwin->w_redr_type = type; 466 467 #ifdef FEAT_WINDOWS 468 /* Redraw the tab pages line if needed. */ 469 if (redraw_tabline || type >= NOT_VALID) 470 draw_tabline(); 471 #endif 472 473 #ifdef FEAT_SYN_HL 474 /* 475 * Correct stored syntax highlighting info for changes in each displayed 476 * buffer. Each buffer must only be done once. 477 */ 478 FOR_ALL_WINDOWS(wp) 479 { 480 if (wp->w_buffer->b_mod_set) 481 { 482 # ifdef FEAT_WINDOWS 483 win_T *wwp; 484 485 /* Check if we already did this buffer. */ 486 for (wwp = firstwin; wwp != wp; wwp = wwp->w_next) 487 if (wwp->w_buffer == wp->w_buffer) 488 break; 489 # endif 490 if ( 491 # ifdef FEAT_WINDOWS 492 wwp == wp && 493 # endif 494 syntax_present(wp->w_buffer)) 495 syn_stack_apply_changes(wp->w_buffer); 496 } 497 } 498 #endif 499 500 /* 501 * Go from top to bottom through the windows, redrawing the ones that need 502 * it. 503 */ 504 #if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_CLIPBOARD) 505 did_one = FALSE; 506 #endif 507 #ifdef FEAT_SEARCH_EXTRA 508 search_hl.rm.regprog = NULL; 509 #endif 510 FOR_ALL_WINDOWS(wp) 511 { 512 if (wp->w_redr_type != 0) 513 { 514 cursor_off(); 515 #if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_CLIPBOARD) 516 if (!did_one) 517 { 518 did_one = TRUE; 519 # ifdef FEAT_SEARCH_EXTRA 520 start_search_hl(); 521 # endif 522 # ifdef FEAT_CLIPBOARD 523 /* When Visual area changed, may have to update selection. */ 524 if (clip_star.available && clip_isautosel()) 525 clip_update_selection(); 526 # endif 527 #ifdef FEAT_GUI 528 /* Remove the cursor before starting to do anything, because 529 * scrolling may make it difficult to redraw the text under 530 * it. */ 531 if (gui.in_use) 532 gui_undraw_cursor(); 533 #endif 534 } 535 #endif 536 win_update(wp); 537 } 538 539 #ifdef FEAT_WINDOWS 540 /* redraw status line after the window to minimize cursor movement */ 541 if (wp->w_redr_status) 542 { 543 cursor_off(); 544 win_redr_status(wp); 545 } 546 #endif 547 } 548 #if defined(FEAT_SEARCH_EXTRA) 549 end_search_hl(); 550 #endif 551 552 #ifdef FEAT_WINDOWS 553 /* Reset b_mod_set flags. Going through all windows is probably faster 554 * than going through all buffers (there could be many buffers). */ 555 for (wp = firstwin; wp != NULL; wp = wp->w_next) 556 wp->w_buffer->b_mod_set = FALSE; 557 #else 558 curbuf->b_mod_set = FALSE; 559 #endif 560 561 updating_screen = FALSE; 562 #ifdef FEAT_GUI 563 gui_may_resize_shell(); 564 #endif 565 566 /* Clear or redraw the command line. Done last, because scrolling may 567 * mess up the command line. */ 568 if (clear_cmdline || redraw_cmdline) 569 showmode(); 570 571 /* May put up an introductory message when not editing a file */ 572 if (!did_intro && bufempty() 573 && curbuf->b_fname == NULL 574 #ifdef FEAT_WINDOWS 575 && firstwin->w_next == NULL 576 #endif 577 && vim_strchr(p_shm, SHM_INTRO) == NULL) 578 intro_message(FALSE); 579 did_intro = TRUE; 580 581 #ifdef FEAT_GUI 582 /* Redraw the cursor and update the scrollbars when all screen updating is 583 * done. */ 584 if (gui.in_use) 585 { 586 out_flush(); /* required before updating the cursor */ 587 if (did_one) 588 gui_update_cursor(FALSE, FALSE); 589 gui_update_scrollbars(FALSE); 590 } 591 #endif 592 } 593 594 #if defined(FEAT_SIGNS) || defined(FEAT_GUI) 595 static void update_prepare __ARGS((void)); 596 static void update_finish __ARGS((void)); 597 598 /* 599 * Prepare for updating one or more windows. 600 */ 601 static void 602 update_prepare() 603 { 604 cursor_off(); 605 updating_screen = TRUE; 606 #ifdef FEAT_GUI 607 /* Remove the cursor before starting to do anything, because scrolling may 608 * make it difficult to redraw the text under it. */ 609 if (gui.in_use) 610 gui_undraw_cursor(); 611 #endif 612 #ifdef FEAT_SEARCH_EXTRA 613 start_search_hl(); 614 #endif 615 } 616 617 /* 618 * Finish updating one or more windows. 619 */ 620 static void 621 update_finish() 622 { 623 if (redraw_cmdline) 624 showmode(); 625 626 # ifdef FEAT_SEARCH_EXTRA 627 end_search_hl(); 628 # endif 629 630 updating_screen = FALSE; 631 632 # ifdef FEAT_GUI 633 gui_may_resize_shell(); 634 635 /* Redraw the cursor and update the scrollbars when all screen updating is 636 * done. */ 637 if (gui.in_use) 638 { 639 out_flush(); /* required before updating the cursor */ 640 gui_update_cursor(FALSE, FALSE); 641 gui_update_scrollbars(FALSE); 642 } 643 # endif 644 } 645 #endif 646 647 #if defined(FEAT_SIGNS) || defined(PROTO) 648 void 649 update_debug_sign(buf, lnum) 650 buf_T *buf; 651 linenr_T lnum; 652 { 653 win_T *wp; 654 int doit = FALSE; 655 656 # ifdef FEAT_FOLDING 657 win_foldinfo.fi_level = 0; 658 # endif 659 660 /* update/delete a specific mark */ 661 FOR_ALL_WINDOWS(wp) 662 { 663 if (buf != NULL && lnum > 0) 664 { 665 if (wp->w_buffer == buf && lnum >= wp->w_topline 666 && lnum < wp->w_botline) 667 { 668 if (wp->w_redraw_top == 0 || wp->w_redraw_top > lnum) 669 wp->w_redraw_top = lnum; 670 if (wp->w_redraw_bot == 0 || wp->w_redraw_bot < lnum) 671 wp->w_redraw_bot = lnum; 672 redraw_win_later(wp, VALID); 673 } 674 } 675 else 676 redraw_win_later(wp, VALID); 677 if (wp->w_redr_type != 0) 678 doit = TRUE; 679 } 680 681 if (!doit) 682 return; 683 684 /* update all windows that need updating */ 685 update_prepare(); 686 687 # ifdef FEAT_WINDOWS 688 for (wp = firstwin; wp; wp = wp->w_next) 689 { 690 if (wp->w_redr_type != 0) 691 win_update(wp); 692 if (wp->w_redr_status) 693 win_redr_status(wp); 694 } 695 # else 696 if (curwin->w_redr_type != 0) 697 win_update(curwin); 698 # endif 699 700 update_finish(); 701 } 702 #endif 703 704 705 #if defined(FEAT_GUI) || defined(PROTO) 706 /* 707 * Update a single window, its status line and maybe the command line msg. 708 * Used for the GUI scrollbar. 709 */ 710 void 711 updateWindow(wp) 712 win_T *wp; 713 { 714 update_prepare(); 715 716 #ifdef FEAT_CLIPBOARD 717 /* When Visual area changed, may have to update selection. */ 718 if (clip_star.available && clip_isautosel()) 719 clip_update_selection(); 720 #endif 721 722 win_update(wp); 723 724 #ifdef FEAT_WINDOWS 725 /* When the screen was cleared redraw the tab pages line. */ 726 if (redraw_tabline) 727 draw_tabline(); 728 729 if (wp->w_redr_status 730 # ifdef FEAT_CMDL_INFO 731 || p_ru 732 # endif 733 # ifdef FEAT_STL_OPT 734 || *p_stl != NUL || *wp->w_p_stl != NUL 735 # endif 736 ) 737 win_redr_status(wp); 738 #endif 739 740 update_finish(); 741 } 742 #endif 743 744 /* 745 * Update a single window. 746 * 747 * This may cause the windows below it also to be redrawn (when clearing the 748 * screen or scrolling lines). 749 * 750 * How the window is redrawn depends on wp->w_redr_type. Each type also 751 * implies the one below it. 752 * NOT_VALID redraw the whole window 753 * SOME_VALID redraw the whole window but do scroll when possible 754 * REDRAW_TOP redraw the top w_upd_rows window lines, otherwise like VALID 755 * INVERTED redraw the changed part of the Visual area 756 * INVERTED_ALL redraw the whole Visual area 757 * VALID 1. scroll up/down to adjust for a changed w_topline 758 * 2. update lines at the top when scrolled down 759 * 3. redraw changed text: 760 * - if wp->w_buffer->b_mod_set set, update lines between 761 * b_mod_top and b_mod_bot. 762 * - if wp->w_redraw_top non-zero, redraw lines between 763 * wp->w_redraw_top and wp->w_redr_bot. 764 * - continue redrawing when syntax status is invalid. 765 * 4. if scrolled up, update lines at the bottom. 766 * This results in three areas that may need updating: 767 * top: from first row to top_end (when scrolled down) 768 * mid: from mid_start to mid_end (update inversion or changed text) 769 * bot: from bot_start to last row (when scrolled up) 770 */ 771 static void 772 win_update(wp) 773 win_T *wp; 774 { 775 buf_T *buf = wp->w_buffer; 776 int type; 777 int top_end = 0; /* Below last row of the top area that needs 778 updating. 0 when no top area updating. */ 779 int mid_start = 999;/* first row of the mid area that needs 780 updating. 999 when no mid area updating. */ 781 int mid_end = 0; /* Below last row of the mid area that needs 782 updating. 0 when no mid area updating. */ 783 int bot_start = 999;/* first row of the bot area that needs 784 updating. 999 when no bot area updating */ 785 #ifdef FEAT_VISUAL 786 int scrolled_down = FALSE; /* TRUE when scrolled down when 787 w_topline got smaller a bit */ 788 #endif 789 #ifdef FEAT_SEARCH_EXTRA 790 int top_to_mod = FALSE; /* redraw above mod_top */ 791 #endif 792 793 int row; /* current window row to display */ 794 linenr_T lnum; /* current buffer lnum to display */ 795 int idx; /* current index in w_lines[] */ 796 int srow; /* starting row of the current line */ 797 798 int eof = FALSE; /* if TRUE, we hit the end of the file */ 799 int didline = FALSE; /* if TRUE, we finished the last line */ 800 int i; 801 long j; 802 static int recursive = FALSE; /* being called recursively */ 803 int old_botline = wp->w_botline; 804 #ifdef FEAT_FOLDING 805 long fold_count; 806 #endif 807 #ifdef FEAT_SYN_HL 808 /* remember what happened to the previous line, to know if 809 * check_visual_highlight() can be used */ 810 #define DID_NONE 1 /* didn't update a line */ 811 #define DID_LINE 2 /* updated a normal line */ 812 #define DID_FOLD 3 /* updated a folded line */ 813 int did_update = DID_NONE; 814 linenr_T syntax_last_parsed = 0; /* last parsed text line */ 815 #endif 816 linenr_T mod_top = 0; 817 linenr_T mod_bot = 0; 818 #if defined(FEAT_SYN_HL) || defined(FEAT_SEARCH_EXTRA) 819 int save_got_int; 820 #endif 821 822 type = wp->w_redr_type; 823 824 if (type == NOT_VALID) 825 { 826 #ifdef FEAT_WINDOWS 827 wp->w_redr_status = TRUE; 828 #endif 829 wp->w_lines_valid = 0; 830 } 831 832 /* Window is zero-height: nothing to draw. */ 833 if (wp->w_height == 0) 834 { 835 wp->w_redr_type = 0; 836 return; 837 } 838 839 #ifdef FEAT_VERTSPLIT 840 /* Window is zero-width: Only need to draw the separator. */ 841 if (wp->w_width == 0) 842 { 843 /* draw the vertical separator right of this window */ 844 draw_vsep_win(wp, 0); 845 wp->w_redr_type = 0; 846 return; 847 } 848 #endif 849 850 #ifdef FEAT_SEARCH_EXTRA 851 /* Setup for ":match" and 'hlsearch' highlighting. Disable any previous 852 * match */ 853 for (i = 0; i < 3; ++i) 854 { 855 match_hl[i].rm = wp->w_match[i]; 856 if (wp->w_match_id[i] == 0) 857 match_hl[i].attr = 0; 858 else 859 match_hl[i].attr = syn_id2attr(wp->w_match_id[i]); 860 match_hl[i].buf = buf; 861 match_hl[i].lnum = 0; 862 match_hl[i].first_lnum = 0; 863 } 864 search_hl.buf = buf; 865 search_hl.lnum = 0; 866 search_hl.first_lnum = 0; 867 #endif 868 869 #ifdef FEAT_LINEBREAK 870 /* Force redraw when width of 'number' column changes. */ 871 i = wp->w_p_nu ? number_width(wp) : 0; 872 if (wp->w_nrwidth != i) 873 { 874 type = NOT_VALID; 875 wp->w_nrwidth = i; 876 } 877 else 878 #endif 879 880 if (buf->b_mod_set && buf->b_mod_xlines != 0 && wp->w_redraw_top != 0) 881 { 882 /* 883 * When there are both inserted/deleted lines and specific lines to be 884 * redrawn, w_redraw_top and w_redraw_bot may be invalid, just redraw 885 * everything (only happens when redrawing is off for while). 886 */ 887 type = NOT_VALID; 888 } 889 else 890 { 891 /* 892 * Set mod_top to the first line that needs displaying because of 893 * changes. Set mod_bot to the first line after the changes. 894 */ 895 mod_top = wp->w_redraw_top; 896 if (wp->w_redraw_bot != 0) 897 mod_bot = wp->w_redraw_bot + 1; 898 else 899 mod_bot = 0; 900 wp->w_redraw_top = 0; /* reset for next time */ 901 wp->w_redraw_bot = 0; 902 if (buf->b_mod_set) 903 { 904 if (mod_top == 0 || mod_top > buf->b_mod_top) 905 { 906 mod_top = buf->b_mod_top; 907 #ifdef FEAT_SYN_HL 908 /* Need to redraw lines above the change that may be included 909 * in a pattern match. */ 910 if (syntax_present(buf)) 911 { 912 mod_top -= buf->b_syn_sync_linebreaks; 913 if (mod_top < 1) 914 mod_top = 1; 915 } 916 #endif 917 } 918 if (mod_bot == 0 || mod_bot < buf->b_mod_bot) 919 mod_bot = buf->b_mod_bot; 920 921 #ifdef FEAT_SEARCH_EXTRA 922 /* When 'hlsearch' is on and using a multi-line search pattern, a 923 * change in one line may make the Search highlighting in a 924 * previous line invalid. Simple solution: redraw all visible 925 * lines above the change. 926 * Same for a ":match" pattern. 927 */ 928 if (search_hl.rm.regprog != NULL 929 && re_multiline(search_hl.rm.regprog)) 930 top_to_mod = TRUE; 931 else 932 for (i = 0; i < 3; ++i) 933 if (match_hl[i].rm.regprog != NULL 934 && re_multiline(match_hl[i].rm.regprog)) 935 { 936 top_to_mod = TRUE; 937 break; 938 } 939 #endif 940 } 941 #ifdef FEAT_FOLDING 942 if (mod_top != 0 && hasAnyFolding(wp)) 943 { 944 linenr_T lnumt, lnumb; 945 946 /* 947 * A change in a line can cause lines above it to become folded or 948 * unfolded. Find the top most buffer line that may be affected. 949 * If the line was previously folded and displayed, get the first 950 * line of that fold. If the line is folded now, get the first 951 * folded line. Use the minimum of these two. 952 */ 953 954 /* Find last valid w_lines[] entry above mod_top. Set lnumt to 955 * the line below it. If there is no valid entry, use w_topline. 956 * Find the first valid w_lines[] entry below mod_bot. Set lnumb 957 * to this line. If there is no valid entry, use MAXLNUM. */ 958 lnumt = wp->w_topline; 959 lnumb = MAXLNUM; 960 for (i = 0; i < wp->w_lines_valid; ++i) 961 if (wp->w_lines[i].wl_valid) 962 { 963 if (wp->w_lines[i].wl_lastlnum < mod_top) 964 lnumt = wp->w_lines[i].wl_lastlnum + 1; 965 if (lnumb == MAXLNUM && wp->w_lines[i].wl_lnum >= mod_bot) 966 { 967 lnumb = wp->w_lines[i].wl_lnum; 968 /* When there is a fold column it might need updating 969 * in the next line ("J" just above an open fold). */ 970 if (wp->w_p_fdc > 0) 971 ++lnumb; 972 } 973 } 974 975 (void)hasFoldingWin(wp, mod_top, &mod_top, NULL, TRUE, NULL); 976 if (mod_top > lnumt) 977 mod_top = lnumt; 978 979 /* Now do the same for the bottom line (one above mod_bot). */ 980 --mod_bot; 981 (void)hasFoldingWin(wp, mod_bot, NULL, &mod_bot, TRUE, NULL); 982 ++mod_bot; 983 if (mod_bot < lnumb) 984 mod_bot = lnumb; 985 } 986 #endif 987 988 /* When a change starts above w_topline and the end is below 989 * w_topline, start redrawing at w_topline. 990 * If the end of the change is above w_topline: do like no change was 991 * made, but redraw the first line to find changes in syntax. */ 992 if (mod_top != 0 && mod_top < wp->w_topline) 993 { 994 if (mod_bot > wp->w_topline) 995 mod_top = wp->w_topline; 996 #ifdef FEAT_SYN_HL 997 else if (syntax_present(buf)) 998 top_end = 1; 999 #endif 1000 } 1001 1002 /* When line numbers are displayed need to redraw all lines below 1003 * inserted/deleted lines. */ 1004 if (mod_top != 0 && buf->b_mod_xlines != 0 && wp->w_p_nu) 1005 mod_bot = MAXLNUM; 1006 } 1007 1008 /* 1009 * When only displaying the lines at the top, set top_end. Used when 1010 * window has scrolled down for msg_scrolled. 1011 */ 1012 if (type == REDRAW_TOP) 1013 { 1014 j = 0; 1015 for (i = 0; i < wp->w_lines_valid; ++i) 1016 { 1017 j += wp->w_lines[i].wl_size; 1018 if (j >= wp->w_upd_rows) 1019 { 1020 top_end = j; 1021 break; 1022 } 1023 } 1024 if (top_end == 0) 1025 /* not found (cannot happen?): redraw everything */ 1026 type = NOT_VALID; 1027 else 1028 /* top area defined, the rest is VALID */ 1029 type = VALID; 1030 } 1031 1032 /* 1033 * If there are no changes on the screen that require a complete redraw, 1034 * handle three cases: 1035 * 1: we are off the top of the screen by a few lines: scroll down 1036 * 2: wp->w_topline is below wp->w_lines[0].wl_lnum: may scroll up 1037 * 3: wp->w_topline is wp->w_lines[0].wl_lnum: find first entry in 1038 * w_lines[] that needs updating. 1039 */ 1040 if ((type == VALID || type == SOME_VALID 1041 || type == INVERTED || type == INVERTED_ALL) 1042 #ifdef FEAT_DIFF 1043 && !wp->w_botfill && !wp->w_old_botfill 1044 #endif 1045 ) 1046 { 1047 if (mod_top != 0 && wp->w_topline == mod_top) 1048 { 1049 /* 1050 * w_topline is the first changed line, the scrolling will be done 1051 * further down. 1052 */ 1053 } 1054 else if (wp->w_lines[0].wl_valid 1055 && (wp->w_topline < wp->w_lines[0].wl_lnum 1056 #ifdef FEAT_DIFF 1057 || (wp->w_topline == wp->w_lines[0].wl_lnum 1058 && wp->w_topfill > wp->w_old_topfill) 1059 #endif 1060 )) 1061 { 1062 /* 1063 * New topline is above old topline: May scroll down. 1064 */ 1065 #ifdef FEAT_FOLDING 1066 if (hasAnyFolding(wp)) 1067 { 1068 linenr_T ln; 1069 1070 /* count the number of lines we are off, counting a sequence 1071 * of folded lines as one */ 1072 j = 0; 1073 for (ln = wp->w_topline; ln < wp->w_lines[0].wl_lnum; ++ln) 1074 { 1075 ++j; 1076 if (j >= wp->w_height - 2) 1077 break; 1078 (void)hasFoldingWin(wp, ln, NULL, &ln, TRUE, NULL); 1079 } 1080 } 1081 else 1082 #endif 1083 j = wp->w_lines[0].wl_lnum - wp->w_topline; 1084 if (j < wp->w_height - 2) /* not too far off */ 1085 { 1086 i = plines_m_win(wp, wp->w_topline, wp->w_lines[0].wl_lnum - 1); 1087 #ifdef FEAT_DIFF 1088 /* insert extra lines for previously invisible filler lines */ 1089 if (wp->w_lines[0].wl_lnum != wp->w_topline) 1090 i += diff_check_fill(wp, wp->w_lines[0].wl_lnum) 1091 - wp->w_old_topfill; 1092 #endif 1093 if (i < wp->w_height - 2) /* less than a screen off */ 1094 { 1095 /* 1096 * Try to insert the correct number of lines. 1097 * If not the last window, delete the lines at the bottom. 1098 * win_ins_lines may fail when the terminal can't do it. 1099 */ 1100 if (i > 0) 1101 check_for_delay(FALSE); 1102 if (win_ins_lines(wp, 0, i, FALSE, wp == firstwin) == OK) 1103 { 1104 if (wp->w_lines_valid != 0) 1105 { 1106 /* Need to update rows that are new, stop at the 1107 * first one that scrolled down. */ 1108 top_end = i; 1109 #ifdef FEAT_VISUAL 1110 scrolled_down = TRUE; 1111 #endif 1112 1113 /* Move the entries that were scrolled, disable 1114 * the entries for the lines to be redrawn. */ 1115 if ((wp->w_lines_valid += j) > wp->w_height) 1116 wp->w_lines_valid = wp->w_height; 1117 for (idx = wp->w_lines_valid; idx - j >= 0; idx--) 1118 wp->w_lines[idx] = wp->w_lines[idx - j]; 1119 while (idx >= 0) 1120 wp->w_lines[idx--].wl_valid = FALSE; 1121 } 1122 } 1123 else 1124 mid_start = 0; /* redraw all lines */ 1125 } 1126 else 1127 mid_start = 0; /* redraw all lines */ 1128 } 1129 else 1130 mid_start = 0; /* redraw all lines */ 1131 } 1132 else 1133 { 1134 /* 1135 * New topline is at or below old topline: May scroll up. 1136 * When topline didn't change, find first entry in w_lines[] that 1137 * needs updating. 1138 */ 1139 1140 /* try to find wp->w_topline in wp->w_lines[].wl_lnum */ 1141 j = -1; 1142 row = 0; 1143 for (i = 0; i < wp->w_lines_valid; i++) 1144 { 1145 if (wp->w_lines[i].wl_valid 1146 && wp->w_lines[i].wl_lnum == wp->w_topline) 1147 { 1148 j = i; 1149 break; 1150 } 1151 row += wp->w_lines[i].wl_size; 1152 } 1153 if (j == -1) 1154 { 1155 /* if wp->w_topline is not in wp->w_lines[].wl_lnum redraw all 1156 * lines */ 1157 mid_start = 0; 1158 } 1159 else 1160 { 1161 /* 1162 * Try to delete the correct number of lines. 1163 * wp->w_topline is at wp->w_lines[i].wl_lnum. 1164 */ 1165 #ifdef FEAT_DIFF 1166 /* If the topline didn't change, delete old filler lines, 1167 * otherwise delete filler lines of the new topline... */ 1168 if (wp->w_lines[0].wl_lnum == wp->w_topline) 1169 row += wp->w_old_topfill; 1170 else 1171 row += diff_check_fill(wp, wp->w_topline); 1172 /* ... but don't delete new filler lines. */ 1173 row -= wp->w_topfill; 1174 #endif 1175 if (row > 0) 1176 { 1177 check_for_delay(FALSE); 1178 if (win_del_lines(wp, 0, row, FALSE, wp == firstwin) == OK) 1179 bot_start = wp->w_height - row; 1180 else 1181 mid_start = 0; /* redraw all lines */ 1182 } 1183 if ((row == 0 || bot_start < 999) && wp->w_lines_valid != 0) 1184 { 1185 /* 1186 * Skip the lines (below the deleted lines) that are still 1187 * valid and don't need redrawing. Copy their info 1188 * upwards, to compensate for the deleted lines. Set 1189 * bot_start to the first row that needs redrawing. 1190 */ 1191 bot_start = 0; 1192 idx = 0; 1193 for (;;) 1194 { 1195 wp->w_lines[idx] = wp->w_lines[j]; 1196 /* stop at line that didn't fit, unless it is still 1197 * valid (no lines deleted) */ 1198 if (row > 0 && bot_start + row 1199 + (int)wp->w_lines[j].wl_size > wp->w_height) 1200 { 1201 wp->w_lines_valid = idx + 1; 1202 break; 1203 } 1204 bot_start += wp->w_lines[idx++].wl_size; 1205 1206 /* stop at the last valid entry in w_lines[].wl_size */ 1207 if (++j >= wp->w_lines_valid) 1208 { 1209 wp->w_lines_valid = idx; 1210 break; 1211 } 1212 } 1213 #ifdef FEAT_DIFF 1214 /* Correct the first entry for filler lines at the top 1215 * when it won't get updated below. */ 1216 if (wp->w_p_diff && bot_start > 0) 1217 wp->w_lines[0].wl_size = 1218 plines_win_nofill(wp, wp->w_topline, TRUE) 1219 + wp->w_topfill; 1220 #endif 1221 } 1222 } 1223 } 1224 1225 /* When starting redraw in the first line, redraw all lines. When 1226 * there is only one window it's probably faster to clear the screen 1227 * first. */ 1228 if (mid_start == 0) 1229 { 1230 mid_end = wp->w_height; 1231 if (lastwin == firstwin) 1232 { 1233 screenclear(); 1234 #ifdef FEAT_WINDOWS 1235 /* The screen was cleared, redraw the tab pages line. */ 1236 if (redraw_tabline) 1237 draw_tabline(); 1238 #endif 1239 } 1240 } 1241 } 1242 else 1243 { 1244 /* Not VALID or INVERTED: redraw all lines. */ 1245 mid_start = 0; 1246 mid_end = wp->w_height; 1247 } 1248 1249 if (type == SOME_VALID) 1250 { 1251 /* SOME_VALID: redraw all lines. */ 1252 mid_start = 0; 1253 mid_end = wp->w_height; 1254 type = NOT_VALID; 1255 } 1256 1257 #ifdef FEAT_VISUAL 1258 /* check if we are updating or removing the inverted part */ 1259 if ((VIsual_active && buf == curwin->w_buffer) 1260 || (wp->w_old_cursor_lnum != 0 && type != NOT_VALID)) 1261 { 1262 linenr_T from, to; 1263 1264 if (VIsual_active) 1265 { 1266 if (VIsual_active 1267 && (VIsual_mode != wp->w_old_visual_mode 1268 || type == INVERTED_ALL)) 1269 { 1270 /* 1271 * If the type of Visual selection changed, redraw the whole 1272 * selection. Also when the ownership of the X selection is 1273 * gained or lost. 1274 */ 1275 if (curwin->w_cursor.lnum < VIsual.lnum) 1276 { 1277 from = curwin->w_cursor.lnum; 1278 to = VIsual.lnum; 1279 } 1280 else 1281 { 1282 from = VIsual.lnum; 1283 to = curwin->w_cursor.lnum; 1284 } 1285 /* redraw more when the cursor moved as well */ 1286 if (wp->w_old_cursor_lnum < from) 1287 from = wp->w_old_cursor_lnum; 1288 if (wp->w_old_cursor_lnum > to) 1289 to = wp->w_old_cursor_lnum; 1290 if (wp->w_old_visual_lnum < from) 1291 from = wp->w_old_visual_lnum; 1292 if (wp->w_old_visual_lnum > to) 1293 to = wp->w_old_visual_lnum; 1294 } 1295 else 1296 { 1297 /* 1298 * Find the line numbers that need to be updated: The lines 1299 * between the old cursor position and the current cursor 1300 * position. Also check if the Visual position changed. 1301 */ 1302 if (curwin->w_cursor.lnum < wp->w_old_cursor_lnum) 1303 { 1304 from = curwin->w_cursor.lnum; 1305 to = wp->w_old_cursor_lnum; 1306 } 1307 else 1308 { 1309 from = wp->w_old_cursor_lnum; 1310 to = curwin->w_cursor.lnum; 1311 if (from == 0) /* Visual mode just started */ 1312 from = to; 1313 } 1314 1315 if (VIsual.lnum != wp->w_old_visual_lnum 1316 || VIsual.col != wp->w_old_visual_col) 1317 { 1318 if (wp->w_old_visual_lnum < from 1319 && wp->w_old_visual_lnum != 0) 1320 from = wp->w_old_visual_lnum; 1321 if (wp->w_old_visual_lnum > to) 1322 to = wp->w_old_visual_lnum; 1323 if (VIsual.lnum < from) 1324 from = VIsual.lnum; 1325 if (VIsual.lnum > to) 1326 to = VIsual.lnum; 1327 } 1328 } 1329 1330 /* 1331 * If in block mode and changed column or curwin->w_curswant: 1332 * update all lines. 1333 * First compute the actual start and end column. 1334 */ 1335 if (VIsual_mode == Ctrl_V) 1336 { 1337 colnr_T fromc, toc; 1338 1339 getvcols(wp, &VIsual, &curwin->w_cursor, &fromc, &toc); 1340 ++toc; 1341 if (curwin->w_curswant == MAXCOL) 1342 toc = MAXCOL; 1343 1344 if (fromc != wp->w_old_cursor_fcol 1345 || toc != wp->w_old_cursor_lcol) 1346 { 1347 if (from > VIsual.lnum) 1348 from = VIsual.lnum; 1349 if (to < VIsual.lnum) 1350 to = VIsual.lnum; 1351 } 1352 wp->w_old_cursor_fcol = fromc; 1353 wp->w_old_cursor_lcol = toc; 1354 } 1355 } 1356 else 1357 { 1358 /* Use the line numbers of the old Visual area. */ 1359 if (wp->w_old_cursor_lnum < wp->w_old_visual_lnum) 1360 { 1361 from = wp->w_old_cursor_lnum; 1362 to = wp->w_old_visual_lnum; 1363 } 1364 else 1365 { 1366 from = wp->w_old_visual_lnum; 1367 to = wp->w_old_cursor_lnum; 1368 } 1369 } 1370 1371 /* 1372 * There is no need to update lines above the top of the window. 1373 */ 1374 if (from < wp->w_topline) 1375 from = wp->w_topline; 1376 1377 /* 1378 * If we know the value of w_botline, use it to restrict the update to 1379 * the lines that are visible in the window. 1380 */ 1381 if (wp->w_valid & VALID_BOTLINE) 1382 { 1383 if (from >= wp->w_botline) 1384 from = wp->w_botline - 1; 1385 if (to >= wp->w_botline) 1386 to = wp->w_botline - 1; 1387 } 1388 1389 /* 1390 * Find the minimal part to be updated. 1391 * Watch out for scrolling that made entries in w_lines[] invalid. 1392 * E.g., CTRL-U makes the first half of w_lines[] invalid and sets 1393 * top_end; need to redraw from top_end to the "to" line. 1394 * A middle mouse click with a Visual selection may change the text 1395 * above the Visual area and reset wl_valid, do count these for 1396 * mid_end (in srow). 1397 */ 1398 if (mid_start > 0) 1399 { 1400 lnum = wp->w_topline; 1401 idx = 0; 1402 srow = 0; 1403 if (scrolled_down) 1404 mid_start = top_end; 1405 else 1406 mid_start = 0; 1407 while (lnum < from && idx < wp->w_lines_valid) /* find start */ 1408 { 1409 if (wp->w_lines[idx].wl_valid) 1410 mid_start += wp->w_lines[idx].wl_size; 1411 else if (!scrolled_down) 1412 srow += wp->w_lines[idx].wl_size; 1413 ++idx; 1414 # ifdef FEAT_FOLDING 1415 if (idx < wp->w_lines_valid && wp->w_lines[idx].wl_valid) 1416 lnum = wp->w_lines[idx].wl_lnum; 1417 else 1418 # endif 1419 ++lnum; 1420 } 1421 srow += mid_start; 1422 mid_end = wp->w_height; 1423 for ( ; idx < wp->w_lines_valid; ++idx) /* find end */ 1424 { 1425 if (wp->w_lines[idx].wl_valid 1426 && wp->w_lines[idx].wl_lnum >= to + 1) 1427 { 1428 /* Only update until first row of this line */ 1429 mid_end = srow; 1430 break; 1431 } 1432 srow += wp->w_lines[idx].wl_size; 1433 } 1434 } 1435 } 1436 1437 if (VIsual_active && buf == curwin->w_buffer) 1438 { 1439 wp->w_old_visual_mode = VIsual_mode; 1440 wp->w_old_cursor_lnum = curwin->w_cursor.lnum; 1441 wp->w_old_visual_lnum = VIsual.lnum; 1442 wp->w_old_visual_col = VIsual.col; 1443 wp->w_old_curswant = curwin->w_curswant; 1444 } 1445 else 1446 { 1447 wp->w_old_visual_mode = 0; 1448 wp->w_old_cursor_lnum = 0; 1449 wp->w_old_visual_lnum = 0; 1450 wp->w_old_visual_col = 0; 1451 } 1452 #endif /* FEAT_VISUAL */ 1453 1454 #if defined(FEAT_SYN_HL) || defined(FEAT_SEARCH_EXTRA) 1455 /* reset got_int, otherwise regexp won't work */ 1456 save_got_int = got_int; 1457 got_int = 0; 1458 #endif 1459 #ifdef FEAT_FOLDING 1460 win_foldinfo.fi_level = 0; 1461 #endif 1462 1463 /* 1464 * Update all the window rows. 1465 */ 1466 idx = 0; /* first entry in w_lines[].wl_size */ 1467 row = 0; 1468 srow = 0; 1469 lnum = wp->w_topline; /* first line shown in window */ 1470 for (;;) 1471 { 1472 /* stop updating when reached the end of the window (check for _past_ 1473 * the end of the window is at the end of the loop) */ 1474 if (row == wp->w_height) 1475 { 1476 didline = TRUE; 1477 break; 1478 } 1479 1480 /* stop updating when hit the end of the file */ 1481 if (lnum > buf->b_ml.ml_line_count) 1482 { 1483 eof = TRUE; 1484 break; 1485 } 1486 1487 /* Remember the starting row of the line that is going to be dealt 1488 * with. It is used further down when the line doesn't fit. */ 1489 srow = row; 1490 1491 /* 1492 * Update a line when it is in an area that needs updating, when it 1493 * has changes or w_lines[idx] is invalid. 1494 * bot_start may be halfway a wrapped line after using 1495 * win_del_lines(), check if the current line includes it. 1496 * When syntax folding is being used, the saved syntax states will 1497 * already have been updated, we can't see where the syntax state is 1498 * the same again, just update until the end of the window. 1499 */ 1500 if (row < top_end 1501 || (row >= mid_start && row < mid_end) 1502 #ifdef FEAT_SEARCH_EXTRA 1503 || top_to_mod 1504 #endif 1505 || idx >= wp->w_lines_valid 1506 || (row + wp->w_lines[idx].wl_size > bot_start) 1507 || (mod_top != 0 1508 && (lnum == mod_top 1509 || (lnum >= mod_top 1510 && (lnum < mod_bot 1511 #ifdef FEAT_SYN_HL 1512 || did_update == DID_FOLD 1513 || (did_update == DID_LINE 1514 && syntax_present(buf) 1515 && ( 1516 # ifdef FEAT_FOLDING 1517 (foldmethodIsSyntax(wp) 1518 && hasAnyFolding(wp)) || 1519 # endif 1520 syntax_check_changed(lnum))) 1521 #endif 1522 ))))) 1523 { 1524 #ifdef FEAT_SEARCH_EXTRA 1525 if (lnum == mod_top) 1526 top_to_mod = FALSE; 1527 #endif 1528 1529 /* 1530 * When at start of changed lines: May scroll following lines 1531 * up or down to minimize redrawing. 1532 * Don't do this when the change continues until the end. 1533 * Don't scroll when dollar_vcol is non-zero, keep the "$". 1534 */ 1535 if (lnum == mod_top 1536 && mod_bot != MAXLNUM 1537 && !(dollar_vcol != 0 && mod_bot == mod_top + 1)) 1538 { 1539 int old_rows = 0; 1540 int new_rows = 0; 1541 int xtra_rows; 1542 linenr_T l; 1543 1544 /* Count the old number of window rows, using w_lines[], which 1545 * should still contain the sizes for the lines as they are 1546 * currently displayed. */ 1547 for (i = idx; i < wp->w_lines_valid; ++i) 1548 { 1549 /* Only valid lines have a meaningful wl_lnum. Invalid 1550 * lines are part of the changed area. */ 1551 if (wp->w_lines[i].wl_valid 1552 && wp->w_lines[i].wl_lnum == mod_bot) 1553 break; 1554 old_rows += wp->w_lines[i].wl_size; 1555 #ifdef FEAT_FOLDING 1556 if (wp->w_lines[i].wl_valid 1557 && wp->w_lines[i].wl_lastlnum + 1 == mod_bot) 1558 { 1559 /* Must have found the last valid entry above mod_bot. 1560 * Add following invalid entries. */ 1561 ++i; 1562 while (i < wp->w_lines_valid 1563 && !wp->w_lines[i].wl_valid) 1564 old_rows += wp->w_lines[i++].wl_size; 1565 break; 1566 } 1567 #endif 1568 } 1569 1570 if (i >= wp->w_lines_valid) 1571 { 1572 /* We can't find a valid line below the changed lines, 1573 * need to redraw until the end of the window. 1574 * Inserting/deleting lines has no use. */ 1575 bot_start = 0; 1576 } 1577 else 1578 { 1579 /* Able to count old number of rows: Count new window 1580 * rows, and may insert/delete lines */ 1581 j = idx; 1582 for (l = lnum; l < mod_bot; ++l) 1583 { 1584 #ifdef FEAT_FOLDING 1585 if (hasFoldingWin(wp, l, NULL, &l, TRUE, NULL)) 1586 ++new_rows; 1587 else 1588 #endif 1589 #ifdef FEAT_DIFF 1590 if (l == wp->w_topline) 1591 new_rows += plines_win_nofill(wp, l, TRUE) 1592 + wp->w_topfill; 1593 else 1594 #endif 1595 new_rows += plines_win(wp, l, TRUE); 1596 ++j; 1597 if (new_rows > wp->w_height - row - 2) 1598 { 1599 /* it's getting too much, must redraw the rest */ 1600 new_rows = 9999; 1601 break; 1602 } 1603 } 1604 xtra_rows = new_rows - old_rows; 1605 if (xtra_rows < 0) 1606 { 1607 /* May scroll text up. If there is not enough 1608 * remaining text or scrolling fails, must redraw the 1609 * rest. If scrolling works, must redraw the text 1610 * below the scrolled text. */ 1611 if (row - xtra_rows >= wp->w_height - 2) 1612 mod_bot = MAXLNUM; 1613 else 1614 { 1615 check_for_delay(FALSE); 1616 if (win_del_lines(wp, row, 1617 -xtra_rows, FALSE, FALSE) == FAIL) 1618 mod_bot = MAXLNUM; 1619 else 1620 bot_start = wp->w_height + xtra_rows; 1621 } 1622 } 1623 else if (xtra_rows > 0) 1624 { 1625 /* May scroll text down. If there is not enough 1626 * remaining text of scrolling fails, must redraw the 1627 * rest. */ 1628 if (row + xtra_rows >= wp->w_height - 2) 1629 mod_bot = MAXLNUM; 1630 else 1631 { 1632 check_for_delay(FALSE); 1633 if (win_ins_lines(wp, row + old_rows, 1634 xtra_rows, FALSE, FALSE) == FAIL) 1635 mod_bot = MAXLNUM; 1636 else if (top_end > row + old_rows) 1637 /* Scrolled the part at the top that requires 1638 * updating down. */ 1639 top_end += xtra_rows; 1640 } 1641 } 1642 1643 /* When not updating the rest, may need to move w_lines[] 1644 * entries. */ 1645 if (mod_bot != MAXLNUM && i != j) 1646 { 1647 if (j < i) 1648 { 1649 int x = row + new_rows; 1650 1651 /* move entries in w_lines[] upwards */ 1652 for (;;) 1653 { 1654 /* stop at last valid entry in w_lines[] */ 1655 if (i >= wp->w_lines_valid) 1656 { 1657 wp->w_lines_valid = j; 1658 break; 1659 } 1660 wp->w_lines[j] = wp->w_lines[i]; 1661 /* stop at a line that won't fit */ 1662 if (x + (int)wp->w_lines[j].wl_size 1663 > wp->w_height) 1664 { 1665 wp->w_lines_valid = j + 1; 1666 break; 1667 } 1668 x += wp->w_lines[j++].wl_size; 1669 ++i; 1670 } 1671 if (bot_start > x) 1672 bot_start = x; 1673 } 1674 else /* j > i */ 1675 { 1676 /* move entries in w_lines[] downwards */ 1677 j -= i; 1678 wp->w_lines_valid += j; 1679 if (wp->w_lines_valid > wp->w_height) 1680 wp->w_lines_valid = wp->w_height; 1681 for (i = wp->w_lines_valid; i - j >= idx; --i) 1682 wp->w_lines[i] = wp->w_lines[i - j]; 1683 1684 /* The w_lines[] entries for inserted lines are 1685 * now invalid, but wl_size may be used above. 1686 * Reset to zero. */ 1687 while (i >= idx) 1688 { 1689 wp->w_lines[i].wl_size = 0; 1690 wp->w_lines[i--].wl_valid = FALSE; 1691 } 1692 } 1693 } 1694 } 1695 } 1696 1697 #ifdef FEAT_FOLDING 1698 /* 1699 * When lines are folded, display one line for all of them. 1700 * Otherwise, display normally (can be several display lines when 1701 * 'wrap' is on). 1702 */ 1703 fold_count = foldedCount(wp, lnum, &win_foldinfo); 1704 if (fold_count != 0) 1705 { 1706 fold_line(wp, fold_count, &win_foldinfo, lnum, row); 1707 ++row; 1708 --fold_count; 1709 wp->w_lines[idx].wl_folded = TRUE; 1710 wp->w_lines[idx].wl_lastlnum = lnum + fold_count; 1711 # ifdef FEAT_SYN_HL 1712 did_update = DID_FOLD; 1713 # endif 1714 } 1715 else 1716 #endif 1717 if (idx < wp->w_lines_valid 1718 && wp->w_lines[idx].wl_valid 1719 && wp->w_lines[idx].wl_lnum == lnum 1720 && lnum > wp->w_topline 1721 && !(dy_flags & DY_LASTLINE) 1722 && srow + wp->w_lines[idx].wl_size > wp->w_height 1723 #ifdef FEAT_DIFF 1724 && diff_check_fill(wp, lnum) == 0 1725 #endif 1726 ) 1727 { 1728 /* This line is not going to fit. Don't draw anything here, 1729 * will draw "@ " lines below. */ 1730 row = wp->w_height + 1; 1731 } 1732 else 1733 { 1734 #ifdef FEAT_SEARCH_EXTRA 1735 prepare_search_hl(wp, lnum); 1736 #endif 1737 #ifdef FEAT_SYN_HL 1738 /* Let the syntax stuff know we skipped a few lines. */ 1739 if (syntax_last_parsed != 0 && syntax_last_parsed + 1 < lnum 1740 && syntax_present(buf)) 1741 syntax_end_parsing(syntax_last_parsed + 1); 1742 #endif 1743 1744 /* 1745 * Display one line. 1746 */ 1747 row = win_line(wp, lnum, srow, wp->w_height, mod_top == 0); 1748 1749 #ifdef FEAT_FOLDING 1750 wp->w_lines[idx].wl_folded = FALSE; 1751 wp->w_lines[idx].wl_lastlnum = lnum; 1752 #endif 1753 #ifdef FEAT_SYN_HL 1754 did_update = DID_LINE; 1755 syntax_last_parsed = lnum; 1756 #endif 1757 } 1758 1759 wp->w_lines[idx].wl_lnum = lnum; 1760 wp->w_lines[idx].wl_valid = TRUE; 1761 if (row > wp->w_height) /* past end of screen */ 1762 { 1763 /* we may need the size of that too long line later on */ 1764 if (dollar_vcol == 0) 1765 wp->w_lines[idx].wl_size = plines_win(wp, lnum, TRUE); 1766 ++idx; 1767 break; 1768 } 1769 if (dollar_vcol == 0) 1770 wp->w_lines[idx].wl_size = row - srow; 1771 ++idx; 1772 #ifdef FEAT_FOLDING 1773 lnum += fold_count + 1; 1774 #else 1775 ++lnum; 1776 #endif 1777 } 1778 else 1779 { 1780 /* This line does not need updating, advance to the next one */ 1781 row += wp->w_lines[idx++].wl_size; 1782 if (row > wp->w_height) /* past end of screen */ 1783 break; 1784 #ifdef FEAT_FOLDING 1785 lnum = wp->w_lines[idx - 1].wl_lastlnum + 1; 1786 #else 1787 ++lnum; 1788 #endif 1789 #ifdef FEAT_SYN_HL 1790 did_update = DID_NONE; 1791 #endif 1792 } 1793 1794 if (lnum > buf->b_ml.ml_line_count) 1795 { 1796 eof = TRUE; 1797 break; 1798 } 1799 } 1800 /* 1801 * End of loop over all window lines. 1802 */ 1803 1804 1805 if (idx > wp->w_lines_valid) 1806 wp->w_lines_valid = idx; 1807 1808 #ifdef FEAT_SYN_HL 1809 /* 1810 * Let the syntax stuff know we stop parsing here. 1811 */ 1812 if (syntax_last_parsed != 0 && syntax_present(buf)) 1813 syntax_end_parsing(syntax_last_parsed + 1); 1814 #endif 1815 1816 /* 1817 * If we didn't hit the end of the file, and we didn't finish the last 1818 * line we were working on, then the line didn't fit. 1819 */ 1820 wp->w_empty_rows = 0; 1821 #ifdef FEAT_DIFF 1822 wp->w_filler_rows = 0; 1823 #endif 1824 if (!eof && !didline) 1825 { 1826 if (lnum == wp->w_topline) 1827 { 1828 /* 1829 * Single line that does not fit! 1830 * Don't overwrite it, it can be edited. 1831 */ 1832 wp->w_botline = lnum + 1; 1833 } 1834 #ifdef FEAT_DIFF 1835 else if (diff_check_fill(wp, lnum) >= wp->w_height - srow) 1836 { 1837 /* Window ends in filler lines. */ 1838 wp->w_botline = lnum; 1839 wp->w_filler_rows = wp->w_height - srow; 1840 } 1841 #endif 1842 else if (dy_flags & DY_LASTLINE) /* 'display' has "lastline" */ 1843 { 1844 /* 1845 * Last line isn't finished: Display "@@@" at the end. 1846 */ 1847 screen_fill(W_WINROW(wp) + wp->w_height - 1, 1848 W_WINROW(wp) + wp->w_height, 1849 (int)W_ENDCOL(wp) - 3, (int)W_ENDCOL(wp), 1850 '@', '@', hl_attr(HLF_AT)); 1851 set_empty_rows(wp, srow); 1852 wp->w_botline = lnum; 1853 } 1854 else 1855 { 1856 win_draw_end(wp, '@', ' ', srow, wp->w_height, HLF_AT); 1857 wp->w_botline = lnum; 1858 } 1859 } 1860 else 1861 { 1862 #ifdef FEAT_VERTSPLIT 1863 draw_vsep_win(wp, row); 1864 #endif 1865 if (eof) /* we hit the end of the file */ 1866 { 1867 wp->w_botline = buf->b_ml.ml_line_count + 1; 1868 #ifdef FEAT_DIFF 1869 j = diff_check_fill(wp, wp->w_botline); 1870 if (j > 0 && !wp->w_botfill) 1871 { 1872 /* 1873 * Display filler lines at the end of the file 1874 */ 1875 if (char2cells(fill_diff) > 1) 1876 i = '-'; 1877 else 1878 i = fill_diff; 1879 if (row + j > wp->w_height) 1880 j = wp->w_height - row; 1881 win_draw_end(wp, i, i, row, row + (int)j, HLF_DED); 1882 row += j; 1883 } 1884 #endif 1885 } 1886 else if (dollar_vcol == 0) 1887 wp->w_botline = lnum; 1888 1889 /* make sure the rest of the screen is blank */ 1890 /* put '~'s on rows that aren't part of the file. */ 1891 win_draw_end(wp, '~', ' ', row, wp->w_height, HLF_AT); 1892 } 1893 1894 /* Reset the type of redrawing required, the window has been updated. */ 1895 wp->w_redr_type = 0; 1896 #ifdef FEAT_DIFF 1897 wp->w_old_topfill = wp->w_topfill; 1898 wp->w_old_botfill = wp->w_botfill; 1899 #endif 1900 1901 if (dollar_vcol == 0) 1902 { 1903 /* 1904 * There is a trick with w_botline. If we invalidate it on each 1905 * change that might modify it, this will cause a lot of expensive 1906 * calls to plines() in update_topline() each time. Therefore the 1907 * value of w_botline is often approximated, and this value is used to 1908 * compute the value of w_topline. If the value of w_botline was 1909 * wrong, check that the value of w_topline is correct (cursor is on 1910 * the visible part of the text). If it's not, we need to redraw 1911 * again. Mostly this just means scrolling up a few lines, so it 1912 * doesn't look too bad. Only do this for the current window (where 1913 * changes are relevant). 1914 */ 1915 wp->w_valid |= VALID_BOTLINE; 1916 if (wp == curwin && wp->w_botline != old_botline && !recursive) 1917 { 1918 recursive = TRUE; 1919 curwin->w_valid &= ~VALID_TOPLINE; 1920 update_topline(); /* may invalidate w_botline again */ 1921 if (must_redraw != 0) 1922 { 1923 /* Don't update for changes in buffer again. */ 1924 i = curbuf->b_mod_set; 1925 curbuf->b_mod_set = FALSE; 1926 win_update(curwin); 1927 must_redraw = 0; 1928 curbuf->b_mod_set = i; 1929 } 1930 recursive = FALSE; 1931 } 1932 } 1933 1934 #if defined(FEAT_SYN_HL) || defined(FEAT_SEARCH_EXTRA) 1935 /* restore got_int, unless CTRL-C was hit while redrawing */ 1936 if (!got_int) 1937 got_int = save_got_int; 1938 #endif 1939 } 1940 1941 #ifdef FEAT_SIGNS 1942 static int draw_signcolumn __ARGS((win_T *wp)); 1943 1944 /* 1945 * Return TRUE when window "wp" has a column to draw signs in. 1946 */ 1947 static int 1948 draw_signcolumn(wp) 1949 win_T *wp; 1950 { 1951 return (wp->w_buffer->b_signlist != NULL 1952 # ifdef FEAT_NETBEANS_INTG 1953 || usingNetbeans 1954 # endif 1955 ); 1956 } 1957 #endif 1958 1959 /* 1960 * Clear the rest of the window and mark the unused lines with "c1". use "c2" 1961 * as the filler character. 1962 */ 1963 static void 1964 win_draw_end(wp, c1, c2, row, endrow, hl) 1965 win_T *wp; 1966 int c1; 1967 int c2; 1968 int row; 1969 int endrow; 1970 hlf_T hl; 1971 { 1972 #if defined(FEAT_FOLDING) || defined(FEAT_SIGNS) || defined(FEAT_CMDWIN) 1973 int n = 0; 1974 # define FDC_OFF n 1975 #else 1976 # define FDC_OFF 0 1977 #endif 1978 1979 #ifdef FEAT_RIGHTLEFT 1980 if (wp->w_p_rl) 1981 { 1982 /* No check for cmdline window: should never be right-left. */ 1983 # ifdef FEAT_FOLDING 1984 n = wp->w_p_fdc; 1985 1986 if (n > 0) 1987 { 1988 /* draw the fold column at the right */ 1989 if (n > W_WIDTH(wp)) 1990 n = W_WIDTH(wp); 1991 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow, 1992 W_ENDCOL(wp) - n, (int)W_ENDCOL(wp), 1993 ' ', ' ', hl_attr(HLF_FC)); 1994 } 1995 # endif 1996 # ifdef FEAT_SIGNS 1997 if (draw_signcolumn(wp)) 1998 { 1999 int nn = n + 2; 2000 2001 /* draw the sign column left of the fold column */ 2002 if (nn > W_WIDTH(wp)) 2003 nn = W_WIDTH(wp); 2004 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow, 2005 W_ENDCOL(wp) - nn, (int)W_ENDCOL(wp) - n, 2006 ' ', ' ', hl_attr(HLF_SC)); 2007 n = nn; 2008 } 2009 # endif 2010 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow, 2011 W_WINCOL(wp), W_ENDCOL(wp) - 1 - FDC_OFF, 2012 c2, c2, hl_attr(hl)); 2013 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow, 2014 W_ENDCOL(wp) - 1 - FDC_OFF, W_ENDCOL(wp) - FDC_OFF, 2015 c1, c2, hl_attr(hl)); 2016 } 2017 else 2018 #endif 2019 { 2020 #ifdef FEAT_CMDWIN 2021 if (cmdwin_type != 0 && wp == curwin) 2022 { 2023 /* draw the cmdline character in the leftmost column */ 2024 n = 1; 2025 if (n > wp->w_width) 2026 n = wp->w_width; 2027 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow, 2028 W_WINCOL(wp), (int)W_WINCOL(wp) + n, 2029 cmdwin_type, ' ', hl_attr(HLF_AT)); 2030 } 2031 #endif 2032 #ifdef FEAT_FOLDING 2033 if (wp->w_p_fdc > 0) 2034 { 2035 int nn = n + wp->w_p_fdc; 2036 2037 /* draw the fold column at the left */ 2038 if (nn > W_WIDTH(wp)) 2039 nn = W_WIDTH(wp); 2040 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow, 2041 W_WINCOL(wp) + n, (int)W_WINCOL(wp) + nn, 2042 ' ', ' ', hl_attr(HLF_FC)); 2043 n = nn; 2044 } 2045 #endif 2046 #ifdef FEAT_SIGNS 2047 if (draw_signcolumn(wp)) 2048 { 2049 int nn = n + 2; 2050 2051 /* draw the sign column after the fold column */ 2052 if (nn > W_WIDTH(wp)) 2053 nn = W_WIDTH(wp); 2054 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow, 2055 W_WINCOL(wp) + n, (int)W_WINCOL(wp) + nn, 2056 ' ', ' ', hl_attr(HLF_SC)); 2057 n = nn; 2058 } 2059 #endif 2060 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow, 2061 W_WINCOL(wp) + FDC_OFF, (int)W_ENDCOL(wp), 2062 c1, c2, hl_attr(hl)); 2063 } 2064 set_empty_rows(wp, row); 2065 } 2066 2067 #ifdef FEAT_FOLDING 2068 /* 2069 * Display one folded line. 2070 */ 2071 static void 2072 fold_line(wp, fold_count, foldinfo, lnum, row) 2073 win_T *wp; 2074 long fold_count; 2075 foldinfo_T *foldinfo; 2076 linenr_T lnum; 2077 int row; 2078 { 2079 char_u buf[51]; 2080 pos_T *top, *bot; 2081 linenr_T lnume = lnum + fold_count - 1; 2082 int len; 2083 char_u *text; 2084 int fdc; 2085 int col; 2086 int txtcol; 2087 int off = (int)(current_ScreenLine - ScreenLines); 2088 int ri; 2089 2090 /* Build the fold line: 2091 * 1. Add the cmdwin_type for the command-line window 2092 * 2. Add the 'foldcolumn' 2093 * 3. Add the 'number' column 2094 * 4. Compose the text 2095 * 5. Add the text 2096 * 6. set highlighting for the Visual area an other text 2097 */ 2098 col = 0; 2099 2100 /* 2101 * 1. Add the cmdwin_type for the command-line window 2102 * Ignores 'rightleft', this window is never right-left. 2103 */ 2104 #ifdef FEAT_CMDWIN 2105 if (cmdwin_type != 0 && wp == curwin) 2106 { 2107 ScreenLines[off] = cmdwin_type; 2108 ScreenAttrs[off] = hl_attr(HLF_AT); 2109 #ifdef FEAT_MBYTE 2110 if (enc_utf8) 2111 ScreenLinesUC[off] = 0; 2112 #endif 2113 ++col; 2114 } 2115 #endif 2116 2117 /* 2118 * 2. Add the 'foldcolumn' 2119 */ 2120 fdc = wp->w_p_fdc; 2121 if (fdc > W_WIDTH(wp) - col) 2122 fdc = W_WIDTH(wp) - col; 2123 if (fdc > 0) 2124 { 2125 fill_foldcolumn(buf, wp, TRUE, lnum); 2126 #ifdef FEAT_RIGHTLEFT 2127 if (wp->w_p_rl) 2128 { 2129 int i; 2130 2131 copy_text_attr(off + W_WIDTH(wp) - fdc - col, buf, fdc, 2132 hl_attr(HLF_FC)); 2133 /* reverse the fold column */ 2134 for (i = 0; i < fdc; ++i) 2135 ScreenLines[off + W_WIDTH(wp) - i - 1 - col] = buf[i]; 2136 } 2137 else 2138 #endif 2139 copy_text_attr(off + col, buf, fdc, hl_attr(HLF_FC)); 2140 col += fdc; 2141 } 2142 2143 #ifdef FEAT_RIGHTLEFT 2144 # define RL_MEMSET(p, v, l) if (wp->w_p_rl) \ 2145 for (ri = 0; ri < l; ++ri) \ 2146 ScreenAttrs[off + (W_WIDTH(wp) - (p) - (l)) + ri] = v; \ 2147 else \ 2148 for (ri = 0; ri < l; ++ri) \ 2149 ScreenAttrs[off + (p) + ri] = v 2150 #else 2151 # define RL_MEMSET(p, v, l) for (ri = 0; ri < l; ++ri) \ 2152 ScreenAttrs[off + (p) + ri] = v 2153 #endif 2154 2155 /* Set all attributes of the 'number' column and the text */ 2156 RL_MEMSET(col, hl_attr(HLF_FL), W_WIDTH(wp) - col); 2157 2158 #ifdef FEAT_SIGNS 2159 /* If signs are being displayed, add two spaces. */ 2160 if (draw_signcolumn(wp)) 2161 { 2162 len = W_WIDTH(wp) - col; 2163 if (len > 0) 2164 { 2165 if (len > 2) 2166 len = 2; 2167 # ifdef FEAT_RIGHTLEFT 2168 if (wp->w_p_rl) 2169 /* the line number isn't reversed */ 2170 copy_text_attr(off + W_WIDTH(wp) - len - col, 2171 (char_u *)" ", len, hl_attr(HLF_FL)); 2172 else 2173 # endif 2174 copy_text_attr(off + col, (char_u *)" ", len, hl_attr(HLF_FL)); 2175 col += len; 2176 } 2177 } 2178 #endif 2179 2180 /* 2181 * 3. Add the 'number' column 2182 */ 2183 if (wp->w_p_nu) 2184 { 2185 len = W_WIDTH(wp) - col; 2186 if (len > 0) 2187 { 2188 int w = number_width(wp); 2189 2190 if (len > w + 1) 2191 len = w + 1; 2192 sprintf((char *)buf, "%*ld ", w, (long)lnum); 2193 #ifdef FEAT_RIGHTLEFT 2194 if (wp->w_p_rl) 2195 /* the line number isn't reversed */ 2196 copy_text_attr(off + W_WIDTH(wp) - len - col, buf, len, 2197 hl_attr(HLF_FL)); 2198 else 2199 #endif 2200 copy_text_attr(off + col, buf, len, hl_attr(HLF_FL)); 2201 col += len; 2202 } 2203 } 2204 2205 /* 2206 * 4. Compose the folded-line string with 'foldtext', if set. 2207 */ 2208 text = get_foldtext(wp, lnum, lnume, foldinfo, buf); 2209 2210 txtcol = col; /* remember where text starts */ 2211 2212 /* 2213 * 5. move the text to current_ScreenLine. Fill up with "fill_fold". 2214 * Right-left text is put in columns 0 - number-col, normal text is put 2215 * in columns number-col - window-width. 2216 */ 2217 #ifdef FEAT_MBYTE 2218 if (has_mbyte) 2219 { 2220 int cells; 2221 int u8c, u8cc[MAX_MCO]; 2222 int i; 2223 int idx; 2224 int c_len; 2225 char_u *p; 2226 # ifdef FEAT_ARABIC 2227 int prev_c = 0; /* previous Arabic character */ 2228 int prev_c1 = 0; /* first composing char for prev_c */ 2229 # endif 2230 2231 # ifdef FEAT_RIGHTLEFT 2232 if (wp->w_p_rl) 2233 idx = off; 2234 else 2235 # endif 2236 idx = off + col; 2237 2238 /* Store multibyte characters in ScreenLines[] et al. correctly. */ 2239 for (p = text; *p != NUL; ) 2240 { 2241 cells = (*mb_ptr2cells)(p); 2242 c_len = (*mb_ptr2len)(p); 2243 if (col + cells > W_WIDTH(wp) 2244 # ifdef FEAT_RIGHTLEFT 2245 - (wp->w_p_rl ? col : 0) 2246 # endif 2247 ) 2248 break; 2249 ScreenLines[idx] = *p; 2250 if (enc_utf8) 2251 { 2252 u8c = utfc_ptr2char(p, u8cc); 2253 if (*p < 0x80 && u8cc[0] == 0) 2254 { 2255 ScreenLinesUC[idx] = 0; 2256 #ifdef FEAT_ARABIC 2257 prev_c = u8c; 2258 #endif 2259 } 2260 else 2261 { 2262 #ifdef FEAT_ARABIC 2263 if (p_arshape && !p_tbidi && ARABIC_CHAR(u8c)) 2264 { 2265 /* Do Arabic shaping. */ 2266 int pc, pc1, nc; 2267 int pcc[MAX_MCO]; 2268 int firstbyte = *p; 2269 2270 /* The idea of what is the previous and next 2271 * character depends on 'rightleft'. */ 2272 if (wp->w_p_rl) 2273 { 2274 pc = prev_c; 2275 pc1 = prev_c1; 2276 nc = utf_ptr2char(p + c_len); 2277 prev_c1 = u8cc[0]; 2278 } 2279 else 2280 { 2281 pc = utfc_ptr2char(p + c_len, pcc); 2282 nc = prev_c; 2283 pc1 = pcc[0]; 2284 } 2285 prev_c = u8c; 2286 2287 u8c = arabic_shape(u8c, &firstbyte, &u8cc[0], 2288 pc, pc1, nc); 2289 ScreenLines[idx] = firstbyte; 2290 } 2291 else 2292 prev_c = u8c; 2293 #endif 2294 /* Non-BMP character: display as ? or fullwidth ?. */ 2295 if (u8c >= 0x10000) 2296 ScreenLinesUC[idx] = (cells == 2) ? 0xff1f : (int)'?'; 2297 else 2298 ScreenLinesUC[idx] = u8c; 2299 for (i = 0; i < Screen_mco; ++i) 2300 { 2301 ScreenLinesC[i][idx] = u8cc[i]; 2302 if (u8cc[i] == 0) 2303 break; 2304 } 2305 } 2306 if (cells > 1) 2307 ScreenLines[idx + 1] = 0; 2308 } 2309 else if (cells > 1) /* double-byte character */ 2310 { 2311 if (enc_dbcs == DBCS_JPNU && *p == 0x8e) 2312 ScreenLines2[idx] = p[1]; 2313 else 2314 ScreenLines[idx + 1] = p[1]; 2315 } 2316 col += cells; 2317 idx += cells; 2318 p += c_len; 2319 } 2320 } 2321 else 2322 #endif 2323 { 2324 len = (int)STRLEN(text); 2325 if (len > W_WIDTH(wp) - col) 2326 len = W_WIDTH(wp) - col; 2327 if (len > 0) 2328 { 2329 #ifdef FEAT_RIGHTLEFT 2330 if (wp->w_p_rl) 2331 STRNCPY(current_ScreenLine, text, len); 2332 else 2333 #endif 2334 STRNCPY(current_ScreenLine + col, text, len); 2335 col += len; 2336 } 2337 } 2338 2339 /* Fill the rest of the line with the fold filler */ 2340 #ifdef FEAT_RIGHTLEFT 2341 if (wp->w_p_rl) 2342 col -= txtcol; 2343 #endif 2344 while (col < W_WIDTH(wp) 2345 #ifdef FEAT_RIGHTLEFT 2346 - (wp->w_p_rl ? txtcol : 0) 2347 #endif 2348 ) 2349 { 2350 #ifdef FEAT_MBYTE 2351 if (enc_utf8) 2352 { 2353 if (fill_fold >= 0x80) 2354 { 2355 ScreenLinesUC[off + col] = fill_fold; 2356 ScreenLinesC[0][off + col] = 0; 2357 } 2358 else 2359 ScreenLinesUC[off + col] = 0; 2360 } 2361 #endif 2362 ScreenLines[off + col++] = fill_fold; 2363 } 2364 2365 if (text != buf) 2366 vim_free(text); 2367 2368 /* 2369 * 6. set highlighting for the Visual area an other text. 2370 * If all folded lines are in the Visual area, highlight the line. 2371 */ 2372 #ifdef FEAT_VISUAL 2373 if (VIsual_active && wp->w_buffer == curwin->w_buffer) 2374 { 2375 if (ltoreq(curwin->w_cursor, VIsual)) 2376 { 2377 /* Visual is after curwin->w_cursor */ 2378 top = &curwin->w_cursor; 2379 bot = &VIsual; 2380 } 2381 else 2382 { 2383 /* Visual is before curwin->w_cursor */ 2384 top = &VIsual; 2385 bot = &curwin->w_cursor; 2386 } 2387 if (lnum >= top->lnum 2388 && lnume <= bot->lnum 2389 && (VIsual_mode != 'v' 2390 || ((lnum > top->lnum 2391 || (lnum == top->lnum 2392 && top->col == 0)) 2393 && (lnume < bot->lnum 2394 || (lnume == bot->lnum 2395 && (bot->col - (*p_sel == 'e')) 2396 >= STRLEN(ml_get_buf(wp->w_buffer, lnume, FALSE))))))) 2397 { 2398 if (VIsual_mode == Ctrl_V) 2399 { 2400 /* Visual block mode: highlight the chars part of the block */ 2401 if (wp->w_old_cursor_fcol + txtcol < (colnr_T)W_WIDTH(wp)) 2402 { 2403 if (wp->w_old_cursor_lcol + txtcol < (colnr_T)W_WIDTH(wp)) 2404 len = wp->w_old_cursor_lcol; 2405 else 2406 len = W_WIDTH(wp) - txtcol; 2407 RL_MEMSET(wp->w_old_cursor_fcol + txtcol, hl_attr(HLF_V), 2408 len - (int)wp->w_old_cursor_fcol); 2409 } 2410 } 2411 else 2412 { 2413 /* Set all attributes of the text */ 2414 RL_MEMSET(txtcol, hl_attr(HLF_V), W_WIDTH(wp) - txtcol); 2415 } 2416 } 2417 } 2418 #endif 2419 2420 #ifdef FEAT_SYN_HL 2421 /* Show 'cursorcolumn' in the fold line. */ 2422 if (wp->w_p_cuc && (int)wp->w_virtcol + txtcol < W_WIDTH(wp)) 2423 ScreenAttrs[off + wp->w_virtcol + txtcol] = hl_combine_attr( 2424 ScreenAttrs[off + wp->w_virtcol + txtcol], hl_attr(HLF_CUC)); 2425 #endif 2426 2427 SCREEN_LINE(row + W_WINROW(wp), W_WINCOL(wp), (int)W_WIDTH(wp), 2428 (int)W_WIDTH(wp), FALSE); 2429 2430 /* 2431 * Update w_cline_height and w_cline_folded if the cursor line was 2432 * updated (saves a call to plines() later). 2433 */ 2434 if (wp == curwin 2435 && lnum <= curwin->w_cursor.lnum 2436 && lnume >= curwin->w_cursor.lnum) 2437 { 2438 curwin->w_cline_row = row; 2439 curwin->w_cline_height = 1; 2440 curwin->w_cline_folded = TRUE; 2441 curwin->w_valid |= (VALID_CHEIGHT|VALID_CROW); 2442 } 2443 } 2444 2445 /* 2446 * Copy "buf[len]" to ScreenLines["off"] and set attributes to "attr". 2447 */ 2448 static void 2449 copy_text_attr(off, buf, len, attr) 2450 int off; 2451 char_u *buf; 2452 int len; 2453 int attr; 2454 { 2455 int i; 2456 2457 mch_memmove(ScreenLines + off, buf, (size_t)len); 2458 # ifdef FEAT_MBYTE 2459 if (enc_utf8) 2460 vim_memset(ScreenLinesUC + off, 0, sizeof(u8char_T) * (size_t)len); 2461 # endif 2462 for (i = 0; i < len; ++i) 2463 ScreenAttrs[off + i] = attr; 2464 } 2465 2466 /* 2467 * Fill the foldcolumn at "p" for window "wp". 2468 * Only to be called when 'foldcolumn' > 0. 2469 */ 2470 static void 2471 fill_foldcolumn(p, wp, closed, lnum) 2472 char_u *p; 2473 win_T *wp; 2474 int closed; /* TRUE of FALSE */ 2475 linenr_T lnum; /* current line number */ 2476 { 2477 int i = 0; 2478 int level; 2479 int first_level; 2480 int empty; 2481 2482 /* Init to all spaces. */ 2483 copy_spaces(p, (size_t)wp->w_p_fdc); 2484 2485 level = win_foldinfo.fi_level; 2486 if (level > 0) 2487 { 2488 /* If there is only one column put more info in it. */ 2489 empty = (wp->w_p_fdc == 1) ? 0 : 1; 2490 2491 /* If the column is too narrow, we start at the lowest level that 2492 * fits and use numbers to indicated the depth. */ 2493 first_level = level - wp->w_p_fdc - closed + 1 + empty; 2494 if (first_level < 1) 2495 first_level = 1; 2496 2497 for (i = 0; i + empty < wp->w_p_fdc; ++i) 2498 { 2499 if (win_foldinfo.fi_lnum == lnum 2500 && first_level + i >= win_foldinfo.fi_low_level) 2501 p[i] = '-'; 2502 else if (first_level == 1) 2503 p[i] = '|'; 2504 else if (first_level + i <= 9) 2505 p[i] = '0' + first_level + i; 2506 else 2507 p[i] = '>'; 2508 if (first_level + i == level) 2509 break; 2510 } 2511 } 2512 if (closed) 2513 p[i >= wp->w_p_fdc ? i - 1 : i] = '+'; 2514 } 2515 #endif /* FEAT_FOLDING */ 2516 2517 /* 2518 * Display line "lnum" of window 'wp' on the screen. 2519 * Start at row "startrow", stop when "endrow" is reached. 2520 * wp->w_virtcol needs to be valid. 2521 * 2522 * Return the number of last row the line occupies. 2523 */ 2524 /* ARGSUSED */ 2525 static int 2526 win_line(wp, lnum, startrow, endrow, nochange) 2527 win_T *wp; 2528 linenr_T lnum; 2529 int startrow; 2530 int endrow; 2531 int nochange; /* not updating for changed text */ 2532 { 2533 int col; /* visual column on screen */ 2534 unsigned off; /* offset in ScreenLines/ScreenAttrs */ 2535 int c = 0; /* init for GCC */ 2536 long vcol = 0; /* virtual column (for tabs) */ 2537 long vcol_prev = -1; /* "vcol" of previous character */ 2538 char_u *line; /* current line */ 2539 char_u *ptr; /* current position in "line" */ 2540 int row; /* row in the window, excl w_winrow */ 2541 int screen_row; /* row on the screen, incl w_winrow */ 2542 2543 char_u extra[18]; /* "%ld" and 'fdc' must fit in here */ 2544 int n_extra = 0; /* number of extra chars */ 2545 char_u *p_extra = NULL; /* string of extra chars */ 2546 int c_extra = NUL; /* extra chars, all the same */ 2547 int extra_attr = 0; /* attributes when n_extra != 0 */ 2548 static char_u *at_end_str = (char_u *)""; /* used for p_extra when 2549 displaying lcs_eol at end-of-line */ 2550 int lcs_eol_one = lcs_eol; /* lcs_eol until it's been used */ 2551 int lcs_prec_todo = lcs_prec; /* lcs_prec until it's been used */ 2552 2553 /* saved "extra" items for when draw_state becomes WL_LINE (again) */ 2554 int saved_n_extra = 0; 2555 char_u *saved_p_extra = NULL; 2556 int saved_c_extra = 0; 2557 int saved_char_attr = 0; 2558 2559 int n_attr = 0; /* chars with special attr */ 2560 int saved_attr2 = 0; /* char_attr saved for n_attr */ 2561 int n_attr3 = 0; /* chars with overruling special attr */ 2562 int saved_attr3 = 0; /* char_attr saved for n_attr3 */ 2563 2564 int n_skip = 0; /* nr of chars to skip for 'nowrap' */ 2565 2566 int fromcol, tocol; /* start/end of inverting */ 2567 int fromcol_prev = -2; /* start of inverting after cursor */ 2568 int noinvcur = FALSE; /* don't invert the cursor */ 2569 #ifdef FEAT_VISUAL 2570 pos_T *top, *bot; 2571 #endif 2572 pos_T pos; 2573 long v; 2574 2575 int char_attr = 0; /* attributes for next character */ 2576 int attr_pri = FALSE; /* char_attr has priority */ 2577 int area_highlighting = FALSE; /* Visual or incsearch highlighting 2578 in this line */ 2579 int attr = 0; /* attributes for area highlighting */ 2580 int area_attr = 0; /* attributes desired by highlighting */ 2581 int search_attr = 0; /* attributes desired by 'hlsearch' */ 2582 #ifdef FEAT_SYN_HL 2583 int vcol_save_attr = 0; /* saved attr for 'cursorcolumn' */ 2584 int syntax_attr = 0; /* attributes desired by syntax */ 2585 int has_syntax = FALSE; /* this buffer has syntax highl. */ 2586 int save_did_emsg; 2587 #endif 2588 #ifdef FEAT_SPELL 2589 int has_spell = FALSE; /* this buffer has spell checking */ 2590 # define SPWORDLEN 150 2591 char_u nextline[SPWORDLEN * 2];/* text with start of the next line */ 2592 int nextlinecol = 0; /* column where nextline[] starts */ 2593 int nextline_idx = 0; /* index in nextline[] where next line 2594 starts */ 2595 int spell_attr = 0; /* attributes desired by spelling */ 2596 int word_end = 0; /* last byte with same spell_attr */ 2597 static linenr_T checked_lnum = 0; /* line number for "checked_col" */ 2598 static int checked_col = 0; /* column in "checked_lnum" up to which 2599 * there are no spell errors */ 2600 static int cap_col = -1; /* column to check for Cap word */ 2601 static linenr_T capcol_lnum = 0; /* line number where "cap_col" used */ 2602 int cur_checked_col = 0; /* checked column for current line */ 2603 #endif 2604 int extra_check; /* has syntax or linebreak */ 2605 #ifdef FEAT_MBYTE 2606 int multi_attr = 0; /* attributes desired by multibyte */ 2607 int mb_l = 1; /* multi-byte byte length */ 2608 int mb_c = 0; /* decoded multi-byte character */ 2609 int mb_utf8 = FALSE; /* screen char is UTF-8 char */ 2610 int u8cc[MAX_MCO]; /* composing UTF-8 chars */ 2611 #endif 2612 #ifdef FEAT_DIFF 2613 int filler_lines; /* nr of filler lines to be drawn */ 2614 int filler_todo; /* nr of filler lines still to do + 1 */ 2615 hlf_T diff_hlf = (hlf_T)0; /* type of diff highlighting */ 2616 int change_start = MAXCOL; /* first col of changed area */ 2617 int change_end = -1; /* last col of changed area */ 2618 #endif 2619 colnr_T trailcol = MAXCOL; /* start of trailing spaces */ 2620 #ifdef FEAT_LINEBREAK 2621 int need_showbreak = FALSE; 2622 #endif 2623 #if defined(FEAT_SIGNS) || (defined(FEAT_QUICKFIX) && defined(FEAT_WINDOWS)) \ 2624 || defined(FEAT_SYN_HL) || defined(FEAT_DIFF) 2625 # define LINE_ATTR 2626 int line_attr = 0; /* atrribute for the whole line */ 2627 #endif 2628 #ifdef FEAT_SEARCH_EXTRA 2629 match_T *shl; /* points to search_hl or match_hl */ 2630 #endif 2631 #if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_MBYTE) 2632 int i; 2633 #endif 2634 #ifdef FEAT_ARABIC 2635 int prev_c = 0; /* previous Arabic character */ 2636 int prev_c1 = 0; /* first composing char for prev_c */ 2637 #endif 2638 #if defined(LINE_ATTR) 2639 int did_line_attr = 0; 2640 #endif 2641 2642 /* draw_state: items that are drawn in sequence: */ 2643 #define WL_START 0 /* nothing done yet */ 2644 #ifdef FEAT_CMDWIN 2645 # define WL_CMDLINE WL_START + 1 /* cmdline window column */ 2646 #else 2647 # define WL_CMDLINE WL_START 2648 #endif 2649 #ifdef FEAT_FOLDING 2650 # define WL_FOLD WL_CMDLINE + 1 /* 'foldcolumn' */ 2651 #else 2652 # define WL_FOLD WL_CMDLINE 2653 #endif 2654 #ifdef FEAT_SIGNS 2655 # define WL_SIGN WL_FOLD + 1 /* column for signs */ 2656 #else 2657 # define WL_SIGN WL_FOLD /* column for signs */ 2658 #endif 2659 #define WL_NR WL_SIGN + 1 /* line number */ 2660 #if defined(FEAT_LINEBREAK) || defined(FEAT_DIFF) 2661 # define WL_SBR WL_NR + 1 /* 'showbreak' or 'diff' */ 2662 #else 2663 # define WL_SBR WL_NR 2664 #endif 2665 #define WL_LINE WL_SBR + 1 /* text in the line */ 2666 int draw_state = WL_START; /* what to draw next */ 2667 #if defined(FEAT_XIM) && defined(FEAT_GUI_GTK) 2668 int feedback_col = 0; 2669 int feedback_old_attr = -1; 2670 #endif 2671 2672 2673 if (startrow > endrow) /* past the end already! */ 2674 return startrow; 2675 2676 row = startrow; 2677 screen_row = row + W_WINROW(wp); 2678 2679 /* 2680 * To speed up the loop below, set extra_check when there is linebreak, 2681 * trailing white space and/or syntax processing to be done. 2682 */ 2683 #ifdef FEAT_LINEBREAK 2684 extra_check = wp->w_p_lbr; 2685 #else 2686 extra_check = 0; 2687 #endif 2688 #ifdef FEAT_SYN_HL 2689 if (syntax_present(wp->w_buffer) && !wp->w_buffer->b_syn_error) 2690 { 2691 /* Prepare for syntax highlighting in this line. When there is an 2692 * error, stop syntax highlighting. */ 2693 save_did_emsg = did_emsg; 2694 did_emsg = FALSE; 2695 syntax_start(wp, lnum); 2696 if (did_emsg) 2697 wp->w_buffer->b_syn_error = TRUE; 2698 else 2699 { 2700 did_emsg = save_did_emsg; 2701 has_syntax = TRUE; 2702 extra_check = TRUE; 2703 } 2704 } 2705 #endif 2706 2707 #ifdef FEAT_SPELL 2708 if (wp->w_p_spell 2709 && *wp->w_buffer->b_p_spl != NUL 2710 && wp->w_buffer->b_langp.ga_len > 0 2711 && *(char **)(wp->w_buffer->b_langp.ga_data) != NULL) 2712 { 2713 /* Prepare for spell checking. */ 2714 has_spell = TRUE; 2715 extra_check = TRUE; 2716 2717 /* Get the start of the next line, so that words that wrap to the next 2718 * line are found too: "et<line-break>al.". 2719 * Trick: skip a few chars for C/shell/Vim comments */ 2720 nextline[SPWORDLEN] = NUL; 2721 if (lnum < wp->w_buffer->b_ml.ml_line_count) 2722 { 2723 line = ml_get_buf(wp->w_buffer, lnum + 1, FALSE); 2724 spell_cat_line(nextline + SPWORDLEN, line, SPWORDLEN); 2725 } 2726 2727 /* When a word wrapped from the previous line the start of the current 2728 * line is valid. */ 2729 if (lnum == checked_lnum) 2730 cur_checked_col = checked_col; 2731 checked_lnum = 0; 2732 2733 /* When there was a sentence end in the previous line may require a 2734 * word starting with capital in this line. In line 1 always check 2735 * the first word. */ 2736 if (lnum != capcol_lnum) 2737 cap_col = -1; 2738 if (lnum == 1) 2739 cap_col = 0; 2740 capcol_lnum = 0; 2741 } 2742 #endif 2743 2744 /* 2745 * handle visual active in this window 2746 */ 2747 fromcol = -10; 2748 tocol = MAXCOL; 2749 #ifdef FEAT_VISUAL 2750 if (VIsual_active && wp->w_buffer == curwin->w_buffer) 2751 { 2752 /* Visual is after curwin->w_cursor */ 2753 if (ltoreq(curwin->w_cursor, VIsual)) 2754 { 2755 top = &curwin->w_cursor; 2756 bot = &VIsual; 2757 } 2758 else /* Visual is before curwin->w_cursor */ 2759 { 2760 top = &VIsual; 2761 bot = &curwin->w_cursor; 2762 } 2763 if (VIsual_mode == Ctrl_V) /* block mode */ 2764 { 2765 if (lnum >= top->lnum && lnum <= bot->lnum) 2766 { 2767 fromcol = wp->w_old_cursor_fcol; 2768 tocol = wp->w_old_cursor_lcol; 2769 } 2770 } 2771 else /* non-block mode */ 2772 { 2773 if (lnum > top->lnum && lnum <= bot->lnum) 2774 fromcol = 0; 2775 else if (lnum == top->lnum) 2776 { 2777 if (VIsual_mode == 'V') /* linewise */ 2778 fromcol = 0; 2779 else 2780 { 2781 getvvcol(wp, top, (colnr_T *)&fromcol, NULL, NULL); 2782 if (gchar_pos(top) == NUL) 2783 tocol = fromcol + 1; 2784 } 2785 } 2786 if (VIsual_mode != 'V' && lnum == bot->lnum) 2787 { 2788 if (*p_sel == 'e' && bot->col == 0 2789 #ifdef FEAT_VIRTUALEDIT 2790 && bot->coladd == 0 2791 #endif 2792 ) 2793 { 2794 fromcol = -10; 2795 tocol = MAXCOL; 2796 } 2797 else if (bot->col == MAXCOL) 2798 tocol = MAXCOL; 2799 else 2800 { 2801 pos = *bot; 2802 if (*p_sel == 'e') 2803 getvvcol(wp, &pos, (colnr_T *)&tocol, NULL, NULL); 2804 else 2805 { 2806 getvvcol(wp, &pos, NULL, NULL, (colnr_T *)&tocol); 2807 ++tocol; 2808 } 2809 } 2810 } 2811 } 2812 2813 #ifndef MSDOS 2814 /* Check if the character under the cursor should not be inverted */ 2815 if (!highlight_match && lnum == curwin->w_cursor.lnum && wp == curwin 2816 # ifdef FEAT_GUI 2817 && !gui.in_use 2818 # endif 2819 ) 2820 noinvcur = TRUE; 2821 #endif 2822 2823 /* if inverting in this line set area_highlighting */ 2824 if (fromcol >= 0) 2825 { 2826 area_highlighting = TRUE; 2827 attr = hl_attr(HLF_V); 2828 #if defined(FEAT_CLIPBOARD) && defined(FEAT_X11) 2829 if (clip_star.available && !clip_star.owned && clip_isautosel()) 2830 attr = hl_attr(HLF_VNC); 2831 #endif 2832 } 2833 } 2834 2835 /* 2836 * handle 'incsearch' and ":s///c" highlighting 2837 */ 2838 else 2839 #endif /* FEAT_VISUAL */ 2840 if (highlight_match 2841 && wp == curwin 2842 && lnum >= curwin->w_cursor.lnum 2843 && lnum <= curwin->w_cursor.lnum + search_match_lines) 2844 { 2845 if (lnum == curwin->w_cursor.lnum) 2846 getvcol(curwin, &(curwin->w_cursor), 2847 (colnr_T *)&fromcol, NULL, NULL); 2848 else 2849 fromcol = 0; 2850 if (lnum == curwin->w_cursor.lnum + search_match_lines) 2851 { 2852 pos.lnum = lnum; 2853 pos.col = search_match_endcol; 2854 getvcol(curwin, &pos, (colnr_T *)&tocol, NULL, NULL); 2855 } 2856 else 2857 tocol = MAXCOL; 2858 if (fromcol == tocol) /* do at least one character */ 2859 tocol = fromcol + 1; /* happens when past end of line */ 2860 area_highlighting = TRUE; 2861 attr = hl_attr(HLF_I); 2862 } 2863 2864 #ifdef FEAT_DIFF 2865 filler_lines = diff_check(wp, lnum); 2866 if (filler_lines < 0) 2867 { 2868 if (filler_lines == -1) 2869 { 2870 if (diff_find_change(wp, lnum, &change_start, &change_end)) 2871 diff_hlf = HLF_ADD; /* added line */ 2872 else if (change_start == 0) 2873 diff_hlf = HLF_TXD; /* changed text */ 2874 else 2875 diff_hlf = HLF_CHD; /* changed line */ 2876 } 2877 else 2878 diff_hlf = HLF_ADD; /* added line */ 2879 filler_lines = 0; 2880 area_highlighting = TRUE; 2881 } 2882 if (lnum == wp->w_topline) 2883 filler_lines = wp->w_topfill; 2884 filler_todo = filler_lines; 2885 #endif 2886 2887 #ifdef LINE_ATTR 2888 # ifdef FEAT_SIGNS 2889 /* If this line has a sign with line highlighting set line_attr. */ 2890 v = buf_getsigntype(wp->w_buffer, lnum, SIGN_LINEHL); 2891 if (v != 0) 2892 line_attr = sign_get_attr((int)v, TRUE); 2893 # endif 2894 # if defined(FEAT_QUICKFIX) && defined(FEAT_WINDOWS) 2895 /* Highlight the current line in the quickfix window. */ 2896 if (bt_quickfix(wp->w_buffer) && qf_current_entry(wp) == lnum) 2897 line_attr = hl_attr(HLF_L); 2898 # endif 2899 if (line_attr != 0) 2900 area_highlighting = TRUE; 2901 #endif 2902 2903 line = ml_get_buf(wp->w_buffer, lnum, FALSE); 2904 ptr = line; 2905 2906 #ifdef FEAT_SPELL 2907 if (has_spell) 2908 { 2909 /* For checking first word with a capital skip white space. */ 2910 if (cap_col == 0) 2911 cap_col = (int)(skipwhite(line) - line); 2912 2913 /* To be able to spell-check over line boundaries copy the end of the 2914 * current line into nextline[]. Above the start of the next line was 2915 * copied to nextline[SPWORDLEN]. */ 2916 if (nextline[SPWORDLEN] == NUL) 2917 { 2918 /* No next line or it is empty. */ 2919 nextlinecol = MAXCOL; 2920 nextline_idx = 0; 2921 } 2922 else 2923 { 2924 v = (long)STRLEN(line); 2925 if (v < SPWORDLEN) 2926 { 2927 /* Short line, use it completely and append the start of the 2928 * next line. */ 2929 nextlinecol = 0; 2930 mch_memmove(nextline, line, (size_t)v); 2931 mch_memmove(nextline + v, nextline + SPWORDLEN, 2932 STRLEN(nextline + SPWORDLEN) + 1); 2933 nextline_idx = v + 1; 2934 } 2935 else 2936 { 2937 /* Long line, use only the last SPWORDLEN bytes. */ 2938 nextlinecol = v - SPWORDLEN; 2939 mch_memmove(nextline, line + nextlinecol, SPWORDLEN); 2940 nextline_idx = SPWORDLEN + 1; 2941 } 2942 } 2943 } 2944 #endif 2945 2946 /* find start of trailing whitespace */ 2947 if (wp->w_p_list && lcs_trail) 2948 { 2949 trailcol = (colnr_T)STRLEN(ptr); 2950 while (trailcol > (colnr_T)0 && vim_iswhite(ptr[trailcol - 1])) 2951 --trailcol; 2952 trailcol += (colnr_T) (ptr - line); 2953 extra_check = TRUE; 2954 } 2955 2956 /* 2957 * 'nowrap' or 'wrap' and a single line that doesn't fit: Advance to the 2958 * first character to be displayed. 2959 */ 2960 if (wp->w_p_wrap) 2961 v = wp->w_skipcol; 2962 else 2963 v = wp->w_leftcol; 2964 if (v > 0) 2965 { 2966 #ifdef FEAT_MBYTE 2967 char_u *prev_ptr = ptr; 2968 #endif 2969 while (vcol < v && *ptr != NUL) 2970 { 2971 c = win_lbr_chartabsize(wp, ptr, (colnr_T)vcol, NULL); 2972 vcol += c; 2973 #ifdef FEAT_MBYTE 2974 prev_ptr = ptr; 2975 #endif 2976 mb_ptr_adv(ptr); 2977 } 2978 2979 #ifdef FEAT_VIRTUALEDIT 2980 /* When 'virtualedit' is set the end of the line may be before the 2981 * start of the displayed part. */ 2982 if (vcol < v && *ptr == NUL && virtual_active()) 2983 vcol = v; 2984 #endif 2985 2986 /* Handle a character that's not completely on the screen: Put ptr at 2987 * that character but skip the first few screen characters. */ 2988 if (vcol > v) 2989 { 2990 vcol -= c; 2991 #ifdef FEAT_MBYTE 2992 ptr = prev_ptr; 2993 #else 2994 --ptr; 2995 #endif 2996 n_skip = v - vcol; 2997 } 2998 2999 /* 3000 * Adjust for when the inverted text is before the screen, 3001 * and when the start of the inverted text is before the screen. 3002 */ 3003 if (tocol <= vcol) 3004 fromcol = 0; 3005 else if (fromcol >= 0 && fromcol < vcol) 3006 fromcol = vcol; 3007 3008 #ifdef FEAT_LINEBREAK 3009 /* When w_skipcol is non-zero, first line needs 'showbreak' */ 3010 if (wp->w_p_wrap) 3011 need_showbreak = TRUE; 3012 #endif 3013 #ifdef FEAT_SPELL 3014 /* When spell checking a word we need to figure out the start of the 3015 * word and if it's badly spelled or not. */ 3016 if (has_spell) 3017 { 3018 int len; 3019 hlf_T spell_hlf = HLF_COUNT; 3020 3021 pos = wp->w_cursor; 3022 wp->w_cursor.lnum = lnum; 3023 wp->w_cursor.col = (colnr_T)(ptr - line); 3024 len = spell_move_to(wp, FORWARD, TRUE, TRUE, &spell_hlf); 3025 if (len == 0 || (int)wp->w_cursor.col > ptr - line) 3026 { 3027 /* no bad word found at line start, don't check until end of a 3028 * word */ 3029 spell_hlf = HLF_COUNT; 3030 word_end = (int)(spell_to_word_end(ptr, wp->w_buffer) - line + 1); 3031 } 3032 else 3033 { 3034 /* bad word found, use attributes until end of word */ 3035 word_end = wp->w_cursor.col + len + 1; 3036 3037 /* Turn index into actual attributes. */ 3038 if (spell_hlf != HLF_COUNT) 3039 spell_attr = highlight_attr[spell_hlf]; 3040 } 3041 wp->w_cursor = pos; 3042 3043 # ifdef FEAT_SYN_HL 3044 /* Need to restart syntax highlighting for this line. */ 3045 if (has_syntax) 3046 syntax_start(wp, lnum); 3047 # endif 3048 } 3049 #endif 3050 } 3051 3052 /* 3053 * Correct highlighting for cursor that can't be disabled. 3054 * Avoids having to check this for each character. 3055 */ 3056 if (fromcol >= 0) 3057 { 3058 if (noinvcur) 3059 { 3060 if ((colnr_T)fromcol == wp->w_virtcol) 3061 { 3062 /* highlighting starts at cursor, let it start just after the 3063 * cursor */ 3064 fromcol_prev = fromcol; 3065 fromcol = -1; 3066 } 3067 else if ((colnr_T)fromcol < wp->w_virtcol) 3068 /* restart highlighting after the cursor */ 3069 fromcol_prev = wp->w_virtcol; 3070 } 3071 if (fromcol >= tocol) 3072 fromcol = -1; 3073 } 3074 3075 #ifdef FEAT_SEARCH_EXTRA 3076 /* 3077 * Handle highlighting the last used search pattern and ":match". 3078 * Do this for both search_hl and match_hl[3]. 3079 */ 3080 for (i = 3; i >= 0; --i) 3081 { 3082 shl = (i == 3) ? &search_hl : &match_hl[i]; 3083 shl->startcol = MAXCOL; 3084 shl->endcol = MAXCOL; 3085 shl->attr_cur = 0; 3086 if (shl->rm.regprog != NULL) 3087 { 3088 v = (long)(ptr - line); 3089 next_search_hl(wp, shl, lnum, (colnr_T)v); 3090 3091 /* Need to get the line again, a multi-line regexp may have made it 3092 * invalid. */ 3093 line = ml_get_buf(wp->w_buffer, lnum, FALSE); 3094 ptr = line + v; 3095 3096 if (shl->lnum != 0 && shl->lnum <= lnum) 3097 { 3098 if (shl->lnum == lnum) 3099 shl->startcol = shl->rm.startpos[0].col; 3100 else 3101 shl->startcol = 0; 3102 if (lnum == shl->lnum + shl->rm.endpos[0].lnum 3103 - shl->rm.startpos[0].lnum) 3104 shl->endcol = shl->rm.endpos[0].col; 3105 else 3106 shl->endcol = MAXCOL; 3107 /* Highlight one character for an empty match. */ 3108 if (shl->startcol == shl->endcol) 3109 { 3110 #ifdef FEAT_MBYTE 3111 if (has_mbyte && line[shl->endcol] != NUL) 3112 shl->endcol += (*mb_ptr2len)(line + shl->endcol); 3113 else 3114 #endif 3115 ++shl->endcol; 3116 } 3117 if ((long)shl->startcol < v) /* match at leftcol */ 3118 { 3119 shl->attr_cur = shl->attr; 3120 search_attr = shl->attr; 3121 } 3122 area_highlighting = TRUE; 3123 } 3124 } 3125 } 3126 #endif 3127 3128 #ifdef FEAT_SYN_HL 3129 /* Cursor line highlighting for 'cursorline'. Not when Visual mode is 3130 * active, because it's not clear what is selected then. */ 3131 if (wp->w_p_cul && lnum == wp->w_cursor.lnum && !VIsual_active) 3132 { 3133 line_attr = hl_attr(HLF_CUL); 3134 area_highlighting = TRUE; 3135 } 3136 #endif 3137 3138 off = (unsigned)(current_ScreenLine - ScreenLines); 3139 col = 0; 3140 #ifdef FEAT_RIGHTLEFT 3141 if (wp->w_p_rl) 3142 { 3143 /* Rightleft window: process the text in the normal direction, but put 3144 * it in current_ScreenLine[] from right to left. Start at the 3145 * rightmost column of the window. */ 3146 col = W_WIDTH(wp) - 1; 3147 off += col; 3148 } 3149 #endif 3150 3151 /* 3152 * Repeat for the whole displayed line. 3153 */ 3154 for (;;) 3155 { 3156 /* Skip this quickly when working on the text. */ 3157 if (draw_state != WL_LINE) 3158 { 3159 #ifdef FEAT_CMDWIN 3160 if (draw_state == WL_CMDLINE - 1 && n_extra == 0) 3161 { 3162 draw_state = WL_CMDLINE; 3163 if (cmdwin_type != 0 && wp == curwin) 3164 { 3165 /* Draw the cmdline character. */ 3166 *extra = cmdwin_type; 3167 n_extra = 1; 3168 p_extra = extra; 3169 c_extra = NUL; 3170 char_attr = hl_attr(HLF_AT); 3171 } 3172 } 3173 #endif 3174 3175 #ifdef FEAT_FOLDING 3176 if (draw_state == WL_FOLD - 1 && n_extra == 0) 3177 { 3178 draw_state = WL_FOLD; 3179 if (wp->w_p_fdc > 0) 3180 { 3181 /* Draw the 'foldcolumn'. */ 3182 fill_foldcolumn(extra, wp, FALSE, lnum); 3183 n_extra = wp->w_p_fdc; 3184 p_extra = extra; 3185 c_extra = NUL; 3186 char_attr = hl_attr(HLF_FC); 3187 } 3188 } 3189 #endif 3190 3191 #ifdef FEAT_SIGNS 3192 if (draw_state == WL_SIGN - 1 && n_extra == 0) 3193 { 3194 draw_state = WL_SIGN; 3195 /* Show the sign column when there are any signs in this 3196 * buffer or when using Netbeans. */ 3197 if (draw_signcolumn(wp) 3198 # ifdef FEAT_DIFF 3199 && filler_todo <= 0 3200 # endif 3201 ) 3202 { 3203 int_u text_sign; 3204 # ifdef FEAT_SIGN_ICONS 3205 int_u icon_sign; 3206 # endif 3207 3208 /* Draw two cells with the sign value or blank. */ 3209 c_extra = ' '; 3210 char_attr = hl_attr(HLF_SC); 3211 n_extra = 2; 3212 3213 if (row == startrow) 3214 { 3215 text_sign = buf_getsigntype(wp->w_buffer, lnum, 3216 SIGN_TEXT); 3217 # ifdef FEAT_SIGN_ICONS 3218 icon_sign = buf_getsigntype(wp->w_buffer, lnum, 3219 SIGN_ICON); 3220 if (gui.in_use && icon_sign != 0) 3221 { 3222 /* Use the image in this position. */ 3223 c_extra = SIGN_BYTE; 3224 # ifdef FEAT_NETBEANS_INTG 3225 if (buf_signcount(wp->w_buffer, lnum) > 1) 3226 c_extra = MULTISIGN_BYTE; 3227 # endif 3228 char_attr = icon_sign; 3229 } 3230 else 3231 # endif 3232 if (text_sign != 0) 3233 { 3234 p_extra = sign_get_text(text_sign); 3235 if (p_extra != NULL) 3236 { 3237 c_extra = NUL; 3238 n_extra = (int)STRLEN(p_extra); 3239 } 3240 char_attr = sign_get_attr(text_sign, FALSE); 3241 } 3242 } 3243 } 3244 } 3245 #endif 3246 3247 if (draw_state == WL_NR - 1 && n_extra == 0) 3248 { 3249 draw_state = WL_NR; 3250 /* Display the line number. After the first fill with blanks 3251 * when the 'n' flag isn't in 'cpo' */ 3252 if (wp->w_p_nu 3253 && (row == startrow 3254 #ifdef FEAT_DIFF 3255 + filler_lines 3256 #endif 3257 || vim_strchr(p_cpo, CPO_NUMCOL) == NULL)) 3258 { 3259 /* Draw the line number (empty space after wrapping). */ 3260 if (row == startrow 3261 #ifdef FEAT_DIFF 3262 + filler_lines 3263 #endif 3264 ) 3265 { 3266 sprintf((char *)extra, "%*ld ", 3267 number_width(wp), (long)lnum); 3268 if (wp->w_skipcol > 0) 3269 for (p_extra = extra; *p_extra == ' '; ++p_extra) 3270 *p_extra = '-'; 3271 #ifdef FEAT_RIGHTLEFT 3272 if (wp->w_p_rl) /* reverse line numbers */ 3273 rl_mirror(extra); 3274 #endif 3275 p_extra = extra; 3276 c_extra = NUL; 3277 } 3278 else 3279 c_extra = ' '; 3280 n_extra = number_width(wp) + 1; 3281 char_attr = hl_attr(HLF_N); 3282 #ifdef FEAT_SYN_HL 3283 /* When 'cursorline' is set highlight the line number of 3284 * the current line differently. */ 3285 if (wp->w_p_cul && lnum == wp->w_cursor.lnum) 3286 char_attr = hl_combine_attr(hl_attr(HLF_CUL), char_attr); 3287 #endif 3288 } 3289 } 3290 3291 #if defined(FEAT_LINEBREAK) || defined(FEAT_DIFF) 3292 if (draw_state == WL_SBR - 1 && n_extra == 0) 3293 { 3294 draw_state = WL_SBR; 3295 # ifdef FEAT_DIFF 3296 if (filler_todo > 0) 3297 { 3298 /* Draw "deleted" diff line(s). */ 3299 if (char2cells(fill_diff) > 1) 3300 c_extra = '-'; 3301 else 3302 c_extra = fill_diff; 3303 # ifdef FEAT_RIGHTLEFT 3304 if (wp->w_p_rl) 3305 n_extra = col + 1; 3306 else 3307 # endif 3308 n_extra = W_WIDTH(wp) - col; 3309 char_attr = hl_attr(HLF_DED); 3310 } 3311 # endif 3312 # ifdef FEAT_LINEBREAK 3313 if (*p_sbr != NUL && need_showbreak) 3314 { 3315 /* Draw 'showbreak' at the start of each broken line. */ 3316 p_extra = p_sbr; 3317 c_extra = NUL; 3318 n_extra = (int)STRLEN(p_sbr); 3319 char_attr = hl_attr(HLF_AT); 3320 need_showbreak = FALSE; 3321 /* Correct end of highlighted area for 'showbreak', 3322 * required when 'linebreak' is also set. */ 3323 if (tocol == vcol) 3324 tocol += n_extra; 3325 } 3326 # endif 3327 } 3328 #endif 3329 3330 if (draw_state == WL_LINE - 1 && n_extra == 0) 3331 { 3332 draw_state = WL_LINE; 3333 if (saved_n_extra) 3334 { 3335 /* Continue item from end of wrapped line. */ 3336 n_extra = saved_n_extra; 3337 c_extra = saved_c_extra; 3338 p_extra = saved_p_extra; 3339 char_attr = saved_char_attr; 3340 } 3341 else 3342 char_attr = 0; 3343 } 3344 } 3345 3346 /* When still displaying '$' of change command, stop at cursor */ 3347 if (dollar_vcol != 0 && wp == curwin 3348 && lnum == wp->w_cursor.lnum && vcol >= (long)wp->w_virtcol 3349 #ifdef FEAT_DIFF 3350 && filler_todo <= 0 3351 #endif 3352 ) 3353 { 3354 SCREEN_LINE(screen_row, W_WINCOL(wp), col, -(int)W_WIDTH(wp), 3355 wp->w_p_rl); 3356 /* Pretend we have finished updating the window. Except when 3357 * 'cursorcolumn' is set. */ 3358 #ifdef FEAT_SYN_HL 3359 if (wp->w_p_cuc) 3360 row = wp->w_cline_row + wp->w_cline_height; 3361 else 3362 #endif 3363 row = wp->w_height; 3364 break; 3365 } 3366 3367 if (draw_state == WL_LINE && area_highlighting) 3368 { 3369 /* handle Visual or match highlighting in this line */ 3370 if (vcol == fromcol 3371 #ifdef FEAT_MBYTE 3372 || (has_mbyte && vcol + 1 == fromcol && n_extra == 0 3373 && (*mb_ptr2cells)(ptr) > 1) 3374 #endif 3375 || ((int)vcol_prev == fromcol_prev 3376 && vcol < tocol)) 3377 area_attr = attr; /* start highlighting */ 3378 else if (area_attr != 0 3379 && (vcol == tocol 3380 || (noinvcur && (colnr_T)vcol == wp->w_virtcol))) 3381 area_attr = 0; /* stop highlighting */ 3382 3383 #ifdef FEAT_SEARCH_EXTRA 3384 if (!n_extra) 3385 { 3386 /* 3387 * Check for start/end of search pattern match. 3388 * After end, check for start/end of next match. 3389 * When another match, have to check for start again. 3390 * Watch out for matching an empty string! 3391 * Do this first for search_hl, then for match_hl, so that 3392 * ":match" overrules 'hlsearch'. 3393 */ 3394 v = (long)(ptr - line); 3395 for (i = 3; i >= 0; --i) 3396 { 3397 shl = (i == 3) ? &search_hl : &match_hl[i]; 3398 while (shl->rm.regprog != NULL) 3399 { 3400 if (shl->startcol != MAXCOL 3401 && v >= (long)shl->startcol 3402 && v < (long)shl->endcol) 3403 { 3404 shl->attr_cur = shl->attr; 3405 } 3406 else if (v == (long)shl->endcol) 3407 { 3408 shl->attr_cur = 0; 3409 3410 next_search_hl(wp, shl, lnum, (colnr_T)v); 3411 3412 /* Need to get the line again, a multi-line regexp 3413 * may have made it invalid. */ 3414 line = ml_get_buf(wp->w_buffer, lnum, FALSE); 3415 ptr = line + v; 3416 3417 if (shl->lnum == lnum) 3418 { 3419 shl->startcol = shl->rm.startpos[0].col; 3420 if (shl->rm.endpos[0].lnum == 0) 3421 shl->endcol = shl->rm.endpos[0].col; 3422 else 3423 shl->endcol = MAXCOL; 3424 3425 if (shl->startcol == shl->endcol) 3426 { 3427 /* highlight empty match, try again after 3428 * it */ 3429 #ifdef FEAT_MBYTE 3430 if (has_mbyte) 3431 shl->endcol += (*mb_ptr2len)(line 3432 + shl->endcol); 3433 else 3434 #endif 3435 ++shl->endcol; 3436 } 3437 3438 /* Loop to check if the match starts at the 3439 * current position */ 3440 continue; 3441 } 3442 } 3443 break; 3444 } 3445 } 3446 3447 /* ":match" highlighting overrules 'hlsearch' */ 3448 for (i = 0; i <= 3; ++i) 3449 if (i == 3) 3450 search_attr = search_hl.attr_cur; 3451 else if (match_hl[i].attr_cur != 0) 3452 { 3453 search_attr = match_hl[i].attr_cur; 3454 break; 3455 } 3456 } 3457 #endif 3458 3459 #ifdef FEAT_DIFF 3460 if (diff_hlf != (hlf_T)0) 3461 { 3462 if (diff_hlf == HLF_CHD && ptr - line >= change_start) 3463 diff_hlf = HLF_TXD; /* changed text */ 3464 if (diff_hlf == HLF_TXD && ptr - line > change_end) 3465 diff_hlf = HLF_CHD; /* changed line */ 3466 line_attr = hl_attr(diff_hlf); 3467 } 3468 #endif 3469 3470 /* Decide which of the highlight attributes to use. */ 3471 attr_pri = TRUE; 3472 if (area_attr != 0) 3473 char_attr = area_attr; 3474 else if (search_attr != 0) 3475 char_attr = search_attr; 3476 #ifdef LINE_ATTR 3477 /* Use line_attr when not in the Visual or 'incsearch' area 3478 * (area_attr may be 0 when "noinvcur" is set). */ 3479 else if (line_attr != 0 && ((fromcol == -10 && tocol == MAXCOL) 3480 || (vcol < fromcol || vcol >= tocol))) 3481 char_attr = line_attr; 3482 #endif 3483 else 3484 { 3485 attr_pri = FALSE; 3486 #ifdef FEAT_SYN_HL 3487 if (has_syntax) 3488 char_attr = syntax_attr; 3489 else 3490 #endif 3491 char_attr = 0; 3492 } 3493 } 3494 3495 /* 3496 * Get the next character to put on the screen. 3497 */ 3498 /* 3499 * The 'extra' array contains the extra stuff that is inserted to 3500 * represent special characters (non-printable stuff). When all 3501 * characters are the same, c_extra is used. 3502 * For the '$' of the 'list' option, n_extra == 1, p_extra == "". 3503 */ 3504 if (n_extra > 0) 3505 { 3506 if (c_extra != NUL) 3507 { 3508 c = c_extra; 3509 #ifdef FEAT_MBYTE 3510 mb_c = c; /* doesn't handle non-utf-8 multi-byte! */ 3511 if (enc_utf8 && (*mb_char2len)(c) > 1) 3512 { 3513 mb_utf8 = TRUE; 3514 u8cc[0] = 0; 3515 c = 0xc0; 3516 } 3517 else 3518 mb_utf8 = FALSE; 3519 #endif 3520 } 3521 else 3522 { 3523 c = *p_extra; 3524 #ifdef FEAT_MBYTE 3525 if (has_mbyte) 3526 { 3527 mb_c = c; 3528 if (enc_utf8) 3529 { 3530 /* If the UTF-8 character is more than one byte: 3531 * Decode it into "mb_c". */ 3532 mb_l = (*mb_ptr2len)(p_extra); 3533 mb_utf8 = FALSE; 3534 if (mb_l > n_extra) 3535 mb_l = 1; 3536 else if (mb_l > 1) 3537 { 3538 mb_c = utfc_ptr2char(p_extra, u8cc); 3539 mb_utf8 = TRUE; 3540 c = 0xc0; 3541 } 3542 } 3543 else 3544 { 3545 /* if this is a DBCS character, put it in "mb_c" */ 3546 mb_l = MB_BYTE2LEN(c); 3547 if (mb_l >= n_extra) 3548 mb_l = 1; 3549 else if (mb_l > 1) 3550 mb_c = (c << 8) + p_extra[1]; 3551 } 3552 if (mb_l == 0) /* at the NUL at end-of-line */ 3553 mb_l = 1; 3554 3555 /* If a double-width char doesn't fit display a '>' in the 3556 * last column. */ 3557 if (( 3558 # ifdef FEAT_RIGHTLEFT 3559 wp->w_p_rl ? (col <= 0) : 3560 # endif 3561 (col >= W_WIDTH(wp) - 1)) 3562 && (*mb_char2cells)(mb_c) == 2) 3563 { 3564 c = '>'; 3565 mb_c = c; 3566 mb_l = 1; 3567 mb_utf8 = FALSE; 3568 multi_attr = hl_attr(HLF_AT); 3569 /* put the pointer back to output the double-width 3570 * character at the start of the next line. */ 3571 ++n_extra; 3572 --p_extra; 3573 } 3574 else 3575 { 3576 n_extra -= mb_l - 1; 3577 p_extra += mb_l - 1; 3578 } 3579 } 3580 #endif 3581 ++p_extra; 3582 } 3583 --n_extra; 3584 } 3585 else 3586 { 3587 /* 3588 * Get a character from the line itself. 3589 */ 3590 c = *ptr; 3591 #ifdef FEAT_MBYTE 3592 if (has_mbyte) 3593 { 3594 mb_c = c; 3595 if (enc_utf8) 3596 { 3597 /* If the UTF-8 character is more than one byte: Decode it 3598 * into "mb_c". */ 3599 mb_l = (*mb_ptr2len)(ptr); 3600 mb_utf8 = FALSE; 3601 if (mb_l > 1) 3602 { 3603 mb_c = utfc_ptr2char(ptr, u8cc); 3604 /* Overlong encoded ASCII or ASCII with composing char 3605 * is displayed normally, except a NUL. */ 3606 if (mb_c < 0x80) 3607 c = mb_c; 3608 mb_utf8 = TRUE; 3609 3610 /* At start of the line we can have a composing char. 3611 * Draw it as a space with a composing char. */ 3612 if (utf_iscomposing(mb_c)) 3613 { 3614 for (i = Screen_mco - 1; i > 0; --i) 3615 u8cc[i] = u8cc[i - 1]; 3616 u8cc[0] = mb_c; 3617 mb_c = ' '; 3618 } 3619 } 3620 3621 if ((mb_l == 1 && c >= 0x80) 3622 || (mb_l >= 1 && mb_c == 0) 3623 || (mb_l > 1 && (!vim_isprintc(mb_c) 3624 || mb_c >= 0x10000))) 3625 { 3626 /* 3627 * Illegal UTF-8 byte: display as <xx>. 3628 * Non-BMP character : display as ? or fullwidth ?. 3629 */ 3630 if (mb_c < 0x10000) 3631 { 3632 transchar_hex(extra, mb_c); 3633 # ifdef FEAT_RIGHTLEFT 3634 if (wp->w_p_rl) /* reverse */ 3635 rl_mirror(extra); 3636 # endif 3637 } 3638 else if (utf_char2cells(mb_c) != 2) 3639 STRCPY(extra, "?"); 3640 else 3641 /* 0xff1f in UTF-8: full-width '?' */ 3642 STRCPY(extra, "\357\274\237"); 3643 3644 p_extra = extra; 3645 c = *p_extra; 3646 mb_c = mb_ptr2char_adv(&p_extra); 3647 mb_utf8 = (c >= 0x80); 3648 n_extra = (int)STRLEN(p_extra); 3649 c_extra = NUL; 3650 if (area_attr == 0 && search_attr == 0) 3651 { 3652 n_attr = n_extra + 1; 3653 extra_attr = hl_attr(HLF_8); 3654 saved_attr2 = char_attr; /* save current attr */ 3655 } 3656 } 3657 else if (mb_l == 0) /* at the NUL at end-of-line */ 3658 mb_l = 1; 3659 #ifdef FEAT_ARABIC 3660 else if (p_arshape && !p_tbidi && ARABIC_CHAR(mb_c)) 3661 { 3662 /* Do Arabic shaping. */ 3663 int pc, pc1, nc; 3664 int pcc[MAX_MCO]; 3665 3666 /* The idea of what is the previous and next 3667 * character depends on 'rightleft'. */ 3668 if (wp->w_p_rl) 3669 { 3670 pc = prev_c; 3671 pc1 = prev_c1; 3672 nc = utf_ptr2char(ptr + mb_l); 3673 prev_c1 = u8cc[0]; 3674 } 3675 else 3676 { 3677 pc = utfc_ptr2char(ptr + mb_l, pcc); 3678 nc = prev_c; 3679 pc1 = pcc[0]; 3680 } 3681 prev_c = mb_c; 3682 3683 mb_c = arabic_shape(mb_c, &c, &u8cc[0], pc, pc1, nc); 3684 } 3685 else 3686 prev_c = mb_c; 3687 #endif 3688 } 3689 else /* enc_dbcs */ 3690 { 3691 mb_l = MB_BYTE2LEN(c); 3692 if (mb_l == 0) /* at the NUL at end-of-line */ 3693 mb_l = 1; 3694 else if (mb_l > 1) 3695 { 3696 /* We assume a second byte below 32 is illegal. 3697 * Hopefully this is OK for all double-byte encodings! 3698 */ 3699 if (ptr[1] >= 32) 3700 mb_c = (c << 8) + ptr[1]; 3701 else 3702 { 3703 if (ptr[1] == NUL) 3704 { 3705 /* head byte at end of line */ 3706 mb_l = 1; 3707 transchar_nonprint(extra, c); 3708 } 3709 else 3710 { 3711 /* illegal tail byte */ 3712 mb_l = 2; 3713 STRCPY(extra, "XX"); 3714 } 3715 p_extra = extra; 3716 n_extra = (int)STRLEN(extra) - 1; 3717 c_extra = NUL; 3718 c = *p_extra++; 3719 if (area_attr == 0 && search_attr == 0) 3720 { 3721 n_attr = n_extra + 1; 3722 extra_attr = hl_attr(HLF_8); 3723 saved_attr2 = char_attr; /* save current attr */ 3724 } 3725 mb_c = c; 3726 } 3727 } 3728 } 3729 /* If a double-width char doesn't fit display a '>' in the 3730 * last column; the character is displayed at the start of the 3731 * next line. */ 3732 if (( 3733 # ifdef FEAT_RIGHTLEFT 3734 wp->w_p_rl ? (col <= 0) : 3735 # endif 3736 (col >= W_WIDTH(wp) - 1)) 3737 && (*mb_char2cells)(mb_c) == 2) 3738 { 3739 c = '>'; 3740 mb_c = c; 3741 mb_utf8 = FALSE; 3742 mb_l = 1; 3743 multi_attr = hl_attr(HLF_AT); 3744 /* Put pointer back so that the character will be 3745 * displayed at the start of the next line. */ 3746 --ptr; 3747 } 3748 else if (*ptr != NUL) 3749 ptr += mb_l - 1; 3750 3751 /* If a double-width char doesn't fit at the left side display 3752 * a '<' in the first column. */ 3753 if (n_skip > 0 && mb_l > 1) 3754 { 3755 extra[0] = '<'; 3756 p_extra = extra; 3757 n_extra = 1; 3758 c_extra = NUL; 3759 c = ' '; 3760 if (area_attr == 0 && search_attr == 0) 3761 { 3762 n_attr = n_extra + 1; 3763 extra_attr = hl_attr(HLF_AT); 3764 saved_attr2 = char_attr; /* save current attr */ 3765 } 3766 mb_c = c; 3767 mb_utf8 = FALSE; 3768 mb_l = 1; 3769 } 3770 3771 } 3772 #endif 3773 ++ptr; 3774 3775 /* 'list' : change char 160 to lcs_nbsp. */ 3776 if (wp->w_p_list && (c == 160 3777 #ifdef FEAT_MBYTE 3778 || (mb_utf8 && mb_c == 160) 3779 #endif 3780 ) && lcs_nbsp) 3781 { 3782 c = lcs_nbsp; 3783 if (area_attr == 0 && search_attr == 0) 3784 { 3785 n_attr = 1; 3786 extra_attr = hl_attr(HLF_8); 3787 saved_attr2 = char_attr; /* save current attr */ 3788 } 3789 #ifdef FEAT_MBYTE 3790 mb_c = c; 3791 if (enc_utf8 && (*mb_char2len)(c) > 1) 3792 { 3793 mb_utf8 = TRUE; 3794 u8cc[0] = 0; 3795 c = 0xc0; 3796 } 3797 else 3798 mb_utf8 = FALSE; 3799 #endif 3800 } 3801 3802 if (extra_check) 3803 { 3804 #ifdef FEAT_SPELL 3805 int can_spell = TRUE; 3806 #endif 3807 3808 #ifdef FEAT_SYN_HL 3809 /* Get syntax attribute, unless still at the start of the line 3810 * (double-wide char that doesn't fit). */ 3811 v = (long)(ptr - line); 3812 if (has_syntax && v > 0) 3813 { 3814 /* Get the syntax attribute for the character. If there 3815 * is an error, disable syntax highlighting. */ 3816 save_did_emsg = did_emsg; 3817 did_emsg = FALSE; 3818 3819 syntax_attr = get_syntax_attr((colnr_T)v - 1, 3820 # ifdef FEAT_SPELL 3821 has_spell ? &can_spell : 3822 # endif 3823 NULL); 3824 3825 if (did_emsg) 3826 { 3827 wp->w_buffer->b_syn_error = TRUE; 3828 has_syntax = FALSE; 3829 } 3830 else 3831 did_emsg = save_did_emsg; 3832 3833 /* Need to get the line again, a multi-line regexp may 3834 * have made it invalid. */ 3835 line = ml_get_buf(wp->w_buffer, lnum, FALSE); 3836 ptr = line + v; 3837 3838 if (!attr_pri) 3839 char_attr = syntax_attr; 3840 else 3841 char_attr = hl_combine_attr(syntax_attr, char_attr); 3842 } 3843 #endif 3844 3845 #ifdef FEAT_SPELL 3846 /* Check spelling (unless at the end of the line). 3847 * Only do this when there is no syntax highlighting, the 3848 * @Spell cluster is not used or the current syntax item 3849 * contains the @Spell cluster. */ 3850 if (has_spell && v >= word_end && v > cur_checked_col) 3851 { 3852 spell_attr = 0; 3853 # ifdef FEAT_SYN_HL 3854 if (!attr_pri) 3855 char_attr = syntax_attr; 3856 # endif 3857 if (c != 0 && ( 3858 # ifdef FEAT_SYN_HL 3859 !has_syntax || 3860 # endif 3861 can_spell)) 3862 { 3863 char_u *prev_ptr, *p; 3864 int len; 3865 hlf_T spell_hlf = HLF_COUNT; 3866 # ifdef FEAT_MBYTE 3867 if (has_mbyte) 3868 { 3869 prev_ptr = ptr - mb_l; 3870 v -= mb_l - 1; 3871 } 3872 else 3873 # endif 3874 prev_ptr = ptr - 1; 3875 3876 /* Use nextline[] if possible, it has the start of the 3877 * next line concatenated. */ 3878 if ((prev_ptr - line) - nextlinecol >= 0) 3879 p = nextline + (prev_ptr - line) - nextlinecol; 3880 else 3881 p = prev_ptr; 3882 cap_col -= (int)(prev_ptr - line); 3883 len = spell_check(wp, p, &spell_hlf, &cap_col, 3884 nochange); 3885 word_end = v + len; 3886 3887 /* In Insert mode only highlight a word that 3888 * doesn't touch the cursor. */ 3889 if (spell_hlf != HLF_COUNT 3890 && (State & INSERT) != 0 3891 && wp->w_cursor.lnum == lnum 3892 && wp->w_cursor.col >= 3893 (colnr_T)(prev_ptr - line) 3894 && wp->w_cursor.col < (colnr_T)word_end) 3895 { 3896 spell_hlf = HLF_COUNT; 3897 spell_redraw_lnum = lnum; 3898 } 3899 3900 if (spell_hlf == HLF_COUNT && p != prev_ptr 3901 && (p - nextline) + len > nextline_idx) 3902 { 3903 /* Remember that the good word continues at the 3904 * start of the next line. */ 3905 checked_lnum = lnum + 1; 3906 checked_col = (int)((p - nextline) + len - nextline_idx); 3907 } 3908 3909 /* Turn index into actual attributes. */ 3910 if (spell_hlf != HLF_COUNT) 3911 spell_attr = highlight_attr[spell_hlf]; 3912 3913 if (cap_col > 0) 3914 { 3915 if (p != prev_ptr 3916 && (p - nextline) + cap_col >= nextline_idx) 3917 { 3918 /* Remember that the word in the next line 3919 * must start with a capital. */ 3920 capcol_lnum = lnum + 1; 3921 cap_col = (int)((p - nextline) + cap_col 3922 - nextline_idx); 3923 } 3924 else 3925 /* Compute the actual column. */ 3926 cap_col += (int)(prev_ptr - line); 3927 } 3928 } 3929 } 3930 if (spell_attr != 0) 3931 { 3932 if (!attr_pri) 3933 char_attr = hl_combine_attr(char_attr, spell_attr); 3934 else 3935 char_attr = hl_combine_attr(spell_attr, char_attr); 3936 } 3937 #endif 3938 #ifdef FEAT_LINEBREAK 3939 /* 3940 * Found last space before word: check for line break. 3941 */ 3942 if (wp->w_p_lbr && vim_isbreak(c) && !vim_isbreak(*ptr) 3943 && !wp->w_p_list) 3944 { 3945 n_extra = win_lbr_chartabsize(wp, ptr - ( 3946 # ifdef FEAT_MBYTE 3947 has_mbyte ? mb_l : 3948 # endif 3949 1), (colnr_T)vcol, NULL) - 1; 3950 c_extra = ' '; 3951 if (vim_iswhite(c)) 3952 c = ' '; 3953 } 3954 #endif 3955 3956 if (trailcol != MAXCOL && ptr > line + trailcol && c == ' ') 3957 { 3958 c = lcs_trail; 3959 if (!attr_pri) 3960 { 3961 n_attr = 1; 3962 extra_attr = hl_attr(HLF_8); 3963 saved_attr2 = char_attr; /* save current attr */ 3964 } 3965 #ifdef FEAT_MBYTE 3966 mb_c = c; 3967 if (enc_utf8 && (*mb_char2len)(c) > 1) 3968 { 3969 mb_utf8 = TRUE; 3970 u8cc[0] = 0; 3971 c = 0xc0; 3972 } 3973 else 3974 mb_utf8 = FALSE; 3975 #endif 3976 } 3977 } 3978 3979 /* 3980 * Handling of non-printable characters. 3981 */ 3982 if (!(chartab[c & 0xff] & CT_PRINT_CHAR)) 3983 { 3984 /* 3985 * when getting a character from the file, we may have to 3986 * turn it into something else on the way to putting it 3987 * into "ScreenLines". 3988 */ 3989 if (c == TAB && (!wp->w_p_list || lcs_tab1)) 3990 { 3991 /* tab amount depends on current column */ 3992 n_extra = (int)wp->w_buffer->b_p_ts 3993 - vcol % (int)wp->w_buffer->b_p_ts - 1; 3994 #ifdef FEAT_MBYTE 3995 mb_utf8 = FALSE; /* don't draw as UTF-8 */ 3996 #endif 3997 if (wp->w_p_list) 3998 { 3999 c = lcs_tab1; 4000 c_extra = lcs_tab2; 4001 n_attr = n_extra + 1; 4002 extra_attr = hl_attr(HLF_8); 4003 saved_attr2 = char_attr; /* save current attr */ 4004 #ifdef FEAT_MBYTE 4005 mb_c = c; 4006 if (enc_utf8 && (*mb_char2len)(c) > 1) 4007 { 4008 mb_utf8 = TRUE; 4009 u8cc[0] = 0; 4010 c = 0xc0; 4011 } 4012 #endif 4013 } 4014 else 4015 { 4016 c_extra = ' '; 4017 c = ' '; 4018 } 4019 } 4020 else if (c == NUL 4021 && ((wp->w_p_list && lcs_eol > 0) 4022 || ((fromcol >= 0 || fromcol_prev >= 0) 4023 && tocol > vcol 4024 #ifdef FEAT_VISUAL 4025 && VIsual_mode != Ctrl_V 4026 #endif 4027 && ( 4028 # ifdef FEAT_RIGHTLEFT 4029 wp->w_p_rl ? (col >= 0) : 4030 # endif 4031 (col < W_WIDTH(wp))) 4032 && !(noinvcur 4033 && (colnr_T)vcol == wp->w_virtcol))) 4034 && lcs_eol_one >= 0) 4035 { 4036 /* Display a '$' after the line or highlight an extra 4037 * character if the line break is included. */ 4038 #if defined(FEAT_DIFF) || defined(LINE_ATTR) 4039 /* For a diff line the highlighting continues after the 4040 * "$". */ 4041 if ( 4042 # ifdef FEAT_DIFF 4043 diff_hlf == (hlf_T)0 4044 # ifdef LINE_ATTR 4045 && 4046 # endif 4047 # endif 4048 # ifdef LINE_ATTR 4049 line_attr == 0 4050 # endif 4051 ) 4052 #endif 4053 { 4054 #ifdef FEAT_VIRTUALEDIT 4055 /* In virtualedit, visual selections may extend 4056 * beyond end of line. */ 4057 if (area_highlighting && virtual_active() 4058 && tocol != MAXCOL && vcol < tocol) 4059 n_extra = 0; 4060 else 4061 #endif 4062 { 4063 p_extra = at_end_str; 4064 n_extra = 1; 4065 c_extra = NUL; 4066 } 4067 } 4068 if (wp->w_p_list) 4069 c = lcs_eol; 4070 else 4071 c = ' '; 4072 lcs_eol_one = -1; 4073 --ptr; /* put it back at the NUL */ 4074 if (!attr_pri) 4075 { 4076 extra_attr = hl_attr(HLF_AT); 4077 n_attr = 1; 4078 } 4079 #ifdef FEAT_MBYTE 4080 mb_c = c; 4081 if (enc_utf8 && (*mb_char2len)(c) > 1) 4082 { 4083 mb_utf8 = TRUE; 4084 u8cc[0] = 0; 4085 c = 0xc0; 4086 } 4087 else 4088 mb_utf8 = FALSE; /* don't draw as UTF-8 */ 4089 #endif 4090 } 4091 else if (c != NUL) 4092 { 4093 p_extra = transchar(c); 4094 #ifdef FEAT_RIGHTLEFT 4095 if ((dy_flags & DY_UHEX) && wp->w_p_rl) 4096 rl_mirror(p_extra); /* reverse "<12>" */ 4097 #endif 4098 n_extra = byte2cells(c) - 1; 4099 c_extra = NUL; 4100 c = *p_extra++; 4101 if (!attr_pri) 4102 { 4103 n_attr = n_extra + 1; 4104 extra_attr = hl_attr(HLF_8); 4105 saved_attr2 = char_attr; /* save current attr */ 4106 } 4107 #ifdef FEAT_MBYTE 4108 mb_utf8 = FALSE; /* don't draw as UTF-8 */ 4109 #endif 4110 } 4111 #ifdef FEAT_VIRTUALEDIT 4112 else if (VIsual_active 4113 && (VIsual_mode == Ctrl_V 4114 || VIsual_mode == 'v') 4115 && virtual_active() 4116 && tocol != MAXCOL 4117 && vcol < tocol 4118 && ( 4119 # ifdef FEAT_RIGHTLEFT 4120 wp->w_p_rl ? (col >= 0) : 4121 # endif 4122 (col < W_WIDTH(wp)))) 4123 { 4124 c = ' '; 4125 --ptr; /* put it back at the NUL */ 4126 } 4127 #endif 4128 #if defined(LINE_ATTR) 4129 else if (( 4130 # ifdef FEAT_DIFF 4131 diff_hlf != (hlf_T)0 || 4132 # endif 4133 line_attr != 0 4134 ) && ( 4135 # ifdef FEAT_RIGHTLEFT 4136 wp->w_p_rl ? (col >= 0) : 4137 # endif 4138 (col < W_WIDTH(wp)))) 4139 { 4140 /* Highlight until the right side of the window */ 4141 c = ' '; 4142 --ptr; /* put it back at the NUL */ 4143 4144 /* Remember we do the char for line highlighting. */ 4145 ++did_line_attr; 4146 4147 /* don't do search HL for the rest of the line */ 4148 if (line_attr != 0 && char_attr == search_attr && col > 0) 4149 char_attr = line_attr; 4150 # ifdef FEAT_DIFF 4151 if (diff_hlf == HLF_TXD) 4152 { 4153 diff_hlf = HLF_CHD; 4154 if (attr == 0 || char_attr != attr) 4155 char_attr = hl_attr(diff_hlf); 4156 } 4157 # endif 4158 } 4159 #endif 4160 } 4161 } 4162 4163 /* Don't override visual selection highlighting. */ 4164 if (n_attr > 0 4165 && draw_state == WL_LINE 4166 && !attr_pri) 4167 char_attr = extra_attr; 4168 4169 #if defined(FEAT_XIM) && defined(FEAT_GUI_GTK) 4170 /* XIM don't send preedit_start and preedit_end, but they send 4171 * preedit_changed and commit. Thus Vim can't set "im_is_active", use 4172 * im_is_preediting() here. */ 4173 if (xic != NULL 4174 && lnum == curwin->w_cursor.lnum 4175 && (State & INSERT) 4176 && !p_imdisable 4177 && im_is_preediting() 4178 && draw_state == WL_LINE) 4179 { 4180 colnr_T tcol; 4181 4182 if (preedit_end_col == MAXCOL) 4183 getvcol(curwin, &(curwin->w_cursor), &tcol, NULL, NULL); 4184 else 4185 tcol = preedit_end_col; 4186 if ((long)preedit_start_col <= vcol && vcol < (long)tcol) 4187 { 4188 if (feedback_old_attr < 0) 4189 { 4190 feedback_col = 0; 4191 feedback_old_attr = char_attr; 4192 } 4193 char_attr = im_get_feedback_attr(feedback_col); 4194 if (char_attr < 0) 4195 char_attr = feedback_old_attr; 4196 feedback_col++; 4197 } 4198 else if (feedback_old_attr >= 0) 4199 { 4200 char_attr = feedback_old_attr; 4201 feedback_old_attr = -1; 4202 feedback_col = 0; 4203 } 4204 } 4205 #endif 4206 /* 4207 * Handle the case where we are in column 0 but not on the first 4208 * character of the line and the user wants us to show us a 4209 * special character (via 'listchars' option "precedes:<char>". 4210 */ 4211 if (lcs_prec_todo != NUL 4212 && (wp->w_p_wrap ? wp->w_skipcol > 0 : wp->w_leftcol > 0) 4213 #ifdef FEAT_DIFF 4214 && filler_todo <= 0 4215 #endif 4216 && draw_state > WL_NR 4217 && c != NUL) 4218 { 4219 c = lcs_prec; 4220 lcs_prec_todo = NUL; 4221 #ifdef FEAT_MBYTE 4222 mb_c = c; 4223 if (enc_utf8 && (*mb_char2len)(c) > 1) 4224 { 4225 mb_utf8 = TRUE; 4226 u8cc[0] = 0; 4227 c = 0xc0; 4228 } 4229 else 4230 mb_utf8 = FALSE; /* don't draw as UTF-8 */ 4231 #endif 4232 if (!attr_pri) 4233 { 4234 saved_attr3 = char_attr; /* save current attr */ 4235 char_attr = hl_attr(HLF_AT); /* later copied to char_attr */ 4236 n_attr3 = 1; 4237 } 4238 } 4239 4240 /* 4241 * At end of the text line or just after the last character. 4242 */ 4243 if (c == NUL 4244 #if defined(LINE_ATTR) 4245 || did_line_attr == 1 4246 #endif 4247 ) 4248 { 4249 #ifdef FEAT_SEARCH_EXTRA 4250 long prevcol = (long)(ptr - line) - (c == NUL); 4251 #endif 4252 4253 /* invert at least one char, used for Visual and empty line or 4254 * highlight match at end of line. If it's beyond the last 4255 * char on the screen, just overwrite that one (tricky!) Not 4256 * needed when a '$' was displayed for 'list'. */ 4257 if (lcs_eol == lcs_eol_one 4258 && ((area_attr != 0 && vcol == fromcol && c == NUL) 4259 #ifdef FEAT_SEARCH_EXTRA 4260 /* highlight 'hlsearch' match at end of line */ 4261 || ((prevcol == (long)search_hl.startcol 4262 || prevcol == (long)match_hl[0].startcol 4263 || prevcol == (long)match_hl[1].startcol 4264 || prevcol == (long)match_hl[2].startcol) 4265 # if defined(LINE_ATTR) 4266 && did_line_attr <= 1 4267 # endif 4268 ) 4269 #endif 4270 )) 4271 { 4272 int n = 0; 4273 4274 #ifdef FEAT_RIGHTLEFT 4275 if (wp->w_p_rl) 4276 { 4277 if (col < 0) 4278 n = 1; 4279 } 4280 else 4281 #endif 4282 { 4283 if (col >= W_WIDTH(wp)) 4284 n = -1; 4285 } 4286 if (n != 0) 4287 { 4288 /* At the window boundary, highlight the last character 4289 * instead (better than nothing). */ 4290 off += n; 4291 col += n; 4292 } 4293 else 4294 { 4295 /* Add a blank character to highlight. */ 4296 ScreenLines[off] = ' '; 4297 #ifdef FEAT_MBYTE 4298 if (enc_utf8) 4299 ScreenLinesUC[off] = 0; 4300 #endif 4301 } 4302 #ifdef FEAT_SEARCH_EXTRA 4303 if (area_attr == 0) 4304 { 4305 for (i = 0; i <= 3; ++i) 4306 { 4307 if (i == 3) 4308 char_attr = search_hl.attr; 4309 else if ((ptr - line) - 1 == (long)match_hl[i].startcol) 4310 { 4311 char_attr = match_hl[i].attr; 4312 break; 4313 } 4314 } 4315 } 4316 #endif 4317 ScreenAttrs[off] = char_attr; 4318 #ifdef FEAT_RIGHTLEFT 4319 if (wp->w_p_rl) 4320 --col; 4321 else 4322 #endif 4323 ++col; 4324 ++vcol; 4325 } 4326 } 4327 4328 /* 4329 * At end of the text line. 4330 */ 4331 if (c == NUL) 4332 { 4333 #ifdef FEAT_SYN_HL 4334 /* Highlight 'cursorcolumn' past end of the line. */ 4335 if (wp->w_p_wrap) 4336 v = wp->w_skipcol; 4337 else 4338 v = wp->w_leftcol; 4339 /* check if line ends before left margin */ 4340 if (vcol < v + col - win_col_off(wp)) 4341 4342 vcol = v + col - win_col_off(wp); 4343 if (wp->w_p_cuc 4344 && (int)wp->w_virtcol >= vcol 4345 && (int)wp->w_virtcol < W_WIDTH(wp) * (row - startrow + 1) 4346 + v 4347 && lnum != wp->w_cursor.lnum 4348 # ifdef FEAT_RIGHTLEFT 4349 && !wp->w_p_rl 4350 # endif 4351 ) 4352 { 4353 while (col < W_WIDTH(wp)) 4354 { 4355 ScreenLines[off] = ' '; 4356 #ifdef FEAT_MBYTE 4357 if (enc_utf8) 4358 ScreenLinesUC[off] = 0; 4359 #endif 4360 ++col; 4361 if (vcol == (long)wp->w_virtcol) 4362 { 4363 ScreenAttrs[off] = hl_attr(HLF_CUC); 4364 break; 4365 } 4366 ScreenAttrs[off++] = 0; 4367 ++vcol; 4368 } 4369 } 4370 #endif 4371 4372 SCREEN_LINE(screen_row, W_WINCOL(wp), col, (int)W_WIDTH(wp), 4373 wp->w_p_rl); 4374 row++; 4375 4376 /* 4377 * Update w_cline_height and w_cline_folded if the cursor line was 4378 * updated (saves a call to plines() later). 4379 */ 4380 if (wp == curwin && lnum == curwin->w_cursor.lnum) 4381 { 4382 curwin->w_cline_row = startrow; 4383 curwin->w_cline_height = row - startrow; 4384 #ifdef FEAT_FOLDING 4385 curwin->w_cline_folded = FALSE; 4386 #endif 4387 curwin->w_valid |= (VALID_CHEIGHT|VALID_CROW); 4388 } 4389 4390 break; 4391 } 4392 4393 /* line continues beyond line end */ 4394 if (lcs_ext 4395 && !wp->w_p_wrap 4396 #ifdef FEAT_DIFF 4397 && filler_todo <= 0 4398 #endif 4399 && ( 4400 #ifdef FEAT_RIGHTLEFT 4401 wp->w_p_rl ? col == 0 : 4402 #endif 4403 col == W_WIDTH(wp) - 1) 4404 && (*ptr != NUL 4405 || (wp->w_p_list && lcs_eol != NUL && p_extra != at_end_str) 4406 || (n_extra && (c_extra != NUL || *p_extra != NUL)))) 4407 { 4408 c = lcs_ext; 4409 char_attr = hl_attr(HLF_AT); 4410 #ifdef FEAT_MBYTE 4411 mb_c = c; 4412 if (enc_utf8 && (*mb_char2len)(c) > 1) 4413 { 4414 mb_utf8 = TRUE; 4415 u8cc[0] = 0; 4416 c = 0xc0; 4417 } 4418 else 4419 mb_utf8 = FALSE; 4420 #endif 4421 } 4422 4423 #ifdef FEAT_SYN_HL 4424 /* Highlight the cursor column if 'cursorcolumn' is set. But don't 4425 * highlight the cursor position itself. */ 4426 if (wp->w_p_cuc && vcol == (long)wp->w_virtcol 4427 && lnum != wp->w_cursor.lnum 4428 && draw_state == WL_LINE) 4429 { 4430 vcol_save_attr = char_attr; 4431 char_attr = hl_combine_attr(char_attr, hl_attr(HLF_CUC)); 4432 } 4433 else 4434 vcol_save_attr = -1; 4435 #endif 4436 4437 /* 4438 * Store character to be displayed. 4439 * Skip characters that are left of the screen for 'nowrap'. 4440 */ 4441 vcol_prev = vcol; 4442 if (draw_state < WL_LINE || n_skip <= 0) 4443 { 4444 /* 4445 * Store the character. 4446 */ 4447 #if defined(FEAT_RIGHTLEFT) && defined(FEAT_MBYTE) 4448 if (has_mbyte && wp->w_p_rl && (*mb_char2cells)(mb_c) > 1) 4449 { 4450 /* A double-wide character is: put first halve in left cell. */ 4451 --off; 4452 --col; 4453 } 4454 #endif 4455 ScreenLines[off] = c; 4456 #ifdef FEAT_MBYTE 4457 if (enc_dbcs == DBCS_JPNU) 4458 ScreenLines2[off] = mb_c & 0xff; 4459 else if (enc_utf8) 4460 { 4461 if (mb_utf8) 4462 { 4463 ScreenLinesUC[off] = mb_c; 4464 if ((c & 0xff) == 0) 4465 ScreenLines[off] = 0x80; /* avoid storing zero */ 4466 for (i = 0; i < Screen_mco; ++i) 4467 { 4468 ScreenLinesC[i][off] = u8cc[i]; 4469 if (u8cc[i] == 0) 4470 break; 4471 } 4472 } 4473 else 4474 ScreenLinesUC[off] = 0; 4475 } 4476 if (multi_attr) 4477 { 4478 ScreenAttrs[off] = multi_attr; 4479 multi_attr = 0; 4480 } 4481 else 4482 #endif 4483 ScreenAttrs[off] = char_attr; 4484 4485 #ifdef FEAT_MBYTE 4486 if (has_mbyte && (*mb_char2cells)(mb_c) > 1) 4487 { 4488 /* Need to fill two screen columns. */ 4489 ++off; 4490 ++col; 4491 if (enc_utf8) 4492 /* UTF-8: Put a 0 in the second screen char. */ 4493 ScreenLines[off] = 0; 4494 else 4495 /* DBCS: Put second byte in the second screen char. */ 4496 ScreenLines[off] = mb_c & 0xff; 4497 ++vcol; 4498 /* When "tocol" is halfway a character, set it to the end of 4499 * the character, otherwise highlighting won't stop. */ 4500 if (tocol == vcol) 4501 ++tocol; 4502 #ifdef FEAT_RIGHTLEFT 4503 if (wp->w_p_rl) 4504 { 4505 /* now it's time to backup one cell */ 4506 --off; 4507 --col; 4508 } 4509 #endif 4510 } 4511 #endif 4512 #ifdef FEAT_RIGHTLEFT 4513 if (wp->w_p_rl) 4514 { 4515 --off; 4516 --col; 4517 } 4518 else 4519 #endif 4520 { 4521 ++off; 4522 ++col; 4523 } 4524 } 4525 else 4526 --n_skip; 4527 4528 /* Only advance the "vcol" when after the 'number' column. */ 4529 if (draw_state >= WL_SBR 4530 #ifdef FEAT_DIFF 4531 && filler_todo <= 0 4532 #endif 4533 ) 4534 ++vcol; 4535 4536 #ifdef FEAT_SYN_HL 4537 if (vcol_save_attr >= 0) 4538 char_attr = vcol_save_attr; 4539 #endif 4540 4541 /* restore attributes after "predeces" in 'listchars' */ 4542 if (draw_state > WL_NR && n_attr3 > 0 && --n_attr3 == 0) 4543 char_attr = saved_attr3; 4544 4545 /* restore attributes after last 'listchars' or 'number' char */ 4546 if (n_attr > 0 && draw_state == WL_LINE && --n_attr == 0) 4547 char_attr = saved_attr2; 4548 4549 /* 4550 * At end of screen line and there is more to come: Display the line 4551 * so far. If there is no more to display it is catched above. 4552 */ 4553 if (( 4554 #ifdef FEAT_RIGHTLEFT 4555 wp->w_p_rl ? (col < 0) : 4556 #endif 4557 (col >= W_WIDTH(wp))) 4558 && (*ptr != NUL 4559 #ifdef FEAT_DIFF 4560 || filler_todo > 0 4561 #endif 4562 || (wp->w_p_list && lcs_eol != NUL && p_extra != at_end_str) 4563 || (n_extra != 0 && (c_extra != NUL || *p_extra != NUL))) 4564 ) 4565 { 4566 SCREEN_LINE(screen_row, W_WINCOL(wp), col, (int)W_WIDTH(wp), 4567 wp->w_p_rl); 4568 ++row; 4569 ++screen_row; 4570 4571 /* When not wrapping and finished diff lines, or when displayed 4572 * '$' and highlighting until last column, break here. */ 4573 if ((!wp->w_p_wrap 4574 #ifdef FEAT_DIFF 4575 && filler_todo <= 0 4576 #endif 4577 ) || lcs_eol_one == -1) 4578 break; 4579 4580 /* When the window is too narrow draw all "@" lines. */ 4581 if (draw_state != WL_LINE 4582 #ifdef FEAT_DIFF 4583 && filler_todo <= 0 4584 #endif 4585 ) 4586 { 4587 win_draw_end(wp, '@', ' ', row, wp->w_height, HLF_AT); 4588 #ifdef FEAT_VERTSPLIT 4589 draw_vsep_win(wp, row); 4590 #endif 4591 row = endrow; 4592 } 4593 4594 /* When line got too long for screen break here. */ 4595 if (row == endrow) 4596 { 4597 ++row; 4598 break; 4599 } 4600 4601 if (screen_cur_row == screen_row - 1 4602 #ifdef FEAT_DIFF 4603 && filler_todo <= 0 4604 #endif 4605 && W_WIDTH(wp) == Columns) 4606 { 4607 /* Remember that the line wraps, used for modeless copy. */ 4608 LineWraps[screen_row - 1] = TRUE; 4609 4610 /* 4611 * Special trick to make copy/paste of wrapped lines work with 4612 * xterm/screen: write an extra character beyond the end of 4613 * the line. This will work with all terminal types 4614 * (regardless of the xn,am settings). 4615 * Only do this on a fast tty. 4616 * Only do this if the cursor is on the current line 4617 * (something has been written in it). 4618 * Don't do this for the GUI. 4619 * Don't do this for double-width characters. 4620 * Don't do this for a window not at the right screen border. 4621 */ 4622 if (p_tf 4623 #ifdef FEAT_GUI 4624 && !gui.in_use 4625 #endif 4626 #ifdef FEAT_MBYTE 4627 && !(has_mbyte 4628 && ((*mb_off2cells)(LineOffset[screen_row]) == 2 4629 || (*mb_off2cells)(LineOffset[screen_row - 1] 4630 + (int)Columns - 2) == 2)) 4631 #endif 4632 ) 4633 { 4634 /* First make sure we are at the end of the screen line, 4635 * then output the same character again to let the 4636 * terminal know about the wrap. If the terminal doesn't 4637 * auto-wrap, we overwrite the character. */ 4638 if (screen_cur_col != W_WIDTH(wp)) 4639 screen_char(LineOffset[screen_row - 1] 4640 + (unsigned)Columns - 1, 4641 screen_row - 1, (int)(Columns - 1)); 4642 4643 #ifdef FEAT_MBYTE 4644 /* When there is a multi-byte character, just output a 4645 * space to keep it simple. */ 4646 if (has_mbyte && MB_BYTE2LEN(ScreenLines[LineOffset[ 4647 screen_row - 1] + (Columns - 1)]) > 1) 4648 out_char(' '); 4649 else 4650 #endif 4651 out_char(ScreenLines[LineOffset[screen_row - 1] 4652 + (Columns - 1)]); 4653 /* force a redraw of the first char on the next line */ 4654 ScreenAttrs[LineOffset[screen_row]] = (sattr_T)-1; 4655 screen_start(); /* don't know where cursor is now */ 4656 } 4657 } 4658 4659 col = 0; 4660 off = (unsigned)(current_ScreenLine - ScreenLines); 4661 #ifdef FEAT_RIGHTLEFT 4662 if (wp->w_p_rl) 4663 { 4664 col = W_WIDTH(wp) - 1; /* col is not used if breaking! */ 4665 off += col; 4666 } 4667 #endif 4668 4669 /* reset the drawing state for the start of a wrapped line */ 4670 draw_state = WL_START; 4671 saved_n_extra = n_extra; 4672 saved_p_extra = p_extra; 4673 saved_c_extra = c_extra; 4674 saved_char_attr = char_attr; 4675 n_extra = 0; 4676 lcs_prec_todo = lcs_prec; 4677 #ifdef FEAT_LINEBREAK 4678 # ifdef FEAT_DIFF 4679 if (filler_todo <= 0) 4680 # endif 4681 need_showbreak = TRUE; 4682 #endif 4683 #ifdef FEAT_DIFF 4684 --filler_todo; 4685 /* When the filler lines are actually below the last line of the 4686 * file, don't draw the line itself, break here. */ 4687 if (filler_todo == 0 && wp->w_botfill) 4688 break; 4689 #endif 4690 } 4691 4692 } /* for every character in the line */ 4693 4694 #ifdef FEAT_SPELL 4695 /* After an empty line check first word for capital. */ 4696 if (*skipwhite(line) == NUL) 4697 { 4698 capcol_lnum = lnum + 1; 4699 cap_col = 0; 4700 } 4701 #endif 4702 4703 return row; 4704 } 4705 4706 #ifdef FEAT_MBYTE 4707 static int comp_char_differs __ARGS((int, int)); 4708 4709 /* 4710 * Return if the composing characters at "off_from" and "off_to" differ. 4711 */ 4712 static int 4713 comp_char_differs(off_from, off_to) 4714 int off_from; 4715 int off_to; 4716 { 4717 int i; 4718 4719 for (i = 0; i < Screen_mco; ++i) 4720 { 4721 if (ScreenLinesC[i][off_from] != ScreenLinesC[i][off_to]) 4722 return TRUE; 4723 if (ScreenLinesC[i][off_from] == 0) 4724 break; 4725 } 4726 return FALSE; 4727 } 4728 #endif 4729 4730 /* 4731 * Check whether the given character needs redrawing: 4732 * - the (first byte of the) character is different 4733 * - the attributes are different 4734 * - the character is multi-byte and the next byte is different 4735 */ 4736 static int 4737 char_needs_redraw(off_from, off_to, cols) 4738 int off_from; 4739 int off_to; 4740 int cols; 4741 { 4742 if (cols > 0 4743 && ((ScreenLines[off_from] != ScreenLines[off_to] 4744 || ScreenAttrs[off_from] != ScreenAttrs[off_to]) 4745 4746 #ifdef FEAT_MBYTE 4747 || (enc_dbcs != 0 4748 && MB_BYTE2LEN(ScreenLines[off_from]) > 1 4749 && (enc_dbcs == DBCS_JPNU && ScreenLines[off_from] == 0x8e 4750 ? ScreenLines2[off_from] != ScreenLines2[off_to] 4751 : (cols > 1 && ScreenLines[off_from + 1] 4752 != ScreenLines[off_to + 1]))) 4753 || (enc_utf8 4754 && (ScreenLinesUC[off_from] != ScreenLinesUC[off_to] 4755 || (ScreenLinesUC[off_from] != 0 4756 && comp_char_differs(off_from, off_to)))) 4757 #endif 4758 )) 4759 return TRUE; 4760 return FALSE; 4761 } 4762 4763 /* 4764 * Move one "cooked" screen line to the screen, but only the characters that 4765 * have actually changed. Handle insert/delete character. 4766 * "coloff" gives the first column on the screen for this line. 4767 * "endcol" gives the columns where valid characters are. 4768 * "clear_width" is the width of the window. It's > 0 if the rest of the line 4769 * needs to be cleared, negative otherwise. 4770 * "rlflag" is TRUE in a rightleft window: 4771 * When TRUE and "clear_width" > 0, clear columns 0 to "endcol" 4772 * When FALSE and "clear_width" > 0, clear columns "endcol" to "clear_width" 4773 */ 4774 static void 4775 screen_line(row, coloff, endcol, clear_width 4776 #ifdef FEAT_RIGHTLEFT 4777 , rlflag 4778 #endif 4779 ) 4780 int row; 4781 int coloff; 4782 int endcol; 4783 int clear_width; 4784 #ifdef FEAT_RIGHTLEFT 4785 int rlflag; 4786 #endif 4787 { 4788 unsigned off_from; 4789 unsigned off_to; 4790 int col = 0; 4791 #if defined(FEAT_GUI) || defined(UNIX) || defined(FEAT_VERTSPLIT) 4792 int hl; 4793 #endif 4794 int force = FALSE; /* force update rest of the line */ 4795 int redraw_this /* bool: does character need redraw? */ 4796 #ifdef FEAT_GUI 4797 = TRUE /* For GUI when while-loop empty */ 4798 #endif 4799 ; 4800 int redraw_next; /* redraw_this for next character */ 4801 #ifdef FEAT_MBYTE 4802 int clear_next = FALSE; 4803 int char_cells; /* 1: normal char */ 4804 /* 2: occupies two display cells */ 4805 # define CHAR_CELLS char_cells 4806 #else 4807 # define CHAR_CELLS 1 4808 #endif 4809 4810 # ifdef FEAT_CLIPBOARD 4811 clip_may_clear_selection(row, row); 4812 # endif 4813 4814 off_from = (unsigned)(current_ScreenLine - ScreenLines); 4815 off_to = LineOffset[row] + coloff; 4816 4817 #ifdef FEAT_RIGHTLEFT 4818 if (rlflag) 4819 { 4820 /* Clear rest first, because it's left of the text. */ 4821 if (clear_width > 0) 4822 { 4823 while (col <= endcol && ScreenLines[off_to] == ' ' 4824 && ScreenAttrs[off_to] == 0 4825 # ifdef FEAT_MBYTE 4826 && (!enc_utf8 || ScreenLinesUC[off_to] == 0) 4827 # endif 4828 ) 4829 { 4830 ++off_to; 4831 ++col; 4832 } 4833 if (col <= endcol) 4834 screen_fill(row, row + 1, col + coloff, 4835 endcol + coloff + 1, ' ', ' ', 0); 4836 } 4837 col = endcol + 1; 4838 off_to = LineOffset[row] + col + coloff; 4839 off_from += col; 4840 endcol = (clear_width > 0 ? clear_width : -clear_width); 4841 } 4842 #endif /* FEAT_RIGHTLEFT */ 4843 4844 redraw_next = char_needs_redraw(off_from, off_to, endcol - col); 4845 4846 while (col < endcol) 4847 { 4848 #ifdef FEAT_MBYTE 4849 if (has_mbyte && (col + 1 < endcol)) 4850 char_cells = (*mb_off2cells)(off_from); 4851 else 4852 char_cells = 1; 4853 #endif 4854 4855 redraw_this = redraw_next; 4856 redraw_next = force || char_needs_redraw(off_from + CHAR_CELLS, 4857 off_to + CHAR_CELLS, endcol - col - CHAR_CELLS); 4858 4859 #ifdef FEAT_GUI 4860 /* If the next character was bold, then redraw the current character to 4861 * remove any pixels that might have spilt over into us. This only 4862 * happens in the GUI. 4863 */ 4864 if (redraw_next && gui.in_use) 4865 { 4866 hl = ScreenAttrs[off_to + CHAR_CELLS]; 4867 if (hl > HL_ALL) 4868 hl = syn_attr2attr(hl); 4869 if (hl & HL_BOLD) 4870 redraw_this = TRUE; 4871 } 4872 #endif 4873 4874 if (redraw_this) 4875 { 4876 /* 4877 * Special handling when 'xs' termcap flag set (hpterm): 4878 * Attributes for characters are stored at the position where the 4879 * cursor is when writing the highlighting code. The 4880 * start-highlighting code must be written with the cursor on the 4881 * first highlighted character. The stop-highlighting code must 4882 * be written with the cursor just after the last highlighted 4883 * character. 4884 * Overwriting a character doesn't remove it's highlighting. Need 4885 * to clear the rest of the line, and force redrawing it 4886 * completely. 4887 */ 4888 if ( p_wiv 4889 && !force 4890 #ifdef FEAT_GUI 4891 && !gui.in_use 4892 #endif 4893 && ScreenAttrs[off_to] != 0 4894 && ScreenAttrs[off_from] != ScreenAttrs[off_to]) 4895 { 4896 /* 4897 * Need to remove highlighting attributes here. 4898 */ 4899 windgoto(row, col + coloff); 4900 out_str(T_CE); /* clear rest of this screen line */ 4901 screen_start(); /* don't know where cursor is now */ 4902 force = TRUE; /* force redraw of rest of the line */ 4903 redraw_next = TRUE; /* or else next char would miss out */ 4904 4905 /* 4906 * If the previous character was highlighted, need to stop 4907 * highlighting at this character. 4908 */ 4909 if (col + coloff > 0 && ScreenAttrs[off_to - 1] != 0) 4910 { 4911 screen_attr = ScreenAttrs[off_to - 1]; 4912 term_windgoto(row, col + coloff); 4913 screen_stop_highlight(); 4914 } 4915 else 4916 screen_attr = 0; /* highlighting has stopped */ 4917 } 4918 #ifdef FEAT_MBYTE 4919 if (enc_dbcs != 0) 4920 { 4921 /* Check if overwriting a double-byte with a single-byte or 4922 * the other way around requires another character to be 4923 * redrawn. For UTF-8 this isn't needed, because comparing 4924 * ScreenLinesUC[] is sufficient. */ 4925 if (char_cells == 1 4926 && col + 1 < endcol 4927 && (*mb_off2cells)(off_to) > 1) 4928 { 4929 /* Writing a single-cell character over a double-cell 4930 * character: need to redraw the next cell. */ 4931 ScreenLines[off_to + 1] = 0; 4932 redraw_next = TRUE; 4933 } 4934 else if (char_cells == 2 4935 && col + 2 < endcol 4936 && (*mb_off2cells)(off_to) == 1 4937 && (*mb_off2cells)(off_to + 1) > 1) 4938 { 4939 /* Writing the second half of a double-cell character over 4940 * a double-cell character: need to redraw the second 4941 * cell. */ 4942 ScreenLines[off_to + 2] = 0; 4943 redraw_next = TRUE; 4944 } 4945 4946 if (enc_dbcs == DBCS_JPNU) 4947 ScreenLines2[off_to] = ScreenLines2[off_from]; 4948 } 4949 /* When writing a single-width character over a double-width 4950 * character and at the end of the redrawn text, need to clear out 4951 * the right halve of the old character. 4952 * Also required when writing the right halve of a double-width 4953 * char over the left halve of an existing one. */ 4954 if (has_mbyte && col + char_cells == endcol 4955 && ((char_cells == 1 4956 && (*mb_off2cells)(off_to) > 1) 4957 || (char_cells == 2 4958 && (*mb_off2cells)(off_to) == 1 4959 && (*mb_off2cells)(off_to + 1) > 1))) 4960 clear_next = TRUE; 4961 #endif 4962 4963 ScreenLines[off_to] = ScreenLines[off_from]; 4964 #ifdef FEAT_MBYTE 4965 if (enc_utf8) 4966 { 4967 ScreenLinesUC[off_to] = ScreenLinesUC[off_from]; 4968 if (ScreenLinesUC[off_from] != 0) 4969 { 4970 int i; 4971 4972 for (i = 0; i < Screen_mco; ++i) 4973 ScreenLinesC[i][off_to] = ScreenLinesC[i][off_from]; 4974 } 4975 } 4976 if (char_cells == 2) 4977 ScreenLines[off_to + 1] = ScreenLines[off_from + 1]; 4978 #endif 4979 4980 #if defined(FEAT_GUI) || defined(UNIX) 4981 /* The bold trick makes a single row of pixels appear in the next 4982 * character. When a bold character is removed, the next 4983 * character should be redrawn too. This happens for our own GUI 4984 * and for some xterms. */ 4985 if ( 4986 # ifdef FEAT_GUI 4987 gui.in_use 4988 # endif 4989 # if defined(FEAT_GUI) && defined(UNIX) 4990 || 4991 # endif 4992 # ifdef UNIX 4993 term_is_xterm 4994 # endif 4995 ) 4996 { 4997 hl = ScreenAttrs[off_to]; 4998 if (hl > HL_ALL) 4999 hl = syn_attr2attr(hl); 5000 if (hl & HL_BOLD) 5001 redraw_next = TRUE; 5002 } 5003 #endif 5004 ScreenAttrs[off_to] = ScreenAttrs[off_from]; 5005 #ifdef FEAT_MBYTE 5006 /* For simplicity set the attributes of second half of a 5007 * double-wide character equal to the first half. */ 5008 if (char_cells == 2) 5009 ScreenAttrs[off_to + 1] = ScreenAttrs[off_from]; 5010 5011 if (enc_dbcs != 0 && char_cells == 2) 5012 screen_char_2(off_to, row, col + coloff); 5013 else 5014 #endif 5015 screen_char(off_to, row, col + coloff); 5016 } 5017 else if ( p_wiv 5018 #ifdef FEAT_GUI 5019 && !gui.in_use 5020 #endif 5021 && col + coloff > 0) 5022 { 5023 if (ScreenAttrs[off_to] == ScreenAttrs[off_to - 1]) 5024 { 5025 /* 5026 * Don't output stop-highlight when moving the cursor, it will 5027 * stop the highlighting when it should continue. 5028 */ 5029 screen_attr = 0; 5030 } 5031 else if (screen_attr != 0) 5032 screen_stop_highlight(); 5033 } 5034 5035 off_to += CHAR_CELLS; 5036 off_from += CHAR_CELLS; 5037 col += CHAR_CELLS; 5038 } 5039 5040 #ifdef FEAT_MBYTE 5041 if (clear_next) 5042 { 5043 /* Clear the second half of a double-wide character of which the left 5044 * half was overwritten with a single-wide character. */ 5045 ScreenLines[off_to] = ' '; 5046 if (enc_utf8) 5047 ScreenLinesUC[off_to] = 0; 5048 screen_char(off_to, row, col + coloff); 5049 } 5050 #endif 5051 5052 if (clear_width > 0 5053 #ifdef FEAT_RIGHTLEFT 5054 && !rlflag 5055 #endif 5056 ) 5057 { 5058 #ifdef FEAT_GUI 5059 int startCol = col; 5060 #endif 5061 5062 /* blank out the rest of the line */ 5063 while (col < clear_width && ScreenLines[off_to] == ' ' 5064 && ScreenAttrs[off_to] == 0 5065 #ifdef FEAT_MBYTE 5066 && (!enc_utf8 || ScreenLinesUC[off_to] == 0) 5067 #endif 5068 ) 5069 { 5070 ++off_to; 5071 ++col; 5072 } 5073 if (col < clear_width) 5074 { 5075 #ifdef FEAT_GUI 5076 /* 5077 * In the GUI, clearing the rest of the line may leave pixels 5078 * behind if the first character cleared was bold. Some bold 5079 * fonts spill over the left. In this case we redraw the previous 5080 * character too. If we didn't skip any blanks above, then we 5081 * only redraw if the character wasn't already redrawn anyway. 5082 */ 5083 if (gui.in_use && (col > startCol || !redraw_this)) 5084 { 5085 hl = ScreenAttrs[off_to]; 5086 if (hl > HL_ALL || (hl & HL_BOLD)) 5087 { 5088 int prev_cells = 1; 5089 # ifdef FEAT_MBYTE 5090 if (enc_utf8) 5091 /* for utf-8, ScreenLines[char_offset + 1] == 0 means 5092 * that its width is 2. */ 5093 prev_cells = ScreenLines[off_to - 1] == 0 ? 2 : 1; 5094 else if (enc_dbcs != 0) 5095 { 5096 /* find previous character by counting from first 5097 * column and get its width. */ 5098 unsigned off = LineOffset[row]; 5099 5100 while (off < off_to) 5101 { 5102 prev_cells = (*mb_off2cells)(off); 5103 off += prev_cells; 5104 } 5105 } 5106 5107 if (enc_dbcs != 0 && prev_cells > 1) 5108 screen_char_2(off_to - prev_cells, row, 5109 col + coloff - prev_cells); 5110 else 5111 # endif 5112 screen_char(off_to - prev_cells, row, 5113 col + coloff - prev_cells); 5114 } 5115 } 5116 #endif 5117 screen_fill(row, row + 1, col + coloff, clear_width + coloff, 5118 ' ', ' ', 0); 5119 #ifdef FEAT_VERTSPLIT 5120 off_to += clear_width - col; 5121 col = clear_width; 5122 #endif 5123 } 5124 } 5125 5126 if (clear_width > 0) 5127 { 5128 #ifdef FEAT_VERTSPLIT 5129 /* For a window that's left of another, draw the separator char. */ 5130 if (col + coloff < Columns) 5131 { 5132 int c; 5133 5134 c = fillchar_vsep(&hl); 5135 if (ScreenLines[off_to] != c 5136 # ifdef FEAT_MBYTE 5137 || (enc_utf8 && (int)ScreenLinesUC[off_to] 5138 != (c >= 0x80 ? c : 0)) 5139 # endif 5140 || ScreenAttrs[off_to] != hl) 5141 { 5142 ScreenLines[off_to] = c; 5143 ScreenAttrs[off_to] = hl; 5144 # ifdef FEAT_MBYTE 5145 if (enc_utf8) 5146 { 5147 if (c >= 0x80) 5148 { 5149 ScreenLinesUC[off_to] = c; 5150 ScreenLinesC[0][off_to] = 0; 5151 } 5152 else 5153 ScreenLinesUC[off_to] = 0; 5154 } 5155 # endif 5156 screen_char(off_to, row, col + coloff); 5157 } 5158 } 5159 else 5160 #endif 5161 LineWraps[row] = FALSE; 5162 } 5163 } 5164 5165 #if defined(FEAT_RIGHTLEFT) || defined(PROTO) 5166 /* 5167 * Mirror text "str" for right-left displaying. 5168 * Only works for single-byte characters (e.g., numbers). 5169 */ 5170 void 5171 rl_mirror(str) 5172 char_u *str; 5173 { 5174 char_u *p1, *p2; 5175 int t; 5176 5177 for (p1 = str, p2 = str + STRLEN(str) - 1; p1 < p2; ++p1, --p2) 5178 { 5179 t = *p1; 5180 *p1 = *p2; 5181 *p2 = t; 5182 } 5183 } 5184 #endif 5185 5186 #if defined(FEAT_WINDOWS) || defined(PROTO) 5187 /* 5188 * mark all status lines for redraw; used after first :cd 5189 */ 5190 void 5191 status_redraw_all() 5192 { 5193 win_T *wp; 5194 5195 for (wp = firstwin; wp; wp = wp->w_next) 5196 if (wp->w_status_height) 5197 { 5198 wp->w_redr_status = TRUE; 5199 redraw_later(VALID); 5200 } 5201 } 5202 5203 /* 5204 * mark all status lines of the current buffer for redraw 5205 */ 5206 void 5207 status_redraw_curbuf() 5208 { 5209 win_T *wp; 5210 5211 for (wp = firstwin; wp; wp = wp->w_next) 5212 if (wp->w_status_height != 0 && wp->w_buffer == curbuf) 5213 { 5214 wp->w_redr_status = TRUE; 5215 redraw_later(VALID); 5216 } 5217 } 5218 5219 /* 5220 * Redraw all status lines that need to be redrawn. 5221 */ 5222 void 5223 redraw_statuslines() 5224 { 5225 win_T *wp; 5226 5227 for (wp = firstwin; wp; wp = wp->w_next) 5228 if (wp->w_redr_status) 5229 win_redr_status(wp); 5230 if (redraw_tabline) 5231 draw_tabline(); 5232 } 5233 #endif 5234 5235 #if (defined(FEAT_WILDMENU) && defined(FEAT_VERTSPLIT)) || defined(PROTO) 5236 /* 5237 * Redraw all status lines at the bottom of frame "frp". 5238 */ 5239 void 5240 win_redraw_last_status(frp) 5241 frame_T *frp; 5242 { 5243 if (frp->fr_layout == FR_LEAF) 5244 frp->fr_win->w_redr_status = TRUE; 5245 else if (frp->fr_layout == FR_ROW) 5246 { 5247 for (frp = frp->fr_child; frp != NULL; frp = frp->fr_next) 5248 win_redraw_last_status(frp); 5249 } 5250 else /* frp->fr_layout == FR_COL */ 5251 { 5252 frp = frp->fr_child; 5253 while (frp->fr_next != NULL) 5254 frp = frp->fr_next; 5255 win_redraw_last_status(frp); 5256 } 5257 } 5258 #endif 5259 5260 #ifdef FEAT_VERTSPLIT 5261 /* 5262 * Draw the verticap separator right of window "wp" starting with line "row". 5263 */ 5264 static void 5265 draw_vsep_win(wp, row) 5266 win_T *wp; 5267 int row; 5268 { 5269 int hl; 5270 int c; 5271 5272 if (wp->w_vsep_width) 5273 { 5274 /* draw the vertical separator right of this window */ 5275 c = fillchar_vsep(&hl); 5276 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + wp->w_height, 5277 W_ENDCOL(wp), W_ENDCOL(wp) + 1, 5278 c, ' ', hl); 5279 } 5280 } 5281 #endif 5282 5283 #ifdef FEAT_WILDMENU 5284 static int status_match_len __ARGS((expand_T *xp, char_u *s)); 5285 static int skip_status_match_char __ARGS((expand_T *xp, char_u *s)); 5286 5287 /* 5288 * Get the lenght of an item as it will be shown in the status line. 5289 */ 5290 static int 5291 status_match_len(xp, s) 5292 expand_T *xp; 5293 char_u *s; 5294 { 5295 int len = 0; 5296 5297 #ifdef FEAT_MENU 5298 int emenu = (xp->xp_context == EXPAND_MENUS 5299 || xp->xp_context == EXPAND_MENUNAMES); 5300 5301 /* Check for menu separators - replace with '|'. */ 5302 if (emenu && menu_is_separator(s)) 5303 return 1; 5304 #endif 5305 5306 while (*s != NUL) 5307 { 5308 if (skip_status_match_char(xp, s)) 5309 ++s; 5310 len += ptr2cells(s); 5311 mb_ptr_adv(s); 5312 } 5313 5314 return len; 5315 } 5316 5317 /* 5318 * Return TRUE for characters that are not displayed in a status match. 5319 * These are backslashes used for escaping. Do show backslashes in help tags. 5320 */ 5321 static int 5322 skip_status_match_char(xp, s) 5323 expand_T *xp; 5324 char_u *s; 5325 { 5326 return ((rem_backslash(s) && xp->xp_context != EXPAND_HELP) 5327 #ifdef FEAT_MENU 5328 || ((xp->xp_context == EXPAND_MENUS 5329 || xp->xp_context == EXPAND_MENUNAMES) 5330 && (s[0] == '\t' || (s[0] == '\\' && s[1] != NUL))) 5331 #endif 5332 ); 5333 } 5334 5335 /* 5336 * Show wildchar matches in the status line. 5337 * Show at least the "match" item. 5338 * We start at item 'first_match' in the list and show all matches that fit. 5339 * 5340 * If inversion is possible we use it. Else '=' characters are used. 5341 */ 5342 void 5343 win_redr_status_matches(xp, num_matches, matches, match, showtail) 5344 expand_T *xp; 5345 int num_matches; 5346 char_u **matches; /* list of matches */ 5347 int match; 5348 int showtail; 5349 { 5350 #define L_MATCH(m) (showtail ? sm_gettail(matches[m]) : matches[m]) 5351 int row; 5352 char_u *buf; 5353 int len; 5354 int clen; /* lenght in screen cells */ 5355 int fillchar; 5356 int attr; 5357 int i; 5358 int highlight = TRUE; 5359 char_u *selstart = NULL; 5360 int selstart_col = 0; 5361 char_u *selend = NULL; 5362 static int first_match = 0; 5363 int add_left = FALSE; 5364 char_u *s; 5365 #ifdef FEAT_MENU 5366 int emenu; 5367 #endif 5368 #if defined(FEAT_MBYTE) || defined(FEAT_MENU) 5369 int l; 5370 #endif 5371 5372 if (matches == NULL) /* interrupted completion? */ 5373 return; 5374 5375 #ifdef FEAT_MBYTE 5376 if (has_mbyte) 5377 buf = alloc((unsigned)Columns * MB_MAXBYTES + 1); 5378 else 5379 #endif 5380 buf = alloc((unsigned)Columns + 1); 5381 if (buf == NULL) 5382 return; 5383 5384 if (match == -1) /* don't show match but original text */ 5385 { 5386 match = 0; 5387 highlight = FALSE; 5388 } 5389 /* count 1 for the ending ">" */ 5390 clen = status_match_len(xp, L_MATCH(match)) + 3; 5391 if (match == 0) 5392 first_match = 0; 5393 else if (match < first_match) 5394 { 5395 /* jumping left, as far as we can go */ 5396 first_match = match; 5397 add_left = TRUE; 5398 } 5399 else 5400 { 5401 /* check if match fits on the screen */ 5402 for (i = first_match; i < match; ++i) 5403 clen += status_match_len(xp, L_MATCH(i)) + 2; 5404 if (first_match > 0) 5405 clen += 2; 5406 /* jumping right, put match at the left */ 5407 if ((long)clen > Columns) 5408 { 5409 first_match = match; 5410 /* if showing the last match, we can add some on the left */ 5411 clen = 2; 5412 for (i = match; i < num_matches; ++i) 5413 { 5414 clen += status_match_len(xp, L_MATCH(i)) + 2; 5415 if ((long)clen >= Columns) 5416 break; 5417 } 5418 if (i == num_matches) 5419 add_left = TRUE; 5420 } 5421 } 5422 if (add_left) 5423 while (first_match > 0) 5424 { 5425 clen += status_match_len(xp, L_MATCH(first_match - 1)) + 2; 5426 if ((long)clen >= Columns) 5427 break; 5428 --first_match; 5429 } 5430 5431 fillchar = fillchar_status(&attr, TRUE); 5432 5433 if (first_match == 0) 5434 { 5435 *buf = NUL; 5436 len = 0; 5437 } 5438 else 5439 { 5440 STRCPY(buf, "< "); 5441 len = 2; 5442 } 5443 clen = len; 5444 5445 i = first_match; 5446 while ((long)(clen + status_match_len(xp, L_MATCH(i)) + 2) < Columns) 5447 { 5448 if (i == match) 5449 { 5450 selstart = buf + len; 5451 selstart_col = clen; 5452 } 5453 5454 s = L_MATCH(i); 5455 /* Check for menu separators - replace with '|' */ 5456 #ifdef FEAT_MENU 5457 emenu = (xp->xp_context == EXPAND_MENUS 5458 || xp->xp_context == EXPAND_MENUNAMES); 5459 if (emenu && menu_is_separator(s)) 5460 { 5461 STRCPY(buf + len, transchar('|')); 5462 l = (int)STRLEN(buf + len); 5463 len += l; 5464 clen += l; 5465 } 5466 else 5467 #endif 5468 for ( ; *s != NUL; ++s) 5469 { 5470 if (skip_status_match_char(xp, s)) 5471 ++s; 5472 clen += ptr2cells(s); 5473 #ifdef FEAT_MBYTE 5474 if (has_mbyte && (l = (*mb_ptr2len)(s)) > 1) 5475 { 5476 STRNCPY(buf + len, s, l); 5477 s += l - 1; 5478 len += l; 5479 } 5480 else 5481 #endif 5482 { 5483 STRCPY(buf + len, transchar_byte(*s)); 5484 len += (int)STRLEN(buf + len); 5485 } 5486 } 5487 if (i == match) 5488 selend = buf + len; 5489 5490 *(buf + len++) = ' '; 5491 *(buf + len++) = ' '; 5492 clen += 2; 5493 if (++i == num_matches) 5494 break; 5495 } 5496 5497 if (i != num_matches) 5498 { 5499 *(buf + len++) = '>'; 5500 ++clen; 5501 } 5502 5503 buf[len] = NUL; 5504 5505 row = cmdline_row - 1; 5506 if (row >= 0) 5507 { 5508 if (wild_menu_showing == 0) 5509 { 5510 if (msg_scrolled > 0) 5511 { 5512 /* Put the wildmenu just above the command line. If there is 5513 * no room, scroll the screen one line up. */ 5514 if (cmdline_row == Rows - 1) 5515 { 5516 screen_del_lines(0, 0, 1, (int)Rows, TRUE, NULL); 5517 ++msg_scrolled; 5518 } 5519 else 5520 { 5521 ++cmdline_row; 5522 ++row; 5523 } 5524 wild_menu_showing = WM_SCROLLED; 5525 } 5526 else 5527 { 5528 /* Create status line if needed by setting 'laststatus' to 2. 5529 * Set 'winminheight' to zero to avoid that the window is 5530 * resized. */ 5531 if (lastwin->w_status_height == 0) 5532 { 5533 save_p_ls = p_ls; 5534 save_p_wmh = p_wmh; 5535 p_ls = 2; 5536 p_wmh = 0; 5537 last_status(FALSE); 5538 } 5539 wild_menu_showing = WM_SHOWN; 5540 } 5541 } 5542 5543 screen_puts(buf, row, 0, attr); 5544 if (selstart != NULL && highlight) 5545 { 5546 *selend = NUL; 5547 screen_puts(selstart, row, selstart_col, hl_attr(HLF_WM)); 5548 } 5549 5550 screen_fill(row, row + 1, clen, (int)Columns, fillchar, fillchar, attr); 5551 } 5552 5553 #ifdef FEAT_VERTSPLIT 5554 win_redraw_last_status(topframe); 5555 #else 5556 lastwin->w_redr_status = TRUE; 5557 #endif 5558 vim_free(buf); 5559 } 5560 #endif 5561 5562 #if defined(FEAT_WINDOWS) || defined(PROTO) 5563 /* 5564 * Redraw the status line of window wp. 5565 * 5566 * If inversion is possible we use it. Else '=' characters are used. 5567 */ 5568 void 5569 win_redr_status(wp) 5570 win_T *wp; 5571 { 5572 int row; 5573 char_u *p; 5574 int len; 5575 int fillchar; 5576 int attr; 5577 int this_ru_col; 5578 5579 wp->w_redr_status = FALSE; 5580 if (wp->w_status_height == 0) 5581 { 5582 /* no status line, can only be last window */ 5583 redraw_cmdline = TRUE; 5584 } 5585 else if (!redrawing() 5586 #ifdef FEAT_INS_EXPAND 5587 /* don't update status line when popup menu is visible and may be 5588 * drawn over it */ 5589 || pum_visible() 5590 #endif 5591 ) 5592 { 5593 /* Don't redraw right now, do it later. */ 5594 wp->w_redr_status = TRUE; 5595 } 5596 #ifdef FEAT_STL_OPT 5597 else if (*p_stl != NUL || *wp->w_p_stl != NUL) 5598 { 5599 /* redraw custom status line */ 5600 redraw_custum_statusline(wp); 5601 } 5602 #endif 5603 else 5604 { 5605 fillchar = fillchar_status(&attr, wp == curwin); 5606 5607 get_trans_bufname(wp->w_buffer); 5608 p = NameBuff; 5609 len = (int)STRLEN(p); 5610 5611 if (wp->w_buffer->b_help 5612 #ifdef FEAT_QUICKFIX 5613 || wp->w_p_pvw 5614 #endif 5615 || bufIsChanged(wp->w_buffer) 5616 || wp->w_buffer->b_p_ro) 5617 *(p + len++) = ' '; 5618 if (wp->w_buffer->b_help) 5619 { 5620 STRCPY(p + len, _("[Help]")); 5621 len += (int)STRLEN(p + len); 5622 } 5623 #ifdef FEAT_QUICKFIX 5624 if (wp->w_p_pvw) 5625 { 5626 STRCPY(p + len, _("[Preview]")); 5627 len += (int)STRLEN(p + len); 5628 } 5629 #endif 5630 if (bufIsChanged(wp->w_buffer)) 5631 { 5632 STRCPY(p + len, "[+]"); 5633 len += 3; 5634 } 5635 if (wp->w_buffer->b_p_ro) 5636 { 5637 STRCPY(p + len, "[RO]"); 5638 len += 4; 5639 } 5640 5641 #ifndef FEAT_VERTSPLIT 5642 this_ru_col = ru_col; 5643 if (this_ru_col < (Columns + 1) / 2) 5644 this_ru_col = (Columns + 1) / 2; 5645 #else 5646 this_ru_col = ru_col - (Columns - W_WIDTH(wp)); 5647 if (this_ru_col < (W_WIDTH(wp) + 1) / 2) 5648 this_ru_col = (W_WIDTH(wp) + 1) / 2; 5649 if (this_ru_col <= 1) 5650 { 5651 p = (char_u *)"<"; /* No room for file name! */ 5652 len = 1; 5653 } 5654 else 5655 #endif 5656 #ifdef FEAT_MBYTE 5657 if (has_mbyte) 5658 { 5659 int clen = 0, i; 5660 5661 /* Count total number of display cells. */ 5662 for (i = 0; p[i] != NUL; i += (*mb_ptr2len)(p + i)) 5663 clen += (*mb_ptr2cells)(p + i); 5664 /* Find first character that will fit. 5665 * Going from start to end is much faster for DBCS. */ 5666 for (i = 0; p[i] != NUL && clen >= this_ru_col - 1; 5667 i += (*mb_ptr2len)(p + i)) 5668 clen -= (*mb_ptr2cells)(p + i); 5669 len = clen; 5670 if (i > 0) 5671 { 5672 p = p + i - 1; 5673 *p = '<'; 5674 ++len; 5675 } 5676 5677 } 5678 else 5679 #endif 5680 if (len > this_ru_col - 1) 5681 { 5682 p += len - (this_ru_col - 1); 5683 *p = '<'; 5684 len = this_ru_col - 1; 5685 } 5686 5687 row = W_WINROW(wp) + wp->w_height; 5688 screen_puts(p, row, W_WINCOL(wp), attr); 5689 screen_fill(row, row + 1, len + W_WINCOL(wp), 5690 this_ru_col + W_WINCOL(wp), fillchar, fillchar, attr); 5691 5692 if (get_keymap_str(wp, NameBuff, MAXPATHL) 5693 && (int)(this_ru_col - len) > (int)(STRLEN(NameBuff) + 1)) 5694 screen_puts(NameBuff, row, (int)(this_ru_col - STRLEN(NameBuff) 5695 - 1 + W_WINCOL(wp)), attr); 5696 5697 #ifdef FEAT_CMDL_INFO 5698 win_redr_ruler(wp, TRUE); 5699 #endif 5700 } 5701 5702 #ifdef FEAT_VERTSPLIT 5703 /* 5704 * May need to draw the character below the vertical separator. 5705 */ 5706 if (wp->w_vsep_width != 0 && wp->w_status_height != 0 && redrawing()) 5707 { 5708 if (stl_connected(wp)) 5709 fillchar = fillchar_status(&attr, wp == curwin); 5710 else 5711 fillchar = fillchar_vsep(&attr); 5712 screen_putchar(fillchar, W_WINROW(wp) + wp->w_height, W_ENDCOL(wp), 5713 attr); 5714 } 5715 #endif 5716 } 5717 5718 #ifdef FEAT_STL_OPT 5719 /* 5720 * Redraw the status line according to 'statusline' and take care of any 5721 * errors encountered. 5722 */ 5723 static void 5724 redraw_custum_statusline(wp) 5725 win_T *wp; 5726 { 5727 int save_called_emsg = called_emsg; 5728 5729 called_emsg = FALSE; 5730 win_redr_custom(wp, FALSE); 5731 if (called_emsg) 5732 set_string_option_direct((char_u *)"statusline", -1, 5733 (char_u *)"", OPT_FREE | (*wp->w_p_stl != NUL 5734 ? OPT_LOCAL : OPT_GLOBAL), SID_ERROR); 5735 called_emsg |= save_called_emsg; 5736 } 5737 #endif 5738 5739 # ifdef FEAT_VERTSPLIT 5740 /* 5741 * Return TRUE if the status line of window "wp" is connected to the status 5742 * line of the window right of it. If not, then it's a vertical separator. 5743 * Only call if (wp->w_vsep_width != 0). 5744 */ 5745 int 5746 stl_connected(wp) 5747 win_T *wp; 5748 { 5749 frame_T *fr; 5750 5751 fr = wp->w_frame; 5752 while (fr->fr_parent != NULL) 5753 { 5754 if (fr->fr_parent->fr_layout == FR_COL) 5755 { 5756 if (fr->fr_next != NULL) 5757 break; 5758 } 5759 else 5760 { 5761 if (fr->fr_next != NULL) 5762 return TRUE; 5763 } 5764 fr = fr->fr_parent; 5765 } 5766 return FALSE; 5767 } 5768 # endif 5769 5770 #endif /* FEAT_WINDOWS */ 5771 5772 #if defined(FEAT_WINDOWS) || defined(FEAT_STL_OPT) || defined(PROTO) 5773 /* 5774 * Get the value to show for the language mappings, active 'keymap'. 5775 */ 5776 int 5777 get_keymap_str(wp, buf, len) 5778 win_T *wp; 5779 char_u *buf; /* buffer for the result */ 5780 int len; /* length of buffer */ 5781 { 5782 char_u *p; 5783 5784 if (wp->w_buffer->b_p_iminsert != B_IMODE_LMAP) 5785 return FALSE; 5786 5787 { 5788 #ifdef FEAT_EVAL 5789 buf_T *old_curbuf = curbuf; 5790 win_T *old_curwin = curwin; 5791 char_u *s; 5792 5793 curbuf = wp->w_buffer; 5794 curwin = wp; 5795 STRCPY(buf, "b:keymap_name"); /* must be writable */ 5796 ++emsg_skip; 5797 s = p = eval_to_string(buf, NULL, FALSE); 5798 --emsg_skip; 5799 curbuf = old_curbuf; 5800 curwin = old_curwin; 5801 if (p == NULL || *p == NUL) 5802 #endif 5803 { 5804 #ifdef FEAT_KEYMAP 5805 if (wp->w_buffer->b_kmap_state & KEYMAP_LOADED) 5806 p = wp->w_buffer->b_p_keymap; 5807 else 5808 #endif 5809 p = (char_u *)"lang"; 5810 } 5811 if ((int)(STRLEN(p) + 3) < len) 5812 sprintf((char *)buf, "<%s>", p); 5813 else 5814 buf[0] = NUL; 5815 #ifdef FEAT_EVAL 5816 vim_free(s); 5817 #endif 5818 } 5819 return buf[0] != NUL; 5820 } 5821 #endif 5822 5823 #if defined(FEAT_STL_OPT) || defined(PROTO) 5824 /* 5825 * Redraw the status line or ruler of window "wp". 5826 * When "wp" is NULL redraw the tab pages line from 'tabline'. 5827 */ 5828 static void 5829 win_redr_custom(wp, draw_ruler) 5830 win_T *wp; 5831 int draw_ruler; /* TRUE or FALSE */ 5832 { 5833 int attr; 5834 int curattr; 5835 int row; 5836 int col = 0; 5837 int maxwidth; 5838 int width; 5839 int n; 5840 int len; 5841 int fillchar; 5842 char_u buf[MAXPATHL]; 5843 char_u *p; 5844 struct stl_hlrec hltab[STL_MAX_ITEM]; 5845 struct stl_hlrec tabtab[STL_MAX_ITEM]; 5846 int use_sandbox = FALSE; 5847 5848 /* setup environment for the task at hand */ 5849 if (wp == NULL) 5850 { 5851 /* Use 'tabline'. Always at the first line of the screen. */ 5852 p = p_tal; 5853 row = 0; 5854 fillchar = ' '; 5855 attr = hl_attr(HLF_TPF); 5856 maxwidth = Columns; 5857 # ifdef FEAT_EVAL 5858 use_sandbox = was_set_insecurely((char_u *)"tabline", 0); 5859 # endif 5860 } 5861 else 5862 { 5863 row = W_WINROW(wp) + wp->w_height; 5864 fillchar = fillchar_status(&attr, wp == curwin); 5865 maxwidth = W_WIDTH(wp); 5866 5867 if (draw_ruler) 5868 { 5869 p = p_ruf; 5870 /* advance past any leading group spec - implicit in ru_col */ 5871 if (*p == '%') 5872 { 5873 if (*++p == '-') 5874 p++; 5875 if (atoi((char *) p)) 5876 while (VIM_ISDIGIT(*p)) 5877 p++; 5878 if (*p++ != '(') 5879 p = p_ruf; 5880 } 5881 #ifdef FEAT_VERTSPLIT 5882 col = ru_col - (Columns - W_WIDTH(wp)); 5883 if (col < (W_WIDTH(wp) + 1) / 2) 5884 col = (W_WIDTH(wp) + 1) / 2; 5885 #else 5886 col = ru_col; 5887 if (col > (Columns + 1) / 2) 5888 col = (Columns + 1) / 2; 5889 #endif 5890 maxwidth = W_WIDTH(wp) - col; 5891 #ifdef FEAT_WINDOWS 5892 if (!wp->w_status_height) 5893 #endif 5894 { 5895 row = Rows - 1; 5896 --maxwidth; /* writing in last column may cause scrolling */ 5897 fillchar = ' '; 5898 attr = 0; 5899 } 5900 5901 # ifdef FEAT_EVAL 5902 use_sandbox = was_set_insecurely((char_u *)"rulerformat", 0); 5903 # endif 5904 } 5905 else 5906 { 5907 if (*wp->w_p_stl != NUL) 5908 p = wp->w_p_stl; 5909 else 5910 p = p_stl; 5911 # ifdef FEAT_EVAL 5912 use_sandbox = was_set_insecurely((char_u *)"statusline", 5913 *wp->w_p_stl == NUL ? 0 : OPT_LOCAL); 5914 # endif 5915 } 5916 5917 #ifdef FEAT_VERTSPLIT 5918 col += W_WINCOL(wp); 5919 #endif 5920 } 5921 5922 if (maxwidth <= 0) 5923 return; 5924 5925 width = build_stl_str_hl(wp == NULL ? curwin : wp, 5926 buf, sizeof(buf), 5927 p, use_sandbox, 5928 fillchar, maxwidth, hltab, tabtab); 5929 len = (int)STRLEN(buf); 5930 5931 while (width < maxwidth && len < sizeof(buf) - 1) 5932 { 5933 #ifdef FEAT_MBYTE 5934 len += (*mb_char2bytes)(fillchar, buf + len); 5935 #else 5936 buf[len++] = fillchar; 5937 #endif 5938 ++width; 5939 } 5940 buf[len] = NUL; 5941 5942 /* 5943 * Draw each snippet with the specified highlighting. 5944 */ 5945 curattr = attr; 5946 p = buf; 5947 for (n = 0; hltab[n].start != NULL; n++) 5948 { 5949 len = (int)(hltab[n].start - p); 5950 screen_puts_len(p, len, row, col, curattr); 5951 col += vim_strnsize(p, len); 5952 p = hltab[n].start; 5953 5954 if (hltab[n].userhl == 0) 5955 curattr = attr; 5956 else if (hltab[n].userhl < 0) 5957 curattr = syn_id2attr(-hltab[n].userhl); 5958 #ifdef FEAT_WINDOWS 5959 else if (wp != NULL && wp != curwin && wp->w_status_height != 0) 5960 curattr = highlight_stlnc[hltab[n].userhl - 1]; 5961 #endif 5962 else 5963 curattr = highlight_user[hltab[n].userhl - 1]; 5964 } 5965 screen_puts(p, row, col, curattr); 5966 5967 if (wp == NULL) 5968 { 5969 /* Fill the TabPageIdxs[] array for clicking in the tab pagesline. */ 5970 col = 0; 5971 len = 0; 5972 p = buf; 5973 fillchar = 0; 5974 for (n = 0; tabtab[n].start != NULL; n++) 5975 { 5976 len += vim_strnsize(p, (int)(tabtab[n].start - p)); 5977 while (col < len) 5978 TabPageIdxs[col++] = fillchar; 5979 p = tabtab[n].start; 5980 fillchar = tabtab[n].userhl; 5981 } 5982 while (col < Columns) 5983 TabPageIdxs[col++] = fillchar; 5984 } 5985 } 5986 5987 #endif /* FEAT_STL_OPT */ 5988 5989 /* 5990 * Output a single character directly to the screen and update ScreenLines. 5991 */ 5992 void 5993 screen_putchar(c, row, col, attr) 5994 int c; 5995 int row, col; 5996 int attr; 5997 { 5998 #ifdef FEAT_MBYTE 5999 char_u buf[MB_MAXBYTES + 1]; 6000 6001 buf[(*mb_char2bytes)(c, buf)] = NUL; 6002 #else 6003 char_u buf[2]; 6004 6005 buf[0] = c; 6006 buf[1] = NUL; 6007 #endif 6008 screen_puts(buf, row, col, attr); 6009 } 6010 6011 /* 6012 * Get a single character directly from ScreenLines into "bytes[]". 6013 * Also return its attribute in *attrp; 6014 */ 6015 void 6016 screen_getbytes(row, col, bytes, attrp) 6017 int row, col; 6018 char_u *bytes; 6019 int *attrp; 6020 { 6021 unsigned off; 6022 6023 /* safety check */ 6024 if (ScreenLines != NULL && row < screen_Rows && col < screen_Columns) 6025 { 6026 off = LineOffset[row] + col; 6027 *attrp = ScreenAttrs[off]; 6028 bytes[0] = ScreenLines[off]; 6029 bytes[1] = NUL; 6030 6031 #ifdef FEAT_MBYTE 6032 if (enc_utf8 && ScreenLinesUC[off] != 0) 6033 bytes[utfc_char2bytes(off, bytes)] = NUL; 6034 else if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e) 6035 { 6036 bytes[0] = ScreenLines[off]; 6037 bytes[1] = ScreenLines2[off]; 6038 bytes[2] = NUL; 6039 } 6040 else if (enc_dbcs && MB_BYTE2LEN(bytes[0]) > 1) 6041 { 6042 bytes[1] = ScreenLines[off + 1]; 6043 bytes[2] = NUL; 6044 } 6045 #endif 6046 } 6047 } 6048 6049 #ifdef FEAT_MBYTE 6050 static int screen_comp_differs __ARGS((int, int*)); 6051 6052 /* 6053 * Return TRUE if composing characters for screen posn "off" differs from 6054 * composing characters in "u8cc". 6055 */ 6056 static int 6057 screen_comp_differs(off, u8cc) 6058 int off; 6059 int *u8cc; 6060 { 6061 int i; 6062 6063 for (i = 0; i < Screen_mco; ++i) 6064 { 6065 if (ScreenLinesC[i][off] != (u8char_T)u8cc[i]) 6066 return TRUE; 6067 if (u8cc[i] == 0) 6068 break; 6069 } 6070 return FALSE; 6071 } 6072 #endif 6073 6074 /* 6075 * Put string '*text' on the screen at position 'row' and 'col', with 6076 * attributes 'attr', and update ScreenLines[] and ScreenAttrs[]. 6077 * Note: only outputs within one row, message is truncated at screen boundary! 6078 * Note: if ScreenLines[], row and/or col is invalid, nothing is done. 6079 */ 6080 void 6081 screen_puts(text, row, col, attr) 6082 char_u *text; 6083 int row; 6084 int col; 6085 int attr; 6086 { 6087 screen_puts_len(text, -1, row, col, attr); 6088 } 6089 6090 /* 6091 * Like screen_puts(), but output "text[len]". When "len" is -1 output up to 6092 * a NUL. 6093 */ 6094 void 6095 screen_puts_len(text, len, row, col, attr) 6096 char_u *text; 6097 int len; 6098 int row; 6099 int col; 6100 int attr; 6101 { 6102 unsigned off; 6103 char_u *ptr = text; 6104 int c; 6105 #ifdef FEAT_MBYTE 6106 int mbyte_blen = 1; 6107 int mbyte_cells = 1; 6108 int u8c = 0; 6109 int u8cc[MAX_MCO]; 6110 int clear_next_cell = FALSE; 6111 # ifdef FEAT_ARABIC 6112 int prev_c = 0; /* previous Arabic character */ 6113 int pc, nc, nc1; 6114 int pcc[MAX_MCO]; 6115 # endif 6116 #endif 6117 6118 if (ScreenLines == NULL || row >= screen_Rows) /* safety check */ 6119 return; 6120 6121 off = LineOffset[row] + col; 6122 while (*ptr != NUL && col < screen_Columns 6123 && (len < 0 || (int)(ptr - text) < len)) 6124 { 6125 c = *ptr; 6126 #ifdef FEAT_MBYTE 6127 /* check if this is the first byte of a multibyte */ 6128 if (has_mbyte) 6129 { 6130 if (enc_utf8 && len > 0) 6131 mbyte_blen = utfc_ptr2len_len(ptr, (int)((text + len) - ptr)); 6132 else 6133 mbyte_blen = (*mb_ptr2len)(ptr); 6134 if (enc_dbcs == DBCS_JPNU && c == 0x8e) 6135 mbyte_cells = 1; 6136 else if (enc_dbcs != 0) 6137 mbyte_cells = mbyte_blen; 6138 else /* enc_utf8 */ 6139 { 6140 if (len >= 0) 6141 u8c = utfc_ptr2char_len(ptr, u8cc, 6142 (int)((text + len) - ptr)); 6143 else 6144 u8c = utfc_ptr2char(ptr, u8cc); 6145 mbyte_cells = utf_char2cells(u8c); 6146 /* Non-BMP character: display as ? or fullwidth ?. */ 6147 if (u8c >= 0x10000) 6148 { 6149 u8c = (mbyte_cells == 2) ? 0xff1f : (int)'?'; 6150 if (attr == 0) 6151 attr = hl_attr(HLF_8); 6152 } 6153 # ifdef FEAT_ARABIC 6154 if (p_arshape && !p_tbidi && ARABIC_CHAR(u8c)) 6155 { 6156 /* Do Arabic shaping. */ 6157 if (len >= 0 && (int)(ptr - text) + mbyte_blen >= len) 6158 { 6159 /* Past end of string to be displayed. */ 6160 nc = NUL; 6161 nc1 = NUL; 6162 } 6163 else 6164 { 6165 nc = utfc_ptr2char(ptr + mbyte_blen, pcc); 6166 nc1 = pcc[0]; 6167 } 6168 pc = prev_c; 6169 prev_c = u8c; 6170 u8c = arabic_shape(u8c, &c, &u8cc[0], nc, nc1, pc); 6171 } 6172 else 6173 prev_c = u8c; 6174 # endif 6175 } 6176 } 6177 #endif 6178 6179 if (ScreenLines[off] != c 6180 #ifdef FEAT_MBYTE 6181 || (mbyte_cells == 2 6182 && ScreenLines[off + 1] != (enc_dbcs ? ptr[1] : 0)) 6183 || (enc_dbcs == DBCS_JPNU 6184 && c == 0x8e 6185 && ScreenLines2[off] != ptr[1]) 6186 || (enc_utf8 6187 && (ScreenLinesUC[off] != (u8char_T)u8c 6188 || screen_comp_differs(off, u8cc))) 6189 #endif 6190 || ScreenAttrs[off] != attr 6191 || exmode_active 6192 ) 6193 { 6194 #if defined(FEAT_GUI) || defined(UNIX) 6195 /* The bold trick makes a single row of pixels appear in the next 6196 * character. When a bold character is removed, the next 6197 * character should be redrawn too. This happens for our own GUI 6198 * and for some xterms. 6199 * Force the redraw by setting the attribute to a different value 6200 * than "attr", the contents of ScreenLines[] may be needed by 6201 * mb_off2cells() further on. 6202 * Don't do this for the last drawn character, because the next 6203 * character may not be redrawn. */ 6204 if ( 6205 # ifdef FEAT_GUI 6206 gui.in_use 6207 # endif 6208 # if defined(FEAT_GUI) && defined(UNIX) 6209 || 6210 # endif 6211 # ifdef UNIX 6212 term_is_xterm 6213 # endif 6214 ) 6215 { 6216 int n; 6217 6218 n = ScreenAttrs[off]; 6219 # ifdef FEAT_MBYTE 6220 if (col + mbyte_cells < screen_Columns 6221 && (n > HL_ALL || (n & HL_BOLD)) 6222 && (len < 0 ? ptr[mbyte_blen] != NUL 6223 : ptr + mbyte_blen < text + len)) 6224 ScreenAttrs[off + mbyte_cells] = attr + 1; 6225 # else 6226 if (col + 1 < screen_Columns 6227 && (n > HL_ALL || (n & HL_BOLD)) 6228 && (len < 0 ? ptr[1] != NUL : ptr + 1 < text + len)) 6229 ScreenLines[off + 1] = 0; 6230 # endif 6231 } 6232 #endif 6233 #ifdef FEAT_MBYTE 6234 /* When at the end of the text and overwriting a two-cell 6235 * character with a one-cell character, need to clear the next 6236 * cell. Also when overwriting the left halve of a two-cell char 6237 * with the right halve of a two-cell char. Do this only once 6238 * (mb_off2cells() may return 2 on the right halve). */ 6239 if (clear_next_cell) 6240 clear_next_cell = FALSE; 6241 else if (has_mbyte 6242 && (len < 0 ? ptr[mbyte_blen] == NUL 6243 : ptr + mbyte_blen >= text + len) 6244 && ((mbyte_cells == 1 && (*mb_off2cells)(off) > 1) 6245 || (mbyte_cells == 2 6246 && (*mb_off2cells)(off) == 1 6247 && (*mb_off2cells)(off + 1) > 1))) 6248 clear_next_cell = TRUE; 6249 6250 /* Make sure we never leave a second byte of a double-byte behind, 6251 * it confuses mb_off2cells(). */ 6252 if (enc_dbcs 6253 && ((mbyte_cells == 1 && (*mb_off2cells)(off) > 1) 6254 || (mbyte_cells == 2 6255 && (*mb_off2cells)(off) == 1 6256 && (*mb_off2cells)(off + 1) > 1))) 6257 ScreenLines[off + mbyte_blen] = 0; 6258 #endif 6259 ScreenLines[off] = c; 6260 ScreenAttrs[off] = attr; 6261 #ifdef FEAT_MBYTE 6262 if (enc_utf8) 6263 { 6264 if (c < 0x80 && u8cc[0] == 0) 6265 ScreenLinesUC[off] = 0; 6266 else 6267 { 6268 int i; 6269 6270 ScreenLinesUC[off] = u8c; 6271 for (i = 0; i < Screen_mco; ++i) 6272 { 6273 ScreenLinesC[i][off] = u8cc[i]; 6274 if (u8cc[i] == 0) 6275 break; 6276 } 6277 } 6278 if (mbyte_cells == 2) 6279 { 6280 ScreenLines[off + 1] = 0; 6281 ScreenAttrs[off + 1] = attr; 6282 } 6283 screen_char(off, row, col); 6284 } 6285 else if (mbyte_cells == 2) 6286 { 6287 ScreenLines[off + 1] = ptr[1]; 6288 ScreenAttrs[off + 1] = attr; 6289 screen_char_2(off, row, col); 6290 } 6291 else if (enc_dbcs == DBCS_JPNU && c == 0x8e) 6292 { 6293 ScreenLines2[off] = ptr[1]; 6294 screen_char(off, row, col); 6295 } 6296 else 6297 #endif 6298 screen_char(off, row, col); 6299 } 6300 #ifdef FEAT_MBYTE 6301 if (has_mbyte) 6302 { 6303 off += mbyte_cells; 6304 col += mbyte_cells; 6305 ptr += mbyte_blen; 6306 if (clear_next_cell) 6307 ptr = (char_u *)" "; 6308 } 6309 else 6310 #endif 6311 { 6312 ++off; 6313 ++col; 6314 ++ptr; 6315 } 6316 } 6317 } 6318 6319 #ifdef FEAT_SEARCH_EXTRA 6320 /* 6321 * Prepare for 'searchhl' highlighting. 6322 */ 6323 static void 6324 start_search_hl() 6325 { 6326 if (p_hls && !no_hlsearch) 6327 { 6328 last_pat_prog(&search_hl.rm); 6329 search_hl.attr = hl_attr(HLF_L); 6330 } 6331 } 6332 6333 /* 6334 * Clean up for 'searchhl' highlighting. 6335 */ 6336 static void 6337 end_search_hl() 6338 { 6339 if (search_hl.rm.regprog != NULL) 6340 { 6341 vim_free(search_hl.rm.regprog); 6342 search_hl.rm.regprog = NULL; 6343 } 6344 } 6345 6346 /* 6347 * Advance to the match in window "wp" line "lnum" or past it. 6348 */ 6349 static void 6350 prepare_search_hl(wp, lnum) 6351 win_T *wp; 6352 linenr_T lnum; 6353 { 6354 match_T *shl; /* points to search_hl or match_hl */ 6355 int n; 6356 int i; 6357 6358 /* 6359 * When using a multi-line pattern, start searching at the top 6360 * of the window or just after a closed fold. 6361 * Do this both for search_hl and match_hl[3]. 6362 */ 6363 for (i = 3; i >= 0; --i) 6364 { 6365 shl = (i == 3) ? &search_hl : &match_hl[i]; 6366 if (shl->rm.regprog != NULL 6367 && shl->lnum == 0 6368 && re_multiline(shl->rm.regprog)) 6369 { 6370 if (shl->first_lnum == 0) 6371 { 6372 # ifdef FEAT_FOLDING 6373 for (shl->first_lnum = lnum; 6374 shl->first_lnum > wp->w_topline; --shl->first_lnum) 6375 if (hasFoldingWin(wp, shl->first_lnum - 1, 6376 NULL, NULL, TRUE, NULL)) 6377 break; 6378 # else 6379 shl->first_lnum = wp->w_topline; 6380 # endif 6381 } 6382 n = 0; 6383 while (shl->first_lnum < lnum && shl->rm.regprog != NULL) 6384 { 6385 next_search_hl(wp, shl, shl->first_lnum, (colnr_T)n); 6386 if (shl->lnum != 0) 6387 { 6388 shl->first_lnum = shl->lnum 6389 + shl->rm.endpos[0].lnum 6390 - shl->rm.startpos[0].lnum; 6391 n = shl->rm.endpos[0].col; 6392 } 6393 else 6394 { 6395 ++shl->first_lnum; 6396 n = 0; 6397 } 6398 } 6399 } 6400 } 6401 } 6402 6403 /* 6404 * Search for a next 'searchl' or ":match" match. 6405 * Uses shl->buf. 6406 * Sets shl->lnum and shl->rm contents. 6407 * Note: Assumes a previous match is always before "lnum", unless 6408 * shl->lnum is zero. 6409 * Careful: Any pointers for buffer lines will become invalid. 6410 */ 6411 static void 6412 next_search_hl(win, shl, lnum, mincol) 6413 win_T *win; 6414 match_T *shl; /* points to search_hl or match_hl */ 6415 linenr_T lnum; 6416 colnr_T mincol; /* minimal column for a match */ 6417 { 6418 linenr_T l; 6419 colnr_T matchcol; 6420 long nmatched; 6421 6422 if (shl->lnum != 0) 6423 { 6424 /* Check for three situations: 6425 * 1. If the "lnum" is below a previous match, start a new search. 6426 * 2. If the previous match includes "mincol", use it. 6427 * 3. Continue after the previous match. 6428 */ 6429 l = shl->lnum + shl->rm.endpos[0].lnum - shl->rm.startpos[0].lnum; 6430 if (lnum > l) 6431 shl->lnum = 0; 6432 else if (lnum < l || shl->rm.endpos[0].col > mincol) 6433 return; 6434 } 6435 6436 /* 6437 * Repeat searching for a match until one is found that includes "mincol" 6438 * or none is found in this line. 6439 */ 6440 called_emsg = FALSE; 6441 for (;;) 6442 { 6443 /* Three situations: 6444 * 1. No useful previous match: search from start of line. 6445 * 2. Not Vi compatible or empty match: continue at next character. 6446 * Break the loop if this is beyond the end of the line. 6447 * 3. Vi compatible searching: continue at end of previous match. 6448 */ 6449 if (shl->lnum == 0) 6450 matchcol = 0; 6451 else if (vim_strchr(p_cpo, CPO_SEARCH) == NULL 6452 || (shl->rm.endpos[0].lnum == 0 6453 && shl->rm.endpos[0].col <= shl->rm.startpos[0].col)) 6454 { 6455 char_u *ml; 6456 6457 matchcol = shl->rm.startpos[0].col; 6458 ml = ml_get_buf(shl->buf, lnum, FALSE) + matchcol; 6459 if (*ml == NUL) 6460 { 6461 ++matchcol; 6462 shl->lnum = 0; 6463 break; 6464 } 6465 #ifdef FEAT_MBYTE 6466 if (has_mbyte) 6467 matchcol += mb_ptr2len(ml); 6468 else 6469 #endif 6470 ++matchcol; 6471 } 6472 else 6473 matchcol = shl->rm.endpos[0].col; 6474 6475 shl->lnum = lnum; 6476 nmatched = vim_regexec_multi(&shl->rm, win, shl->buf, lnum, matchcol); 6477 if (called_emsg) 6478 { 6479 /* Error while handling regexp: stop using this regexp. */ 6480 if (shl == &search_hl) 6481 { 6482 /* don't free the regprog in match_hl[], it's a copy */ 6483 vim_free(shl->rm.regprog); 6484 no_hlsearch = TRUE; 6485 } 6486 shl->rm.regprog = NULL; 6487 shl->lnum = 0; 6488 got_int = FALSE; /* avoid the "Type :quit to exit Vim" message */ 6489 break; 6490 } 6491 if (nmatched == 0) 6492 { 6493 shl->lnum = 0; /* no match found */ 6494 break; 6495 } 6496 if (shl->rm.startpos[0].lnum > 0 6497 || shl->rm.startpos[0].col >= mincol 6498 || nmatched > 1 6499 || shl->rm.endpos[0].col > mincol) 6500 { 6501 shl->lnum += shl->rm.startpos[0].lnum; 6502 break; /* useful match found */ 6503 } 6504 } 6505 } 6506 #endif 6507 6508 static void 6509 screen_start_highlight(attr) 6510 int attr; 6511 { 6512 attrentry_T *aep = NULL; 6513 6514 screen_attr = attr; 6515 if (full_screen 6516 #ifdef WIN3264 6517 && termcap_active 6518 #endif 6519 ) 6520 { 6521 #ifdef FEAT_GUI 6522 if (gui.in_use) 6523 { 6524 char buf[20]; 6525 6526 /* The GUI handles this internally. */ 6527 sprintf(buf, IF_EB("\033|%dh", ESC_STR "|%dh"), attr); 6528 OUT_STR(buf); 6529 } 6530 else 6531 #endif 6532 { 6533 if (attr > HL_ALL) /* special HL attr. */ 6534 { 6535 if (t_colors > 1) 6536 aep = syn_cterm_attr2entry(attr); 6537 else 6538 aep = syn_term_attr2entry(attr); 6539 if (aep == NULL) /* did ":syntax clear" */ 6540 attr = 0; 6541 else 6542 attr = aep->ae_attr; 6543 } 6544 if ((attr & HL_BOLD) && T_MD != NULL) /* bold */ 6545 out_str(T_MD); 6546 else if (aep != NULL && t_colors > 1 && aep->ae_u.cterm.fg_color 6547 && cterm_normal_fg_bold) 6548 /* If the Normal FG color has BOLD attribute and the new HL 6549 * has a FG color defined, clear BOLD. */ 6550 out_str(T_ME); 6551 if ((attr & HL_STANDOUT) && T_SO != NULL) /* standout */ 6552 out_str(T_SO); 6553 if ((attr & (HL_UNDERLINE | HL_UNDERCURL)) && T_US != NULL) 6554 /* underline or undercurl */ 6555 out_str(T_US); 6556 if ((attr & HL_ITALIC) && T_CZH != NULL) /* italic */ 6557 out_str(T_CZH); 6558 if ((attr & HL_INVERSE) && T_MR != NULL) /* inverse (reverse) */ 6559 out_str(T_MR); 6560 6561 /* 6562 * Output the color or start string after bold etc., in case the 6563 * bold etc. override the color setting. 6564 */ 6565 if (aep != NULL) 6566 { 6567 if (t_colors > 1) 6568 { 6569 if (aep->ae_u.cterm.fg_color) 6570 term_fg_color(aep->ae_u.cterm.fg_color - 1); 6571 if (aep->ae_u.cterm.bg_color) 6572 term_bg_color(aep->ae_u.cterm.bg_color - 1); 6573 } 6574 else 6575 { 6576 if (aep->ae_u.term.start != NULL) 6577 out_str(aep->ae_u.term.start); 6578 } 6579 } 6580 } 6581 } 6582 } 6583 6584 void 6585 screen_stop_highlight() 6586 { 6587 int do_ME = FALSE; /* output T_ME code */ 6588 6589 if (screen_attr != 0 6590 #ifdef WIN3264 6591 && termcap_active 6592 #endif 6593 ) 6594 { 6595 #ifdef FEAT_GUI 6596 if (gui.in_use) 6597 { 6598 char buf[20]; 6599 6600 /* use internal GUI code */ 6601 sprintf(buf, IF_EB("\033|%dH", ESC_STR "|%dH"), screen_attr); 6602 OUT_STR(buf); 6603 } 6604 else 6605 #endif 6606 { 6607 if (screen_attr > HL_ALL) /* special HL attr. */ 6608 { 6609 attrentry_T *aep; 6610 6611 if (t_colors > 1) 6612 { 6613 /* 6614 * Assume that t_me restores the original colors! 6615 */ 6616 aep = syn_cterm_attr2entry(screen_attr); 6617 if (aep != NULL && (aep->ae_u.cterm.fg_color 6618 || aep->ae_u.cterm.bg_color)) 6619 do_ME = TRUE; 6620 } 6621 else 6622 { 6623 aep = syn_term_attr2entry(screen_attr); 6624 if (aep != NULL && aep->ae_u.term.stop != NULL) 6625 { 6626 if (STRCMP(aep->ae_u.term.stop, T_ME) == 0) 6627 do_ME = TRUE; 6628 else 6629 out_str(aep->ae_u.term.stop); 6630 } 6631 } 6632 if (aep == NULL) /* did ":syntax clear" */ 6633 screen_attr = 0; 6634 else 6635 screen_attr = aep->ae_attr; 6636 } 6637 6638 /* 6639 * Often all ending-codes are equal to T_ME. Avoid outputting the 6640 * same sequence several times. 6641 */ 6642 if (screen_attr & HL_STANDOUT) 6643 { 6644 if (STRCMP(T_SE, T_ME) == 0) 6645 do_ME = TRUE; 6646 else 6647 out_str(T_SE); 6648 } 6649 if (screen_attr & (HL_UNDERLINE | HL_UNDERCURL)) 6650 { 6651 if (STRCMP(T_UE, T_ME) == 0) 6652 do_ME = TRUE; 6653 else 6654 out_str(T_UE); 6655 } 6656 if (screen_attr & HL_ITALIC) 6657 { 6658 if (STRCMP(T_CZR, T_ME) == 0) 6659 do_ME = TRUE; 6660 else 6661 out_str(T_CZR); 6662 } 6663 if (do_ME || (screen_attr & (HL_BOLD | HL_INVERSE))) 6664 out_str(T_ME); 6665 6666 if (t_colors > 1) 6667 { 6668 /* set Normal cterm colors */ 6669 if (cterm_normal_fg_color != 0) 6670 term_fg_color(cterm_normal_fg_color - 1); 6671 if (cterm_normal_bg_color != 0) 6672 term_bg_color(cterm_normal_bg_color - 1); 6673 if (cterm_normal_fg_bold) 6674 out_str(T_MD); 6675 } 6676 } 6677 } 6678 screen_attr = 0; 6679 } 6680 6681 /* 6682 * Reset the colors for a cterm. Used when leaving Vim. 6683 * The machine specific code may override this again. 6684 */ 6685 void 6686 reset_cterm_colors() 6687 { 6688 if (t_colors > 1) 6689 { 6690 /* set Normal cterm colors */ 6691 if (cterm_normal_fg_color > 0 || cterm_normal_bg_color > 0) 6692 { 6693 out_str(T_OP); 6694 screen_attr = -1; 6695 } 6696 if (cterm_normal_fg_bold) 6697 { 6698 out_str(T_ME); 6699 screen_attr = -1; 6700 } 6701 } 6702 } 6703 6704 /* 6705 * Put character ScreenLines["off"] on the screen at position "row" and "col", 6706 * using the attributes from ScreenAttrs["off"]. 6707 */ 6708 static void 6709 screen_char(off, row, col) 6710 unsigned off; 6711 int row; 6712 int col; 6713 { 6714 int attr; 6715 6716 /* Check for illegal values, just in case (could happen just after 6717 * resizing). */ 6718 if (row >= screen_Rows || col >= screen_Columns) 6719 return; 6720 6721 /* Outputting the last character on the screen may scrollup the screen. 6722 * Don't to it! Mark the character invalid (update it when scrolled up) */ 6723 if (row == screen_Rows - 1 && col == screen_Columns - 1 6724 #ifdef FEAT_RIGHTLEFT 6725 /* account for first command-line character in rightleft mode */ 6726 && !cmdmsg_rl 6727 #endif 6728 ) 6729 { 6730 ScreenAttrs[off] = (sattr_T)-1; 6731 return; 6732 } 6733 6734 /* 6735 * Stop highlighting first, so it's easier to move the cursor. 6736 */ 6737 #if defined(FEAT_CLIPBOARD) || defined(FEAT_VERTSPLIT) 6738 if (screen_char_attr != 0) 6739 attr = screen_char_attr; 6740 else 6741 #endif 6742 attr = ScreenAttrs[off]; 6743 if (screen_attr != attr) 6744 screen_stop_highlight(); 6745 6746 windgoto(row, col); 6747 6748 if (screen_attr != attr) 6749 screen_start_highlight(attr); 6750 6751 #ifdef FEAT_MBYTE 6752 if (enc_utf8 && ScreenLinesUC[off] != 0) 6753 { 6754 char_u buf[MB_MAXBYTES + 1]; 6755 6756 /* Convert UTF-8 character to bytes and write it. */ 6757 6758 buf[utfc_char2bytes(off, buf)] = NUL; 6759 6760 out_str(buf); 6761 if (utf_char2cells(ScreenLinesUC[off]) > 1) 6762 ++screen_cur_col; 6763 } 6764 else 6765 #endif 6766 { 6767 #ifdef FEAT_MBYTE 6768 out_flush_check(); 6769 #endif 6770 out_char(ScreenLines[off]); 6771 #ifdef FEAT_MBYTE 6772 /* double-byte character in single-width cell */ 6773 if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e) 6774 out_char(ScreenLines2[off]); 6775 #endif 6776 } 6777 6778 screen_cur_col++; 6779 } 6780 6781 #ifdef FEAT_MBYTE 6782 6783 /* 6784 * Used for enc_dbcs only: Put one double-wide character at ScreenLines["off"] 6785 * on the screen at position 'row' and 'col'. 6786 * The attributes of the first byte is used for all. This is required to 6787 * output the two bytes of a double-byte character with nothing in between. 6788 */ 6789 static void 6790 screen_char_2(off, row, col) 6791 unsigned off; 6792 int row; 6793 int col; 6794 { 6795 /* Check for illegal values (could be wrong when screen was resized). */ 6796 if (off + 1 >= (unsigned)(screen_Rows * screen_Columns)) 6797 return; 6798 6799 /* Outputting the last character on the screen may scrollup the screen. 6800 * Don't to it! Mark the character invalid (update it when scrolled up) */ 6801 if (row == screen_Rows - 1 && col >= screen_Columns - 2) 6802 { 6803 ScreenAttrs[off] = (sattr_T)-1; 6804 return; 6805 } 6806 6807 /* Output the first byte normally (positions the cursor), then write the 6808 * second byte directly. */ 6809 screen_char(off, row, col); 6810 out_char(ScreenLines[off + 1]); 6811 ++screen_cur_col; 6812 } 6813 #endif 6814 6815 #if defined(FEAT_CLIPBOARD) || defined(FEAT_VERTSPLIT) || defined(PROTO) 6816 /* 6817 * Draw a rectangle of the screen, inverted when "invert" is TRUE. 6818 * This uses the contents of ScreenLines[] and doesn't change it. 6819 */ 6820 void 6821 screen_draw_rectangle(row, col, height, width, invert) 6822 int row; 6823 int col; 6824 int height; 6825 int width; 6826 int invert; 6827 { 6828 int r, c; 6829 int off; 6830 6831 /* Can't use ScreenLines unless initialized */ 6832 if (ScreenLines == NULL) 6833 return; 6834 6835 if (invert) 6836 screen_char_attr = HL_INVERSE; 6837 for (r = row; r < row + height; ++r) 6838 { 6839 off = LineOffset[r]; 6840 for (c = col; c < col + width; ++c) 6841 { 6842 #ifdef FEAT_MBYTE 6843 if (enc_dbcs != 0 && dbcs_off2cells(off + c) > 1) 6844 { 6845 screen_char_2(off + c, r, c); 6846 ++c; 6847 } 6848 else 6849 #endif 6850 { 6851 screen_char(off + c, r, c); 6852 #ifdef FEAT_MBYTE 6853 if (utf_off2cells(off + c) > 1) 6854 ++c; 6855 #endif 6856 } 6857 } 6858 } 6859 screen_char_attr = 0; 6860 } 6861 #endif 6862 6863 #ifdef FEAT_VERTSPLIT 6864 /* 6865 * Redraw the characters for a vertically split window. 6866 */ 6867 static void 6868 redraw_block(row, end, wp) 6869 int row; 6870 int end; 6871 win_T *wp; 6872 { 6873 int col; 6874 int width; 6875 6876 # ifdef FEAT_CLIPBOARD 6877 clip_may_clear_selection(row, end - 1); 6878 # endif 6879 6880 if (wp == NULL) 6881 { 6882 col = 0; 6883 width = Columns; 6884 } 6885 else 6886 { 6887 col = wp->w_wincol; 6888 width = wp->w_width; 6889 } 6890 screen_draw_rectangle(row, col, end - row, width, FALSE); 6891 } 6892 #endif 6893 6894 /* 6895 * Fill the screen from 'start_row' to 'end_row', from 'start_col' to 'end_col' 6896 * with character 'c1' in first column followed by 'c2' in the other columns. 6897 * Use attributes 'attr'. 6898 */ 6899 void 6900 screen_fill(start_row, end_row, start_col, end_col, c1, c2, attr) 6901 int start_row, end_row; 6902 int start_col, end_col; 6903 int c1, c2; 6904 int attr; 6905 { 6906 int row; 6907 int col; 6908 int off; 6909 int end_off; 6910 int did_delete; 6911 int c; 6912 int norm_term; 6913 #if defined(FEAT_GUI) || defined(UNIX) 6914 int force_next = FALSE; 6915 #endif 6916 6917 if (end_row > screen_Rows) /* safety check */ 6918 end_row = screen_Rows; 6919 if (end_col > screen_Columns) /* safety check */ 6920 end_col = screen_Columns; 6921 if (ScreenLines == NULL 6922 || start_row >= end_row 6923 || start_col >= end_col) /* nothing to do */ 6924 return; 6925 6926 /* it's a "normal" terminal when not in a GUI or cterm */ 6927 norm_term = ( 6928 #ifdef FEAT_GUI 6929 !gui.in_use && 6930 #endif 6931 t_colors <= 1); 6932 for (row = start_row; row < end_row; ++row) 6933 { 6934 /* 6935 * Try to use delete-line termcap code, when no attributes or in a 6936 * "normal" terminal, where a bold/italic space is just a 6937 * space. 6938 */ 6939 did_delete = FALSE; 6940 if (c2 == ' ' 6941 && end_col == Columns 6942 && can_clear(T_CE) 6943 && (attr == 0 6944 || (norm_term 6945 && attr <= HL_ALL 6946 && ((attr & ~(HL_BOLD | HL_ITALIC)) == 0)))) 6947 { 6948 /* 6949 * check if we really need to clear something 6950 */ 6951 col = start_col; 6952 if (c1 != ' ') /* don't clear first char */ 6953 ++col; 6954 6955 off = LineOffset[row] + col; 6956 end_off = LineOffset[row] + end_col; 6957 6958 /* skip blanks (used often, keep it fast!) */ 6959 #ifdef FEAT_MBYTE 6960 if (enc_utf8) 6961 while (off < end_off && ScreenLines[off] == ' ' 6962 && ScreenAttrs[off] == 0 && ScreenLinesUC[off] == 0) 6963 ++off; 6964 else 6965 #endif 6966 while (off < end_off && ScreenLines[off] == ' ' 6967 && ScreenAttrs[off] == 0) 6968 ++off; 6969 if (off < end_off) /* something to be cleared */ 6970 { 6971 col = off - LineOffset[row]; 6972 screen_stop_highlight(); 6973 term_windgoto(row, col);/* clear rest of this screen line */ 6974 out_str(T_CE); 6975 screen_start(); /* don't know where cursor is now */ 6976 col = end_col - col; 6977 while (col--) /* clear chars in ScreenLines */ 6978 { 6979 ScreenLines[off] = ' '; 6980 #ifdef FEAT_MBYTE 6981 if (enc_utf8) 6982 ScreenLinesUC[off] = 0; 6983 #endif 6984 ScreenAttrs[off] = 0; 6985 ++off; 6986 } 6987 } 6988 did_delete = TRUE; /* the chars are cleared now */ 6989 } 6990 6991 off = LineOffset[row] + start_col; 6992 c = c1; 6993 for (col = start_col; col < end_col; ++col) 6994 { 6995 if (ScreenLines[off] != c 6996 #ifdef FEAT_MBYTE 6997 || (enc_utf8 && (int)ScreenLinesUC[off] 6998 != (c >= 0x80 ? c : 0)) 6999 #endif 7000 || ScreenAttrs[off] != attr 7001 #if defined(FEAT_GUI) || defined(UNIX) 7002 || force_next 7003 #endif 7004 ) 7005 { 7006 #if defined(FEAT_GUI) || defined(UNIX) 7007 /* The bold trick may make a single row of pixels appear in 7008 * the next character. When a bold character is removed, the 7009 * next character should be redrawn too. This happens for our 7010 * own GUI and for some xterms. */ 7011 if ( 7012 # ifdef FEAT_GUI 7013 gui.in_use 7014 # endif 7015 # if defined(FEAT_GUI) && defined(UNIX) 7016 || 7017 # endif 7018 # ifdef UNIX 7019 term_is_xterm 7020 # endif 7021 ) 7022 { 7023 if (ScreenLines[off] != ' ' 7024 && (ScreenAttrs[off] > HL_ALL 7025 || ScreenAttrs[off] & HL_BOLD)) 7026 force_next = TRUE; 7027 else 7028 force_next = FALSE; 7029 } 7030 #endif 7031 ScreenLines[off] = c; 7032 #ifdef FEAT_MBYTE 7033 if (enc_utf8) 7034 { 7035 if (c >= 0x80) 7036 { 7037 ScreenLinesUC[off] = c; 7038 ScreenLinesC[0][off] = 0; 7039 } 7040 else 7041 ScreenLinesUC[off] = 0; 7042 } 7043 #endif 7044 ScreenAttrs[off] = attr; 7045 if (!did_delete || c != ' ') 7046 screen_char(off, row, col); 7047 } 7048 ++off; 7049 if (col == start_col) 7050 { 7051 if (did_delete) 7052 break; 7053 c = c2; 7054 } 7055 } 7056 if (end_col == Columns) 7057 LineWraps[row] = FALSE; 7058 if (row == Rows - 1) /* overwritten the command line */ 7059 { 7060 redraw_cmdline = TRUE; 7061 if (c1 == ' ' && c2 == ' ') 7062 clear_cmdline = FALSE; /* command line has been cleared */ 7063 if (start_col == 0) 7064 mode_displayed = FALSE; /* mode cleared or overwritten */ 7065 } 7066 } 7067 } 7068 7069 /* 7070 * Check if there should be a delay. Used before clearing or redrawing the 7071 * screen or the command line. 7072 */ 7073 void 7074 check_for_delay(check_msg_scroll) 7075 int check_msg_scroll; 7076 { 7077 if ((emsg_on_display || (check_msg_scroll && msg_scroll)) 7078 && !did_wait_return 7079 && emsg_silent == 0) 7080 { 7081 out_flush(); 7082 ui_delay(1000L, TRUE); 7083 emsg_on_display = FALSE; 7084 if (check_msg_scroll) 7085 msg_scroll = FALSE; 7086 } 7087 } 7088 7089 /* 7090 * screen_valid - allocate screen buffers if size changed 7091 * If "clear" is TRUE: clear screen if it has been resized. 7092 * Returns TRUE if there is a valid screen to write to. 7093 * Returns FALSE when starting up and screen not initialized yet. 7094 */ 7095 int 7096 screen_valid(clear) 7097 int clear; 7098 { 7099 screenalloc(clear); /* allocate screen buffers if size changed */ 7100 return (ScreenLines != NULL); 7101 } 7102 7103 /* 7104 * Resize the shell to Rows and Columns. 7105 * Allocate ScreenLines[] and associated items. 7106 * 7107 * There may be some time between setting Rows and Columns and (re)allocating 7108 * ScreenLines[]. This happens when starting up and when (manually) changing 7109 * the shell size. Always use screen_Rows and screen_Columns to access items 7110 * in ScreenLines[]. Use Rows and Columns for positioning text etc. where the 7111 * final size of the shell is needed. 7112 */ 7113 void 7114 screenalloc(clear) 7115 int clear; 7116 { 7117 int new_row, old_row; 7118 #ifdef FEAT_GUI 7119 int old_Rows; 7120 #endif 7121 win_T *wp; 7122 int outofmem = FALSE; 7123 int len; 7124 schar_T *new_ScreenLines; 7125 #ifdef FEAT_MBYTE 7126 u8char_T *new_ScreenLinesUC = NULL; 7127 u8char_T *new_ScreenLinesC[MAX_MCO]; 7128 schar_T *new_ScreenLines2 = NULL; 7129 int i; 7130 #endif 7131 sattr_T *new_ScreenAttrs; 7132 unsigned *new_LineOffset; 7133 char_u *new_LineWraps; 7134 #ifdef FEAT_WINDOWS 7135 short *new_TabPageIdxs; 7136 tabpage_T *tp; 7137 #endif 7138 static int entered = FALSE; /* avoid recursiveness */ 7139 static int done_outofmem_msg = FALSE; /* did outofmem message */ 7140 7141 /* 7142 * Allocation of the screen buffers is done only when the size changes and 7143 * when Rows and Columns have been set and we have started doing full 7144 * screen stuff. 7145 */ 7146 if ((ScreenLines != NULL 7147 && Rows == screen_Rows 7148 && Columns == screen_Columns 7149 #ifdef FEAT_MBYTE 7150 && enc_utf8 == (ScreenLinesUC != NULL) 7151 && (enc_dbcs == DBCS_JPNU) == (ScreenLines2 != NULL) 7152 && p_mco == Screen_mco 7153 #endif 7154 ) 7155 || Rows == 0 7156 || Columns == 0 7157 || (!full_screen && ScreenLines == NULL)) 7158 return; 7159 7160 /* 7161 * It's possible that we produce an out-of-memory message below, which 7162 * will cause this function to be called again. To break the loop, just 7163 * return here. 7164 */ 7165 if (entered) 7166 return; 7167 entered = TRUE; 7168 7169 /* 7170 * Note that the window sizes are updated before reallocating the arrays, 7171 * thus we must not redraw here! 7172 */ 7173 ++RedrawingDisabled; 7174 7175 win_new_shellsize(); /* fit the windows in the new sized shell */ 7176 7177 comp_col(); /* recompute columns for shown command and ruler */ 7178 7179 /* 7180 * We're changing the size of the screen. 7181 * - Allocate new arrays for ScreenLines and ScreenAttrs. 7182 * - Move lines from the old arrays into the new arrays, clear extra 7183 * lines (unless the screen is going to be cleared). 7184 * - Free the old arrays. 7185 * 7186 * If anything fails, make ScreenLines NULL, so we don't do anything! 7187 * Continuing with the old ScreenLines may result in a crash, because the 7188 * size is wrong. 7189 */ 7190 FOR_ALL_TAB_WINDOWS(tp, wp) 7191 win_free_lsize(wp); 7192 7193 new_ScreenLines = (schar_T *)lalloc((long_u)( 7194 (Rows + 1) * Columns * sizeof(schar_T)), FALSE); 7195 #ifdef FEAT_MBYTE 7196 vim_memset(new_ScreenLinesC, 0, sizeof(u8char_T) * MAX_MCO); 7197 if (enc_utf8) 7198 { 7199 new_ScreenLinesUC = (u8char_T *)lalloc((long_u)( 7200 (Rows + 1) * Columns * sizeof(u8char_T)), FALSE); 7201 for (i = 0; i < p_mco; ++i) 7202 new_ScreenLinesC[i] = (u8char_T *)lalloc((long_u)( 7203 (Rows + 1) * Columns * sizeof(u8char_T)), FALSE); 7204 } 7205 if (enc_dbcs == DBCS_JPNU) 7206 new_ScreenLines2 = (schar_T *)lalloc((long_u)( 7207 (Rows + 1) * Columns * sizeof(schar_T)), FALSE); 7208 #endif 7209 new_ScreenAttrs = (sattr_T *)lalloc((long_u)( 7210 (Rows + 1) * Columns * sizeof(sattr_T)), FALSE); 7211 new_LineOffset = (unsigned *)lalloc((long_u)( 7212 Rows * sizeof(unsigned)), FALSE); 7213 new_LineWraps = (char_u *)lalloc((long_u)(Rows * sizeof(char_u)), FALSE); 7214 #ifdef FEAT_WINDOWS 7215 new_TabPageIdxs = (short *)lalloc((long_u)(Columns * sizeof(short)), FALSE); 7216 #endif 7217 7218 FOR_ALL_TAB_WINDOWS(tp, wp) 7219 { 7220 if (win_alloc_lines(wp) == FAIL) 7221 { 7222 outofmem = TRUE; 7223 #ifdef FEAT_WINDOWS 7224 break; 7225 #endif 7226 } 7227 } 7228 7229 #ifdef FEAT_MBYTE 7230 for (i = 0; i < p_mco; ++i) 7231 if (new_ScreenLinesC[i] == NULL) 7232 break; 7233 #endif 7234 if (new_ScreenLines == NULL 7235 #ifdef FEAT_MBYTE 7236 || (enc_utf8 && (new_ScreenLinesUC == NULL || i != p_mco)) 7237 || (enc_dbcs == DBCS_JPNU && new_ScreenLines2 == NULL) 7238 #endif 7239 || new_ScreenAttrs == NULL 7240 || new_LineOffset == NULL 7241 || new_LineWraps == NULL 7242 #ifdef FEAT_WINDOWS 7243 || new_TabPageIdxs == NULL 7244 #endif 7245 || outofmem) 7246 { 7247 if (ScreenLines != NULL || !done_outofmem_msg) 7248 { 7249 /* guess the size */ 7250 do_outofmem_msg((long_u)((Rows + 1) * Columns)); 7251 7252 /* Remember we did this to avoid getting outofmem messages over 7253 * and over again. */ 7254 done_outofmem_msg = TRUE; 7255 } 7256 vim_free(new_ScreenLines); 7257 new_ScreenLines = NULL; 7258 #ifdef FEAT_MBYTE 7259 vim_free(new_ScreenLinesUC); 7260 new_ScreenLinesUC = NULL; 7261 for (i = 0; i < p_mco; ++i) 7262 { 7263 vim_free(new_ScreenLinesC[i]); 7264 new_ScreenLinesC[i] = NULL; 7265 } 7266 vim_free(new_ScreenLines2); 7267 new_ScreenLines2 = NULL; 7268 #endif 7269 vim_free(new_ScreenAttrs); 7270 new_ScreenAttrs = NULL; 7271 vim_free(new_LineOffset); 7272 new_LineOffset = NULL; 7273 vim_free(new_LineWraps); 7274 new_LineWraps = NULL; 7275 #ifdef FEAT_WINDOWS 7276 vim_free(new_TabPageIdxs); 7277 new_TabPageIdxs = NULL; 7278 #endif 7279 } 7280 else 7281 { 7282 done_outofmem_msg = FALSE; 7283 7284 for (new_row = 0; new_row < Rows; ++new_row) 7285 { 7286 new_LineOffset[new_row] = new_row * Columns; 7287 new_LineWraps[new_row] = FALSE; 7288 7289 /* 7290 * If the screen is not going to be cleared, copy as much as 7291 * possible from the old screen to the new one and clear the rest 7292 * (used when resizing the window at the "--more--" prompt or when 7293 * executing an external command, for the GUI). 7294 */ 7295 if (!clear) 7296 { 7297 (void)vim_memset(new_ScreenLines + new_row * Columns, 7298 ' ', (size_t)Columns * sizeof(schar_T)); 7299 #ifdef FEAT_MBYTE 7300 if (enc_utf8) 7301 { 7302 (void)vim_memset(new_ScreenLinesUC + new_row * Columns, 7303 0, (size_t)Columns * sizeof(u8char_T)); 7304 for (i = 0; i < p_mco; ++i) 7305 (void)vim_memset(new_ScreenLinesC[i] 7306 + new_row * Columns, 7307 0, (size_t)Columns * sizeof(u8char_T)); 7308 } 7309 if (enc_dbcs == DBCS_JPNU) 7310 (void)vim_memset(new_ScreenLines2 + new_row * Columns, 7311 0, (size_t)Columns * sizeof(schar_T)); 7312 #endif 7313 (void)vim_memset(new_ScreenAttrs + new_row * Columns, 7314 0, (size_t)Columns * sizeof(sattr_T)); 7315 old_row = new_row + (screen_Rows - Rows); 7316 if (old_row >= 0 && ScreenLines != NULL) 7317 { 7318 if (screen_Columns < Columns) 7319 len = screen_Columns; 7320 else 7321 len = Columns; 7322 #ifdef FEAT_MBYTE 7323 /* When switching to utf-8 don't copy characters, they 7324 * may be invalid now. Also when p_mco changes. */ 7325 if (!(enc_utf8 && ScreenLinesUC == NULL) 7326 && p_mco == Screen_mco) 7327 #endif 7328 mch_memmove(new_ScreenLines + new_LineOffset[new_row], 7329 ScreenLines + LineOffset[old_row], 7330 (size_t)len * sizeof(schar_T)); 7331 #ifdef FEAT_MBYTE 7332 if (enc_utf8 && ScreenLinesUC != NULL 7333 && p_mco == Screen_mco) 7334 { 7335 mch_memmove(new_ScreenLinesUC + new_LineOffset[new_row], 7336 ScreenLinesUC + LineOffset[old_row], 7337 (size_t)len * sizeof(u8char_T)); 7338 for (i = 0; i < p_mco; ++i) 7339 mch_memmove(new_ScreenLinesC[i] 7340 + new_LineOffset[new_row], 7341 ScreenLinesC[i] + LineOffset[old_row], 7342 (size_t)len * sizeof(u8char_T)); 7343 } 7344 if (enc_dbcs == DBCS_JPNU && ScreenLines2 != NULL) 7345 mch_memmove(new_ScreenLines2 + new_LineOffset[new_row], 7346 ScreenLines2 + LineOffset[old_row], 7347 (size_t)len * sizeof(schar_T)); 7348 #endif 7349 mch_memmove(new_ScreenAttrs + new_LineOffset[new_row], 7350 ScreenAttrs + LineOffset[old_row], 7351 (size_t)len * sizeof(sattr_T)); 7352 } 7353 } 7354 } 7355 /* Use the last line of the screen for the current line. */ 7356 current_ScreenLine = new_ScreenLines + Rows * Columns; 7357 } 7358 7359 free_screenlines(); 7360 7361 ScreenLines = new_ScreenLines; 7362 #ifdef FEAT_MBYTE 7363 ScreenLinesUC = new_ScreenLinesUC; 7364 for (i = 0; i < p_mco; ++i) 7365 ScreenLinesC[i] = new_ScreenLinesC[i]; 7366 Screen_mco = p_mco; 7367 ScreenLines2 = new_ScreenLines2; 7368 #endif 7369 ScreenAttrs = new_ScreenAttrs; 7370 LineOffset = new_LineOffset; 7371 LineWraps = new_LineWraps; 7372 #ifdef FEAT_WINDOWS 7373 TabPageIdxs = new_TabPageIdxs; 7374 #endif 7375 7376 /* It's important that screen_Rows and screen_Columns reflect the actual 7377 * size of ScreenLines[]. Set them before calling anything. */ 7378 #ifdef FEAT_GUI 7379 old_Rows = screen_Rows; 7380 #endif 7381 screen_Rows = Rows; 7382 screen_Columns = Columns; 7383 7384 must_redraw = CLEAR; /* need to clear the screen later */ 7385 if (clear) 7386 screenclear2(); 7387 7388 #ifdef FEAT_GUI 7389 else if (gui.in_use 7390 && !gui.starting 7391 && ScreenLines != NULL 7392 && old_Rows != Rows) 7393 { 7394 (void)gui_redraw_block(0, 0, (int)Rows - 1, (int)Columns - 1, 0); 7395 /* 7396 * Adjust the position of the cursor, for when executing an external 7397 * command. 7398 */ 7399 if (msg_row >= Rows) /* Rows got smaller */ 7400 msg_row = Rows - 1; /* put cursor at last row */ 7401 else if (Rows > old_Rows) /* Rows got bigger */ 7402 msg_row += Rows - old_Rows; /* put cursor in same place */ 7403 if (msg_col >= Columns) /* Columns got smaller */ 7404 msg_col = Columns - 1; /* put cursor at last column */ 7405 } 7406 #endif 7407 7408 entered = FALSE; 7409 --RedrawingDisabled; 7410 7411 #ifdef FEAT_AUTOCMD 7412 if (starting == 0) 7413 apply_autocmds(EVENT_VIMRESIZED, NULL, NULL, FALSE, curbuf); 7414 #endif 7415 } 7416 7417 void 7418 free_screenlines() 7419 { 7420 #ifdef FEAT_MBYTE 7421 int i; 7422 7423 vim_free(ScreenLinesUC); 7424 for (i = 0; i < Screen_mco; ++i) 7425 vim_free(ScreenLinesC[i]); 7426 vim_free(ScreenLines2); 7427 #endif 7428 vim_free(ScreenLines); 7429 vim_free(ScreenAttrs); 7430 vim_free(LineOffset); 7431 vim_free(LineWraps); 7432 #ifdef FEAT_WINDOWS 7433 vim_free(TabPageIdxs); 7434 #endif 7435 } 7436 7437 void 7438 screenclear() 7439 { 7440 check_for_delay(FALSE); 7441 screenalloc(FALSE); /* allocate screen buffers if size changed */ 7442 screenclear2(); /* clear the screen */ 7443 } 7444 7445 static void 7446 screenclear2() 7447 { 7448 int i; 7449 7450 if (starting == NO_SCREEN || ScreenLines == NULL 7451 #ifdef FEAT_GUI 7452 || (gui.in_use && gui.starting) 7453 #endif 7454 ) 7455 return; 7456 7457 #ifdef FEAT_GUI 7458 if (!gui.in_use) 7459 #endif 7460 screen_attr = -1; /* force setting the Normal colors */ 7461 screen_stop_highlight(); /* don't want highlighting here */ 7462 7463 #ifdef FEAT_CLIPBOARD 7464 /* disable selection without redrawing it */ 7465 clip_scroll_selection(9999); 7466 #endif 7467 7468 /* blank out ScreenLines */ 7469 for (i = 0; i < Rows; ++i) 7470 { 7471 lineclear(LineOffset[i], (int)Columns); 7472 LineWraps[i] = FALSE; 7473 } 7474 7475 if (can_clear(T_CL)) 7476 { 7477 out_str(T_CL); /* clear the display */ 7478 clear_cmdline = FALSE; 7479 mode_displayed = FALSE; 7480 } 7481 else 7482 { 7483 /* can't clear the screen, mark all chars with invalid attributes */ 7484 for (i = 0; i < Rows; ++i) 7485 lineinvalid(LineOffset[i], (int)Columns); 7486 clear_cmdline = TRUE; 7487 } 7488 7489 screen_cleared = TRUE; /* can use contents of ScreenLines now */ 7490 7491 win_rest_invalid(firstwin); 7492 redraw_cmdline = TRUE; 7493 #ifdef FEAT_WINDOWS 7494 redraw_tabline = TRUE; 7495 #endif 7496 if (must_redraw == CLEAR) /* no need to clear again */ 7497 must_redraw = NOT_VALID; 7498 compute_cmdrow(); 7499 msg_row = cmdline_row; /* put cursor on last line for messages */ 7500 msg_col = 0; 7501 screen_start(); /* don't know where cursor is now */ 7502 msg_scrolled = 0; /* can't scroll back */ 7503 msg_didany = FALSE; 7504 msg_didout = FALSE; 7505 } 7506 7507 /* 7508 * Clear one line in ScreenLines. 7509 */ 7510 static void 7511 lineclear(off, width) 7512 unsigned off; 7513 int width; 7514 { 7515 (void)vim_memset(ScreenLines + off, ' ', (size_t)width * sizeof(schar_T)); 7516 #ifdef FEAT_MBYTE 7517 if (enc_utf8) 7518 (void)vim_memset(ScreenLinesUC + off, 0, 7519 (size_t)width * sizeof(u8char_T)); 7520 #endif 7521 (void)vim_memset(ScreenAttrs + off, 0, (size_t)width * sizeof(sattr_T)); 7522 } 7523 7524 /* 7525 * Mark one line in ScreenLines invalid by setting the attributes to an 7526 * invalid value. 7527 */ 7528 static void 7529 lineinvalid(off, width) 7530 unsigned off; 7531 int width; 7532 { 7533 (void)vim_memset(ScreenAttrs + off, -1, (size_t)width * sizeof(sattr_T)); 7534 } 7535 7536 #ifdef FEAT_VERTSPLIT 7537 /* 7538 * Copy part of a Screenline for vertically split window "wp". 7539 */ 7540 static void 7541 linecopy(to, from, wp) 7542 int to; 7543 int from; 7544 win_T *wp; 7545 { 7546 unsigned off_to = LineOffset[to] + wp->w_wincol; 7547 unsigned off_from = LineOffset[from] + wp->w_wincol; 7548 7549 mch_memmove(ScreenLines + off_to, ScreenLines + off_from, 7550 wp->w_width * sizeof(schar_T)); 7551 # ifdef FEAT_MBYTE 7552 if (enc_utf8) 7553 { 7554 int i; 7555 7556 mch_memmove(ScreenLinesUC + off_to, ScreenLinesUC + off_from, 7557 wp->w_width * sizeof(u8char_T)); 7558 for (i = 0; i < p_mco; ++i) 7559 mch_memmove(ScreenLinesC[i] + off_to, ScreenLinesC[i] + off_from, 7560 wp->w_width * sizeof(u8char_T)); 7561 } 7562 if (enc_dbcs == DBCS_JPNU) 7563 mch_memmove(ScreenLines2 + off_to, ScreenLines2 + off_from, 7564 wp->w_width * sizeof(schar_T)); 7565 # endif 7566 mch_memmove(ScreenAttrs + off_to, ScreenAttrs + off_from, 7567 wp->w_width * sizeof(sattr_T)); 7568 } 7569 #endif 7570 7571 /* 7572 * Return TRUE if clearing with term string "p" would work. 7573 * It can't work when the string is empty or it won't set the right background. 7574 */ 7575 int 7576 can_clear(p) 7577 char_u *p; 7578 { 7579 return (*p != NUL && (t_colors <= 1 7580 #ifdef FEAT_GUI 7581 || gui.in_use 7582 #endif 7583 || cterm_normal_bg_color == 0 || *T_UT != NUL)); 7584 } 7585 7586 /* 7587 * Reset cursor position. Use whenever cursor was moved because of outputting 7588 * something directly to the screen (shell commands) or a terminal control 7589 * code. 7590 */ 7591 void 7592 screen_start() 7593 { 7594 screen_cur_row = screen_cur_col = 9999; 7595 } 7596 7597 /* 7598 * Move the cursor to position "row","col" in the screen. 7599 * This tries to find the most efficient way to move, minimizing the number of 7600 * characters sent to the terminal. 7601 */ 7602 void 7603 windgoto(row, col) 7604 int row; 7605 int col; 7606 { 7607 sattr_T *p; 7608 int i; 7609 int plan; 7610 int cost; 7611 int wouldbe_col; 7612 int noinvcurs; 7613 char_u *bs; 7614 int goto_cost; 7615 int attr; 7616 7617 #define GOTO_COST 7 /* asssume a term_windgoto() takes about 7 chars */ 7618 #define HIGHL_COST 5 /* assume unhighlight takes 5 chars */ 7619 7620 #define PLAN_LE 1 7621 #define PLAN_CR 2 7622 #define PLAN_NL 3 7623 #define PLAN_WRITE 4 7624 /* Can't use ScreenLines unless initialized */ 7625 if (ScreenLines == NULL) 7626 return; 7627 7628 if (col != screen_cur_col || row != screen_cur_row) 7629 { 7630 /* Check for valid position. */ 7631 if (row < 0) /* window without text lines? */ 7632 row = 0; 7633 if (row >= screen_Rows) 7634 row = screen_Rows - 1; 7635 if (col >= screen_Columns) 7636 col = screen_Columns - 1; 7637 7638 /* check if no cursor movement is allowed in highlight mode */ 7639 if (screen_attr && *T_MS == NUL) 7640 noinvcurs = HIGHL_COST; 7641 else 7642 noinvcurs = 0; 7643 goto_cost = GOTO_COST + noinvcurs; 7644 7645 /* 7646 * Plan how to do the positioning: 7647 * 1. Use CR to move it to column 0, same row. 7648 * 2. Use T_LE to move it a few columns to the left. 7649 * 3. Use NL to move a few lines down, column 0. 7650 * 4. Move a few columns to the right with T_ND or by writing chars. 7651 * 7652 * Don't do this if the cursor went beyond the last column, the cursor 7653 * position is unknown then (some terminals wrap, some don't ) 7654 * 7655 * First check if the highlighting attibutes allow us to write 7656 * characters to move the cursor to the right. 7657 */ 7658 if (row >= screen_cur_row && screen_cur_col < Columns) 7659 { 7660 /* 7661 * If the cursor is in the same row, bigger col, we can use CR 7662 * or T_LE. 7663 */ 7664 bs = NULL; /* init for GCC */ 7665 attr = screen_attr; 7666 if (row == screen_cur_row && col < screen_cur_col) 7667 { 7668 /* "le" is preferred over "bc", because "bc" is obsolete */ 7669 if (*T_LE) 7670 bs = T_LE; /* "cursor left" */ 7671 else 7672 bs = T_BC; /* "backspace character (old) */ 7673 if (*bs) 7674 cost = (screen_cur_col - col) * (int)STRLEN(bs); 7675 else 7676 cost = 999; 7677 if (col + 1 < cost) /* using CR is less characters */ 7678 { 7679 plan = PLAN_CR; 7680 wouldbe_col = 0; 7681 cost = 1; /* CR is just one character */ 7682 } 7683 else 7684 { 7685 plan = PLAN_LE; 7686 wouldbe_col = col; 7687 } 7688 if (noinvcurs) /* will stop highlighting */ 7689 { 7690 cost += noinvcurs; 7691 attr = 0; 7692 } 7693 } 7694 7695 /* 7696 * If the cursor is above where we want to be, we can use CR LF. 7697 */ 7698 else if (row > screen_cur_row) 7699 { 7700 plan = PLAN_NL; 7701 wouldbe_col = 0; 7702 cost = (row - screen_cur_row) * 2; /* CR LF */ 7703 if (noinvcurs) /* will stop highlighting */ 7704 { 7705 cost += noinvcurs; 7706 attr = 0; 7707 } 7708 } 7709 7710 /* 7711 * If the cursor is in the same row, smaller col, just use write. 7712 */ 7713 else 7714 { 7715 plan = PLAN_WRITE; 7716 wouldbe_col = screen_cur_col; 7717 cost = 0; 7718 } 7719 7720 /* 7721 * Check if any characters that need to be written have the 7722 * correct attributes. Also avoid UTF-8 characters. 7723 */ 7724 i = col - wouldbe_col; 7725 if (i > 0) 7726 cost += i; 7727 if (cost < goto_cost && i > 0) 7728 { 7729 /* 7730 * Check if the attributes are correct without additionally 7731 * stopping highlighting. 7732 */ 7733 p = ScreenAttrs + LineOffset[row] + wouldbe_col; 7734 while (i && *p++ == attr) 7735 --i; 7736 if (i != 0) 7737 { 7738 /* 7739 * Try if it works when highlighting is stopped here. 7740 */ 7741 if (*--p == 0) 7742 { 7743 cost += noinvcurs; 7744 while (i && *p++ == 0) 7745 --i; 7746 } 7747 if (i != 0) 7748 cost = 999; /* different attributes, don't do it */ 7749 } 7750 #ifdef FEAT_MBYTE 7751 if (enc_utf8) 7752 { 7753 /* Don't use an UTF-8 char for positioning, it's slow. */ 7754 for (i = wouldbe_col; i < col; ++i) 7755 if (ScreenLinesUC[LineOffset[row] + i] != 0) 7756 { 7757 cost = 999; 7758 break; 7759 } 7760 } 7761 #endif 7762 } 7763 7764 /* 7765 * We can do it without term_windgoto()! 7766 */ 7767 if (cost < goto_cost) 7768 { 7769 if (plan == PLAN_LE) 7770 { 7771 if (noinvcurs) 7772 screen_stop_highlight(); 7773 while (screen_cur_col > col) 7774 { 7775 out_str(bs); 7776 --screen_cur_col; 7777 } 7778 } 7779 else if (plan == PLAN_CR) 7780 { 7781 if (noinvcurs) 7782 screen_stop_highlight(); 7783 out_char('\r'); 7784 screen_cur_col = 0; 7785 } 7786 else if (plan == PLAN_NL) 7787 { 7788 if (noinvcurs) 7789 screen_stop_highlight(); 7790 while (screen_cur_row < row) 7791 { 7792 out_char('\n'); 7793 ++screen_cur_row; 7794 } 7795 screen_cur_col = 0; 7796 } 7797 7798 i = col - screen_cur_col; 7799 if (i > 0) 7800 { 7801 /* 7802 * Use cursor-right if it's one character only. Avoids 7803 * removing a line of pixels from the last bold char, when 7804 * using the bold trick in the GUI. 7805 */ 7806 if (T_ND[0] != NUL && T_ND[1] == NUL) 7807 { 7808 while (i-- > 0) 7809 out_char(*T_ND); 7810 } 7811 else 7812 { 7813 int off; 7814 7815 off = LineOffset[row] + screen_cur_col; 7816 while (i-- > 0) 7817 { 7818 if (ScreenAttrs[off] != screen_attr) 7819 screen_stop_highlight(); 7820 #ifdef FEAT_MBYTE 7821 out_flush_check(); 7822 #endif 7823 out_char(ScreenLines[off]); 7824 #ifdef FEAT_MBYTE 7825 if (enc_dbcs == DBCS_JPNU 7826 && ScreenLines[off] == 0x8e) 7827 out_char(ScreenLines2[off]); 7828 #endif 7829 ++off; 7830 } 7831 } 7832 } 7833 } 7834 } 7835 else 7836 cost = 999; 7837 7838 if (cost >= goto_cost) 7839 { 7840 if (noinvcurs) 7841 screen_stop_highlight(); 7842 if (row == screen_cur_row && (col > screen_cur_col) && 7843 *T_CRI != NUL) 7844 term_cursor_right(col - screen_cur_col); 7845 else 7846 term_windgoto(row, col); 7847 } 7848 screen_cur_row = row; 7849 screen_cur_col = col; 7850 } 7851 } 7852 7853 /* 7854 * Set cursor to its position in the current window. 7855 */ 7856 void 7857 setcursor() 7858 { 7859 if (redrawing()) 7860 { 7861 validate_cursor(); 7862 windgoto(W_WINROW(curwin) + curwin->w_wrow, 7863 W_WINCOL(curwin) + ( 7864 #ifdef FEAT_RIGHTLEFT 7865 curwin->w_p_rl ? ((int)W_WIDTH(curwin) - curwin->w_wcol - ( 7866 # ifdef FEAT_MBYTE 7867 has_mbyte ? (*mb_ptr2cells)(ml_get_cursor()) : 7868 # endif 7869 1)) : 7870 #endif 7871 curwin->w_wcol)); 7872 } 7873 } 7874 7875 7876 /* 7877 * insert 'line_count' lines at 'row' in window 'wp' 7878 * if 'invalid' is TRUE the wp->w_lines[].wl_lnum is invalidated. 7879 * if 'mayclear' is TRUE the screen will be cleared if it is faster than 7880 * scrolling. 7881 * Returns FAIL if the lines are not inserted, OK for success. 7882 */ 7883 int 7884 win_ins_lines(wp, row, line_count, invalid, mayclear) 7885 win_T *wp; 7886 int row; 7887 int line_count; 7888 int invalid; 7889 int mayclear; 7890 { 7891 int did_delete; 7892 int nextrow; 7893 int lastrow; 7894 int retval; 7895 7896 if (invalid) 7897 wp->w_lines_valid = 0; 7898 7899 if (wp->w_height < 5) 7900 return FAIL; 7901 7902 if (line_count > wp->w_height - row) 7903 line_count = wp->w_height - row; 7904 7905 retval = win_do_lines(wp, row, line_count, mayclear, FALSE); 7906 if (retval != MAYBE) 7907 return retval; 7908 7909 /* 7910 * If there is a next window or a status line, we first try to delete the 7911 * lines at the bottom to avoid messing what is after the window. 7912 * If this fails and there are following windows, don't do anything to avoid 7913 * messing up those windows, better just redraw. 7914 */ 7915 did_delete = FALSE; 7916 #ifdef FEAT_WINDOWS 7917 if (wp->w_next != NULL || wp->w_status_height) 7918 { 7919 if (screen_del_lines(0, W_WINROW(wp) + wp->w_height - line_count, 7920 line_count, (int)Rows, FALSE, NULL) == OK) 7921 did_delete = TRUE; 7922 else if (wp->w_next) 7923 return FAIL; 7924 } 7925 #endif 7926 /* 7927 * if no lines deleted, blank the lines that will end up below the window 7928 */ 7929 if (!did_delete) 7930 { 7931 #ifdef FEAT_WINDOWS 7932 wp->w_redr_status = TRUE; 7933 #endif 7934 redraw_cmdline = TRUE; 7935 nextrow = W_WINROW(wp) + wp->w_height + W_STATUS_HEIGHT(wp); 7936 lastrow = nextrow + line_count; 7937 if (lastrow > Rows) 7938 lastrow = Rows; 7939 screen_fill(nextrow - line_count, lastrow - line_count, 7940 W_WINCOL(wp), (int)W_ENDCOL(wp), 7941 ' ', ' ', 0); 7942 } 7943 7944 if (screen_ins_lines(0, W_WINROW(wp) + row, line_count, (int)Rows, NULL) 7945 == FAIL) 7946 { 7947 /* deletion will have messed up other windows */ 7948 if (did_delete) 7949 { 7950 #ifdef FEAT_WINDOWS 7951 wp->w_redr_status = TRUE; 7952 #endif 7953 win_rest_invalid(W_NEXT(wp)); 7954 } 7955 return FAIL; 7956 } 7957 7958 return OK; 7959 } 7960 7961 /* 7962 * delete "line_count" window lines at "row" in window "wp" 7963 * If "invalid" is TRUE curwin->w_lines[] is invalidated. 7964 * If "mayclear" is TRUE the screen will be cleared if it is faster than 7965 * scrolling 7966 * Return OK for success, FAIL if the lines are not deleted. 7967 */ 7968 int 7969 win_del_lines(wp, row, line_count, invalid, mayclear) 7970 win_T *wp; 7971 int row; 7972 int line_count; 7973 int invalid; 7974 int mayclear; 7975 { 7976 int retval; 7977 7978 if (invalid) 7979 wp->w_lines_valid = 0; 7980 7981 if (line_count > wp->w_height - row) 7982 line_count = wp->w_height - row; 7983 7984 retval = win_do_lines(wp, row, line_count, mayclear, TRUE); 7985 if (retval != MAYBE) 7986 return retval; 7987 7988 if (screen_del_lines(0, W_WINROW(wp) + row, line_count, 7989 (int)Rows, FALSE, NULL) == FAIL) 7990 return FAIL; 7991 7992 #ifdef FEAT_WINDOWS 7993 /* 7994 * If there are windows or status lines below, try to put them at the 7995 * correct place. If we can't do that, they have to be redrawn. 7996 */ 7997 if (wp->w_next || wp->w_status_height || cmdline_row < Rows - 1) 7998 { 7999 if (screen_ins_lines(0, W_WINROW(wp) + wp->w_height - line_count, 8000 line_count, (int)Rows, NULL) == FAIL) 8001 { 8002 wp->w_redr_status = TRUE; 8003 win_rest_invalid(wp->w_next); 8004 } 8005 } 8006 /* 8007 * If this is the last window and there is no status line, redraw the 8008 * command line later. 8009 */ 8010 else 8011 #endif 8012 redraw_cmdline = TRUE; 8013 return OK; 8014 } 8015 8016 /* 8017 * Common code for win_ins_lines() and win_del_lines(). 8018 * Returns OK or FAIL when the work has been done. 8019 * Returns MAYBE when not finished yet. 8020 */ 8021 static int 8022 win_do_lines(wp, row, line_count, mayclear, del) 8023 win_T *wp; 8024 int row; 8025 int line_count; 8026 int mayclear; 8027 int del; 8028 { 8029 int retval; 8030 8031 if (!redrawing() || line_count <= 0) 8032 return FAIL; 8033 8034 /* only a few lines left: redraw is faster */ 8035 if (mayclear && Rows - line_count < 5 8036 #ifdef FEAT_VERTSPLIT 8037 && wp->w_width == Columns 8038 #endif 8039 ) 8040 { 8041 screenclear(); /* will set wp->w_lines_valid to 0 */ 8042 return FAIL; 8043 } 8044 8045 /* 8046 * Delete all remaining lines 8047 */ 8048 if (row + line_count >= wp->w_height) 8049 { 8050 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + wp->w_height, 8051 W_WINCOL(wp), (int)W_ENDCOL(wp), 8052 ' ', ' ', 0); 8053 return OK; 8054 } 8055 8056 /* 8057 * when scrolling, the message on the command line should be cleared, 8058 * otherwise it will stay there forever. 8059 */ 8060 clear_cmdline = TRUE; 8061 8062 /* 8063 * If the terminal can set a scroll region, use that. 8064 * Always do this in a vertically split window. This will redraw from 8065 * ScreenLines[] when t_CV isn't defined. That's faster than using 8066 * win_line(). 8067 * Don't use a scroll region when we are going to redraw the text, writing 8068 * a character in the lower right corner of the scroll region causes a 8069 * scroll-up in the DJGPP version. 8070 */ 8071 if (scroll_region 8072 #ifdef FEAT_VERTSPLIT 8073 || W_WIDTH(wp) != Columns 8074 #endif 8075 ) 8076 { 8077 #ifdef FEAT_VERTSPLIT 8078 if (scroll_region && (wp->w_width == Columns || *T_CSV != NUL)) 8079 #endif 8080 scroll_region_set(wp, row); 8081 if (del) 8082 retval = screen_del_lines(W_WINROW(wp) + row, 0, line_count, 8083 wp->w_height - row, FALSE, wp); 8084 else 8085 retval = screen_ins_lines(W_WINROW(wp) + row, 0, line_count, 8086 wp->w_height - row, wp); 8087 #ifdef FEAT_VERTSPLIT 8088 if (scroll_region && (wp->w_width == Columns || *T_CSV != NUL)) 8089 #endif 8090 scroll_region_reset(); 8091 return retval; 8092 } 8093 8094 #ifdef FEAT_WINDOWS 8095 if (wp->w_next != NULL && p_tf) /* don't delete/insert on fast terminal */ 8096 return FAIL; 8097 #endif 8098 8099 return MAYBE; 8100 } 8101 8102 /* 8103 * window 'wp' and everything after it is messed up, mark it for redraw 8104 */ 8105 static void 8106 win_rest_invalid(wp) 8107 win_T *wp; 8108 { 8109 #ifdef FEAT_WINDOWS 8110 while (wp != NULL) 8111 #else 8112 if (wp != NULL) 8113 #endif 8114 { 8115 redraw_win_later(wp, NOT_VALID); 8116 #ifdef FEAT_WINDOWS 8117 wp->w_redr_status = TRUE; 8118 wp = wp->w_next; 8119 #endif 8120 } 8121 redraw_cmdline = TRUE; 8122 } 8123 8124 /* 8125 * The rest of the routines in this file perform screen manipulations. The 8126 * given operation is performed physically on the screen. The corresponding 8127 * change is also made to the internal screen image. In this way, the editor 8128 * anticipates the effect of editing changes on the appearance of the screen. 8129 * That way, when we call screenupdate a complete redraw isn't usually 8130 * necessary. Another advantage is that we can keep adding code to anticipate 8131 * screen changes, and in the meantime, everything still works. 8132 */ 8133 8134 /* 8135 * types for inserting or deleting lines 8136 */ 8137 #define USE_T_CAL 1 8138 #define USE_T_CDL 2 8139 #define USE_T_AL 3 8140 #define USE_T_CE 4 8141 #define USE_T_DL 5 8142 #define USE_T_SR 6 8143 #define USE_NL 7 8144 #define USE_T_CD 8 8145 #define USE_REDRAW 9 8146 8147 /* 8148 * insert lines on the screen and update ScreenLines[] 8149 * 'end' is the line after the scrolled part. Normally it is Rows. 8150 * When scrolling region used 'off' is the offset from the top for the region. 8151 * 'row' and 'end' are relative to the start of the region. 8152 * 8153 * return FAIL for failure, OK for success. 8154 */ 8155 int 8156 screen_ins_lines(off, row, line_count, end, wp) 8157 int off; 8158 int row; 8159 int line_count; 8160 int end; 8161 win_T *wp; /* NULL or window to use width from */ 8162 { 8163 int i; 8164 int j; 8165 unsigned temp; 8166 int cursor_row; 8167 int type; 8168 int result_empty; 8169 int can_ce = can_clear(T_CE); 8170 8171 /* 8172 * FAIL if 8173 * - there is no valid screen 8174 * - the screen has to be redrawn completely 8175 * - the line count is less than one 8176 * - the line count is more than 'ttyscroll' 8177 */ 8178 if (!screen_valid(TRUE) || line_count <= 0 || line_count > p_ttyscroll) 8179 return FAIL; 8180 8181 /* 8182 * There are seven ways to insert lines: 8183 * 0. When in a vertically split window and t_CV isn't set, redraw the 8184 * characters from ScreenLines[]. 8185 * 1. Use T_CD (clear to end of display) if it exists and the result of 8186 * the insert is just empty lines 8187 * 2. Use T_CAL (insert multiple lines) if it exists and T_AL is not 8188 * present or line_count > 1. It looks better if we do all the inserts 8189 * at once. 8190 * 3. Use T_CDL (delete multiple lines) if it exists and the result of the 8191 * insert is just empty lines and T_CE is not present or line_count > 8192 * 1. 8193 * 4. Use T_AL (insert line) if it exists. 8194 * 5. Use T_CE (erase line) if it exists and the result of the insert is 8195 * just empty lines. 8196 * 6. Use T_DL (delete line) if it exists and the result of the insert is 8197 * just empty lines. 8198 * 7. Use T_SR (scroll reverse) if it exists and inserting at row 0 and 8199 * the 'da' flag is not set or we have clear line capability. 8200 * 8. redraw the characters from ScreenLines[]. 8201 * 8202 * Careful: In a hpterm scroll reverse doesn't work as expected, it moves 8203 * the scrollbar for the window. It does have insert line, use that if it 8204 * exists. 8205 */ 8206 result_empty = (row + line_count >= end); 8207 #ifdef FEAT_VERTSPLIT 8208 if (wp != NULL && wp->w_width != Columns && *T_CSV == NUL) 8209 type = USE_REDRAW; 8210 else 8211 #endif 8212 if (can_clear(T_CD) && result_empty) 8213 type = USE_T_CD; 8214 else if (*T_CAL != NUL && (line_count > 1 || *T_AL == NUL)) 8215 type = USE_T_CAL; 8216 else if (*T_CDL != NUL && result_empty && (line_count > 1 || !can_ce)) 8217 type = USE_T_CDL; 8218 else if (*T_AL != NUL) 8219 type = USE_T_AL; 8220 else if (can_ce && result_empty) 8221 type = USE_T_CE; 8222 else if (*T_DL != NUL && result_empty) 8223 type = USE_T_DL; 8224 else if (*T_SR != NUL && row == 0 && (*T_DA == NUL || can_ce)) 8225 type = USE_T_SR; 8226 else 8227 return FAIL; 8228 8229 /* 8230 * For clearing the lines screen_del_lines() is used. This will also take 8231 * care of t_db if necessary. 8232 */ 8233 if (type == USE_T_CD || type == USE_T_CDL || 8234 type == USE_T_CE || type == USE_T_DL) 8235 return screen_del_lines(off, row, line_count, end, FALSE, wp); 8236 8237 /* 8238 * If text is retained below the screen, first clear or delete as many 8239 * lines at the bottom of the window as are about to be inserted so that 8240 * the deleted lines won't later surface during a screen_del_lines. 8241 */ 8242 if (*T_DB) 8243 screen_del_lines(off, end - line_count, line_count, end, FALSE, wp); 8244 8245 #ifdef FEAT_CLIPBOARD 8246 /* Remove a modeless selection when inserting lines halfway the screen 8247 * or not the full width of the screen. */ 8248 if (off + row > 0 8249 # ifdef FEAT_VERTSPLIT 8250 || (wp != NULL && wp->w_width != Columns) 8251 # endif 8252 ) 8253 clip_clear_selection(); 8254 else 8255 clip_scroll_selection(-line_count); 8256 #endif 8257 8258 #ifdef FEAT_GUI 8259 /* Don't update the GUI cursor here, ScreenLines[] is invalid until the 8260 * scrolling is actually carried out. */ 8261 gui_dont_update_cursor(); 8262 #endif 8263 8264 if (*T_CCS != NUL) /* cursor relative to region */ 8265 cursor_row = row; 8266 else 8267 cursor_row = row + off; 8268 8269 /* 8270 * Shift LineOffset[] line_count down to reflect the inserted lines. 8271 * Clear the inserted lines in ScreenLines[]. 8272 */ 8273 row += off; 8274 end += off; 8275 for (i = 0; i < line_count; ++i) 8276 { 8277 #ifdef FEAT_VERTSPLIT 8278 if (wp != NULL && wp->w_width != Columns) 8279 { 8280 /* need to copy part of a line */ 8281 j = end - 1 - i; 8282 while ((j -= line_count) >= row) 8283 linecopy(j + line_count, j, wp); 8284 j += line_count; 8285 if (can_clear((char_u *)" ")) 8286 lineclear(LineOffset[j] + wp->w_wincol, wp->w_width); 8287 else 8288 lineinvalid(LineOffset[j] + wp->w_wincol, wp->w_width); 8289 LineWraps[j] = FALSE; 8290 } 8291 else 8292 #endif 8293 { 8294 j = end - 1 - i; 8295 temp = LineOffset[j]; 8296 while ((j -= line_count) >= row) 8297 { 8298 LineOffset[j + line_count] = LineOffset[j]; 8299 LineWraps[j + line_count] = LineWraps[j]; 8300 } 8301 LineOffset[j + line_count] = temp; 8302 LineWraps[j + line_count] = FALSE; 8303 if (can_clear((char_u *)" ")) 8304 lineclear(temp, (int)Columns); 8305 else 8306 lineinvalid(temp, (int)Columns); 8307 } 8308 } 8309 8310 screen_stop_highlight(); 8311 windgoto(cursor_row, 0); 8312 8313 #ifdef FEAT_VERTSPLIT 8314 /* redraw the characters */ 8315 if (type == USE_REDRAW) 8316 redraw_block(row, end, wp); 8317 else 8318 #endif 8319 if (type == USE_T_CAL) 8320 { 8321 term_append_lines(line_count); 8322 screen_start(); /* don't know where cursor is now */ 8323 } 8324 else 8325 { 8326 for (i = 0; i < line_count; i++) 8327 { 8328 if (type == USE_T_AL) 8329 { 8330 if (i && cursor_row != 0) 8331 windgoto(cursor_row, 0); 8332 out_str(T_AL); 8333 } 8334 else /* type == USE_T_SR */ 8335 out_str(T_SR); 8336 screen_start(); /* don't know where cursor is now */ 8337 } 8338 } 8339 8340 /* 8341 * With scroll-reverse and 'da' flag set we need to clear the lines that 8342 * have been scrolled down into the region. 8343 */ 8344 if (type == USE_T_SR && *T_DA) 8345 { 8346 for (i = 0; i < line_count; ++i) 8347 { 8348 windgoto(off + i, 0); 8349 out_str(T_CE); 8350 screen_start(); /* don't know where cursor is now */ 8351 } 8352 } 8353 8354 #ifdef FEAT_GUI 8355 gui_can_update_cursor(); 8356 if (gui.in_use) 8357 out_flush(); /* always flush after a scroll */ 8358 #endif 8359 return OK; 8360 } 8361 8362 /* 8363 * delete lines on the screen and update ScreenLines[] 8364 * 'end' is the line after the scrolled part. Normally it is Rows. 8365 * When scrolling region used 'off' is the offset from the top for the region. 8366 * 'row' and 'end' are relative to the start of the region. 8367 * 8368 * Return OK for success, FAIL if the lines are not deleted. 8369 */ 8370 /*ARGSUSED*/ 8371 int 8372 screen_del_lines(off, row, line_count, end, force, wp) 8373 int off; 8374 int row; 8375 int line_count; 8376 int end; 8377 int force; /* even when line_count > p_ttyscroll */ 8378 win_T *wp; /* NULL or window to use width from */ 8379 { 8380 int j; 8381 int i; 8382 unsigned temp; 8383 int cursor_row; 8384 int cursor_end; 8385 int result_empty; /* result is empty until end of region */ 8386 int can_delete; /* deleting line codes can be used */ 8387 int type; 8388 8389 /* 8390 * FAIL if 8391 * - there is no valid screen 8392 * - the screen has to be redrawn completely 8393 * - the line count is less than one 8394 * - the line count is more than 'ttyscroll' 8395 */ 8396 if (!screen_valid(TRUE) || line_count <= 0 || 8397 (!force && line_count > p_ttyscroll)) 8398 return FAIL; 8399 8400 /* 8401 * Check if the rest of the current region will become empty. 8402 */ 8403 result_empty = row + line_count >= end; 8404 8405 /* 8406 * We can delete lines only when 'db' flag not set or when 'ce' option 8407 * available. 8408 */ 8409 can_delete = (*T_DB == NUL || can_clear(T_CE)); 8410 8411 /* 8412 * There are six ways to delete lines: 8413 * 0. When in a vertically split window and t_CV isn't set, redraw the 8414 * characters from ScreenLines[]. 8415 * 1. Use T_CD if it exists and the result is empty. 8416 * 2. Use newlines if row == 0 and count == 1 or T_CDL does not exist. 8417 * 3. Use T_CDL (delete multiple lines) if it exists and line_count > 1 or 8418 * none of the other ways work. 8419 * 4. Use T_CE (erase line) if the result is empty. 8420 * 5. Use T_DL (delete line) if it exists. 8421 * 6. redraw the characters from ScreenLines[]. 8422 */ 8423 #ifdef FEAT_VERTSPLIT 8424 if (wp != NULL && wp->w_width != Columns && *T_CSV == NUL) 8425 type = USE_REDRAW; 8426 else 8427 #endif 8428 if (can_clear(T_CD) && result_empty) 8429 type = USE_T_CD; 8430 #if defined(__BEOS__) && defined(BEOS_DR8) 8431 /* 8432 * USE_NL does not seem to work in Terminal of DR8 so we set T_DB="" in 8433 * its internal termcap... this works okay for tests which test *T_DB != 8434 * NUL. It has the disadvantage that the user cannot use any :set t_* 8435 * command to get T_DB (back) to empty_option, only :set term=... will do 8436 * the trick... 8437 * Anyway, this hack will hopefully go away with the next OS release. 8438 * (Olaf Seibert) 8439 */ 8440 else if (row == 0 && T_DB == empty_option 8441 && (line_count == 1 || *T_CDL == NUL)) 8442 #else 8443 else if (row == 0 && ( 8444 #ifndef AMIGA 8445 /* On the Amiga, somehow '\n' on the last line doesn't always scroll 8446 * up, so use delete-line command */ 8447 line_count == 1 || 8448 #endif 8449 *T_CDL == NUL)) 8450 #endif 8451 type = USE_NL; 8452 else if (*T_CDL != NUL && line_count > 1 && can_delete) 8453 type = USE_T_CDL; 8454 else if (can_clear(T_CE) && result_empty 8455 #ifdef FEAT_VERTSPLIT 8456 && (wp == NULL || wp->w_width == Columns) 8457 #endif 8458 ) 8459 type = USE_T_CE; 8460 else if (*T_DL != NUL && can_delete) 8461 type = USE_T_DL; 8462 else if (*T_CDL != NUL && can_delete) 8463 type = USE_T_CDL; 8464 else 8465 return FAIL; 8466 8467 #ifdef FEAT_CLIPBOARD 8468 /* Remove a modeless selection when deleting lines halfway the screen or 8469 * not the full width of the screen. */ 8470 if (off + row > 0 8471 # ifdef FEAT_VERTSPLIT 8472 || (wp != NULL && wp->w_width != Columns) 8473 # endif 8474 ) 8475 clip_clear_selection(); 8476 else 8477 clip_scroll_selection(line_count); 8478 #endif 8479 8480 #ifdef FEAT_GUI 8481 /* Don't update the GUI cursor here, ScreenLines[] is invalid until the 8482 * scrolling is actually carried out. */ 8483 gui_dont_update_cursor(); 8484 #endif 8485 8486 if (*T_CCS != NUL) /* cursor relative to region */ 8487 { 8488 cursor_row = row; 8489 cursor_end = end; 8490 } 8491 else 8492 { 8493 cursor_row = row + off; 8494 cursor_end = end + off; 8495 } 8496 8497 /* 8498 * Now shift LineOffset[] line_count up to reflect the deleted lines. 8499 * Clear the inserted lines in ScreenLines[]. 8500 */ 8501 row += off; 8502 end += off; 8503 for (i = 0; i < line_count; ++i) 8504 { 8505 #ifdef FEAT_VERTSPLIT 8506 if (wp != NULL && wp->w_width != Columns) 8507 { 8508 /* need to copy part of a line */ 8509 j = row + i; 8510 while ((j += line_count) <= end - 1) 8511 linecopy(j - line_count, j, wp); 8512 j -= line_count; 8513 if (can_clear((char_u *)" ")) 8514 lineclear(LineOffset[j] + wp->w_wincol, wp->w_width); 8515 else 8516 lineinvalid(LineOffset[j] + wp->w_wincol, wp->w_width); 8517 LineWraps[j] = FALSE; 8518 } 8519 else 8520 #endif 8521 { 8522 /* whole width, moving the line pointers is faster */ 8523 j = row + i; 8524 temp = LineOffset[j]; 8525 while ((j += line_count) <= end - 1) 8526 { 8527 LineOffset[j - line_count] = LineOffset[j]; 8528 LineWraps[j - line_count] = LineWraps[j]; 8529 } 8530 LineOffset[j - line_count] = temp; 8531 LineWraps[j - line_count] = FALSE; 8532 if (can_clear((char_u *)" ")) 8533 lineclear(temp, (int)Columns); 8534 else 8535 lineinvalid(temp, (int)Columns); 8536 } 8537 } 8538 8539 screen_stop_highlight(); 8540 8541 #ifdef FEAT_VERTSPLIT 8542 /* redraw the characters */ 8543 if (type == USE_REDRAW) 8544 redraw_block(row, end, wp); 8545 else 8546 #endif 8547 if (type == USE_T_CD) /* delete the lines */ 8548 { 8549 windgoto(cursor_row, 0); 8550 out_str(T_CD); 8551 screen_start(); /* don't know where cursor is now */ 8552 } 8553 else if (type == USE_T_CDL) 8554 { 8555 windgoto(cursor_row, 0); 8556 term_delete_lines(line_count); 8557 screen_start(); /* don't know where cursor is now */ 8558 } 8559 /* 8560 * Deleting lines at top of the screen or scroll region: Just scroll 8561 * the whole screen (scroll region) up by outputting newlines on the 8562 * last line. 8563 */ 8564 else if (type == USE_NL) 8565 { 8566 windgoto(cursor_end - 1, 0); 8567 for (i = line_count; --i >= 0; ) 8568 out_char('\n'); /* cursor will remain on same line */ 8569 } 8570 else 8571 { 8572 for (i = line_count; --i >= 0; ) 8573 { 8574 if (type == USE_T_DL) 8575 { 8576 windgoto(cursor_row, 0); 8577 out_str(T_DL); /* delete a line */ 8578 } 8579 else /* type == USE_T_CE */ 8580 { 8581 windgoto(cursor_row + i, 0); 8582 out_str(T_CE); /* erase a line */ 8583 } 8584 screen_start(); /* don't know where cursor is now */ 8585 } 8586 } 8587 8588 /* 8589 * If the 'db' flag is set, we need to clear the lines that have been 8590 * scrolled up at the bottom of the region. 8591 */ 8592 if (*T_DB && (type == USE_T_DL || type == USE_T_CDL)) 8593 { 8594 for (i = line_count; i > 0; --i) 8595 { 8596 windgoto(cursor_end - i, 0); 8597 out_str(T_CE); /* erase a line */ 8598 screen_start(); /* don't know where cursor is now */ 8599 } 8600 } 8601 8602 #ifdef FEAT_GUI 8603 gui_can_update_cursor(); 8604 if (gui.in_use) 8605 out_flush(); /* always flush after a scroll */ 8606 #endif 8607 8608 return OK; 8609 } 8610 8611 /* 8612 * show the current mode and ruler 8613 * 8614 * If clear_cmdline is TRUE, clear the rest of the cmdline. 8615 * If clear_cmdline is FALSE there may be a message there that needs to be 8616 * cleared only if a mode is shown. 8617 * Return the length of the message (0 if no message). 8618 */ 8619 int 8620 showmode() 8621 { 8622 int need_clear; 8623 int length = 0; 8624 int do_mode; 8625 int attr; 8626 int nwr_save; 8627 #ifdef FEAT_INS_EXPAND 8628 int sub_attr; 8629 #endif 8630 8631 do_mode = ((p_smd && msg_silent == 0) 8632 && ((State & INSERT) 8633 || restart_edit 8634 #ifdef FEAT_VISUAL 8635 || VIsual_active 8636 #endif 8637 )); 8638 if (do_mode || Recording) 8639 { 8640 /* 8641 * Don't show mode right now, when not redrawing or inside a mapping. 8642 * Call char_avail() only when we are going to show something, because 8643 * it takes a bit of time. 8644 */ 8645 if (!redrawing() || (char_avail() && !KeyTyped) || msg_silent != 0) 8646 { 8647 redraw_cmdline = TRUE; /* show mode later */ 8648 return 0; 8649 } 8650 8651 nwr_save = need_wait_return; 8652 8653 /* wait a bit before overwriting an important message */ 8654 check_for_delay(FALSE); 8655 8656 /* if the cmdline is more than one line high, erase top lines */ 8657 need_clear = clear_cmdline; 8658 if (clear_cmdline && cmdline_row < Rows - 1) 8659 msg_clr_cmdline(); /* will reset clear_cmdline */ 8660 8661 /* Position on the last line in the window, column 0 */ 8662 msg_pos_mode(); 8663 cursor_off(); 8664 attr = hl_attr(HLF_CM); /* Highlight mode */ 8665 if (do_mode) 8666 { 8667 MSG_PUTS_ATTR("--", attr); 8668 #if defined(FEAT_XIM) 8669 if (xic != NULL && im_get_status() && !p_imdisable 8670 && curbuf->b_p_iminsert == B_IMODE_IM) 8671 # ifdef HAVE_GTK2 /* most of the time, it's not XIM being used */ 8672 MSG_PUTS_ATTR(" IM", attr); 8673 # else 8674 MSG_PUTS_ATTR(" XIM", attr); 8675 # endif 8676 #endif 8677 #if defined(FEAT_HANGULIN) && defined(FEAT_GUI) 8678 if (gui.in_use) 8679 { 8680 if (hangul_input_state_get()) 8681 MSG_PUTS_ATTR(" \307\321\261\333", attr); /* HANGUL */ 8682 } 8683 #endif 8684 #ifdef FEAT_INS_EXPAND 8685 if (edit_submode != NULL) /* CTRL-X in Insert mode */ 8686 { 8687 /* These messages can get long, avoid a wrap in a narrow 8688 * window. Prefer showing edit_submode_extra. */ 8689 length = (Rows - msg_row) * Columns - 3; 8690 if (edit_submode_extra != NULL) 8691 length -= vim_strsize(edit_submode_extra); 8692 if (length > 0) 8693 { 8694 if (edit_submode_pre != NULL) 8695 length -= vim_strsize(edit_submode_pre); 8696 if (length - vim_strsize(edit_submode) > 0) 8697 { 8698 if (edit_submode_pre != NULL) 8699 msg_puts_attr(edit_submode_pre, attr); 8700 msg_puts_attr(edit_submode, attr); 8701 } 8702 if (edit_submode_extra != NULL) 8703 { 8704 MSG_PUTS_ATTR(" ", attr); /* add a space in between */ 8705 if ((int)edit_submode_highl < (int)HLF_COUNT) 8706 sub_attr = hl_attr(edit_submode_highl); 8707 else 8708 sub_attr = attr; 8709 msg_puts_attr(edit_submode_extra, sub_attr); 8710 } 8711 } 8712 length = 0; 8713 } 8714 else 8715 #endif 8716 { 8717 #ifdef FEAT_VREPLACE 8718 if (State & VREPLACE_FLAG) 8719 MSG_PUTS_ATTR(_(" VREPLACE"), attr); 8720 else 8721 #endif 8722 if (State & REPLACE_FLAG) 8723 MSG_PUTS_ATTR(_(" REPLACE"), attr); 8724 else if (State & INSERT) 8725 { 8726 #ifdef FEAT_RIGHTLEFT 8727 if (p_ri) 8728 MSG_PUTS_ATTR(_(" REVERSE"), attr); 8729 #endif 8730 MSG_PUTS_ATTR(_(" INSERT"), attr); 8731 } 8732 else if (restart_edit == 'I') 8733 MSG_PUTS_ATTR(_(" (insert)"), attr); 8734 else if (restart_edit == 'R') 8735 MSG_PUTS_ATTR(_(" (replace)"), attr); 8736 else if (restart_edit == 'V') 8737 MSG_PUTS_ATTR(_(" (vreplace)"), attr); 8738 #ifdef FEAT_RIGHTLEFT 8739 if (p_hkmap) 8740 MSG_PUTS_ATTR(_(" Hebrew"), attr); 8741 # ifdef FEAT_FKMAP 8742 if (p_fkmap) 8743 MSG_PUTS_ATTR(farsi_text_5, attr); 8744 # endif 8745 #endif 8746 #ifdef FEAT_KEYMAP 8747 if (State & LANGMAP) 8748 { 8749 # ifdef FEAT_ARABIC 8750 if (curwin->w_p_arab) 8751 MSG_PUTS_ATTR(_(" Arabic"), attr); 8752 else 8753 # endif 8754 MSG_PUTS_ATTR(_(" (lang)"), attr); 8755 } 8756 #endif 8757 if ((State & INSERT) && p_paste) 8758 MSG_PUTS_ATTR(_(" (paste)"), attr); 8759 8760 #ifdef FEAT_VISUAL 8761 if (VIsual_active) 8762 { 8763 char *p; 8764 8765 /* Don't concatenate separate words to avoid translation 8766 * problems. */ 8767 switch ((VIsual_select ? 4 : 0) 8768 + (VIsual_mode == Ctrl_V) * 2 8769 + (VIsual_mode == 'V')) 8770 { 8771 case 0: p = N_(" VISUAL"); break; 8772 case 1: p = N_(" VISUAL LINE"); break; 8773 case 2: p = N_(" VISUAL BLOCK"); break; 8774 case 4: p = N_(" SELECT"); break; 8775 case 5: p = N_(" SELECT LINE"); break; 8776 default: p = N_(" SELECT BLOCK"); break; 8777 } 8778 MSG_PUTS_ATTR(_(p), attr); 8779 } 8780 #endif 8781 MSG_PUTS_ATTR(" --", attr); 8782 } 8783 8784 need_clear = TRUE; 8785 } 8786 if (Recording 8787 #ifdef FEAT_INS_EXPAND 8788 && edit_submode == NULL /* otherwise it gets too long */ 8789 #endif 8790 ) 8791 { 8792 MSG_PUTS_ATTR(_("recording"), attr); 8793 need_clear = TRUE; 8794 } 8795 8796 mode_displayed = TRUE; 8797 if (need_clear || clear_cmdline) 8798 msg_clr_eos(); 8799 msg_didout = FALSE; /* overwrite this message */ 8800 length = msg_col; 8801 msg_col = 0; 8802 need_wait_return = nwr_save; /* never ask for hit-return for this */ 8803 } 8804 else if (clear_cmdline && msg_silent == 0) 8805 /* Clear the whole command line. Will reset "clear_cmdline". */ 8806 msg_clr_cmdline(); 8807 8808 #ifdef FEAT_CMDL_INFO 8809 # ifdef FEAT_VISUAL 8810 /* In Visual mode the size of the selected area must be redrawn. */ 8811 if (VIsual_active) 8812 clear_showcmd(); 8813 # endif 8814 8815 /* If the last window has no status line, the ruler is after the mode 8816 * message and must be redrawn */ 8817 if (redrawing() 8818 # ifdef FEAT_WINDOWS 8819 && lastwin->w_status_height == 0 8820 # endif 8821 ) 8822 win_redr_ruler(lastwin, TRUE); 8823 #endif 8824 redraw_cmdline = FALSE; 8825 clear_cmdline = FALSE; 8826 8827 return length; 8828 } 8829 8830 /* 8831 * Position for a mode message. 8832 */ 8833 static void 8834 msg_pos_mode() 8835 { 8836 msg_col = 0; 8837 msg_row = Rows - 1; 8838 } 8839 8840 /* 8841 * Delete mode message. Used when ESC is typed which is expected to end 8842 * Insert mode (but Insert mode didn't end yet!). 8843 * Caller should check "mode_displayed". 8844 */ 8845 void 8846 unshowmode(force) 8847 int force; 8848 { 8849 /* 8850 * Don't delete it right now, when not redrawing or insided a mapping. 8851 */ 8852 if (!redrawing() || (!force && char_avail() && !KeyTyped)) 8853 redraw_cmdline = TRUE; /* delete mode later */ 8854 else 8855 { 8856 msg_pos_mode(); 8857 if (Recording) 8858 MSG_PUTS_ATTR(_("recording"), hl_attr(HLF_CM)); 8859 msg_clr_eos(); 8860 } 8861 } 8862 8863 #if defined(FEAT_WINDOWS) 8864 /* 8865 * Draw the tab pages line at the top of the Vim window. 8866 */ 8867 static void 8868 draw_tabline() 8869 { 8870 int tabcount = 0; 8871 tabpage_T *tp; 8872 int tabwidth; 8873 int col = 0; 8874 int scol = 0; 8875 int attr; 8876 win_T *wp; 8877 win_T *cwp; 8878 int wincount; 8879 int modified; 8880 int c; 8881 int len; 8882 int attr_sel = hl_attr(HLF_TPS); 8883 int attr_nosel = hl_attr(HLF_TP); 8884 int attr_fill = hl_attr(HLF_TPF); 8885 char_u *p; 8886 int room; 8887 int use_sep_chars = (t_colors < 8 8888 #ifdef FEAT_GUI 8889 && !gui.in_use 8890 #endif 8891 ); 8892 8893 redraw_tabline = FALSE; 8894 8895 #ifdef FEAT_GUI_TABLINE 8896 /* Take care of a GUI tabline. */ 8897 if (gui_use_tabline()) 8898 { 8899 gui_update_tabline(); 8900 return; 8901 } 8902 #endif 8903 8904 if (tabline_height() < 1) 8905 return; 8906 8907 #if defined(FEAT_STL_OPT) 8908 8909 /* Init TabPageIdxs[] to zero: Clicking outside of tabs has no effect. */ 8910 for (scol = 0; scol < Columns; ++scol) 8911 TabPageIdxs[scol] = 0; 8912 8913 /* Use the 'tabline' option if it's set. */ 8914 if (*p_tal != NUL) 8915 { 8916 int save_called_emsg = called_emsg; 8917 8918 /* Check for an error. If there is one we would loop in redrawing the 8919 * screen. Avoid that by making 'tabline' empty. */ 8920 called_emsg = FALSE; 8921 win_redr_custom(NULL, FALSE); 8922 if (called_emsg) 8923 set_string_option_direct((char_u *)"tabline", -1, 8924 (char_u *)"", OPT_FREE, SID_ERROR); 8925 called_emsg |= save_called_emsg; 8926 } 8927 else 8928 #endif 8929 { 8930 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) 8931 ++tabcount; 8932 8933 tabwidth = (Columns - 1 + tabcount / 2) / tabcount; 8934 if (tabwidth < 6) 8935 tabwidth = 6; 8936 8937 attr = attr_nosel; 8938 tabcount = 0; 8939 scol = 0; 8940 for (tp = first_tabpage; tp != NULL && col < Columns - 4; 8941 tp = tp->tp_next) 8942 { 8943 scol = col; 8944 8945 if (tp->tp_topframe == topframe) 8946 attr = attr_sel; 8947 if (use_sep_chars && col > 0) 8948 screen_putchar('|', 0, col++, attr); 8949 8950 if (tp->tp_topframe != topframe) 8951 attr = attr_nosel; 8952 8953 screen_putchar(' ', 0, col++, attr); 8954 8955 if (tp == curtab) 8956 { 8957 cwp = curwin; 8958 wp = firstwin; 8959 } 8960 else 8961 { 8962 cwp = tp->tp_curwin; 8963 wp = tp->tp_firstwin; 8964 } 8965 8966 modified = FALSE; 8967 for (wincount = 0; wp != NULL; wp = wp->w_next, ++wincount) 8968 if (bufIsChanged(wp->w_buffer)) 8969 modified = TRUE; 8970 if (modified || wincount > 1) 8971 { 8972 if (wincount > 1) 8973 { 8974 vim_snprintf((char *)NameBuff, MAXPATHL, "%d", wincount); 8975 len = (int)STRLEN(NameBuff); 8976 if (col + len >= Columns - 3) 8977 break; 8978 screen_puts_len(NameBuff, len, 0, col, 8979 #if defined(FEAT_SYN_HL) 8980 hl_combine_attr(attr, hl_attr(HLF_T)) 8981 #else 8982 attr 8983 #endif 8984 ); 8985 col += len; 8986 } 8987 if (modified) 8988 screen_puts_len((char_u *)"+", 1, 0, col++, attr); 8989 screen_putchar(' ', 0, col++, attr); 8990 } 8991 8992 room = scol - col + tabwidth - 1; 8993 if (room > 0) 8994 { 8995 /* Get buffer name in NameBuff[] */ 8996 get_trans_bufname(cwp->w_buffer); 8997 shorten_dir(NameBuff); 8998 len = vim_strsize(NameBuff); 8999 p = NameBuff; 9000 #ifdef FEAT_MBYTE 9001 if (has_mbyte) 9002 while (len > room) 9003 { 9004 len -= ptr2cells(p); 9005 mb_ptr_adv(p); 9006 } 9007 else 9008 #endif 9009 if (len > room) 9010 { 9011 p += len - room; 9012 len = room; 9013 } 9014 if (len > Columns - col - 1) 9015 len = Columns - col - 1; 9016 9017 screen_puts_len(p, (int)STRLEN(p), 0, col, attr); 9018 col += len; 9019 } 9020 screen_putchar(' ', 0, col++, attr); 9021 9022 /* Store the tab page number in TabPageIdxs[], so that 9023 * jump_to_mouse() knows where each one is. */ 9024 ++tabcount; 9025 while (scol < col) 9026 TabPageIdxs[scol++] = tabcount; 9027 } 9028 9029 if (use_sep_chars) 9030 c = '_'; 9031 else 9032 c = ' '; 9033 screen_fill(0, 1, col, (int)Columns, c, c, attr_fill); 9034 9035 /* Put an "X" for closing the current tab if there are several. */ 9036 if (first_tabpage->tp_next != NULL) 9037 { 9038 screen_putchar('X', 0, (int)Columns - 1, attr_nosel); 9039 TabPageIdxs[Columns - 1] = -999; 9040 } 9041 } 9042 9043 /* Reset the flag here again, in case evaluating 'tabline' causes it to be 9044 * set. */ 9045 redraw_tabline = FALSE; 9046 } 9047 9048 /* 9049 * Get buffer name for "buf" into NameBuff[]. 9050 * Takes care of special buffer names and translates special characters. 9051 */ 9052 void 9053 get_trans_bufname(buf) 9054 buf_T *buf; 9055 { 9056 if (buf_spname(buf) != NULL) 9057 STRCPY(NameBuff, buf_spname(buf)); 9058 else 9059 home_replace(buf, buf->b_fname, NameBuff, MAXPATHL, TRUE); 9060 trans_characters(NameBuff, MAXPATHL); 9061 } 9062 #endif 9063 9064 #if defined(FEAT_WINDOWS) || defined(FEAT_WILDMENU) || defined(FEAT_STL_OPT) 9065 /* 9066 * Get the character to use in a status line. Get its attributes in "*attr". 9067 */ 9068 static int 9069 fillchar_status(attr, is_curwin) 9070 int *attr; 9071 int is_curwin; 9072 { 9073 int fill; 9074 if (is_curwin) 9075 { 9076 *attr = hl_attr(HLF_S); 9077 fill = fill_stl; 9078 } 9079 else 9080 { 9081 *attr = hl_attr(HLF_SNC); 9082 fill = fill_stlnc; 9083 } 9084 /* Use fill when there is highlighting, and highlighting of current 9085 * window differs, or the fillchars differ, or this is not the 9086 * current window */ 9087 if (*attr != 0 && ((hl_attr(HLF_S) != hl_attr(HLF_SNC) 9088 || !is_curwin || firstwin == lastwin) 9089 || (fill_stl != fill_stlnc))) 9090 return fill; 9091 if (is_curwin) 9092 return '^'; 9093 return '='; 9094 } 9095 #endif 9096 9097 #ifdef FEAT_VERTSPLIT 9098 /* 9099 * Get the character to use in a separator between vertically split windows. 9100 * Get its attributes in "*attr". 9101 */ 9102 static int 9103 fillchar_vsep(attr) 9104 int *attr; 9105 { 9106 *attr = hl_attr(HLF_C); 9107 if (*attr == 0 && fill_vert == ' ') 9108 return '|'; 9109 else 9110 return fill_vert; 9111 } 9112 #endif 9113 9114 /* 9115 * Return TRUE if redrawing should currently be done. 9116 */ 9117 int 9118 redrawing() 9119 { 9120 return (!RedrawingDisabled 9121 && !(p_lz && char_avail() && !KeyTyped && !do_redraw)); 9122 } 9123 9124 /* 9125 * Return TRUE if printing messages should currently be done. 9126 */ 9127 int 9128 messaging() 9129 { 9130 return (!(p_lz && char_avail() && !KeyTyped)); 9131 } 9132 9133 /* 9134 * Show current status info in ruler and various other places 9135 * If always is FALSE, only show ruler if position has changed. 9136 */ 9137 void 9138 showruler(always) 9139 int always; 9140 { 9141 if (!always && !redrawing()) 9142 return; 9143 #ifdef FEAT_INS_EXPAND 9144 if (pum_visible()) 9145 { 9146 # ifdef FEAT_WINDOWS 9147 /* Don't redraw right now, do it later. */ 9148 curwin->w_redr_status = TRUE; 9149 # endif 9150 return; 9151 } 9152 #endif 9153 #if defined(FEAT_STL_OPT) && defined(FEAT_WINDOWS) 9154 if ((*p_stl != NUL || *curwin->w_p_stl != NUL) && curwin->w_status_height) 9155 { 9156 redraw_custum_statusline(curwin); 9157 } 9158 else 9159 #endif 9160 #ifdef FEAT_CMDL_INFO 9161 win_redr_ruler(curwin, always); 9162 #endif 9163 9164 #ifdef FEAT_TITLE 9165 if (need_maketitle 9166 # ifdef FEAT_STL_OPT 9167 || (p_icon && (stl_syntax & STL_IN_ICON)) 9168 || (p_title && (stl_syntax & STL_IN_TITLE)) 9169 # endif 9170 ) 9171 maketitle(); 9172 #endif 9173 } 9174 9175 #ifdef FEAT_CMDL_INFO 9176 static void 9177 win_redr_ruler(wp, always) 9178 win_T *wp; 9179 int always; 9180 { 9181 char_u buffer[70]; 9182 int row; 9183 int fillchar; 9184 int attr; 9185 int empty_line = FALSE; 9186 colnr_T virtcol; 9187 int i; 9188 int o; 9189 #ifdef FEAT_VERTSPLIT 9190 int this_ru_col; 9191 int off = 0; 9192 int width = Columns; 9193 # define WITH_OFF(x) x 9194 # define WITH_WIDTH(x) x 9195 #else 9196 # define WITH_OFF(x) 0 9197 # define WITH_WIDTH(x) Columns 9198 # define this_ru_col ru_col 9199 #endif 9200 9201 /* If 'ruler' off or redrawing disabled, don't do anything */ 9202 if (!p_ru) 9203 return; 9204 9205 /* 9206 * Check if cursor.lnum is valid, since win_redr_ruler() may be called 9207 * after deleting lines, before cursor.lnum is corrected. 9208 */ 9209 if (wp->w_cursor.lnum > wp->w_buffer->b_ml.ml_line_count) 9210 return; 9211 9212 #ifdef FEAT_INS_EXPAND 9213 /* Don't draw the ruler while doing insert-completion, it might overwrite 9214 * the (long) mode message. */ 9215 # ifdef FEAT_WINDOWS 9216 if (wp == lastwin && lastwin->w_status_height == 0) 9217 # endif 9218 if (edit_submode != NULL) 9219 return; 9220 /* Don't draw the ruler when the popup menu is visible, it may overlap. */ 9221 if (pum_visible()) 9222 return; 9223 #endif 9224 9225 #ifdef FEAT_STL_OPT 9226 if (*p_ruf) 9227 { 9228 int save_called_emsg = called_emsg; 9229 9230 called_emsg = FALSE; 9231 win_redr_custom(wp, TRUE); 9232 if (called_emsg) 9233 set_string_option_direct((char_u *)"rulerformat", -1, 9234 (char_u *)"", OPT_FREE, SID_ERROR); 9235 called_emsg |= save_called_emsg; 9236 return; 9237 } 9238 #endif 9239 9240 /* 9241 * Check if not in Insert mode and the line is empty (will show "0-1"). 9242 */ 9243 if (!(State & INSERT) 9244 && *ml_get_buf(wp->w_buffer, wp->w_cursor.lnum, FALSE) == NUL) 9245 empty_line = TRUE; 9246 9247 /* 9248 * Only draw the ruler when something changed. 9249 */ 9250 validate_virtcol_win(wp); 9251 if ( redraw_cmdline 9252 || always 9253 || wp->w_cursor.lnum != wp->w_ru_cursor.lnum 9254 || wp->w_cursor.col != wp->w_ru_cursor.col 9255 || wp->w_virtcol != wp->w_ru_virtcol 9256 #ifdef FEAT_VIRTUALEDIT 9257 || wp->w_cursor.coladd != wp->w_ru_cursor.coladd 9258 #endif 9259 || wp->w_topline != wp->w_ru_topline 9260 || wp->w_buffer->b_ml.ml_line_count != wp->w_ru_line_count 9261 #ifdef FEAT_DIFF 9262 || wp->w_topfill != wp->w_ru_topfill 9263 #endif 9264 || empty_line != wp->w_ru_empty) 9265 { 9266 cursor_off(); 9267 #ifdef FEAT_WINDOWS 9268 if (wp->w_status_height) 9269 { 9270 row = W_WINROW(wp) + wp->w_height; 9271 fillchar = fillchar_status(&attr, wp == curwin); 9272 # ifdef FEAT_VERTSPLIT 9273 off = W_WINCOL(wp); 9274 width = W_WIDTH(wp); 9275 # endif 9276 } 9277 else 9278 #endif 9279 { 9280 row = Rows - 1; 9281 fillchar = ' '; 9282 attr = 0; 9283 #ifdef FEAT_VERTSPLIT 9284 width = Columns; 9285 off = 0; 9286 #endif 9287 } 9288 9289 /* In list mode virtcol needs to be recomputed */ 9290 virtcol = wp->w_virtcol; 9291 if (wp->w_p_list && lcs_tab1 == NUL) 9292 { 9293 wp->w_p_list = FALSE; 9294 getvvcol(wp, &wp->w_cursor, NULL, &virtcol, NULL); 9295 wp->w_p_list = TRUE; 9296 } 9297 9298 /* 9299 * Some sprintfs return the length, some return a pointer. 9300 * To avoid portability problems we use strlen() here. 9301 */ 9302 sprintf((char *)buffer, "%ld,", 9303 (wp->w_buffer->b_ml.ml_flags & ML_EMPTY) 9304 ? 0L 9305 : (long)(wp->w_cursor.lnum)); 9306 col_print(buffer + STRLEN(buffer), 9307 empty_line ? 0 : (int)wp->w_cursor.col + 1, 9308 (int)virtcol + 1); 9309 9310 /* 9311 * Add a "50%" if there is room for it. 9312 * On the last line, don't print in the last column (scrolls the 9313 * screen up on some terminals). 9314 */ 9315 i = (int)STRLEN(buffer); 9316 get_rel_pos(wp, buffer + i + 1); 9317 o = i + vim_strsize(buffer + i + 1); 9318 #ifdef FEAT_WINDOWS 9319 if (wp->w_status_height == 0) /* can't use last char of screen */ 9320 #endif 9321 ++o; 9322 #ifdef FEAT_VERTSPLIT 9323 this_ru_col = ru_col - (Columns - width); 9324 if (this_ru_col < 0) 9325 this_ru_col = 0; 9326 #endif 9327 /* Never use more than half the window/screen width, leave the other 9328 * half for the filename. */ 9329 if (this_ru_col < (WITH_WIDTH(width) + 1) / 2) 9330 this_ru_col = (WITH_WIDTH(width) + 1) / 2; 9331 if (this_ru_col + o < WITH_WIDTH(width)) 9332 { 9333 while (this_ru_col + o < WITH_WIDTH(width)) 9334 { 9335 #ifdef FEAT_MBYTE 9336 if (has_mbyte) 9337 i += (*mb_char2bytes)(fillchar, buffer + i); 9338 else 9339 #endif 9340 buffer[i++] = fillchar; 9341 ++o; 9342 } 9343 get_rel_pos(wp, buffer + i); 9344 } 9345 /* Truncate at window boundary. */ 9346 #ifdef FEAT_MBYTE 9347 if (has_mbyte) 9348 { 9349 o = 0; 9350 for (i = 0; buffer[i] != NUL; i += (*mb_ptr2len)(buffer + i)) 9351 { 9352 o += (*mb_ptr2cells)(buffer + i); 9353 if (this_ru_col + o > WITH_WIDTH(width)) 9354 { 9355 buffer[i] = NUL; 9356 break; 9357 } 9358 } 9359 } 9360 else 9361 #endif 9362 if (this_ru_col + (int)STRLEN(buffer) > WITH_WIDTH(width)) 9363 buffer[WITH_WIDTH(width) - this_ru_col] = NUL; 9364 9365 screen_puts(buffer, row, this_ru_col + WITH_OFF(off), attr); 9366 i = redraw_cmdline; 9367 screen_fill(row, row + 1, 9368 this_ru_col + WITH_OFF(off) + (int)STRLEN(buffer), 9369 (int)(WITH_OFF(off) + WITH_WIDTH(width)), 9370 fillchar, fillchar, attr); 9371 /* don't redraw the cmdline because of showing the ruler */ 9372 redraw_cmdline = i; 9373 wp->w_ru_cursor = wp->w_cursor; 9374 wp->w_ru_virtcol = wp->w_virtcol; 9375 wp->w_ru_empty = empty_line; 9376 wp->w_ru_topline = wp->w_topline; 9377 wp->w_ru_line_count = wp->w_buffer->b_ml.ml_line_count; 9378 #ifdef FEAT_DIFF 9379 wp->w_ru_topfill = wp->w_topfill; 9380 #endif 9381 } 9382 } 9383 #endif 9384 9385 #if defined(FEAT_LINEBREAK) || defined(PROTO) 9386 /* 9387 * Return the width of the 'number' column. 9388 * Caller may need to check if 'number' is set. 9389 * Otherwise it depends on 'numberwidth' and the line count. 9390 */ 9391 int 9392 number_width(wp) 9393 win_T *wp; 9394 { 9395 int n; 9396 linenr_T lnum; 9397 9398 lnum = wp->w_buffer->b_ml.ml_line_count; 9399 if (lnum == wp->w_nrwidth_line_count) 9400 return wp->w_nrwidth_width; 9401 wp->w_nrwidth_line_count = lnum; 9402 9403 n = 0; 9404 do 9405 { 9406 lnum /= 10; 9407 ++n; 9408 } while (lnum > 0); 9409 9410 /* 'numberwidth' gives the minimal width plus one */ 9411 if (n < wp->w_p_nuw - 1) 9412 n = wp->w_p_nuw - 1; 9413 9414 wp->w_nrwidth_width = n; 9415 return n; 9416 } 9417 #endif 9418