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