1 /* vi:set ts=8 sts=4 sw=4 noet: 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: Lower level 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 and 29 * ScreenLinesC[][] is not used. When the character occupies two display 30 * cells the next byte in ScreenLines[] is 0. 31 * ScreenLinesC[][] contain up to 'maxcombine' composing characters 32 * (drawn on top of the first character). There is 0 after the last one used. 33 * ScreenLines2[] is only used for euc-jp to store the second byte if the 34 * first byte is 0x8e (single-width character). 35 * 36 * The screen_*() functions write to the screen and handle updating 37 * ScreenLines[]. 38 */ 39 40 #include "vim.h" 41 42 /* 43 * The attributes that are actually active for writing to the screen. 44 */ 45 static int screen_attr = 0; 46 47 static void screen_char_2(unsigned off, int row, int col); 48 static void screenclear2(void); 49 static void lineclear(unsigned off, int width, int attr); 50 static void lineinvalid(unsigned off, int width); 51 static int win_do_lines(win_T *wp, int row, int line_count, int mayclear, int del, int clear_attr); 52 static void win_rest_invalid(win_T *wp); 53 static void msg_pos_mode(void); 54 static void recording_mode(int attr); 55 56 // Ugly global: overrule attribute used by screen_char() 57 static int screen_char_attr = 0; 58 59 #if defined(FEAT_CONCEAL) || defined(PROTO) 60 /* 61 * Return TRUE if the cursor line in window "wp" may be concealed, according 62 * to the 'concealcursor' option. 63 */ 64 int 65 conceal_cursor_line(win_T *wp) 66 { 67 int c; 68 69 if (*wp->w_p_cocu == NUL) 70 return FALSE; 71 if (get_real_state() & VISUAL) 72 c = 'v'; 73 else if (State & INSERT) 74 c = 'i'; 75 else if (State & NORMAL) 76 c = 'n'; 77 else if (State & CMDLINE) 78 c = 'c'; 79 else 80 return FALSE; 81 return vim_strchr(wp->w_p_cocu, c) != NULL; 82 } 83 84 /* 85 * Check if the cursor line needs to be redrawn because of 'concealcursor'. 86 */ 87 void 88 conceal_check_cursor_line(void) 89 { 90 if (curwin->w_p_cole > 0 && conceal_cursor_line(curwin)) 91 { 92 need_cursor_line_redraw = TRUE; 93 // Need to recompute cursor column, e.g., when starting Visual mode 94 // without concealing. 95 curs_columns(TRUE); 96 } 97 } 98 #endif 99 100 /* 101 * Get 'wincolor' attribute for window "wp". If not set and "wp" is a popup 102 * window then get the "Pmenu" highlight attribute. 103 */ 104 int 105 get_wcr_attr(win_T *wp) 106 { 107 int wcr_attr = 0; 108 109 if (*wp->w_p_wcr != NUL) 110 wcr_attr = syn_name2attr(wp->w_p_wcr); 111 #ifdef FEAT_PROP_POPUP 112 else if (WIN_IS_POPUP(wp)) 113 { 114 if (wp->w_popup_flags & POPF_INFO) 115 wcr_attr = HL_ATTR(HLF_PSI); // PmenuSel 116 else 117 wcr_attr = HL_ATTR(HLF_PNI); // Pmenu 118 } 119 #endif 120 return wcr_attr; 121 } 122 123 /* 124 * Call screen_fill() with the columns adjusted for 'rightleft' if needed. 125 * Return the new offset. 126 */ 127 static int 128 screen_fill_end( 129 win_T *wp, 130 int c1, 131 int c2, 132 int off, 133 int width, 134 int row, 135 int endrow, 136 int attr) 137 { 138 int nn = off + width; 139 140 if (nn > wp->w_width) 141 nn = wp->w_width; 142 #ifdef FEAT_RIGHTLEFT 143 if (wp->w_p_rl) 144 { 145 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow, 146 W_ENDCOL(wp) - nn, (int)W_ENDCOL(wp) - off, 147 c1, c2, attr); 148 } 149 else 150 #endif 151 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow, 152 wp->w_wincol + off, (int)wp->w_wincol + nn, 153 c1, c2, attr); 154 return nn; 155 } 156 157 /* 158 * Clear lines near the end the window and mark the unused lines with "c1". 159 * use "c2" as the filler character. 160 * When "draw_margin" is TRUE then draw the sign, fold and number columns. 161 */ 162 void 163 win_draw_end( 164 win_T *wp, 165 int c1, 166 int c2, 167 int draw_margin, 168 int row, 169 int endrow, 170 hlf_T hl) 171 { 172 int n = 0; 173 int attr = HL_ATTR(hl); 174 int wcr_attr = get_wcr_attr(wp); 175 176 attr = hl_combine_attr(wcr_attr, attr); 177 178 if (draw_margin) 179 { 180 #ifdef FEAT_FOLDING 181 int fdc = compute_foldcolumn(wp, 0); 182 183 if (fdc > 0) 184 // draw the fold column 185 n = screen_fill_end(wp, ' ', ' ', n, fdc, 186 row, endrow, hl_combine_attr(wcr_attr, HL_ATTR(HLF_FC))); 187 #endif 188 #ifdef FEAT_SIGNS 189 if (signcolumn_on(wp)) 190 // draw the sign column 191 n = screen_fill_end(wp, ' ', ' ', n, 2, 192 row, endrow, hl_combine_attr(wcr_attr, HL_ATTR(HLF_SC))); 193 #endif 194 if ((wp->w_p_nu || wp->w_p_rnu) 195 && vim_strchr(p_cpo, CPO_NUMCOL) == NULL) 196 // draw the number column 197 n = screen_fill_end(wp, ' ', ' ', n, number_width(wp) + 1, 198 row, endrow, hl_combine_attr(wcr_attr, HL_ATTR(HLF_N))); 199 } 200 201 #ifdef FEAT_RIGHTLEFT 202 if (wp->w_p_rl) 203 { 204 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow, 205 wp->w_wincol, W_ENDCOL(wp) - 1 - n, 206 c2, c2, attr); 207 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow, 208 W_ENDCOL(wp) - 1 - n, W_ENDCOL(wp) - n, 209 c1, c2, attr); 210 } 211 else 212 #endif 213 { 214 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow, 215 wp->w_wincol + n, (int)W_ENDCOL(wp), 216 c1, c2, attr); 217 } 218 219 set_empty_rows(wp, row); 220 } 221 222 #if defined(FEAT_FOLDING) || defined(PROTO) 223 /* 224 * Compute the width of the foldcolumn. Based on 'foldcolumn' and how much 225 * space is available for window "wp", minus "col". 226 */ 227 int 228 compute_foldcolumn(win_T *wp, int col) 229 { 230 int fdc = wp->w_p_fdc; 231 int wmw = wp == curwin && p_wmw == 0 ? 1 : p_wmw; 232 int wwidth = wp->w_width; 233 234 if (fdc > wwidth - (col + wmw)) 235 fdc = wwidth - (col + wmw); 236 return fdc; 237 } 238 239 /* 240 * Fill the foldcolumn at "p" for window "wp". 241 * Only to be called when 'foldcolumn' > 0. 242 */ 243 void 244 fill_foldcolumn( 245 char_u *p, 246 win_T *wp, 247 int closed, // TRUE of FALSE 248 linenr_T lnum) // current line number 249 { 250 int i = 0; 251 int level; 252 int first_level; 253 int empty; 254 int fdc = compute_foldcolumn(wp, 0); 255 256 // Init to all spaces. 257 vim_memset(p, ' ', (size_t)fdc); 258 259 level = win_foldinfo.fi_level; 260 if (level > 0) 261 { 262 // If there is only one column put more info in it. 263 empty = (fdc == 1) ? 0 : 1; 264 265 // If the column is too narrow, we start at the lowest level that 266 // fits and use numbers to indicated the depth. 267 first_level = level - fdc - closed + 1 + empty; 268 if (first_level < 1) 269 first_level = 1; 270 271 for (i = 0; i + empty < fdc; ++i) 272 { 273 if (win_foldinfo.fi_lnum == lnum 274 && first_level + i >= win_foldinfo.fi_low_level) 275 p[i] = '-'; 276 else if (first_level == 1) 277 p[i] = '|'; 278 else if (first_level + i <= 9) 279 p[i] = '0' + first_level + i; 280 else 281 p[i] = '>'; 282 if (first_level + i == level) 283 break; 284 } 285 } 286 if (closed) 287 p[i >= fdc ? i - 1 : i] = '+'; 288 } 289 #endif // FEAT_FOLDING 290 291 /* 292 * Return if the composing characters at "off_from" and "off_to" differ. 293 * Only to be used when ScreenLinesUC[off_from] != 0. 294 */ 295 static int 296 comp_char_differs(int off_from, int off_to) 297 { 298 int i; 299 300 for (i = 0; i < Screen_mco; ++i) 301 { 302 if (ScreenLinesC[i][off_from] != ScreenLinesC[i][off_to]) 303 return TRUE; 304 if (ScreenLinesC[i][off_from] == 0) 305 break; 306 } 307 return FALSE; 308 } 309 310 /* 311 * Check whether the given character needs redrawing: 312 * - the (first byte of the) character is different 313 * - the attributes are different 314 * - the character is multi-byte and the next byte is different 315 * - the character is two cells wide and the second cell differs. 316 */ 317 static int 318 char_needs_redraw(int off_from, int off_to, int cols) 319 { 320 if (cols > 0 321 && ((ScreenLines[off_from] != ScreenLines[off_to] 322 || ScreenAttrs[off_from] != ScreenAttrs[off_to]) 323 || (enc_dbcs != 0 324 && MB_BYTE2LEN(ScreenLines[off_from]) > 1 325 && (enc_dbcs == DBCS_JPNU && ScreenLines[off_from] == 0x8e 326 ? ScreenLines2[off_from] != ScreenLines2[off_to] 327 : (cols > 1 && ScreenLines[off_from + 1] 328 != ScreenLines[off_to + 1]))) 329 || (enc_utf8 330 && (ScreenLinesUC[off_from] != ScreenLinesUC[off_to] 331 || (ScreenLinesUC[off_from] != 0 332 && comp_char_differs(off_from, off_to)) 333 || ((*mb_off2cells)(off_from, off_from + cols) > 1 334 && ScreenLines[off_from + 1] 335 != ScreenLines[off_to + 1]))))) 336 return TRUE; 337 return FALSE; 338 } 339 340 #if defined(FEAT_TERMINAL) || defined(PROTO) 341 /* 342 * Return the index in ScreenLines[] for the current screen line. 343 */ 344 int 345 screen_get_current_line_off() 346 { 347 return (int)(current_ScreenLine - ScreenLines); 348 } 349 #endif 350 351 #ifdef FEAT_PROP_POPUP 352 /* 353 * Return TRUE if this position has a higher level popup or this cell is 354 * transparent in the current popup. 355 */ 356 static int 357 blocked_by_popup(int row, int col) 358 { 359 int off; 360 361 if (!popup_visible) 362 return FALSE; 363 off = row * screen_Columns + col; 364 return popup_mask[off] > screen_zindex || popup_transparent[off]; 365 } 366 #endif 367 368 /* 369 * Reset the highlighting. Used before clearing the screen. 370 */ 371 void 372 reset_screen_attr(void) 373 { 374 #ifdef FEAT_GUI 375 if (gui.in_use) 376 // Use a code that will reset gui.highlight_mask in 377 // gui_stop_highlight(). 378 screen_attr = HL_ALL + 1; 379 else 380 #endif 381 // Use attributes that is very unlikely to appear in text. 382 screen_attr = HL_BOLD | HL_UNDERLINE | HL_INVERSE | HL_STRIKETHROUGH; 383 } 384 385 /* 386 * Move one "cooked" screen line to the screen, but only the characters that 387 * have actually changed. Handle insert/delete character. 388 * "coloff" gives the first column on the screen for this line. 389 * "endcol" gives the columns where valid characters are. 390 * "clear_width" is the width of the window. It's > 0 if the rest of the line 391 * needs to be cleared, negative otherwise. 392 * "flags" can have bits: 393 * SLF_POPUP popup window 394 * SLF_RIGHTLEFT rightleft window: 395 * When TRUE and "clear_width" > 0, clear columns 0 to "endcol" 396 * When FALSE and "clear_width" > 0, clear columns "endcol" to "clear_width" 397 */ 398 void 399 screen_line( 400 int row, 401 int coloff, 402 int endcol, 403 int clear_width, 404 int flags UNUSED) 405 { 406 unsigned off_from; 407 unsigned off_to; 408 unsigned max_off_from; 409 unsigned max_off_to; 410 int col = 0; 411 int hl; 412 int force = FALSE; // force update rest of the line 413 int redraw_this // bool: does character need redraw? 414 #ifdef FEAT_GUI 415 = TRUE // For GUI when while-loop empty 416 #endif 417 ; 418 int redraw_next; // redraw_this for next character 419 int clear_next = FALSE; 420 int char_cells; // 1: normal char 421 // 2: occupies two display cells 422 # define CHAR_CELLS char_cells 423 424 // Check for illegal row and col, just in case. 425 if (row >= Rows) 426 row = Rows - 1; 427 if (endcol > Columns) 428 endcol = Columns; 429 430 # ifdef FEAT_CLIPBOARD 431 clip_may_clear_selection(row, row); 432 # endif 433 434 off_from = (unsigned)(current_ScreenLine - ScreenLines); 435 off_to = LineOffset[row] + coloff; 436 max_off_from = off_from + screen_Columns; 437 max_off_to = LineOffset[row] + screen_Columns; 438 439 #ifdef FEAT_RIGHTLEFT 440 if (flags & SLF_RIGHTLEFT) 441 { 442 // Clear rest first, because it's left of the text. 443 if (clear_width > 0) 444 { 445 while (col <= endcol && ScreenLines[off_to] == ' ' 446 && ScreenAttrs[off_to] == 0 447 && (!enc_utf8 || ScreenLinesUC[off_to] == 0)) 448 { 449 ++off_to; 450 ++col; 451 } 452 if (col <= endcol) 453 screen_fill(row, row + 1, col + coloff, 454 endcol + coloff + 1, ' ', ' ', 0); 455 } 456 col = endcol + 1; 457 off_to = LineOffset[row] + col + coloff; 458 off_from += col; 459 endcol = (clear_width > 0 ? clear_width : -clear_width); 460 } 461 #endif // FEAT_RIGHTLEFT 462 463 #ifdef FEAT_PROP_POPUP 464 // First char of a popup window may go on top of the right half of a 465 // double-wide character. Clear the left half to avoid it getting the popup 466 // window background color. 467 if (coloff > 0 && ScreenLines[off_to] == 0) 468 { 469 ScreenLines[off_to - 1] = ' '; 470 ScreenLinesUC[off_to - 1] = 0; 471 screen_char(off_to - 1, row, col + coloff - 1); 472 } 473 #endif 474 475 redraw_next = char_needs_redraw(off_from, off_to, endcol - col); 476 477 while (col < endcol) 478 { 479 if (has_mbyte && (col + 1 < endcol)) 480 char_cells = (*mb_off2cells)(off_from, max_off_from); 481 else 482 char_cells = 1; 483 484 redraw_this = redraw_next; 485 redraw_next = force || char_needs_redraw(off_from + CHAR_CELLS, 486 off_to + CHAR_CELLS, endcol - col - CHAR_CELLS); 487 488 #ifdef FEAT_GUI 489 // If the next character was bold, then redraw the current character to 490 // remove any pixels that might have spilt over into us. This only 491 // happens in the GUI. 492 if (redraw_next && gui.in_use) 493 { 494 hl = ScreenAttrs[off_to + CHAR_CELLS]; 495 if (hl > HL_ALL) 496 hl = syn_attr2attr(hl); 497 if (hl & HL_BOLD) 498 redraw_this = TRUE; 499 } 500 #endif 501 #ifdef FEAT_PROP_POPUP 502 if (blocked_by_popup(row, col + coloff)) 503 redraw_this = FALSE; 504 #endif 505 if (redraw_this) 506 { 507 /* 508 * Special handling when 'xs' termcap flag set (hpterm): 509 * Attributes for characters are stored at the position where the 510 * cursor is when writing the highlighting code. The 511 * start-highlighting code must be written with the cursor on the 512 * first highlighted character. The stop-highlighting code must 513 * be written with the cursor just after the last highlighted 514 * character. 515 * Overwriting a character doesn't remove its highlighting. Need 516 * to clear the rest of the line, and force redrawing it 517 * completely. 518 */ 519 if ( p_wiv 520 && !force 521 #ifdef FEAT_GUI 522 && !gui.in_use 523 #endif 524 && ScreenAttrs[off_to] != 0 525 && ScreenAttrs[off_from] != ScreenAttrs[off_to]) 526 { 527 /* 528 * Need to remove highlighting attributes here. 529 */ 530 windgoto(row, col + coloff); 531 out_str(T_CE); // clear rest of this screen line 532 screen_start(); // don't know where cursor is now 533 force = TRUE; // force redraw of rest of the line 534 redraw_next = TRUE; // or else next char would miss out 535 536 /* 537 * If the previous character was highlighted, need to stop 538 * highlighting at this character. 539 */ 540 if (col + coloff > 0 && ScreenAttrs[off_to - 1] != 0) 541 { 542 screen_attr = ScreenAttrs[off_to - 1]; 543 term_windgoto(row, col + coloff); 544 screen_stop_highlight(); 545 } 546 else 547 screen_attr = 0; // highlighting has stopped 548 } 549 if (enc_dbcs != 0) 550 { 551 // Check if overwriting a double-byte with a single-byte or 552 // the other way around requires another character to be 553 // redrawn. For UTF-8 this isn't needed, because comparing 554 // ScreenLinesUC[] is sufficient. 555 if (char_cells == 1 556 && col + 1 < endcol 557 && (*mb_off2cells)(off_to, max_off_to) > 1) 558 { 559 // Writing a single-cell character over a double-cell 560 // character: need to redraw the next cell. 561 ScreenLines[off_to + 1] = 0; 562 redraw_next = TRUE; 563 } 564 else if (char_cells == 2 565 && col + 2 < endcol 566 && (*mb_off2cells)(off_to, max_off_to) == 1 567 && (*mb_off2cells)(off_to + 1, max_off_to) > 1) 568 { 569 // Writing the second half of a double-cell character over 570 // a double-cell character: need to redraw the second 571 // cell. 572 ScreenLines[off_to + 2] = 0; 573 redraw_next = TRUE; 574 } 575 576 if (enc_dbcs == DBCS_JPNU) 577 ScreenLines2[off_to] = ScreenLines2[off_from]; 578 } 579 // When writing a single-width character over a double-width 580 // character and at the end of the redrawn text, need to clear out 581 // the right halve of the old character. 582 // Also required when writing the right halve of a double-width 583 // char over the left halve of an existing one. 584 if (has_mbyte && col + char_cells == endcol 585 && ((char_cells == 1 586 && (*mb_off2cells)(off_to, max_off_to) > 1) 587 || (char_cells == 2 588 && (*mb_off2cells)(off_to, max_off_to) == 1 589 && (*mb_off2cells)(off_to + 1, max_off_to) > 1))) 590 clear_next = TRUE; 591 592 ScreenLines[off_to] = ScreenLines[off_from]; 593 if (enc_utf8) 594 { 595 ScreenLinesUC[off_to] = ScreenLinesUC[off_from]; 596 if (ScreenLinesUC[off_from] != 0) 597 { 598 int i; 599 600 for (i = 0; i < Screen_mco; ++i) 601 ScreenLinesC[i][off_to] = ScreenLinesC[i][off_from]; 602 } 603 } 604 if (char_cells == 2) 605 ScreenLines[off_to + 1] = ScreenLines[off_from + 1]; 606 607 #if defined(FEAT_GUI) || defined(UNIX) 608 // The bold trick makes a single column of pixels appear in the 609 // next character. When a bold character is removed, the next 610 // character should be redrawn too. This happens for our own GUI 611 // and for some xterms. 612 if ( 613 # ifdef FEAT_GUI 614 gui.in_use 615 # endif 616 # if defined(FEAT_GUI) && defined(UNIX) 617 || 618 # endif 619 # ifdef UNIX 620 term_is_xterm 621 # endif 622 ) 623 { 624 hl = ScreenAttrs[off_to]; 625 if (hl > HL_ALL) 626 hl = syn_attr2attr(hl); 627 if (hl & HL_BOLD) 628 redraw_next = TRUE; 629 } 630 #endif 631 ScreenAttrs[off_to] = ScreenAttrs[off_from]; 632 633 // For simplicity set the attributes of second half of a 634 // double-wide character equal to the first half. 635 if (char_cells == 2) 636 ScreenAttrs[off_to + 1] = ScreenAttrs[off_from]; 637 638 if (enc_dbcs != 0 && char_cells == 2) 639 screen_char_2(off_to, row, col + coloff); 640 else 641 screen_char(off_to, row, col + coloff); 642 } 643 else if ( p_wiv 644 #ifdef FEAT_GUI 645 && !gui.in_use 646 #endif 647 && col + coloff > 0) 648 { 649 if (ScreenAttrs[off_to] == ScreenAttrs[off_to - 1]) 650 { 651 /* 652 * Don't output stop-highlight when moving the cursor, it will 653 * stop the highlighting when it should continue. 654 */ 655 screen_attr = 0; 656 } 657 else if (screen_attr != 0) 658 screen_stop_highlight(); 659 } 660 661 off_to += CHAR_CELLS; 662 off_from += CHAR_CELLS; 663 col += CHAR_CELLS; 664 } 665 666 if (clear_next) 667 { 668 // Clear the second half of a double-wide character of which the left 669 // half was overwritten with a single-wide character. 670 ScreenLines[off_to] = ' '; 671 if (enc_utf8) 672 ScreenLinesUC[off_to] = 0; 673 screen_char(off_to, row, col + coloff); 674 } 675 676 if (clear_width > 0 677 #ifdef FEAT_RIGHTLEFT 678 && !(flags & SLF_RIGHTLEFT) 679 #endif 680 ) 681 { 682 #ifdef FEAT_GUI 683 int startCol = col; 684 #endif 685 686 // blank out the rest of the line 687 while (col < clear_width && ScreenLines[off_to] == ' ' 688 && ScreenAttrs[off_to] == 0 689 && (!enc_utf8 || ScreenLinesUC[off_to] == 0)) 690 { 691 ++off_to; 692 ++col; 693 } 694 if (col < clear_width) 695 { 696 #ifdef FEAT_GUI 697 /* 698 * In the GUI, clearing the rest of the line may leave pixels 699 * behind if the first character cleared was bold. Some bold 700 * fonts spill over the left. In this case we redraw the previous 701 * character too. If we didn't skip any blanks above, then we 702 * only redraw if the character wasn't already redrawn anyway. 703 */ 704 if (gui.in_use && (col > startCol || !redraw_this)) 705 { 706 hl = ScreenAttrs[off_to]; 707 if (hl > HL_ALL || (hl & HL_BOLD)) 708 { 709 int prev_cells = 1; 710 711 if (enc_utf8) 712 // for utf-8, ScreenLines[char_offset + 1] == 0 means 713 // that its width is 2. 714 prev_cells = ScreenLines[off_to - 1] == 0 ? 2 : 1; 715 else if (enc_dbcs != 0) 716 { 717 // find previous character by counting from first 718 // column and get its width. 719 unsigned off = LineOffset[row]; 720 unsigned max_off = LineOffset[row] + screen_Columns; 721 722 while (off < off_to) 723 { 724 prev_cells = (*mb_off2cells)(off, max_off); 725 off += prev_cells; 726 } 727 } 728 729 if (enc_dbcs != 0 && prev_cells > 1) 730 screen_char_2(off_to - prev_cells, row, 731 col + coloff - prev_cells); 732 else 733 screen_char(off_to - prev_cells, row, 734 col + coloff - prev_cells); 735 } 736 } 737 #endif 738 screen_fill(row, row + 1, col + coloff, clear_width + coloff, 739 ' ', ' ', 0); 740 off_to += clear_width - col; 741 col = clear_width; 742 } 743 } 744 745 if (clear_width > 0 746 #ifdef FEAT_PROP_POPUP 747 && !(flags & SLF_POPUP) // no separator for popup window 748 #endif 749 ) 750 { 751 // For a window that has a right neighbor, draw the separator char 752 // right of the window contents. But not on top of a popup window. 753 if (coloff + col < Columns) 754 { 755 #ifdef FEAT_PROP_POPUP 756 if (!blocked_by_popup(row, col + coloff)) 757 #endif 758 { 759 int c; 760 761 c = fillchar_vsep(&hl); 762 if (ScreenLines[off_to] != (schar_T)c 763 || (enc_utf8 && (int)ScreenLinesUC[off_to] 764 != (c >= 0x80 ? c : 0)) 765 || ScreenAttrs[off_to] != hl) 766 { 767 ScreenLines[off_to] = c; 768 ScreenAttrs[off_to] = hl; 769 if (enc_utf8) 770 { 771 if (c >= 0x80) 772 { 773 ScreenLinesUC[off_to] = c; 774 ScreenLinesC[0][off_to] = 0; 775 } 776 else 777 ScreenLinesUC[off_to] = 0; 778 } 779 screen_char(off_to, row, col + coloff); 780 } 781 } 782 } 783 else 784 LineWraps[row] = FALSE; 785 } 786 } 787 788 #if defined(FEAT_RIGHTLEFT) || defined(PROTO) 789 /* 790 * Mirror text "str" for right-left displaying. 791 * Only works for single-byte characters (e.g., numbers). 792 */ 793 void 794 rl_mirror(char_u *str) 795 { 796 char_u *p1, *p2; 797 int t; 798 799 for (p1 = str, p2 = str + STRLEN(str) - 1; p1 < p2; ++p1, --p2) 800 { 801 t = *p1; 802 *p1 = *p2; 803 *p2 = t; 804 } 805 } 806 #endif 807 808 /* 809 * Draw the verticap separator right of window "wp" starting with line "row". 810 */ 811 void 812 draw_vsep_win(win_T *wp, int row) 813 { 814 int hl; 815 int c; 816 817 if (wp->w_vsep_width) 818 { 819 // draw the vertical separator right of this window 820 c = fillchar_vsep(&hl); 821 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + wp->w_height, 822 W_ENDCOL(wp), W_ENDCOL(wp) + 1, 823 c, ' ', hl); 824 } 825 } 826 827 #ifdef FEAT_WILDMENU 828 static int skip_status_match_char(expand_T *xp, char_u *s); 829 830 /* 831 * Get the length of an item as it will be shown in the status line. 832 */ 833 static int 834 status_match_len(expand_T *xp, char_u *s) 835 { 836 int len = 0; 837 838 #ifdef FEAT_MENU 839 int emenu = (xp->xp_context == EXPAND_MENUS 840 || xp->xp_context == EXPAND_MENUNAMES); 841 842 // Check for menu separators - replace with '|'. 843 if (emenu && menu_is_separator(s)) 844 return 1; 845 #endif 846 847 while (*s != NUL) 848 { 849 s += skip_status_match_char(xp, s); 850 len += ptr2cells(s); 851 MB_PTR_ADV(s); 852 } 853 854 return len; 855 } 856 857 /* 858 * Return the number of characters that should be skipped in a status match. 859 * These are backslashes used for escaping. Do show backslashes in help tags. 860 */ 861 static int 862 skip_status_match_char(expand_T *xp, char_u *s) 863 { 864 if ((rem_backslash(s) && xp->xp_context != EXPAND_HELP) 865 #ifdef FEAT_MENU 866 || ((xp->xp_context == EXPAND_MENUS 867 || xp->xp_context == EXPAND_MENUNAMES) 868 && (s[0] == '\t' || (s[0] == '\\' && s[1] != NUL))) 869 #endif 870 ) 871 { 872 #ifndef BACKSLASH_IN_FILENAME 873 if (xp->xp_shell && csh_like_shell() && s[1] == '\\' && s[2] == '!') 874 return 2; 875 #endif 876 return 1; 877 } 878 return 0; 879 } 880 881 /* 882 * Show wildchar matches in the status line. 883 * Show at least the "match" item. 884 * We start at item 'first_match' in the list and show all matches that fit. 885 * 886 * If inversion is possible we use it. Else '=' characters are used. 887 */ 888 void 889 win_redr_status_matches( 890 expand_T *xp, 891 int num_matches, 892 char_u **matches, // list of matches 893 int match, 894 int showtail) 895 { 896 #define L_MATCH(m) (showtail ? sm_gettail(matches[m]) : matches[m]) 897 int row; 898 char_u *buf; 899 int len; 900 int clen; // length in screen cells 901 int fillchar; 902 int attr; 903 int i; 904 int highlight = TRUE; 905 char_u *selstart = NULL; 906 int selstart_col = 0; 907 char_u *selend = NULL; 908 static int first_match = 0; 909 int add_left = FALSE; 910 char_u *s; 911 #ifdef FEAT_MENU 912 int emenu; 913 #endif 914 int l; 915 916 if (matches == NULL) // interrupted completion? 917 return; 918 919 if (has_mbyte) 920 buf = alloc(Columns * MB_MAXBYTES + 1); 921 else 922 buf = alloc(Columns + 1); 923 if (buf == NULL) 924 return; 925 926 if (match == -1) // don't show match but original text 927 { 928 match = 0; 929 highlight = FALSE; 930 } 931 // count 1 for the ending ">" 932 clen = status_match_len(xp, L_MATCH(match)) + 3; 933 if (match == 0) 934 first_match = 0; 935 else if (match < first_match) 936 { 937 // jumping left, as far as we can go 938 first_match = match; 939 add_left = TRUE; 940 } 941 else 942 { 943 // check if match fits on the screen 944 for (i = first_match; i < match; ++i) 945 clen += status_match_len(xp, L_MATCH(i)) + 2; 946 if (first_match > 0) 947 clen += 2; 948 // jumping right, put match at the left 949 if ((long)clen > Columns) 950 { 951 first_match = match; 952 // if showing the last match, we can add some on the left 953 clen = 2; 954 for (i = match; i < num_matches; ++i) 955 { 956 clen += status_match_len(xp, L_MATCH(i)) + 2; 957 if ((long)clen >= Columns) 958 break; 959 } 960 if (i == num_matches) 961 add_left = TRUE; 962 } 963 } 964 if (add_left) 965 while (first_match > 0) 966 { 967 clen += status_match_len(xp, L_MATCH(first_match - 1)) + 2; 968 if ((long)clen >= Columns) 969 break; 970 --first_match; 971 } 972 973 fillchar = fillchar_status(&attr, curwin); 974 975 if (first_match == 0) 976 { 977 *buf = NUL; 978 len = 0; 979 } 980 else 981 { 982 STRCPY(buf, "< "); 983 len = 2; 984 } 985 clen = len; 986 987 i = first_match; 988 while ((long)(clen + status_match_len(xp, L_MATCH(i)) + 2) < Columns) 989 { 990 if (i == match) 991 { 992 selstart = buf + len; 993 selstart_col = clen; 994 } 995 996 s = L_MATCH(i); 997 // Check for menu separators - replace with '|' 998 #ifdef FEAT_MENU 999 emenu = (xp->xp_context == EXPAND_MENUS 1000 || xp->xp_context == EXPAND_MENUNAMES); 1001 if (emenu && menu_is_separator(s)) 1002 { 1003 STRCPY(buf + len, transchar('|')); 1004 l = (int)STRLEN(buf + len); 1005 len += l; 1006 clen += l; 1007 } 1008 else 1009 #endif 1010 for ( ; *s != NUL; ++s) 1011 { 1012 s += skip_status_match_char(xp, s); 1013 clen += ptr2cells(s); 1014 if (has_mbyte && (l = (*mb_ptr2len)(s)) > 1) 1015 { 1016 STRNCPY(buf + len, s, l); 1017 s += l - 1; 1018 len += l; 1019 } 1020 else 1021 { 1022 STRCPY(buf + len, transchar_byte(*s)); 1023 len += (int)STRLEN(buf + len); 1024 } 1025 } 1026 if (i == match) 1027 selend = buf + len; 1028 1029 *(buf + len++) = ' '; 1030 *(buf + len++) = ' '; 1031 clen += 2; 1032 if (++i == num_matches) 1033 break; 1034 } 1035 1036 if (i != num_matches) 1037 { 1038 *(buf + len++) = '>'; 1039 ++clen; 1040 } 1041 1042 buf[len] = NUL; 1043 1044 row = cmdline_row - 1; 1045 if (row >= 0) 1046 { 1047 if (wild_menu_showing == 0) 1048 { 1049 if (msg_scrolled > 0) 1050 { 1051 // Put the wildmenu just above the command line. If there is 1052 // no room, scroll the screen one line up. 1053 if (cmdline_row == Rows - 1) 1054 { 1055 screen_del_lines(0, 0, 1, (int)Rows, TRUE, 0, NULL); 1056 ++msg_scrolled; 1057 } 1058 else 1059 { 1060 ++cmdline_row; 1061 ++row; 1062 } 1063 wild_menu_showing = WM_SCROLLED; 1064 } 1065 else 1066 { 1067 // Create status line if needed by setting 'laststatus' to 2. 1068 // Set 'winminheight' to zero to avoid that the window is 1069 // resized. 1070 if (lastwin->w_status_height == 0) 1071 { 1072 save_p_ls = p_ls; 1073 save_p_wmh = p_wmh; 1074 p_ls = 2; 1075 p_wmh = 0; 1076 last_status(FALSE); 1077 } 1078 wild_menu_showing = WM_SHOWN; 1079 } 1080 } 1081 1082 screen_puts(buf, row, 0, attr); 1083 if (selstart != NULL && highlight) 1084 { 1085 *selend = NUL; 1086 screen_puts(selstart, row, selstart_col, HL_ATTR(HLF_WM)); 1087 } 1088 1089 screen_fill(row, row + 1, clen, (int)Columns, fillchar, fillchar, attr); 1090 } 1091 1092 win_redraw_last_status(topframe); 1093 vim_free(buf); 1094 } 1095 #endif 1096 1097 /* 1098 * Return TRUE if the status line of window "wp" is connected to the status 1099 * line of the window right of it. If not, then it's a vertical separator. 1100 * Only call if (wp->w_vsep_width != 0). 1101 */ 1102 int 1103 stl_connected(win_T *wp) 1104 { 1105 frame_T *fr; 1106 1107 fr = wp->w_frame; 1108 while (fr->fr_parent != NULL) 1109 { 1110 if (fr->fr_parent->fr_layout == FR_COL) 1111 { 1112 if (fr->fr_next != NULL) 1113 break; 1114 } 1115 else 1116 { 1117 if (fr->fr_next != NULL) 1118 return TRUE; 1119 } 1120 fr = fr->fr_parent; 1121 } 1122 return FALSE; 1123 } 1124 1125 1126 /* 1127 * Get the value to show for the language mappings, active 'keymap'. 1128 */ 1129 int 1130 get_keymap_str( 1131 win_T *wp, 1132 char_u *fmt, // format string containing one %s item 1133 char_u *buf, // buffer for the result 1134 int len) // length of buffer 1135 { 1136 char_u *p; 1137 1138 if (wp->w_buffer->b_p_iminsert != B_IMODE_LMAP) 1139 return FALSE; 1140 1141 { 1142 #ifdef FEAT_EVAL 1143 buf_T *old_curbuf = curbuf; 1144 win_T *old_curwin = curwin; 1145 char_u *s; 1146 1147 curbuf = wp->w_buffer; 1148 curwin = wp; 1149 STRCPY(buf, "b:keymap_name"); // must be writable 1150 ++emsg_skip; 1151 s = p = eval_to_string(buf, NULL, FALSE); 1152 --emsg_skip; 1153 curbuf = old_curbuf; 1154 curwin = old_curwin; 1155 if (p == NULL || *p == NUL) 1156 #endif 1157 { 1158 #ifdef FEAT_KEYMAP 1159 if (wp->w_buffer->b_kmap_state & KEYMAP_LOADED) 1160 p = wp->w_buffer->b_p_keymap; 1161 else 1162 #endif 1163 p = (char_u *)"lang"; 1164 } 1165 if (vim_snprintf((char *)buf, len, (char *)fmt, p) > len - 1) 1166 buf[0] = NUL; 1167 #ifdef FEAT_EVAL 1168 vim_free(s); 1169 #endif 1170 } 1171 return buf[0] != NUL; 1172 } 1173 1174 #if defined(FEAT_STL_OPT) || defined(PROTO) 1175 /* 1176 * Redraw the status line or ruler of window "wp". 1177 * When "wp" is NULL redraw the tab pages line from 'tabline'. 1178 */ 1179 void 1180 win_redr_custom( 1181 win_T *wp, 1182 int draw_ruler) // TRUE or FALSE 1183 { 1184 static int entered = FALSE; 1185 int attr; 1186 int curattr; 1187 int row; 1188 int col = 0; 1189 int maxwidth; 1190 int width; 1191 int n; 1192 int len; 1193 int fillchar; 1194 char_u buf[MAXPATHL]; 1195 char_u *stl; 1196 char_u *p; 1197 struct stl_hlrec hltab[STL_MAX_ITEM]; 1198 struct stl_hlrec tabtab[STL_MAX_ITEM]; 1199 int use_sandbox = FALSE; 1200 win_T *ewp; 1201 int p_crb_save; 1202 1203 // There is a tiny chance that this gets called recursively: When 1204 // redrawing a status line triggers redrawing the ruler or tabline. 1205 // Avoid trouble by not allowing recursion. 1206 if (entered) 1207 return; 1208 entered = TRUE; 1209 1210 // setup environment for the task at hand 1211 if (wp == NULL) 1212 { 1213 // Use 'tabline'. Always at the first line of the screen. 1214 stl = p_tal; 1215 row = 0; 1216 fillchar = ' '; 1217 attr = HL_ATTR(HLF_TPF); 1218 maxwidth = Columns; 1219 # ifdef FEAT_EVAL 1220 use_sandbox = was_set_insecurely((char_u *)"tabline", 0); 1221 # endif 1222 } 1223 else 1224 { 1225 row = W_WINROW(wp) + wp->w_height; 1226 fillchar = fillchar_status(&attr, wp); 1227 maxwidth = wp->w_width; 1228 1229 if (draw_ruler) 1230 { 1231 stl = p_ruf; 1232 // advance past any leading group spec - implicit in ru_col 1233 if (*stl == '%') 1234 { 1235 if (*++stl == '-') 1236 stl++; 1237 if (atoi((char *)stl)) 1238 while (VIM_ISDIGIT(*stl)) 1239 stl++; 1240 if (*stl++ != '(') 1241 stl = p_ruf; 1242 } 1243 col = ru_col - (Columns - wp->w_width); 1244 if (col < (wp->w_width + 1) / 2) 1245 col = (wp->w_width + 1) / 2; 1246 maxwidth = wp->w_width - col; 1247 if (!wp->w_status_height) 1248 { 1249 row = Rows - 1; 1250 --maxwidth; // writing in last column may cause scrolling 1251 fillchar = ' '; 1252 attr = 0; 1253 } 1254 1255 # ifdef FEAT_EVAL 1256 use_sandbox = was_set_insecurely((char_u *)"rulerformat", 0); 1257 # endif 1258 } 1259 else 1260 { 1261 if (*wp->w_p_stl != NUL) 1262 stl = wp->w_p_stl; 1263 else 1264 stl = p_stl; 1265 # ifdef FEAT_EVAL 1266 use_sandbox = was_set_insecurely((char_u *)"statusline", 1267 *wp->w_p_stl == NUL ? 0 : OPT_LOCAL); 1268 # endif 1269 } 1270 1271 col += wp->w_wincol; 1272 } 1273 1274 if (maxwidth <= 0) 1275 goto theend; 1276 1277 // Temporarily reset 'cursorbind', we don't want a side effect from moving 1278 // the cursor away and back. 1279 ewp = wp == NULL ? curwin : wp; 1280 p_crb_save = ewp->w_p_crb; 1281 ewp->w_p_crb = FALSE; 1282 1283 // Make a copy, because the statusline may include a function call that 1284 // might change the option value and free the memory. 1285 stl = vim_strsave(stl); 1286 width = build_stl_str_hl(ewp, buf, sizeof(buf), 1287 stl, use_sandbox, 1288 fillchar, maxwidth, hltab, tabtab); 1289 vim_free(stl); 1290 ewp->w_p_crb = p_crb_save; 1291 1292 // Make all characters printable. 1293 p = transstr(buf); 1294 if (p != NULL) 1295 { 1296 vim_strncpy(buf, p, sizeof(buf) - 1); 1297 vim_free(p); 1298 } 1299 1300 // fill up with "fillchar" 1301 len = (int)STRLEN(buf); 1302 while (width < maxwidth && len < (int)sizeof(buf) - 1) 1303 { 1304 len += (*mb_char2bytes)(fillchar, buf + len); 1305 ++width; 1306 } 1307 buf[len] = NUL; 1308 1309 /* 1310 * Draw each snippet with the specified highlighting. 1311 */ 1312 curattr = attr; 1313 p = buf; 1314 for (n = 0; hltab[n].start != NULL; n++) 1315 { 1316 len = (int)(hltab[n].start - p); 1317 screen_puts_len(p, len, row, col, curattr); 1318 col += vim_strnsize(p, len); 1319 p = hltab[n].start; 1320 1321 if (hltab[n].userhl == 0) 1322 curattr = attr; 1323 else if (hltab[n].userhl < 0) 1324 curattr = syn_id2attr(-hltab[n].userhl); 1325 #ifdef FEAT_TERMINAL 1326 else if (wp != NULL && wp != curwin && bt_terminal(wp->w_buffer) 1327 && wp->w_status_height != 0) 1328 curattr = highlight_stltermnc[hltab[n].userhl - 1]; 1329 else if (wp != NULL && bt_terminal(wp->w_buffer) 1330 && wp->w_status_height != 0) 1331 curattr = highlight_stlterm[hltab[n].userhl - 1]; 1332 #endif 1333 else if (wp != NULL && wp != curwin && wp->w_status_height != 0) 1334 curattr = highlight_stlnc[hltab[n].userhl - 1]; 1335 else 1336 curattr = highlight_user[hltab[n].userhl - 1]; 1337 } 1338 screen_puts(p, row, col, curattr); 1339 1340 if (wp == NULL) 1341 { 1342 // Fill the TabPageIdxs[] array for clicking in the tab pagesline. 1343 col = 0; 1344 len = 0; 1345 p = buf; 1346 fillchar = 0; 1347 for (n = 0; tabtab[n].start != NULL; n++) 1348 { 1349 len += vim_strnsize(p, (int)(tabtab[n].start - p)); 1350 while (col < len) 1351 TabPageIdxs[col++] = fillchar; 1352 p = tabtab[n].start; 1353 fillchar = tabtab[n].userhl; 1354 } 1355 while (col < Columns) 1356 TabPageIdxs[col++] = fillchar; 1357 } 1358 1359 theend: 1360 entered = FALSE; 1361 } 1362 1363 #endif // FEAT_STL_OPT 1364 1365 /* 1366 * Output a single character directly to the screen and update ScreenLines. 1367 */ 1368 void 1369 screen_putchar(int c, int row, int col, int attr) 1370 { 1371 char_u buf[MB_MAXBYTES + 1]; 1372 1373 if (has_mbyte) 1374 buf[(*mb_char2bytes)(c, buf)] = NUL; 1375 else 1376 { 1377 buf[0] = c; 1378 buf[1] = NUL; 1379 } 1380 screen_puts(buf, row, col, attr); 1381 } 1382 1383 /* 1384 * Get a single character directly from ScreenLines into "bytes[]". 1385 * Also return its attribute in *attrp; 1386 */ 1387 void 1388 screen_getbytes(int row, int col, char_u *bytes, int *attrp) 1389 { 1390 unsigned off; 1391 1392 // safety check 1393 if (ScreenLines != NULL && row < screen_Rows && col < screen_Columns) 1394 { 1395 off = LineOffset[row] + col; 1396 *attrp = ScreenAttrs[off]; 1397 bytes[0] = ScreenLines[off]; 1398 bytes[1] = NUL; 1399 1400 if (enc_utf8 && ScreenLinesUC[off] != 0) 1401 bytes[utfc_char2bytes(off, bytes)] = NUL; 1402 else if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e) 1403 { 1404 bytes[0] = ScreenLines[off]; 1405 bytes[1] = ScreenLines2[off]; 1406 bytes[2] = NUL; 1407 } 1408 else if (enc_dbcs && MB_BYTE2LEN(bytes[0]) > 1) 1409 { 1410 bytes[1] = ScreenLines[off + 1]; 1411 bytes[2] = NUL; 1412 } 1413 } 1414 } 1415 1416 /* 1417 * Return TRUE if composing characters for screen posn "off" differs from 1418 * composing characters in "u8cc". 1419 * Only to be used when ScreenLinesUC[off] != 0. 1420 */ 1421 static int 1422 screen_comp_differs(int off, int *u8cc) 1423 { 1424 int i; 1425 1426 for (i = 0; i < Screen_mco; ++i) 1427 { 1428 if (ScreenLinesC[i][off] != (u8char_T)u8cc[i]) 1429 return TRUE; 1430 if (u8cc[i] == 0) 1431 break; 1432 } 1433 return FALSE; 1434 } 1435 1436 /* 1437 * Put string '*text' on the screen at position 'row' and 'col', with 1438 * attributes 'attr', and update ScreenLines[] and ScreenAttrs[]. 1439 * Note: only outputs within one row, message is truncated at screen boundary! 1440 * Note: if ScreenLines[], row and/or col is invalid, nothing is done. 1441 */ 1442 void 1443 screen_puts( 1444 char_u *text, 1445 int row, 1446 int col, 1447 int attr) 1448 { 1449 screen_puts_len(text, -1, row, col, attr); 1450 } 1451 1452 /* 1453 * Like screen_puts(), but output "text[len]". When "len" is -1 output up to 1454 * a NUL. 1455 */ 1456 void 1457 screen_puts_len( 1458 char_u *text, 1459 int textlen, 1460 int row, 1461 int col, 1462 int attr) 1463 { 1464 unsigned off; 1465 char_u *ptr = text; 1466 int len = textlen; 1467 int c; 1468 unsigned max_off; 1469 int mbyte_blen = 1; 1470 int mbyte_cells = 1; 1471 int u8c = 0; 1472 int u8cc[MAX_MCO]; 1473 int clear_next_cell = FALSE; 1474 #ifdef FEAT_ARABIC 1475 int prev_c = 0; // previous Arabic character 1476 int pc, nc, nc1; 1477 int pcc[MAX_MCO]; 1478 #endif 1479 int force_redraw_this; 1480 int force_redraw_next = FALSE; 1481 int need_redraw; 1482 1483 // Safety check. The check for negative row and column is to fix issue 1484 // #4102. TODO: find out why row/col could be negative. 1485 if (ScreenLines == NULL 1486 || row >= screen_Rows || row < 0 1487 || col >= screen_Columns || col < 0) 1488 return; 1489 off = LineOffset[row] + col; 1490 1491 // When drawing over the right halve of a double-wide char clear out the 1492 // left halve. Only needed in a terminal. 1493 if (has_mbyte && col > 0 && col < screen_Columns 1494 #ifdef FEAT_GUI 1495 && !gui.in_use 1496 #endif 1497 && mb_fix_col(col, row) != col) 1498 { 1499 ScreenLines[off - 1] = ' '; 1500 ScreenAttrs[off - 1] = 0; 1501 if (enc_utf8) 1502 { 1503 ScreenLinesUC[off - 1] = 0; 1504 ScreenLinesC[0][off - 1] = 0; 1505 } 1506 // redraw the previous cell, make it empty 1507 screen_char(off - 1, row, col - 1); 1508 // force the cell at "col" to be redrawn 1509 force_redraw_next = TRUE; 1510 } 1511 1512 max_off = LineOffset[row] + screen_Columns; 1513 while (col < screen_Columns 1514 && (len < 0 || (int)(ptr - text) < len) 1515 && *ptr != NUL) 1516 { 1517 c = *ptr; 1518 // check if this is the first byte of a multibyte 1519 if (has_mbyte) 1520 { 1521 if (enc_utf8 && len > 0) 1522 mbyte_blen = utfc_ptr2len_len(ptr, (int)((text + len) - ptr)); 1523 else 1524 mbyte_blen = (*mb_ptr2len)(ptr); 1525 if (enc_dbcs == DBCS_JPNU && c == 0x8e) 1526 mbyte_cells = 1; 1527 else if (enc_dbcs != 0) 1528 mbyte_cells = mbyte_blen; 1529 else // enc_utf8 1530 { 1531 if (len >= 0) 1532 u8c = utfc_ptr2char_len(ptr, u8cc, 1533 (int)((text + len) - ptr)); 1534 else 1535 u8c = utfc_ptr2char(ptr, u8cc); 1536 mbyte_cells = utf_char2cells(u8c); 1537 #ifdef FEAT_ARABIC 1538 if (p_arshape && !p_tbidi && ARABIC_CHAR(u8c)) 1539 { 1540 // Do Arabic shaping. 1541 if (len >= 0 && (int)(ptr - text) + mbyte_blen >= len) 1542 { 1543 // Past end of string to be displayed. 1544 nc = NUL; 1545 nc1 = NUL; 1546 } 1547 else 1548 { 1549 nc = utfc_ptr2char_len(ptr + mbyte_blen, pcc, 1550 (int)((text + len) - ptr - mbyte_blen)); 1551 nc1 = pcc[0]; 1552 } 1553 pc = prev_c; 1554 prev_c = u8c; 1555 u8c = arabic_shape(u8c, &c, &u8cc[0], nc, nc1, pc); 1556 } 1557 else 1558 prev_c = u8c; 1559 #endif 1560 if (col + mbyte_cells > screen_Columns) 1561 { 1562 // Only 1 cell left, but character requires 2 cells: 1563 // display a '>' in the last column to avoid wrapping. 1564 c = '>'; 1565 mbyte_cells = 1; 1566 } 1567 } 1568 } 1569 1570 force_redraw_this = force_redraw_next; 1571 force_redraw_next = FALSE; 1572 1573 need_redraw = ScreenLines[off] != c 1574 || (mbyte_cells == 2 1575 && ScreenLines[off + 1] != (enc_dbcs ? ptr[1] : 0)) 1576 || (enc_dbcs == DBCS_JPNU 1577 && c == 0x8e 1578 && ScreenLines2[off] != ptr[1]) 1579 || (enc_utf8 1580 && (ScreenLinesUC[off] != 1581 (u8char_T)(c < 0x80 && u8cc[0] == 0 ? 0 : u8c) 1582 || (ScreenLinesUC[off] != 0 1583 && screen_comp_differs(off, u8cc)))) 1584 || ScreenAttrs[off] != attr 1585 || exmode_active; 1586 1587 if ((need_redraw || force_redraw_this) 1588 #ifdef FEAT_PROP_POPUP 1589 && !blocked_by_popup(row, col) 1590 #endif 1591 ) 1592 { 1593 #if defined(FEAT_GUI) || defined(UNIX) 1594 // The bold trick makes a single row of pixels appear in the next 1595 // character. When a bold character is removed, the next 1596 // character should be redrawn too. This happens for our own GUI 1597 // and for some xterms. 1598 if (need_redraw && ScreenLines[off] != ' ' && ( 1599 # ifdef FEAT_GUI 1600 gui.in_use 1601 # endif 1602 # if defined(FEAT_GUI) && defined(UNIX) 1603 || 1604 # endif 1605 # ifdef UNIX 1606 term_is_xterm 1607 # endif 1608 )) 1609 { 1610 int n = ScreenAttrs[off]; 1611 1612 if (n > HL_ALL) 1613 n = syn_attr2attr(n); 1614 if (n & HL_BOLD) 1615 force_redraw_next = TRUE; 1616 } 1617 #endif 1618 // When at the end of the text and overwriting a two-cell 1619 // character with a one-cell character, need to clear the next 1620 // cell. Also when overwriting the left halve of a two-cell char 1621 // with the right halve of a two-cell char. Do this only once 1622 // (mb_off2cells() may return 2 on the right halve). 1623 if (clear_next_cell) 1624 clear_next_cell = FALSE; 1625 else if (has_mbyte 1626 && (len < 0 ? ptr[mbyte_blen] == NUL 1627 : ptr + mbyte_blen >= text + len) 1628 && ((mbyte_cells == 1 && (*mb_off2cells)(off, max_off) > 1) 1629 || (mbyte_cells == 2 1630 && (*mb_off2cells)(off, max_off) == 1 1631 && (*mb_off2cells)(off + 1, max_off) > 1))) 1632 clear_next_cell = TRUE; 1633 1634 // Make sure we never leave a second byte of a double-byte behind, 1635 // it confuses mb_off2cells(). 1636 if (enc_dbcs 1637 && ((mbyte_cells == 1 && (*mb_off2cells)(off, max_off) > 1) 1638 || (mbyte_cells == 2 1639 && (*mb_off2cells)(off, max_off) == 1 1640 && (*mb_off2cells)(off + 1, max_off) > 1))) 1641 ScreenLines[off + mbyte_blen] = 0; 1642 ScreenLines[off] = c; 1643 ScreenAttrs[off] = attr; 1644 if (enc_utf8) 1645 { 1646 if (c < 0x80 && u8cc[0] == 0) 1647 ScreenLinesUC[off] = 0; 1648 else 1649 { 1650 int i; 1651 1652 ScreenLinesUC[off] = u8c; 1653 for (i = 0; i < Screen_mco; ++i) 1654 { 1655 ScreenLinesC[i][off] = u8cc[i]; 1656 if (u8cc[i] == 0) 1657 break; 1658 } 1659 } 1660 if (mbyte_cells == 2) 1661 { 1662 ScreenLines[off + 1] = 0; 1663 ScreenAttrs[off + 1] = attr; 1664 } 1665 screen_char(off, row, col); 1666 } 1667 else if (mbyte_cells == 2) 1668 { 1669 ScreenLines[off + 1] = ptr[1]; 1670 ScreenAttrs[off + 1] = attr; 1671 screen_char_2(off, row, col); 1672 } 1673 else if (enc_dbcs == DBCS_JPNU && c == 0x8e) 1674 { 1675 ScreenLines2[off] = ptr[1]; 1676 screen_char(off, row, col); 1677 } 1678 else 1679 screen_char(off, row, col); 1680 } 1681 if (has_mbyte) 1682 { 1683 off += mbyte_cells; 1684 col += mbyte_cells; 1685 ptr += mbyte_blen; 1686 if (clear_next_cell) 1687 { 1688 // This only happens at the end, display one space next. 1689 ptr = (char_u *)" "; 1690 len = -1; 1691 } 1692 } 1693 else 1694 { 1695 ++off; 1696 ++col; 1697 ++ptr; 1698 } 1699 } 1700 1701 // If we detected the next character needs to be redrawn, but the text 1702 // doesn't extend up to there, update the character here. 1703 if (force_redraw_next && col < screen_Columns) 1704 { 1705 if (enc_dbcs != 0 && dbcs_off2cells(off, max_off) > 1) 1706 screen_char_2(off, row, col); 1707 else 1708 screen_char(off, row, col); 1709 } 1710 } 1711 1712 #if defined(FEAT_SEARCH_EXTRA) || defined(PROTO) 1713 /* 1714 * Prepare for 'hlsearch' highlighting. 1715 */ 1716 void 1717 start_search_hl(void) 1718 { 1719 if (p_hls && !no_hlsearch) 1720 { 1721 last_pat_prog(&screen_search_hl.rm); 1722 screen_search_hl.attr = HL_ATTR(HLF_L); 1723 # ifdef FEAT_RELTIME 1724 // Set the time limit to 'redrawtime'. 1725 profile_setlimit(p_rdt, &screen_search_hl.tm); 1726 # endif 1727 } 1728 } 1729 1730 /* 1731 * Clean up for 'hlsearch' highlighting. 1732 */ 1733 void 1734 end_search_hl(void) 1735 { 1736 if (screen_search_hl.rm.regprog != NULL) 1737 { 1738 vim_regfree(screen_search_hl.rm.regprog); 1739 screen_search_hl.rm.regprog = NULL; 1740 } 1741 } 1742 #endif 1743 1744 static void 1745 screen_start_highlight(int attr) 1746 { 1747 attrentry_T *aep = NULL; 1748 1749 screen_attr = attr; 1750 if (full_screen 1751 #ifdef MSWIN 1752 && termcap_active 1753 #endif 1754 ) 1755 { 1756 #ifdef FEAT_GUI 1757 if (gui.in_use) 1758 { 1759 char buf[20]; 1760 1761 // The GUI handles this internally. 1762 sprintf(buf, IF_EB("\033|%dh", ESC_STR "|%dh"), attr); 1763 OUT_STR(buf); 1764 } 1765 else 1766 #endif 1767 { 1768 if (attr > HL_ALL) // special HL attr. 1769 { 1770 if (IS_CTERM) 1771 aep = syn_cterm_attr2entry(attr); 1772 else 1773 aep = syn_term_attr2entry(attr); 1774 if (aep == NULL) // did ":syntax clear" 1775 attr = 0; 1776 else 1777 attr = aep->ae_attr; 1778 } 1779 #if defined(FEAT_VTP) && defined(FEAT_TERMGUICOLORS) 1780 if (use_vtp()) 1781 { 1782 guicolor_T defguifg, defguibg; 1783 int defctermfg, defctermbg; 1784 1785 // If FG and BG are unset, the color is undefined when 1786 // BOLD+INVERSE. Use Normal as the default value. 1787 get_default_console_color(&defctermfg, &defctermbg, &defguifg, 1788 &defguibg); 1789 1790 if (p_tgc) 1791 { 1792 if (aep == NULL || COLOR_INVALID(aep->ae_u.cterm.fg_rgb)) 1793 term_fg_rgb_color(defguifg); 1794 if (aep == NULL || COLOR_INVALID(aep->ae_u.cterm.bg_rgb)) 1795 term_bg_rgb_color(defguibg); 1796 } 1797 else if (t_colors >= 256) 1798 { 1799 if (aep == NULL || aep->ae_u.cterm.fg_color == 0) 1800 term_fg_color(defctermfg); 1801 if (aep == NULL || aep->ae_u.cterm.bg_color == 0) 1802 term_bg_color(defctermbg); 1803 } 1804 } 1805 #endif 1806 if ((attr & HL_BOLD) && *T_MD != NUL) // bold 1807 out_str(T_MD); 1808 else if (aep != NULL && cterm_normal_fg_bold && ( 1809 #ifdef FEAT_TERMGUICOLORS 1810 p_tgc && aep->ae_u.cterm.fg_rgb != CTERMCOLOR 1811 ? aep->ae_u.cterm.fg_rgb != INVALCOLOR 1812 : 1813 #endif 1814 t_colors > 1 && aep->ae_u.cterm.fg_color)) 1815 // If the Normal FG color has BOLD attribute and the new HL 1816 // has a FG color defined, clear BOLD. 1817 out_str(T_ME); 1818 if ((attr & HL_STANDOUT) && *T_SO != NUL) // standout 1819 out_str(T_SO); 1820 if ((attr & HL_UNDERCURL) && *T_UCS != NUL) // undercurl 1821 out_str(T_UCS); 1822 if (((attr & HL_UNDERLINE) // underline or undercurl 1823 || ((attr & HL_UNDERCURL) && *T_UCS == NUL)) 1824 && *T_US != NUL) 1825 out_str(T_US); 1826 if ((attr & HL_ITALIC) && *T_CZH != NUL) // italic 1827 out_str(T_CZH); 1828 if ((attr & HL_INVERSE) && *T_MR != NUL) // inverse (reverse) 1829 out_str(T_MR); 1830 if ((attr & HL_STRIKETHROUGH) && *T_STS != NUL) // strike 1831 out_str(T_STS); 1832 1833 /* 1834 * Output the color or start string after bold etc., in case the 1835 * bold etc. override the color setting. 1836 */ 1837 if (aep != NULL) 1838 { 1839 #ifdef FEAT_TERMGUICOLORS 1840 // When 'termguicolors' is set but fg or bg is unset, 1841 // fall back to the cterm colors. This helps for SpellBad, 1842 // where the GUI uses a red undercurl. 1843 if (p_tgc && aep->ae_u.cterm.fg_rgb != CTERMCOLOR) 1844 { 1845 if (aep->ae_u.cterm.fg_rgb != INVALCOLOR) 1846 term_fg_rgb_color(aep->ae_u.cterm.fg_rgb); 1847 } 1848 else 1849 #endif 1850 if (t_colors > 1) 1851 { 1852 if (aep->ae_u.cterm.fg_color) 1853 term_fg_color(aep->ae_u.cterm.fg_color - 1); 1854 } 1855 #ifdef FEAT_TERMGUICOLORS 1856 if (p_tgc && aep->ae_u.cterm.bg_rgb != CTERMCOLOR) 1857 { 1858 if (aep->ae_u.cterm.bg_rgb != INVALCOLOR) 1859 term_bg_rgb_color(aep->ae_u.cterm.bg_rgb); 1860 } 1861 else 1862 #endif 1863 if (t_colors > 1) 1864 { 1865 if (aep->ae_u.cterm.bg_color) 1866 term_bg_color(aep->ae_u.cterm.bg_color - 1); 1867 } 1868 1869 if (!IS_CTERM) 1870 { 1871 if (aep->ae_u.term.start != NULL) 1872 out_str(aep->ae_u.term.start); 1873 } 1874 } 1875 } 1876 } 1877 } 1878 1879 void 1880 screen_stop_highlight(void) 1881 { 1882 int do_ME = FALSE; // output T_ME code 1883 1884 if (screen_attr != 0 1885 #ifdef MSWIN 1886 && termcap_active 1887 #endif 1888 ) 1889 { 1890 #ifdef FEAT_GUI 1891 if (gui.in_use) 1892 { 1893 char buf[20]; 1894 1895 // use internal GUI code 1896 sprintf(buf, IF_EB("\033|%dH", ESC_STR "|%dH"), screen_attr); 1897 OUT_STR(buf); 1898 } 1899 else 1900 #endif 1901 { 1902 if (screen_attr > HL_ALL) // special HL attr. 1903 { 1904 attrentry_T *aep; 1905 1906 if (IS_CTERM) 1907 { 1908 /* 1909 * Assume that t_me restores the original colors! 1910 */ 1911 aep = syn_cterm_attr2entry(screen_attr); 1912 if (aep != NULL && (( 1913 #ifdef FEAT_TERMGUICOLORS 1914 p_tgc && aep->ae_u.cterm.fg_rgb != CTERMCOLOR 1915 ? aep->ae_u.cterm.fg_rgb != INVALCOLOR 1916 : 1917 #endif 1918 aep->ae_u.cterm.fg_color) || ( 1919 #ifdef FEAT_TERMGUICOLORS 1920 p_tgc && aep->ae_u.cterm.bg_rgb != CTERMCOLOR 1921 ? aep->ae_u.cterm.bg_rgb != INVALCOLOR 1922 : 1923 #endif 1924 aep->ae_u.cterm.bg_color))) 1925 do_ME = TRUE; 1926 } 1927 else 1928 { 1929 aep = syn_term_attr2entry(screen_attr); 1930 if (aep != NULL && aep->ae_u.term.stop != NULL) 1931 { 1932 if (STRCMP(aep->ae_u.term.stop, T_ME) == 0) 1933 do_ME = TRUE; 1934 else 1935 out_str(aep->ae_u.term.stop); 1936 } 1937 } 1938 if (aep == NULL) // did ":syntax clear" 1939 screen_attr = 0; 1940 else 1941 screen_attr = aep->ae_attr; 1942 } 1943 1944 /* 1945 * Often all ending-codes are equal to T_ME. Avoid outputting the 1946 * same sequence several times. 1947 */ 1948 if (screen_attr & HL_STANDOUT) 1949 { 1950 if (STRCMP(T_SE, T_ME) == 0) 1951 do_ME = TRUE; 1952 else 1953 out_str(T_SE); 1954 } 1955 if ((screen_attr & HL_UNDERCURL) && *T_UCE != NUL) 1956 { 1957 if (STRCMP(T_UCE, T_ME) == 0) 1958 do_ME = TRUE; 1959 else 1960 out_str(T_UCE); 1961 } 1962 if ((screen_attr & HL_UNDERLINE) 1963 || ((screen_attr & HL_UNDERCURL) && *T_UCE == NUL)) 1964 { 1965 if (STRCMP(T_UE, T_ME) == 0) 1966 do_ME = TRUE; 1967 else 1968 out_str(T_UE); 1969 } 1970 if (screen_attr & HL_ITALIC) 1971 { 1972 if (STRCMP(T_CZR, T_ME) == 0) 1973 do_ME = TRUE; 1974 else 1975 out_str(T_CZR); 1976 } 1977 if (screen_attr & HL_STRIKETHROUGH) 1978 { 1979 if (STRCMP(T_STE, T_ME) == 0) 1980 do_ME = TRUE; 1981 else 1982 out_str(T_STE); 1983 } 1984 if (do_ME || (screen_attr & (HL_BOLD | HL_INVERSE))) 1985 out_str(T_ME); 1986 1987 #ifdef FEAT_TERMGUICOLORS 1988 if (p_tgc) 1989 { 1990 if (cterm_normal_fg_gui_color != INVALCOLOR) 1991 term_fg_rgb_color(cterm_normal_fg_gui_color); 1992 if (cterm_normal_bg_gui_color != INVALCOLOR) 1993 term_bg_rgb_color(cterm_normal_bg_gui_color); 1994 } 1995 else 1996 #endif 1997 { 1998 if (t_colors > 1) 1999 { 2000 // set Normal cterm colors 2001 if (cterm_normal_fg_color != 0) 2002 term_fg_color(cterm_normal_fg_color - 1); 2003 if (cterm_normal_bg_color != 0) 2004 term_bg_color(cterm_normal_bg_color - 1); 2005 if (cterm_normal_fg_bold) 2006 out_str(T_MD); 2007 } 2008 } 2009 } 2010 } 2011 screen_attr = 0; 2012 } 2013 2014 /* 2015 * Reset the colors for a cterm. Used when leaving Vim. 2016 * The machine specific code may override this again. 2017 */ 2018 void 2019 reset_cterm_colors(void) 2020 { 2021 if (IS_CTERM) 2022 { 2023 // set Normal cterm colors 2024 #ifdef FEAT_TERMGUICOLORS 2025 if (p_tgc ? (cterm_normal_fg_gui_color != INVALCOLOR 2026 || cterm_normal_bg_gui_color != INVALCOLOR) 2027 : (cterm_normal_fg_color > 0 || cterm_normal_bg_color > 0)) 2028 #else 2029 if (cterm_normal_fg_color > 0 || cterm_normal_bg_color > 0) 2030 #endif 2031 { 2032 out_str(T_OP); 2033 screen_attr = -1; 2034 } 2035 if (cterm_normal_fg_bold) 2036 { 2037 out_str(T_ME); 2038 screen_attr = -1; 2039 } 2040 } 2041 } 2042 2043 /* 2044 * Put character ScreenLines["off"] on the screen at position "row" and "col", 2045 * using the attributes from ScreenAttrs["off"]. 2046 */ 2047 void 2048 screen_char(unsigned off, int row, int col) 2049 { 2050 int attr; 2051 2052 // Check for illegal values, just in case (could happen just after 2053 // resizing). 2054 if (row >= screen_Rows || col >= screen_Columns) 2055 return; 2056 2057 // Skip if under the popup menu. 2058 // Popup windows with zindex higher than POPUPMENU_ZINDEX go on top. 2059 if (pum_under_menu(row, col) 2060 #ifdef FEAT_PROP_POPUP 2061 && screen_zindex <= POPUPMENU_ZINDEX 2062 #endif 2063 ) 2064 return; 2065 #ifdef FEAT_PROP_POPUP 2066 if (blocked_by_popup(row, col)) 2067 return; 2068 #endif 2069 2070 // Outputting a character in the last cell on the screen may scroll the 2071 // screen up. Only do it when the "xn" termcap property is set, otherwise 2072 // mark the character invalid (update it when scrolled up). 2073 if (*T_XN == NUL 2074 && row == screen_Rows - 1 && col == screen_Columns - 1 2075 #ifdef FEAT_RIGHTLEFT 2076 // account for first command-line character in rightleft mode 2077 && !cmdmsg_rl 2078 #endif 2079 ) 2080 { 2081 ScreenAttrs[off] = (sattr_T)-1; 2082 return; 2083 } 2084 2085 /* 2086 * Stop highlighting first, so it's easier to move the cursor. 2087 */ 2088 if (screen_char_attr != 0) 2089 attr = screen_char_attr; 2090 else 2091 attr = ScreenAttrs[off]; 2092 if (screen_attr != attr) 2093 screen_stop_highlight(); 2094 2095 windgoto(row, col); 2096 2097 if (screen_attr != attr) 2098 screen_start_highlight(attr); 2099 2100 if (enc_utf8 && ScreenLinesUC[off] != 0) 2101 { 2102 char_u buf[MB_MAXBYTES + 1]; 2103 2104 if (utf_ambiguous_width(ScreenLinesUC[off])) 2105 { 2106 if (*p_ambw == 'd' 2107 #ifdef FEAT_GUI 2108 && !gui.in_use 2109 #endif 2110 ) 2111 { 2112 // Clear the two screen cells. If the character is actually 2113 // single width it won't change the second cell. 2114 out_str((char_u *)" "); 2115 term_windgoto(row, col); 2116 } 2117 // not sure where the cursor is after drawing the ambiguous width 2118 // character 2119 screen_cur_col = 9999; 2120 } 2121 else if (utf_char2cells(ScreenLinesUC[off]) > 1) 2122 ++screen_cur_col; 2123 2124 // Convert the UTF-8 character to bytes and write it. 2125 buf[utfc_char2bytes(off, buf)] = NUL; 2126 out_str(buf); 2127 } 2128 else 2129 { 2130 out_flush_check(); 2131 out_char(ScreenLines[off]); 2132 // double-byte character in single-width cell 2133 if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e) 2134 out_char(ScreenLines2[off]); 2135 } 2136 2137 screen_cur_col++; 2138 } 2139 2140 /* 2141 * Used for enc_dbcs only: Put one double-wide character at ScreenLines["off"] 2142 * on the screen at position 'row' and 'col'. 2143 * The attributes of the first byte is used for all. This is required to 2144 * output the two bytes of a double-byte character with nothing in between. 2145 */ 2146 static void 2147 screen_char_2(unsigned off, int row, int col) 2148 { 2149 // Check for illegal values (could be wrong when screen was resized). 2150 if (off + 1 >= (unsigned)(screen_Rows * screen_Columns)) 2151 return; 2152 2153 // Outputting the last character on the screen may scrollup the screen. 2154 // Don't to it! Mark the character invalid (update it when scrolled up) 2155 if (row == screen_Rows - 1 && col >= screen_Columns - 2) 2156 { 2157 ScreenAttrs[off] = (sattr_T)-1; 2158 return; 2159 } 2160 2161 // Output the first byte normally (positions the cursor), then write the 2162 // second byte directly. 2163 screen_char(off, row, col); 2164 out_char(ScreenLines[off + 1]); 2165 ++screen_cur_col; 2166 } 2167 2168 /* 2169 * Draw a rectangle of the screen, inverted when "invert" is TRUE. 2170 * This uses the contents of ScreenLines[] and doesn't change it. 2171 */ 2172 void 2173 screen_draw_rectangle( 2174 int row, 2175 int col, 2176 int height, 2177 int width, 2178 int invert) 2179 { 2180 int r, c; 2181 int off; 2182 int max_off; 2183 2184 // Can't use ScreenLines unless initialized 2185 if (ScreenLines == NULL) 2186 return; 2187 2188 if (invert) 2189 screen_char_attr = HL_INVERSE; 2190 for (r = row; r < row + height; ++r) 2191 { 2192 off = LineOffset[r]; 2193 max_off = off + screen_Columns; 2194 for (c = col; c < col + width; ++c) 2195 { 2196 if (enc_dbcs != 0 && dbcs_off2cells(off + c, max_off) > 1) 2197 { 2198 screen_char_2(off + c, r, c); 2199 ++c; 2200 } 2201 else 2202 { 2203 screen_char(off + c, r, c); 2204 if (utf_off2cells(off + c, max_off) > 1) 2205 ++c; 2206 } 2207 } 2208 } 2209 screen_char_attr = 0; 2210 } 2211 2212 /* 2213 * Redraw the characters for a vertically split window. 2214 */ 2215 static void 2216 redraw_block(int row, int end, win_T *wp) 2217 { 2218 int col; 2219 int width; 2220 2221 # ifdef FEAT_CLIPBOARD 2222 clip_may_clear_selection(row, end - 1); 2223 # endif 2224 2225 if (wp == NULL) 2226 { 2227 col = 0; 2228 width = Columns; 2229 } 2230 else 2231 { 2232 col = wp->w_wincol; 2233 width = wp->w_width; 2234 } 2235 screen_draw_rectangle(row, col, end - row, width, FALSE); 2236 } 2237 2238 void 2239 space_to_screenline(int off, int attr) 2240 { 2241 ScreenLines[off] = ' '; 2242 ScreenAttrs[off] = attr; 2243 if (enc_utf8) 2244 ScreenLinesUC[off] = 0; 2245 } 2246 2247 /* 2248 * Fill the screen from 'start_row' to 'end_row', from 'start_col' to 'end_col' 2249 * with character 'c1' in first column followed by 'c2' in the other columns. 2250 * Use attributes 'attr'. 2251 */ 2252 void 2253 screen_fill( 2254 int start_row, 2255 int end_row, 2256 int start_col, 2257 int end_col, 2258 int c1, 2259 int c2, 2260 int attr) 2261 { 2262 int row; 2263 int col; 2264 int off; 2265 int end_off; 2266 int did_delete; 2267 int c; 2268 int norm_term; 2269 #if defined(FEAT_GUI) || defined(UNIX) 2270 int force_next = FALSE; 2271 #endif 2272 2273 if (end_row > screen_Rows) // safety check 2274 end_row = screen_Rows; 2275 if (end_col > screen_Columns) // safety check 2276 end_col = screen_Columns; 2277 if (ScreenLines == NULL 2278 || start_row >= end_row 2279 || start_col >= end_col) // nothing to do 2280 return; 2281 2282 // it's a "normal" terminal when not in a GUI or cterm 2283 norm_term = ( 2284 #ifdef FEAT_GUI 2285 !gui.in_use && 2286 #endif 2287 !IS_CTERM); 2288 for (row = start_row; row < end_row; ++row) 2289 { 2290 if (has_mbyte 2291 #ifdef FEAT_GUI 2292 && !gui.in_use 2293 #endif 2294 ) 2295 { 2296 // When drawing over the right halve of a double-wide char clear 2297 // out the left halve. When drawing over the left halve of a 2298 // double wide-char clear out the right halve. Only needed in a 2299 // terminal. 2300 if (start_col > 0 && mb_fix_col(start_col, row) != start_col) 2301 screen_puts_len((char_u *)" ", 1, row, start_col - 1, 0); 2302 if (end_col < screen_Columns && mb_fix_col(end_col, row) != end_col) 2303 screen_puts_len((char_u *)" ", 1, row, end_col, 0); 2304 } 2305 /* 2306 * Try to use delete-line termcap code, when no attributes or in a 2307 * "normal" terminal, where a bold/italic space is just a 2308 * space. 2309 */ 2310 did_delete = FALSE; 2311 if (c2 == ' ' 2312 && end_col == Columns 2313 && can_clear(T_CE) 2314 && (attr == 0 2315 || (norm_term 2316 && attr <= HL_ALL 2317 && ((attr & ~(HL_BOLD | HL_ITALIC)) == 0)))) 2318 { 2319 /* 2320 * check if we really need to clear something 2321 */ 2322 col = start_col; 2323 if (c1 != ' ') // don't clear first char 2324 ++col; 2325 2326 off = LineOffset[row] + col; 2327 end_off = LineOffset[row] + end_col; 2328 2329 // skip blanks (used often, keep it fast!) 2330 if (enc_utf8) 2331 while (off < end_off && ScreenLines[off] == ' ' 2332 && ScreenAttrs[off] == 0 && ScreenLinesUC[off] == 0) 2333 ++off; 2334 else 2335 while (off < end_off && ScreenLines[off] == ' ' 2336 && ScreenAttrs[off] == 0) 2337 ++off; 2338 if (off < end_off) // something to be cleared 2339 { 2340 col = off - LineOffset[row]; 2341 screen_stop_highlight(); 2342 term_windgoto(row, col);// clear rest of this screen line 2343 out_str(T_CE); 2344 screen_start(); // don't know where cursor is now 2345 col = end_col - col; 2346 while (col--) // clear chars in ScreenLines 2347 { 2348 space_to_screenline(off, 0); 2349 ++off; 2350 } 2351 } 2352 did_delete = TRUE; // the chars are cleared now 2353 } 2354 2355 off = LineOffset[row] + start_col; 2356 c = c1; 2357 for (col = start_col; col < end_col; ++col) 2358 { 2359 if ((ScreenLines[off] != c 2360 || (enc_utf8 && (int)ScreenLinesUC[off] 2361 != (c >= 0x80 ? c : 0)) 2362 || ScreenAttrs[off] != attr 2363 #if defined(FEAT_GUI) || defined(UNIX) 2364 || force_next 2365 #endif 2366 ) 2367 #ifdef FEAT_PROP_POPUP 2368 // Skip if under a(nother) popup. 2369 && !blocked_by_popup(row, col) 2370 #endif 2371 ) 2372 { 2373 #if defined(FEAT_GUI) || defined(UNIX) 2374 // The bold trick may make a single row of pixels appear in 2375 // the next character. When a bold character is removed, the 2376 // next character should be redrawn too. This happens for our 2377 // own GUI and for some xterms. 2378 if ( 2379 # ifdef FEAT_GUI 2380 gui.in_use 2381 # endif 2382 # if defined(FEAT_GUI) && defined(UNIX) 2383 || 2384 # endif 2385 # ifdef UNIX 2386 term_is_xterm 2387 # endif 2388 ) 2389 { 2390 if (ScreenLines[off] != ' ' 2391 && (ScreenAttrs[off] > HL_ALL 2392 || ScreenAttrs[off] & HL_BOLD)) 2393 force_next = TRUE; 2394 else 2395 force_next = FALSE; 2396 } 2397 #endif 2398 ScreenLines[off] = c; 2399 if (enc_utf8) 2400 { 2401 if (c >= 0x80) 2402 { 2403 ScreenLinesUC[off] = c; 2404 ScreenLinesC[0][off] = 0; 2405 } 2406 else 2407 ScreenLinesUC[off] = 0; 2408 } 2409 ScreenAttrs[off] = attr; 2410 if (!did_delete || c != ' ') 2411 screen_char(off, row, col); 2412 } 2413 ++off; 2414 if (col == start_col) 2415 { 2416 if (did_delete) 2417 break; 2418 c = c2; 2419 } 2420 } 2421 if (end_col == Columns) 2422 LineWraps[row] = FALSE; 2423 if (row == Rows - 1) // overwritten the command line 2424 { 2425 redraw_cmdline = TRUE; 2426 if (start_col == 0 && end_col == Columns 2427 && c1 == ' ' && c2 == ' ' && attr == 0) 2428 clear_cmdline = FALSE; // command line has been cleared 2429 if (start_col == 0) 2430 mode_displayed = FALSE; // mode cleared or overwritten 2431 } 2432 } 2433 } 2434 2435 /* 2436 * Check if there should be a delay. Used before clearing or redrawing the 2437 * screen or the command line. 2438 */ 2439 void 2440 check_for_delay(int check_msg_scroll) 2441 { 2442 if ((emsg_on_display || (check_msg_scroll && msg_scroll)) 2443 && !did_wait_return 2444 && emsg_silent == 0) 2445 { 2446 out_flush(); 2447 ui_delay(1006L, TRUE); 2448 emsg_on_display = FALSE; 2449 if (check_msg_scroll) 2450 msg_scroll = FALSE; 2451 } 2452 } 2453 2454 /* 2455 * Init TabPageIdxs[] to zero: Clicking outside of tabs has no effect. 2456 */ 2457 static void 2458 clear_TabPageIdxs(void) 2459 { 2460 int scol; 2461 2462 for (scol = 0; scol < Columns; ++scol) 2463 TabPageIdxs[scol] = 0; 2464 } 2465 2466 /* 2467 * screen_valid - allocate screen buffers if size changed 2468 * If "doclear" is TRUE: clear screen if it has been resized. 2469 * Returns TRUE if there is a valid screen to write to. 2470 * Returns FALSE when starting up and screen not initialized yet. 2471 */ 2472 int 2473 screen_valid(int doclear) 2474 { 2475 screenalloc(doclear); // allocate screen buffers if size changed 2476 return (ScreenLines != NULL); 2477 } 2478 2479 /* 2480 * Resize the shell to Rows and Columns. 2481 * Allocate ScreenLines[] and associated items. 2482 * 2483 * There may be some time between setting Rows and Columns and (re)allocating 2484 * ScreenLines[]. This happens when starting up and when (manually) changing 2485 * the shell size. Always use screen_Rows and screen_Columns to access items 2486 * in ScreenLines[]. Use Rows and Columns for positioning text etc. where the 2487 * final size of the shell is needed. 2488 */ 2489 void 2490 screenalloc(int doclear) 2491 { 2492 int new_row, old_row; 2493 #ifdef FEAT_GUI 2494 int old_Rows; 2495 #endif 2496 win_T *wp; 2497 int outofmem = FALSE; 2498 int len; 2499 schar_T *new_ScreenLines; 2500 u8char_T *new_ScreenLinesUC = NULL; 2501 u8char_T *new_ScreenLinesC[MAX_MCO]; 2502 schar_T *new_ScreenLines2 = NULL; 2503 int i; 2504 sattr_T *new_ScreenAttrs; 2505 unsigned *new_LineOffset; 2506 char_u *new_LineWraps; 2507 short *new_TabPageIdxs; 2508 #ifdef FEAT_PROP_POPUP 2509 short *new_popup_mask; 2510 short *new_popup_mask_next; 2511 char *new_popup_transparent; 2512 #endif 2513 tabpage_T *tp; 2514 static int entered = FALSE; // avoid recursiveness 2515 static int done_outofmem_msg = FALSE; // did outofmem message 2516 int retry_count = 0; 2517 2518 retry: 2519 /* 2520 * Allocation of the screen buffers is done only when the size changes and 2521 * when Rows and Columns have been set and we have started doing full 2522 * screen stuff. 2523 */ 2524 if ((ScreenLines != NULL 2525 && Rows == screen_Rows 2526 && Columns == screen_Columns 2527 && enc_utf8 == (ScreenLinesUC != NULL) 2528 && (enc_dbcs == DBCS_JPNU) == (ScreenLines2 != NULL) 2529 && p_mco == Screen_mco) 2530 || Rows == 0 2531 || Columns == 0 2532 || (!full_screen && ScreenLines == NULL)) 2533 return; 2534 2535 /* 2536 * It's possible that we produce an out-of-memory message below, which 2537 * will cause this function to be called again. To break the loop, just 2538 * return here. 2539 */ 2540 if (entered) 2541 return; 2542 entered = TRUE; 2543 2544 /* 2545 * Note that the window sizes are updated before reallocating the arrays, 2546 * thus we must not redraw here! 2547 */ 2548 ++RedrawingDisabled; 2549 2550 win_new_shellsize(); // fit the windows in the new sized shell 2551 2552 #ifdef FEAT_GUI_HAIKU 2553 vim_lock_screen(); // be safe, put it here 2554 #endif 2555 2556 comp_col(); // recompute columns for shown command and ruler 2557 2558 /* 2559 * We're changing the size of the screen. 2560 * - Allocate new arrays for ScreenLines and ScreenAttrs. 2561 * - Move lines from the old arrays into the new arrays, clear extra 2562 * lines (unless the screen is going to be cleared). 2563 * - Free the old arrays. 2564 * 2565 * If anything fails, make ScreenLines NULL, so we don't do anything! 2566 * Continuing with the old ScreenLines may result in a crash, because the 2567 * size is wrong. 2568 */ 2569 FOR_ALL_TAB_WINDOWS(tp, wp) 2570 win_free_lsize(wp); 2571 if (aucmd_win != NULL) 2572 win_free_lsize(aucmd_win); 2573 #ifdef FEAT_PROP_POPUP 2574 // global popup windows 2575 FOR_ALL_POPUPWINS(wp) 2576 win_free_lsize(wp); 2577 // tab-local popup windows 2578 FOR_ALL_TABPAGES(tp) 2579 FOR_ALL_POPUPWINS_IN_TAB(tp, wp) 2580 win_free_lsize(wp); 2581 #endif 2582 2583 new_ScreenLines = LALLOC_MULT(schar_T, (Rows + 1) * Columns); 2584 vim_memset(new_ScreenLinesC, 0, sizeof(u8char_T *) * MAX_MCO); 2585 if (enc_utf8) 2586 { 2587 new_ScreenLinesUC = LALLOC_MULT(u8char_T, (Rows + 1) * Columns); 2588 for (i = 0; i < p_mco; ++i) 2589 new_ScreenLinesC[i] = LALLOC_CLEAR_MULT(u8char_T, 2590 (Rows + 1) * Columns); 2591 } 2592 if (enc_dbcs == DBCS_JPNU) 2593 new_ScreenLines2 = LALLOC_MULT(schar_T, (Rows + 1) * Columns); 2594 new_ScreenAttrs = LALLOC_MULT(sattr_T, (Rows + 1) * Columns); 2595 new_LineOffset = LALLOC_MULT(unsigned, Rows); 2596 new_LineWraps = LALLOC_MULT(char_u, Rows); 2597 new_TabPageIdxs = LALLOC_MULT(short, Columns); 2598 #ifdef FEAT_PROP_POPUP 2599 new_popup_mask = LALLOC_MULT(short, Rows * Columns); 2600 new_popup_mask_next = LALLOC_MULT(short, Rows * Columns); 2601 new_popup_transparent = LALLOC_MULT(char, Rows * Columns); 2602 #endif 2603 2604 FOR_ALL_TAB_WINDOWS(tp, wp) 2605 { 2606 if (win_alloc_lines(wp) == FAIL) 2607 { 2608 outofmem = TRUE; 2609 goto give_up; 2610 } 2611 } 2612 if (aucmd_win != NULL && aucmd_win->w_lines == NULL 2613 && win_alloc_lines(aucmd_win) == FAIL) 2614 outofmem = TRUE; 2615 #ifdef FEAT_PROP_POPUP 2616 // global popup windows 2617 FOR_ALL_POPUPWINS(wp) 2618 if (win_alloc_lines(wp) == FAIL) 2619 { 2620 outofmem = TRUE; 2621 goto give_up; 2622 } 2623 // tab-local popup windows 2624 FOR_ALL_TABPAGES(tp) 2625 FOR_ALL_POPUPWINS_IN_TAB(tp, wp) 2626 if (win_alloc_lines(wp) == FAIL) 2627 { 2628 outofmem = TRUE; 2629 goto give_up; 2630 } 2631 #endif 2632 2633 give_up: 2634 2635 for (i = 0; i < p_mco; ++i) 2636 if (new_ScreenLinesC[i] == NULL) 2637 break; 2638 if (new_ScreenLines == NULL 2639 || (enc_utf8 && (new_ScreenLinesUC == NULL || i != p_mco)) 2640 || (enc_dbcs == DBCS_JPNU && new_ScreenLines2 == NULL) 2641 || new_ScreenAttrs == NULL 2642 || new_LineOffset == NULL 2643 || new_LineWraps == NULL 2644 || new_TabPageIdxs == NULL 2645 #ifdef FEAT_PROP_POPUP 2646 || new_popup_mask == NULL 2647 || new_popup_mask_next == NULL 2648 || new_popup_transparent == NULL 2649 #endif 2650 || outofmem) 2651 { 2652 if (ScreenLines != NULL || !done_outofmem_msg) 2653 { 2654 // guess the size 2655 do_outofmem_msg((long_u)((Rows + 1) * Columns)); 2656 2657 // Remember we did this to avoid getting outofmem messages over 2658 // and over again. 2659 done_outofmem_msg = TRUE; 2660 } 2661 VIM_CLEAR(new_ScreenLines); 2662 VIM_CLEAR(new_ScreenLinesUC); 2663 for (i = 0; i < p_mco; ++i) 2664 VIM_CLEAR(new_ScreenLinesC[i]); 2665 VIM_CLEAR(new_ScreenLines2); 2666 VIM_CLEAR(new_ScreenAttrs); 2667 VIM_CLEAR(new_LineOffset); 2668 VIM_CLEAR(new_LineWraps); 2669 VIM_CLEAR(new_TabPageIdxs); 2670 #ifdef FEAT_PROP_POPUP 2671 VIM_CLEAR(new_popup_mask); 2672 VIM_CLEAR(new_popup_mask_next); 2673 VIM_CLEAR(new_popup_transparent); 2674 #endif 2675 } 2676 else 2677 { 2678 done_outofmem_msg = FALSE; 2679 2680 for (new_row = 0; new_row < Rows; ++new_row) 2681 { 2682 new_LineOffset[new_row] = new_row * Columns; 2683 new_LineWraps[new_row] = FALSE; 2684 2685 /* 2686 * If the screen is not going to be cleared, copy as much as 2687 * possible from the old screen to the new one and clear the rest 2688 * (used when resizing the window at the "--more--" prompt or when 2689 * executing an external command, for the GUI). 2690 */ 2691 if (!doclear) 2692 { 2693 (void)vim_memset(new_ScreenLines + new_row * Columns, 2694 ' ', (size_t)Columns * sizeof(schar_T)); 2695 if (enc_utf8) 2696 { 2697 (void)vim_memset(new_ScreenLinesUC + new_row * Columns, 2698 0, (size_t)Columns * sizeof(u8char_T)); 2699 for (i = 0; i < p_mco; ++i) 2700 (void)vim_memset(new_ScreenLinesC[i] 2701 + new_row * Columns, 2702 0, (size_t)Columns * sizeof(u8char_T)); 2703 } 2704 if (enc_dbcs == DBCS_JPNU) 2705 (void)vim_memset(new_ScreenLines2 + new_row * Columns, 2706 0, (size_t)Columns * sizeof(schar_T)); 2707 (void)vim_memset(new_ScreenAttrs + new_row * Columns, 2708 0, (size_t)Columns * sizeof(sattr_T)); 2709 old_row = new_row + (screen_Rows - Rows); 2710 if (old_row >= 0 && ScreenLines != NULL) 2711 { 2712 if (screen_Columns < Columns) 2713 len = screen_Columns; 2714 else 2715 len = Columns; 2716 // When switching to utf-8 don't copy characters, they 2717 // may be invalid now. Also when p_mco changes. 2718 if (!(enc_utf8 && ScreenLinesUC == NULL) 2719 && p_mco == Screen_mco) 2720 mch_memmove(new_ScreenLines + new_LineOffset[new_row], 2721 ScreenLines + LineOffset[old_row], 2722 (size_t)len * sizeof(schar_T)); 2723 if (enc_utf8 && ScreenLinesUC != NULL 2724 && p_mco == Screen_mco) 2725 { 2726 mch_memmove(new_ScreenLinesUC + new_LineOffset[new_row], 2727 ScreenLinesUC + LineOffset[old_row], 2728 (size_t)len * sizeof(u8char_T)); 2729 for (i = 0; i < p_mco; ++i) 2730 mch_memmove(new_ScreenLinesC[i] 2731 + new_LineOffset[new_row], 2732 ScreenLinesC[i] + LineOffset[old_row], 2733 (size_t)len * sizeof(u8char_T)); 2734 } 2735 if (enc_dbcs == DBCS_JPNU && ScreenLines2 != NULL) 2736 mch_memmove(new_ScreenLines2 + new_LineOffset[new_row], 2737 ScreenLines2 + LineOffset[old_row], 2738 (size_t)len * sizeof(schar_T)); 2739 mch_memmove(new_ScreenAttrs + new_LineOffset[new_row], 2740 ScreenAttrs + LineOffset[old_row], 2741 (size_t)len * sizeof(sattr_T)); 2742 } 2743 } 2744 } 2745 // Use the last line of the screen for the current line. 2746 current_ScreenLine = new_ScreenLines + Rows * Columns; 2747 2748 #ifdef FEAT_PROP_POPUP 2749 vim_memset(new_popup_mask, 0, Rows * Columns * sizeof(short)); 2750 vim_memset(new_popup_transparent, 0, Rows * Columns * sizeof(char)); 2751 #endif 2752 } 2753 2754 free_screenlines(); 2755 2756 // NOTE: this may result in all pointers to become NULL. 2757 ScreenLines = new_ScreenLines; 2758 ScreenLinesUC = new_ScreenLinesUC; 2759 for (i = 0; i < p_mco; ++i) 2760 ScreenLinesC[i] = new_ScreenLinesC[i]; 2761 Screen_mco = p_mco; 2762 ScreenLines2 = new_ScreenLines2; 2763 ScreenAttrs = new_ScreenAttrs; 2764 LineOffset = new_LineOffset; 2765 LineWraps = new_LineWraps; 2766 TabPageIdxs = new_TabPageIdxs; 2767 #ifdef FEAT_PROP_POPUP 2768 popup_mask = new_popup_mask; 2769 popup_mask_next = new_popup_mask_next; 2770 popup_transparent = new_popup_transparent; 2771 popup_mask_refresh = TRUE; 2772 #endif 2773 2774 // It's important that screen_Rows and screen_Columns reflect the actual 2775 // size of ScreenLines[]. Set them before calling anything. 2776 #ifdef FEAT_GUI 2777 old_Rows = screen_Rows; 2778 #endif 2779 screen_Rows = Rows; 2780 screen_Columns = Columns; 2781 2782 must_redraw = CLEAR; // need to clear the screen later 2783 if (doclear) 2784 screenclear2(); 2785 #ifdef FEAT_GUI 2786 else if (gui.in_use 2787 && !gui.starting 2788 && ScreenLines != NULL 2789 && old_Rows != Rows) 2790 { 2791 gui_redraw_block(0, 0, (int)Rows - 1, (int)Columns - 1, 0); 2792 2793 // Adjust the position of the cursor, for when executing an external 2794 // command. 2795 if (msg_row >= Rows) // Rows got smaller 2796 msg_row = Rows - 1; // put cursor at last row 2797 else if (Rows > old_Rows) // Rows got bigger 2798 msg_row += Rows - old_Rows; // put cursor in same place 2799 if (msg_col >= Columns) // Columns got smaller 2800 msg_col = Columns - 1; // put cursor at last column 2801 } 2802 #endif 2803 clear_TabPageIdxs(); 2804 2805 #ifdef FEAT_GUI_HAIKU 2806 vim_unlock_screen(); 2807 #endif 2808 2809 entered = FALSE; 2810 --RedrawingDisabled; 2811 2812 /* 2813 * Do not apply autocommands more than 3 times to avoid an endless loop 2814 * in case applying autocommands always changes Rows or Columns. 2815 */ 2816 if (starting == 0 && ++retry_count <= 3) 2817 { 2818 apply_autocmds(EVENT_VIMRESIZED, NULL, NULL, FALSE, curbuf); 2819 // In rare cases, autocommands may have altered Rows or Columns, 2820 // jump back to check if we need to allocate the screen again. 2821 goto retry; 2822 } 2823 } 2824 2825 void 2826 free_screenlines(void) 2827 { 2828 int i; 2829 2830 VIM_CLEAR(ScreenLinesUC); 2831 for (i = 0; i < Screen_mco; ++i) 2832 VIM_CLEAR(ScreenLinesC[i]); 2833 VIM_CLEAR(ScreenLines2); 2834 VIM_CLEAR(ScreenLines); 2835 VIM_CLEAR(ScreenAttrs); 2836 VIM_CLEAR(LineOffset); 2837 VIM_CLEAR(LineWraps); 2838 VIM_CLEAR(TabPageIdxs); 2839 #ifdef FEAT_PROP_POPUP 2840 VIM_CLEAR(popup_mask); 2841 VIM_CLEAR(popup_mask_next); 2842 VIM_CLEAR(popup_transparent); 2843 #endif 2844 } 2845 2846 void 2847 screenclear(void) 2848 { 2849 check_for_delay(FALSE); 2850 screenalloc(FALSE); // allocate screen buffers if size changed 2851 screenclear2(); // clear the screen 2852 } 2853 2854 static void 2855 screenclear2(void) 2856 { 2857 int i; 2858 2859 if (starting == NO_SCREEN || ScreenLines == NULL 2860 #ifdef FEAT_GUI 2861 || (gui.in_use && gui.starting) 2862 #endif 2863 ) 2864 return; 2865 2866 #ifdef FEAT_GUI 2867 if (!gui.in_use) 2868 #endif 2869 screen_attr = -1; // force setting the Normal colors 2870 screen_stop_highlight(); // don't want highlighting here 2871 2872 #ifdef FEAT_CLIPBOARD 2873 // disable selection without redrawing it 2874 clip_scroll_selection(9999); 2875 #endif 2876 2877 // blank out ScreenLines 2878 for (i = 0; i < Rows; ++i) 2879 { 2880 lineclear(LineOffset[i], (int)Columns, 0); 2881 LineWraps[i] = FALSE; 2882 } 2883 2884 if (can_clear(T_CL)) 2885 { 2886 out_str(T_CL); // clear the display 2887 clear_cmdline = FALSE; 2888 mode_displayed = FALSE; 2889 } 2890 else 2891 { 2892 // can't clear the screen, mark all chars with invalid attributes 2893 for (i = 0; i < Rows; ++i) 2894 lineinvalid(LineOffset[i], (int)Columns); 2895 clear_cmdline = TRUE; 2896 } 2897 2898 screen_cleared = TRUE; // can use contents of ScreenLines now 2899 2900 win_rest_invalid(firstwin); 2901 redraw_cmdline = TRUE; 2902 redraw_tabline = TRUE; 2903 if (must_redraw == CLEAR) // no need to clear again 2904 must_redraw = NOT_VALID; 2905 compute_cmdrow(); 2906 msg_row = cmdline_row; // put cursor on last line for messages 2907 msg_col = 0; 2908 screen_start(); // don't know where cursor is now 2909 msg_scrolled = 0; // can't scroll back 2910 msg_didany = FALSE; 2911 msg_didout = FALSE; 2912 } 2913 2914 /* 2915 * Clear one line in ScreenLines. 2916 */ 2917 static void 2918 lineclear(unsigned off, int width, int attr) 2919 { 2920 (void)vim_memset(ScreenLines + off, ' ', (size_t)width * sizeof(schar_T)); 2921 if (enc_utf8) 2922 (void)vim_memset(ScreenLinesUC + off, 0, 2923 (size_t)width * sizeof(u8char_T)); 2924 (void)vim_memset(ScreenAttrs + off, attr, (size_t)width * sizeof(sattr_T)); 2925 } 2926 2927 /* 2928 * Mark one line in ScreenLines invalid by setting the attributes to an 2929 * invalid value. 2930 */ 2931 static void 2932 lineinvalid(unsigned off, int width) 2933 { 2934 (void)vim_memset(ScreenAttrs + off, -1, (size_t)width * sizeof(sattr_T)); 2935 } 2936 2937 /* 2938 * Copy part of a Screenline for vertically split window "wp". 2939 */ 2940 static void 2941 linecopy(int to, int from, win_T *wp) 2942 { 2943 unsigned off_to = LineOffset[to] + wp->w_wincol; 2944 unsigned off_from = LineOffset[from] + wp->w_wincol; 2945 2946 mch_memmove(ScreenLines + off_to, ScreenLines + off_from, 2947 wp->w_width * sizeof(schar_T)); 2948 if (enc_utf8) 2949 { 2950 int i; 2951 2952 mch_memmove(ScreenLinesUC + off_to, ScreenLinesUC + off_from, 2953 wp->w_width * sizeof(u8char_T)); 2954 for (i = 0; i < p_mco; ++i) 2955 mch_memmove(ScreenLinesC[i] + off_to, ScreenLinesC[i] + off_from, 2956 wp->w_width * sizeof(u8char_T)); 2957 } 2958 if (enc_dbcs == DBCS_JPNU) 2959 mch_memmove(ScreenLines2 + off_to, ScreenLines2 + off_from, 2960 wp->w_width * sizeof(schar_T)); 2961 mch_memmove(ScreenAttrs + off_to, ScreenAttrs + off_from, 2962 wp->w_width * sizeof(sattr_T)); 2963 } 2964 2965 /* 2966 * Return TRUE if clearing with term string "p" would work. 2967 * It can't work when the string is empty or it won't set the right background. 2968 * Don't clear to end-of-line when there are popups, it may cause flicker. 2969 */ 2970 int 2971 can_clear(char_u *p) 2972 { 2973 return (*p != NUL && (t_colors <= 1 2974 #ifdef FEAT_GUI 2975 || gui.in_use 2976 #endif 2977 #ifdef FEAT_TERMGUICOLORS 2978 || (p_tgc && cterm_normal_bg_gui_color == INVALCOLOR) 2979 || (!p_tgc && cterm_normal_bg_color == 0) 2980 #else 2981 || cterm_normal_bg_color == 0 2982 #endif 2983 || *T_UT != NUL) 2984 #ifdef FEAT_PROP_POPUP 2985 && !(p == T_CE && popup_visible) 2986 #endif 2987 ); 2988 } 2989 2990 /* 2991 * Reset cursor position. Use whenever cursor was moved because of outputting 2992 * something directly to the screen (shell commands) or a terminal control 2993 * code. 2994 */ 2995 void 2996 screen_start(void) 2997 { 2998 screen_cur_row = screen_cur_col = 9999; 2999 } 3000 3001 /* 3002 * Move the cursor to position "row","col" in the screen. 3003 * This tries to find the most efficient way to move, minimizing the number of 3004 * characters sent to the terminal. 3005 */ 3006 void 3007 windgoto(int row, int col) 3008 { 3009 sattr_T *p; 3010 int i; 3011 int plan; 3012 int cost; 3013 int wouldbe_col; 3014 int noinvcurs; 3015 char_u *bs; 3016 int goto_cost; 3017 int attr; 3018 3019 #define GOTO_COST 7 // assume a term_windgoto() takes about 7 chars 3020 #define HIGHL_COST 5 // assume unhighlight takes 5 chars 3021 3022 #define PLAN_LE 1 3023 #define PLAN_CR 2 3024 #define PLAN_NL 3 3025 #define PLAN_WRITE 4 3026 // Can't use ScreenLines unless initialized 3027 if (ScreenLines == NULL) 3028 return; 3029 3030 if (col != screen_cur_col || row != screen_cur_row) 3031 { 3032 // Check for valid position. 3033 if (row < 0) // window without text lines? 3034 row = 0; 3035 if (row >= screen_Rows) 3036 row = screen_Rows - 1; 3037 if (col >= screen_Columns) 3038 col = screen_Columns - 1; 3039 3040 // check if no cursor movement is allowed in highlight mode 3041 if (screen_attr && *T_MS == NUL) 3042 noinvcurs = HIGHL_COST; 3043 else 3044 noinvcurs = 0; 3045 goto_cost = GOTO_COST + noinvcurs; 3046 3047 /* 3048 * Plan how to do the positioning: 3049 * 1. Use CR to move it to column 0, same row. 3050 * 2. Use T_LE to move it a few columns to the left. 3051 * 3. Use NL to move a few lines down, column 0. 3052 * 4. Move a few columns to the right with T_ND or by writing chars. 3053 * 3054 * Don't do this if the cursor went beyond the last column, the cursor 3055 * position is unknown then (some terminals wrap, some don't ) 3056 * 3057 * First check if the highlighting attributes allow us to write 3058 * characters to move the cursor to the right. 3059 */ 3060 if (row >= screen_cur_row && screen_cur_col < Columns) 3061 { 3062 /* 3063 * If the cursor is in the same row, bigger col, we can use CR 3064 * or T_LE. 3065 */ 3066 bs = NULL; // init for GCC 3067 attr = screen_attr; 3068 if (row == screen_cur_row && col < screen_cur_col) 3069 { 3070 // "le" is preferred over "bc", because "bc" is obsolete 3071 if (*T_LE) 3072 bs = T_LE; // "cursor left" 3073 else 3074 bs = T_BC; // "backspace character (old) 3075 if (*bs) 3076 cost = (screen_cur_col - col) * (int)STRLEN(bs); 3077 else 3078 cost = 999; 3079 if (col + 1 < cost) // using CR is less characters 3080 { 3081 plan = PLAN_CR; 3082 wouldbe_col = 0; 3083 cost = 1; // CR is just one character 3084 } 3085 else 3086 { 3087 plan = PLAN_LE; 3088 wouldbe_col = col; 3089 } 3090 if (noinvcurs) // will stop highlighting 3091 { 3092 cost += noinvcurs; 3093 attr = 0; 3094 } 3095 } 3096 3097 /* 3098 * If the cursor is above where we want to be, we can use CR LF. 3099 */ 3100 else if (row > screen_cur_row) 3101 { 3102 plan = PLAN_NL; 3103 wouldbe_col = 0; 3104 cost = (row - screen_cur_row) * 2; // CR LF 3105 if (noinvcurs) // will stop highlighting 3106 { 3107 cost += noinvcurs; 3108 attr = 0; 3109 } 3110 } 3111 3112 /* 3113 * If the cursor is in the same row, smaller col, just use write. 3114 */ 3115 else 3116 { 3117 plan = PLAN_WRITE; 3118 wouldbe_col = screen_cur_col; 3119 cost = 0; 3120 } 3121 3122 /* 3123 * Check if any characters that need to be written have the 3124 * correct attributes. Also avoid UTF-8 characters. 3125 */ 3126 i = col - wouldbe_col; 3127 if (i > 0) 3128 cost += i; 3129 if (cost < goto_cost && i > 0) 3130 { 3131 /* 3132 * Check if the attributes are correct without additionally 3133 * stopping highlighting. 3134 */ 3135 p = ScreenAttrs + LineOffset[row] + wouldbe_col; 3136 while (i && *p++ == attr) 3137 --i; 3138 if (i != 0) 3139 { 3140 /* 3141 * Try if it works when highlighting is stopped here. 3142 */ 3143 if (*--p == 0) 3144 { 3145 cost += noinvcurs; 3146 while (i && *p++ == 0) 3147 --i; 3148 } 3149 if (i != 0) 3150 cost = 999; // different attributes, don't do it 3151 } 3152 if (enc_utf8) 3153 { 3154 // Don't use an UTF-8 char for positioning, it's slow. 3155 for (i = wouldbe_col; i < col; ++i) 3156 if (ScreenLinesUC[LineOffset[row] + i] != 0) 3157 { 3158 cost = 999; 3159 break; 3160 } 3161 } 3162 } 3163 3164 /* 3165 * We can do it without term_windgoto()! 3166 */ 3167 if (cost < goto_cost) 3168 { 3169 if (plan == PLAN_LE) 3170 { 3171 if (noinvcurs) 3172 screen_stop_highlight(); 3173 while (screen_cur_col > col) 3174 { 3175 out_str(bs); 3176 --screen_cur_col; 3177 } 3178 } 3179 else if (plan == PLAN_CR) 3180 { 3181 if (noinvcurs) 3182 screen_stop_highlight(); 3183 out_char('\r'); 3184 screen_cur_col = 0; 3185 } 3186 else if (plan == PLAN_NL) 3187 { 3188 if (noinvcurs) 3189 screen_stop_highlight(); 3190 while (screen_cur_row < row) 3191 { 3192 out_char('\n'); 3193 ++screen_cur_row; 3194 } 3195 screen_cur_col = 0; 3196 } 3197 3198 i = col - screen_cur_col; 3199 if (i > 0) 3200 { 3201 /* 3202 * Use cursor-right if it's one character only. Avoids 3203 * removing a line of pixels from the last bold char, when 3204 * using the bold trick in the GUI. 3205 */ 3206 if (T_ND[0] != NUL && T_ND[1] == NUL) 3207 { 3208 while (i-- > 0) 3209 out_char(*T_ND); 3210 } 3211 else 3212 { 3213 int off; 3214 3215 off = LineOffset[row] + screen_cur_col; 3216 while (i-- > 0) 3217 { 3218 if (ScreenAttrs[off] != screen_attr) 3219 screen_stop_highlight(); 3220 out_flush_check(); 3221 out_char(ScreenLines[off]); 3222 if (enc_dbcs == DBCS_JPNU 3223 && ScreenLines[off] == 0x8e) 3224 out_char(ScreenLines2[off]); 3225 ++off; 3226 } 3227 } 3228 } 3229 } 3230 } 3231 else 3232 cost = 999; 3233 3234 if (cost >= goto_cost) 3235 { 3236 if (noinvcurs) 3237 screen_stop_highlight(); 3238 if (row == screen_cur_row && (col > screen_cur_col) 3239 && *T_CRI != NUL) 3240 term_cursor_right(col - screen_cur_col); 3241 else 3242 term_windgoto(row, col); 3243 } 3244 screen_cur_row = row; 3245 screen_cur_col = col; 3246 } 3247 } 3248 3249 /* 3250 * Set cursor to its position in the current window. 3251 */ 3252 void 3253 setcursor(void) 3254 { 3255 setcursor_mayforce(FALSE); 3256 } 3257 3258 /* 3259 * Set cursor to its position in the current window. 3260 * When "force" is TRUE also when not redrawing. 3261 */ 3262 void 3263 setcursor_mayforce(int force) 3264 { 3265 if (force || redrawing()) 3266 { 3267 validate_cursor(); 3268 windgoto(W_WINROW(curwin) + curwin->w_wrow, 3269 curwin->w_wincol + ( 3270 #ifdef FEAT_RIGHTLEFT 3271 // With 'rightleft' set and the cursor on a double-wide 3272 // character, position it on the leftmost column. 3273 curwin->w_p_rl ? ((int)curwin->w_width - curwin->w_wcol 3274 - ((has_mbyte 3275 && (*mb_ptr2cells)(ml_get_cursor()) == 2 3276 && vim_isprintc(gchar_cursor())) ? 2 : 1)) : 3277 #endif 3278 curwin->w_wcol)); 3279 } 3280 } 3281 3282 3283 /* 3284 * Insert 'line_count' lines at 'row' in window 'wp'. 3285 * If 'invalid' is TRUE the wp->w_lines[].wl_lnum is invalidated. 3286 * If 'mayclear' is TRUE the screen will be cleared if it is faster than 3287 * scrolling. 3288 * Returns FAIL if the lines are not inserted, OK for success. 3289 */ 3290 int 3291 win_ins_lines( 3292 win_T *wp, 3293 int row, 3294 int line_count, 3295 int invalid, 3296 int mayclear) 3297 { 3298 int did_delete; 3299 int nextrow; 3300 int lastrow; 3301 int retval; 3302 3303 if (invalid) 3304 wp->w_lines_valid = 0; 3305 3306 if (wp->w_height < 5) 3307 return FAIL; 3308 3309 if (line_count > wp->w_height - row) 3310 line_count = wp->w_height - row; 3311 3312 retval = win_do_lines(wp, row, line_count, mayclear, FALSE, 0); 3313 if (retval != MAYBE) 3314 return retval; 3315 3316 /* 3317 * If there is a next window or a status line, we first try to delete the 3318 * lines at the bottom to avoid messing what is after the window. 3319 * If this fails and there are following windows, don't do anything to 3320 * avoid messing up those windows, better just redraw. 3321 */ 3322 did_delete = FALSE; 3323 if (wp->w_next != NULL || wp->w_status_height) 3324 { 3325 if (screen_del_lines(0, W_WINROW(wp) + wp->w_height - line_count, 3326 line_count, (int)Rows, FALSE, 0, NULL) == OK) 3327 did_delete = TRUE; 3328 else if (wp->w_next) 3329 return FAIL; 3330 } 3331 /* 3332 * if no lines deleted, blank the lines that will end up below the window 3333 */ 3334 if (!did_delete) 3335 { 3336 wp->w_redr_status = TRUE; 3337 redraw_cmdline = TRUE; 3338 nextrow = W_WINROW(wp) + wp->w_height + wp->w_status_height; 3339 lastrow = nextrow + line_count; 3340 if (lastrow > Rows) 3341 lastrow = Rows; 3342 screen_fill(nextrow - line_count, lastrow - line_count, 3343 wp->w_wincol, (int)W_ENDCOL(wp), 3344 ' ', ' ', 0); 3345 } 3346 3347 if (screen_ins_lines(0, W_WINROW(wp) + row, line_count, (int)Rows, 0, NULL) 3348 == FAIL) 3349 { 3350 // deletion will have messed up other windows 3351 if (did_delete) 3352 { 3353 wp->w_redr_status = TRUE; 3354 win_rest_invalid(W_NEXT(wp)); 3355 } 3356 return FAIL; 3357 } 3358 3359 return OK; 3360 } 3361 3362 /* 3363 * Delete "line_count" window lines at "row" in window "wp". 3364 * If "invalid" is TRUE curwin->w_lines[] is invalidated. 3365 * If "mayclear" is TRUE the screen will be cleared if it is faster than 3366 * scrolling 3367 * Return OK for success, FAIL if the lines are not deleted. 3368 */ 3369 int 3370 win_del_lines( 3371 win_T *wp, 3372 int row, 3373 int line_count, 3374 int invalid, 3375 int mayclear, 3376 int clear_attr) // for clearing lines 3377 { 3378 int retval; 3379 3380 if (invalid) 3381 wp->w_lines_valid = 0; 3382 3383 if (line_count > wp->w_height - row) 3384 line_count = wp->w_height - row; 3385 3386 retval = win_do_lines(wp, row, line_count, mayclear, TRUE, clear_attr); 3387 if (retval != MAYBE) 3388 return retval; 3389 3390 if (screen_del_lines(0, W_WINROW(wp) + row, line_count, 3391 (int)Rows, FALSE, clear_attr, NULL) == FAIL) 3392 return FAIL; 3393 3394 /* 3395 * If there are windows or status lines below, try to put them at the 3396 * correct place. If we can't do that, they have to be redrawn. 3397 */ 3398 if (wp->w_next || wp->w_status_height || cmdline_row < Rows - 1) 3399 { 3400 if (screen_ins_lines(0, W_WINROW(wp) + wp->w_height - line_count, 3401 line_count, (int)Rows, clear_attr, NULL) == FAIL) 3402 { 3403 wp->w_redr_status = TRUE; 3404 win_rest_invalid(wp->w_next); 3405 } 3406 } 3407 /* 3408 * If this is the last window and there is no status line, redraw the 3409 * command line later. 3410 */ 3411 else 3412 redraw_cmdline = TRUE; 3413 return OK; 3414 } 3415 3416 /* 3417 * Common code for win_ins_lines() and win_del_lines(). 3418 * Returns OK or FAIL when the work has been done. 3419 * Returns MAYBE when not finished yet. 3420 */ 3421 static int 3422 win_do_lines( 3423 win_T *wp, 3424 int row, 3425 int line_count, 3426 int mayclear, 3427 int del, 3428 int clear_attr) 3429 { 3430 int retval; 3431 3432 if (!redrawing() || line_count <= 0) 3433 return FAIL; 3434 3435 // When inserting lines would result in loss of command output, just redraw 3436 // the lines. 3437 if (no_win_do_lines_ins && !del) 3438 return FAIL; 3439 3440 // only a few lines left: redraw is faster 3441 if (mayclear && Rows - line_count < 5 && wp->w_width == Columns) 3442 { 3443 if (!no_win_do_lines_ins) 3444 screenclear(); // will set wp->w_lines_valid to 0 3445 return FAIL; 3446 } 3447 3448 #ifdef FEAT_PROP_POPUP 3449 // this doesn't work when there are popups visible 3450 if (popup_visible) 3451 return FAIL; 3452 #endif 3453 3454 // Delete all remaining lines 3455 if (row + line_count >= wp->w_height) 3456 { 3457 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + wp->w_height, 3458 wp->w_wincol, (int)W_ENDCOL(wp), 3459 ' ', ' ', 0); 3460 return OK; 3461 } 3462 3463 /* 3464 * When scrolling, the message on the command line should be cleared, 3465 * otherwise it will stay there forever. 3466 * Don't do this when avoiding to insert lines. 3467 */ 3468 if (!no_win_do_lines_ins) 3469 clear_cmdline = TRUE; 3470 3471 /* 3472 * If the terminal can set a scroll region, use that. 3473 * Always do this in a vertically split window. This will redraw from 3474 * ScreenLines[] when t_CV isn't defined. That's faster than using 3475 * win_line(). 3476 * Don't use a scroll region when we are going to redraw the text, writing 3477 * a character in the lower right corner of the scroll region may cause a 3478 * scroll-up . 3479 */ 3480 if (scroll_region || wp->w_width != Columns) 3481 { 3482 if (scroll_region && (wp->w_width == Columns || *T_CSV != NUL)) 3483 scroll_region_set(wp, row); 3484 if (del) 3485 retval = screen_del_lines(W_WINROW(wp) + row, 0, line_count, 3486 wp->w_height - row, FALSE, clear_attr, wp); 3487 else 3488 retval = screen_ins_lines(W_WINROW(wp) + row, 0, line_count, 3489 wp->w_height - row, clear_attr, wp); 3490 if (scroll_region && (wp->w_width == Columns || *T_CSV != NUL)) 3491 scroll_region_reset(); 3492 return retval; 3493 } 3494 3495 if (wp->w_next != NULL && p_tf) // don't delete/insert on fast terminal 3496 return FAIL; 3497 3498 return MAYBE; 3499 } 3500 3501 /* 3502 * window 'wp' and everything after it is messed up, mark it for redraw 3503 */ 3504 static void 3505 win_rest_invalid(win_T *wp) 3506 { 3507 while (wp != NULL) 3508 { 3509 redraw_win_later(wp, NOT_VALID); 3510 wp->w_redr_status = TRUE; 3511 wp = wp->w_next; 3512 } 3513 redraw_cmdline = TRUE; 3514 } 3515 3516 /* 3517 * The rest of the routines in this file perform screen manipulations. The 3518 * given operation is performed physically on the screen. The corresponding 3519 * change is also made to the internal screen image. In this way, the editor 3520 * anticipates the effect of editing changes on the appearance of the screen. 3521 * That way, when we call screenupdate a complete redraw isn't usually 3522 * necessary. Another advantage is that we can keep adding code to anticipate 3523 * screen changes, and in the meantime, everything still works. 3524 */ 3525 3526 /* 3527 * types for inserting or deleting lines 3528 */ 3529 #define USE_T_CAL 1 3530 #define USE_T_CDL 2 3531 #define USE_T_AL 3 3532 #define USE_T_CE 4 3533 #define USE_T_DL 5 3534 #define USE_T_SR 6 3535 #define USE_NL 7 3536 #define USE_T_CD 8 3537 #define USE_REDRAW 9 3538 3539 /* 3540 * insert lines on the screen and update ScreenLines[] 3541 * 'end' is the line after the scrolled part. Normally it is Rows. 3542 * When scrolling region used 'off' is the offset from the top for the region. 3543 * 'row' and 'end' are relative to the start of the region. 3544 * 3545 * return FAIL for failure, OK for success. 3546 */ 3547 int 3548 screen_ins_lines( 3549 int off, 3550 int row, 3551 int line_count, 3552 int end, 3553 int clear_attr, 3554 win_T *wp) // NULL or window to use width from 3555 { 3556 int i; 3557 int j; 3558 unsigned temp; 3559 int cursor_row; 3560 int cursor_col = 0; 3561 int type; 3562 int result_empty; 3563 int can_ce = can_clear(T_CE); 3564 3565 /* 3566 * FAIL if 3567 * - there is no valid screen 3568 * - the screen has to be redrawn completely 3569 * - the line count is less than one 3570 * - the line count is more than 'ttyscroll' 3571 * - redrawing for a callback and there is a modeless selection 3572 * - there is a popup window 3573 */ 3574 if (!screen_valid(TRUE) 3575 || line_count <= 0 || line_count > p_ttyscroll 3576 #ifdef FEAT_CLIPBOARD 3577 || (clip_star.state != SELECT_CLEARED 3578 && redrawing_for_callback > 0) 3579 #endif 3580 #ifdef FEAT_PROP_POPUP 3581 || popup_visible 3582 #endif 3583 ) 3584 return FAIL; 3585 3586 /* 3587 * There are seven ways to insert lines: 3588 * 0. When in a vertically split window and t_CV isn't set, redraw the 3589 * characters from ScreenLines[]. 3590 * 1. Use T_CD (clear to end of display) if it exists and the result of 3591 * the insert is just empty lines 3592 * 2. Use T_CAL (insert multiple lines) if it exists and T_AL is not 3593 * present or line_count > 1. It looks better if we do all the inserts 3594 * at once. 3595 * 3. Use T_CDL (delete multiple lines) if it exists and the result of the 3596 * insert is just empty lines and T_CE is not present or line_count > 3597 * 1. 3598 * 4. Use T_AL (insert line) if it exists. 3599 * 5. Use T_CE (erase line) if it exists and the result of the insert is 3600 * just empty lines. 3601 * 6. Use T_DL (delete line) if it exists and the result of the insert is 3602 * just empty lines. 3603 * 7. Use T_SR (scroll reverse) if it exists and inserting at row 0 and 3604 * the 'da' flag is not set or we have clear line capability. 3605 * 8. redraw the characters from ScreenLines[]. 3606 * 3607 * Careful: In a hpterm scroll reverse doesn't work as expected, it moves 3608 * the scrollbar for the window. It does have insert line, use that if it 3609 * exists. 3610 */ 3611 result_empty = (row + line_count >= end); 3612 if (wp != NULL && wp->w_width != Columns && *T_CSV == NUL) 3613 type = USE_REDRAW; 3614 else if (can_clear(T_CD) && result_empty) 3615 type = USE_T_CD; 3616 else if (*T_CAL != NUL && (line_count > 1 || *T_AL == NUL)) 3617 type = USE_T_CAL; 3618 else if (*T_CDL != NUL && result_empty && (line_count > 1 || !can_ce)) 3619 type = USE_T_CDL; 3620 else if (*T_AL != NUL) 3621 type = USE_T_AL; 3622 else if (can_ce && result_empty) 3623 type = USE_T_CE; 3624 else if (*T_DL != NUL && result_empty) 3625 type = USE_T_DL; 3626 else if (*T_SR != NUL && row == 0 && (*T_DA == NUL || can_ce)) 3627 type = USE_T_SR; 3628 else 3629 return FAIL; 3630 3631 /* 3632 * For clearing the lines screen_del_lines() is used. This will also take 3633 * care of t_db if necessary. 3634 */ 3635 if (type == USE_T_CD || type == USE_T_CDL || 3636 type == USE_T_CE || type == USE_T_DL) 3637 return screen_del_lines(off, row, line_count, end, FALSE, 0, wp); 3638 3639 /* 3640 * If text is retained below the screen, first clear or delete as many 3641 * lines at the bottom of the window as are about to be inserted so that 3642 * the deleted lines won't later surface during a screen_del_lines. 3643 */ 3644 if (*T_DB) 3645 screen_del_lines(off, end - line_count, line_count, end, FALSE, 0, wp); 3646 3647 #ifdef FEAT_CLIPBOARD 3648 // Remove a modeless selection when inserting lines halfway the screen 3649 // or not the full width of the screen. 3650 if (off + row > 0 || (wp != NULL && wp->w_width != Columns)) 3651 clip_clear_selection(&clip_star); 3652 else 3653 clip_scroll_selection(-line_count); 3654 #endif 3655 3656 #ifdef FEAT_GUI_HAIKU 3657 vim_lock_screen(); 3658 #endif 3659 3660 #ifdef FEAT_GUI 3661 // Don't update the GUI cursor here, ScreenLines[] is invalid until the 3662 // scrolling is actually carried out. 3663 gui_dont_update_cursor(row + off <= gui.cursor_row); 3664 #endif 3665 3666 if (wp != NULL && wp->w_wincol != 0 && *T_CSV != NUL && *T_CCS == NUL) 3667 cursor_col = wp->w_wincol; 3668 3669 if (*T_CCS != NUL) // cursor relative to region 3670 cursor_row = row; 3671 else 3672 cursor_row = row + off; 3673 3674 /* 3675 * Shift LineOffset[] line_count down to reflect the inserted lines. 3676 * Clear the inserted lines in ScreenLines[]. 3677 */ 3678 row += off; 3679 end += off; 3680 for (i = 0; i < line_count; ++i) 3681 { 3682 if (wp != NULL && wp->w_width != Columns) 3683 { 3684 // need to copy part of a line 3685 j = end - 1 - i; 3686 while ((j -= line_count) >= row) 3687 linecopy(j + line_count, j, wp); 3688 j += line_count; 3689 if (can_clear((char_u *)" ")) 3690 lineclear(LineOffset[j] + wp->w_wincol, wp->w_width, 3691 clear_attr); 3692 else 3693 lineinvalid(LineOffset[j] + wp->w_wincol, wp->w_width); 3694 LineWraps[j] = FALSE; 3695 } 3696 else 3697 { 3698 j = end - 1 - i; 3699 temp = LineOffset[j]; 3700 while ((j -= line_count) >= row) 3701 { 3702 LineOffset[j + line_count] = LineOffset[j]; 3703 LineWraps[j + line_count] = LineWraps[j]; 3704 } 3705 LineOffset[j + line_count] = temp; 3706 LineWraps[j + line_count] = FALSE; 3707 if (can_clear((char_u *)" ")) 3708 lineclear(temp, (int)Columns, clear_attr); 3709 else 3710 lineinvalid(temp, (int)Columns); 3711 } 3712 } 3713 3714 #ifdef FEAT_GUI_HAIKU 3715 vim_unlock_screen(); 3716 #endif 3717 3718 screen_stop_highlight(); 3719 windgoto(cursor_row, cursor_col); 3720 if (clear_attr != 0) 3721 screen_start_highlight(clear_attr); 3722 3723 // redraw the characters 3724 if (type == USE_REDRAW) 3725 redraw_block(row, end, wp); 3726 else if (type == USE_T_CAL) 3727 { 3728 term_append_lines(line_count); 3729 screen_start(); // don't know where cursor is now 3730 } 3731 else 3732 { 3733 for (i = 0; i < line_count; i++) 3734 { 3735 if (type == USE_T_AL) 3736 { 3737 if (i && cursor_row != 0) 3738 windgoto(cursor_row, cursor_col); 3739 out_str(T_AL); 3740 } 3741 else // type == USE_T_SR 3742 out_str(T_SR); 3743 screen_start(); // don't know where cursor is now 3744 } 3745 } 3746 3747 /* 3748 * With scroll-reverse and 'da' flag set we need to clear the lines that 3749 * have been scrolled down into the region. 3750 */ 3751 if (type == USE_T_SR && *T_DA) 3752 { 3753 for (i = 0; i < line_count; ++i) 3754 { 3755 windgoto(off + i, cursor_col); 3756 out_str(T_CE); 3757 screen_start(); // don't know where cursor is now 3758 } 3759 } 3760 3761 #ifdef FEAT_GUI 3762 gui_can_update_cursor(); 3763 if (gui.in_use) 3764 out_flush(); // always flush after a scroll 3765 #endif 3766 return OK; 3767 } 3768 3769 /* 3770 * Delete lines on the screen and update ScreenLines[]. 3771 * "end" is the line after the scrolled part. Normally it is Rows. 3772 * When scrolling region used "off" is the offset from the top for the region. 3773 * "row" and "end" are relative to the start of the region. 3774 * 3775 * Return OK for success, FAIL if the lines are not deleted. 3776 */ 3777 int 3778 screen_del_lines( 3779 int off, 3780 int row, 3781 int line_count, 3782 int end, 3783 int force, // even when line_count > p_ttyscroll 3784 int clear_attr, // used for clearing lines 3785 win_T *wp UNUSED) // NULL or window to use width from 3786 { 3787 int j; 3788 int i; 3789 unsigned temp; 3790 int cursor_row; 3791 int cursor_col = 0; 3792 int cursor_end; 3793 int result_empty; // result is empty until end of region 3794 int can_delete; // deleting line codes can be used 3795 int type; 3796 3797 /* 3798 * FAIL if 3799 * - there is no valid screen 3800 * - the screen has to be redrawn completely 3801 * - the line count is less than one 3802 * - the line count is more than 'ttyscroll' 3803 * - redrawing for a callback and there is a modeless selection 3804 */ 3805 if (!screen_valid(TRUE) || line_count <= 0 3806 || (!force && line_count > p_ttyscroll) 3807 #ifdef FEAT_CLIPBOARD 3808 || (clip_star.state != SELECT_CLEARED 3809 && redrawing_for_callback > 0) 3810 #endif 3811 ) 3812 return FAIL; 3813 3814 /* 3815 * Check if the rest of the current region will become empty. 3816 */ 3817 result_empty = row + line_count >= end; 3818 3819 /* 3820 * We can delete lines only when 'db' flag not set or when 'ce' option 3821 * available. 3822 */ 3823 can_delete = (*T_DB == NUL || can_clear(T_CE)); 3824 3825 /* 3826 * There are six ways to delete lines: 3827 * 0. When in a vertically split window and t_CV isn't set, redraw the 3828 * characters from ScreenLines[]. 3829 * 1. Use T_CD if it exists and the result is empty. 3830 * 2. Use newlines if row == 0 and count == 1 or T_CDL does not exist. 3831 * 3. Use T_CDL (delete multiple lines) if it exists and line_count > 1 or 3832 * none of the other ways work. 3833 * 4. Use T_CE (erase line) if the result is empty. 3834 * 5. Use T_DL (delete line) if it exists. 3835 * 6. redraw the characters from ScreenLines[]. 3836 */ 3837 if (wp != NULL && wp->w_width != Columns && *T_CSV == NUL) 3838 type = USE_REDRAW; 3839 else if (can_clear(T_CD) && result_empty) 3840 type = USE_T_CD; 3841 #if defined(__BEOS__) && defined(BEOS_DR8) 3842 /* 3843 * USE_NL does not seem to work in Terminal of DR8 so we set T_DB="" in 3844 * its internal termcap... this works okay for tests which test *T_DB != 3845 * NUL. It has the disadvantage that the user cannot use any :set t_* 3846 * command to get T_DB (back) to empty_option, only :set term=... will do 3847 * the trick... 3848 * Anyway, this hack will hopefully go away with the next OS release. 3849 * (Olaf Seibert) 3850 */ 3851 else if (row == 0 && T_DB == empty_option 3852 && (line_count == 1 || *T_CDL == NUL)) 3853 #else 3854 else if (row == 0 && ( 3855 #ifndef AMIGA 3856 // On the Amiga, somehow '\n' on the last line doesn't always scroll 3857 // up, so use delete-line command 3858 line_count == 1 || 3859 #endif 3860 *T_CDL == NUL)) 3861 #endif 3862 type = USE_NL; 3863 else if (*T_CDL != NUL && line_count > 1 && can_delete) 3864 type = USE_T_CDL; 3865 else if (can_clear(T_CE) && result_empty 3866 && (wp == NULL || wp->w_width == Columns)) 3867 type = USE_T_CE; 3868 else if (*T_DL != NUL && can_delete) 3869 type = USE_T_DL; 3870 else if (*T_CDL != NUL && can_delete) 3871 type = USE_T_CDL; 3872 else 3873 return FAIL; 3874 3875 #ifdef FEAT_CLIPBOARD 3876 // Remove a modeless selection when deleting lines halfway the screen or 3877 // not the full width of the screen. 3878 if (off + row > 0 || (wp != NULL && wp->w_width != Columns)) 3879 clip_clear_selection(&clip_star); 3880 else 3881 clip_scroll_selection(line_count); 3882 #endif 3883 3884 #ifdef FEAT_GUI 3885 // Don't update the GUI cursor here, ScreenLines[] is invalid until the 3886 // scrolling is actually carried out. 3887 gui_dont_update_cursor(gui.cursor_row >= row + off 3888 && gui.cursor_row < end + off); 3889 #endif 3890 3891 if (wp != NULL && wp->w_wincol != 0 && *T_CSV != NUL && *T_CCS == NUL) 3892 cursor_col = wp->w_wincol; 3893 3894 if (*T_CCS != NUL) // cursor relative to region 3895 { 3896 cursor_row = row; 3897 cursor_end = end; 3898 } 3899 else 3900 { 3901 cursor_row = row + off; 3902 cursor_end = end + off; 3903 } 3904 3905 /* 3906 * Now shift LineOffset[] line_count up to reflect the deleted lines. 3907 * Clear the inserted lines in ScreenLines[]. 3908 */ 3909 row += off; 3910 end += off; 3911 for (i = 0; i < line_count; ++i) 3912 { 3913 if (wp != NULL && wp->w_width != Columns) 3914 { 3915 // need to copy part of a line 3916 j = row + i; 3917 while ((j += line_count) <= end - 1) 3918 linecopy(j - line_count, j, wp); 3919 j -= line_count; 3920 if (can_clear((char_u *)" ")) 3921 lineclear(LineOffset[j] + wp->w_wincol, wp->w_width, 3922 clear_attr); 3923 else 3924 lineinvalid(LineOffset[j] + wp->w_wincol, wp->w_width); 3925 LineWraps[j] = FALSE; 3926 } 3927 else 3928 { 3929 // whole width, moving the line pointers is faster 3930 j = row + i; 3931 temp = LineOffset[j]; 3932 while ((j += line_count) <= end - 1) 3933 { 3934 LineOffset[j - line_count] = LineOffset[j]; 3935 LineWraps[j - line_count] = LineWraps[j]; 3936 } 3937 LineOffset[j - line_count] = temp; 3938 LineWraps[j - line_count] = FALSE; 3939 if (can_clear((char_u *)" ")) 3940 lineclear(temp, (int)Columns, clear_attr); 3941 else 3942 lineinvalid(temp, (int)Columns); 3943 } 3944 } 3945 3946 #ifdef FEAT_GUI_HAIKU 3947 vim_unlock_screen(); 3948 #endif 3949 3950 if (screen_attr != clear_attr) 3951 screen_stop_highlight(); 3952 if (clear_attr != 0) 3953 screen_start_highlight(clear_attr); 3954 3955 // redraw the characters 3956 if (type == USE_REDRAW) 3957 redraw_block(row, end, wp); 3958 else if (type == USE_T_CD) // delete the lines 3959 { 3960 windgoto(cursor_row, cursor_col); 3961 out_str(T_CD); 3962 screen_start(); // don't know where cursor is now 3963 } 3964 else if (type == USE_T_CDL) 3965 { 3966 windgoto(cursor_row, cursor_col); 3967 term_delete_lines(line_count); 3968 screen_start(); // don't know where cursor is now 3969 } 3970 /* 3971 * Deleting lines at top of the screen or scroll region: Just scroll 3972 * the whole screen (scroll region) up by outputting newlines on the 3973 * last line. 3974 */ 3975 else if (type == USE_NL) 3976 { 3977 windgoto(cursor_end - 1, cursor_col); 3978 for (i = line_count; --i >= 0; ) 3979 out_char('\n'); // cursor will remain on same line 3980 } 3981 else 3982 { 3983 for (i = line_count; --i >= 0; ) 3984 { 3985 if (type == USE_T_DL) 3986 { 3987 windgoto(cursor_row, cursor_col); 3988 out_str(T_DL); // delete a line 3989 } 3990 else // type == USE_T_CE 3991 { 3992 windgoto(cursor_row + i, cursor_col); 3993 out_str(T_CE); // erase a line 3994 } 3995 screen_start(); // don't know where cursor is now 3996 } 3997 } 3998 3999 /* 4000 * If the 'db' flag is set, we need to clear the lines that have been 4001 * scrolled up at the bottom of the region. 4002 */ 4003 if (*T_DB && (type == USE_T_DL || type == USE_T_CDL)) 4004 { 4005 for (i = line_count; i > 0; --i) 4006 { 4007 windgoto(cursor_end - i, cursor_col); 4008 out_str(T_CE); // erase a line 4009 screen_start(); // don't know where cursor is now 4010 } 4011 } 4012 4013 #ifdef FEAT_GUI 4014 gui_can_update_cursor(); 4015 if (gui.in_use) 4016 out_flush(); // always flush after a scroll 4017 #endif 4018 4019 return OK; 4020 } 4021 4022 /* 4023 * Return TRUE when postponing displaying the mode message: when not redrawing 4024 * or inside a mapping. 4025 */ 4026 int 4027 skip_showmode() 4028 { 4029 // Call char_avail() only when we are going to show something, because it 4030 // takes a bit of time. redrawing() may also call char_avail_avail(). 4031 if (global_busy 4032 || msg_silent != 0 4033 || !redrawing() 4034 || (char_avail() && !KeyTyped)) 4035 { 4036 redraw_mode = TRUE; // show mode later 4037 return TRUE; 4038 } 4039 return FALSE; 4040 } 4041 4042 /* 4043 * Show the current mode and ruler. 4044 * 4045 * If clear_cmdline is TRUE, clear the rest of the cmdline. 4046 * If clear_cmdline is FALSE there may be a message there that needs to be 4047 * cleared only if a mode is shown. 4048 * If redraw_mode is TRUE show or clear the mode. 4049 * Return the length of the message (0 if no message). 4050 */ 4051 int 4052 showmode(void) 4053 { 4054 int need_clear; 4055 int length = 0; 4056 int do_mode; 4057 int attr; 4058 int nwr_save; 4059 int sub_attr; 4060 4061 do_mode = ((p_smd && msg_silent == 0) 4062 && ((State & INSERT) 4063 || restart_edit != NUL 4064 || VIsual_active)); 4065 if (do_mode || reg_recording != 0) 4066 { 4067 if (skip_showmode()) 4068 return 0; // show mode later 4069 4070 nwr_save = need_wait_return; 4071 4072 // wait a bit before overwriting an important message 4073 check_for_delay(FALSE); 4074 4075 // if the cmdline is more than one line high, erase top lines 4076 need_clear = clear_cmdline; 4077 if (clear_cmdline && cmdline_row < Rows - 1) 4078 msg_clr_cmdline(); // will reset clear_cmdline 4079 4080 // Position on the last line in the window, column 0 4081 msg_pos_mode(); 4082 cursor_off(); 4083 attr = HL_ATTR(HLF_CM); // Highlight mode 4084 if (do_mode) 4085 { 4086 msg_puts_attr("--", attr); 4087 #if defined(FEAT_XIM) 4088 if ( 4089 # ifdef FEAT_GUI_GTK 4090 preedit_get_status() 4091 # else 4092 im_get_status() 4093 # endif 4094 ) 4095 # ifdef FEAT_GUI_GTK // most of the time, it's not XIM being used 4096 msg_puts_attr(" IM", attr); 4097 # else 4098 msg_puts_attr(" XIM", attr); 4099 # endif 4100 #endif 4101 // CTRL-X in Insert mode 4102 if (edit_submode != NULL && !shortmess(SHM_COMPLETIONMENU)) 4103 { 4104 // These messages can get long, avoid a wrap in a narrow 4105 // window. Prefer showing edit_submode_extra. 4106 length = (Rows - msg_row) * Columns - 3; 4107 if (edit_submode_extra != NULL) 4108 length -= vim_strsize(edit_submode_extra); 4109 if (length > 0) 4110 { 4111 if (edit_submode_pre != NULL) 4112 length -= vim_strsize(edit_submode_pre); 4113 if (length - vim_strsize(edit_submode) > 0) 4114 { 4115 if (edit_submode_pre != NULL) 4116 msg_puts_attr((char *)edit_submode_pre, attr); 4117 msg_puts_attr((char *)edit_submode, attr); 4118 } 4119 if (edit_submode_extra != NULL) 4120 { 4121 msg_puts_attr(" ", attr); // add a space in between 4122 if ((int)edit_submode_highl < (int)HLF_COUNT) 4123 sub_attr = HL_ATTR(edit_submode_highl); 4124 else 4125 sub_attr = attr; 4126 msg_puts_attr((char *)edit_submode_extra, sub_attr); 4127 } 4128 } 4129 } 4130 else 4131 { 4132 if (State & VREPLACE_FLAG) 4133 msg_puts_attr(_(" VREPLACE"), attr); 4134 else if (State & REPLACE_FLAG) 4135 msg_puts_attr(_(" REPLACE"), attr); 4136 else if (State & INSERT) 4137 { 4138 #ifdef FEAT_RIGHTLEFT 4139 if (p_ri) 4140 msg_puts_attr(_(" REVERSE"), attr); 4141 #endif 4142 msg_puts_attr(_(" INSERT"), attr); 4143 } 4144 else if (restart_edit == 'I' || restart_edit == 'A') 4145 msg_puts_attr(_(" (insert)"), attr); 4146 else if (restart_edit == 'R') 4147 msg_puts_attr(_(" (replace)"), attr); 4148 else if (restart_edit == 'V') 4149 msg_puts_attr(_(" (vreplace)"), attr); 4150 #ifdef FEAT_RIGHTLEFT 4151 if (p_hkmap) 4152 msg_puts_attr(_(" Hebrew"), attr); 4153 #endif 4154 #ifdef FEAT_KEYMAP 4155 if (State & LANGMAP) 4156 { 4157 # ifdef FEAT_ARABIC 4158 if (curwin->w_p_arab) 4159 msg_puts_attr(_(" Arabic"), attr); 4160 else 4161 # endif 4162 if (get_keymap_str(curwin, (char_u *)" (%s)", 4163 NameBuff, MAXPATHL)) 4164 msg_puts_attr((char *)NameBuff, attr); 4165 } 4166 #endif 4167 if ((State & INSERT) && p_paste) 4168 msg_puts_attr(_(" (paste)"), attr); 4169 4170 if (VIsual_active) 4171 { 4172 char *p; 4173 4174 // Don't concatenate separate words to avoid translation 4175 // problems. 4176 switch ((VIsual_select ? 4 : 0) 4177 + (VIsual_mode == Ctrl_V) * 2 4178 + (VIsual_mode == 'V')) 4179 { 4180 case 0: p = N_(" VISUAL"); break; 4181 case 1: p = N_(" VISUAL LINE"); break; 4182 case 2: p = N_(" VISUAL BLOCK"); break; 4183 case 4: p = N_(" SELECT"); break; 4184 case 5: p = N_(" SELECT LINE"); break; 4185 default: p = N_(" SELECT BLOCK"); break; 4186 } 4187 msg_puts_attr(_(p), attr); 4188 } 4189 msg_puts_attr(" --", attr); 4190 } 4191 4192 need_clear = TRUE; 4193 } 4194 if (reg_recording != 0 4195 && edit_submode == NULL) // otherwise it gets too long 4196 { 4197 recording_mode(attr); 4198 need_clear = TRUE; 4199 } 4200 4201 mode_displayed = TRUE; 4202 if (need_clear || clear_cmdline || redraw_mode) 4203 msg_clr_eos(); 4204 msg_didout = FALSE; // overwrite this message 4205 length = msg_col; 4206 msg_col = 0; 4207 need_wait_return = nwr_save; // never ask for hit-return for this 4208 } 4209 else if (clear_cmdline && msg_silent == 0) 4210 // Clear the whole command line. Will reset "clear_cmdline". 4211 msg_clr_cmdline(); 4212 else if (redraw_mode) 4213 { 4214 msg_pos_mode(); 4215 msg_clr_eos(); 4216 } 4217 4218 #ifdef FEAT_CMDL_INFO 4219 // In Visual mode the size of the selected area must be redrawn. 4220 if (VIsual_active) 4221 clear_showcmd(); 4222 4223 // If the last window has no status line, the ruler is after the mode 4224 // message and must be redrawn 4225 if (redrawing() && lastwin->w_status_height == 0) 4226 win_redr_ruler(lastwin, TRUE, FALSE); 4227 #endif 4228 redraw_cmdline = FALSE; 4229 redraw_mode = FALSE; 4230 clear_cmdline = FALSE; 4231 4232 return length; 4233 } 4234 4235 /* 4236 * Position for a mode message. 4237 */ 4238 static void 4239 msg_pos_mode(void) 4240 { 4241 msg_col = 0; 4242 msg_row = Rows - 1; 4243 } 4244 4245 /* 4246 * Delete mode message. Used when ESC is typed which is expected to end 4247 * Insert mode (but Insert mode didn't end yet!). 4248 * Caller should check "mode_displayed". 4249 */ 4250 void 4251 unshowmode(int force) 4252 { 4253 /* 4254 * Don't delete it right now, when not redrawing or inside a mapping. 4255 */ 4256 if (!redrawing() || (!force && char_avail() && !KeyTyped)) 4257 redraw_cmdline = TRUE; // delete mode later 4258 else 4259 clearmode(); 4260 } 4261 4262 /* 4263 * Clear the mode message. 4264 */ 4265 void 4266 clearmode(void) 4267 { 4268 int save_msg_row = msg_row; 4269 int save_msg_col = msg_col; 4270 4271 msg_pos_mode(); 4272 if (reg_recording != 0) 4273 recording_mode(HL_ATTR(HLF_CM)); 4274 msg_clr_eos(); 4275 4276 msg_col = save_msg_col; 4277 msg_row = save_msg_row; 4278 } 4279 4280 static void 4281 recording_mode(int attr) 4282 { 4283 msg_puts_attr(_("recording"), attr); 4284 if (!shortmess(SHM_RECORDING)) 4285 { 4286 char s[4]; 4287 4288 sprintf(s, " @%c", reg_recording); 4289 msg_puts_attr(s, attr); 4290 } 4291 } 4292 4293 /* 4294 * Draw the tab pages line at the top of the Vim window. 4295 */ 4296 void 4297 draw_tabline(void) 4298 { 4299 int tabcount = 0; 4300 tabpage_T *tp; 4301 int tabwidth; 4302 int col = 0; 4303 int scol = 0; 4304 int attr; 4305 win_T *wp; 4306 win_T *cwp; 4307 int wincount; 4308 int modified; 4309 int c; 4310 int len; 4311 int attr_sel = HL_ATTR(HLF_TPS); 4312 int attr_nosel = HL_ATTR(HLF_TP); 4313 int attr_fill = HL_ATTR(HLF_TPF); 4314 char_u *p; 4315 int room; 4316 int use_sep_chars = (t_colors < 8 4317 #ifdef FEAT_GUI 4318 && !gui.in_use 4319 #endif 4320 #ifdef FEAT_TERMGUICOLORS 4321 && !p_tgc 4322 #endif 4323 ); 4324 4325 if (ScreenLines == NULL) 4326 return; 4327 redraw_tabline = FALSE; 4328 4329 #ifdef FEAT_GUI_TABLINE 4330 // Take care of a GUI tabline. 4331 if (gui_use_tabline()) 4332 { 4333 gui_update_tabline(); 4334 return; 4335 } 4336 #endif 4337 4338 if (tabline_height() < 1) 4339 return; 4340 4341 #if defined(FEAT_STL_OPT) 4342 clear_TabPageIdxs(); 4343 4344 // Use the 'tabline' option if it's set. 4345 if (*p_tal != NUL) 4346 { 4347 int saved_did_emsg = did_emsg; 4348 4349 // Check for an error. If there is one we would loop in redrawing the 4350 // screen. Avoid that by making 'tabline' empty. 4351 did_emsg = FALSE; 4352 win_redr_custom(NULL, FALSE); 4353 if (did_emsg) 4354 set_string_option_direct((char_u *)"tabline", -1, 4355 (char_u *)"", OPT_FREE, SID_ERROR); 4356 did_emsg |= saved_did_emsg; 4357 } 4358 else 4359 #endif 4360 { 4361 FOR_ALL_TABPAGES(tp) 4362 ++tabcount; 4363 4364 tabwidth = (Columns - 1 + tabcount / 2) / tabcount; 4365 if (tabwidth < 6) 4366 tabwidth = 6; 4367 4368 attr = attr_nosel; 4369 tabcount = 0; 4370 for (tp = first_tabpage; tp != NULL && col < Columns - 4; 4371 tp = tp->tp_next) 4372 { 4373 scol = col; 4374 4375 if (tp->tp_topframe == topframe) 4376 attr = attr_sel; 4377 if (use_sep_chars && col > 0) 4378 screen_putchar('|', 0, col++, attr); 4379 4380 if (tp->tp_topframe != topframe) 4381 attr = attr_nosel; 4382 4383 screen_putchar(' ', 0, col++, attr); 4384 4385 if (tp == curtab) 4386 { 4387 cwp = curwin; 4388 wp = firstwin; 4389 } 4390 else 4391 { 4392 cwp = tp->tp_curwin; 4393 wp = tp->tp_firstwin; 4394 } 4395 4396 modified = FALSE; 4397 for (wincount = 0; wp != NULL; wp = wp->w_next, ++wincount) 4398 if (bufIsChanged(wp->w_buffer)) 4399 modified = TRUE; 4400 if (modified || wincount > 1) 4401 { 4402 if (wincount > 1) 4403 { 4404 vim_snprintf((char *)NameBuff, MAXPATHL, "%d", wincount); 4405 len = (int)STRLEN(NameBuff); 4406 if (col + len >= Columns - 3) 4407 break; 4408 screen_puts_len(NameBuff, len, 0, col, 4409 #if defined(FEAT_SYN_HL) 4410 hl_combine_attr(attr, HL_ATTR(HLF_T)) 4411 #else 4412 attr 4413 #endif 4414 ); 4415 col += len; 4416 } 4417 if (modified) 4418 screen_puts_len((char_u *)"+", 1, 0, col++, attr); 4419 screen_putchar(' ', 0, col++, attr); 4420 } 4421 4422 room = scol - col + tabwidth - 1; 4423 if (room > 0) 4424 { 4425 // Get buffer name in NameBuff[] 4426 get_trans_bufname(cwp->w_buffer); 4427 shorten_dir(NameBuff); 4428 len = vim_strsize(NameBuff); 4429 p = NameBuff; 4430 if (has_mbyte) 4431 while (len > room) 4432 { 4433 len -= ptr2cells(p); 4434 MB_PTR_ADV(p); 4435 } 4436 else if (len > room) 4437 { 4438 p += len - room; 4439 len = room; 4440 } 4441 if (len > Columns - col - 1) 4442 len = Columns - col - 1; 4443 4444 screen_puts_len(p, (int)STRLEN(p), 0, col, attr); 4445 col += len; 4446 } 4447 screen_putchar(' ', 0, col++, attr); 4448 4449 // Store the tab page number in TabPageIdxs[], so that 4450 // jump_to_mouse() knows where each one is. 4451 ++tabcount; 4452 while (scol < col) 4453 TabPageIdxs[scol++] = tabcount; 4454 } 4455 4456 if (use_sep_chars) 4457 c = '_'; 4458 else 4459 c = ' '; 4460 screen_fill(0, 1, col, (int)Columns, c, c, attr_fill); 4461 4462 // Put an "X" for closing the current tab if there are several. 4463 if (first_tabpage->tp_next != NULL) 4464 { 4465 screen_putchar('X', 0, (int)Columns - 1, attr_nosel); 4466 TabPageIdxs[Columns - 1] = -999; 4467 } 4468 } 4469 4470 // Reset the flag here again, in case evaluating 'tabline' causes it to be 4471 // set. 4472 redraw_tabline = FALSE; 4473 } 4474 4475 /* 4476 * Get buffer name for "buf" into NameBuff[]. 4477 * Takes care of special buffer names and translates special characters. 4478 */ 4479 void 4480 get_trans_bufname(buf_T *buf) 4481 { 4482 if (buf_spname(buf) != NULL) 4483 vim_strncpy(NameBuff, buf_spname(buf), MAXPATHL - 1); 4484 else 4485 home_replace(buf, buf->b_fname, NameBuff, MAXPATHL, TRUE); 4486 trans_characters(NameBuff, MAXPATHL); 4487 } 4488 4489 /* 4490 * Get the character to use in a status line. Get its attributes in "*attr". 4491 */ 4492 int 4493 fillchar_status(int *attr, win_T *wp) 4494 { 4495 int fill; 4496 4497 #ifdef FEAT_TERMINAL 4498 if (bt_terminal(wp->w_buffer)) 4499 { 4500 if (wp == curwin) 4501 { 4502 *attr = HL_ATTR(HLF_ST); 4503 fill = fill_stl; 4504 } 4505 else 4506 { 4507 *attr = HL_ATTR(HLF_STNC); 4508 fill = fill_stlnc; 4509 } 4510 } 4511 else 4512 #endif 4513 if (wp == curwin) 4514 { 4515 *attr = HL_ATTR(HLF_S); 4516 fill = fill_stl; 4517 } 4518 else 4519 { 4520 *attr = HL_ATTR(HLF_SNC); 4521 fill = fill_stlnc; 4522 } 4523 // Use fill when there is highlighting, and highlighting of current 4524 // window differs, or the fillchars differ, or this is not the 4525 // current window 4526 if (*attr != 0 && ((HL_ATTR(HLF_S) != HL_ATTR(HLF_SNC) 4527 || wp != curwin || ONE_WINDOW) 4528 || (fill_stl != fill_stlnc))) 4529 return fill; 4530 if (wp == curwin) 4531 return '^'; 4532 return '='; 4533 } 4534 4535 /* 4536 * Get the character to use in a separator between vertically split windows. 4537 * Get its attributes in "*attr". 4538 */ 4539 int 4540 fillchar_vsep(int *attr) 4541 { 4542 *attr = HL_ATTR(HLF_C); 4543 if (*attr == 0 && fill_vert == ' ') 4544 return '|'; 4545 else 4546 return fill_vert; 4547 } 4548 4549 /* 4550 * Return TRUE if redrawing should currently be done. 4551 */ 4552 int 4553 redrawing(void) 4554 { 4555 #ifdef FEAT_EVAL 4556 if (disable_redraw_for_testing) 4557 return 0; 4558 else 4559 #endif 4560 return ((!RedrawingDisabled 4561 #ifdef FEAT_EVAL 4562 || ignore_redraw_flag_for_testing 4563 #endif 4564 ) && !(p_lz && char_avail() && !KeyTyped && !do_redraw)); 4565 } 4566 4567 /* 4568 * Return TRUE if printing messages should currently be done. 4569 */ 4570 int 4571 messaging(void) 4572 { 4573 return (!(p_lz && char_avail() && !KeyTyped)); 4574 } 4575 4576 /* 4577 * Compute columns for ruler and shown command. 'sc_col' is also used to 4578 * decide what the maximum length of a message on the status line can be. 4579 * If there is a status line for the last window, 'sc_col' is independent 4580 * of 'ru_col'. 4581 */ 4582 4583 #define COL_RULER 17 // columns needed by standard ruler 4584 4585 void 4586 comp_col(void) 4587 { 4588 #if defined(FEAT_CMDL_INFO) 4589 int last_has_status = (p_ls == 2 || (p_ls == 1 && !ONE_WINDOW)); 4590 4591 sc_col = 0; 4592 ru_col = 0; 4593 if (p_ru) 4594 { 4595 # ifdef FEAT_STL_OPT 4596 ru_col = (ru_wid ? ru_wid : COL_RULER) + 1; 4597 # else 4598 ru_col = COL_RULER + 1; 4599 # endif 4600 // no last status line, adjust sc_col 4601 if (!last_has_status) 4602 sc_col = ru_col; 4603 } 4604 if (p_sc) 4605 { 4606 sc_col += SHOWCMD_COLS; 4607 if (!p_ru || last_has_status) // no need for separating space 4608 ++sc_col; 4609 } 4610 sc_col = Columns - sc_col; 4611 ru_col = Columns - ru_col; 4612 if (sc_col <= 0) // screen too narrow, will become a mess 4613 sc_col = 1; 4614 if (ru_col <= 0) 4615 ru_col = 1; 4616 #else 4617 sc_col = Columns; 4618 ru_col = Columns; 4619 #endif 4620 #ifdef FEAT_EVAL 4621 set_vim_var_nr(VV_ECHOSPACE, sc_col - 1); 4622 #endif 4623 } 4624 4625 #if defined(FEAT_LINEBREAK) || defined(PROTO) 4626 /* 4627 * Return the width of the 'number' and 'relativenumber' column. 4628 * Caller may need to check if 'number' or 'relativenumber' is set. 4629 * Otherwise it depends on 'numberwidth' and the line count. 4630 */ 4631 int 4632 number_width(win_T *wp) 4633 { 4634 int n; 4635 linenr_T lnum; 4636 4637 if (wp->w_p_rnu && !wp->w_p_nu) 4638 // cursor line shows "0" 4639 lnum = wp->w_height; 4640 else 4641 // cursor line shows absolute line number 4642 lnum = wp->w_buffer->b_ml.ml_line_count; 4643 4644 if (lnum == wp->w_nrwidth_line_count && wp->w_nuw_cached == wp->w_p_nuw) 4645 return wp->w_nrwidth_width; 4646 wp->w_nrwidth_line_count = lnum; 4647 4648 n = 0; 4649 do 4650 { 4651 lnum /= 10; 4652 ++n; 4653 } while (lnum > 0); 4654 4655 // 'numberwidth' gives the minimal width plus one 4656 if (n < wp->w_p_nuw - 1) 4657 n = wp->w_p_nuw - 1; 4658 4659 # ifdef FEAT_SIGNS 4660 // If 'signcolumn' is set to 'number' and there is a sign to display, then 4661 // the minimal width for the number column is 2. 4662 if (n < 2 && get_first_valid_sign(wp) != NULL 4663 && (*wp->w_p_scl == 'n' && *(wp->w_p_scl + 1) == 'u')) 4664 n = 2; 4665 # endif 4666 4667 wp->w_nrwidth_width = n; 4668 wp->w_nuw_cached = wp->w_p_nuw; 4669 return n; 4670 } 4671 #endif 4672 4673 #if defined(FEAT_EVAL) || defined(PROTO) 4674 /* 4675 * Return the current cursor column. This is the actual position on the 4676 * screen. First column is 0. 4677 */ 4678 int 4679 screen_screencol(void) 4680 { 4681 return screen_cur_col; 4682 } 4683 4684 /* 4685 * Return the current cursor row. This is the actual position on the screen. 4686 * First row is 0. 4687 */ 4688 int 4689 screen_screenrow(void) 4690 { 4691 return screen_cur_row; 4692 } 4693 #endif 4694 4695 /* 4696 * Handle setting 'listchars' or 'fillchars'. 4697 * Returns error message, NULL if it's OK. 4698 */ 4699 char * 4700 set_chars_option(char_u **varp) 4701 { 4702 int round, i, len, entries; 4703 char_u *p, *s; 4704 int c1 = 0, c2 = 0, c3 = 0; 4705 struct charstab 4706 { 4707 int *cp; 4708 char *name; 4709 }; 4710 static struct charstab filltab[] = 4711 { 4712 {&fill_stl, "stl"}, 4713 {&fill_stlnc, "stlnc"}, 4714 {&fill_vert, "vert"}, 4715 {&fill_fold, "fold"}, 4716 {&fill_diff, "diff"}, 4717 }; 4718 static struct charstab lcstab[] = 4719 { 4720 {&lcs_eol, "eol"}, 4721 {&lcs_ext, "extends"}, 4722 {&lcs_nbsp, "nbsp"}, 4723 {&lcs_prec, "precedes"}, 4724 {&lcs_space, "space"}, 4725 {&lcs_tab2, "tab"}, 4726 {&lcs_trail, "trail"}, 4727 #ifdef FEAT_CONCEAL 4728 {&lcs_conceal, "conceal"}, 4729 #else 4730 {NULL, "conceal"}, 4731 #endif 4732 }; 4733 struct charstab *tab; 4734 4735 if (varp == &p_lcs) 4736 { 4737 tab = lcstab; 4738 entries = sizeof(lcstab) / sizeof(struct charstab); 4739 } 4740 else 4741 { 4742 tab = filltab; 4743 entries = sizeof(filltab) / sizeof(struct charstab); 4744 } 4745 4746 // first round: check for valid value, second round: assign values 4747 for (round = 0; round <= 1; ++round) 4748 { 4749 if (round > 0) 4750 { 4751 // After checking that the value is valid: set defaults: space for 4752 // 'fillchars', NUL for 'listchars' 4753 for (i = 0; i < entries; ++i) 4754 if (tab[i].cp != NULL) 4755 *(tab[i].cp) = (varp == &p_lcs ? NUL : ' '); 4756 4757 if (varp == &p_lcs) 4758 { 4759 lcs_tab1 = NUL; 4760 lcs_tab3 = NUL; 4761 } 4762 else 4763 fill_diff = '-'; 4764 } 4765 p = *varp; 4766 while (*p) 4767 { 4768 for (i = 0; i < entries; ++i) 4769 { 4770 len = (int)STRLEN(tab[i].name); 4771 if (STRNCMP(p, tab[i].name, len) == 0 4772 && p[len] == ':' 4773 && p[len + 1] != NUL) 4774 { 4775 c2 = c3 = 0; 4776 s = p + len + 1; 4777 c1 = mb_ptr2char_adv(&s); 4778 if (mb_char2cells(c1) > 1) 4779 continue; 4780 if (tab[i].cp == &lcs_tab2) 4781 { 4782 if (*s == NUL) 4783 continue; 4784 c2 = mb_ptr2char_adv(&s); 4785 if (mb_char2cells(c2) > 1) 4786 continue; 4787 if (!(*s == ',' || *s == NUL)) 4788 { 4789 c3 = mb_ptr2char_adv(&s); 4790 if (mb_char2cells(c3) > 1) 4791 continue; 4792 } 4793 } 4794 4795 if (*s == ',' || *s == NUL) 4796 { 4797 if (round) 4798 { 4799 if (tab[i].cp == &lcs_tab2) 4800 { 4801 lcs_tab1 = c1; 4802 lcs_tab2 = c2; 4803 lcs_tab3 = c3; 4804 } 4805 else if (tab[i].cp != NULL) 4806 *(tab[i].cp) = c1; 4807 4808 } 4809 p = s; 4810 break; 4811 } 4812 } 4813 } 4814 4815 if (i == entries) 4816 return e_invarg; 4817 if (*p == ',') 4818 ++p; 4819 } 4820 } 4821 4822 return NULL; // no error 4823 } 4824 4825