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, hlf_T 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 hlf_T 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 * Only to be called when 'foldcolumn' > 0. 2394 */ 2395 static void 2396 fill_foldcolumn(p, wp, closed, lnum) 2397 char_u *p; 2398 win_T *wp; 2399 int closed; /* TRUE of FALSE */ 2400 linenr_T lnum; /* current line number */ 2401 { 2402 int i = 0; 2403 int level; 2404 int first_level; 2405 int empty; 2406 2407 /* Init to all spaces. */ 2408 copy_spaces(p, (size_t)wp->w_p_fdc); 2409 2410 level = win_foldinfo.fi_level; 2411 if (level > 0) 2412 { 2413 /* If there is only one column put more info in it. */ 2414 empty = (wp->w_p_fdc == 1) ? 0 : 1; 2415 2416 /* If the column is too narrow, we start at the lowest level that 2417 * fits and use numbers to indicated the depth. */ 2418 first_level = level - wp->w_p_fdc - closed + 1 + empty; 2419 if (first_level < 1) 2420 first_level = 1; 2421 2422 for (i = 0; i + empty < wp->w_p_fdc; ++i) 2423 { 2424 if (win_foldinfo.fi_lnum == lnum 2425 && first_level + i >= win_foldinfo.fi_low_level) 2426 p[i] = '-'; 2427 else if (first_level == 1) 2428 p[i] = '|'; 2429 else if (first_level + i <= 9) 2430 p[i] = '0' + first_level + i; 2431 else 2432 p[i] = '>'; 2433 if (first_level + i == level) 2434 break; 2435 } 2436 } 2437 if (closed) 2438 p[i >= wp->w_p_fdc ? i - 1 : i] = '+'; 2439 } 2440 #endif /* FEAT_FOLDING */ 2441 2442 /* 2443 * Display line "lnum" of window 'wp' on the screen. 2444 * Start at row "startrow", stop when "endrow" is reached. 2445 * wp->w_virtcol needs to be valid. 2446 * 2447 * Return the number of last row the line occupies. 2448 */ 2449 static int 2450 win_line(wp, lnum, startrow, endrow) 2451 win_T *wp; 2452 linenr_T lnum; 2453 int startrow; 2454 int endrow; 2455 { 2456 int col; /* visual column on screen */ 2457 unsigned off; /* offset in ScreenLines/ScreenAttrs */ 2458 int c = 0; /* init for GCC */ 2459 long vcol = 0; /* virtual column (for tabs) */ 2460 long vcol_prev = -1; /* "vcol" of previous character */ 2461 char_u *line; /* current line */ 2462 char_u *ptr; /* current position in "line" */ 2463 int row; /* row in the window, excl w_winrow */ 2464 int screen_row; /* row on the screen, incl w_winrow */ 2465 2466 char_u extra[18]; /* "%ld" and 'fdc' must fit in here */ 2467 int n_extra = 0; /* number of extra chars */ 2468 char_u *p_extra = NULL; /* string of extra chars */ 2469 int c_extra = NUL; /* extra chars, all the same */ 2470 int extra_attr = 0; /* attributes when n_extra != 0 */ 2471 static char_u *at_end_str = (char_u *)""; /* used for p_extra when 2472 displaying lcs_eol at end-of-line */ 2473 int lcs_eol_one = lcs_eol; /* lcs_eol until it's been used */ 2474 int lcs_prec_todo = lcs_prec; /* lcs_prec until it's been used */ 2475 2476 /* saved "extra" items for when draw_state becomes WL_LINE (again) */ 2477 int saved_n_extra = 0; 2478 char_u *saved_p_extra = NULL; 2479 int saved_c_extra = 0; 2480 int saved_char_attr = 0; 2481 2482 int n_attr = 0; /* chars with special attr */ 2483 int saved_attr2 = 0; /* char_attr saved for n_attr */ 2484 int n_attr3 = 0; /* chars with overruling special attr */ 2485 int saved_attr3 = 0; /* char_attr saved for n_attr3 */ 2486 2487 int n_skip = 0; /* nr of chars to skip for 'nowrap' */ 2488 2489 int fromcol, tocol; /* start/end of inverting */ 2490 int fromcol_prev = -2; /* start of inverting after cursor */ 2491 int noinvcur = FALSE; /* don't invert the cursor */ 2492 #ifdef FEAT_VISUAL 2493 pos_T *top, *bot; 2494 #endif 2495 pos_T pos; 2496 long v; 2497 2498 int char_attr = 0; /* attributes for next character */ 2499 int area_highlighting = FALSE; /* Visual or incsearch highlighting 2500 in this line */ 2501 int attr = 0; /* attributes for area highlighting */ 2502 int area_attr = 0; /* attributes desired by highlighting */ 2503 int search_attr = 0; /* attributes desired by 'hlsearch' */ 2504 #ifdef FEAT_SYN_HL 2505 int syntax_attr = 0; /* attributes desired by syntax */ 2506 int has_syntax = FALSE; /* this buffer has syntax highl. */ 2507 int save_did_emsg; 2508 int has_spell = FALSE; /* this buffer has spell checking */ 2509 # define SPWORDLEN 150 2510 char_u nextline[SPWORDLEN * 2];/* text with start of the next line */ 2511 int nextlinecol = 0; /* column where nextline[] starts */ 2512 int nextline_idx = 0; /* index in nextline[] where next line 2513 starts */ 2514 int spell_attr = 0; /* attributes desired by spelling */ 2515 int word_end = 0; /* last byte with same spell_attr */ 2516 static linenr_T checked_lnum = 0; /* line number for "checked_col" */ 2517 static int checked_col = 0; /* column in "checked_lnum" up to which 2518 * there are no spell errors */ 2519 static int cap_col = -1; /* column to check for Cap word */ 2520 static linenr_T capcol_lnum = 0; /* line number where "cap_col" used */ 2521 int cur_checked_col = 0; /* checked column for current line */ 2522 #endif 2523 int extra_check; /* has syntax or linebreak */ 2524 #ifdef FEAT_MBYTE 2525 int multi_attr = 0; /* attributes desired by multibyte */ 2526 int mb_l = 1; /* multi-byte byte length */ 2527 int mb_c = 0; /* decoded multi-byte character */ 2528 int mb_utf8 = FALSE; /* screen char is UTF-8 char */ 2529 int u8c_c1 = 0; /* first composing UTF-8 char */ 2530 int u8c_c2 = 0; /* second composing UTF-8 char */ 2531 #endif 2532 #ifdef FEAT_DIFF 2533 int filler_lines; /* nr of filler lines to be drawn */ 2534 int filler_todo; /* nr of filler lines still to do + 1 */ 2535 hlf_T diff_hlf = (hlf_T)0; /* type of diff highlighting */ 2536 int change_start = MAXCOL; /* first col of changed area */ 2537 int change_end = -1; /* last col of changed area */ 2538 #endif 2539 colnr_T trailcol = MAXCOL; /* start of trailing spaces */ 2540 #ifdef FEAT_LINEBREAK 2541 int need_showbreak = FALSE; 2542 #endif 2543 #if defined(FEAT_SIGNS) || (defined(FEAT_QUICKFIX) && defined(FEAT_WINDOWS)) 2544 # define LINE_ATTR 2545 int line_attr = 0; /* atrribute for the whole line */ 2546 #endif 2547 #ifdef FEAT_SEARCH_EXTRA 2548 match_T *shl; /* points to search_hl or match_hl */ 2549 #endif 2550 #ifdef FEAT_ARABIC 2551 int prev_c = 0; /* previous Arabic character */ 2552 int prev_c1 = 0; /* first composing char for prev_c */ 2553 #endif 2554 2555 /* draw_state: items that are drawn in sequence: */ 2556 #define WL_START 0 /* nothing done yet */ 2557 #ifdef FEAT_CMDWIN 2558 # define WL_CMDLINE WL_START + 1 /* cmdline window column */ 2559 #else 2560 # define WL_CMDLINE WL_START 2561 #endif 2562 #ifdef FEAT_FOLDING 2563 # define WL_FOLD WL_CMDLINE + 1 /* 'foldcolumn' */ 2564 #else 2565 # define WL_FOLD WL_CMDLINE 2566 #endif 2567 #ifdef FEAT_SIGNS 2568 # define WL_SIGN WL_FOLD + 1 /* column for signs */ 2569 #else 2570 # define WL_SIGN WL_FOLD /* column for signs */ 2571 #endif 2572 #define WL_NR WL_SIGN + 1 /* line number */ 2573 #if defined(FEAT_LINEBREAK) || defined(FEAT_DIFF) 2574 # define WL_SBR WL_NR + 1 /* 'showbreak' or 'diff' */ 2575 #else 2576 # define WL_SBR WL_NR 2577 #endif 2578 #define WL_LINE WL_SBR + 1 /* text in the line */ 2579 int draw_state = WL_START; /* what to draw next */ 2580 #if defined(FEAT_XIM) && (defined(FEAT_GUI_GTK) || defined(FEAT_GUI_KDE)) 2581 int feedback_col = 0; 2582 int feedback_old_attr = -1; 2583 #endif 2584 2585 2586 if (startrow > endrow) /* past the end already! */ 2587 return startrow; 2588 2589 row = startrow; 2590 screen_row = row + W_WINROW(wp); 2591 2592 /* 2593 * To speed up the loop below, set extra_check when there is linebreak, 2594 * trailing white space and/or syntax processing to be done. 2595 */ 2596 #ifdef FEAT_LINEBREAK 2597 extra_check = wp->w_p_lbr; 2598 #else 2599 extra_check = 0; 2600 #endif 2601 #ifdef FEAT_SYN_HL 2602 if (syntax_present(wp->w_buffer) && !wp->w_buffer->b_syn_error) 2603 { 2604 /* Prepare for syntax highlighting in this line. When there is an 2605 * error, stop syntax highlighting. */ 2606 save_did_emsg = did_emsg; 2607 did_emsg = FALSE; 2608 syntax_start(wp, lnum); 2609 if (did_emsg) 2610 wp->w_buffer->b_syn_error = TRUE; 2611 else 2612 { 2613 did_emsg = save_did_emsg; 2614 has_syntax = TRUE; 2615 extra_check = TRUE; 2616 } 2617 } 2618 2619 if (wp->w_p_spell 2620 && *wp->w_buffer->b_p_spl != NUL 2621 && wp->w_buffer->b_langp.ga_len > 0 2622 && *(char **)(wp->w_buffer->b_langp.ga_data) != NULL) 2623 { 2624 /* Prepare for spell checking. */ 2625 has_spell = TRUE; 2626 extra_check = TRUE; 2627 2628 /* Get the start of the next line, so that words that wrap to the next 2629 * line are found too: "et<line-break>al.". 2630 * Trick: skip a few chars for C/shell/Vim comments */ 2631 nextline[SPWORDLEN] = NUL; 2632 if (lnum < wp->w_buffer->b_ml.ml_line_count) 2633 { 2634 line = ml_get_buf(wp->w_buffer, lnum + 1, FALSE); 2635 spell_cat_line(nextline + SPWORDLEN, line, SPWORDLEN); 2636 } 2637 2638 /* When a word wrapped from the previous line the start of the current 2639 * line is valid. */ 2640 if (lnum == checked_lnum) 2641 cur_checked_col = checked_col; 2642 checked_lnum = 0; 2643 2644 /* When there was a sentence end in the previous line may require a 2645 * word starting with capital in this line. In line 1 always check 2646 * the first word. */ 2647 if (lnum != capcol_lnum) 2648 cap_col = -1; 2649 if (lnum == 1) 2650 cap_col = 0; 2651 capcol_lnum = 0; 2652 } 2653 #endif 2654 2655 /* 2656 * handle visual active in this window 2657 */ 2658 fromcol = -10; 2659 tocol = MAXCOL; 2660 #ifdef FEAT_VISUAL 2661 if (VIsual_active && wp->w_buffer == curwin->w_buffer) 2662 { 2663 /* Visual is after curwin->w_cursor */ 2664 if (ltoreq(curwin->w_cursor, VIsual)) 2665 { 2666 top = &curwin->w_cursor; 2667 bot = &VIsual; 2668 } 2669 else /* Visual is before curwin->w_cursor */ 2670 { 2671 top = &VIsual; 2672 bot = &curwin->w_cursor; 2673 } 2674 if (VIsual_mode == Ctrl_V) /* block mode */ 2675 { 2676 if (lnum >= top->lnum && lnum <= bot->lnum) 2677 { 2678 fromcol = wp->w_old_cursor_fcol; 2679 tocol = wp->w_old_cursor_lcol; 2680 } 2681 } 2682 else /* non-block mode */ 2683 { 2684 if (lnum > top->lnum && lnum <= bot->lnum) 2685 fromcol = 0; 2686 else if (lnum == top->lnum) 2687 { 2688 if (VIsual_mode == 'V') /* linewise */ 2689 fromcol = 0; 2690 else 2691 { 2692 getvvcol(wp, top, (colnr_T *)&fromcol, NULL, NULL); 2693 if (gchar_pos(top) == NUL) 2694 tocol = fromcol + 1; 2695 } 2696 } 2697 if (VIsual_mode != 'V' && lnum == bot->lnum) 2698 { 2699 if (*p_sel == 'e' && bot->col == 0 2700 #ifdef FEAT_VIRTUALEDIT 2701 && bot->coladd == 0 2702 #endif 2703 ) 2704 { 2705 fromcol = -10; 2706 tocol = MAXCOL; 2707 } 2708 else if (bot->col == MAXCOL) 2709 tocol = MAXCOL; 2710 else 2711 { 2712 pos = *bot; 2713 if (*p_sel == 'e') 2714 getvvcol(wp, &pos, (colnr_T *)&tocol, NULL, NULL); 2715 else 2716 { 2717 getvvcol(wp, &pos, NULL, NULL, (colnr_T *)&tocol); 2718 ++tocol; 2719 } 2720 } 2721 } 2722 } 2723 2724 #ifndef MSDOS 2725 /* Check if the character under the cursor should not be inverted */ 2726 if (!highlight_match && lnum == curwin->w_cursor.lnum && wp == curwin 2727 # ifdef FEAT_GUI 2728 && !gui.in_use 2729 # endif 2730 ) 2731 noinvcur = TRUE; 2732 #endif 2733 2734 /* if inverting in this line set area_highlighting */ 2735 if (fromcol >= 0) 2736 { 2737 area_highlighting = TRUE; 2738 attr = hl_attr(HLF_V); 2739 #if defined(FEAT_CLIPBOARD) && defined(FEAT_X11) 2740 if (clip_star.available && !clip_star.owned && clip_isautosel()) 2741 attr = hl_attr(HLF_VNC); 2742 #endif 2743 } 2744 } 2745 2746 /* 2747 * handle 'insearch' and ":s///c" highlighting 2748 */ 2749 else 2750 #endif /* FEAT_VISUAL */ 2751 if (highlight_match 2752 && wp == curwin 2753 && lnum >= curwin->w_cursor.lnum 2754 && lnum <= curwin->w_cursor.lnum + search_match_lines) 2755 { 2756 if (lnum == curwin->w_cursor.lnum) 2757 getvcol(curwin, &(curwin->w_cursor), 2758 (colnr_T *)&fromcol, NULL, NULL); 2759 else 2760 fromcol = 0; 2761 if (lnum == curwin->w_cursor.lnum + search_match_lines) 2762 { 2763 pos.lnum = lnum; 2764 pos.col = search_match_endcol; 2765 getvcol(curwin, &pos, (colnr_T *)&tocol, NULL, NULL); 2766 } 2767 else 2768 tocol = MAXCOL; 2769 if (fromcol == tocol) /* do at least one character */ 2770 tocol = fromcol + 1; /* happens when past end of line */ 2771 area_highlighting = TRUE; 2772 attr = hl_attr(HLF_I); 2773 } 2774 2775 #ifdef FEAT_DIFF 2776 filler_lines = diff_check(wp, lnum); 2777 if (filler_lines < 0) 2778 { 2779 if (filler_lines == -1) 2780 { 2781 if (diff_find_change(wp, lnum, &change_start, &change_end)) 2782 diff_hlf = HLF_ADD; /* added line */ 2783 else if (change_start == 0) 2784 diff_hlf = HLF_TXD; /* changed text */ 2785 else 2786 diff_hlf = HLF_CHD; /* changed line */ 2787 } 2788 else 2789 diff_hlf = HLF_ADD; /* added line */ 2790 filler_lines = 0; 2791 area_highlighting = TRUE; 2792 } 2793 if (lnum == wp->w_topline) 2794 filler_lines = wp->w_topfill; 2795 filler_todo = filler_lines; 2796 #endif 2797 2798 #ifdef LINE_ATTR 2799 # ifdef FEAT_SIGNS 2800 /* If this line has a sign with line highlighting set line_attr. */ 2801 v = buf_getsigntype(wp->w_buffer, lnum, SIGN_LINEHL); 2802 if (v != 0) 2803 line_attr = sign_get_attr((int)v, TRUE); 2804 # endif 2805 # if defined(FEAT_QUICKFIX) && defined(FEAT_WINDOWS) 2806 /* Highlight the current line in the quickfix window. */ 2807 if (bt_quickfix(wp->w_buffer) && qf_current_entry() == lnum) 2808 line_attr = hl_attr(HLF_L); 2809 # endif 2810 if (line_attr != 0) 2811 area_highlighting = TRUE; 2812 #endif 2813 2814 line = ml_get_buf(wp->w_buffer, lnum, FALSE); 2815 ptr = line; 2816 2817 #ifdef FEAT_SYN_HL 2818 if (has_spell) 2819 { 2820 /* For checking first word with a capital skip white space. */ 2821 if (cap_col == 0) 2822 cap_col = skipwhite(line) - line; 2823 2824 /* To be able to spell-check over line boundaries copy the end of the 2825 * current line into nextline[]. Above the start of the next line was 2826 * copied to nextline[SPWORDLEN]. */ 2827 if (nextline[SPWORDLEN] == NUL) 2828 { 2829 /* No next line or it is empty. */ 2830 nextlinecol = MAXCOL; 2831 nextline_idx = 0; 2832 } 2833 else 2834 { 2835 v = STRLEN(line); 2836 if (v < SPWORDLEN) 2837 { 2838 /* Short line, use it completely and append the start of the 2839 * next line. */ 2840 nextlinecol = 0; 2841 mch_memmove(nextline, line, (size_t)v); 2842 mch_memmove(nextline + v, nextline + SPWORDLEN, 2843 STRLEN(nextline + SPWORDLEN) + 1); 2844 nextline_idx = v + 1; 2845 } 2846 else 2847 { 2848 /* Long line, use only the last SPWORDLEN bytes. */ 2849 nextlinecol = v - SPWORDLEN; 2850 mch_memmove(nextline, line + nextlinecol, SPWORDLEN); 2851 nextline_idx = SPWORDLEN + 1; 2852 } 2853 } 2854 } 2855 #endif 2856 2857 /* find start of trailing whitespace */ 2858 if (wp->w_p_list && lcs_trail) 2859 { 2860 trailcol = (colnr_T)STRLEN(ptr); 2861 while (trailcol > (colnr_T)0 && vim_iswhite(ptr[trailcol - 1])) 2862 --trailcol; 2863 trailcol += (colnr_T) (ptr - line); 2864 extra_check = TRUE; 2865 } 2866 2867 /* 2868 * 'nowrap' or 'wrap' and a single line that doesn't fit: Advance to the 2869 * first character to be displayed. 2870 */ 2871 if (wp->w_p_wrap) 2872 v = wp->w_skipcol; 2873 else 2874 v = wp->w_leftcol; 2875 if (v > 0) 2876 { 2877 #ifdef FEAT_MBYTE 2878 char_u *prev_ptr = ptr; 2879 #endif 2880 while (vcol < v && *ptr != NUL) 2881 { 2882 c = win_lbr_chartabsize(wp, ptr, (colnr_T)vcol, NULL); 2883 vcol += c; 2884 #ifdef FEAT_MBYTE 2885 prev_ptr = ptr; 2886 #endif 2887 mb_ptr_adv(ptr); 2888 } 2889 2890 #ifdef FEAT_VIRTUALEDIT 2891 /* When 'virtualedit' is set the end of the line may be before the 2892 * start of the displayed part. */ 2893 if (vcol < v && *ptr == NUL && virtual_active()) 2894 vcol = v; 2895 #endif 2896 2897 /* Handle a character that's not completely on the screen: Put ptr at 2898 * that character but skip the first few screen characters. */ 2899 if (vcol > v) 2900 { 2901 vcol -= c; 2902 #ifdef FEAT_MBYTE 2903 ptr = prev_ptr; 2904 #else 2905 --ptr; 2906 #endif 2907 n_skip = v - vcol; 2908 } 2909 2910 /* 2911 * Adjust for when the inverted text is before the screen, 2912 * and when the start of the inverted text is before the screen. 2913 */ 2914 if (tocol <= vcol) 2915 fromcol = 0; 2916 else if (fromcol >= 0 && fromcol < vcol) 2917 fromcol = vcol; 2918 2919 #ifdef FEAT_LINEBREAK 2920 /* When w_skipcol is non-zero, first line needs 'showbreak' */ 2921 if (wp->w_p_wrap) 2922 need_showbreak = TRUE; 2923 #endif 2924 #ifdef FEAT_SYN_HL 2925 /* When spell checking a word we need to figure out the start of the 2926 * word and if it's badly spelled or not. */ 2927 if (has_spell) 2928 { 2929 int len; 2930 hlf_T spell_hlf = HLF_COUNT; 2931 2932 pos = wp->w_cursor; 2933 wp->w_cursor.lnum = lnum; 2934 wp->w_cursor.col = ptr - line; 2935 len = spell_move_to(wp, FORWARD, TRUE, TRUE, &spell_hlf); 2936 if (len == 0 || (int)wp->w_cursor.col > ptr - line) 2937 { 2938 /* no bad word found at line start, don't check until end of a 2939 * word */ 2940 spell_hlf = HLF_COUNT; 2941 word_end = spell_to_word_end(ptr, wp->w_buffer) - line + 1; 2942 } 2943 else 2944 { 2945 /* bad word found, use attributes until end of word */ 2946 word_end = wp->w_cursor.col + len + 1; 2947 2948 /* Turn index into actual attributes. */ 2949 if (spell_hlf != HLF_COUNT) 2950 spell_attr = highlight_attr[spell_hlf]; 2951 } 2952 wp->w_cursor = pos; 2953 2954 /* Need to restart syntax highlighting for this line. */ 2955 if (has_syntax) 2956 syntax_start(wp, lnum); 2957 } 2958 #endif 2959 } 2960 2961 /* 2962 * Correct highlighting for cursor that can't be disabled. 2963 * Avoids having to check this for each character. 2964 */ 2965 if (fromcol >= 0) 2966 { 2967 if (noinvcur) 2968 { 2969 if ((colnr_T)fromcol == wp->w_virtcol) 2970 { 2971 /* highlighting starts at cursor, let it start just after the 2972 * cursor */ 2973 fromcol_prev = fromcol; 2974 fromcol = -1; 2975 } 2976 else if ((colnr_T)fromcol < wp->w_virtcol) 2977 /* restart highlighting after the cursor */ 2978 fromcol_prev = wp->w_virtcol; 2979 } 2980 if (fromcol >= tocol) 2981 fromcol = -1; 2982 } 2983 2984 #ifdef FEAT_SEARCH_EXTRA 2985 /* 2986 * Handle highlighting the last used search pattern. 2987 * Do this for both search_hl and match_hl. 2988 */ 2989 shl = &search_hl; 2990 for (;;) 2991 { 2992 shl->startcol = MAXCOL; 2993 shl->endcol = MAXCOL; 2994 shl->attr_cur = 0; 2995 if (shl->rm.regprog != NULL) 2996 { 2997 v = (long)(ptr - line); 2998 next_search_hl(wp, shl, lnum, (colnr_T)v); 2999 3000 /* Need to get the line again, a multi-line regexp may have made it 3001 * invalid. */ 3002 line = ml_get_buf(wp->w_buffer, lnum, FALSE); 3003 ptr = line + v; 3004 3005 if (shl->lnum != 0 && shl->lnum <= lnum) 3006 { 3007 if (shl->lnum == lnum) 3008 shl->startcol = shl->rm.startpos[0].col; 3009 else 3010 shl->startcol = 0; 3011 if (lnum == shl->lnum + shl->rm.endpos[0].lnum 3012 - shl->rm.startpos[0].lnum) 3013 shl->endcol = shl->rm.endpos[0].col; 3014 else 3015 shl->endcol = MAXCOL; 3016 /* Highlight one character for an empty match. */ 3017 if (shl->startcol == shl->endcol) 3018 { 3019 #ifdef FEAT_MBYTE 3020 if (has_mbyte && line[shl->endcol] != NUL) 3021 shl->endcol += (*mb_ptr2len)(line + shl->endcol); 3022 else 3023 #endif 3024 ++shl->endcol; 3025 } 3026 if ((long)shl->startcol < v) /* match at leftcol */ 3027 { 3028 shl->attr_cur = shl->attr; 3029 search_attr = shl->attr; 3030 } 3031 area_highlighting = TRUE; 3032 } 3033 } 3034 if (shl == &match_hl) 3035 break; 3036 shl = &match_hl; 3037 } 3038 #endif 3039 3040 off = (unsigned)(current_ScreenLine - ScreenLines); 3041 col = 0; 3042 #ifdef FEAT_RIGHTLEFT 3043 if (wp->w_p_rl) 3044 { 3045 /* Rightleft window: process the text in the normal direction, but put 3046 * it in current_ScreenLine[] from right to left. Start at the 3047 * rightmost column of the window. */ 3048 col = W_WIDTH(wp) - 1; 3049 off += col; 3050 } 3051 #endif 3052 3053 /* 3054 * Repeat for the whole displayed line. 3055 */ 3056 for (;;) 3057 { 3058 /* Skip this quickly when working on the text. */ 3059 if (draw_state != WL_LINE) 3060 { 3061 #ifdef FEAT_CMDWIN 3062 if (draw_state == WL_CMDLINE - 1 && n_extra == 0) 3063 { 3064 draw_state = WL_CMDLINE; 3065 if (cmdwin_type != 0 && wp == curwin) 3066 { 3067 /* Draw the cmdline character. */ 3068 *extra = cmdwin_type; 3069 n_extra = 1; 3070 p_extra = extra; 3071 c_extra = NUL; 3072 char_attr = hl_attr(HLF_AT); 3073 } 3074 } 3075 #endif 3076 3077 #ifdef FEAT_FOLDING 3078 if (draw_state == WL_FOLD - 1 && n_extra == 0) 3079 { 3080 draw_state = WL_FOLD; 3081 if (wp->w_p_fdc > 0) 3082 { 3083 /* Draw the 'foldcolumn'. */ 3084 fill_foldcolumn(extra, wp, FALSE, lnum); 3085 n_extra = wp->w_p_fdc; 3086 p_extra = extra; 3087 c_extra = NUL; 3088 char_attr = hl_attr(HLF_FC); 3089 } 3090 } 3091 #endif 3092 3093 #ifdef FEAT_SIGNS 3094 if (draw_state == WL_SIGN - 1 && n_extra == 0) 3095 { 3096 draw_state = WL_SIGN; 3097 /* Show the sign column when there are any signs in this 3098 * buffer or when using Netbeans. */ 3099 if (draw_signcolumn(wp) 3100 # ifdef FEAT_DIFF 3101 && filler_todo <= 0 3102 # endif 3103 ) 3104 { 3105 int_u text_sign; 3106 # ifdef FEAT_SIGN_ICONS 3107 int_u icon_sign; 3108 # endif 3109 3110 /* Draw two cells with the sign value or blank. */ 3111 c_extra = ' '; 3112 char_attr = hl_attr(HLF_SC); 3113 n_extra = 2; 3114 3115 if (row == startrow) 3116 { 3117 text_sign = buf_getsigntype(wp->w_buffer, lnum, 3118 SIGN_TEXT); 3119 # ifdef FEAT_SIGN_ICONS 3120 icon_sign = buf_getsigntype(wp->w_buffer, lnum, 3121 SIGN_ICON); 3122 if (gui.in_use && icon_sign != 0) 3123 { 3124 /* Use the image in this position. */ 3125 c_extra = SIGN_BYTE; 3126 # ifdef FEAT_NETBEANS_INTG 3127 if (buf_signcount(wp->w_buffer, lnum) > 1) 3128 c_extra = MULTISIGN_BYTE; 3129 # endif 3130 char_attr = icon_sign; 3131 } 3132 else 3133 # endif 3134 if (text_sign != 0) 3135 { 3136 p_extra = sign_get_text(text_sign); 3137 if (p_extra != NULL) 3138 { 3139 c_extra = NUL; 3140 n_extra = STRLEN(p_extra); 3141 } 3142 char_attr = sign_get_attr(text_sign, FALSE); 3143 } 3144 } 3145 } 3146 } 3147 #endif 3148 3149 if (draw_state == WL_NR - 1 && n_extra == 0) 3150 { 3151 draw_state = WL_NR; 3152 /* Display the line number. After the first fill with blanks 3153 * when the 'n' flag isn't in 'cpo' */ 3154 if (wp->w_p_nu 3155 && (row == startrow 3156 #ifdef FEAT_DIFF 3157 + filler_lines 3158 #endif 3159 || vim_strchr(p_cpo, CPO_NUMCOL) == NULL)) 3160 { 3161 /* Draw the line number (empty space after wrapping). */ 3162 if (row == startrow 3163 #ifdef FEAT_DIFF 3164 + filler_lines 3165 #endif 3166 ) 3167 { 3168 sprintf((char *)extra, "%*ld ", 3169 number_width(wp), (long)lnum); 3170 if (wp->w_skipcol > 0) 3171 for (p_extra = extra; *p_extra == ' '; ++p_extra) 3172 *p_extra = '-'; 3173 #ifdef FEAT_RIGHTLEFT 3174 if (wp->w_p_rl) /* reverse line numbers */ 3175 rl_mirror(extra); 3176 #endif 3177 p_extra = extra; 3178 c_extra = NUL; 3179 } 3180 else 3181 c_extra = ' '; 3182 n_extra = number_width(wp) + 1; 3183 char_attr = hl_attr(HLF_N); 3184 } 3185 } 3186 3187 #if defined(FEAT_LINEBREAK) || defined(FEAT_DIFF) 3188 if (draw_state == WL_SBR - 1 && n_extra == 0) 3189 { 3190 draw_state = WL_SBR; 3191 # ifdef FEAT_DIFF 3192 if (filler_todo > 0) 3193 { 3194 /* Draw "deleted" diff line(s). */ 3195 if (char2cells(fill_diff) > 1) 3196 c_extra = '-'; 3197 else 3198 c_extra = fill_diff; 3199 # ifdef FEAT_RIGHTLEFT 3200 if (wp->w_p_rl) 3201 n_extra = col + 1; 3202 else 3203 # endif 3204 n_extra = W_WIDTH(wp) - col; 3205 char_attr = hl_attr(HLF_DED); 3206 } 3207 # endif 3208 # ifdef FEAT_LINEBREAK 3209 if (*p_sbr != NUL && need_showbreak) 3210 { 3211 /* Draw 'showbreak' at the start of each broken line. */ 3212 p_extra = p_sbr; 3213 c_extra = NUL; 3214 n_extra = (int)STRLEN(p_sbr); 3215 char_attr = hl_attr(HLF_AT); 3216 need_showbreak = FALSE; 3217 /* Correct end of highlighted area for 'showbreak', 3218 * required when 'linebreak' is also set. */ 3219 if (tocol == vcol) 3220 tocol += n_extra; 3221 } 3222 # endif 3223 } 3224 #endif 3225 3226 if (draw_state == WL_LINE - 1 && n_extra == 0) 3227 { 3228 draw_state = WL_LINE; 3229 if (saved_n_extra) 3230 { 3231 /* Continue item from end of wrapped line. */ 3232 n_extra = saved_n_extra; 3233 c_extra = saved_c_extra; 3234 p_extra = saved_p_extra; 3235 char_attr = saved_char_attr; 3236 } 3237 else 3238 char_attr = 0; 3239 } 3240 } 3241 3242 /* When still displaying '$' of change command, stop at cursor */ 3243 if (dollar_vcol != 0 && wp == curwin && vcol >= (long)wp->w_virtcol 3244 #ifdef FEAT_DIFF 3245 && filler_todo <= 0 3246 #endif 3247 ) 3248 { 3249 SCREEN_LINE(screen_row, W_WINCOL(wp), col, -(int)W_WIDTH(wp), 3250 wp->w_p_rl); 3251 /* Pretend we have finished updating the window. */ 3252 row = wp->w_height; 3253 break; 3254 } 3255 3256 if (draw_state == WL_LINE && area_highlighting) 3257 { 3258 /* handle Visual or match highlighting in this line */ 3259 if (vcol == fromcol 3260 #ifdef FEAT_MBYTE 3261 || (has_mbyte && vcol + 1 == fromcol && n_extra == 0 3262 && (*mb_ptr2cells)(ptr) > 1) 3263 #endif 3264 || ((int)vcol_prev == fromcol_prev 3265 && vcol < tocol)) 3266 area_attr = attr; /* start highlighting */ 3267 else if (area_attr != 0 3268 && (vcol == tocol 3269 || (noinvcur && (colnr_T)vcol == wp->w_virtcol))) 3270 #ifdef LINE_ATTR 3271 area_attr = line_attr; /* stop highlighting */ 3272 else if (line_attr && ((fromcol == -10 && tocol == MAXCOL) 3273 || (vcol < fromcol || vcol > tocol))) 3274 area_attr = line_attr; 3275 #else 3276 area_attr = 0; /* stop highlighting */ 3277 #endif 3278 3279 #ifdef FEAT_SEARCH_EXTRA 3280 if (!n_extra) 3281 { 3282 /* 3283 * Check for start/end of search pattern match. 3284 * After end, check for start/end of next match. 3285 * When another match, have to check for start again. 3286 * Watch out for matching an empty string! 3287 * Do this first for search_hl, then for match_hl, so that 3288 * ":match" overrules 'hlsearch'. 3289 */ 3290 v = (long)(ptr - line); 3291 shl = &search_hl; 3292 for (;;) 3293 { 3294 while (shl->rm.regprog != NULL) 3295 { 3296 if (shl->startcol != MAXCOL 3297 && v >= (long)shl->startcol 3298 && v < (long)shl->endcol) 3299 { 3300 shl->attr_cur = shl->attr; 3301 } 3302 else if (v == (long)shl->endcol) 3303 { 3304 shl->attr_cur = 0; 3305 3306 next_search_hl(wp, shl, lnum, (colnr_T)v); 3307 3308 /* Need to get the line again, a multi-line regexp 3309 * may have made it invalid. */ 3310 line = ml_get_buf(wp->w_buffer, lnum, FALSE); 3311 ptr = line + v; 3312 3313 if (shl->lnum == lnum) 3314 { 3315 shl->startcol = shl->rm.startpos[0].col; 3316 if (shl->rm.endpos[0].lnum == 0) 3317 shl->endcol = shl->rm.endpos[0].col; 3318 else 3319 shl->endcol = MAXCOL; 3320 3321 if (shl->startcol == shl->endcol) 3322 { 3323 /* highlight empty match, try again after 3324 * it */ 3325 #ifdef FEAT_MBYTE 3326 if (has_mbyte) 3327 shl->endcol += (*mb_ptr2len)(line 3328 + shl->endcol); 3329 else 3330 #endif 3331 ++shl->endcol; 3332 } 3333 3334 /* Loop to check if the match starts at the 3335 * current position */ 3336 continue; 3337 } 3338 } 3339 break; 3340 } 3341 if (shl == &match_hl) 3342 break; 3343 shl = &match_hl; 3344 } 3345 /* ":match" highlighting overrules 'hlsearch' */ 3346 if (match_hl.attr_cur != 0) 3347 search_attr = match_hl.attr_cur; 3348 else 3349 search_attr = search_hl.attr_cur; 3350 } 3351 #endif 3352 3353 if (area_attr != 0) 3354 char_attr = area_attr; 3355 #ifdef FEAT_SYN_HL 3356 else if (search_attr == 0 && has_syntax) 3357 char_attr = syntax_attr; 3358 #endif 3359 else 3360 char_attr = search_attr; 3361 3362 #ifdef FEAT_DIFF 3363 if (diff_hlf != (hlf_T)0 && n_extra == 0) 3364 { 3365 if (diff_hlf == HLF_CHD && ptr - line >= change_start) 3366 diff_hlf = HLF_TXD; /* changed text */ 3367 if (diff_hlf == HLF_TXD && ptr - line > change_end) 3368 diff_hlf = HLF_CHD; /* changed line */ 3369 if (attr == 0 || area_attr != attr) 3370 area_attr = hl_attr(diff_hlf); 3371 if (attr == 0 || char_attr != attr) 3372 { 3373 if (search_attr != 0) 3374 char_attr = search_attr; 3375 else 3376 char_attr = hl_attr(diff_hlf); 3377 } 3378 } 3379 #endif 3380 } 3381 3382 /* 3383 * Get the next character to put on the screen. 3384 */ 3385 /* 3386 * The 'extra' array contains the extra stuff that is inserted to 3387 * represent special characters (non-printable stuff). When all 3388 * characters are the same, c_extra is used. 3389 * For the '$' of the 'list' option, n_extra == 1, p_extra == "". 3390 */ 3391 if (n_extra > 0) 3392 { 3393 if (c_extra != NUL) 3394 { 3395 c = c_extra; 3396 #ifdef FEAT_MBYTE 3397 mb_c = c; /* doesn't handle non-utf-8 multi-byte! */ 3398 if (enc_utf8 && (*mb_char2len)(c) > 1) 3399 { 3400 mb_utf8 = TRUE; 3401 u8c_c1 = u8c_c2 = 0; 3402 } 3403 else 3404 mb_utf8 = FALSE; 3405 #endif 3406 } 3407 else 3408 { 3409 c = *p_extra; 3410 #ifdef FEAT_MBYTE 3411 if (has_mbyte) 3412 { 3413 mb_c = c; 3414 if (enc_utf8) 3415 { 3416 /* If the UTF-8 character is more than one byte: 3417 * Decode it into "mb_c". */ 3418 mb_l = (*mb_ptr2len)(p_extra); 3419 mb_utf8 = FALSE; 3420 if (mb_l > n_extra) 3421 mb_l = 1; 3422 else if (mb_l > 1) 3423 { 3424 mb_c = utfc_ptr2char(p_extra, &u8c_c1, &u8c_c2); 3425 mb_utf8 = TRUE; 3426 } 3427 } 3428 else 3429 { 3430 /* if this is a DBCS character, put it in "mb_c" */ 3431 mb_l = MB_BYTE2LEN(c); 3432 if (mb_l >= n_extra) 3433 mb_l = 1; 3434 else if (mb_l > 1) 3435 mb_c = (c << 8) + p_extra[1]; 3436 } 3437 if (mb_l == 0) /* at the NUL at end-of-line */ 3438 mb_l = 1; 3439 3440 /* If a double-width char doesn't fit display a '>' in the 3441 * last column. */ 3442 if (( 3443 # ifdef FEAT_RIGHTLEFT 3444 wp->w_p_rl ? (col <= 0) : 3445 # endif 3446 (col >= W_WIDTH(wp) - 1)) 3447 && (*mb_char2cells)(mb_c) == 2) 3448 { 3449 c = '>'; 3450 mb_c = c; 3451 mb_l = 1; 3452 mb_utf8 = FALSE; 3453 multi_attr = hl_attr(HLF_AT); 3454 /* put the pointer back to output the double-width 3455 * character at the start of the next line. */ 3456 ++n_extra; 3457 --p_extra; 3458 } 3459 else 3460 { 3461 n_extra -= mb_l - 1; 3462 p_extra += mb_l - 1; 3463 } 3464 } 3465 #endif 3466 ++p_extra; 3467 } 3468 --n_extra; 3469 } 3470 else 3471 { 3472 /* 3473 * Get a character from the line itself. 3474 */ 3475 c = *ptr; 3476 #ifdef FEAT_MBYTE 3477 if (has_mbyte) 3478 { 3479 mb_c = c; 3480 if (enc_utf8) 3481 { 3482 /* If the UTF-8 character is more than one byte: Decode it 3483 * into "mb_c". */ 3484 mb_l = (*mb_ptr2len)(ptr); 3485 mb_utf8 = FALSE; 3486 if (mb_l > 1) 3487 { 3488 mb_c = utfc_ptr2char(ptr, &u8c_c1, &u8c_c2); 3489 /* Overlong encoded ASCII or ASCII with composing char 3490 * is displayed normally, except a NUL. */ 3491 if (mb_c < 0x80) 3492 c = mb_c; 3493 mb_utf8 = TRUE; 3494 3495 /* At start of the line we can have a composing char. 3496 * Draw it as a space with a composing char. */ 3497 if (utf_iscomposing(mb_c)) 3498 { 3499 u8c_c2 = u8c_c1; 3500 u8c_c1 = mb_c; 3501 mb_c = ' '; 3502 } 3503 } 3504 3505 if ((mb_l == 1 && c >= 0x80) 3506 || (mb_l >= 1 && mb_c == 0) 3507 || (mb_l > 1 && (!vim_isprintc(mb_c) 3508 || mb_c >= 0x10000))) 3509 { 3510 /* 3511 * Illegal UTF-8 byte: display as <xx>. 3512 * Non-BMP character : display as ? or fullwidth ?. 3513 */ 3514 if (mb_c < 0x10000) 3515 { 3516 transchar_hex(extra, mb_c); 3517 #ifdef FEAT_RIGHTLEFT 3518 if (wp->w_p_rl) /* reverse */ 3519 rl_mirror(extra); 3520 #endif 3521 } 3522 else if (utf_char2cells(mb_c) != 2) 3523 STRCPY(extra, "?"); 3524 else 3525 /* 0xff1f in UTF-8: full-width '?' */ 3526 STRCPY(extra, "\357\274\237"); 3527 3528 p_extra = extra; 3529 c = *p_extra; 3530 mb_c = mb_ptr2char_adv(&p_extra); 3531 mb_utf8 = (c >= 0x80); 3532 n_extra = (int)STRLEN(p_extra); 3533 c_extra = NUL; 3534 if (area_attr == 0 && search_attr == 0) 3535 { 3536 n_attr = n_extra + 1; 3537 extra_attr = hl_attr(HLF_8); 3538 saved_attr2 = char_attr; /* save current attr */ 3539 } 3540 } 3541 else if (mb_l == 0) /* at the NUL at end-of-line */ 3542 mb_l = 1; 3543 #ifdef FEAT_ARABIC 3544 else if (p_arshape && !p_tbidi && ARABIC_CHAR(mb_c)) 3545 { 3546 /* Do Arabic shaping. */ 3547 int pc, pc1, nc, dummy; 3548 3549 /* The idea of what is the previous and next 3550 * character depends on 'rightleft'. */ 3551 if (wp->w_p_rl) 3552 { 3553 pc = prev_c; 3554 pc1 = prev_c1; 3555 nc = utf_ptr2char(ptr + mb_l); 3556 prev_c1 = u8c_c1; 3557 } 3558 else 3559 { 3560 pc = utfc_ptr2char(ptr + mb_l, &pc1, &dummy); 3561 nc = prev_c; 3562 } 3563 prev_c = mb_c; 3564 3565 mb_c = arabic_shape(mb_c, &c, &u8c_c1, pc, pc1, nc); 3566 } 3567 else 3568 prev_c = mb_c; 3569 #endif 3570 } 3571 else /* enc_dbcs */ 3572 { 3573 mb_l = MB_BYTE2LEN(c); 3574 if (mb_l == 0) /* at the NUL at end-of-line */ 3575 mb_l = 1; 3576 else if (mb_l > 1) 3577 { 3578 /* We assume a second byte below 32 is illegal. 3579 * Hopefully this is OK for all double-byte encodings! 3580 */ 3581 if (ptr[1] >= 32) 3582 mb_c = (c << 8) + ptr[1]; 3583 else 3584 { 3585 if (ptr[1] == NUL) 3586 { 3587 /* head byte at end of line */ 3588 mb_l = 1; 3589 transchar_nonprint(extra, c); 3590 } 3591 else 3592 { 3593 /* illegal tail byte */ 3594 mb_l = 2; 3595 STRCPY(extra, "XX"); 3596 } 3597 p_extra = extra; 3598 n_extra = (int)STRLEN(extra) - 1; 3599 c_extra = NUL; 3600 c = *p_extra++; 3601 if (area_attr == 0 && search_attr == 0) 3602 { 3603 n_attr = n_extra + 1; 3604 extra_attr = hl_attr(HLF_8); 3605 saved_attr2 = char_attr; /* save current attr */ 3606 } 3607 mb_c = c; 3608 } 3609 } 3610 } 3611 /* If a double-width char doesn't fit display a '>' in the 3612 * last column; the character is displayed at the start of the 3613 * next line. */ 3614 if (( 3615 # ifdef FEAT_RIGHTLEFT 3616 wp->w_p_rl ? (col <= 0) : 3617 # endif 3618 (col >= W_WIDTH(wp) - 1)) 3619 && (*mb_char2cells)(mb_c) == 2) 3620 { 3621 c = '>'; 3622 mb_c = c; 3623 mb_utf8 = FALSE; 3624 mb_l = 1; 3625 multi_attr = hl_attr(HLF_AT); 3626 /* Put pointer back so that the character will be 3627 * displayed at the start of the next line. */ 3628 --ptr; 3629 } 3630 else if (*ptr != NUL) 3631 ptr += mb_l - 1; 3632 3633 /* If a double-width char doesn't fit at the left side display 3634 * a '<' in the first column. */ 3635 if (n_skip > 0 && mb_l > 1) 3636 { 3637 extra[0] = '<'; 3638 p_extra = extra; 3639 n_extra = 1; 3640 c_extra = NUL; 3641 c = ' '; 3642 if (area_attr == 0 && search_attr == 0) 3643 { 3644 n_attr = n_extra + 1; 3645 extra_attr = hl_attr(HLF_AT); 3646 saved_attr2 = char_attr; /* save current attr */ 3647 } 3648 mb_c = c; 3649 mb_utf8 = FALSE; 3650 mb_l = 1; 3651 } 3652 3653 } 3654 #endif 3655 ++ptr; 3656 3657 /* 'list' : change char 160 to lcs_nbsp. */ 3658 if (wp->w_p_list && c == 160 && lcs_nbsp) 3659 { 3660 c = lcs_nbsp; 3661 if (area_attr == 0 && search_attr == 0) 3662 { 3663 n_attr = 1; 3664 extra_attr = hl_attr(HLF_8); 3665 saved_attr2 = char_attr; /* save current attr */ 3666 } 3667 #ifdef FEAT_MBYTE 3668 mb_c = c; 3669 if (enc_utf8 && (*mb_char2len)(c) > 1) 3670 { 3671 mb_utf8 = TRUE; 3672 u8c_c1 = u8c_c2 = 0; 3673 } 3674 else 3675 mb_utf8 = FALSE; 3676 #endif 3677 } 3678 3679 if (extra_check) 3680 { 3681 #ifdef FEAT_SYN_HL 3682 int can_spell = TRUE; 3683 3684 /* Get syntax attribute, unless still at the start of the line 3685 * (double-wide char that doesn't fit). */ 3686 v = (long)(ptr - line); 3687 if (has_syntax && v > 0) 3688 { 3689 /* Get the syntax attribute for the character. If there 3690 * is an error, disable syntax highlighting. */ 3691 save_did_emsg = did_emsg; 3692 did_emsg = FALSE; 3693 3694 syntax_attr = get_syntax_attr((colnr_T)v - 1, 3695 has_spell ? &can_spell : NULL); 3696 3697 if (did_emsg) 3698 { 3699 wp->w_buffer->b_syn_error = TRUE; 3700 has_syntax = FALSE; 3701 } 3702 else 3703 did_emsg = save_did_emsg; 3704 3705 /* Need to get the line again, a multi-line regexp may 3706 * have made it invalid. */ 3707 line = ml_get_buf(wp->w_buffer, lnum, FALSE); 3708 ptr = line + v; 3709 3710 if (area_attr == 0 && search_attr == 0) 3711 char_attr = syntax_attr; 3712 else 3713 char_attr = hl_combine_attr(syntax_attr, char_attr); 3714 } 3715 3716 /* Check spelling (unless at the end of the line). 3717 * Only do this when there is no syntax highlighting, the 3718 * @Spell cluster is not used or the current syntax item 3719 * contains the @Spell cluster. */ 3720 if (has_spell && v >= word_end && v > cur_checked_col) 3721 { 3722 spell_attr = 0; 3723 if (area_attr == 0 && search_attr == 0) 3724 char_attr = syntax_attr; 3725 if (c != 0 && (!has_syntax || can_spell)) 3726 { 3727 char_u *prev_ptr, *p; 3728 int len; 3729 hlf_T spell_hlf = HLF_COUNT; 3730 # ifdef FEAT_MBYTE 3731 if (has_mbyte) 3732 { 3733 prev_ptr = ptr - mb_l; 3734 v -= mb_l - 1; 3735 } 3736 else 3737 # endif 3738 prev_ptr = ptr - 1; 3739 3740 /* Use nextline[] if possible, it has the start of the 3741 * next line concatenated. */ 3742 if ((prev_ptr - line) - nextlinecol >= 0) 3743 p = nextline + (prev_ptr - line) - nextlinecol; 3744 else 3745 p = prev_ptr; 3746 cap_col -= (prev_ptr - line); 3747 len = spell_check(wp, p, &spell_hlf, &cap_col); 3748 word_end = v + len; 3749 3750 /* In Insert mode only highlight a word that 3751 * doesn't touch the cursor. */ 3752 if (spell_hlf != HLF_COUNT 3753 && (State & INSERT) != 0 3754 && wp->w_cursor.lnum == lnum 3755 && wp->w_cursor.col >= 3756 (colnr_T)(prev_ptr - line) 3757 && wp->w_cursor.col < (colnr_T)word_end) 3758 { 3759 spell_hlf = HLF_COUNT; 3760 spell_redraw_lnum = lnum; 3761 } 3762 3763 if (spell_hlf == HLF_COUNT && p != prev_ptr 3764 && (p - nextline) + len > nextline_idx) 3765 { 3766 /* Remember that the good word continues at the 3767 * start of the next line. */ 3768 checked_lnum = lnum + 1; 3769 checked_col = (p - nextline) + len - nextline_idx; 3770 } 3771 3772 /* Turn index into actual attributes. */ 3773 if (spell_hlf != HLF_COUNT) 3774 spell_attr = highlight_attr[spell_hlf]; 3775 3776 if (cap_col > 0) 3777 { 3778 if (p != prev_ptr 3779 && (p - nextline) + cap_col >= nextline_idx) 3780 { 3781 /* Remember that the word in the next line 3782 * must start with a capital. */ 3783 capcol_lnum = lnum + 1; 3784 cap_col = (p - nextline) + cap_col 3785 - nextline_idx; 3786 } 3787 else 3788 /* Compute the actual column. */ 3789 cap_col += (prev_ptr - line); 3790 } 3791 } 3792 } 3793 if (spell_attr != 0) 3794 { 3795 if (area_attr == 0 && search_attr == 0) 3796 char_attr = hl_combine_attr(char_attr, spell_attr); 3797 else 3798 char_attr = hl_combine_attr(spell_attr, char_attr); 3799 } 3800 #endif 3801 #ifdef FEAT_LINEBREAK 3802 /* 3803 * Found last space before word: check for line break. 3804 */ 3805 if (wp->w_p_lbr && vim_isbreak(c) && !vim_isbreak(*ptr) 3806 && !wp->w_p_list) 3807 { 3808 n_extra = win_lbr_chartabsize(wp, ptr - ( 3809 # ifdef FEAT_MBYTE 3810 has_mbyte ? mb_l : 3811 # endif 3812 1), (colnr_T)vcol, NULL) - 1; 3813 c_extra = ' '; 3814 if (vim_iswhite(c)) 3815 c = ' '; 3816 } 3817 #endif 3818 3819 if (trailcol != MAXCOL && ptr > line + trailcol && c == ' ') 3820 { 3821 c = lcs_trail; 3822 if (area_attr == 0 && search_attr == 0) 3823 { 3824 n_attr = 1; 3825 extra_attr = hl_attr(HLF_8); 3826 saved_attr2 = char_attr; /* save current attr */ 3827 } 3828 #ifdef FEAT_MBYTE 3829 mb_c = c; 3830 if (enc_utf8 && (*mb_char2len)(c) > 1) 3831 { 3832 mb_utf8 = TRUE; 3833 u8c_c1 = u8c_c2 = 0; 3834 } 3835 else 3836 mb_utf8 = FALSE; 3837 #endif 3838 } 3839 } 3840 3841 /* 3842 * Handling of non-printable characters. 3843 */ 3844 if (!(chartab[c] & CT_PRINT_CHAR)) 3845 { 3846 /* 3847 * when getting a character from the file, we may have to 3848 * turn it into something else on the way to putting it 3849 * into "ScreenLines". 3850 */ 3851 if (c == TAB && (!wp->w_p_list || lcs_tab1)) 3852 { 3853 /* tab amount depends on current column */ 3854 n_extra = (int)wp->w_buffer->b_p_ts 3855 - vcol % (int)wp->w_buffer->b_p_ts - 1; 3856 #ifdef FEAT_MBYTE 3857 mb_utf8 = FALSE; /* don't draw as UTF-8 */ 3858 #endif 3859 if (wp->w_p_list) 3860 { 3861 c = lcs_tab1; 3862 c_extra = lcs_tab2; 3863 n_attr = n_extra + 1; 3864 extra_attr = hl_attr(HLF_8); 3865 saved_attr2 = char_attr; /* save current attr */ 3866 #ifdef FEAT_MBYTE 3867 mb_c = c; 3868 if (enc_utf8 && (*mb_char2len)(c) > 1) 3869 { 3870 mb_utf8 = TRUE; 3871 u8c_c1 = u8c_c2 = 0; 3872 } 3873 #endif 3874 } 3875 else 3876 { 3877 c_extra = ' '; 3878 c = ' '; 3879 } 3880 } 3881 else if (c == NUL 3882 && ((wp->w_p_list && lcs_eol > 0) 3883 || ((fromcol >= 0 || fromcol_prev >= 0) 3884 && tocol > vcol 3885 #ifdef FEAT_VISUAL 3886 && VIsual_mode != Ctrl_V 3887 #endif 3888 && ( 3889 # ifdef FEAT_RIGHTLEFT 3890 wp->w_p_rl ? (col >= 0) : 3891 # endif 3892 (col < W_WIDTH(wp))) 3893 && !(noinvcur 3894 && (colnr_T)vcol == wp->w_virtcol))) 3895 && lcs_eol_one >= 0) 3896 { 3897 /* Display a '$' after the line or highlight an extra 3898 * character if the line break is included. */ 3899 #if defined(FEAT_DIFF) || defined(LINE_ATTR) 3900 /* For a diff line the highlighting continues after the 3901 * "$". */ 3902 if ( 3903 # ifdef FEAT_DIFF 3904 diff_hlf == (hlf_T)0 3905 # ifdef LINE_ATTR 3906 && 3907 # endif 3908 # endif 3909 # ifdef LINE_ATTR 3910 line_attr == 0 3911 # endif 3912 ) 3913 #endif 3914 { 3915 #ifdef FEAT_VIRTUALEDIT 3916 /* In virtualedit, visual selections may extend 3917 * beyond end of line. */ 3918 if (area_highlighting && virtual_active() 3919 && tocol != MAXCOL && vcol < tocol) 3920 n_extra = 0; 3921 else 3922 #endif 3923 { 3924 p_extra = at_end_str; 3925 n_extra = 1; 3926 c_extra = NUL; 3927 } 3928 } 3929 if (wp->w_p_list) 3930 c = lcs_eol; 3931 else 3932 c = ' '; 3933 lcs_eol_one = -1; 3934 --ptr; /* put it back at the NUL */ 3935 if (area_attr == 0 && search_attr == 0) 3936 { 3937 extra_attr = hl_attr(HLF_AT); 3938 n_attr = 1; 3939 } 3940 #ifdef FEAT_MBYTE 3941 mb_c = c; 3942 if (enc_utf8 && (*mb_char2len)(c) > 1) 3943 { 3944 mb_utf8 = TRUE; 3945 u8c_c1 = u8c_c2 = 0; 3946 } 3947 else 3948 mb_utf8 = FALSE; /* don't draw as UTF-8 */ 3949 #endif 3950 } 3951 else if (c != NUL) 3952 { 3953 p_extra = transchar(c); 3954 #ifdef FEAT_RIGHTLEFT 3955 if ((dy_flags & DY_UHEX) && wp->w_p_rl) 3956 rl_mirror(p_extra); /* reverse "<12>" */ 3957 #endif 3958 n_extra = byte2cells(c) - 1; 3959 c_extra = NUL; 3960 c = *p_extra++; 3961 if (area_attr == 0 && search_attr == 0) 3962 { 3963 n_attr = n_extra + 1; 3964 extra_attr = hl_attr(HLF_8); 3965 saved_attr2 = char_attr; /* save current attr */ 3966 } 3967 #ifdef FEAT_MBYTE 3968 mb_utf8 = FALSE; /* don't draw as UTF-8 */ 3969 #endif 3970 } 3971 #ifdef FEAT_VIRTUALEDIT 3972 else if (VIsual_active 3973 && (VIsual_mode == Ctrl_V 3974 || VIsual_mode == 'v') 3975 && virtual_active() 3976 && tocol != MAXCOL 3977 && vcol < tocol 3978 && ( 3979 # ifdef FEAT_RIGHTLEFT 3980 wp->w_p_rl ? (col >= 0) : 3981 # endif 3982 (col < W_WIDTH(wp)))) 3983 { 3984 c = ' '; 3985 --ptr; /* put it back at the NUL */ 3986 } 3987 #endif 3988 #if defined(FEAT_DIFF) || defined(LINE_ATTR) 3989 else if (( 3990 # ifdef FEAT_DIFF 3991 diff_hlf != (hlf_T)0 3992 # ifdef LINE_ATTR 3993 || 3994 # endif 3995 # endif 3996 # ifdef LINE_ATTR 3997 line_attr != 0 3998 # endif 3999 ) && ( 4000 # ifdef FEAT_RIGHTLEFT 4001 wp->w_p_rl ? (col >= 0) : 4002 # endif 4003 (col < W_WIDTH(wp)))) 4004 { 4005 /* Highlight until the right side of the window */ 4006 c = ' '; 4007 --ptr; /* put it back at the NUL */ 4008 # ifdef FEAT_DIFF 4009 if (diff_hlf == HLF_TXD) 4010 { 4011 diff_hlf = HLF_CHD; 4012 if (attr == 0 || char_attr != attr) 4013 char_attr = hl_attr(diff_hlf); 4014 } 4015 # endif 4016 } 4017 #endif 4018 } 4019 } 4020 4021 /* Don't override visual selection highlighting. */ 4022 if (n_attr > 0 4023 && draw_state == WL_LINE 4024 && (area_attr == 0 || char_attr != area_attr) 4025 && (search_attr == 0 || char_attr != search_attr)) 4026 char_attr = extra_attr; 4027 4028 #if defined(FEAT_XIM) && defined(FEAT_GUI_GTK) 4029 /* XIM don't send preedit_start and preedit_end, but they send 4030 * preedit_changed and commit. Thus Vim can't set "im_is_active", use 4031 * im_is_preediting() here. */ 4032 if (xic != NULL 4033 && lnum == curwin->w_cursor.lnum 4034 && (State & INSERT) 4035 && !p_imdisable 4036 && im_is_preediting() 4037 && draw_state == WL_LINE) 4038 { 4039 colnr_T tcol; 4040 4041 if (preedit_end_col == MAXCOL) 4042 getvcol(curwin, &(curwin->w_cursor), &tcol, NULL, NULL); 4043 else 4044 tcol = preedit_end_col; 4045 if ((long)preedit_start_col <= vcol && vcol < (long)tcol) 4046 { 4047 if (feedback_old_attr < 0) 4048 { 4049 feedback_col = 0; 4050 feedback_old_attr = char_attr; 4051 } 4052 char_attr = im_get_feedback_attr(feedback_col); 4053 if (char_attr < 0) 4054 char_attr = feedback_old_attr; 4055 feedback_col++; 4056 } 4057 else if (feedback_old_attr >= 0) 4058 { 4059 char_attr = feedback_old_attr; 4060 feedback_old_attr = -1; 4061 feedback_col = 0; 4062 } 4063 } 4064 #endif 4065 /* 4066 * Handle the case where we are in column 0 but not on the first 4067 * character of the line and the user wants us to show us a 4068 * special character (via 'listchars' option "precedes:<char>". 4069 */ 4070 if (lcs_prec_todo != NUL 4071 && (wp->w_p_wrap ? wp->w_skipcol > 0 : wp->w_leftcol > 0) 4072 #ifdef FEAT_DIFF 4073 && filler_todo <= 0 4074 #endif 4075 && draw_state > WL_NR 4076 && c != NUL) 4077 { 4078 c = lcs_prec; 4079 lcs_prec_todo = NUL; 4080 #ifdef FEAT_MBYTE 4081 mb_c = c; 4082 if (enc_utf8 && (*mb_char2len)(c) > 1) 4083 { 4084 mb_utf8 = TRUE; 4085 u8c_c1 = u8c_c2 = 0; 4086 } 4087 else 4088 mb_utf8 = FALSE; /* don't draw as UTF-8 */ 4089 #endif 4090 if ((area_attr == 0 || char_attr != area_attr) 4091 && (search_attr == 0 || char_attr != search_attr)) 4092 { 4093 saved_attr3 = char_attr; /* save current attr */ 4094 char_attr = hl_attr(HLF_AT); /* later copied to char_attr */ 4095 n_attr3 = 1; 4096 } 4097 } 4098 4099 /* 4100 * At end of the text line. 4101 */ 4102 if (c == NUL) 4103 { 4104 /* invert at least one char, used for Visual and empty line or 4105 * highlight match at end of line. If it's beyond the last 4106 * char on the screen, just overwrite that one (tricky!) Not 4107 * needed when a '$' was displayed for 'list'. */ 4108 if (lcs_eol == lcs_eol_one 4109 && ((area_attr != 0 && vcol == fromcol) 4110 #ifdef FEAT_SEARCH_EXTRA 4111 /* highlight 'hlsearch' match at end of line */ 4112 || (ptr - line) - 1 == (long)search_hl.startcol 4113 || (ptr - line) - 1 == (long)match_hl.startcol 4114 #endif 4115 )) 4116 { 4117 int n = 0; 4118 4119 #ifdef FEAT_RIGHTLEFT 4120 if (wp->w_p_rl) 4121 { 4122 if (col < 0) 4123 n = 1; 4124 } 4125 else 4126 #endif 4127 { 4128 if (col >= W_WIDTH(wp)) 4129 n = -1; 4130 } 4131 if (n != 0) 4132 { 4133 /* At the window boundary, highlight the last character 4134 * instead (better than nothing). */ 4135 off += n; 4136 col += n; 4137 } 4138 else 4139 { 4140 /* Add a blank character to highlight. */ 4141 ScreenLines[off] = ' '; 4142 #ifdef FEAT_MBYTE 4143 if (enc_utf8) 4144 ScreenLinesUC[off] = 0; 4145 #endif 4146 } 4147 #ifdef FEAT_SEARCH_EXTRA 4148 if (area_attr == 0) 4149 { 4150 if ((ptr - line) - 1 == (long)match_hl.startcol) 4151 char_attr = match_hl.attr; 4152 else 4153 char_attr = search_hl.attr; 4154 } 4155 #endif 4156 ScreenAttrs[off] = char_attr; 4157 #ifdef FEAT_RIGHTLEFT 4158 if (wp->w_p_rl) 4159 --col; 4160 else 4161 #endif 4162 ++col; 4163 } 4164 4165 SCREEN_LINE(screen_row, W_WINCOL(wp), col, (int)W_WIDTH(wp), 4166 wp->w_p_rl); 4167 row++; 4168 4169 /* 4170 * Update w_cline_height and w_cline_folded if the cursor line was 4171 * updated (saves a call to plines() later). 4172 */ 4173 if (wp == curwin && lnum == curwin->w_cursor.lnum) 4174 { 4175 curwin->w_cline_row = startrow; 4176 curwin->w_cline_height = row - startrow; 4177 #ifdef FEAT_FOLDING 4178 curwin->w_cline_folded = FALSE; 4179 #endif 4180 curwin->w_valid |= (VALID_CHEIGHT|VALID_CROW); 4181 } 4182 4183 break; 4184 } 4185 4186 /* line continues beyond line end */ 4187 if (lcs_ext 4188 && !wp->w_p_wrap 4189 #ifdef FEAT_DIFF 4190 && filler_todo <= 0 4191 #endif 4192 && ( 4193 #ifdef FEAT_RIGHTLEFT 4194 wp->w_p_rl ? col == 0 : 4195 #endif 4196 col == W_WIDTH(wp) - 1) 4197 && (*ptr != NUL 4198 || (wp->w_p_list && lcs_eol != NUL && p_extra != at_end_str) 4199 || (n_extra && (c_extra != NUL || *p_extra != NUL)))) 4200 { 4201 c = lcs_ext; 4202 char_attr = hl_attr(HLF_AT); 4203 #ifdef FEAT_MBYTE 4204 mb_c = c; 4205 if (enc_utf8 && (*mb_char2len)(c) > 1) 4206 { 4207 mb_utf8 = TRUE; 4208 u8c_c1 = u8c_c2 = 0; 4209 } 4210 else 4211 mb_utf8 = FALSE; 4212 #endif 4213 } 4214 4215 /* 4216 * Store character to be displayed. 4217 * Skip characters that are left of the screen for 'nowrap'. 4218 */ 4219 vcol_prev = vcol; 4220 if (draw_state < WL_LINE || n_skip <= 0) 4221 { 4222 /* 4223 * Store the character. 4224 */ 4225 #if defined(FEAT_RIGHTLEFT) && defined(FEAT_MBYTE) 4226 if (has_mbyte && wp->w_p_rl && (*mb_char2cells)(mb_c) > 1) 4227 { 4228 /* A double-wide character is: put first halve in left cell. */ 4229 --off; 4230 --col; 4231 } 4232 #endif 4233 ScreenLines[off] = c; 4234 #ifdef FEAT_MBYTE 4235 if (enc_dbcs == DBCS_JPNU) 4236 ScreenLines2[off] = mb_c & 0xff; 4237 else if (enc_utf8) 4238 { 4239 if (mb_utf8) 4240 { 4241 ScreenLinesUC[off] = mb_c; 4242 ScreenLinesC1[off] = u8c_c1; 4243 ScreenLinesC2[off] = u8c_c2; 4244 } 4245 else 4246 ScreenLinesUC[off] = 0; 4247 } 4248 if (multi_attr) 4249 { 4250 ScreenAttrs[off] = multi_attr; 4251 multi_attr = 0; 4252 } 4253 else 4254 #endif 4255 ScreenAttrs[off] = char_attr; 4256 4257 #ifdef FEAT_MBYTE 4258 if (has_mbyte && (*mb_char2cells)(mb_c) > 1) 4259 { 4260 /* Need to fill two screen columns. */ 4261 ++off; 4262 ++col; 4263 if (enc_utf8) 4264 /* UTF-8: Put a 0 in the second screen char. */ 4265 ScreenLines[off] = 0; 4266 else 4267 /* DBCS: Put second byte in the second screen char. */ 4268 ScreenLines[off] = mb_c & 0xff; 4269 ++vcol; 4270 /* When "tocol" is halfway a character, set it to the end of 4271 * the character, otherwise highlighting won't stop. */ 4272 if (tocol == vcol) 4273 ++tocol; 4274 #ifdef FEAT_RIGHTLEFT 4275 if (wp->w_p_rl) 4276 { 4277 /* now it's time to backup one cell */ 4278 --off; 4279 --col; 4280 } 4281 #endif 4282 } 4283 #endif 4284 #ifdef FEAT_RIGHTLEFT 4285 if (wp->w_p_rl) 4286 { 4287 --off; 4288 --col; 4289 } 4290 else 4291 #endif 4292 { 4293 ++off; 4294 ++col; 4295 } 4296 } 4297 else 4298 --n_skip; 4299 4300 /* Only advance the "vcol" when after the 'number' column. */ 4301 if (draw_state >= WL_SBR 4302 #ifdef FEAT_DIFF 4303 && filler_todo <= 0 4304 #endif 4305 ) 4306 ++vcol; 4307 4308 /* restore attributes after "predeces" in 'listchars' */ 4309 if (draw_state > WL_NR && n_attr3 > 0 && --n_attr3 == 0) 4310 char_attr = saved_attr3; 4311 4312 /* restore attributes after last 'listchars' or 'number' char */ 4313 if (n_attr > 0 && draw_state == WL_LINE && --n_attr == 0) 4314 char_attr = saved_attr2; 4315 4316 /* 4317 * At end of screen line and there is more to come: Display the line 4318 * so far. If there is no more to display it is catched above. 4319 */ 4320 if (( 4321 #ifdef FEAT_RIGHTLEFT 4322 wp->w_p_rl ? (col < 0) : 4323 #endif 4324 (col >= W_WIDTH(wp))) 4325 && (*ptr != NUL 4326 #ifdef FEAT_DIFF 4327 || filler_todo > 0 4328 #endif 4329 || (wp->w_p_list && lcs_eol != NUL && p_extra != at_end_str) 4330 || (n_extra != 0 && (c_extra != NUL || *p_extra != NUL))) 4331 ) 4332 { 4333 SCREEN_LINE(screen_row, W_WINCOL(wp), col, (int)W_WIDTH(wp), 4334 wp->w_p_rl); 4335 ++row; 4336 ++screen_row; 4337 4338 /* When not wrapping and finished diff lines, or when displayed 4339 * '$' and highlighting until last column, break here. */ 4340 if ((!wp->w_p_wrap 4341 #ifdef FEAT_DIFF 4342 && filler_todo <= 0 4343 #endif 4344 ) || lcs_eol_one == -1) 4345 break; 4346 4347 /* When the window is too narrow draw all "@" lines. */ 4348 if (draw_state != WL_LINE 4349 #ifdef FEAT_DIFF 4350 && filler_todo <= 0 4351 #endif 4352 ) 4353 { 4354 win_draw_end(wp, '@', ' ', row, wp->w_height, HLF_AT); 4355 #ifdef FEAT_VERTSPLIT 4356 draw_vsep_win(wp, row); 4357 #endif 4358 row = endrow; 4359 } 4360 4361 /* When line got too long for screen break here. */ 4362 if (row == endrow) 4363 { 4364 ++row; 4365 break; 4366 } 4367 4368 if (screen_cur_row == screen_row - 1 4369 #ifdef FEAT_DIFF 4370 && filler_todo <= 0 4371 #endif 4372 && W_WIDTH(wp) == Columns) 4373 { 4374 /* Remember that the line wraps, used for modeless copy. */ 4375 LineWraps[screen_row - 1] = TRUE; 4376 4377 /* 4378 * Special trick to make copy/paste of wrapped lines work with 4379 * xterm/screen: write an extra character beyond the end of 4380 * the line. This will work with all terminal types 4381 * (regardless of the xn,am settings). 4382 * Only do this on a fast tty. 4383 * Only do this if the cursor is on the current line 4384 * (something has been written in it). 4385 * Don't do this for the GUI. 4386 * Don't do this for double-width characters. 4387 * Don't do this for a window not at the right screen border. 4388 */ 4389 if (p_tf 4390 #ifdef FEAT_GUI 4391 && !gui.in_use 4392 #endif 4393 #ifdef FEAT_MBYTE 4394 && !(has_mbyte 4395 && ((*mb_off2cells)(LineOffset[screen_row]) == 2 4396 || (*mb_off2cells)(LineOffset[screen_row - 1] 4397 + (int)Columns - 2) == 2)) 4398 #endif 4399 ) 4400 { 4401 /* First make sure we are at the end of the screen line, 4402 * then output the same character again to let the 4403 * terminal know about the wrap. If the terminal doesn't 4404 * auto-wrap, we overwrite the character. */ 4405 if (screen_cur_col != W_WIDTH(wp)) 4406 screen_char(LineOffset[screen_row - 1] 4407 + (unsigned)Columns - 1, 4408 screen_row - 1, (int)(Columns - 1)); 4409 4410 #ifdef FEAT_MBYTE 4411 /* When there is a multi-byte character, just output a 4412 * space to keep it simple. */ 4413 if (has_mbyte && MB_BYTE2LEN(ScreenLines[LineOffset[ 4414 screen_row - 1] + (Columns - 1)]) > 1) 4415 out_char(' '); 4416 else 4417 #endif 4418 out_char(ScreenLines[LineOffset[screen_row - 1] 4419 + (Columns - 1)]); 4420 /* force a redraw of the first char on the next line */ 4421 ScreenAttrs[LineOffset[screen_row]] = (sattr_T)-1; 4422 screen_start(); /* don't know where cursor is now */ 4423 } 4424 } 4425 4426 col = 0; 4427 off = (unsigned)(current_ScreenLine - ScreenLines); 4428 #ifdef FEAT_RIGHTLEFT 4429 if (wp->w_p_rl) 4430 { 4431 col = W_WIDTH(wp) - 1; /* col is not used if breaking! */ 4432 off += col; 4433 } 4434 #endif 4435 4436 /* reset the drawing state for the start of a wrapped line */ 4437 draw_state = WL_START; 4438 saved_n_extra = n_extra; 4439 saved_p_extra = p_extra; 4440 saved_c_extra = c_extra; 4441 saved_char_attr = char_attr; 4442 n_extra = 0; 4443 lcs_prec_todo = lcs_prec; 4444 #ifdef FEAT_LINEBREAK 4445 # ifdef FEAT_DIFF 4446 if (filler_todo <= 0) 4447 # endif 4448 need_showbreak = TRUE; 4449 #endif 4450 #ifdef FEAT_DIFF 4451 --filler_todo; 4452 /* When the filler lines are actually below the last line of the 4453 * file, don't draw the line itself, break here. */ 4454 if (filler_todo == 0 && wp->w_botfill) 4455 break; 4456 #endif 4457 } 4458 4459 } /* for every character in the line */ 4460 4461 #ifdef FEAT_SYN_HL 4462 /* After an empty line check first word for capital. */ 4463 if (*skipwhite(line) == NUL) 4464 { 4465 capcol_lnum = lnum + 1; 4466 cap_col = 0; 4467 } 4468 #endif 4469 4470 return row; 4471 } 4472 4473 /* 4474 * Check whether the given character needs redrawing: 4475 * - the (first byte of the) character is different 4476 * - the attributes are different 4477 * - the character is multi-byte and the next byte is different 4478 */ 4479 static int 4480 char_needs_redraw(off_from, off_to, cols) 4481 int off_from; 4482 int off_to; 4483 int cols; 4484 { 4485 if (cols > 0 4486 && ((ScreenLines[off_from] != ScreenLines[off_to] 4487 || ScreenAttrs[off_from] != ScreenAttrs[off_to]) 4488 4489 #ifdef FEAT_MBYTE 4490 || (enc_dbcs != 0 4491 && MB_BYTE2LEN(ScreenLines[off_from]) > 1 4492 && (enc_dbcs == DBCS_JPNU && ScreenLines[off_from] == 0x8e 4493 ? ScreenLines2[off_from] != ScreenLines2[off_to] 4494 : (cols > 1 && ScreenLines[off_from + 1] 4495 != ScreenLines[off_to + 1]))) 4496 || (enc_utf8 4497 && (ScreenLinesUC[off_from] != ScreenLinesUC[off_to] 4498 || (ScreenLinesUC[off_from] != 0 4499 && (ScreenLinesC1[off_from] 4500 != ScreenLinesC1[off_to] 4501 || ScreenLinesC2[off_from] 4502 != ScreenLinesC2[off_to])))) 4503 #endif 4504 )) 4505 return TRUE; 4506 return FALSE; 4507 } 4508 4509 /* 4510 * Move one "cooked" screen line to the screen, but only the characters that 4511 * have actually changed. Handle insert/delete character. 4512 * "coloff" gives the first column on the screen for this line. 4513 * "endcol" gives the columns where valid characters are. 4514 * "clear_width" is the width of the window. It's > 0 if the rest of the line 4515 * needs to be cleared, negative otherwise. 4516 * "rlflag" is TRUE in a rightleft window: 4517 * When TRUE and "clear_width" > 0, clear columns 0 to "endcol" 4518 * When FALSE and "clear_width" > 0, clear columns "endcol" to "clear_width" 4519 */ 4520 static void 4521 screen_line(row, coloff, endcol, clear_width 4522 #ifdef FEAT_RIGHTLEFT 4523 , rlflag 4524 #endif 4525 ) 4526 int row; 4527 int coloff; 4528 int endcol; 4529 int clear_width; 4530 #ifdef FEAT_RIGHTLEFT 4531 int rlflag; 4532 #endif 4533 { 4534 unsigned off_from; 4535 unsigned off_to; 4536 int col = 0; 4537 #if defined(FEAT_GUI) || defined(UNIX) || defined(FEAT_VERTSPLIT) 4538 int hl; 4539 #endif 4540 int force = FALSE; /* force update rest of the line */ 4541 int redraw_this /* bool: does character need redraw? */ 4542 #ifdef FEAT_GUI 4543 = TRUE /* For GUI when while-loop empty */ 4544 #endif 4545 ; 4546 int redraw_next; /* redraw_this for next character */ 4547 #ifdef FEAT_MBYTE 4548 int clear_next = FALSE; 4549 int char_cells; /* 1: normal char */ 4550 /* 2: occupies two display cells */ 4551 # define CHAR_CELLS char_cells 4552 #else 4553 # define CHAR_CELLS 1 4554 #endif 4555 4556 # ifdef FEAT_CLIPBOARD 4557 clip_may_clear_selection(row, row); 4558 # endif 4559 4560 off_from = (unsigned)(current_ScreenLine - ScreenLines); 4561 off_to = LineOffset[row] + coloff; 4562 4563 #ifdef FEAT_RIGHTLEFT 4564 if (rlflag) 4565 { 4566 /* Clear rest first, because it's left of the text. */ 4567 if (clear_width > 0) 4568 { 4569 while (col <= endcol && ScreenLines[off_to] == ' ' 4570 && ScreenAttrs[off_to] == 0 4571 # ifdef FEAT_MBYTE 4572 && (!enc_utf8 || ScreenLinesUC[off_to] == 0) 4573 # endif 4574 ) 4575 { 4576 ++off_to; 4577 ++col; 4578 } 4579 if (col <= endcol) 4580 screen_fill(row, row + 1, col + coloff, 4581 endcol + coloff + 1, ' ', ' ', 0); 4582 } 4583 col = endcol + 1; 4584 off_to = LineOffset[row] + col + coloff; 4585 off_from += col; 4586 endcol = (clear_width > 0 ? clear_width : -clear_width); 4587 } 4588 #endif /* FEAT_RIGHTLEFT */ 4589 4590 redraw_next = char_needs_redraw(off_from, off_to, endcol - col); 4591 4592 while (col < endcol) 4593 { 4594 #ifdef FEAT_MBYTE 4595 if (has_mbyte && (col + 1 < endcol)) 4596 char_cells = (*mb_off2cells)(off_from); 4597 else 4598 char_cells = 1; 4599 #endif 4600 4601 redraw_this = redraw_next; 4602 redraw_next = force || char_needs_redraw(off_from + CHAR_CELLS, 4603 off_to + CHAR_CELLS, endcol - col - CHAR_CELLS); 4604 4605 #ifdef FEAT_GUI 4606 /* If the next character was bold, then redraw the current character to 4607 * remove any pixels that might have spilt over into us. This only 4608 * happens in the GUI. 4609 */ 4610 if (redraw_next && gui.in_use) 4611 { 4612 hl = ScreenAttrs[off_to + CHAR_CELLS]; 4613 if (hl > HL_ALL || (hl & HL_BOLD)) 4614 redraw_this = TRUE; 4615 } 4616 #endif 4617 4618 if (redraw_this) 4619 { 4620 /* 4621 * Special handling when 'xs' termcap flag set (hpterm): 4622 * Attributes for characters are stored at the position where the 4623 * cursor is when writing the highlighting code. The 4624 * start-highlighting code must be written with the cursor on the 4625 * first highlighted character. The stop-highlighting code must 4626 * be written with the cursor just after the last highlighted 4627 * character. 4628 * Overwriting a character doesn't remove it's highlighting. Need 4629 * to clear the rest of the line, and force redrawing it 4630 * completely. 4631 */ 4632 if ( p_wiv 4633 && !force 4634 #ifdef FEAT_GUI 4635 && !gui.in_use 4636 #endif 4637 && ScreenAttrs[off_to] != 0 4638 && ScreenAttrs[off_from] != ScreenAttrs[off_to]) 4639 { 4640 /* 4641 * Need to remove highlighting attributes here. 4642 */ 4643 windgoto(row, col + coloff); 4644 out_str(T_CE); /* clear rest of this screen line */ 4645 screen_start(); /* don't know where cursor is now */ 4646 force = TRUE; /* force redraw of rest of the line */ 4647 redraw_next = TRUE; /* or else next char would miss out */ 4648 4649 /* 4650 * If the previous character was highlighted, need to stop 4651 * highlighting at this character. 4652 */ 4653 if (col + coloff > 0 && ScreenAttrs[off_to - 1] != 0) 4654 { 4655 screen_attr = ScreenAttrs[off_to - 1]; 4656 term_windgoto(row, col + coloff); 4657 screen_stop_highlight(); 4658 } 4659 else 4660 screen_attr = 0; /* highlighting has stopped */ 4661 } 4662 #ifdef FEAT_MBYTE 4663 if (enc_dbcs != 0) 4664 { 4665 /* Check if overwriting a double-byte with a single-byte or 4666 * the other way around requires another character to be 4667 * redrawn. For UTF-8 this isn't needed, because comparing 4668 * ScreenLinesUC[] is sufficient. */ 4669 if (char_cells == 1 4670 && col + 1 < endcol 4671 && (*mb_off2cells)(off_to) > 1) 4672 { 4673 /* Writing a single-cell character over a double-cell 4674 * character: need to redraw the next cell. */ 4675 ScreenLines[off_to + 1] = 0; 4676 redraw_next = TRUE; 4677 } 4678 else if (char_cells == 2 4679 && col + 2 < endcol 4680 && (*mb_off2cells)(off_to) == 1 4681 && (*mb_off2cells)(off_to + 1) > 1) 4682 { 4683 /* Writing the second half of a double-cell character over 4684 * a double-cell character: need to redraw the second 4685 * cell. */ 4686 ScreenLines[off_to + 2] = 0; 4687 redraw_next = TRUE; 4688 } 4689 4690 if (enc_dbcs == DBCS_JPNU) 4691 ScreenLines2[off_to] = ScreenLines2[off_from]; 4692 } 4693 /* When writing a single-width character over a double-width 4694 * character and at the end of the redrawn text, need to clear out 4695 * the right halve of the old character. 4696 * Also required when writing the right halve of a double-width 4697 * char over the left halve of an existing one. */ 4698 if (has_mbyte && col + char_cells == endcol 4699 && ((char_cells == 1 4700 && (*mb_off2cells)(off_to) > 1) 4701 || (char_cells == 2 4702 && (*mb_off2cells)(off_to) == 1 4703 && (*mb_off2cells)(off_to + 1) > 1))) 4704 clear_next = TRUE; 4705 #endif 4706 4707 ScreenLines[off_to] = ScreenLines[off_from]; 4708 #ifdef FEAT_MBYTE 4709 if (enc_utf8) 4710 { 4711 ScreenLinesUC[off_to] = ScreenLinesUC[off_from]; 4712 if (ScreenLinesUC[off_from] != 0) 4713 { 4714 ScreenLinesC1[off_to] = ScreenLinesC1[off_from]; 4715 ScreenLinesC2[off_to] = ScreenLinesC2[off_from]; 4716 } 4717 } 4718 if (char_cells == 2) 4719 ScreenLines[off_to + 1] = ScreenLines[off_from + 1]; 4720 #endif 4721 4722 #if defined(FEAT_GUI) || defined(UNIX) 4723 /* The bold trick makes a single row of pixels appear in the next 4724 * character. When a bold character is removed, the next 4725 * character should be redrawn too. This happens for our own GUI 4726 * and for some xterms. */ 4727 if ( 4728 # ifdef FEAT_GUI 4729 gui.in_use 4730 # endif 4731 # if defined(FEAT_GUI) && defined(UNIX) 4732 || 4733 # endif 4734 # ifdef UNIX 4735 term_is_xterm 4736 # endif 4737 ) 4738 { 4739 hl = ScreenAttrs[off_to]; 4740 if (hl > HL_ALL || (hl & HL_BOLD)) 4741 redraw_next = TRUE; 4742 } 4743 #endif 4744 ScreenAttrs[off_to] = ScreenAttrs[off_from]; 4745 #ifdef FEAT_MBYTE 4746 if (enc_dbcs != 0 && char_cells == 2) 4747 { 4748 /* just a hack: It makes two bytes of DBCS have same attr */ 4749 ScreenAttrs[off_to + 1] = ScreenAttrs[off_from]; 4750 screen_char_2(off_to, row, col + coloff); 4751 } 4752 else 4753 #endif 4754 screen_char(off_to, row, col + coloff); 4755 } 4756 else if ( p_wiv 4757 #ifdef FEAT_GUI 4758 && !gui.in_use 4759 #endif 4760 && col + coloff > 0) 4761 { 4762 if (ScreenAttrs[off_to] == ScreenAttrs[off_to - 1]) 4763 { 4764 /* 4765 * Don't output stop-highlight when moving the cursor, it will 4766 * stop the highlighting when it should continue. 4767 */ 4768 screen_attr = 0; 4769 } 4770 else if (screen_attr != 0) 4771 screen_stop_highlight(); 4772 } 4773 4774 off_to += CHAR_CELLS; 4775 off_from += CHAR_CELLS; 4776 col += CHAR_CELLS; 4777 } 4778 4779 #ifdef FEAT_MBYTE 4780 if (clear_next) 4781 { 4782 /* Clear the second half of a double-wide character of which the left 4783 * half was overwritten with a single-wide character. */ 4784 ScreenLines[off_to] = ' '; 4785 if (enc_utf8) 4786 ScreenLinesUC[off_to] = 0; 4787 screen_char(off_to, row, col + coloff); 4788 } 4789 #endif 4790 4791 if (clear_width > 0 4792 #ifdef FEAT_RIGHTLEFT 4793 && !rlflag 4794 #endif 4795 ) 4796 { 4797 #ifdef FEAT_GUI 4798 int startCol = col; 4799 #endif 4800 4801 /* blank out the rest of the line */ 4802 while (col < clear_width && ScreenLines[off_to] == ' ' 4803 && ScreenAttrs[off_to] == 0 4804 #ifdef FEAT_MBYTE 4805 && (!enc_utf8 || ScreenLinesUC[off_to] == 0) 4806 #endif 4807 ) 4808 { 4809 ++off_to; 4810 ++col; 4811 } 4812 if (col < clear_width) 4813 { 4814 #ifdef FEAT_GUI 4815 /* 4816 * In the GUI, clearing the rest of the line may leave pixels 4817 * behind if the first character cleared was bold. Some bold 4818 * fonts spill over the left. In this case we redraw the previous 4819 * character too. If we didn't skip any blanks above, then we 4820 * only redraw if the character wasn't already redrawn anyway. 4821 */ 4822 if (gui.in_use && (col > startCol || !redraw_this) 4823 # ifdef FEAT_MBYTE 4824 && enc_dbcs == 0 4825 # endif 4826 ) 4827 { 4828 hl = ScreenAttrs[off_to]; 4829 if (hl > HL_ALL || (hl & HL_BOLD)) 4830 screen_char(off_to - 1, row, col + coloff - 1); 4831 } 4832 #endif 4833 screen_fill(row, row + 1, col + coloff, clear_width + coloff, 4834 ' ', ' ', 0); 4835 #ifdef FEAT_VERTSPLIT 4836 off_to += clear_width - col; 4837 col = clear_width; 4838 #endif 4839 } 4840 } 4841 4842 if (clear_width > 0) 4843 { 4844 #ifdef FEAT_VERTSPLIT 4845 /* For a window that's left of another, draw the separator char. */ 4846 if (col + coloff < Columns) 4847 { 4848 int c; 4849 4850 c = fillchar_vsep(&hl); 4851 if (ScreenLines[off_to] != c 4852 # ifdef FEAT_MBYTE 4853 || (enc_utf8 4854 && ScreenLinesUC[off_to] != (c >= 0x80 ? c : 0)) 4855 # endif 4856 || ScreenAttrs[off_to] != hl) 4857 { 4858 ScreenLines[off_to] = c; 4859 ScreenAttrs[off_to] = hl; 4860 # ifdef FEAT_MBYTE 4861 if (enc_utf8) 4862 { 4863 if (c >= 0x80) 4864 { 4865 ScreenLinesUC[off_to] = c; 4866 ScreenLinesC1[off_to] = 0; 4867 ScreenLinesC2[off_to] = 0; 4868 } 4869 else 4870 ScreenLinesUC[off_to] = 0; 4871 } 4872 # endif 4873 screen_char(off_to, row, col + coloff); 4874 } 4875 } 4876 else 4877 #endif 4878 LineWraps[row] = FALSE; 4879 } 4880 } 4881 4882 #if defined(FEAT_RIGHTLEFT) || defined(PROTO) 4883 /* 4884 * Mirror text "str" for right-left displaying. 4885 * Only works for single-byte characters (e.g., numbers). 4886 */ 4887 void 4888 rl_mirror(str) 4889 char_u *str; 4890 { 4891 char_u *p1, *p2; 4892 int t; 4893 4894 for (p1 = str, p2 = str + STRLEN(str) - 1; p1 < p2; ++p1, --p2) 4895 { 4896 t = *p1; 4897 *p1 = *p2; 4898 *p2 = t; 4899 } 4900 } 4901 #endif 4902 4903 #if defined(FEAT_WINDOWS) || defined(PROTO) 4904 /* 4905 * mark all status lines for redraw; used after first :cd 4906 */ 4907 void 4908 status_redraw_all() 4909 { 4910 win_T *wp; 4911 4912 for (wp = firstwin; wp; wp = wp->w_next) 4913 if (wp->w_status_height) 4914 { 4915 wp->w_redr_status = TRUE; 4916 redraw_later(VALID); 4917 } 4918 } 4919 4920 /* 4921 * mark all status lines of the current buffer for redraw 4922 */ 4923 void 4924 status_redraw_curbuf() 4925 { 4926 win_T *wp; 4927 4928 for (wp = firstwin; wp; wp = wp->w_next) 4929 if (wp->w_status_height != 0 && wp->w_buffer == curbuf) 4930 { 4931 wp->w_redr_status = TRUE; 4932 redraw_later(VALID); 4933 } 4934 } 4935 4936 /* 4937 * Redraw all status lines that need to be redrawn. 4938 */ 4939 void 4940 redraw_statuslines() 4941 { 4942 win_T *wp; 4943 4944 for (wp = firstwin; wp; wp = wp->w_next) 4945 if (wp->w_redr_status) 4946 win_redr_status(wp); 4947 } 4948 #endif 4949 4950 #if (defined(FEAT_WILDMENU) && defined(FEAT_VERTSPLIT)) || defined(PROTO) 4951 /* 4952 * Redraw all status lines at the bottom of frame "frp". 4953 */ 4954 void 4955 win_redraw_last_status(frp) 4956 frame_T *frp; 4957 { 4958 if (frp->fr_layout == FR_LEAF) 4959 frp->fr_win->w_redr_status = TRUE; 4960 else if (frp->fr_layout == FR_ROW) 4961 { 4962 for (frp = frp->fr_child; frp != NULL; frp = frp->fr_next) 4963 win_redraw_last_status(frp); 4964 } 4965 else /* frp->fr_layout == FR_COL */ 4966 { 4967 frp = frp->fr_child; 4968 while (frp->fr_next != NULL) 4969 frp = frp->fr_next; 4970 win_redraw_last_status(frp); 4971 } 4972 } 4973 #endif 4974 4975 #ifdef FEAT_VERTSPLIT 4976 /* 4977 * Draw the verticap separator right of window "wp" starting with line "row". 4978 */ 4979 static void 4980 draw_vsep_win(wp, row) 4981 win_T *wp; 4982 int row; 4983 { 4984 int hl; 4985 int c; 4986 4987 if (wp->w_vsep_width) 4988 { 4989 /* draw the vertical separator right of this window */ 4990 c = fillchar_vsep(&hl); 4991 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + wp->w_height, 4992 W_ENDCOL(wp), W_ENDCOL(wp) + 1, 4993 c, ' ', hl); 4994 } 4995 } 4996 #endif 4997 4998 #ifdef FEAT_WILDMENU 4999 static int status_match_len __ARGS((expand_T *xp, char_u *s)); 5000 static int skip_status_match_char __ARGS((expand_T *xp, char_u *s)); 5001 5002 /* 5003 * Get the lenght of an item as it will be shown in the status line. 5004 */ 5005 static int 5006 status_match_len(xp, s) 5007 expand_T *xp; 5008 char_u *s; 5009 { 5010 int len = 0; 5011 5012 #ifdef FEAT_MENU 5013 int emenu = (xp->xp_context == EXPAND_MENUS 5014 || xp->xp_context == EXPAND_MENUNAMES); 5015 5016 /* Check for menu separators - replace with '|'. */ 5017 if (emenu && menu_is_separator(s)) 5018 return 1; 5019 #endif 5020 5021 while (*s != NUL) 5022 { 5023 if (skip_status_match_char(xp, s)) 5024 ++s; 5025 len += ptr2cells(s); 5026 mb_ptr_adv(s); 5027 } 5028 5029 return len; 5030 } 5031 5032 /* 5033 * Return TRUE for characters that are not displayed in a status match. 5034 * These are backslashes used for escaping. Do show backslashes in help tags. 5035 */ 5036 static int 5037 skip_status_match_char(xp, s) 5038 expand_T *xp; 5039 char_u *s; 5040 { 5041 return ((rem_backslash(s) && xp->xp_context != EXPAND_HELP) 5042 #ifdef FEAT_MENU 5043 || ((xp->xp_context == EXPAND_MENUS 5044 || xp->xp_context == EXPAND_MENUNAMES) 5045 && (s[0] == '\t' || (s[0] == '\\' && s[1] != NUL))) 5046 #endif 5047 ); 5048 } 5049 5050 /* 5051 * Show wildchar matches in the status line. 5052 * Show at least the "match" item. 5053 * We start at item 'first_match' in the list and show all matches that fit. 5054 * 5055 * If inversion is possible we use it. Else '=' characters are used. 5056 */ 5057 void 5058 win_redr_status_matches(xp, num_matches, matches, match, showtail) 5059 expand_T *xp; 5060 int num_matches; 5061 char_u **matches; /* list of matches */ 5062 int match; 5063 int showtail; 5064 { 5065 #define L_MATCH(m) (showtail ? sm_gettail(matches[m]) : matches[m]) 5066 int row; 5067 char_u *buf; 5068 int len; 5069 int clen; /* lenght in screen cells */ 5070 int fillchar; 5071 int attr; 5072 int i; 5073 int highlight = TRUE; 5074 char_u *selstart = NULL; 5075 int selstart_col = 0; 5076 char_u *selend = NULL; 5077 static int first_match = 0; 5078 int add_left = FALSE; 5079 char_u *s; 5080 #ifdef FEAT_MENU 5081 int emenu; 5082 #endif 5083 #if defined(FEAT_MBYTE) || defined(FEAT_MENU) 5084 int l; 5085 #endif 5086 5087 if (matches == NULL) /* interrupted completion? */ 5088 return; 5089 5090 #ifdef FEAT_MBYTE 5091 if (has_mbyte) 5092 buf = alloc((unsigned)Columns * MB_MAXBYTES + 1); 5093 else 5094 #endif 5095 buf = alloc((unsigned)Columns + 1); 5096 if (buf == NULL) 5097 return; 5098 5099 if (match == -1) /* don't show match but original text */ 5100 { 5101 match = 0; 5102 highlight = FALSE; 5103 } 5104 /* count 1 for the ending ">" */ 5105 clen = status_match_len(xp, L_MATCH(match)) + 3; 5106 if (match == 0) 5107 first_match = 0; 5108 else if (match < first_match) 5109 { 5110 /* jumping left, as far as we can go */ 5111 first_match = match; 5112 add_left = TRUE; 5113 } 5114 else 5115 { 5116 /* check if match fits on the screen */ 5117 for (i = first_match; i < match; ++i) 5118 clen += status_match_len(xp, L_MATCH(i)) + 2; 5119 if (first_match > 0) 5120 clen += 2; 5121 /* jumping right, put match at the left */ 5122 if ((long)clen > Columns) 5123 { 5124 first_match = match; 5125 /* if showing the last match, we can add some on the left */ 5126 clen = 2; 5127 for (i = match; i < num_matches; ++i) 5128 { 5129 clen += status_match_len(xp, L_MATCH(i)) + 2; 5130 if ((long)clen >= Columns) 5131 break; 5132 } 5133 if (i == num_matches) 5134 add_left = TRUE; 5135 } 5136 } 5137 if (add_left) 5138 while (first_match > 0) 5139 { 5140 clen += status_match_len(xp, L_MATCH(first_match - 1)) + 2; 5141 if ((long)clen >= Columns) 5142 break; 5143 --first_match; 5144 } 5145 5146 fillchar = fillchar_status(&attr, TRUE); 5147 5148 if (first_match == 0) 5149 { 5150 *buf = NUL; 5151 len = 0; 5152 } 5153 else 5154 { 5155 STRCPY(buf, "< "); 5156 len = 2; 5157 } 5158 clen = len; 5159 5160 i = first_match; 5161 while ((long)(clen + status_match_len(xp, L_MATCH(i)) + 2) < Columns) 5162 { 5163 if (i == match) 5164 { 5165 selstart = buf + len; 5166 selstart_col = clen; 5167 } 5168 5169 s = L_MATCH(i); 5170 /* Check for menu separators - replace with '|' */ 5171 #ifdef FEAT_MENU 5172 emenu = (xp->xp_context == EXPAND_MENUS 5173 || xp->xp_context == EXPAND_MENUNAMES); 5174 if (emenu && menu_is_separator(s)) 5175 { 5176 STRCPY(buf + len, transchar('|')); 5177 l = (int)STRLEN(buf + len); 5178 len += l; 5179 clen += l; 5180 } 5181 else 5182 #endif 5183 for ( ; *s != NUL; ++s) 5184 { 5185 if (skip_status_match_char(xp, s)) 5186 ++s; 5187 clen += ptr2cells(s); 5188 #ifdef FEAT_MBYTE 5189 if (has_mbyte && (l = (*mb_ptr2len)(s)) > 1) 5190 { 5191 STRNCPY(buf + len, s, l); 5192 s += l - 1; 5193 len += l; 5194 } 5195 else 5196 #endif 5197 { 5198 STRCPY(buf + len, transchar_byte(*s)); 5199 len += (int)STRLEN(buf + len); 5200 } 5201 } 5202 if (i == match) 5203 selend = buf + len; 5204 5205 *(buf + len++) = ' '; 5206 *(buf + len++) = ' '; 5207 clen += 2; 5208 if (++i == num_matches) 5209 break; 5210 } 5211 5212 if (i != num_matches) 5213 { 5214 *(buf + len++) = '>'; 5215 ++clen; 5216 } 5217 5218 buf[len] = NUL; 5219 5220 row = cmdline_row - 1; 5221 if (row >= 0) 5222 { 5223 if (wild_menu_showing == 0) 5224 { 5225 if (msg_scrolled > 0) 5226 { 5227 /* Put the wildmenu just above the command line. If there is 5228 * no room, scroll the screen one line up. */ 5229 if (cmdline_row == Rows - 1) 5230 { 5231 screen_del_lines(0, 0, 1, (int)Rows, TRUE, NULL); 5232 ++msg_scrolled; 5233 } 5234 else 5235 { 5236 ++cmdline_row; 5237 ++row; 5238 } 5239 wild_menu_showing = WM_SCROLLED; 5240 } 5241 else 5242 { 5243 /* Create status line if needed by setting 'laststatus' to 2. 5244 * Set 'winminheight' to zero to avoid that the window is 5245 * resized. */ 5246 if (lastwin->w_status_height == 0) 5247 { 5248 save_p_ls = p_ls; 5249 save_p_wmh = p_wmh; 5250 p_ls = 2; 5251 p_wmh = 0; 5252 last_status(FALSE); 5253 } 5254 wild_menu_showing = WM_SHOWN; 5255 } 5256 } 5257 5258 screen_puts(buf, row, 0, attr); 5259 if (selstart != NULL && highlight) 5260 { 5261 *selend = NUL; 5262 screen_puts(selstart, row, selstart_col, hl_attr(HLF_WM)); 5263 } 5264 5265 screen_fill(row, row + 1, clen, (int)Columns, fillchar, fillchar, attr); 5266 } 5267 5268 #ifdef FEAT_VERTSPLIT 5269 win_redraw_last_status(topframe); 5270 #else 5271 lastwin->w_redr_status = TRUE; 5272 #endif 5273 vim_free(buf); 5274 } 5275 #endif 5276 5277 #if defined(FEAT_WINDOWS) || defined(PROTO) 5278 /* 5279 * Redraw the status line of window wp. 5280 * 5281 * If inversion is possible we use it. Else '=' characters are used. 5282 */ 5283 void 5284 win_redr_status(wp) 5285 win_T *wp; 5286 { 5287 int row; 5288 char_u *p; 5289 int len; 5290 int fillchar; 5291 int attr; 5292 int this_ru_col; 5293 5294 wp->w_redr_status = FALSE; 5295 if (wp->w_status_height == 0) 5296 { 5297 /* no status line, can only be last window */ 5298 redraw_cmdline = TRUE; 5299 } 5300 else if (!redrawing() 5301 #ifdef FEAT_INS_EXPAND 5302 /* don't update status line when popup menu is visible and may be 5303 * drawn over it */ 5304 || pum_visible() 5305 #endif 5306 ) 5307 { 5308 /* Don't redraw right now, do it later. */ 5309 wp->w_redr_status = TRUE; 5310 } 5311 #ifdef FEAT_STL_OPT 5312 else if (*p_stl != NUL || *wp->w_p_stl != NUL) 5313 { 5314 /* redraw custom status line */ 5315 win_redr_custom(wp, FALSE); 5316 } 5317 #endif 5318 else 5319 { 5320 fillchar = fillchar_status(&attr, wp == curwin); 5321 5322 if (buf_spname(wp->w_buffer) != NULL) 5323 STRCPY(NameBuff, buf_spname(wp->w_buffer)); 5324 else 5325 home_replace(wp->w_buffer, wp->w_buffer->b_fname, NameBuff, 5326 MAXPATHL, TRUE); 5327 trans_characters(NameBuff, MAXPATHL); 5328 p = NameBuff; 5329 len = (int)STRLEN(p); 5330 5331 if (wp->w_buffer->b_help 5332 #ifdef FEAT_QUICKFIX 5333 || wp->w_p_pvw 5334 #endif 5335 || bufIsChanged(wp->w_buffer) 5336 || wp->w_buffer->b_p_ro) 5337 *(p + len++) = ' '; 5338 if (wp->w_buffer->b_help) 5339 { 5340 STRCPY(p + len, _("[help]")); 5341 len += (int)STRLEN(p + len); 5342 } 5343 #ifdef FEAT_QUICKFIX 5344 if (wp->w_p_pvw) 5345 { 5346 STRCPY(p + len, _("[Preview]")); 5347 len += (int)STRLEN(p + len); 5348 } 5349 #endif 5350 if (bufIsChanged(wp->w_buffer)) 5351 { 5352 STRCPY(p + len, "[+]"); 5353 len += 3; 5354 } 5355 if (wp->w_buffer->b_p_ro) 5356 { 5357 STRCPY(p + len, "[RO]"); 5358 len += 4; 5359 } 5360 5361 #ifndef FEAT_VERTSPLIT 5362 this_ru_col = ru_col; 5363 if (this_ru_col < (Columns + 1) / 2) 5364 this_ru_col = (Columns + 1) / 2; 5365 #else 5366 this_ru_col = ru_col - (Columns - W_WIDTH(wp)); 5367 if (this_ru_col < (W_WIDTH(wp) + 1) / 2) 5368 this_ru_col = (W_WIDTH(wp) + 1) / 2; 5369 if (this_ru_col <= 1) 5370 { 5371 p = (char_u *)"<"; /* No room for file name! */ 5372 len = 1; 5373 } 5374 else 5375 #endif 5376 #ifdef FEAT_MBYTE 5377 if (has_mbyte) 5378 { 5379 int clen = 0, i; 5380 5381 /* Count total number of display cells. */ 5382 for (i = 0; p[i] != NUL; i += (*mb_ptr2len)(p + i)) 5383 clen += (*mb_ptr2cells)(p + i); 5384 /* Find first character that will fit. 5385 * Going from start to end is much faster for DBCS. */ 5386 for (i = 0; p[i] != NUL && clen >= this_ru_col - 1; 5387 i += (*mb_ptr2len)(p + i)) 5388 clen -= (*mb_ptr2cells)(p + i); 5389 len = clen; 5390 if (i > 0) 5391 { 5392 p = p + i - 1; 5393 *p = '<'; 5394 ++len; 5395 } 5396 5397 } 5398 else 5399 #endif 5400 if (len > this_ru_col - 1) 5401 { 5402 p += len - (this_ru_col - 1); 5403 *p = '<'; 5404 len = this_ru_col - 1; 5405 } 5406 5407 row = W_WINROW(wp) + wp->w_height; 5408 screen_puts(p, row, W_WINCOL(wp), attr); 5409 screen_fill(row, row + 1, len + W_WINCOL(wp), 5410 this_ru_col + W_WINCOL(wp), fillchar, fillchar, attr); 5411 5412 if (get_keymap_str(wp, NameBuff, MAXPATHL) 5413 && (int)(this_ru_col - len) > (int)(STRLEN(NameBuff) + 1)) 5414 screen_puts(NameBuff, row, (int)(this_ru_col - STRLEN(NameBuff) 5415 - 1 + W_WINCOL(wp)), attr); 5416 5417 #ifdef FEAT_CMDL_INFO 5418 win_redr_ruler(wp, TRUE); 5419 #endif 5420 } 5421 5422 #ifdef FEAT_VERTSPLIT 5423 /* 5424 * May need to draw the character below the vertical separator. 5425 */ 5426 if (wp->w_vsep_width != 0 && wp->w_status_height != 0 && redrawing()) 5427 { 5428 if (stl_connected(wp)) 5429 fillchar = fillchar_status(&attr, wp == curwin); 5430 else 5431 fillchar = fillchar_vsep(&attr); 5432 screen_putchar(fillchar, W_WINROW(wp) + wp->w_height, W_ENDCOL(wp), 5433 attr); 5434 } 5435 #endif 5436 } 5437 5438 # ifdef FEAT_VERTSPLIT 5439 /* 5440 * Return TRUE if the status line of window "wp" is connected to the status 5441 * line of the window right of it. If not, then it's a vertical separator. 5442 * Only call if (wp->w_vsep_width != 0). 5443 */ 5444 int 5445 stl_connected(wp) 5446 win_T *wp; 5447 { 5448 frame_T *fr; 5449 5450 fr = wp->w_frame; 5451 while (fr->fr_parent != NULL) 5452 { 5453 if (fr->fr_parent->fr_layout == FR_COL) 5454 { 5455 if (fr->fr_next != NULL) 5456 break; 5457 } 5458 else 5459 { 5460 if (fr->fr_next != NULL) 5461 return TRUE; 5462 } 5463 fr = fr->fr_parent; 5464 } 5465 return FALSE; 5466 } 5467 # endif 5468 5469 #endif /* FEAT_WINDOWS */ 5470 5471 #if defined(FEAT_WINDOWS) || defined(FEAT_STL_OPT) || defined(PROTO) 5472 /* 5473 * Get the value to show for the language mappings, active 'keymap'. 5474 */ 5475 int 5476 get_keymap_str(wp, buf, len) 5477 win_T *wp; 5478 char_u *buf; /* buffer for the result */ 5479 int len; /* length of buffer */ 5480 { 5481 char_u *p; 5482 5483 if (wp->w_buffer->b_p_iminsert != B_IMODE_LMAP) 5484 return FALSE; 5485 5486 { 5487 #ifdef FEAT_EVAL 5488 buf_T *old_curbuf = curbuf; 5489 win_T *old_curwin = curwin; 5490 char_u *s; 5491 5492 curbuf = wp->w_buffer; 5493 curwin = wp; 5494 STRCPY(buf, "b:keymap_name"); /* must be writable */ 5495 ++emsg_skip; 5496 s = p = eval_to_string(buf, NULL); 5497 --emsg_skip; 5498 curbuf = old_curbuf; 5499 curwin = old_curwin; 5500 if (p == NULL || *p == NUL) 5501 #endif 5502 { 5503 #ifdef FEAT_KEYMAP 5504 if (wp->w_buffer->b_kmap_state & KEYMAP_LOADED) 5505 p = wp->w_buffer->b_p_keymap; 5506 else 5507 #endif 5508 p = (char_u *)"lang"; 5509 } 5510 if ((int)(STRLEN(p) + 3) < len) 5511 sprintf((char *)buf, "<%s>", p); 5512 else 5513 buf[0] = NUL; 5514 #ifdef FEAT_EVAL 5515 vim_free(s); 5516 #endif 5517 } 5518 return buf[0] != NUL; 5519 } 5520 #endif 5521 5522 #if defined(FEAT_STL_OPT) || defined(PROTO) 5523 /* 5524 * Redraw the status line or ruler of window wp. 5525 */ 5526 static void 5527 win_redr_custom(wp, Ruler) 5528 win_T *wp; 5529 int Ruler; 5530 { 5531 int attr; 5532 int curattr; 5533 int row; 5534 int col = 0; 5535 int maxwidth; 5536 int width; 5537 int n; 5538 int len; 5539 int fillchar; 5540 char_u buf[MAXPATHL]; 5541 char_u *p; 5542 struct stl_hlrec hl[STL_MAX_ITEM]; 5543 5544 /* setup environment for the task at hand */ 5545 row = W_WINROW(wp) + wp->w_height; 5546 fillchar = fillchar_status(&attr, wp == curwin); 5547 maxwidth = W_WIDTH(wp); 5548 if (*wp->w_p_stl != NUL) 5549 p = wp->w_p_stl; 5550 else 5551 p = p_stl; 5552 if (Ruler) 5553 { 5554 p = p_ruf; 5555 /* advance past any leading group spec - implicit in ru_col */ 5556 if (*p == '%') 5557 { 5558 if (*++p == '-') 5559 p++; 5560 if (atoi((char *) p)) 5561 while (VIM_ISDIGIT(*p)) 5562 p++; 5563 if (*p++ != '(') 5564 p = p_ruf; 5565 } 5566 #ifdef FEAT_VERTSPLIT 5567 col = ru_col - (Columns - W_WIDTH(wp)); 5568 if (col < (W_WIDTH(wp) + 1) / 2) 5569 col = (W_WIDTH(wp) + 1) / 2; 5570 #else 5571 col = ru_col; 5572 if (col > (Columns + 1) / 2) 5573 col = (Columns + 1) / 2; 5574 #endif 5575 maxwidth = W_WIDTH(wp) - col; 5576 #ifdef FEAT_WINDOWS 5577 if (!wp->w_status_height) 5578 #endif 5579 { 5580 row = Rows - 1; 5581 --maxwidth; /* writing in last column may cause scrolling */ 5582 fillchar = ' '; 5583 attr = 0; 5584 } 5585 } 5586 if (maxwidth <= 0) 5587 return; 5588 #ifdef FEAT_VERTSPLIT 5589 col += W_WINCOL(wp); 5590 #endif 5591 5592 width = build_stl_str_hl(wp, buf, sizeof(buf), p, fillchar, maxwidth, hl); 5593 len = STRLEN(buf); 5594 5595 while (width < maxwidth && len < sizeof(buf) - 1) 5596 { 5597 #ifdef FEAT_MBYTE 5598 len += (*mb_char2bytes)(fillchar, buf + len); 5599 #else 5600 buf[len++] = fillchar; 5601 #endif 5602 ++width; 5603 } 5604 buf[len] = NUL; 5605 5606 curattr = attr; 5607 p = buf; 5608 for (n = 0; hl[n].start != NULL; n++) 5609 { 5610 len = (int)(hl[n].start - p); 5611 screen_puts_len(p, len, row, col, curattr); 5612 col += vim_strnsize(p, len); 5613 p = hl[n].start; 5614 5615 if (hl[n].userhl == 0) 5616 curattr = attr; 5617 #ifdef FEAT_WINDOWS 5618 else if (wp != curwin && wp->w_status_height != 0) 5619 curattr = highlight_stlnc[hl[n].userhl - 1]; 5620 #endif 5621 else 5622 curattr = highlight_user[hl[n].userhl - 1]; 5623 } 5624 screen_puts(p, row, col, curattr); 5625 } 5626 5627 #endif /* FEAT_STL_OPT */ 5628 5629 /* 5630 * Output a single character directly to the screen and update ScreenLines. 5631 */ 5632 void 5633 screen_putchar(c, row, col, attr) 5634 int c; 5635 int row, col; 5636 int attr; 5637 { 5638 #ifdef FEAT_MBYTE 5639 char_u buf[MB_MAXBYTES + 1]; 5640 5641 buf[(*mb_char2bytes)(c, buf)] = NUL; 5642 #else 5643 char_u buf[2]; 5644 5645 buf[0] = c; 5646 buf[1] = NUL; 5647 #endif 5648 screen_puts(buf, row, col, attr); 5649 } 5650 5651 /* 5652 * Get a single character directly from ScreenLines into "bytes[]". 5653 * Also return its attribute in *attrp; 5654 */ 5655 void 5656 screen_getbytes(row, col, bytes, attrp) 5657 int row, col; 5658 char_u *bytes; 5659 int *attrp; 5660 { 5661 unsigned off; 5662 5663 /* safety check */ 5664 if (ScreenLines != NULL && row < screen_Rows && col < screen_Columns) 5665 { 5666 off = LineOffset[row] + col; 5667 *attrp = ScreenAttrs[off]; 5668 bytes[0] = ScreenLines[off]; 5669 bytes[1] = NUL; 5670 5671 #ifdef FEAT_MBYTE 5672 if (enc_utf8 && ScreenLinesUC[off] != 0) 5673 bytes[utfc_char2bytes(off, bytes)] = NUL; 5674 else if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e) 5675 { 5676 bytes[0] = ScreenLines[off]; 5677 bytes[1] = ScreenLines2[off]; 5678 bytes[2] = NUL; 5679 } 5680 else if (enc_dbcs && MB_BYTE2LEN(bytes[0]) > 1) 5681 { 5682 bytes[1] = ScreenLines[off + 1]; 5683 bytes[2] = NUL; 5684 } 5685 #endif 5686 } 5687 } 5688 5689 /* 5690 * Put string '*text' on the screen at position 'row' and 'col', with 5691 * attributes 'attr', and update ScreenLines[] and ScreenAttrs[]. 5692 * Note: only outputs within one row, message is truncated at screen boundary! 5693 * Note: if ScreenLines[], row and/or col is invalid, nothing is done. 5694 */ 5695 void 5696 screen_puts(text, row, col, attr) 5697 char_u *text; 5698 int row; 5699 int col; 5700 int attr; 5701 { 5702 screen_puts_len(text, -1, row, col, attr); 5703 } 5704 5705 /* 5706 * Like screen_puts(), but output "text[len]". When "len" is -1 output up to 5707 * a NUL. 5708 */ 5709 void 5710 screen_puts_len(text, len, row, col, attr) 5711 char_u *text; 5712 int len; 5713 int row; 5714 int col; 5715 int attr; 5716 { 5717 unsigned off; 5718 char_u *ptr = text; 5719 int c; 5720 #ifdef FEAT_MBYTE 5721 int mbyte_blen = 1; 5722 int mbyte_cells = 1; 5723 int u8c = 0; 5724 int u8c_c1 = 0; 5725 int u8c_c2 = 0; 5726 int clear_next_cell = FALSE; 5727 # ifdef FEAT_ARABIC 5728 int prev_c = 0; /* previous Arabic character */ 5729 int pc, nc, nc1, dummy; 5730 # endif 5731 #endif 5732 5733 if (ScreenLines == NULL || row >= screen_Rows) /* safety check */ 5734 return; 5735 5736 off = LineOffset[row] + col; 5737 while (*ptr != NUL && col < screen_Columns 5738 && (len < 0 || (int)(ptr - text) < len)) 5739 { 5740 c = *ptr; 5741 #ifdef FEAT_MBYTE 5742 /* check if this is the first byte of a multibyte */ 5743 if (has_mbyte) 5744 { 5745 if (enc_utf8 && len > 0) 5746 mbyte_blen = utfc_ptr2len_len(ptr, (int)((text + len) - ptr)); 5747 else 5748 mbyte_blen = (*mb_ptr2len)(ptr); 5749 if (enc_dbcs == DBCS_JPNU && c == 0x8e) 5750 mbyte_cells = 1; 5751 else if (enc_dbcs != 0) 5752 mbyte_cells = mbyte_blen; 5753 else /* enc_utf8 */ 5754 { 5755 if (len >= 0) 5756 u8c = utfc_ptr2char_len(ptr, &u8c_c1, &u8c_c2, 5757 (int)((text + len) - ptr)); 5758 else 5759 u8c = utfc_ptr2char(ptr, &u8c_c1, &u8c_c2); 5760 mbyte_cells = utf_char2cells(u8c); 5761 /* Non-BMP character: display as ? or fullwidth ?. */ 5762 if (u8c >= 0x10000) 5763 { 5764 u8c = (mbyte_cells == 2) ? 0xff1f : (int)'?'; 5765 if (attr == 0) 5766 attr = hl_attr(HLF_8); 5767 } 5768 # ifdef FEAT_ARABIC 5769 if (p_arshape && !p_tbidi && ARABIC_CHAR(u8c)) 5770 { 5771 /* Do Arabic shaping. */ 5772 if (len >= 0 && (int)(ptr - text) + mbyte_blen >= len) 5773 { 5774 /* Past end of string to be displayed. */ 5775 nc = NUL; 5776 nc1 = NUL; 5777 } 5778 else 5779 nc = utfc_ptr2char(ptr + mbyte_blen, &nc1, &dummy); 5780 pc = prev_c; 5781 prev_c = u8c; 5782 u8c = arabic_shape(u8c, &c, &u8c_c1, nc, nc1, pc); 5783 } 5784 else 5785 prev_c = u8c; 5786 # endif 5787 } 5788 } 5789 #endif 5790 5791 if (ScreenLines[off] != c 5792 #ifdef FEAT_MBYTE 5793 || (mbyte_cells == 2 5794 && ScreenLines[off + 1] != (enc_dbcs ? ptr[1] : 0)) 5795 || (enc_dbcs == DBCS_JPNU 5796 && c == 0x8e 5797 && ScreenLines2[off] != ptr[1]) 5798 || (enc_utf8 5799 && mbyte_blen > 1 5800 && (ScreenLinesUC[off] != u8c 5801 || ScreenLinesC1[off] != u8c_c1 5802 || ScreenLinesC2[off] != u8c_c2)) 5803 #endif 5804 || ScreenAttrs[off] != attr 5805 || exmode_active 5806 ) 5807 { 5808 #if defined(FEAT_GUI) || defined(UNIX) 5809 /* The bold trick makes a single row of pixels appear in the next 5810 * character. When a bold character is removed, the next 5811 * character should be redrawn too. This happens for our own GUI 5812 * and for some xterms. 5813 * Force the redraw by setting the attribute to a different value 5814 * than "attr", the contents of ScreenLines[] may be needed by 5815 * mb_off2cells() further on. 5816 * Don't do this for the last drawn character, because the next 5817 * character may not be redrawn. */ 5818 if ( 5819 # ifdef FEAT_GUI 5820 gui.in_use 5821 # endif 5822 # if defined(FEAT_GUI) && defined(UNIX) 5823 || 5824 # endif 5825 # ifdef UNIX 5826 term_is_xterm 5827 # endif 5828 ) 5829 { 5830 int n; 5831 5832 n = ScreenAttrs[off]; 5833 # ifdef FEAT_MBYTE 5834 if (col + mbyte_cells < screen_Columns 5835 && (n > HL_ALL || (n & HL_BOLD)) 5836 && (len < 0 ? ptr[mbyte_blen] != NUL 5837 : ptr + mbyte_blen < text + len)) 5838 ScreenAttrs[off + mbyte_cells] = attr + 1; 5839 # else 5840 if (col + 1 < screen_Columns 5841 && (n > HL_ALL || (n & HL_BOLD)) 5842 && (len < 0 ? ptr[1] != NUL : ptr + 1 < text + len)) 5843 ScreenLines[off + 1] = 0; 5844 # endif 5845 } 5846 #endif 5847 #ifdef FEAT_MBYTE 5848 /* When at the end of the text and overwriting a two-cell 5849 * character with a one-cell character, need to clear the next 5850 * cell. Also when overwriting the left halve of a two-cell char 5851 * with the right halve of a two-cell char. Do this only once 5852 * (mb_off2cells() may return 2 on the right halve). */ 5853 if (clear_next_cell) 5854 clear_next_cell = FALSE; 5855 else if (has_mbyte 5856 && (len < 0 ? ptr[mbyte_blen] == NUL 5857 : ptr + mbyte_blen >= text + len) 5858 && ((mbyte_cells == 1 && (*mb_off2cells)(off) > 1) 5859 || (mbyte_cells == 2 5860 && (*mb_off2cells)(off) == 1 5861 && (*mb_off2cells)(off + 1) > 1))) 5862 clear_next_cell = TRUE; 5863 5864 /* Make sure we never leave a second byte of a double-byte behind, 5865 * it confuses mb_off2cells(). */ 5866 if (enc_dbcs 5867 && ((mbyte_cells == 1 && (*mb_off2cells)(off) > 1) 5868 || (mbyte_cells == 2 5869 && (*mb_off2cells)(off) == 1 5870 && (*mb_off2cells)(off + 1) > 1))) 5871 ScreenLines[off + mbyte_blen] = 0; 5872 #endif 5873 ScreenLines[off] = c; 5874 ScreenAttrs[off] = attr; 5875 #ifdef FEAT_MBYTE 5876 if (enc_utf8) 5877 { 5878 if (c < 0x80 && u8c_c1 == 0 && u8c_c2 == 0) 5879 ScreenLinesUC[off] = 0; 5880 else 5881 { 5882 ScreenLinesUC[off] = u8c; 5883 ScreenLinesC1[off] = u8c_c1; 5884 ScreenLinesC2[off] = u8c_c2; 5885 } 5886 if (mbyte_cells == 2) 5887 { 5888 ScreenLines[off + 1] = 0; 5889 ScreenAttrs[off + 1] = attr; 5890 } 5891 screen_char(off, row, col); 5892 } 5893 else if (mbyte_cells == 2) 5894 { 5895 ScreenLines[off + 1] = ptr[1]; 5896 ScreenAttrs[off + 1] = attr; 5897 screen_char_2(off, row, col); 5898 } 5899 else if (enc_dbcs == DBCS_JPNU && c == 0x8e) 5900 { 5901 ScreenLines2[off] = ptr[1]; 5902 screen_char(off, row, col); 5903 } 5904 else 5905 #endif 5906 screen_char(off, row, col); 5907 } 5908 #ifdef FEAT_MBYTE 5909 if (has_mbyte) 5910 { 5911 off += mbyte_cells; 5912 col += mbyte_cells; 5913 ptr += mbyte_blen; 5914 if (clear_next_cell) 5915 ptr = (char_u *)" "; 5916 } 5917 else 5918 #endif 5919 { 5920 ++off; 5921 ++col; 5922 ++ptr; 5923 } 5924 } 5925 } 5926 5927 #ifdef FEAT_SEARCH_EXTRA 5928 /* 5929 * Prepare for 'searchhl' highlighting. 5930 */ 5931 static void 5932 start_search_hl() 5933 { 5934 if (p_hls && !no_hlsearch) 5935 { 5936 last_pat_prog(&search_hl.rm); 5937 search_hl.attr = hl_attr(HLF_L); 5938 } 5939 } 5940 5941 /* 5942 * Clean up for 'searchhl' highlighting. 5943 */ 5944 static void 5945 end_search_hl() 5946 { 5947 if (search_hl.rm.regprog != NULL) 5948 { 5949 vim_free(search_hl.rm.regprog); 5950 search_hl.rm.regprog = NULL; 5951 } 5952 } 5953 5954 /* 5955 * Advance to the match in window "wp" line "lnum" or past it. 5956 */ 5957 static void 5958 prepare_search_hl(wp, lnum) 5959 win_T *wp; 5960 linenr_T lnum; 5961 { 5962 match_T *shl; /* points to search_hl or match_hl */ 5963 int n; 5964 5965 /* 5966 * When using a multi-line pattern, start searching at the top 5967 * of the window or just after a closed fold. 5968 * Do this both for search_hl and match_hl. 5969 */ 5970 shl = &search_hl; 5971 for (;;) 5972 { 5973 if (shl->rm.regprog != NULL 5974 && shl->lnum == 0 5975 && re_multiline(shl->rm.regprog)) 5976 { 5977 if (shl->first_lnum == 0) 5978 { 5979 # ifdef FEAT_FOLDING 5980 for (shl->first_lnum = lnum; 5981 shl->first_lnum > wp->w_topline; --shl->first_lnum) 5982 if (hasFoldingWin(wp, shl->first_lnum - 1, 5983 NULL, NULL, TRUE, NULL)) 5984 break; 5985 # else 5986 shl->first_lnum = wp->w_topline; 5987 # endif 5988 } 5989 n = 0; 5990 while (shl->first_lnum < lnum && shl->rm.regprog != NULL) 5991 { 5992 next_search_hl(wp, shl, shl->first_lnum, (colnr_T)n); 5993 if (shl->lnum != 0) 5994 { 5995 shl->first_lnum = shl->lnum 5996 + shl->rm.endpos[0].lnum 5997 - shl->rm.startpos[0].lnum; 5998 n = shl->rm.endpos[0].col; 5999 } 6000 else 6001 { 6002 ++shl->first_lnum; 6003 n = 0; 6004 } 6005 } 6006 } 6007 if (shl == &match_hl) 6008 break; 6009 shl = &match_hl; 6010 } 6011 } 6012 6013 /* 6014 * Search for a next 'searchl' or ":match" match. 6015 * Uses shl->buf. 6016 * Sets shl->lnum and shl->rm contents. 6017 * Note: Assumes a previous match is always before "lnum", unless 6018 * shl->lnum is zero. 6019 * Careful: Any pointers for buffer lines will become invalid. 6020 */ 6021 static void 6022 next_search_hl(win, shl, lnum, mincol) 6023 win_T *win; 6024 match_T *shl; /* points to search_hl or match_hl */ 6025 linenr_T lnum; 6026 colnr_T mincol; /* minimal column for a match */ 6027 { 6028 linenr_T l; 6029 colnr_T matchcol; 6030 long nmatched; 6031 6032 if (shl->lnum != 0) 6033 { 6034 /* Check for three situations: 6035 * 1. If the "lnum" is below a previous match, start a new search. 6036 * 2. If the previous match includes "mincol", use it. 6037 * 3. Continue after the previous match. 6038 */ 6039 l = shl->lnum + shl->rm.endpos[0].lnum - shl->rm.startpos[0].lnum; 6040 if (lnum > l) 6041 shl->lnum = 0; 6042 else if (lnum < l || shl->rm.endpos[0].col > mincol) 6043 return; 6044 } 6045 6046 /* 6047 * Repeat searching for a match until one is found that includes "mincol" 6048 * or none is found in this line. 6049 */ 6050 called_emsg = FALSE; 6051 for (;;) 6052 { 6053 /* Three situations: 6054 * 1. No useful previous match: search from start of line. 6055 * 2. Not Vi compatible or empty match: continue at next character. 6056 * Break the loop if this is beyond the end of the line. 6057 * 3. Vi compatible searching: continue at end of previous match. 6058 */ 6059 if (shl->lnum == 0) 6060 matchcol = 0; 6061 else if (vim_strchr(p_cpo, CPO_SEARCH) == NULL 6062 || (shl->rm.endpos[0].lnum == 0 6063 && shl->rm.endpos[0].col == shl->rm.startpos[0].col)) 6064 { 6065 matchcol = shl->rm.startpos[0].col + 1; 6066 if (ml_get_buf(shl->buf, lnum, FALSE)[matchcol - 1] == NUL) 6067 { 6068 shl->lnum = 0; 6069 break; 6070 } 6071 } 6072 else 6073 matchcol = shl->rm.endpos[0].col; 6074 6075 shl->lnum = lnum; 6076 nmatched = vim_regexec_multi(&shl->rm, win, shl->buf, lnum, matchcol); 6077 if (called_emsg) 6078 { 6079 /* Error while handling regexp: stop using this regexp. */ 6080 vim_free(shl->rm.regprog); 6081 shl->rm.regprog = NULL; 6082 no_hlsearch = TRUE; 6083 break; 6084 } 6085 if (nmatched == 0) 6086 { 6087 shl->lnum = 0; /* no match found */ 6088 break; 6089 } 6090 if (shl->rm.startpos[0].lnum > 0 6091 || shl->rm.startpos[0].col >= mincol 6092 || nmatched > 1 6093 || shl->rm.endpos[0].col > mincol) 6094 { 6095 shl->lnum += shl->rm.startpos[0].lnum; 6096 break; /* useful match found */ 6097 } 6098 } 6099 } 6100 #endif 6101 6102 static void 6103 screen_start_highlight(attr) 6104 int attr; 6105 { 6106 attrentry_T *aep = NULL; 6107 6108 screen_attr = attr; 6109 if (full_screen 6110 #ifdef WIN3264 6111 && termcap_active 6112 #endif 6113 ) 6114 { 6115 #ifdef FEAT_GUI 6116 if (gui.in_use) 6117 { 6118 char buf[20]; 6119 6120 sprintf(buf, IF_EB("\033|%dh", ESC_STR "|%dh"), attr); /* internal GUI code */ 6121 OUT_STR(buf); 6122 } 6123 else 6124 #endif 6125 { 6126 if (attr > HL_ALL) /* special HL attr. */ 6127 { 6128 if (t_colors > 1) 6129 aep = syn_cterm_attr2entry(attr); 6130 else 6131 aep = syn_term_attr2entry(attr); 6132 if (aep == NULL) /* did ":syntax clear" */ 6133 attr = 0; 6134 else 6135 attr = aep->ae_attr; 6136 } 6137 if ((attr & HL_BOLD) && T_MD != NULL) /* bold */ 6138 out_str(T_MD); 6139 if ((attr & HL_STANDOUT) && T_SO != NULL) /* standout */ 6140 out_str(T_SO); 6141 if ((attr & (HL_UNDERLINE | HL_UNDERCURL)) && T_US != NULL) 6142 /* underline or undercurl */ 6143 out_str(T_US); 6144 if ((attr & HL_ITALIC) && T_CZH != NULL) /* italic */ 6145 out_str(T_CZH); 6146 if ((attr & HL_INVERSE) && T_MR != NULL) /* inverse (reverse) */ 6147 out_str(T_MR); 6148 6149 /* 6150 * Output the color or start string after bold etc., in case the 6151 * bold etc. override the color setting. 6152 */ 6153 if (aep != NULL) 6154 { 6155 if (t_colors > 1) 6156 { 6157 if (aep->ae_u.cterm.fg_color) 6158 term_fg_color(aep->ae_u.cterm.fg_color - 1); 6159 if (aep->ae_u.cterm.bg_color) 6160 term_bg_color(aep->ae_u.cterm.bg_color - 1); 6161 } 6162 else 6163 { 6164 if (aep->ae_u.term.start != NULL) 6165 out_str(aep->ae_u.term.start); 6166 } 6167 } 6168 } 6169 } 6170 } 6171 6172 void 6173 screen_stop_highlight() 6174 { 6175 int do_ME = FALSE; /* output T_ME code */ 6176 6177 if (screen_attr != 0 6178 #ifdef WIN3264 6179 && termcap_active 6180 #endif 6181 ) 6182 { 6183 #ifdef FEAT_GUI 6184 if (gui.in_use) 6185 { 6186 char buf[20]; 6187 6188 /* use internal GUI code */ 6189 sprintf(buf, IF_EB("\033|%dH", ESC_STR "|%dH"), screen_attr); 6190 OUT_STR(buf); 6191 } 6192 else 6193 #endif 6194 { 6195 if (screen_attr > HL_ALL) /* special HL attr. */ 6196 { 6197 attrentry_T *aep; 6198 6199 if (t_colors > 1) 6200 { 6201 /* 6202 * Assume that t_me restores the original colors! 6203 */ 6204 aep = syn_cterm_attr2entry(screen_attr); 6205 if (aep != NULL && (aep->ae_u.cterm.fg_color 6206 || aep->ae_u.cterm.bg_color)) 6207 do_ME = TRUE; 6208 } 6209 else 6210 { 6211 aep = syn_term_attr2entry(screen_attr); 6212 if (aep != NULL && aep->ae_u.term.stop != NULL) 6213 { 6214 if (STRCMP(aep->ae_u.term.stop, T_ME) == 0) 6215 do_ME = TRUE; 6216 else 6217 out_str(aep->ae_u.term.stop); 6218 } 6219 } 6220 if (aep == NULL) /* did ":syntax clear" */ 6221 screen_attr = 0; 6222 else 6223 screen_attr = aep->ae_attr; 6224 } 6225 6226 /* 6227 * Often all ending-codes are equal to T_ME. Avoid outputting the 6228 * same sequence several times. 6229 */ 6230 if (screen_attr & HL_STANDOUT) 6231 { 6232 if (STRCMP(T_SE, T_ME) == 0) 6233 do_ME = TRUE; 6234 else 6235 out_str(T_SE); 6236 } 6237 if (screen_attr & (HL_UNDERLINE | HL_UNDERCURL)) 6238 { 6239 if (STRCMP(T_UE, T_ME) == 0) 6240 do_ME = TRUE; 6241 else 6242 out_str(T_UE); 6243 } 6244 if (screen_attr & HL_ITALIC) 6245 { 6246 if (STRCMP(T_CZR, T_ME) == 0) 6247 do_ME = TRUE; 6248 else 6249 out_str(T_CZR); 6250 } 6251 if (do_ME || (screen_attr & (HL_BOLD | HL_INVERSE))) 6252 out_str(T_ME); 6253 6254 if (t_colors > 1) 6255 { 6256 /* set Normal cterm colors */ 6257 if (cterm_normal_fg_color != 0) 6258 term_fg_color(cterm_normal_fg_color - 1); 6259 if (cterm_normal_bg_color != 0) 6260 term_bg_color(cterm_normal_bg_color - 1); 6261 if (cterm_normal_fg_bold) 6262 out_str(T_MD); 6263 } 6264 } 6265 } 6266 screen_attr = 0; 6267 } 6268 6269 /* 6270 * Reset the colors for a cterm. Used when leaving Vim. 6271 * The machine specific code may override this again. 6272 */ 6273 void 6274 reset_cterm_colors() 6275 { 6276 if (t_colors > 1) 6277 { 6278 /* set Normal cterm colors */ 6279 if (cterm_normal_fg_color > 0 || cterm_normal_bg_color > 0) 6280 { 6281 out_str(T_OP); 6282 screen_attr = -1; 6283 } 6284 if (cterm_normal_fg_bold) 6285 { 6286 out_str(T_ME); 6287 screen_attr = -1; 6288 } 6289 } 6290 } 6291 6292 /* 6293 * Put character ScreenLines["off"] on the screen at position "row" and "col", 6294 * using the attributes from ScreenAttrs["off"]. 6295 */ 6296 static void 6297 screen_char(off, row, col) 6298 unsigned off; 6299 int row; 6300 int col; 6301 { 6302 int attr; 6303 6304 /* Check for illegal values, just in case (could happen just after 6305 * resizing). */ 6306 if (row >= screen_Rows || col >= screen_Columns) 6307 return; 6308 6309 /* Outputting the last character on the screen may scrollup the screen. 6310 * Don't to it! Mark the character invalid (update it when scrolled up) */ 6311 if (row == screen_Rows - 1 && col == screen_Columns - 1 6312 #ifdef FEAT_RIGHTLEFT 6313 /* account for first command-line character in rightleft mode */ 6314 && !cmdmsg_rl 6315 #endif 6316 ) 6317 { 6318 ScreenAttrs[off] = (sattr_T)-1; 6319 return; 6320 } 6321 6322 /* 6323 * Stop highlighting first, so it's easier to move the cursor. 6324 */ 6325 #if defined(FEAT_CLIPBOARD) || defined(FEAT_VERTSPLIT) 6326 if (screen_char_attr != 0) 6327 attr = screen_char_attr; 6328 else 6329 #endif 6330 attr = ScreenAttrs[off]; 6331 if (screen_attr != attr) 6332 screen_stop_highlight(); 6333 6334 windgoto(row, col); 6335 6336 if (screen_attr != attr) 6337 screen_start_highlight(attr); 6338 6339 #ifdef FEAT_MBYTE 6340 if (enc_utf8 && ScreenLinesUC[off] != 0) 6341 { 6342 char_u buf[MB_MAXBYTES + 1]; 6343 6344 /* Convert UTF-8 character to bytes and write it. */ 6345 6346 buf[utfc_char2bytes(off, buf)] = NUL; 6347 6348 out_str(buf); 6349 if (utf_char2cells(ScreenLinesUC[off]) > 1) 6350 ++screen_cur_col; 6351 } 6352 else 6353 #endif 6354 { 6355 #ifdef FEAT_MBYTE 6356 out_flush_check(); 6357 #endif 6358 out_char(ScreenLines[off]); 6359 #ifdef FEAT_MBYTE 6360 /* double-byte character in single-width cell */ 6361 if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e) 6362 out_char(ScreenLines2[off]); 6363 #endif 6364 } 6365 6366 screen_cur_col++; 6367 } 6368 6369 #ifdef FEAT_MBYTE 6370 6371 /* 6372 * Used for enc_dbcs only: Put one double-wide character at ScreenLines["off"] 6373 * on the screen at position 'row' and 'col'. 6374 * The attributes of the first byte is used for all. This is required to 6375 * output the two bytes of a double-byte character with nothing in between. 6376 */ 6377 static void 6378 screen_char_2(off, row, col) 6379 unsigned off; 6380 int row; 6381 int col; 6382 { 6383 /* Check for illegal values (could be wrong when screen was resized). */ 6384 if (off + 1 >= (unsigned)(screen_Rows * screen_Columns)) 6385 return; 6386 6387 /* Outputting the last character on the screen may scrollup the screen. 6388 * Don't to it! Mark the character invalid (update it when scrolled up) */ 6389 if (row == screen_Rows - 1 && col >= screen_Columns - 2) 6390 { 6391 ScreenAttrs[off] = (sattr_T)-1; 6392 return; 6393 } 6394 6395 /* Output the first byte normally (positions the cursor), then write the 6396 * second byte directly. */ 6397 screen_char(off, row, col); 6398 out_char(ScreenLines[off + 1]); 6399 ++screen_cur_col; 6400 } 6401 #endif 6402 6403 #if defined(FEAT_CLIPBOARD) || defined(FEAT_VERTSPLIT) || defined(PROTO) 6404 /* 6405 * Draw a rectangle of the screen, inverted when "invert" is TRUE. 6406 * This uses the contents of ScreenLines[] and doesn't change it. 6407 */ 6408 void 6409 screen_draw_rectangle(row, col, height, width, invert) 6410 int row; 6411 int col; 6412 int height; 6413 int width; 6414 int invert; 6415 { 6416 int r, c; 6417 int off; 6418 6419 /* Can't use ScreenLines unless initialized */ 6420 if (ScreenLines == NULL) 6421 return; 6422 6423 if (invert) 6424 screen_char_attr = HL_INVERSE; 6425 for (r = row; r < row + height; ++r) 6426 { 6427 off = LineOffset[r]; 6428 for (c = col; c < col + width; ++c) 6429 { 6430 #ifdef FEAT_MBYTE 6431 if (enc_dbcs != 0 && dbcs_off2cells(off + c) > 1) 6432 { 6433 screen_char_2(off + c, r, c); 6434 ++c; 6435 } 6436 else 6437 #endif 6438 { 6439 screen_char(off + c, r, c); 6440 #ifdef FEAT_MBYTE 6441 if (utf_off2cells(off + c) > 1) 6442 ++c; 6443 #endif 6444 } 6445 } 6446 } 6447 screen_char_attr = 0; 6448 } 6449 #endif 6450 6451 #ifdef FEAT_VERTSPLIT 6452 /* 6453 * Redraw the characters for a vertically split window. 6454 */ 6455 static void 6456 redraw_block(row, end, wp) 6457 int row; 6458 int end; 6459 win_T *wp; 6460 { 6461 int col; 6462 int width; 6463 6464 # ifdef FEAT_CLIPBOARD 6465 clip_may_clear_selection(row, end - 1); 6466 # endif 6467 6468 if (wp == NULL) 6469 { 6470 col = 0; 6471 width = Columns; 6472 } 6473 else 6474 { 6475 col = wp->w_wincol; 6476 width = wp->w_width; 6477 } 6478 screen_draw_rectangle(row, col, end - row, width, FALSE); 6479 } 6480 #endif 6481 6482 /* 6483 * Fill the screen from 'start_row' to 'end_row', from 'start_col' to 'end_col' 6484 * with character 'c1' in first column followed by 'c2' in the other columns. 6485 * Use attributes 'attr'. 6486 */ 6487 void 6488 screen_fill(start_row, end_row, start_col, end_col, c1, c2, attr) 6489 int start_row, end_row; 6490 int start_col, end_col; 6491 int c1, c2; 6492 int attr; 6493 { 6494 int row; 6495 int col; 6496 int off; 6497 int end_off; 6498 int did_delete; 6499 int c; 6500 int norm_term; 6501 #if defined(FEAT_GUI) || defined(UNIX) 6502 int force_next = FALSE; 6503 #endif 6504 6505 if (end_row > screen_Rows) /* safety check */ 6506 end_row = screen_Rows; 6507 if (end_col > screen_Columns) /* safety check */ 6508 end_col = screen_Columns; 6509 if (ScreenLines == NULL 6510 || start_row >= end_row 6511 || start_col >= end_col) /* nothing to do */ 6512 return; 6513 6514 /* it's a "normal" terminal when not in a GUI or cterm */ 6515 norm_term = ( 6516 #ifdef FEAT_GUI 6517 !gui.in_use && 6518 #endif 6519 t_colors <= 1); 6520 for (row = start_row; row < end_row; ++row) 6521 { 6522 /* 6523 * Try to use delete-line termcap code, when no attributes or in a 6524 * "normal" terminal, where a bold/italic space is just a 6525 * space. 6526 */ 6527 did_delete = FALSE; 6528 if (c2 == ' ' 6529 && end_col == Columns 6530 && can_clear(T_CE) 6531 && (attr == 0 6532 || (norm_term 6533 && attr <= HL_ALL 6534 && ((attr & ~(HL_BOLD | HL_ITALIC)) == 0)))) 6535 { 6536 /* 6537 * check if we really need to clear something 6538 */ 6539 col = start_col; 6540 if (c1 != ' ') /* don't clear first char */ 6541 ++col; 6542 6543 off = LineOffset[row] + col; 6544 end_off = LineOffset[row] + end_col; 6545 6546 /* skip blanks (used often, keep it fast!) */ 6547 #ifdef FEAT_MBYTE 6548 if (enc_utf8) 6549 while (off < end_off && ScreenLines[off] == ' ' 6550 && ScreenAttrs[off] == 0 && ScreenLinesUC[off] == 0) 6551 ++off; 6552 else 6553 #endif 6554 while (off < end_off && ScreenLines[off] == ' ' 6555 && ScreenAttrs[off] == 0) 6556 ++off; 6557 if (off < end_off) /* something to be cleared */ 6558 { 6559 col = off - LineOffset[row]; 6560 screen_stop_highlight(); 6561 term_windgoto(row, col);/* clear rest of this screen line */ 6562 out_str(T_CE); 6563 screen_start(); /* don't know where cursor is now */ 6564 col = end_col - col; 6565 while (col--) /* clear chars in ScreenLines */ 6566 { 6567 ScreenLines[off] = ' '; 6568 #ifdef FEAT_MBYTE 6569 if (enc_utf8) 6570 ScreenLinesUC[off] = 0; 6571 #endif 6572 ScreenAttrs[off] = 0; 6573 ++off; 6574 } 6575 } 6576 did_delete = TRUE; /* the chars are cleared now */ 6577 } 6578 6579 off = LineOffset[row] + start_col; 6580 c = c1; 6581 for (col = start_col; col < end_col; ++col) 6582 { 6583 if (ScreenLines[off] != c 6584 #ifdef FEAT_MBYTE 6585 || (enc_utf8 && ScreenLinesUC[off] != (c >= 0x80 ? c : 0)) 6586 #endif 6587 || ScreenAttrs[off] != attr 6588 #if defined(FEAT_GUI) || defined(UNIX) 6589 || force_next 6590 #endif 6591 ) 6592 { 6593 #if defined(FEAT_GUI) || defined(UNIX) 6594 /* The bold trick may make a single row of pixels appear in 6595 * the next character. When a bold character is removed, the 6596 * next character should be redrawn too. This happens for our 6597 * own GUI and for some xterms. */ 6598 if ( 6599 # ifdef FEAT_GUI 6600 gui.in_use 6601 # endif 6602 # if defined(FEAT_GUI) && defined(UNIX) 6603 || 6604 # endif 6605 # ifdef UNIX 6606 term_is_xterm 6607 # endif 6608 ) 6609 { 6610 if (ScreenLines[off] != ' ' 6611 && (ScreenAttrs[off] > HL_ALL 6612 || ScreenAttrs[off] & HL_BOLD)) 6613 force_next = TRUE; 6614 else 6615 force_next = FALSE; 6616 } 6617 #endif 6618 ScreenLines[off] = c; 6619 #ifdef FEAT_MBYTE 6620 if (enc_utf8) 6621 { 6622 if (c >= 0x80) 6623 { 6624 ScreenLinesUC[off] = c; 6625 ScreenLinesC1[off] = 0; 6626 ScreenLinesC2[off] = 0; 6627 } 6628 else 6629 ScreenLinesUC[off] = 0; 6630 } 6631 #endif 6632 ScreenAttrs[off] = attr; 6633 if (!did_delete || c != ' ') 6634 screen_char(off, row, col); 6635 } 6636 ++off; 6637 if (col == start_col) 6638 { 6639 if (did_delete) 6640 break; 6641 c = c2; 6642 } 6643 } 6644 if (end_col == Columns) 6645 LineWraps[row] = FALSE; 6646 if (row == Rows - 1) /* overwritten the command line */ 6647 { 6648 redraw_cmdline = TRUE; 6649 if (c1 == ' ' && c2 == ' ') 6650 clear_cmdline = FALSE; /* command line has been cleared */ 6651 } 6652 } 6653 } 6654 6655 /* 6656 * Check if there should be a delay. Used before clearing or redrawing the 6657 * screen or the command line. 6658 */ 6659 void 6660 check_for_delay(check_msg_scroll) 6661 int check_msg_scroll; 6662 { 6663 if ((emsg_on_display || (check_msg_scroll && msg_scroll)) 6664 && !did_wait_return 6665 && emsg_silent == 0) 6666 { 6667 out_flush(); 6668 ui_delay(1000L, TRUE); 6669 emsg_on_display = FALSE; 6670 if (check_msg_scroll) 6671 msg_scroll = FALSE; 6672 } 6673 } 6674 6675 /* 6676 * screen_valid - allocate screen buffers if size changed 6677 * If "clear" is TRUE: clear screen if it has been resized. 6678 * Returns TRUE if there is a valid screen to write to. 6679 * Returns FALSE when starting up and screen not initialized yet. 6680 */ 6681 int 6682 screen_valid(clear) 6683 int clear; 6684 { 6685 screenalloc(clear); /* allocate screen buffers if size changed */ 6686 return (ScreenLines != NULL); 6687 } 6688 6689 /* 6690 * Resize the shell to Rows and Columns. 6691 * Allocate ScreenLines[] and associated items. 6692 * 6693 * There may be some time between setting Rows and Columns and (re)allocating 6694 * ScreenLines[]. This happens when starting up and when (manually) changing 6695 * the shell size. Always use screen_Rows and screen_Columns to access items 6696 * in ScreenLines[]. Use Rows and Columns for positioning text etc. where the 6697 * final size of the shell is needed. 6698 */ 6699 void 6700 screenalloc(clear) 6701 int clear; 6702 { 6703 int new_row, old_row; 6704 #ifdef FEAT_GUI 6705 int old_Rows; 6706 #endif 6707 win_T *wp; 6708 int outofmem = FALSE; 6709 int len; 6710 schar_T *new_ScreenLines; 6711 #ifdef FEAT_MBYTE 6712 u8char_T *new_ScreenLinesUC = NULL; 6713 u8char_T *new_ScreenLinesC1 = NULL; 6714 u8char_T *new_ScreenLinesC2 = NULL; 6715 schar_T *new_ScreenLines2 = NULL; 6716 #endif 6717 sattr_T *new_ScreenAttrs; 6718 unsigned *new_LineOffset; 6719 char_u *new_LineWraps; 6720 static int entered = FALSE; /* avoid recursiveness */ 6721 static int did_outofmem_msg = FALSE; /* did outofmem message */ 6722 6723 /* 6724 * Allocation of the screen buffers is done only when the size changes and 6725 * when Rows and Columns have been set and we have started doing full 6726 * screen stuff. 6727 */ 6728 if ((ScreenLines != NULL 6729 && Rows == screen_Rows 6730 && Columns == screen_Columns 6731 #ifdef FEAT_MBYTE 6732 && enc_utf8 == (ScreenLinesUC != NULL) 6733 && (enc_dbcs == DBCS_JPNU) == (ScreenLines2 != NULL) 6734 #endif 6735 ) 6736 || Rows == 0 6737 || Columns == 0 6738 || (!full_screen && ScreenLines == NULL)) 6739 return; 6740 6741 /* 6742 * It's possible that we produce an out-of-memory message below, which 6743 * will cause this function to be called again. To break the loop, just 6744 * return here. 6745 */ 6746 if (entered) 6747 return; 6748 entered = TRUE; 6749 6750 win_new_shellsize(); /* fit the windows in the new sized shell */ 6751 6752 comp_col(); /* recompute columns for shown command and ruler */ 6753 6754 /* 6755 * We're changing the size of the screen. 6756 * - Allocate new arrays for ScreenLines and ScreenAttrs. 6757 * - Move lines from the old arrays into the new arrays, clear extra 6758 * lines (unless the screen is going to be cleared). 6759 * - Free the old arrays. 6760 * 6761 * If anything fails, make ScreenLines NULL, so we don't do anything! 6762 * Continuing with the old ScreenLines may result in a crash, because the 6763 * size is wrong. 6764 */ 6765 #ifdef FEAT_WINDOWS 6766 for (wp = firstwin; wp; wp = wp->w_next) 6767 win_free_lsize(wp); 6768 #else 6769 win_free_lsize(curwin); 6770 #endif 6771 6772 new_ScreenLines = (schar_T *)lalloc((long_u)( 6773 (Rows + 1) * Columns * sizeof(schar_T)), FALSE); 6774 #ifdef FEAT_MBYTE 6775 if (enc_utf8) 6776 { 6777 new_ScreenLinesUC = (u8char_T *)lalloc((long_u)( 6778 (Rows + 1) * Columns * sizeof(u8char_T)), FALSE); 6779 new_ScreenLinesC1 = (u8char_T *)lalloc((long_u)( 6780 (Rows + 1) * Columns * sizeof(u8char_T)), FALSE); 6781 new_ScreenLinesC2 = (u8char_T *)lalloc((long_u)( 6782 (Rows + 1) * Columns * sizeof(u8char_T)), FALSE); 6783 } 6784 if (enc_dbcs == DBCS_JPNU) 6785 new_ScreenLines2 = (schar_T *)lalloc((long_u)( 6786 (Rows + 1) * Columns * sizeof(schar_T)), FALSE); 6787 #endif 6788 new_ScreenAttrs = (sattr_T *)lalloc((long_u)( 6789 (Rows + 1) * Columns * sizeof(sattr_T)), FALSE); 6790 new_LineOffset = (unsigned *)lalloc((long_u)( 6791 Rows * sizeof(unsigned)), FALSE); 6792 new_LineWraps = (char_u *)lalloc((long_u)(Rows * sizeof(char_u)), FALSE); 6793 6794 FOR_ALL_WINDOWS(wp) 6795 { 6796 if (win_alloc_lines(wp) == FAIL) 6797 { 6798 outofmem = TRUE; 6799 #ifdef FEAT_WINDOWS 6800 break; 6801 #endif 6802 } 6803 } 6804 6805 if (new_ScreenLines == NULL 6806 #ifdef FEAT_MBYTE 6807 || (enc_utf8 && (new_ScreenLinesUC == NULL 6808 || new_ScreenLinesC1 == NULL || new_ScreenLinesC2 == NULL)) 6809 || (enc_dbcs == DBCS_JPNU && new_ScreenLines2 == NULL) 6810 #endif 6811 || new_ScreenAttrs == NULL 6812 || new_LineOffset == NULL 6813 || new_LineWraps == NULL 6814 || outofmem) 6815 { 6816 if (ScreenLines != NULL || !did_outofmem_msg) 6817 { 6818 /* guess the size */ 6819 do_outofmem_msg((long_u)((Rows + 1) * Columns)); 6820 6821 /* Remember we did this to avoid getting outofmem messages over 6822 * and over again. */ 6823 did_outofmem_msg = TRUE; 6824 } 6825 vim_free(new_ScreenLines); 6826 new_ScreenLines = NULL; 6827 #ifdef FEAT_MBYTE 6828 vim_free(new_ScreenLinesUC); 6829 new_ScreenLinesUC = NULL; 6830 vim_free(new_ScreenLinesC1); 6831 new_ScreenLinesC1 = NULL; 6832 vim_free(new_ScreenLinesC2); 6833 new_ScreenLinesC2 = NULL; 6834 vim_free(new_ScreenLines2); 6835 new_ScreenLines2 = NULL; 6836 #endif 6837 vim_free(new_ScreenAttrs); 6838 new_ScreenAttrs = NULL; 6839 vim_free(new_LineOffset); 6840 new_LineOffset = NULL; 6841 vim_free(new_LineWraps); 6842 new_LineWraps = NULL; 6843 } 6844 else 6845 { 6846 did_outofmem_msg = FALSE; 6847 6848 for (new_row = 0; new_row < Rows; ++new_row) 6849 { 6850 new_LineOffset[new_row] = new_row * Columns; 6851 new_LineWraps[new_row] = FALSE; 6852 6853 /* 6854 * If the screen is not going to be cleared, copy as much as 6855 * possible from the old screen to the new one and clear the rest 6856 * (used when resizing the window at the "--more--" prompt or when 6857 * executing an external command, for the GUI). 6858 */ 6859 if (!clear) 6860 { 6861 (void)vim_memset(new_ScreenLines + new_row * Columns, 6862 ' ', (size_t)Columns * sizeof(schar_T)); 6863 #ifdef FEAT_MBYTE 6864 if (enc_utf8) 6865 { 6866 (void)vim_memset(new_ScreenLinesUC + new_row * Columns, 6867 0, (size_t)Columns * sizeof(u8char_T)); 6868 (void)vim_memset(new_ScreenLinesC1 + new_row * Columns, 6869 0, (size_t)Columns * sizeof(u8char_T)); 6870 (void)vim_memset(new_ScreenLinesC2 + new_row * Columns, 6871 0, (size_t)Columns * sizeof(u8char_T)); 6872 } 6873 if (enc_dbcs == DBCS_JPNU) 6874 (void)vim_memset(new_ScreenLines2 + new_row * Columns, 6875 0, (size_t)Columns * sizeof(schar_T)); 6876 #endif 6877 (void)vim_memset(new_ScreenAttrs + new_row * Columns, 6878 0, (size_t)Columns * sizeof(sattr_T)); 6879 old_row = new_row + (screen_Rows - Rows); 6880 if (old_row >= 0 && ScreenLines != NULL) 6881 { 6882 if (screen_Columns < Columns) 6883 len = screen_Columns; 6884 else 6885 len = Columns; 6886 #ifdef FEAT_MBYTE 6887 /* When switching to utf-8 dont copy characters, they 6888 * may be invalid now. */ 6889 if (!(enc_utf8 && ScreenLinesUC == NULL)) 6890 #endif 6891 mch_memmove(new_ScreenLines + new_LineOffset[new_row], 6892 ScreenLines + LineOffset[old_row], 6893 (size_t)len * sizeof(schar_T)); 6894 #ifdef FEAT_MBYTE 6895 if (enc_utf8 && ScreenLinesUC != NULL) 6896 { 6897 mch_memmove(new_ScreenLinesUC + new_LineOffset[new_row], 6898 ScreenLinesUC + LineOffset[old_row], 6899 (size_t)len * sizeof(u8char_T)); 6900 mch_memmove(new_ScreenLinesC1 + new_LineOffset[new_row], 6901 ScreenLinesC1 + LineOffset[old_row], 6902 (size_t)len * sizeof(u8char_T)); 6903 mch_memmove(new_ScreenLinesC2 + new_LineOffset[new_row], 6904 ScreenLinesC2 + LineOffset[old_row], 6905 (size_t)len * sizeof(u8char_T)); 6906 } 6907 if (enc_dbcs == DBCS_JPNU && ScreenLines2 != NULL) 6908 mch_memmove(new_ScreenLines2 + new_LineOffset[new_row], 6909 ScreenLines2 + LineOffset[old_row], 6910 (size_t)len * sizeof(schar_T)); 6911 #endif 6912 mch_memmove(new_ScreenAttrs + new_LineOffset[new_row], 6913 ScreenAttrs + LineOffset[old_row], 6914 (size_t)len * sizeof(sattr_T)); 6915 } 6916 } 6917 } 6918 /* Use the last line of the screen for the current line. */ 6919 current_ScreenLine = new_ScreenLines + Rows * Columns; 6920 } 6921 6922 free_screenlines(); 6923 6924 ScreenLines = new_ScreenLines; 6925 #ifdef FEAT_MBYTE 6926 ScreenLinesUC = new_ScreenLinesUC; 6927 ScreenLinesC1 = new_ScreenLinesC1; 6928 ScreenLinesC2 = new_ScreenLinesC2; 6929 ScreenLines2 = new_ScreenLines2; 6930 #endif 6931 ScreenAttrs = new_ScreenAttrs; 6932 LineOffset = new_LineOffset; 6933 LineWraps = new_LineWraps; 6934 6935 /* It's important that screen_Rows and screen_Columns reflect the actual 6936 * size of ScreenLines[]. Set them before calling anything. */ 6937 #ifdef FEAT_GUI 6938 old_Rows = screen_Rows; 6939 #endif 6940 screen_Rows = Rows; 6941 screen_Columns = Columns; 6942 6943 must_redraw = CLEAR; /* need to clear the screen later */ 6944 if (clear) 6945 screenclear2(); 6946 6947 #ifdef FEAT_GUI 6948 else if (gui.in_use 6949 && !gui.starting 6950 && ScreenLines != NULL 6951 && old_Rows != Rows) 6952 { 6953 (void)gui_redraw_block(0, 0, (int)Rows - 1, (int)Columns - 1, 0); 6954 /* 6955 * Adjust the position of the cursor, for when executing an external 6956 * command. 6957 */ 6958 if (msg_row >= Rows) /* Rows got smaller */ 6959 msg_row = Rows - 1; /* put cursor at last row */ 6960 else if (Rows > old_Rows) /* Rows got bigger */ 6961 msg_row += Rows - old_Rows; /* put cursor in same place */ 6962 if (msg_col >= Columns) /* Columns got smaller */ 6963 msg_col = Columns - 1; /* put cursor at last column */ 6964 } 6965 #endif 6966 6967 entered = FALSE; 6968 } 6969 6970 void 6971 free_screenlines() 6972 { 6973 vim_free(ScreenLines); 6974 #ifdef FEAT_MBYTE 6975 vim_free(ScreenLinesUC); 6976 vim_free(ScreenLinesC1); 6977 vim_free(ScreenLinesC2); 6978 vim_free(ScreenLines2); 6979 #endif 6980 vim_free(ScreenAttrs); 6981 vim_free(LineOffset); 6982 vim_free(LineWraps); 6983 } 6984 6985 void 6986 screenclear() 6987 { 6988 check_for_delay(FALSE); 6989 screenalloc(FALSE); /* allocate screen buffers if size changed */ 6990 screenclear2(); /* clear the screen */ 6991 } 6992 6993 static void 6994 screenclear2() 6995 { 6996 int i; 6997 6998 if (starting == NO_SCREEN || ScreenLines == NULL 6999 #ifdef FEAT_GUI 7000 || (gui.in_use && gui.starting) 7001 #endif 7002 ) 7003 return; 7004 7005 #ifdef FEAT_GUI 7006 if (!gui.in_use) 7007 #endif 7008 screen_attr = -1; /* force setting the Normal colors */ 7009 screen_stop_highlight(); /* don't want highlighting here */ 7010 7011 #ifdef FEAT_CLIPBOARD 7012 /* disable selection without redrawing it */ 7013 clip_scroll_selection(9999); 7014 #endif 7015 7016 /* blank out ScreenLines */ 7017 for (i = 0; i < Rows; ++i) 7018 { 7019 lineclear(LineOffset[i], (int)Columns); 7020 LineWraps[i] = FALSE; 7021 } 7022 7023 if (can_clear(T_CL)) 7024 { 7025 out_str(T_CL); /* clear the display */ 7026 clear_cmdline = FALSE; 7027 } 7028 else 7029 { 7030 /* can't clear the screen, mark all chars with invalid attributes */ 7031 for (i = 0; i < Rows; ++i) 7032 lineinvalid(LineOffset[i], (int)Columns); 7033 clear_cmdline = TRUE; 7034 } 7035 7036 screen_cleared = TRUE; /* can use contents of ScreenLines now */ 7037 7038 win_rest_invalid(firstwin); 7039 redraw_cmdline = TRUE; 7040 if (must_redraw == CLEAR) /* no need to clear again */ 7041 must_redraw = NOT_VALID; 7042 compute_cmdrow(); 7043 msg_row = cmdline_row; /* put cursor on last line for messages */ 7044 msg_col = 0; 7045 screen_start(); /* don't know where cursor is now */ 7046 msg_scrolled = 0; /* can't scroll back */ 7047 msg_didany = FALSE; 7048 msg_didout = FALSE; 7049 } 7050 7051 /* 7052 * Clear one line in ScreenLines. 7053 */ 7054 static void 7055 lineclear(off, width) 7056 unsigned off; 7057 int width; 7058 { 7059 (void)vim_memset(ScreenLines + off, ' ', (size_t)width * sizeof(schar_T)); 7060 #ifdef FEAT_MBYTE 7061 if (enc_utf8) 7062 (void)vim_memset(ScreenLinesUC + off, 0, 7063 (size_t)width * sizeof(u8char_T)); 7064 #endif 7065 (void)vim_memset(ScreenAttrs + off, 0, (size_t)width * sizeof(sattr_T)); 7066 } 7067 7068 /* 7069 * Mark one line in ScreenLines invalid by setting the attributes to an 7070 * invalid value. 7071 */ 7072 static void 7073 lineinvalid(off, width) 7074 unsigned off; 7075 int width; 7076 { 7077 (void)vim_memset(ScreenAttrs + off, -1, (size_t)width * sizeof(sattr_T)); 7078 } 7079 7080 #ifdef FEAT_VERTSPLIT 7081 /* 7082 * Copy part of a Screenline for vertically split window "wp". 7083 */ 7084 static void 7085 linecopy(to, from, wp) 7086 int to; 7087 int from; 7088 win_T *wp; 7089 { 7090 unsigned off_to = LineOffset[to] + wp->w_wincol; 7091 unsigned off_from = LineOffset[from] + wp->w_wincol; 7092 7093 mch_memmove(ScreenLines + off_to, ScreenLines + off_from, 7094 wp->w_width * sizeof(schar_T)); 7095 # ifdef FEAT_MBYTE 7096 if (enc_utf8) 7097 { 7098 mch_memmove(ScreenLinesUC + off_to, ScreenLinesUC + off_from, 7099 wp->w_width * sizeof(u8char_T)); 7100 mch_memmove(ScreenLinesC1 + off_to, ScreenLinesC1 + off_from, 7101 wp->w_width * sizeof(u8char_T)); 7102 mch_memmove(ScreenLinesC2 + off_to, ScreenLinesC2 + off_from, 7103 wp->w_width * sizeof(u8char_T)); 7104 } 7105 if (enc_dbcs == DBCS_JPNU) 7106 mch_memmove(ScreenLines2 + off_to, ScreenLines2 + off_from, 7107 wp->w_width * sizeof(schar_T)); 7108 # endif 7109 mch_memmove(ScreenAttrs + off_to, ScreenAttrs + off_from, 7110 wp->w_width * sizeof(sattr_T)); 7111 } 7112 #endif 7113 7114 /* 7115 * Return TRUE if clearing with term string "p" would work. 7116 * It can't work when the string is empty or it won't set the right background. 7117 */ 7118 int 7119 can_clear(p) 7120 char_u *p; 7121 { 7122 return (*p != NUL && (t_colors <= 1 7123 #ifdef FEAT_GUI 7124 || gui.in_use 7125 #endif 7126 || cterm_normal_bg_color == 0 || *T_UT != NUL)); 7127 } 7128 7129 /* 7130 * Reset cursor position. Use whenever cursor was moved because of outputting 7131 * something directly to the screen (shell commands) or a terminal control 7132 * code. 7133 */ 7134 void 7135 screen_start() 7136 { 7137 screen_cur_row = screen_cur_col = 9999; 7138 } 7139 7140 /* 7141 * Move the cursor to position "row","col" in the screen. 7142 * This tries to find the most efficient way to move, minimizing the number of 7143 * characters sent to the terminal. 7144 */ 7145 void 7146 windgoto(row, col) 7147 int row; 7148 int col; 7149 { 7150 sattr_T *p; 7151 int i; 7152 int plan; 7153 int cost; 7154 int wouldbe_col; 7155 int noinvcurs; 7156 char_u *bs; 7157 int goto_cost; 7158 int attr; 7159 7160 #define GOTO_COST 7 /* asssume a term_windgoto() takes about 7 chars */ 7161 #define HIGHL_COST 5 /* assume unhighlight takes 5 chars */ 7162 7163 #define PLAN_LE 1 7164 #define PLAN_CR 2 7165 #define PLAN_NL 3 7166 #define PLAN_WRITE 4 7167 /* Can't use ScreenLines unless initialized */ 7168 if (ScreenLines == NULL) 7169 return; 7170 7171 if (col != screen_cur_col || row != screen_cur_row) 7172 { 7173 /* Check for valid position. */ 7174 if (row < 0) /* window without text lines? */ 7175 row = 0; 7176 if (row >= screen_Rows) 7177 row = screen_Rows - 1; 7178 if (col >= screen_Columns) 7179 col = screen_Columns - 1; 7180 7181 /* check if no cursor movement is allowed in highlight mode */ 7182 if (screen_attr && *T_MS == NUL) 7183 noinvcurs = HIGHL_COST; 7184 else 7185 noinvcurs = 0; 7186 goto_cost = GOTO_COST + noinvcurs; 7187 7188 /* 7189 * Plan how to do the positioning: 7190 * 1. Use CR to move it to column 0, same row. 7191 * 2. Use T_LE to move it a few columns to the left. 7192 * 3. Use NL to move a few lines down, column 0. 7193 * 4. Move a few columns to the right with T_ND or by writing chars. 7194 * 7195 * Don't do this if the cursor went beyond the last column, the cursor 7196 * position is unknown then (some terminals wrap, some don't ) 7197 * 7198 * First check if the highlighting attibutes allow us to write 7199 * characters to move the cursor to the right. 7200 */ 7201 if (row >= screen_cur_row && screen_cur_col < Columns) 7202 { 7203 /* 7204 * If the cursor is in the same row, bigger col, we can use CR 7205 * or T_LE. 7206 */ 7207 bs = NULL; /* init for GCC */ 7208 attr = screen_attr; 7209 if (row == screen_cur_row && col < screen_cur_col) 7210 { 7211 /* "le" is preferred over "bc", because "bc" is obsolete */ 7212 if (*T_LE) 7213 bs = T_LE; /* "cursor left" */ 7214 else 7215 bs = T_BC; /* "backspace character (old) */ 7216 if (*bs) 7217 cost = (screen_cur_col - col) * (int)STRLEN(bs); 7218 else 7219 cost = 999; 7220 if (col + 1 < cost) /* using CR is less characters */ 7221 { 7222 plan = PLAN_CR; 7223 wouldbe_col = 0; 7224 cost = 1; /* CR is just one character */ 7225 } 7226 else 7227 { 7228 plan = PLAN_LE; 7229 wouldbe_col = col; 7230 } 7231 if (noinvcurs) /* will stop highlighting */ 7232 { 7233 cost += noinvcurs; 7234 attr = 0; 7235 } 7236 } 7237 7238 /* 7239 * If the cursor is above where we want to be, we can use CR LF. 7240 */ 7241 else if (row > screen_cur_row) 7242 { 7243 plan = PLAN_NL; 7244 wouldbe_col = 0; 7245 cost = (row - screen_cur_row) * 2; /* CR LF */ 7246 if (noinvcurs) /* will stop highlighting */ 7247 { 7248 cost += noinvcurs; 7249 attr = 0; 7250 } 7251 } 7252 7253 /* 7254 * If the cursor is in the same row, smaller col, just use write. 7255 */ 7256 else 7257 { 7258 plan = PLAN_WRITE; 7259 wouldbe_col = screen_cur_col; 7260 cost = 0; 7261 } 7262 7263 /* 7264 * Check if any characters that need to be written have the 7265 * correct attributes. Also avoid UTF-8 characters. 7266 */ 7267 i = col - wouldbe_col; 7268 if (i > 0) 7269 cost += i; 7270 if (cost < goto_cost && i > 0) 7271 { 7272 /* 7273 * Check if the attributes are correct without additionally 7274 * stopping highlighting. 7275 */ 7276 p = ScreenAttrs + LineOffset[row] + wouldbe_col; 7277 while (i && *p++ == attr) 7278 --i; 7279 if (i != 0) 7280 { 7281 /* 7282 * Try if it works when highlighting is stopped here. 7283 */ 7284 if (*--p == 0) 7285 { 7286 cost += noinvcurs; 7287 while (i && *p++ == 0) 7288 --i; 7289 } 7290 if (i != 0) 7291 cost = 999; /* different attributes, don't do it */ 7292 } 7293 #ifdef FEAT_MBYTE 7294 if (enc_utf8) 7295 { 7296 /* Don't use an UTF-8 char for positioning, it's slow. */ 7297 for (i = wouldbe_col; i < col; ++i) 7298 if (ScreenLinesUC[LineOffset[row] + i] != 0) 7299 { 7300 cost = 999; 7301 break; 7302 } 7303 } 7304 #endif 7305 } 7306 7307 /* 7308 * We can do it without term_windgoto()! 7309 */ 7310 if (cost < goto_cost) 7311 { 7312 if (plan == PLAN_LE) 7313 { 7314 if (noinvcurs) 7315 screen_stop_highlight(); 7316 while (screen_cur_col > col) 7317 { 7318 out_str(bs); 7319 --screen_cur_col; 7320 } 7321 } 7322 else if (plan == PLAN_CR) 7323 { 7324 if (noinvcurs) 7325 screen_stop_highlight(); 7326 out_char('\r'); 7327 screen_cur_col = 0; 7328 } 7329 else if (plan == PLAN_NL) 7330 { 7331 if (noinvcurs) 7332 screen_stop_highlight(); 7333 while (screen_cur_row < row) 7334 { 7335 out_char('\n'); 7336 ++screen_cur_row; 7337 } 7338 screen_cur_col = 0; 7339 } 7340 7341 i = col - screen_cur_col; 7342 if (i > 0) 7343 { 7344 /* 7345 * Use cursor-right if it's one character only. Avoids 7346 * removing a line of pixels from the last bold char, when 7347 * using the bold trick in the GUI. 7348 */ 7349 if (T_ND[0] != NUL && T_ND[1] == NUL) 7350 { 7351 while (i-- > 0) 7352 out_char(*T_ND); 7353 } 7354 else 7355 { 7356 int off; 7357 7358 off = LineOffset[row] + screen_cur_col; 7359 while (i-- > 0) 7360 { 7361 if (ScreenAttrs[off] != screen_attr) 7362 screen_stop_highlight(); 7363 #ifdef FEAT_MBYTE 7364 out_flush_check(); 7365 #endif 7366 out_char(ScreenLines[off]); 7367 #ifdef FEAT_MBYTE 7368 if (enc_dbcs == DBCS_JPNU 7369 && ScreenLines[off] == 0x8e) 7370 out_char(ScreenLines2[off]); 7371 #endif 7372 ++off; 7373 } 7374 } 7375 } 7376 } 7377 } 7378 else 7379 cost = 999; 7380 7381 if (cost >= goto_cost) 7382 { 7383 if (noinvcurs) 7384 screen_stop_highlight(); 7385 if (row == screen_cur_row && (col > screen_cur_col) && 7386 *T_CRI != NUL) 7387 term_cursor_right(col - screen_cur_col); 7388 else 7389 term_windgoto(row, col); 7390 } 7391 screen_cur_row = row; 7392 screen_cur_col = col; 7393 } 7394 } 7395 7396 /* 7397 * Set cursor to its position in the current window. 7398 */ 7399 void 7400 setcursor() 7401 { 7402 if (redrawing()) 7403 { 7404 validate_cursor(); 7405 windgoto(W_WINROW(curwin) + curwin->w_wrow, 7406 W_WINCOL(curwin) + ( 7407 #ifdef FEAT_RIGHTLEFT 7408 curwin->w_p_rl ? ((int)W_WIDTH(curwin) - curwin->w_wcol - ( 7409 # ifdef FEAT_MBYTE 7410 has_mbyte ? (*mb_ptr2cells)(ml_get_cursor()) : 7411 # endif 7412 1)) : 7413 #endif 7414 curwin->w_wcol)); 7415 } 7416 } 7417 7418 7419 /* 7420 * insert 'line_count' lines at 'row' in window 'wp' 7421 * if 'invalid' is TRUE the wp->w_lines[].wl_lnum is invalidated. 7422 * if 'mayclear' is TRUE the screen will be cleared if it is faster than 7423 * scrolling. 7424 * Returns FAIL if the lines are not inserted, OK for success. 7425 */ 7426 int 7427 win_ins_lines(wp, row, line_count, invalid, mayclear) 7428 win_T *wp; 7429 int row; 7430 int line_count; 7431 int invalid; 7432 int mayclear; 7433 { 7434 int did_delete; 7435 int nextrow; 7436 int lastrow; 7437 int retval; 7438 7439 if (invalid) 7440 wp->w_lines_valid = 0; 7441 7442 if (wp->w_height < 5) 7443 return FAIL; 7444 7445 if (line_count > wp->w_height - row) 7446 line_count = wp->w_height - row; 7447 7448 retval = win_do_lines(wp, row, line_count, mayclear, FALSE); 7449 if (retval != MAYBE) 7450 return retval; 7451 7452 /* 7453 * If there is a next window or a status line, we first try to delete the 7454 * lines at the bottom to avoid messing what is after the window. 7455 * If this fails and there are following windows, don't do anything to avoid 7456 * messing up those windows, better just redraw. 7457 */ 7458 did_delete = FALSE; 7459 #ifdef FEAT_WINDOWS 7460 if (wp->w_next != NULL || wp->w_status_height) 7461 { 7462 if (screen_del_lines(0, W_WINROW(wp) + wp->w_height - line_count, 7463 line_count, (int)Rows, FALSE, NULL) == OK) 7464 did_delete = TRUE; 7465 else if (wp->w_next) 7466 return FAIL; 7467 } 7468 #endif 7469 /* 7470 * if no lines deleted, blank the lines that will end up below the window 7471 */ 7472 if (!did_delete) 7473 { 7474 #ifdef FEAT_WINDOWS 7475 wp->w_redr_status = TRUE; 7476 #endif 7477 redraw_cmdline = TRUE; 7478 nextrow = W_WINROW(wp) + wp->w_height + W_STATUS_HEIGHT(wp); 7479 lastrow = nextrow + line_count; 7480 if (lastrow > Rows) 7481 lastrow = Rows; 7482 screen_fill(nextrow - line_count, lastrow - line_count, 7483 W_WINCOL(wp), (int)W_ENDCOL(wp), 7484 ' ', ' ', 0); 7485 } 7486 7487 if (screen_ins_lines(0, W_WINROW(wp) + row, line_count, (int)Rows, NULL) 7488 == FAIL) 7489 { 7490 /* deletion will have messed up other windows */ 7491 if (did_delete) 7492 { 7493 #ifdef FEAT_WINDOWS 7494 wp->w_redr_status = TRUE; 7495 #endif 7496 win_rest_invalid(W_NEXT(wp)); 7497 } 7498 return FAIL; 7499 } 7500 7501 return OK; 7502 } 7503 7504 /* 7505 * delete "line_count" window lines at "row" in window "wp" 7506 * If "invalid" is TRUE curwin->w_lines[] is invalidated. 7507 * If "mayclear" is TRUE the screen will be cleared if it is faster than 7508 * scrolling 7509 * Return OK for success, FAIL if the lines are not deleted. 7510 */ 7511 int 7512 win_del_lines(wp, row, line_count, invalid, mayclear) 7513 win_T *wp; 7514 int row; 7515 int line_count; 7516 int invalid; 7517 int mayclear; 7518 { 7519 int retval; 7520 7521 if (invalid) 7522 wp->w_lines_valid = 0; 7523 7524 if (line_count > wp->w_height - row) 7525 line_count = wp->w_height - row; 7526 7527 retval = win_do_lines(wp, row, line_count, mayclear, TRUE); 7528 if (retval != MAYBE) 7529 return retval; 7530 7531 if (screen_del_lines(0, W_WINROW(wp) + row, line_count, 7532 (int)Rows, FALSE, NULL) == FAIL) 7533 return FAIL; 7534 7535 #ifdef FEAT_WINDOWS 7536 /* 7537 * If there are windows or status lines below, try to put them at the 7538 * correct place. If we can't do that, they have to be redrawn. 7539 */ 7540 if (wp->w_next || wp->w_status_height || cmdline_row < Rows - 1) 7541 { 7542 if (screen_ins_lines(0, W_WINROW(wp) + wp->w_height - line_count, 7543 line_count, (int)Rows, NULL) == FAIL) 7544 { 7545 wp->w_redr_status = TRUE; 7546 win_rest_invalid(wp->w_next); 7547 } 7548 } 7549 /* 7550 * If this is the last window and there is no status line, redraw the 7551 * command line later. 7552 */ 7553 else 7554 #endif 7555 redraw_cmdline = TRUE; 7556 return OK; 7557 } 7558 7559 /* 7560 * Common code for win_ins_lines() and win_del_lines(). 7561 * Returns OK or FAIL when the work has been done. 7562 * Returns MAYBE when not finished yet. 7563 */ 7564 static int 7565 win_do_lines(wp, row, line_count, mayclear, del) 7566 win_T *wp; 7567 int row; 7568 int line_count; 7569 int mayclear; 7570 int del; 7571 { 7572 int retval; 7573 7574 if (!redrawing() || line_count <= 0) 7575 return FAIL; 7576 7577 /* only a few lines left: redraw is faster */ 7578 if (mayclear && Rows - line_count < 5 7579 #ifdef FEAT_VERTSPLIT 7580 && wp->w_width == Columns 7581 #endif 7582 ) 7583 { 7584 screenclear(); /* will set wp->w_lines_valid to 0 */ 7585 return FAIL; 7586 } 7587 7588 /* 7589 * Delete all remaining lines 7590 */ 7591 if (row + line_count >= wp->w_height) 7592 { 7593 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + wp->w_height, 7594 W_WINCOL(wp), (int)W_ENDCOL(wp), 7595 ' ', ' ', 0); 7596 return OK; 7597 } 7598 7599 /* 7600 * when scrolling, the message on the command line should be cleared, 7601 * otherwise it will stay there forever. 7602 */ 7603 clear_cmdline = TRUE; 7604 7605 /* 7606 * If the terminal can set a scroll region, use that. 7607 * Always do this in a vertically split window. This will redraw from 7608 * ScreenLines[] when t_CV isn't defined. That's faster than using 7609 * win_line(). 7610 * Don't use a scroll region when we are going to redraw the text, writing 7611 * a character in the lower right corner of the scroll region causes a 7612 * scroll-up in the DJGPP version. 7613 */ 7614 if (scroll_region 7615 #ifdef FEAT_VERTSPLIT 7616 || W_WIDTH(wp) != Columns 7617 #endif 7618 ) 7619 { 7620 #ifdef FEAT_VERTSPLIT 7621 if (scroll_region && (wp->w_width == Columns || *T_CSV != NUL)) 7622 #endif 7623 scroll_region_set(wp, row); 7624 if (del) 7625 retval = screen_del_lines(W_WINROW(wp) + row, 0, line_count, 7626 wp->w_height - row, FALSE, wp); 7627 else 7628 retval = screen_ins_lines(W_WINROW(wp) + row, 0, line_count, 7629 wp->w_height - row, wp); 7630 #ifdef FEAT_VERTSPLIT 7631 if (scroll_region && (wp->w_width == Columns || *T_CSV != NUL)) 7632 #endif 7633 scroll_region_reset(); 7634 return retval; 7635 } 7636 7637 #ifdef FEAT_WINDOWS 7638 if (wp->w_next != NULL && p_tf) /* don't delete/insert on fast terminal */ 7639 return FAIL; 7640 #endif 7641 7642 return MAYBE; 7643 } 7644 7645 /* 7646 * window 'wp' and everything after it is messed up, mark it for redraw 7647 */ 7648 static void 7649 win_rest_invalid(wp) 7650 win_T *wp; 7651 { 7652 #ifdef FEAT_WINDOWS 7653 while (wp != NULL) 7654 #else 7655 if (wp != NULL) 7656 #endif 7657 { 7658 redraw_win_later(wp, NOT_VALID); 7659 #ifdef FEAT_WINDOWS 7660 wp->w_redr_status = TRUE; 7661 wp = wp->w_next; 7662 #endif 7663 } 7664 redraw_cmdline = TRUE; 7665 } 7666 7667 /* 7668 * The rest of the routines in this file perform screen manipulations. The 7669 * given operation is performed physically on the screen. The corresponding 7670 * change is also made to the internal screen image. In this way, the editor 7671 * anticipates the effect of editing changes on the appearance of the screen. 7672 * That way, when we call screenupdate a complete redraw isn't usually 7673 * necessary. Another advantage is that we can keep adding code to anticipate 7674 * screen changes, and in the meantime, everything still works. 7675 */ 7676 7677 /* 7678 * types for inserting or deleting lines 7679 */ 7680 #define USE_T_CAL 1 7681 #define USE_T_CDL 2 7682 #define USE_T_AL 3 7683 #define USE_T_CE 4 7684 #define USE_T_DL 5 7685 #define USE_T_SR 6 7686 #define USE_NL 7 7687 #define USE_T_CD 8 7688 #define USE_REDRAW 9 7689 7690 /* 7691 * insert lines on the screen and update ScreenLines[] 7692 * 'end' is the line after the scrolled part. Normally it is Rows. 7693 * When scrolling region used 'off' is the offset from the top for the region. 7694 * 'row' and 'end' are relative to the start of the region. 7695 * 7696 * return FAIL for failure, OK for success. 7697 */ 7698 int 7699 screen_ins_lines(off, row, line_count, end, wp) 7700 int off; 7701 int row; 7702 int line_count; 7703 int end; 7704 win_T *wp; /* NULL or window to use width from */ 7705 { 7706 int i; 7707 int j; 7708 unsigned temp; 7709 int cursor_row; 7710 int type; 7711 int result_empty; 7712 int can_ce = can_clear(T_CE); 7713 7714 /* 7715 * FAIL if 7716 * - there is no valid screen 7717 * - the screen has to be redrawn completely 7718 * - the line count is less than one 7719 * - the line count is more than 'ttyscroll' 7720 */ 7721 if (!screen_valid(TRUE) || line_count <= 0 || line_count > p_ttyscroll) 7722 return FAIL; 7723 7724 /* 7725 * There are seven ways to insert lines: 7726 * 0. When in a vertically split window and t_CV isn't set, redraw the 7727 * characters from ScreenLines[]. 7728 * 1. Use T_CD (clear to end of display) if it exists and the result of 7729 * the insert is just empty lines 7730 * 2. Use T_CAL (insert multiple lines) if it exists and T_AL is not 7731 * present or line_count > 1. It looks better if we do all the inserts 7732 * at once. 7733 * 3. Use T_CDL (delete multiple lines) if it exists and the result of the 7734 * insert is just empty lines and T_CE is not present or line_count > 7735 * 1. 7736 * 4. Use T_AL (insert line) if it exists. 7737 * 5. Use T_CE (erase line) if it exists and the result of the insert is 7738 * just empty lines. 7739 * 6. Use T_DL (delete line) if it exists and the result of the insert is 7740 * just empty lines. 7741 * 7. Use T_SR (scroll reverse) if it exists and inserting at row 0 and 7742 * the 'da' flag is not set or we have clear line capability. 7743 * 8. redraw the characters from ScreenLines[]. 7744 * 7745 * Careful: In a hpterm scroll reverse doesn't work as expected, it moves 7746 * the scrollbar for the window. It does have insert line, use that if it 7747 * exists. 7748 */ 7749 result_empty = (row + line_count >= end); 7750 #ifdef FEAT_VERTSPLIT 7751 if (wp != NULL && wp->w_width != Columns && *T_CSV == NUL) 7752 type = USE_REDRAW; 7753 else 7754 #endif 7755 if (can_clear(T_CD) && result_empty) 7756 type = USE_T_CD; 7757 else if (*T_CAL != NUL && (line_count > 1 || *T_AL == NUL)) 7758 type = USE_T_CAL; 7759 else if (*T_CDL != NUL && result_empty && (line_count > 1 || !can_ce)) 7760 type = USE_T_CDL; 7761 else if (*T_AL != NUL) 7762 type = USE_T_AL; 7763 else if (can_ce && result_empty) 7764 type = USE_T_CE; 7765 else if (*T_DL != NUL && result_empty) 7766 type = USE_T_DL; 7767 else if (*T_SR != NUL && row == 0 && (*T_DA == NUL || can_ce)) 7768 type = USE_T_SR; 7769 else 7770 return FAIL; 7771 7772 /* 7773 * For clearing the lines screen_del_lines() is used. This will also take 7774 * care of t_db if necessary. 7775 */ 7776 if (type == USE_T_CD || type == USE_T_CDL || 7777 type == USE_T_CE || type == USE_T_DL) 7778 return screen_del_lines(off, row, line_count, end, FALSE, wp); 7779 7780 /* 7781 * If text is retained below the screen, first clear or delete as many 7782 * lines at the bottom of the window as are about to be inserted so that 7783 * the deleted lines won't later surface during a screen_del_lines. 7784 */ 7785 if (*T_DB) 7786 screen_del_lines(off, end - line_count, line_count, end, FALSE, wp); 7787 7788 #ifdef FEAT_CLIPBOARD 7789 /* Remove a modeless selection when inserting lines halfway the screen 7790 * or not the full width of the screen. */ 7791 if (off + row > 0 7792 # ifdef FEAT_VERTSPLIT 7793 || (wp != NULL && wp->w_width != Columns) 7794 # endif 7795 ) 7796 clip_clear_selection(); 7797 else 7798 clip_scroll_selection(-line_count); 7799 #endif 7800 7801 #ifdef FEAT_GUI 7802 /* Don't update the GUI cursor here, ScreenLines[] is invalid until the 7803 * scrolling is actually carried out. */ 7804 gui_dont_update_cursor(); 7805 #endif 7806 7807 if (*T_CCS != NUL) /* cursor relative to region */ 7808 cursor_row = row; 7809 else 7810 cursor_row = row + off; 7811 7812 /* 7813 * Shift LineOffset[] line_count down to reflect the inserted lines. 7814 * Clear the inserted lines in ScreenLines[]. 7815 */ 7816 row += off; 7817 end += off; 7818 for (i = 0; i < line_count; ++i) 7819 { 7820 #ifdef FEAT_VERTSPLIT 7821 if (wp != NULL && wp->w_width != Columns) 7822 { 7823 /* need to copy part of a line */ 7824 j = end - 1 - i; 7825 while ((j -= line_count) >= row) 7826 linecopy(j + line_count, j, wp); 7827 j += line_count; 7828 if (can_clear((char_u *)" ")) 7829 lineclear(LineOffset[j] + wp->w_wincol, wp->w_width); 7830 else 7831 lineinvalid(LineOffset[j] + wp->w_wincol, wp->w_width); 7832 LineWraps[j] = FALSE; 7833 } 7834 else 7835 #endif 7836 { 7837 j = end - 1 - i; 7838 temp = LineOffset[j]; 7839 while ((j -= line_count) >= row) 7840 { 7841 LineOffset[j + line_count] = LineOffset[j]; 7842 LineWraps[j + line_count] = LineWraps[j]; 7843 } 7844 LineOffset[j + line_count] = temp; 7845 LineWraps[j + line_count] = FALSE; 7846 if (can_clear((char_u *)" ")) 7847 lineclear(temp, (int)Columns); 7848 else 7849 lineinvalid(temp, (int)Columns); 7850 } 7851 } 7852 7853 screen_stop_highlight(); 7854 windgoto(cursor_row, 0); 7855 7856 #ifdef FEAT_VERTSPLIT 7857 /* redraw the characters */ 7858 if (type == USE_REDRAW) 7859 redraw_block(row, end, wp); 7860 else 7861 #endif 7862 if (type == USE_T_CAL) 7863 { 7864 term_append_lines(line_count); 7865 screen_start(); /* don't know where cursor is now */ 7866 } 7867 else 7868 { 7869 for (i = 0; i < line_count; i++) 7870 { 7871 if (type == USE_T_AL) 7872 { 7873 if (i && cursor_row != 0) 7874 windgoto(cursor_row, 0); 7875 out_str(T_AL); 7876 } 7877 else /* type == USE_T_SR */ 7878 out_str(T_SR); 7879 screen_start(); /* don't know where cursor is now */ 7880 } 7881 } 7882 7883 /* 7884 * With scroll-reverse and 'da' flag set we need to clear the lines that 7885 * have been scrolled down into the region. 7886 */ 7887 if (type == USE_T_SR && *T_DA) 7888 { 7889 for (i = 0; i < line_count; ++i) 7890 { 7891 windgoto(off + i, 0); 7892 out_str(T_CE); 7893 screen_start(); /* don't know where cursor is now */ 7894 } 7895 } 7896 7897 #ifdef FEAT_GUI 7898 gui_can_update_cursor(); 7899 if (gui.in_use) 7900 out_flush(); /* always flush after a scroll */ 7901 #endif 7902 return OK; 7903 } 7904 7905 /* 7906 * delete lines on the screen and update ScreenLines[] 7907 * 'end' is the line after the scrolled part. Normally it is Rows. 7908 * When scrolling region used 'off' is the offset from the top for the region. 7909 * 'row' and 'end' are relative to the start of the region. 7910 * 7911 * Return OK for success, FAIL if the lines are not deleted. 7912 */ 7913 /*ARGSUSED*/ 7914 int 7915 screen_del_lines(off, row, line_count, end, force, wp) 7916 int off; 7917 int row; 7918 int line_count; 7919 int end; 7920 int force; /* even when line_count > p_ttyscroll */ 7921 win_T *wp; /* NULL or window to use width from */ 7922 { 7923 int j; 7924 int i; 7925 unsigned temp; 7926 int cursor_row; 7927 int cursor_end; 7928 int result_empty; /* result is empty until end of region */ 7929 int can_delete; /* deleting line codes can be used */ 7930 int type; 7931 7932 /* 7933 * FAIL if 7934 * - there is no valid screen 7935 * - the screen has to be redrawn completely 7936 * - the line count is less than one 7937 * - the line count is more than 'ttyscroll' 7938 */ 7939 if (!screen_valid(TRUE) || line_count <= 0 || 7940 (!force && line_count > p_ttyscroll)) 7941 return FAIL; 7942 7943 /* 7944 * Check if the rest of the current region will become empty. 7945 */ 7946 result_empty = row + line_count >= end; 7947 7948 /* 7949 * We can delete lines only when 'db' flag not set or when 'ce' option 7950 * available. 7951 */ 7952 can_delete = (*T_DB == NUL || can_clear(T_CE)); 7953 7954 /* 7955 * There are six ways to delete lines: 7956 * 0. When in a vertically split window and t_CV isn't set, redraw the 7957 * characters from ScreenLines[]. 7958 * 1. Use T_CD if it exists and the result is empty. 7959 * 2. Use newlines if row == 0 and count == 1 or T_CDL does not exist. 7960 * 3. Use T_CDL (delete multiple lines) if it exists and line_count > 1 or 7961 * none of the other ways work. 7962 * 4. Use T_CE (erase line) if the result is empty. 7963 * 5. Use T_DL (delete line) if it exists. 7964 * 6. redraw the characters from ScreenLines[]. 7965 */ 7966 #ifdef FEAT_VERTSPLIT 7967 if (wp != NULL && wp->w_width != Columns && *T_CSV == NUL) 7968 type = USE_REDRAW; 7969 else 7970 #endif 7971 if (can_clear(T_CD) && result_empty) 7972 type = USE_T_CD; 7973 #if defined(__BEOS__) && defined(BEOS_DR8) 7974 /* 7975 * USE_NL does not seem to work in Terminal of DR8 so we set T_DB="" in 7976 * its internal termcap... this works okay for tests which test *T_DB != 7977 * NUL. It has the disadvantage that the user cannot use any :set t_* 7978 * command to get T_DB (back) to empty_option, only :set term=... will do 7979 * the trick... 7980 * Anyway, this hack will hopefully go away with the next OS release. 7981 * (Olaf Seibert) 7982 */ 7983 else if (row == 0 && T_DB == empty_option 7984 && (line_count == 1 || *T_CDL == NUL)) 7985 #else 7986 else if (row == 0 && ( 7987 #ifndef AMIGA 7988 /* On the Amiga, somehow '\n' on the last line doesn't always scroll 7989 * up, so use delete-line command */ 7990 line_count == 1 || 7991 #endif 7992 *T_CDL == NUL)) 7993 #endif 7994 type = USE_NL; 7995 else if (*T_CDL != NUL && line_count > 1 && can_delete) 7996 type = USE_T_CDL; 7997 else if (can_clear(T_CE) && result_empty 7998 #ifdef FEAT_VERTSPLIT 7999 && (wp == NULL || wp->w_width == Columns) 8000 #endif 8001 ) 8002 type = USE_T_CE; 8003 else if (*T_DL != NUL && can_delete) 8004 type = USE_T_DL; 8005 else if (*T_CDL != NUL && can_delete) 8006 type = USE_T_CDL; 8007 else 8008 return FAIL; 8009 8010 #ifdef FEAT_CLIPBOARD 8011 /* Remove a modeless selection when deleting lines halfway the screen or 8012 * not the full width of the screen. */ 8013 if (off + row > 0 8014 # ifdef FEAT_VERTSPLIT 8015 || (wp != NULL && wp->w_width != Columns) 8016 # endif 8017 ) 8018 clip_clear_selection(); 8019 else 8020 clip_scroll_selection(line_count); 8021 #endif 8022 8023 #ifdef FEAT_GUI 8024 /* Don't update the GUI cursor here, ScreenLines[] is invalid until the 8025 * scrolling is actually carried out. */ 8026 gui_dont_update_cursor(); 8027 #endif 8028 8029 if (*T_CCS != NUL) /* cursor relative to region */ 8030 { 8031 cursor_row = row; 8032 cursor_end = end; 8033 } 8034 else 8035 { 8036 cursor_row = row + off; 8037 cursor_end = end + off; 8038 } 8039 8040 /* 8041 * Now shift LineOffset[] line_count up to reflect the deleted lines. 8042 * Clear the inserted lines in ScreenLines[]. 8043 */ 8044 row += off; 8045 end += off; 8046 for (i = 0; i < line_count; ++i) 8047 { 8048 #ifdef FEAT_VERTSPLIT 8049 if (wp != NULL && wp->w_width != Columns) 8050 { 8051 /* need to copy part of a line */ 8052 j = row + i; 8053 while ((j += line_count) <= end - 1) 8054 linecopy(j - line_count, j, wp); 8055 j -= line_count; 8056 if (can_clear((char_u *)" ")) 8057 lineclear(LineOffset[j] + wp->w_wincol, wp->w_width); 8058 else 8059 lineinvalid(LineOffset[j] + wp->w_wincol, wp->w_width); 8060 LineWraps[j] = FALSE; 8061 } 8062 else 8063 #endif 8064 { 8065 /* whole width, moving the line pointers is faster */ 8066 j = row + i; 8067 temp = LineOffset[j]; 8068 while ((j += line_count) <= end - 1) 8069 { 8070 LineOffset[j - line_count] = LineOffset[j]; 8071 LineWraps[j - line_count] = LineWraps[j]; 8072 } 8073 LineOffset[j - line_count] = temp; 8074 LineWraps[j - line_count] = FALSE; 8075 if (can_clear((char_u *)" ")) 8076 lineclear(temp, (int)Columns); 8077 else 8078 lineinvalid(temp, (int)Columns); 8079 } 8080 } 8081 8082 screen_stop_highlight(); 8083 8084 #ifdef FEAT_VERTSPLIT 8085 /* redraw the characters */ 8086 if (type == USE_REDRAW) 8087 redraw_block(row, end, wp); 8088 else 8089 #endif 8090 if (type == USE_T_CD) /* delete the lines */ 8091 { 8092 windgoto(cursor_row, 0); 8093 out_str(T_CD); 8094 screen_start(); /* don't know where cursor is now */ 8095 } 8096 else if (type == USE_T_CDL) 8097 { 8098 windgoto(cursor_row, 0); 8099 term_delete_lines(line_count); 8100 screen_start(); /* don't know where cursor is now */ 8101 } 8102 /* 8103 * Deleting lines at top of the screen or scroll region: Just scroll 8104 * the whole screen (scroll region) up by outputting newlines on the 8105 * last line. 8106 */ 8107 else if (type == USE_NL) 8108 { 8109 windgoto(cursor_end - 1, 0); 8110 for (i = line_count; --i >= 0; ) 8111 out_char('\n'); /* cursor will remain on same line */ 8112 } 8113 else 8114 { 8115 for (i = line_count; --i >= 0; ) 8116 { 8117 if (type == USE_T_DL) 8118 { 8119 windgoto(cursor_row, 0); 8120 out_str(T_DL); /* delete a line */ 8121 } 8122 else /* type == USE_T_CE */ 8123 { 8124 windgoto(cursor_row + i, 0); 8125 out_str(T_CE); /* erase a line */ 8126 } 8127 screen_start(); /* don't know where cursor is now */ 8128 } 8129 } 8130 8131 /* 8132 * If the 'db' flag is set, we need to clear the lines that have been 8133 * scrolled up at the bottom of the region. 8134 */ 8135 if (*T_DB && (type == USE_T_DL || type == USE_T_CDL)) 8136 { 8137 for (i = line_count; i > 0; --i) 8138 { 8139 windgoto(cursor_end - i, 0); 8140 out_str(T_CE); /* erase a line */ 8141 screen_start(); /* don't know where cursor is now */ 8142 } 8143 } 8144 8145 #ifdef FEAT_GUI 8146 gui_can_update_cursor(); 8147 if (gui.in_use) 8148 out_flush(); /* always flush after a scroll */ 8149 #endif 8150 8151 return OK; 8152 } 8153 8154 /* 8155 * show the current mode and ruler 8156 * 8157 * If clear_cmdline is TRUE, clear the rest of the cmdline. 8158 * If clear_cmdline is FALSE there may be a message there that needs to be 8159 * cleared only if a mode is shown. 8160 * Return the length of the message (0 if no message). 8161 */ 8162 int 8163 showmode() 8164 { 8165 int need_clear; 8166 int length = 0; 8167 int do_mode; 8168 int attr; 8169 int nwr_save; 8170 #ifdef FEAT_INS_EXPAND 8171 int sub_attr; 8172 #endif 8173 8174 do_mode = (p_smd && ((State & INSERT) || restart_edit 8175 #ifdef FEAT_VISUAL 8176 || VIsual_active 8177 #endif 8178 )); 8179 if (do_mode || Recording) 8180 { 8181 /* 8182 * Don't show mode right now, when not redrawing or inside a mapping. 8183 * Call char_avail() only when we are going to show something, because 8184 * it takes a bit of time. 8185 */ 8186 if (!redrawing() || (char_avail() && !KeyTyped) || msg_silent != 0) 8187 { 8188 redraw_cmdline = TRUE; /* show mode later */ 8189 return 0; 8190 } 8191 8192 nwr_save = need_wait_return; 8193 8194 /* wait a bit before overwriting an important message */ 8195 check_for_delay(FALSE); 8196 8197 /* if the cmdline is more than one line high, erase top lines */ 8198 need_clear = clear_cmdline; 8199 if (clear_cmdline && cmdline_row < Rows - 1) 8200 msg_clr_cmdline(); /* will reset clear_cmdline */ 8201 8202 /* Position on the last line in the window, column 0 */ 8203 msg_pos_mode(); 8204 cursor_off(); 8205 attr = hl_attr(HLF_CM); /* Highlight mode */ 8206 if (do_mode) 8207 { 8208 MSG_PUTS_ATTR("--", attr); 8209 #if defined(FEAT_XIM) 8210 if (xic != NULL && im_get_status() && !p_imdisable 8211 && curbuf->b_p_iminsert == B_IMODE_IM) 8212 # ifdef HAVE_GTK2 /* most of the time, it's not XIM being used */ 8213 MSG_PUTS_ATTR(" IM", attr); 8214 # else 8215 MSG_PUTS_ATTR(" XIM", attr); 8216 # endif 8217 #endif 8218 #if defined(FEAT_HANGULIN) && defined(FEAT_GUI) 8219 if (gui.in_use) 8220 { 8221 if (hangul_input_state_get()) 8222 MSG_PUTS_ATTR(" \307\321\261\333", attr); /* HANGUL */ 8223 } 8224 #endif 8225 #ifdef FEAT_INS_EXPAND 8226 if (edit_submode != NULL) /* CTRL-X in Insert mode */ 8227 { 8228 /* These messages can get long, avoid a wrap in a narrow 8229 * window. Prefer showing edit_submode_extra. */ 8230 length = (Rows - msg_row) * Columns - 3; 8231 if (edit_submode_extra != NULL) 8232 length -= vim_strsize(edit_submode_extra); 8233 if (length > 0) 8234 { 8235 if (edit_submode_pre != NULL) 8236 length -= vim_strsize(edit_submode_pre); 8237 if (length - vim_strsize(edit_submode) > 0) 8238 { 8239 if (edit_submode_pre != NULL) 8240 msg_puts_attr(edit_submode_pre, attr); 8241 msg_puts_attr(edit_submode, attr); 8242 } 8243 if (edit_submode_extra != NULL) 8244 { 8245 MSG_PUTS_ATTR(" ", attr); /* add a space in between */ 8246 if ((int)edit_submode_highl < (int)HLF_COUNT) 8247 sub_attr = hl_attr(edit_submode_highl); 8248 else 8249 sub_attr = attr; 8250 msg_puts_attr(edit_submode_extra, sub_attr); 8251 } 8252 } 8253 length = 0; 8254 } 8255 else 8256 #endif 8257 { 8258 #ifdef FEAT_VREPLACE 8259 if (State & VREPLACE_FLAG) 8260 MSG_PUTS_ATTR(_(" VREPLACE"), attr); 8261 else 8262 #endif 8263 if (State & REPLACE_FLAG) 8264 MSG_PUTS_ATTR(_(" REPLACE"), attr); 8265 else if (State & INSERT) 8266 { 8267 #ifdef FEAT_RIGHTLEFT 8268 if (p_ri) 8269 MSG_PUTS_ATTR(_(" REVERSE"), attr); 8270 #endif 8271 MSG_PUTS_ATTR(_(" INSERT"), attr); 8272 } 8273 else if (restart_edit == 'I') 8274 MSG_PUTS_ATTR(_(" (insert)"), attr); 8275 else if (restart_edit == 'R') 8276 MSG_PUTS_ATTR(_(" (replace)"), attr); 8277 else if (restart_edit == 'V') 8278 MSG_PUTS_ATTR(_(" (vreplace)"), attr); 8279 #ifdef FEAT_RIGHTLEFT 8280 if (p_hkmap) 8281 MSG_PUTS_ATTR(_(" Hebrew"), attr); 8282 # ifdef FEAT_FKMAP 8283 if (p_fkmap) 8284 MSG_PUTS_ATTR(farsi_text_5, attr); 8285 # endif 8286 #endif 8287 #ifdef FEAT_KEYMAP 8288 if (State & LANGMAP) 8289 { 8290 # ifdef FEAT_ARABIC 8291 if (curwin->w_p_arab) 8292 MSG_PUTS_ATTR(_(" Arabic"), attr); 8293 else 8294 # endif 8295 MSG_PUTS_ATTR(_(" (lang)"), attr); 8296 } 8297 #endif 8298 if ((State & INSERT) && p_paste) 8299 MSG_PUTS_ATTR(_(" (paste)"), attr); 8300 8301 #ifdef FEAT_VISUAL 8302 if (VIsual_active) 8303 { 8304 char *p; 8305 8306 /* Don't concatenate separate words to avoid translation 8307 * problems. */ 8308 switch ((VIsual_select ? 4 : 0) 8309 + (VIsual_mode == Ctrl_V) * 2 8310 + (VIsual_mode == 'V')) 8311 { 8312 case 0: p = N_(" VISUAL"); break; 8313 case 1: p = N_(" VISUAL LINE"); break; 8314 case 2: p = N_(" VISUAL BLOCK"); break; 8315 case 4: p = N_(" SELECT"); break; 8316 case 5: p = N_(" SELECT LINE"); break; 8317 default: p = N_(" SELECT BLOCK"); break; 8318 } 8319 MSG_PUTS_ATTR(_(p), attr); 8320 } 8321 #endif 8322 MSG_PUTS_ATTR(" --", attr); 8323 } 8324 need_clear = TRUE; 8325 } 8326 if (Recording 8327 #ifdef FEAT_INS_EXPAND 8328 && edit_submode == NULL /* otherwise it gets too long */ 8329 #endif 8330 ) 8331 { 8332 MSG_PUTS_ATTR(_("recording"), attr); 8333 need_clear = TRUE; 8334 } 8335 if (need_clear || clear_cmdline) 8336 msg_clr_eos(); 8337 msg_didout = FALSE; /* overwrite this message */ 8338 length = msg_col; 8339 msg_col = 0; 8340 need_wait_return = nwr_save; /* never ask for hit-return for this */ 8341 } 8342 else if (clear_cmdline && msg_silent == 0) 8343 /* Clear the whole command line. Will reset "clear_cmdline". */ 8344 msg_clr_cmdline(); 8345 8346 #ifdef FEAT_CMDL_INFO 8347 # ifdef FEAT_VISUAL 8348 /* In Visual mode the size of the selected area must be redrawn. */ 8349 if (VIsual_active) 8350 clear_showcmd(); 8351 # endif 8352 8353 /* If the last window has no status line, the ruler is after the mode 8354 * message and must be redrawn */ 8355 if (redrawing() 8356 # ifdef FEAT_WINDOWS 8357 && lastwin->w_status_height == 0 8358 # endif 8359 ) 8360 win_redr_ruler(lastwin, TRUE); 8361 #endif 8362 redraw_cmdline = FALSE; 8363 clear_cmdline = FALSE; 8364 8365 return length; 8366 } 8367 8368 /* 8369 * Position for a mode message. 8370 */ 8371 static void 8372 msg_pos_mode() 8373 { 8374 msg_col = 0; 8375 msg_row = Rows - 1; 8376 } 8377 8378 /* 8379 * Delete mode message. Used when ESC is typed which is expected to end 8380 * Insert mode (but Insert mode didn't end yet!). 8381 */ 8382 void 8383 unshowmode(force) 8384 int force; 8385 { 8386 /* 8387 * Don't delete it right now, when not redrawing or insided a mapping. 8388 */ 8389 if (!redrawing() || (!force && char_avail() && !KeyTyped)) 8390 redraw_cmdline = TRUE; /* delete mode later */ 8391 else 8392 { 8393 msg_pos_mode(); 8394 if (Recording) 8395 MSG_PUTS_ATTR(_("recording"), hl_attr(HLF_CM)); 8396 msg_clr_eos(); 8397 } 8398 } 8399 8400 #if defined(FEAT_WINDOWS) || defined(FEAT_WILDMENU) || defined(FEAT_STL_OPT) 8401 /* 8402 * Get the character to use in a status line. Get its attributes in "*attr". 8403 */ 8404 static int 8405 fillchar_status(attr, is_curwin) 8406 int *attr; 8407 int is_curwin; 8408 { 8409 int fill; 8410 if (is_curwin) 8411 { 8412 *attr = hl_attr(HLF_S); 8413 fill = fill_stl; 8414 } 8415 else 8416 { 8417 *attr = hl_attr(HLF_SNC); 8418 fill = fill_stlnc; 8419 } 8420 /* Use fill when there is highlighting, and highlighting of current 8421 * window differs, or the fillchars differ, or this is not the 8422 * current window */ 8423 if (*attr != 0 && ((hl_attr(HLF_S) != hl_attr(HLF_SNC) 8424 || !is_curwin || firstwin == lastwin) 8425 || (fill_stl != fill_stlnc))) 8426 return fill; 8427 if (is_curwin) 8428 return '^'; 8429 return '='; 8430 } 8431 #endif 8432 8433 #ifdef FEAT_VERTSPLIT 8434 /* 8435 * Get the character to use in a separator between vertically split windows. 8436 * Get its attributes in "*attr". 8437 */ 8438 static int 8439 fillchar_vsep(attr) 8440 int *attr; 8441 { 8442 *attr = hl_attr(HLF_C); 8443 if (*attr == 0 && fill_vert == ' ') 8444 return '|'; 8445 else 8446 return fill_vert; 8447 } 8448 #endif 8449 8450 /* 8451 * Return TRUE if redrawing should currently be done. 8452 */ 8453 int 8454 redrawing() 8455 { 8456 return (!RedrawingDisabled 8457 && !(p_lz && char_avail() && !KeyTyped && !do_redraw)); 8458 } 8459 8460 /* 8461 * Return TRUE if printing messages should currently be done. 8462 */ 8463 int 8464 messaging() 8465 { 8466 return (!(p_lz && char_avail() && !KeyTyped)); 8467 } 8468 8469 /* 8470 * Show current status info in ruler and various other places 8471 * If always is FALSE, only show ruler if position has changed. 8472 */ 8473 void 8474 showruler(always) 8475 int always; 8476 { 8477 if (!always && !redrawing()) 8478 return; 8479 #if defined(FEAT_STL_OPT) && defined(FEAT_WINDOWS) 8480 if ((*p_stl != NUL || *curwin->w_p_stl != NUL) && curwin->w_status_height) 8481 win_redr_custom(curwin, FALSE); 8482 else 8483 #endif 8484 #ifdef FEAT_CMDL_INFO 8485 win_redr_ruler(curwin, always); 8486 #endif 8487 8488 #ifdef FEAT_TITLE 8489 if (need_maketitle 8490 # ifdef FEAT_STL_OPT 8491 || (p_icon && (stl_syntax & STL_IN_ICON)) 8492 || (p_title && (stl_syntax & STL_IN_TITLE)) 8493 # endif 8494 ) 8495 maketitle(); 8496 #endif 8497 } 8498 8499 #ifdef FEAT_CMDL_INFO 8500 static void 8501 win_redr_ruler(wp, always) 8502 win_T *wp; 8503 int always; 8504 { 8505 char_u buffer[70]; 8506 int row; 8507 int fillchar; 8508 int attr; 8509 int empty_line = FALSE; 8510 colnr_T virtcol; 8511 int i; 8512 int o; 8513 #ifdef FEAT_VERTSPLIT 8514 int this_ru_col; 8515 int off = 0; 8516 int width = Columns; 8517 # define WITH_OFF(x) x 8518 # define WITH_WIDTH(x) x 8519 #else 8520 # define WITH_OFF(x) 0 8521 # define WITH_WIDTH(x) Columns 8522 # define this_ru_col ru_col 8523 #endif 8524 8525 /* If 'ruler' off or redrawing disabled, don't do anything */ 8526 if (!p_ru) 8527 return; 8528 8529 /* 8530 * Check if cursor.lnum is valid, since win_redr_ruler() may be called 8531 * after deleting lines, before cursor.lnum is corrected. 8532 */ 8533 if (wp->w_cursor.lnum > wp->w_buffer->b_ml.ml_line_count) 8534 return; 8535 8536 #ifdef FEAT_INS_EXPAND 8537 /* Don't draw the ruler while doing insert-completion, it might overwrite 8538 * the (long) mode message. */ 8539 # ifdef FEAT_WINDOWS 8540 if (wp == lastwin && lastwin->w_status_height == 0) 8541 # endif 8542 if (edit_submode != NULL) 8543 return; 8544 /* Don't draw the ruler when the popup menu is visible, it may overlap. */ 8545 if (pum_visible()) 8546 return; 8547 #endif 8548 8549 #ifdef FEAT_STL_OPT 8550 if (*p_ruf) 8551 { 8552 win_redr_custom(wp, TRUE); 8553 return; 8554 } 8555 #endif 8556 8557 /* 8558 * Check if not in Insert mode and the line is empty (will show "0-1"). 8559 */ 8560 if (!(State & INSERT) 8561 && *ml_get_buf(wp->w_buffer, wp->w_cursor.lnum, FALSE) == NUL) 8562 empty_line = TRUE; 8563 8564 /* 8565 * Only draw the ruler when something changed. 8566 */ 8567 validate_virtcol_win(wp); 8568 if ( redraw_cmdline 8569 || always 8570 || wp->w_cursor.lnum != wp->w_ru_cursor.lnum 8571 || wp->w_cursor.col != wp->w_ru_cursor.col 8572 || wp->w_virtcol != wp->w_ru_virtcol 8573 #ifdef FEAT_VIRTUALEDIT 8574 || wp->w_cursor.coladd != wp->w_ru_cursor.coladd 8575 #endif 8576 || wp->w_topline != wp->w_ru_topline 8577 || wp->w_buffer->b_ml.ml_line_count != wp->w_ru_line_count 8578 #ifdef FEAT_DIFF 8579 || wp->w_topfill != wp->w_ru_topfill 8580 #endif 8581 || empty_line != wp->w_ru_empty) 8582 { 8583 cursor_off(); 8584 #ifdef FEAT_WINDOWS 8585 if (wp->w_status_height) 8586 { 8587 row = W_WINROW(wp) + wp->w_height; 8588 fillchar = fillchar_status(&attr, wp == curwin); 8589 # ifdef FEAT_VERTSPLIT 8590 off = W_WINCOL(wp); 8591 width = W_WIDTH(wp); 8592 # endif 8593 } 8594 else 8595 #endif 8596 { 8597 row = Rows - 1; 8598 fillchar = ' '; 8599 attr = 0; 8600 #ifdef FEAT_VERTSPLIT 8601 width = Columns; 8602 off = 0; 8603 #endif 8604 } 8605 8606 /* In list mode virtcol needs to be recomputed */ 8607 virtcol = wp->w_virtcol; 8608 if (wp->w_p_list && lcs_tab1 == NUL) 8609 { 8610 wp->w_p_list = FALSE; 8611 getvvcol(wp, &wp->w_cursor, NULL, &virtcol, NULL); 8612 wp->w_p_list = TRUE; 8613 } 8614 8615 /* 8616 * Some sprintfs return the length, some return a pointer. 8617 * To avoid portability problems we use strlen() here. 8618 */ 8619 sprintf((char *)buffer, "%ld,", 8620 (wp->w_buffer->b_ml.ml_flags & ML_EMPTY) 8621 ? 0L 8622 : (long)(wp->w_cursor.lnum)); 8623 col_print(buffer + STRLEN(buffer), 8624 empty_line ? 0 : (int)wp->w_cursor.col + 1, 8625 (int)virtcol + 1); 8626 8627 /* 8628 * Add a "50%" if there is room for it. 8629 * On the last line, don't print in the last column (scrolls the 8630 * screen up on some terminals). 8631 */ 8632 i = (int)STRLEN(buffer); 8633 get_rel_pos(wp, buffer + i + 1); 8634 o = i + vim_strsize(buffer + i + 1); 8635 #ifdef FEAT_WINDOWS 8636 if (wp->w_status_height == 0) /* can't use last char of screen */ 8637 #endif 8638 ++o; 8639 #ifdef FEAT_VERTSPLIT 8640 this_ru_col = ru_col - (Columns - width); 8641 if (this_ru_col < 0) 8642 this_ru_col = 0; 8643 #endif 8644 /* Never use more than half the window/screen width, leave the other 8645 * half for the filename. */ 8646 if (this_ru_col < (WITH_WIDTH(width) + 1) / 2) 8647 this_ru_col = (WITH_WIDTH(width) + 1) / 2; 8648 if (this_ru_col + o < WITH_WIDTH(width)) 8649 { 8650 while (this_ru_col + o < WITH_WIDTH(width)) 8651 { 8652 #ifdef FEAT_MBYTE 8653 if (has_mbyte) 8654 i += (*mb_char2bytes)(fillchar, buffer + i); 8655 else 8656 #endif 8657 buffer[i++] = fillchar; 8658 ++o; 8659 } 8660 get_rel_pos(wp, buffer + i); 8661 } 8662 /* Truncate at window boundary. */ 8663 #ifdef FEAT_MBYTE 8664 if (has_mbyte) 8665 { 8666 o = 0; 8667 for (i = 0; buffer[i] != NUL; i += (*mb_ptr2len)(buffer + i)) 8668 { 8669 o += (*mb_ptr2cells)(buffer + i); 8670 if (this_ru_col + o > WITH_WIDTH(width)) 8671 { 8672 buffer[i] = NUL; 8673 break; 8674 } 8675 } 8676 } 8677 else 8678 #endif 8679 if (this_ru_col + (int)STRLEN(buffer) > WITH_WIDTH(width)) 8680 buffer[WITH_WIDTH(width) - this_ru_col] = NUL; 8681 8682 screen_puts(buffer, row, this_ru_col + WITH_OFF(off), attr); 8683 i = redraw_cmdline; 8684 screen_fill(row, row + 1, 8685 this_ru_col + WITH_OFF(off) + (int)STRLEN(buffer), 8686 (int)(WITH_OFF(off) + WITH_WIDTH(width)), 8687 fillchar, fillchar, attr); 8688 /* don't redraw the cmdline because of showing the ruler */ 8689 redraw_cmdline = i; 8690 wp->w_ru_cursor = wp->w_cursor; 8691 wp->w_ru_virtcol = wp->w_virtcol; 8692 wp->w_ru_empty = empty_line; 8693 wp->w_ru_topline = wp->w_topline; 8694 wp->w_ru_line_count = wp->w_buffer->b_ml.ml_line_count; 8695 #ifdef FEAT_DIFF 8696 wp->w_ru_topfill = wp->w_topfill; 8697 #endif 8698 } 8699 } 8700 #endif 8701 8702 #if defined(FEAT_LINEBREAK) || defined(PROTO) 8703 /* 8704 * Return the width of the 'number' column. 8705 * Zero when 'number' isn't set. 8706 * Otherwise it depends on 'numberwidth' and the line count. 8707 */ 8708 int 8709 number_width(wp) 8710 win_T *wp; 8711 { 8712 int n; 8713 linenr_T lnum; 8714 8715 if (!wp->w_p_nu) 8716 return 0; 8717 8718 lnum = wp->w_buffer->b_ml.ml_line_count; 8719 if (lnum == wp->w_nrwidth_line_count) 8720 return wp->w_nrwidth_width; 8721 wp->w_nrwidth_line_count = lnum; 8722 8723 n = 0; 8724 do 8725 { 8726 lnum /= 10; 8727 ++n; 8728 } while (lnum > 0); 8729 8730 /* 'numberwidth' gives the minimal width plus one */ 8731 if (n < wp->w_p_nuw - 1) 8732 n = wp->w_p_nuw - 1; 8733 8734 wp->w_nrwidth_width = n; 8735 return n; 8736 } 8737 #endif 8738