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