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 end_search_hl(); // just in case it wasn't called before 1722 last_pat_prog(&screen_search_hl.rm); 1723 screen_search_hl.attr = HL_ATTR(HLF_L); 1724 # ifdef FEAT_RELTIME 1725 // Set the time limit to 'redrawtime'. 1726 profile_setlimit(p_rdt, &screen_search_hl.tm); 1727 # endif 1728 } 1729 } 1730 1731 /* 1732 * Clean up for 'hlsearch' highlighting. 1733 */ 1734 void 1735 end_search_hl(void) 1736 { 1737 if (screen_search_hl.rm.regprog != NULL) 1738 { 1739 vim_regfree(screen_search_hl.rm.regprog); 1740 screen_search_hl.rm.regprog = NULL; 1741 } 1742 } 1743 #endif 1744 1745 static void 1746 screen_start_highlight(int attr) 1747 { 1748 attrentry_T *aep = NULL; 1749 1750 screen_attr = attr; 1751 if (full_screen 1752 #ifdef MSWIN 1753 && termcap_active 1754 #endif 1755 ) 1756 { 1757 #ifdef FEAT_GUI 1758 if (gui.in_use) 1759 { 1760 char buf[20]; 1761 1762 // The GUI handles this internally. 1763 sprintf(buf, IF_EB("\033|%dh", ESC_STR "|%dh"), attr); 1764 OUT_STR(buf); 1765 } 1766 else 1767 #endif 1768 { 1769 if (attr > HL_ALL) // special HL attr. 1770 { 1771 if (IS_CTERM) 1772 aep = syn_cterm_attr2entry(attr); 1773 else 1774 aep = syn_term_attr2entry(attr); 1775 if (aep == NULL) // did ":syntax clear" 1776 attr = 0; 1777 else 1778 attr = aep->ae_attr; 1779 } 1780 #if defined(FEAT_VTP) && defined(FEAT_TERMGUICOLORS) 1781 if (use_vtp()) 1782 { 1783 guicolor_T defguifg, defguibg; 1784 int defctermfg, defctermbg; 1785 1786 // If FG and BG are unset, the color is undefined when 1787 // BOLD+INVERSE. Use Normal as the default value. 1788 get_default_console_color(&defctermfg, &defctermbg, &defguifg, 1789 &defguibg); 1790 1791 if (p_tgc) 1792 { 1793 if (aep == NULL || COLOR_INVALID(aep->ae_u.cterm.fg_rgb)) 1794 term_fg_rgb_color(defguifg); 1795 if (aep == NULL || COLOR_INVALID(aep->ae_u.cterm.bg_rgb)) 1796 term_bg_rgb_color(defguibg); 1797 } 1798 else if (t_colors >= 256) 1799 { 1800 if (aep == NULL || aep->ae_u.cterm.fg_color == 0) 1801 term_fg_color(defctermfg); 1802 if (aep == NULL || aep->ae_u.cterm.bg_color == 0) 1803 term_bg_color(defctermbg); 1804 } 1805 } 1806 #endif 1807 if ((attr & HL_BOLD) && *T_MD != NUL) // bold 1808 out_str(T_MD); 1809 else if (aep != NULL && cterm_normal_fg_bold && ( 1810 #ifdef FEAT_TERMGUICOLORS 1811 p_tgc && aep->ae_u.cterm.fg_rgb != CTERMCOLOR 1812 ? aep->ae_u.cterm.fg_rgb != INVALCOLOR 1813 : 1814 #endif 1815 t_colors > 1 && aep->ae_u.cterm.fg_color)) 1816 // If the Normal FG color has BOLD attribute and the new HL 1817 // has a FG color defined, clear BOLD. 1818 out_str(T_ME); 1819 if ((attr & HL_STANDOUT) && *T_SO != NUL) // standout 1820 out_str(T_SO); 1821 if ((attr & HL_UNDERCURL) && *T_UCS != NUL) // undercurl 1822 out_str(T_UCS); 1823 if (((attr & HL_UNDERLINE) // underline or undercurl 1824 || ((attr & HL_UNDERCURL) && *T_UCS == NUL)) 1825 && *T_US != NUL) 1826 out_str(T_US); 1827 if ((attr & HL_ITALIC) && *T_CZH != NUL) // italic 1828 out_str(T_CZH); 1829 if ((attr & HL_INVERSE) && *T_MR != NUL) // inverse (reverse) 1830 out_str(T_MR); 1831 if ((attr & HL_STRIKETHROUGH) && *T_STS != NUL) // strike 1832 out_str(T_STS); 1833 1834 /* 1835 * Output the color or start string after bold etc., in case the 1836 * bold etc. override the color setting. 1837 */ 1838 if (aep != NULL) 1839 { 1840 #ifdef FEAT_TERMGUICOLORS 1841 // When 'termguicolors' is set but fg or bg is unset, 1842 // fall back to the cterm colors. This helps for SpellBad, 1843 // where the GUI uses a red undercurl. 1844 if (p_tgc && aep->ae_u.cterm.fg_rgb != CTERMCOLOR) 1845 { 1846 if (aep->ae_u.cterm.fg_rgb != INVALCOLOR) 1847 term_fg_rgb_color(aep->ae_u.cterm.fg_rgb); 1848 } 1849 else 1850 #endif 1851 if (t_colors > 1) 1852 { 1853 if (aep->ae_u.cterm.fg_color) 1854 term_fg_color(aep->ae_u.cterm.fg_color - 1); 1855 } 1856 #ifdef FEAT_TERMGUICOLORS 1857 if (p_tgc && aep->ae_u.cterm.bg_rgb != CTERMCOLOR) 1858 { 1859 if (aep->ae_u.cterm.bg_rgb != INVALCOLOR) 1860 term_bg_rgb_color(aep->ae_u.cterm.bg_rgb); 1861 } 1862 else 1863 #endif 1864 if (t_colors > 1) 1865 { 1866 if (aep->ae_u.cterm.bg_color) 1867 term_bg_color(aep->ae_u.cterm.bg_color - 1); 1868 } 1869 1870 if (!IS_CTERM) 1871 { 1872 if (aep->ae_u.term.start != NULL) 1873 out_str(aep->ae_u.term.start); 1874 } 1875 } 1876 } 1877 } 1878 } 1879 1880 void 1881 screen_stop_highlight(void) 1882 { 1883 int do_ME = FALSE; // output T_ME code 1884 #if defined(FEAT_VTP) && defined(FEAT_TERMGUICOLORS) 1885 int do_ME_fg, do_ME_bg; 1886 #endif 1887 1888 if (screen_attr != 0 1889 #ifdef MSWIN 1890 && termcap_active 1891 #endif 1892 ) 1893 { 1894 #ifdef FEAT_GUI 1895 if (gui.in_use) 1896 { 1897 char buf[20]; 1898 1899 // use internal GUI code 1900 sprintf(buf, IF_EB("\033|%dH", ESC_STR "|%dH"), screen_attr); 1901 OUT_STR(buf); 1902 } 1903 else 1904 #endif 1905 { 1906 if (screen_attr > HL_ALL) // special HL attr. 1907 { 1908 attrentry_T *aep; 1909 1910 if (IS_CTERM) 1911 { 1912 /* 1913 * Assume that t_me restores the original colors! 1914 */ 1915 aep = syn_cterm_attr2entry(screen_attr); 1916 if (aep != NULL && (( 1917 #ifdef FEAT_TERMGUICOLORS 1918 p_tgc && aep->ae_u.cterm.fg_rgb != CTERMCOLOR 1919 ? aep->ae_u.cterm.fg_rgb != INVALCOLOR 1920 # ifdef FEAT_VTP 1921 ? !(do_ME_fg = TRUE) : (do_ME_fg = FALSE) 1922 # endif 1923 : 1924 #endif 1925 aep->ae_u.cterm.fg_color) || ( 1926 #ifdef FEAT_TERMGUICOLORS 1927 p_tgc && aep->ae_u.cterm.bg_rgb != CTERMCOLOR 1928 ? aep->ae_u.cterm.bg_rgb != INVALCOLOR 1929 # ifdef FEAT_VTP 1930 ? !(do_ME_bg = TRUE) : (do_ME_bg = FALSE) 1931 # endif 1932 : 1933 #endif 1934 aep->ae_u.cterm.bg_color))) 1935 do_ME = TRUE; 1936 #if defined(FEAT_VTP) && defined(FEAT_TERMGUICOLORS) 1937 if (use_vtp()) 1938 { 1939 if (do_ME_fg && do_ME_bg) 1940 do_ME = TRUE; 1941 1942 // FG and BG cannot be separated in T_ME, which is not 1943 // efficient. 1944 if (!do_ME && do_ME_fg) 1945 out_str((char_u *)"\033|39m"); // restore FG 1946 if (!do_ME && do_ME_bg) 1947 out_str((char_u *)"\033|49m"); // restore BG 1948 } 1949 else 1950 { 1951 // Process FG and BG at once. 1952 if (!do_ME) 1953 do_ME = do_ME_fg | do_ME_bg; 1954 } 1955 #endif 1956 } 1957 else 1958 { 1959 aep = syn_term_attr2entry(screen_attr); 1960 if (aep != NULL && aep->ae_u.term.stop != NULL) 1961 { 1962 if (STRCMP(aep->ae_u.term.stop, T_ME) == 0) 1963 do_ME = TRUE; 1964 else 1965 out_str(aep->ae_u.term.stop); 1966 } 1967 } 1968 if (aep == NULL) // did ":syntax clear" 1969 screen_attr = 0; 1970 else 1971 screen_attr = aep->ae_attr; 1972 } 1973 1974 /* 1975 * Often all ending-codes are equal to T_ME. Avoid outputting the 1976 * same sequence several times. 1977 */ 1978 if (screen_attr & HL_STANDOUT) 1979 { 1980 if (STRCMP(T_SE, T_ME) == 0) 1981 do_ME = TRUE; 1982 else 1983 out_str(T_SE); 1984 } 1985 if ((screen_attr & HL_UNDERCURL) && *T_UCE != NUL) 1986 { 1987 if (STRCMP(T_UCE, T_ME) == 0) 1988 do_ME = TRUE; 1989 else 1990 out_str(T_UCE); 1991 } 1992 if ((screen_attr & HL_UNDERLINE) 1993 || ((screen_attr & HL_UNDERCURL) && *T_UCE == NUL)) 1994 { 1995 if (STRCMP(T_UE, T_ME) == 0) 1996 do_ME = TRUE; 1997 else 1998 out_str(T_UE); 1999 } 2000 if (screen_attr & HL_ITALIC) 2001 { 2002 if (STRCMP(T_CZR, T_ME) == 0) 2003 do_ME = TRUE; 2004 else 2005 out_str(T_CZR); 2006 } 2007 if (screen_attr & HL_STRIKETHROUGH) 2008 { 2009 if (STRCMP(T_STE, T_ME) == 0) 2010 do_ME = TRUE; 2011 else 2012 out_str(T_STE); 2013 } 2014 if (do_ME || (screen_attr & (HL_BOLD | HL_INVERSE))) 2015 out_str(T_ME); 2016 2017 #ifdef FEAT_TERMGUICOLORS 2018 if (p_tgc) 2019 { 2020 if (cterm_normal_fg_gui_color != INVALCOLOR) 2021 term_fg_rgb_color(cterm_normal_fg_gui_color); 2022 if (cterm_normal_bg_gui_color != INVALCOLOR) 2023 term_bg_rgb_color(cterm_normal_bg_gui_color); 2024 } 2025 else 2026 #endif 2027 { 2028 if (t_colors > 1) 2029 { 2030 // set Normal cterm colors 2031 if (cterm_normal_fg_color != 0) 2032 term_fg_color(cterm_normal_fg_color - 1); 2033 if (cterm_normal_bg_color != 0) 2034 term_bg_color(cterm_normal_bg_color - 1); 2035 if (cterm_normal_fg_bold) 2036 out_str(T_MD); 2037 } 2038 } 2039 } 2040 } 2041 screen_attr = 0; 2042 } 2043 2044 /* 2045 * Reset the colors for a cterm. Used when leaving Vim. 2046 * The machine specific code may override this again. 2047 */ 2048 void 2049 reset_cterm_colors(void) 2050 { 2051 if (IS_CTERM) 2052 { 2053 // set Normal cterm colors 2054 #ifdef FEAT_TERMGUICOLORS 2055 if (p_tgc ? (cterm_normal_fg_gui_color != INVALCOLOR 2056 || cterm_normal_bg_gui_color != INVALCOLOR) 2057 : (cterm_normal_fg_color > 0 || cterm_normal_bg_color > 0)) 2058 #else 2059 if (cterm_normal_fg_color > 0 || cterm_normal_bg_color > 0) 2060 #endif 2061 { 2062 out_str(T_OP); 2063 screen_attr = -1; 2064 } 2065 if (cterm_normal_fg_bold) 2066 { 2067 out_str(T_ME); 2068 screen_attr = -1; 2069 } 2070 } 2071 } 2072 2073 /* 2074 * Put character ScreenLines["off"] on the screen at position "row" and "col", 2075 * using the attributes from ScreenAttrs["off"]. 2076 */ 2077 void 2078 screen_char(unsigned off, int row, int col) 2079 { 2080 int attr; 2081 2082 // Check for illegal values, just in case (could happen just after 2083 // resizing). 2084 if (row >= screen_Rows || col >= screen_Columns) 2085 return; 2086 2087 // Skip if under the popup menu. 2088 // Popup windows with zindex higher than POPUPMENU_ZINDEX go on top. 2089 if (pum_under_menu(row, col) 2090 #ifdef FEAT_PROP_POPUP 2091 && screen_zindex <= POPUPMENU_ZINDEX 2092 #endif 2093 ) 2094 return; 2095 #ifdef FEAT_PROP_POPUP 2096 if (blocked_by_popup(row, col)) 2097 return; 2098 #endif 2099 2100 // Outputting a character in the last cell on the screen may scroll the 2101 // screen up. Only do it when the "xn" termcap property is set, otherwise 2102 // mark the character invalid (update it when scrolled up). 2103 if (*T_XN == NUL 2104 && row == screen_Rows - 1 && col == screen_Columns - 1 2105 #ifdef FEAT_RIGHTLEFT 2106 // account for first command-line character in rightleft mode 2107 && !cmdmsg_rl 2108 #endif 2109 ) 2110 { 2111 ScreenAttrs[off] = (sattr_T)-1; 2112 return; 2113 } 2114 2115 /* 2116 * Stop highlighting first, so it's easier to move the cursor. 2117 */ 2118 if (screen_char_attr != 0) 2119 attr = screen_char_attr; 2120 else 2121 attr = ScreenAttrs[off]; 2122 if (screen_attr != attr) 2123 screen_stop_highlight(); 2124 2125 windgoto(row, col); 2126 2127 if (screen_attr != attr) 2128 screen_start_highlight(attr); 2129 2130 if (enc_utf8 && ScreenLinesUC[off] != 0) 2131 { 2132 char_u buf[MB_MAXBYTES + 1]; 2133 2134 if (utf_ambiguous_width(ScreenLinesUC[off])) 2135 { 2136 if (*p_ambw == 'd' 2137 #ifdef FEAT_GUI 2138 && !gui.in_use 2139 #endif 2140 ) 2141 { 2142 // Clear the two screen cells. If the character is actually 2143 // single width it won't change the second cell. 2144 out_str((char_u *)" "); 2145 term_windgoto(row, col); 2146 } 2147 // not sure where the cursor is after drawing the ambiguous width 2148 // character 2149 screen_cur_col = 9999; 2150 } 2151 else if (utf_char2cells(ScreenLinesUC[off]) > 1) 2152 ++screen_cur_col; 2153 2154 // Convert the UTF-8 character to bytes and write it. 2155 buf[utfc_char2bytes(off, buf)] = NUL; 2156 out_str(buf); 2157 } 2158 else 2159 { 2160 out_flush_check(); 2161 out_char(ScreenLines[off]); 2162 // double-byte character in single-width cell 2163 if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e) 2164 out_char(ScreenLines2[off]); 2165 } 2166 2167 screen_cur_col++; 2168 } 2169 2170 /* 2171 * Used for enc_dbcs only: Put one double-wide character at ScreenLines["off"] 2172 * on the screen at position 'row' and 'col'. 2173 * The attributes of the first byte is used for all. This is required to 2174 * output the two bytes of a double-byte character with nothing in between. 2175 */ 2176 static void 2177 screen_char_2(unsigned off, int row, int col) 2178 { 2179 // Check for illegal values (could be wrong when screen was resized). 2180 if (off + 1 >= (unsigned)(screen_Rows * screen_Columns)) 2181 return; 2182 2183 // Outputting the last character on the screen may scrollup the screen. 2184 // Don't to it! Mark the character invalid (update it when scrolled up) 2185 if (row == screen_Rows - 1 && col >= screen_Columns - 2) 2186 { 2187 ScreenAttrs[off] = (sattr_T)-1; 2188 return; 2189 } 2190 2191 // Output the first byte normally (positions the cursor), then write the 2192 // second byte directly. 2193 screen_char(off, row, col); 2194 out_char(ScreenLines[off + 1]); 2195 ++screen_cur_col; 2196 } 2197 2198 /* 2199 * Draw a rectangle of the screen, inverted when "invert" is TRUE. 2200 * This uses the contents of ScreenLines[] and doesn't change it. 2201 */ 2202 void 2203 screen_draw_rectangle( 2204 int row, 2205 int col, 2206 int height, 2207 int width, 2208 int invert) 2209 { 2210 int r, c; 2211 int off; 2212 int max_off; 2213 2214 // Can't use ScreenLines unless initialized 2215 if (ScreenLines == NULL) 2216 return; 2217 2218 if (invert) 2219 screen_char_attr = HL_INVERSE; 2220 for (r = row; r < row + height; ++r) 2221 { 2222 off = LineOffset[r]; 2223 max_off = off + screen_Columns; 2224 for (c = col; c < col + width; ++c) 2225 { 2226 if (enc_dbcs != 0 && dbcs_off2cells(off + c, max_off) > 1) 2227 { 2228 screen_char_2(off + c, r, c); 2229 ++c; 2230 } 2231 else 2232 { 2233 screen_char(off + c, r, c); 2234 if (utf_off2cells(off + c, max_off) > 1) 2235 ++c; 2236 } 2237 } 2238 } 2239 screen_char_attr = 0; 2240 } 2241 2242 /* 2243 * Redraw the characters for a vertically split window. 2244 */ 2245 static void 2246 redraw_block(int row, int end, win_T *wp) 2247 { 2248 int col; 2249 int width; 2250 2251 # ifdef FEAT_CLIPBOARD 2252 clip_may_clear_selection(row, end - 1); 2253 # endif 2254 2255 if (wp == NULL) 2256 { 2257 col = 0; 2258 width = Columns; 2259 } 2260 else 2261 { 2262 col = wp->w_wincol; 2263 width = wp->w_width; 2264 } 2265 screen_draw_rectangle(row, col, end - row, width, FALSE); 2266 } 2267 2268 void 2269 space_to_screenline(int off, int attr) 2270 { 2271 ScreenLines[off] = ' '; 2272 ScreenAttrs[off] = attr; 2273 if (enc_utf8) 2274 ScreenLinesUC[off] = 0; 2275 } 2276 2277 /* 2278 * Fill the screen from 'start_row' to 'end_row', from 'start_col' to 'end_col' 2279 * with character 'c1' in first column followed by 'c2' in the other columns. 2280 * Use attributes 'attr'. 2281 */ 2282 void 2283 screen_fill( 2284 int start_row, 2285 int end_row, 2286 int start_col, 2287 int end_col, 2288 int c1, 2289 int c2, 2290 int attr) 2291 { 2292 int row; 2293 int col; 2294 int off; 2295 int end_off; 2296 int did_delete; 2297 int c; 2298 int norm_term; 2299 #if defined(FEAT_GUI) || defined(UNIX) 2300 int force_next = FALSE; 2301 #endif 2302 2303 if (end_row > screen_Rows) // safety check 2304 end_row = screen_Rows; 2305 if (end_col > screen_Columns) // safety check 2306 end_col = screen_Columns; 2307 if (ScreenLines == NULL 2308 || start_row >= end_row 2309 || start_col >= end_col) // nothing to do 2310 return; 2311 2312 // it's a "normal" terminal when not in a GUI or cterm 2313 norm_term = ( 2314 #ifdef FEAT_GUI 2315 !gui.in_use && 2316 #endif 2317 !IS_CTERM); 2318 for (row = start_row; row < end_row; ++row) 2319 { 2320 if (has_mbyte 2321 #ifdef FEAT_GUI 2322 && !gui.in_use 2323 #endif 2324 ) 2325 { 2326 // When drawing over the right halve of a double-wide char clear 2327 // out the left halve. When drawing over the left halve of a 2328 // double wide-char clear out the right halve. Only needed in a 2329 // terminal. 2330 if (start_col > 0 && mb_fix_col(start_col, row) != start_col) 2331 screen_puts_len((char_u *)" ", 1, row, start_col - 1, 0); 2332 if (end_col < screen_Columns && mb_fix_col(end_col, row) != end_col) 2333 screen_puts_len((char_u *)" ", 1, row, end_col, 0); 2334 } 2335 /* 2336 * Try to use delete-line termcap code, when no attributes or in a 2337 * "normal" terminal, where a bold/italic space is just a 2338 * space. 2339 */ 2340 did_delete = FALSE; 2341 if (c2 == ' ' 2342 && end_col == Columns 2343 && can_clear(T_CE) 2344 && (attr == 0 2345 || (norm_term 2346 && attr <= HL_ALL 2347 && ((attr & ~(HL_BOLD | HL_ITALIC)) == 0)))) 2348 { 2349 /* 2350 * check if we really need to clear something 2351 */ 2352 col = start_col; 2353 if (c1 != ' ') // don't clear first char 2354 ++col; 2355 2356 off = LineOffset[row] + col; 2357 end_off = LineOffset[row] + end_col; 2358 2359 // skip blanks (used often, keep it fast!) 2360 if (enc_utf8) 2361 while (off < end_off && ScreenLines[off] == ' ' 2362 && ScreenAttrs[off] == 0 && ScreenLinesUC[off] == 0) 2363 ++off; 2364 else 2365 while (off < end_off && ScreenLines[off] == ' ' 2366 && ScreenAttrs[off] == 0) 2367 ++off; 2368 if (off < end_off) // something to be cleared 2369 { 2370 col = off - LineOffset[row]; 2371 screen_stop_highlight(); 2372 term_windgoto(row, col);// clear rest of this screen line 2373 out_str(T_CE); 2374 screen_start(); // don't know where cursor is now 2375 col = end_col - col; 2376 while (col--) // clear chars in ScreenLines 2377 { 2378 space_to_screenline(off, 0); 2379 ++off; 2380 } 2381 } 2382 did_delete = TRUE; // the chars are cleared now 2383 } 2384 2385 off = LineOffset[row] + start_col; 2386 c = c1; 2387 for (col = start_col; col < end_col; ++col) 2388 { 2389 if ((ScreenLines[off] != c 2390 || (enc_utf8 && (int)ScreenLinesUC[off] 2391 != (c >= 0x80 ? c : 0)) 2392 || ScreenAttrs[off] != attr 2393 #if defined(FEAT_GUI) || defined(UNIX) 2394 || force_next 2395 #endif 2396 ) 2397 #ifdef FEAT_PROP_POPUP 2398 // Skip if under a(nother) popup. 2399 && !blocked_by_popup(row, col) 2400 #endif 2401 ) 2402 { 2403 #if defined(FEAT_GUI) || defined(UNIX) 2404 // The bold trick may make a single row of pixels appear in 2405 // the next character. When a bold character is removed, the 2406 // next character should be redrawn too. This happens for our 2407 // own GUI and for some xterms. 2408 if ( 2409 # ifdef FEAT_GUI 2410 gui.in_use 2411 # endif 2412 # if defined(FEAT_GUI) && defined(UNIX) 2413 || 2414 # endif 2415 # ifdef UNIX 2416 term_is_xterm 2417 # endif 2418 ) 2419 { 2420 if (ScreenLines[off] != ' ' 2421 && (ScreenAttrs[off] > HL_ALL 2422 || ScreenAttrs[off] & HL_BOLD)) 2423 force_next = TRUE; 2424 else 2425 force_next = FALSE; 2426 } 2427 #endif 2428 ScreenLines[off] = c; 2429 if (enc_utf8) 2430 { 2431 if (c >= 0x80) 2432 { 2433 ScreenLinesUC[off] = c; 2434 ScreenLinesC[0][off] = 0; 2435 } 2436 else 2437 ScreenLinesUC[off] = 0; 2438 } 2439 ScreenAttrs[off] = attr; 2440 if (!did_delete || c != ' ') 2441 screen_char(off, row, col); 2442 } 2443 ++off; 2444 if (col == start_col) 2445 { 2446 if (did_delete) 2447 break; 2448 c = c2; 2449 } 2450 } 2451 if (end_col == Columns) 2452 LineWraps[row] = FALSE; 2453 if (row == Rows - 1) // overwritten the command line 2454 { 2455 redraw_cmdline = TRUE; 2456 if (start_col == 0 && end_col == Columns 2457 && c1 == ' ' && c2 == ' ' && attr == 0) 2458 clear_cmdline = FALSE; // command line has been cleared 2459 if (start_col == 0) 2460 mode_displayed = FALSE; // mode cleared or overwritten 2461 } 2462 } 2463 } 2464 2465 /* 2466 * Check if there should be a delay. Used before clearing or redrawing the 2467 * screen or the command line. 2468 */ 2469 void 2470 check_for_delay(int check_msg_scroll) 2471 { 2472 if ((emsg_on_display || (check_msg_scroll && msg_scroll)) 2473 && !did_wait_return 2474 && emsg_silent == 0) 2475 { 2476 out_flush(); 2477 ui_delay(1006L, TRUE); 2478 emsg_on_display = FALSE; 2479 if (check_msg_scroll) 2480 msg_scroll = FALSE; 2481 } 2482 } 2483 2484 /* 2485 * Init TabPageIdxs[] to zero: Clicking outside of tabs has no effect. 2486 */ 2487 static void 2488 clear_TabPageIdxs(void) 2489 { 2490 int scol; 2491 2492 for (scol = 0; scol < Columns; ++scol) 2493 TabPageIdxs[scol] = 0; 2494 } 2495 2496 /* 2497 * screen_valid - allocate screen buffers if size changed 2498 * If "doclear" is TRUE: clear screen if it has been resized. 2499 * Returns TRUE if there is a valid screen to write to. 2500 * Returns FALSE when starting up and screen not initialized yet. 2501 */ 2502 int 2503 screen_valid(int doclear) 2504 { 2505 screenalloc(doclear); // allocate screen buffers if size changed 2506 return (ScreenLines != NULL); 2507 } 2508 2509 /* 2510 * Resize the shell to Rows and Columns. 2511 * Allocate ScreenLines[] and associated items. 2512 * 2513 * There may be some time between setting Rows and Columns and (re)allocating 2514 * ScreenLines[]. This happens when starting up and when (manually) changing 2515 * the shell size. Always use screen_Rows and screen_Columns to access items 2516 * in ScreenLines[]. Use Rows and Columns for positioning text etc. where the 2517 * final size of the shell is needed. 2518 */ 2519 void 2520 screenalloc(int doclear) 2521 { 2522 int new_row, old_row; 2523 #ifdef FEAT_GUI 2524 int old_Rows; 2525 #endif 2526 win_T *wp; 2527 int outofmem = FALSE; 2528 int len; 2529 schar_T *new_ScreenLines; 2530 u8char_T *new_ScreenLinesUC = NULL; 2531 u8char_T *new_ScreenLinesC[MAX_MCO]; 2532 schar_T *new_ScreenLines2 = NULL; 2533 int i; 2534 sattr_T *new_ScreenAttrs; 2535 unsigned *new_LineOffset; 2536 char_u *new_LineWraps; 2537 short *new_TabPageIdxs; 2538 #ifdef FEAT_PROP_POPUP 2539 short *new_popup_mask; 2540 short *new_popup_mask_next; 2541 char *new_popup_transparent; 2542 #endif 2543 tabpage_T *tp; 2544 static int entered = FALSE; // avoid recursiveness 2545 static int done_outofmem_msg = FALSE; // did outofmem message 2546 int retry_count = 0; 2547 2548 retry: 2549 /* 2550 * Allocation of the screen buffers is done only when the size changes and 2551 * when Rows and Columns have been set and we have started doing full 2552 * screen stuff. 2553 */ 2554 if ((ScreenLines != NULL 2555 && Rows == screen_Rows 2556 && Columns == screen_Columns 2557 && enc_utf8 == (ScreenLinesUC != NULL) 2558 && (enc_dbcs == DBCS_JPNU) == (ScreenLines2 != NULL) 2559 && p_mco == Screen_mco) 2560 || Rows == 0 2561 || Columns == 0 2562 || (!full_screen && ScreenLines == NULL)) 2563 return; 2564 2565 /* 2566 * It's possible that we produce an out-of-memory message below, which 2567 * will cause this function to be called again. To break the loop, just 2568 * return here. 2569 */ 2570 if (entered) 2571 return; 2572 entered = TRUE; 2573 2574 /* 2575 * Note that the window sizes are updated before reallocating the arrays, 2576 * thus we must not redraw here! 2577 */ 2578 ++RedrawingDisabled; 2579 2580 win_new_shellsize(); // fit the windows in the new sized shell 2581 2582 #ifdef FEAT_GUI_HAIKU 2583 vim_lock_screen(); // be safe, put it here 2584 #endif 2585 2586 comp_col(); // recompute columns for shown command and ruler 2587 2588 /* 2589 * We're changing the size of the screen. 2590 * - Allocate new arrays for ScreenLines and ScreenAttrs. 2591 * - Move lines from the old arrays into the new arrays, clear extra 2592 * lines (unless the screen is going to be cleared). 2593 * - Free the old arrays. 2594 * 2595 * If anything fails, make ScreenLines NULL, so we don't do anything! 2596 * Continuing with the old ScreenLines may result in a crash, because the 2597 * size is wrong. 2598 */ 2599 FOR_ALL_TAB_WINDOWS(tp, wp) 2600 win_free_lsize(wp); 2601 if (aucmd_win != NULL) 2602 win_free_lsize(aucmd_win); 2603 #ifdef FEAT_PROP_POPUP 2604 // global popup windows 2605 FOR_ALL_POPUPWINS(wp) 2606 win_free_lsize(wp); 2607 // tab-local popup windows 2608 FOR_ALL_TABPAGES(tp) 2609 FOR_ALL_POPUPWINS_IN_TAB(tp, wp) 2610 win_free_lsize(wp); 2611 #endif 2612 2613 new_ScreenLines = LALLOC_MULT(schar_T, (Rows + 1) * Columns); 2614 vim_memset(new_ScreenLinesC, 0, sizeof(u8char_T *) * MAX_MCO); 2615 if (enc_utf8) 2616 { 2617 new_ScreenLinesUC = LALLOC_MULT(u8char_T, (Rows + 1) * Columns); 2618 for (i = 0; i < p_mco; ++i) 2619 new_ScreenLinesC[i] = LALLOC_CLEAR_MULT(u8char_T, 2620 (Rows + 1) * Columns); 2621 } 2622 if (enc_dbcs == DBCS_JPNU) 2623 new_ScreenLines2 = LALLOC_MULT(schar_T, (Rows + 1) * Columns); 2624 new_ScreenAttrs = LALLOC_MULT(sattr_T, (Rows + 1) * Columns); 2625 new_LineOffset = LALLOC_MULT(unsigned, Rows); 2626 new_LineWraps = LALLOC_MULT(char_u, Rows); 2627 new_TabPageIdxs = LALLOC_MULT(short, Columns); 2628 #ifdef FEAT_PROP_POPUP 2629 new_popup_mask = LALLOC_MULT(short, Rows * Columns); 2630 new_popup_mask_next = LALLOC_MULT(short, Rows * Columns); 2631 new_popup_transparent = LALLOC_MULT(char, Rows * Columns); 2632 #endif 2633 2634 FOR_ALL_TAB_WINDOWS(tp, wp) 2635 { 2636 if (win_alloc_lines(wp) == FAIL) 2637 { 2638 outofmem = TRUE; 2639 goto give_up; 2640 } 2641 } 2642 if (aucmd_win != NULL && aucmd_win->w_lines == NULL 2643 && win_alloc_lines(aucmd_win) == FAIL) 2644 outofmem = TRUE; 2645 #ifdef FEAT_PROP_POPUP 2646 // global popup windows 2647 FOR_ALL_POPUPWINS(wp) 2648 if (win_alloc_lines(wp) == FAIL) 2649 { 2650 outofmem = TRUE; 2651 goto give_up; 2652 } 2653 // tab-local popup windows 2654 FOR_ALL_TABPAGES(tp) 2655 FOR_ALL_POPUPWINS_IN_TAB(tp, wp) 2656 if (win_alloc_lines(wp) == FAIL) 2657 { 2658 outofmem = TRUE; 2659 goto give_up; 2660 } 2661 #endif 2662 2663 give_up: 2664 2665 for (i = 0; i < p_mco; ++i) 2666 if (new_ScreenLinesC[i] == NULL) 2667 break; 2668 if (new_ScreenLines == NULL 2669 || (enc_utf8 && (new_ScreenLinesUC == NULL || i != p_mco)) 2670 || (enc_dbcs == DBCS_JPNU && new_ScreenLines2 == NULL) 2671 || new_ScreenAttrs == NULL 2672 || new_LineOffset == NULL 2673 || new_LineWraps == NULL 2674 || new_TabPageIdxs == NULL 2675 #ifdef FEAT_PROP_POPUP 2676 || new_popup_mask == NULL 2677 || new_popup_mask_next == NULL 2678 || new_popup_transparent == NULL 2679 #endif 2680 || outofmem) 2681 { 2682 if (ScreenLines != NULL || !done_outofmem_msg) 2683 { 2684 // guess the size 2685 do_outofmem_msg((long_u)((Rows + 1) * Columns)); 2686 2687 // Remember we did this to avoid getting outofmem messages over 2688 // and over again. 2689 done_outofmem_msg = TRUE; 2690 } 2691 VIM_CLEAR(new_ScreenLines); 2692 VIM_CLEAR(new_ScreenLinesUC); 2693 for (i = 0; i < p_mco; ++i) 2694 VIM_CLEAR(new_ScreenLinesC[i]); 2695 VIM_CLEAR(new_ScreenLines2); 2696 VIM_CLEAR(new_ScreenAttrs); 2697 VIM_CLEAR(new_LineOffset); 2698 VIM_CLEAR(new_LineWraps); 2699 VIM_CLEAR(new_TabPageIdxs); 2700 #ifdef FEAT_PROP_POPUP 2701 VIM_CLEAR(new_popup_mask); 2702 VIM_CLEAR(new_popup_mask_next); 2703 VIM_CLEAR(new_popup_transparent); 2704 #endif 2705 } 2706 else 2707 { 2708 done_outofmem_msg = FALSE; 2709 2710 for (new_row = 0; new_row < Rows; ++new_row) 2711 { 2712 new_LineOffset[new_row] = new_row * Columns; 2713 new_LineWraps[new_row] = FALSE; 2714 2715 /* 2716 * If the screen is not going to be cleared, copy as much as 2717 * possible from the old screen to the new one and clear the rest 2718 * (used when resizing the window at the "--more--" prompt or when 2719 * executing an external command, for the GUI). 2720 */ 2721 if (!doclear) 2722 { 2723 (void)vim_memset(new_ScreenLines + new_row * Columns, 2724 ' ', (size_t)Columns * sizeof(schar_T)); 2725 if (enc_utf8) 2726 { 2727 (void)vim_memset(new_ScreenLinesUC + new_row * Columns, 2728 0, (size_t)Columns * sizeof(u8char_T)); 2729 for (i = 0; i < p_mco; ++i) 2730 (void)vim_memset(new_ScreenLinesC[i] 2731 + new_row * Columns, 2732 0, (size_t)Columns * sizeof(u8char_T)); 2733 } 2734 if (enc_dbcs == DBCS_JPNU) 2735 (void)vim_memset(new_ScreenLines2 + new_row * Columns, 2736 0, (size_t)Columns * sizeof(schar_T)); 2737 (void)vim_memset(new_ScreenAttrs + new_row * Columns, 2738 0, (size_t)Columns * sizeof(sattr_T)); 2739 old_row = new_row + (screen_Rows - Rows); 2740 if (old_row >= 0 && ScreenLines != NULL) 2741 { 2742 if (screen_Columns < Columns) 2743 len = screen_Columns; 2744 else 2745 len = Columns; 2746 // When switching to utf-8 don't copy characters, they 2747 // may be invalid now. Also when p_mco changes. 2748 if (!(enc_utf8 && ScreenLinesUC == NULL) 2749 && p_mco == Screen_mco) 2750 mch_memmove(new_ScreenLines + new_LineOffset[new_row], 2751 ScreenLines + LineOffset[old_row], 2752 (size_t)len * sizeof(schar_T)); 2753 if (enc_utf8 && ScreenLinesUC != NULL 2754 && p_mco == Screen_mco) 2755 { 2756 mch_memmove(new_ScreenLinesUC + new_LineOffset[new_row], 2757 ScreenLinesUC + LineOffset[old_row], 2758 (size_t)len * sizeof(u8char_T)); 2759 for (i = 0; i < p_mco; ++i) 2760 mch_memmove(new_ScreenLinesC[i] 2761 + new_LineOffset[new_row], 2762 ScreenLinesC[i] + LineOffset[old_row], 2763 (size_t)len * sizeof(u8char_T)); 2764 } 2765 if (enc_dbcs == DBCS_JPNU && ScreenLines2 != NULL) 2766 mch_memmove(new_ScreenLines2 + new_LineOffset[new_row], 2767 ScreenLines2 + LineOffset[old_row], 2768 (size_t)len * sizeof(schar_T)); 2769 mch_memmove(new_ScreenAttrs + new_LineOffset[new_row], 2770 ScreenAttrs + LineOffset[old_row], 2771 (size_t)len * sizeof(sattr_T)); 2772 } 2773 } 2774 } 2775 // Use the last line of the screen for the current line. 2776 current_ScreenLine = new_ScreenLines + Rows * Columns; 2777 2778 #ifdef FEAT_PROP_POPUP 2779 vim_memset(new_popup_mask, 0, Rows * Columns * sizeof(short)); 2780 vim_memset(new_popup_transparent, 0, Rows * Columns * sizeof(char)); 2781 #endif 2782 } 2783 2784 free_screenlines(); 2785 2786 // NOTE: this may result in all pointers to become NULL. 2787 ScreenLines = new_ScreenLines; 2788 ScreenLinesUC = new_ScreenLinesUC; 2789 for (i = 0; i < p_mco; ++i) 2790 ScreenLinesC[i] = new_ScreenLinesC[i]; 2791 Screen_mco = p_mco; 2792 ScreenLines2 = new_ScreenLines2; 2793 ScreenAttrs = new_ScreenAttrs; 2794 LineOffset = new_LineOffset; 2795 LineWraps = new_LineWraps; 2796 TabPageIdxs = new_TabPageIdxs; 2797 #ifdef FEAT_PROP_POPUP 2798 popup_mask = new_popup_mask; 2799 popup_mask_next = new_popup_mask_next; 2800 popup_transparent = new_popup_transparent; 2801 popup_mask_refresh = TRUE; 2802 #endif 2803 2804 // It's important that screen_Rows and screen_Columns reflect the actual 2805 // size of ScreenLines[]. Set them before calling anything. 2806 #ifdef FEAT_GUI 2807 old_Rows = screen_Rows; 2808 #endif 2809 screen_Rows = Rows; 2810 screen_Columns = Columns; 2811 2812 must_redraw = CLEAR; // need to clear the screen later 2813 if (doclear) 2814 screenclear2(); 2815 #ifdef FEAT_GUI 2816 else if (gui.in_use 2817 && !gui.starting 2818 && ScreenLines != NULL 2819 && old_Rows != Rows) 2820 { 2821 gui_redraw_block(0, 0, (int)Rows - 1, (int)Columns - 1, 0); 2822 2823 // Adjust the position of the cursor, for when executing an external 2824 // command. 2825 if (msg_row >= Rows) // Rows got smaller 2826 msg_row = Rows - 1; // put cursor at last row 2827 else if (Rows > old_Rows) // Rows got bigger 2828 msg_row += Rows - old_Rows; // put cursor in same place 2829 if (msg_col >= Columns) // Columns got smaller 2830 msg_col = Columns - 1; // put cursor at last column 2831 } 2832 #endif 2833 clear_TabPageIdxs(); 2834 2835 #ifdef FEAT_GUI_HAIKU 2836 vim_unlock_screen(); 2837 #endif 2838 2839 entered = FALSE; 2840 --RedrawingDisabled; 2841 2842 /* 2843 * Do not apply autocommands more than 3 times to avoid an endless loop 2844 * in case applying autocommands always changes Rows or Columns. 2845 */ 2846 if (starting == 0 && ++retry_count <= 3) 2847 { 2848 apply_autocmds(EVENT_VIMRESIZED, NULL, NULL, FALSE, curbuf); 2849 // In rare cases, autocommands may have altered Rows or Columns, 2850 // jump back to check if we need to allocate the screen again. 2851 goto retry; 2852 } 2853 } 2854 2855 void 2856 free_screenlines(void) 2857 { 2858 int i; 2859 2860 VIM_CLEAR(ScreenLinesUC); 2861 for (i = 0; i < Screen_mco; ++i) 2862 VIM_CLEAR(ScreenLinesC[i]); 2863 VIM_CLEAR(ScreenLines2); 2864 VIM_CLEAR(ScreenLines); 2865 VIM_CLEAR(ScreenAttrs); 2866 VIM_CLEAR(LineOffset); 2867 VIM_CLEAR(LineWraps); 2868 VIM_CLEAR(TabPageIdxs); 2869 #ifdef FEAT_PROP_POPUP 2870 VIM_CLEAR(popup_mask); 2871 VIM_CLEAR(popup_mask_next); 2872 VIM_CLEAR(popup_transparent); 2873 #endif 2874 } 2875 2876 void 2877 screenclear(void) 2878 { 2879 check_for_delay(FALSE); 2880 screenalloc(FALSE); // allocate screen buffers if size changed 2881 screenclear2(); // clear the screen 2882 } 2883 2884 static void 2885 screenclear2(void) 2886 { 2887 int i; 2888 2889 if (starting == NO_SCREEN || ScreenLines == NULL 2890 #ifdef FEAT_GUI 2891 || (gui.in_use && gui.starting) 2892 #endif 2893 ) 2894 return; 2895 2896 #ifdef FEAT_GUI 2897 if (!gui.in_use) 2898 #endif 2899 screen_attr = -1; // force setting the Normal colors 2900 screen_stop_highlight(); // don't want highlighting here 2901 2902 #ifdef FEAT_CLIPBOARD 2903 // disable selection without redrawing it 2904 clip_scroll_selection(9999); 2905 #endif 2906 2907 // blank out ScreenLines 2908 for (i = 0; i < Rows; ++i) 2909 { 2910 lineclear(LineOffset[i], (int)Columns, 0); 2911 LineWraps[i] = FALSE; 2912 } 2913 2914 if (can_clear(T_CL)) 2915 { 2916 out_str(T_CL); // clear the display 2917 clear_cmdline = FALSE; 2918 mode_displayed = FALSE; 2919 } 2920 else 2921 { 2922 // can't clear the screen, mark all chars with invalid attributes 2923 for (i = 0; i < Rows; ++i) 2924 lineinvalid(LineOffset[i], (int)Columns); 2925 clear_cmdline = TRUE; 2926 } 2927 2928 screen_cleared = TRUE; // can use contents of ScreenLines now 2929 2930 win_rest_invalid(firstwin); 2931 redraw_cmdline = TRUE; 2932 redraw_tabline = TRUE; 2933 if (must_redraw == CLEAR) // no need to clear again 2934 must_redraw = NOT_VALID; 2935 compute_cmdrow(); 2936 msg_row = cmdline_row; // put cursor on last line for messages 2937 msg_col = 0; 2938 screen_start(); // don't know where cursor is now 2939 msg_scrolled = 0; // can't scroll back 2940 msg_didany = FALSE; 2941 msg_didout = FALSE; 2942 } 2943 2944 /* 2945 * Clear one line in ScreenLines. 2946 */ 2947 static void 2948 lineclear(unsigned off, int width, int attr) 2949 { 2950 (void)vim_memset(ScreenLines + off, ' ', (size_t)width * sizeof(schar_T)); 2951 if (enc_utf8) 2952 (void)vim_memset(ScreenLinesUC + off, 0, 2953 (size_t)width * sizeof(u8char_T)); 2954 (void)vim_memset(ScreenAttrs + off, attr, (size_t)width * sizeof(sattr_T)); 2955 } 2956 2957 /* 2958 * Mark one line in ScreenLines invalid by setting the attributes to an 2959 * invalid value. 2960 */ 2961 static void 2962 lineinvalid(unsigned off, int width) 2963 { 2964 (void)vim_memset(ScreenAttrs + off, -1, (size_t)width * sizeof(sattr_T)); 2965 } 2966 2967 /* 2968 * Copy part of a Screenline for vertically split window "wp". 2969 */ 2970 static void 2971 linecopy(int to, int from, win_T *wp) 2972 { 2973 unsigned off_to = LineOffset[to] + wp->w_wincol; 2974 unsigned off_from = LineOffset[from] + wp->w_wincol; 2975 2976 mch_memmove(ScreenLines + off_to, ScreenLines + off_from, 2977 wp->w_width * sizeof(schar_T)); 2978 if (enc_utf8) 2979 { 2980 int i; 2981 2982 mch_memmove(ScreenLinesUC + off_to, ScreenLinesUC + off_from, 2983 wp->w_width * sizeof(u8char_T)); 2984 for (i = 0; i < p_mco; ++i) 2985 mch_memmove(ScreenLinesC[i] + off_to, ScreenLinesC[i] + off_from, 2986 wp->w_width * sizeof(u8char_T)); 2987 } 2988 if (enc_dbcs == DBCS_JPNU) 2989 mch_memmove(ScreenLines2 + off_to, ScreenLines2 + off_from, 2990 wp->w_width * sizeof(schar_T)); 2991 mch_memmove(ScreenAttrs + off_to, ScreenAttrs + off_from, 2992 wp->w_width * sizeof(sattr_T)); 2993 } 2994 2995 /* 2996 * Return TRUE if clearing with term string "p" would work. 2997 * It can't work when the string is empty or it won't set the right background. 2998 * Don't clear to end-of-line when there are popups, it may cause flicker. 2999 */ 3000 int 3001 can_clear(char_u *p) 3002 { 3003 return (*p != NUL && (t_colors <= 1 3004 #ifdef FEAT_GUI 3005 || gui.in_use 3006 #endif 3007 #ifdef FEAT_TERMGUICOLORS 3008 || (p_tgc && cterm_normal_bg_gui_color == INVALCOLOR) 3009 || (!p_tgc && cterm_normal_bg_color == 0) 3010 #else 3011 || cterm_normal_bg_color == 0 3012 #endif 3013 || *T_UT != NUL) 3014 #ifdef FEAT_PROP_POPUP 3015 && !(p == T_CE && popup_visible) 3016 #endif 3017 ); 3018 } 3019 3020 /* 3021 * Reset cursor position. Use whenever cursor was moved because of outputting 3022 * something directly to the screen (shell commands) or a terminal control 3023 * code. 3024 */ 3025 void 3026 screen_start(void) 3027 { 3028 screen_cur_row = screen_cur_col = 9999; 3029 } 3030 3031 /* 3032 * Move the cursor to position "row","col" in the screen. 3033 * This tries to find the most efficient way to move, minimizing the number of 3034 * characters sent to the terminal. 3035 */ 3036 void 3037 windgoto(int row, int col) 3038 { 3039 sattr_T *p; 3040 int i; 3041 int plan; 3042 int cost; 3043 int wouldbe_col; 3044 int noinvcurs; 3045 char_u *bs; 3046 int goto_cost; 3047 int attr; 3048 3049 #define GOTO_COST 7 // assume a term_windgoto() takes about 7 chars 3050 #define HIGHL_COST 5 // assume unhighlight takes 5 chars 3051 3052 #define PLAN_LE 1 3053 #define PLAN_CR 2 3054 #define PLAN_NL 3 3055 #define PLAN_WRITE 4 3056 // Can't use ScreenLines unless initialized 3057 if (ScreenLines == NULL) 3058 return; 3059 3060 if (col != screen_cur_col || row != screen_cur_row) 3061 { 3062 // Check for valid position. 3063 if (row < 0) // window without text lines? 3064 row = 0; 3065 if (row >= screen_Rows) 3066 row = screen_Rows - 1; 3067 if (col >= screen_Columns) 3068 col = screen_Columns - 1; 3069 3070 // check if no cursor movement is allowed in highlight mode 3071 if (screen_attr && *T_MS == NUL) 3072 noinvcurs = HIGHL_COST; 3073 else 3074 noinvcurs = 0; 3075 goto_cost = GOTO_COST + noinvcurs; 3076 3077 /* 3078 * Plan how to do the positioning: 3079 * 1. Use CR to move it to column 0, same row. 3080 * 2. Use T_LE to move it a few columns to the left. 3081 * 3. Use NL to move a few lines down, column 0. 3082 * 4. Move a few columns to the right with T_ND or by writing chars. 3083 * 3084 * Don't do this if the cursor went beyond the last column, the cursor 3085 * position is unknown then (some terminals wrap, some don't ) 3086 * 3087 * First check if the highlighting attributes allow us to write 3088 * characters to move the cursor to the right. 3089 */ 3090 if (row >= screen_cur_row && screen_cur_col < Columns) 3091 { 3092 /* 3093 * If the cursor is in the same row, bigger col, we can use CR 3094 * or T_LE. 3095 */ 3096 bs = NULL; // init for GCC 3097 attr = screen_attr; 3098 if (row == screen_cur_row && col < screen_cur_col) 3099 { 3100 // "le" is preferred over "bc", because "bc" is obsolete 3101 if (*T_LE) 3102 bs = T_LE; // "cursor left" 3103 else 3104 bs = T_BC; // "backspace character (old) 3105 if (*bs) 3106 cost = (screen_cur_col - col) * (int)STRLEN(bs); 3107 else 3108 cost = 999; 3109 if (col + 1 < cost) // using CR is less characters 3110 { 3111 plan = PLAN_CR; 3112 wouldbe_col = 0; 3113 cost = 1; // CR is just one character 3114 } 3115 else 3116 { 3117 plan = PLAN_LE; 3118 wouldbe_col = col; 3119 } 3120 if (noinvcurs) // will stop highlighting 3121 { 3122 cost += noinvcurs; 3123 attr = 0; 3124 } 3125 } 3126 3127 /* 3128 * If the cursor is above where we want to be, we can use CR LF. 3129 */ 3130 else if (row > screen_cur_row) 3131 { 3132 plan = PLAN_NL; 3133 wouldbe_col = 0; 3134 cost = (row - screen_cur_row) * 2; // CR LF 3135 if (noinvcurs) // will stop highlighting 3136 { 3137 cost += noinvcurs; 3138 attr = 0; 3139 } 3140 } 3141 3142 /* 3143 * If the cursor is in the same row, smaller col, just use write. 3144 */ 3145 else 3146 { 3147 plan = PLAN_WRITE; 3148 wouldbe_col = screen_cur_col; 3149 cost = 0; 3150 } 3151 3152 /* 3153 * Check if any characters that need to be written have the 3154 * correct attributes. Also avoid UTF-8 characters. 3155 */ 3156 i = col - wouldbe_col; 3157 if (i > 0) 3158 cost += i; 3159 if (cost < goto_cost && i > 0) 3160 { 3161 /* 3162 * Check if the attributes are correct without additionally 3163 * stopping highlighting. 3164 */ 3165 p = ScreenAttrs + LineOffset[row] + wouldbe_col; 3166 while (i && *p++ == attr) 3167 --i; 3168 if (i != 0) 3169 { 3170 /* 3171 * Try if it works when highlighting is stopped here. 3172 */ 3173 if (*--p == 0) 3174 { 3175 cost += noinvcurs; 3176 while (i && *p++ == 0) 3177 --i; 3178 } 3179 if (i != 0) 3180 cost = 999; // different attributes, don't do it 3181 } 3182 if (enc_utf8) 3183 { 3184 // Don't use an UTF-8 char for positioning, it's slow. 3185 for (i = wouldbe_col; i < col; ++i) 3186 if (ScreenLinesUC[LineOffset[row] + i] != 0) 3187 { 3188 cost = 999; 3189 break; 3190 } 3191 } 3192 } 3193 3194 /* 3195 * We can do it without term_windgoto()! 3196 */ 3197 if (cost < goto_cost) 3198 { 3199 if (plan == PLAN_LE) 3200 { 3201 if (noinvcurs) 3202 screen_stop_highlight(); 3203 while (screen_cur_col > col) 3204 { 3205 out_str(bs); 3206 --screen_cur_col; 3207 } 3208 } 3209 else if (plan == PLAN_CR) 3210 { 3211 if (noinvcurs) 3212 screen_stop_highlight(); 3213 out_char('\r'); 3214 screen_cur_col = 0; 3215 } 3216 else if (plan == PLAN_NL) 3217 { 3218 if (noinvcurs) 3219 screen_stop_highlight(); 3220 while (screen_cur_row < row) 3221 { 3222 out_char('\n'); 3223 ++screen_cur_row; 3224 } 3225 screen_cur_col = 0; 3226 } 3227 3228 i = col - screen_cur_col; 3229 if (i > 0) 3230 { 3231 /* 3232 * Use cursor-right if it's one character only. Avoids 3233 * removing a line of pixels from the last bold char, when 3234 * using the bold trick in the GUI. 3235 */ 3236 if (T_ND[0] != NUL && T_ND[1] == NUL) 3237 { 3238 while (i-- > 0) 3239 out_char(*T_ND); 3240 } 3241 else 3242 { 3243 int off; 3244 3245 off = LineOffset[row] + screen_cur_col; 3246 while (i-- > 0) 3247 { 3248 if (ScreenAttrs[off] != screen_attr) 3249 screen_stop_highlight(); 3250 out_flush_check(); 3251 out_char(ScreenLines[off]); 3252 if (enc_dbcs == DBCS_JPNU 3253 && ScreenLines[off] == 0x8e) 3254 out_char(ScreenLines2[off]); 3255 ++off; 3256 } 3257 } 3258 } 3259 } 3260 } 3261 else 3262 cost = 999; 3263 3264 if (cost >= goto_cost) 3265 { 3266 if (noinvcurs) 3267 screen_stop_highlight(); 3268 if (row == screen_cur_row && (col > screen_cur_col) 3269 && *T_CRI != NUL) 3270 term_cursor_right(col - screen_cur_col); 3271 else 3272 term_windgoto(row, col); 3273 } 3274 screen_cur_row = row; 3275 screen_cur_col = col; 3276 } 3277 } 3278 3279 /* 3280 * Set cursor to its position in the current window. 3281 */ 3282 void 3283 setcursor(void) 3284 { 3285 setcursor_mayforce(FALSE); 3286 } 3287 3288 /* 3289 * Set cursor to its position in the current window. 3290 * When "force" is TRUE also when not redrawing. 3291 */ 3292 void 3293 setcursor_mayforce(int force) 3294 { 3295 if (force || redrawing()) 3296 { 3297 validate_cursor(); 3298 windgoto(W_WINROW(curwin) + curwin->w_wrow, 3299 curwin->w_wincol + ( 3300 #ifdef FEAT_RIGHTLEFT 3301 // With 'rightleft' set and the cursor on a double-wide 3302 // character, position it on the leftmost column. 3303 curwin->w_p_rl ? ((int)curwin->w_width - curwin->w_wcol 3304 - ((has_mbyte 3305 && (*mb_ptr2cells)(ml_get_cursor()) == 2 3306 && vim_isprintc(gchar_cursor())) ? 2 : 1)) : 3307 #endif 3308 curwin->w_wcol)); 3309 } 3310 } 3311 3312 3313 /* 3314 * Insert 'line_count' lines at 'row' in window 'wp'. 3315 * If 'invalid' is TRUE the wp->w_lines[].wl_lnum is invalidated. 3316 * If 'mayclear' is TRUE the screen will be cleared if it is faster than 3317 * scrolling. 3318 * Returns FAIL if the lines are not inserted, OK for success. 3319 */ 3320 int 3321 win_ins_lines( 3322 win_T *wp, 3323 int row, 3324 int line_count, 3325 int invalid, 3326 int mayclear) 3327 { 3328 int did_delete; 3329 int nextrow; 3330 int lastrow; 3331 int retval; 3332 3333 if (invalid) 3334 wp->w_lines_valid = 0; 3335 3336 if (wp->w_height < 5) 3337 return FAIL; 3338 3339 if (line_count > wp->w_height - row) 3340 line_count = wp->w_height - row; 3341 3342 retval = win_do_lines(wp, row, line_count, mayclear, FALSE, 0); 3343 if (retval != MAYBE) 3344 return retval; 3345 3346 /* 3347 * If there is a next window or a status line, we first try to delete the 3348 * lines at the bottom to avoid messing what is after the window. 3349 * If this fails and there are following windows, don't do anything to 3350 * avoid messing up those windows, better just redraw. 3351 */ 3352 did_delete = FALSE; 3353 if (wp->w_next != NULL || wp->w_status_height) 3354 { 3355 if (screen_del_lines(0, W_WINROW(wp) + wp->w_height - line_count, 3356 line_count, (int)Rows, FALSE, 0, NULL) == OK) 3357 did_delete = TRUE; 3358 else if (wp->w_next) 3359 return FAIL; 3360 } 3361 /* 3362 * if no lines deleted, blank the lines that will end up below the window 3363 */ 3364 if (!did_delete) 3365 { 3366 wp->w_redr_status = TRUE; 3367 redraw_cmdline = TRUE; 3368 nextrow = W_WINROW(wp) + wp->w_height + wp->w_status_height; 3369 lastrow = nextrow + line_count; 3370 if (lastrow > Rows) 3371 lastrow = Rows; 3372 screen_fill(nextrow - line_count, lastrow - line_count, 3373 wp->w_wincol, (int)W_ENDCOL(wp), 3374 ' ', ' ', 0); 3375 } 3376 3377 if (screen_ins_lines(0, W_WINROW(wp) + row, line_count, (int)Rows, 0, NULL) 3378 == FAIL) 3379 { 3380 // deletion will have messed up other windows 3381 if (did_delete) 3382 { 3383 wp->w_redr_status = TRUE; 3384 win_rest_invalid(W_NEXT(wp)); 3385 } 3386 return FAIL; 3387 } 3388 3389 return OK; 3390 } 3391 3392 /* 3393 * Delete "line_count" window lines at "row" in window "wp". 3394 * If "invalid" is TRUE curwin->w_lines[] is invalidated. 3395 * If "mayclear" is TRUE the screen will be cleared if it is faster than 3396 * scrolling 3397 * Return OK for success, FAIL if the lines are not deleted. 3398 */ 3399 int 3400 win_del_lines( 3401 win_T *wp, 3402 int row, 3403 int line_count, 3404 int invalid, 3405 int mayclear, 3406 int clear_attr) // for clearing lines 3407 { 3408 int retval; 3409 3410 if (invalid) 3411 wp->w_lines_valid = 0; 3412 3413 if (line_count > wp->w_height - row) 3414 line_count = wp->w_height - row; 3415 3416 retval = win_do_lines(wp, row, line_count, mayclear, TRUE, clear_attr); 3417 if (retval != MAYBE) 3418 return retval; 3419 3420 if (screen_del_lines(0, W_WINROW(wp) + row, line_count, 3421 (int)Rows, FALSE, clear_attr, NULL) == FAIL) 3422 return FAIL; 3423 3424 /* 3425 * If there are windows or status lines below, try to put them at the 3426 * correct place. If we can't do that, they have to be redrawn. 3427 */ 3428 if (wp->w_next || wp->w_status_height || cmdline_row < Rows - 1) 3429 { 3430 if (screen_ins_lines(0, W_WINROW(wp) + wp->w_height - line_count, 3431 line_count, (int)Rows, clear_attr, NULL) == FAIL) 3432 { 3433 wp->w_redr_status = TRUE; 3434 win_rest_invalid(wp->w_next); 3435 } 3436 } 3437 /* 3438 * If this is the last window and there is no status line, redraw the 3439 * command line later. 3440 */ 3441 else 3442 redraw_cmdline = TRUE; 3443 return OK; 3444 } 3445 3446 /* 3447 * Common code for win_ins_lines() and win_del_lines(). 3448 * Returns OK or FAIL when the work has been done. 3449 * Returns MAYBE when not finished yet. 3450 */ 3451 static int 3452 win_do_lines( 3453 win_T *wp, 3454 int row, 3455 int line_count, 3456 int mayclear, 3457 int del, 3458 int clear_attr) 3459 { 3460 int retval; 3461 3462 if (!redrawing() || line_count <= 0) 3463 return FAIL; 3464 3465 // When inserting lines would result in loss of command output, just redraw 3466 // the lines. 3467 if (no_win_do_lines_ins && !del) 3468 return FAIL; 3469 3470 // only a few lines left: redraw is faster 3471 if (mayclear && Rows - line_count < 5 && wp->w_width == Columns) 3472 { 3473 if (!no_win_do_lines_ins) 3474 screenclear(); // will set wp->w_lines_valid to 0 3475 return FAIL; 3476 } 3477 3478 #ifdef FEAT_PROP_POPUP 3479 // this doesn't work when there are popups visible 3480 if (popup_visible) 3481 return FAIL; 3482 #endif 3483 3484 // Delete all remaining lines 3485 if (row + line_count >= wp->w_height) 3486 { 3487 screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + wp->w_height, 3488 wp->w_wincol, (int)W_ENDCOL(wp), 3489 ' ', ' ', 0); 3490 return OK; 3491 } 3492 3493 /* 3494 * When scrolling, the message on the command line should be cleared, 3495 * otherwise it will stay there forever. 3496 * Don't do this when avoiding to insert lines. 3497 */ 3498 if (!no_win_do_lines_ins) 3499 clear_cmdline = TRUE; 3500 3501 /* 3502 * If the terminal can set a scroll region, use that. 3503 * Always do this in a vertically split window. This will redraw from 3504 * ScreenLines[] when t_CV isn't defined. That's faster than using 3505 * win_line(). 3506 * Don't use a scroll region when we are going to redraw the text, writing 3507 * a character in the lower right corner of the scroll region may cause a 3508 * scroll-up . 3509 */ 3510 if (scroll_region || wp->w_width != Columns) 3511 { 3512 if (scroll_region && (wp->w_width == Columns || *T_CSV != NUL)) 3513 scroll_region_set(wp, row); 3514 if (del) 3515 retval = screen_del_lines(W_WINROW(wp) + row, 0, line_count, 3516 wp->w_height - row, FALSE, clear_attr, wp); 3517 else 3518 retval = screen_ins_lines(W_WINROW(wp) + row, 0, line_count, 3519 wp->w_height - row, clear_attr, wp); 3520 if (scroll_region && (wp->w_width == Columns || *T_CSV != NUL)) 3521 scroll_region_reset(); 3522 return retval; 3523 } 3524 3525 if (wp->w_next != NULL && p_tf) // don't delete/insert on fast terminal 3526 return FAIL; 3527 3528 return MAYBE; 3529 } 3530 3531 /* 3532 * window 'wp' and everything after it is messed up, mark it for redraw 3533 */ 3534 static void 3535 win_rest_invalid(win_T *wp) 3536 { 3537 while (wp != NULL) 3538 { 3539 redraw_win_later(wp, NOT_VALID); 3540 wp->w_redr_status = TRUE; 3541 wp = wp->w_next; 3542 } 3543 redraw_cmdline = TRUE; 3544 } 3545 3546 /* 3547 * The rest of the routines in this file perform screen manipulations. The 3548 * given operation is performed physically on the screen. The corresponding 3549 * change is also made to the internal screen image. In this way, the editor 3550 * anticipates the effect of editing changes on the appearance of the screen. 3551 * That way, when we call screenupdate a complete redraw isn't usually 3552 * necessary. Another advantage is that we can keep adding code to anticipate 3553 * screen changes, and in the meantime, everything still works. 3554 */ 3555 3556 /* 3557 * types for inserting or deleting lines 3558 */ 3559 #define USE_T_CAL 1 3560 #define USE_T_CDL 2 3561 #define USE_T_AL 3 3562 #define USE_T_CE 4 3563 #define USE_T_DL 5 3564 #define USE_T_SR 6 3565 #define USE_NL 7 3566 #define USE_T_CD 8 3567 #define USE_REDRAW 9 3568 3569 /* 3570 * insert lines on the screen and update ScreenLines[] 3571 * 'end' is the line after the scrolled part. Normally it is Rows. 3572 * When scrolling region used 'off' is the offset from the top for the region. 3573 * 'row' and 'end' are relative to the start of the region. 3574 * 3575 * return FAIL for failure, OK for success. 3576 */ 3577 int 3578 screen_ins_lines( 3579 int off, 3580 int row, 3581 int line_count, 3582 int end, 3583 int clear_attr, 3584 win_T *wp) // NULL or window to use width from 3585 { 3586 int i; 3587 int j; 3588 unsigned temp; 3589 int cursor_row; 3590 int cursor_col = 0; 3591 int type; 3592 int result_empty; 3593 int can_ce = can_clear(T_CE); 3594 3595 /* 3596 * FAIL if 3597 * - there is no valid screen 3598 * - the screen has to be redrawn completely 3599 * - the line count is less than one 3600 * - the line count is more than 'ttyscroll' 3601 * - redrawing for a callback and there is a modeless selection 3602 * - there is a popup window 3603 */ 3604 if (!screen_valid(TRUE) 3605 || line_count <= 0 || line_count > p_ttyscroll 3606 #ifdef FEAT_CLIPBOARD 3607 || (clip_star.state != SELECT_CLEARED 3608 && redrawing_for_callback > 0) 3609 #endif 3610 #ifdef FEAT_PROP_POPUP 3611 || popup_visible 3612 #endif 3613 ) 3614 return FAIL; 3615 3616 /* 3617 * There are seven ways to insert lines: 3618 * 0. When in a vertically split window and t_CV isn't set, redraw the 3619 * characters from ScreenLines[]. 3620 * 1. Use T_CD (clear to end of display) if it exists and the result of 3621 * the insert is just empty lines 3622 * 2. Use T_CAL (insert multiple lines) if it exists and T_AL is not 3623 * present or line_count > 1. It looks better if we do all the inserts 3624 * at once. 3625 * 3. Use T_CDL (delete multiple lines) if it exists and the result of the 3626 * insert is just empty lines and T_CE is not present or line_count > 3627 * 1. 3628 * 4. Use T_AL (insert line) if it exists. 3629 * 5. Use T_CE (erase line) if it exists and the result of the insert is 3630 * just empty lines. 3631 * 6. Use T_DL (delete line) if it exists and the result of the insert is 3632 * just empty lines. 3633 * 7. Use T_SR (scroll reverse) if it exists and inserting at row 0 and 3634 * the 'da' flag is not set or we have clear line capability. 3635 * 8. redraw the characters from ScreenLines[]. 3636 * 3637 * Careful: In a hpterm scroll reverse doesn't work as expected, it moves 3638 * the scrollbar for the window. It does have insert line, use that if it 3639 * exists. 3640 */ 3641 result_empty = (row + line_count >= end); 3642 if (wp != NULL && wp->w_width != Columns && *T_CSV == NUL) 3643 type = USE_REDRAW; 3644 else if (can_clear(T_CD) && result_empty) 3645 type = USE_T_CD; 3646 else if (*T_CAL != NUL && (line_count > 1 || *T_AL == NUL)) 3647 type = USE_T_CAL; 3648 else if (*T_CDL != NUL && result_empty && (line_count > 1 || !can_ce)) 3649 type = USE_T_CDL; 3650 else if (*T_AL != NUL) 3651 type = USE_T_AL; 3652 else if (can_ce && result_empty) 3653 type = USE_T_CE; 3654 else if (*T_DL != NUL && result_empty) 3655 type = USE_T_DL; 3656 else if (*T_SR != NUL && row == 0 && (*T_DA == NUL || can_ce)) 3657 type = USE_T_SR; 3658 else 3659 return FAIL; 3660 3661 /* 3662 * For clearing the lines screen_del_lines() is used. This will also take 3663 * care of t_db if necessary. 3664 */ 3665 if (type == USE_T_CD || type == USE_T_CDL || 3666 type == USE_T_CE || type == USE_T_DL) 3667 return screen_del_lines(off, row, line_count, end, FALSE, 0, wp); 3668 3669 /* 3670 * If text is retained below the screen, first clear or delete as many 3671 * lines at the bottom of the window as are about to be inserted so that 3672 * the deleted lines won't later surface during a screen_del_lines. 3673 */ 3674 if (*T_DB) 3675 screen_del_lines(off, end - line_count, line_count, end, FALSE, 0, wp); 3676 3677 #ifdef FEAT_CLIPBOARD 3678 // Remove a modeless selection when inserting lines halfway the screen 3679 // or not the full width of the screen. 3680 if (off + row > 0 || (wp != NULL && wp->w_width != Columns)) 3681 clip_clear_selection(&clip_star); 3682 else 3683 clip_scroll_selection(-line_count); 3684 #endif 3685 3686 #ifdef FEAT_GUI_HAIKU 3687 vim_lock_screen(); 3688 #endif 3689 3690 #ifdef FEAT_GUI 3691 // Don't update the GUI cursor here, ScreenLines[] is invalid until the 3692 // scrolling is actually carried out. 3693 gui_dont_update_cursor(row + off <= gui.cursor_row); 3694 #endif 3695 3696 if (wp != NULL && wp->w_wincol != 0 && *T_CSV != NUL && *T_CCS == NUL) 3697 cursor_col = wp->w_wincol; 3698 3699 if (*T_CCS != NUL) // cursor relative to region 3700 cursor_row = row; 3701 else 3702 cursor_row = row + off; 3703 3704 /* 3705 * Shift LineOffset[] line_count down to reflect the inserted lines. 3706 * Clear the inserted lines in ScreenLines[]. 3707 */ 3708 row += off; 3709 end += off; 3710 for (i = 0; i < line_count; ++i) 3711 { 3712 if (wp != NULL && wp->w_width != Columns) 3713 { 3714 // need to copy part of a line 3715 j = end - 1 - i; 3716 while ((j -= line_count) >= row) 3717 linecopy(j + line_count, j, wp); 3718 j += line_count; 3719 if (can_clear((char_u *)" ")) 3720 lineclear(LineOffset[j] + wp->w_wincol, wp->w_width, 3721 clear_attr); 3722 else 3723 lineinvalid(LineOffset[j] + wp->w_wincol, wp->w_width); 3724 LineWraps[j] = FALSE; 3725 } 3726 else 3727 { 3728 j = end - 1 - i; 3729 temp = LineOffset[j]; 3730 while ((j -= line_count) >= row) 3731 { 3732 LineOffset[j + line_count] = LineOffset[j]; 3733 LineWraps[j + line_count] = LineWraps[j]; 3734 } 3735 LineOffset[j + line_count] = temp; 3736 LineWraps[j + line_count] = FALSE; 3737 if (can_clear((char_u *)" ")) 3738 lineclear(temp, (int)Columns, clear_attr); 3739 else 3740 lineinvalid(temp, (int)Columns); 3741 } 3742 } 3743 3744 #ifdef FEAT_GUI_HAIKU 3745 vim_unlock_screen(); 3746 #endif 3747 3748 screen_stop_highlight(); 3749 windgoto(cursor_row, cursor_col); 3750 if (clear_attr != 0) 3751 screen_start_highlight(clear_attr); 3752 3753 // redraw the characters 3754 if (type == USE_REDRAW) 3755 redraw_block(row, end, wp); 3756 else if (type == USE_T_CAL) 3757 { 3758 term_append_lines(line_count); 3759 screen_start(); // don't know where cursor is now 3760 } 3761 else 3762 { 3763 for (i = 0; i < line_count; i++) 3764 { 3765 if (type == USE_T_AL) 3766 { 3767 if (i && cursor_row != 0) 3768 windgoto(cursor_row, cursor_col); 3769 out_str(T_AL); 3770 } 3771 else // type == USE_T_SR 3772 out_str(T_SR); 3773 screen_start(); // don't know where cursor is now 3774 } 3775 } 3776 3777 /* 3778 * With scroll-reverse and 'da' flag set we need to clear the lines that 3779 * have been scrolled down into the region. 3780 */ 3781 if (type == USE_T_SR && *T_DA) 3782 { 3783 for (i = 0; i < line_count; ++i) 3784 { 3785 windgoto(off + i, cursor_col); 3786 out_str(T_CE); 3787 screen_start(); // don't know where cursor is now 3788 } 3789 } 3790 3791 #ifdef FEAT_GUI 3792 gui_can_update_cursor(); 3793 if (gui.in_use) 3794 out_flush(); // always flush after a scroll 3795 #endif 3796 return OK; 3797 } 3798 3799 /* 3800 * Delete lines on the screen and update ScreenLines[]. 3801 * "end" is the line after the scrolled part. Normally it is Rows. 3802 * When scrolling region used "off" is the offset from the top for the region. 3803 * "row" and "end" are relative to the start of the region. 3804 * 3805 * Return OK for success, FAIL if the lines are not deleted. 3806 */ 3807 int 3808 screen_del_lines( 3809 int off, 3810 int row, 3811 int line_count, 3812 int end, 3813 int force, // even when line_count > p_ttyscroll 3814 int clear_attr, // used for clearing lines 3815 win_T *wp UNUSED) // NULL or window to use width from 3816 { 3817 int j; 3818 int i; 3819 unsigned temp; 3820 int cursor_row; 3821 int cursor_col = 0; 3822 int cursor_end; 3823 int result_empty; // result is empty until end of region 3824 int can_delete; // deleting line codes can be used 3825 int type; 3826 3827 /* 3828 * FAIL if 3829 * - there is no valid screen 3830 * - the screen has to be redrawn completely 3831 * - the line count is less than one 3832 * - the line count is more than 'ttyscroll' 3833 * - redrawing for a callback and there is a modeless selection 3834 */ 3835 if (!screen_valid(TRUE) || line_count <= 0 3836 || (!force && line_count > p_ttyscroll) 3837 #ifdef FEAT_CLIPBOARD 3838 || (clip_star.state != SELECT_CLEARED 3839 && redrawing_for_callback > 0) 3840 #endif 3841 ) 3842 return FAIL; 3843 3844 /* 3845 * Check if the rest of the current region will become empty. 3846 */ 3847 result_empty = row + line_count >= end; 3848 3849 /* 3850 * We can delete lines only when 'db' flag not set or when 'ce' option 3851 * available. 3852 */ 3853 can_delete = (*T_DB == NUL || can_clear(T_CE)); 3854 3855 /* 3856 * There are six ways to delete lines: 3857 * 0. When in a vertically split window and t_CV isn't set, redraw the 3858 * characters from ScreenLines[]. 3859 * 1. Use T_CD if it exists and the result is empty. 3860 * 2. Use newlines if row == 0 and count == 1 or T_CDL does not exist. 3861 * 3. Use T_CDL (delete multiple lines) if it exists and line_count > 1 or 3862 * none of the other ways work. 3863 * 4. Use T_CE (erase line) if the result is empty. 3864 * 5. Use T_DL (delete line) if it exists. 3865 * 6. redraw the characters from ScreenLines[]. 3866 */ 3867 if (wp != NULL && wp->w_width != Columns && *T_CSV == NUL) 3868 type = USE_REDRAW; 3869 else if (can_clear(T_CD) && result_empty) 3870 type = USE_T_CD; 3871 #if defined(__BEOS__) && defined(BEOS_DR8) 3872 /* 3873 * USE_NL does not seem to work in Terminal of DR8 so we set T_DB="" in 3874 * its internal termcap... this works okay for tests which test *T_DB != 3875 * NUL. It has the disadvantage that the user cannot use any :set t_* 3876 * command to get T_DB (back) to empty_option, only :set term=... will do 3877 * the trick... 3878 * Anyway, this hack will hopefully go away with the next OS release. 3879 * (Olaf Seibert) 3880 */ 3881 else if (row == 0 && T_DB == empty_option 3882 && (line_count == 1 || *T_CDL == NUL)) 3883 #else 3884 else if (row == 0 && ( 3885 #ifndef AMIGA 3886 // On the Amiga, somehow '\n' on the last line doesn't always scroll 3887 // up, so use delete-line command 3888 line_count == 1 || 3889 #endif 3890 *T_CDL == NUL)) 3891 #endif 3892 type = USE_NL; 3893 else if (*T_CDL != NUL && line_count > 1 && can_delete) 3894 type = USE_T_CDL; 3895 else if (can_clear(T_CE) && result_empty 3896 && (wp == NULL || wp->w_width == Columns)) 3897 type = USE_T_CE; 3898 else if (*T_DL != NUL && can_delete) 3899 type = USE_T_DL; 3900 else if (*T_CDL != NUL && can_delete) 3901 type = USE_T_CDL; 3902 else 3903 return FAIL; 3904 3905 #ifdef FEAT_CLIPBOARD 3906 // Remove a modeless selection when deleting lines halfway the screen or 3907 // not the full width of the screen. 3908 if (off + row > 0 || (wp != NULL && wp->w_width != Columns)) 3909 clip_clear_selection(&clip_star); 3910 else 3911 clip_scroll_selection(line_count); 3912 #endif 3913 3914 #ifdef FEAT_GUI_HAIKU 3915 vim_lock_screen(); 3916 #endif 3917 3918 #ifdef FEAT_GUI 3919 // Don't update the GUI cursor here, ScreenLines[] is invalid until the 3920 // scrolling is actually carried out. 3921 gui_dont_update_cursor(gui.cursor_row >= row + off 3922 && gui.cursor_row < end + off); 3923 #endif 3924 3925 if (wp != NULL && wp->w_wincol != 0 && *T_CSV != NUL && *T_CCS == NUL) 3926 cursor_col = wp->w_wincol; 3927 3928 if (*T_CCS != NUL) // cursor relative to region 3929 { 3930 cursor_row = row; 3931 cursor_end = end; 3932 } 3933 else 3934 { 3935 cursor_row = row + off; 3936 cursor_end = end + off; 3937 } 3938 3939 /* 3940 * Now shift LineOffset[] line_count up to reflect the deleted lines. 3941 * Clear the inserted lines in ScreenLines[]. 3942 */ 3943 row += off; 3944 end += off; 3945 for (i = 0; i < line_count; ++i) 3946 { 3947 if (wp != NULL && wp->w_width != Columns) 3948 { 3949 // need to copy part of a line 3950 j = row + i; 3951 while ((j += line_count) <= end - 1) 3952 linecopy(j - line_count, j, wp); 3953 j -= line_count; 3954 if (can_clear((char_u *)" ")) 3955 lineclear(LineOffset[j] + wp->w_wincol, wp->w_width, 3956 clear_attr); 3957 else 3958 lineinvalid(LineOffset[j] + wp->w_wincol, wp->w_width); 3959 LineWraps[j] = FALSE; 3960 } 3961 else 3962 { 3963 // whole width, moving the line pointers is faster 3964 j = row + i; 3965 temp = LineOffset[j]; 3966 while ((j += line_count) <= end - 1) 3967 { 3968 LineOffset[j - line_count] = LineOffset[j]; 3969 LineWraps[j - line_count] = LineWraps[j]; 3970 } 3971 LineOffset[j - line_count] = temp; 3972 LineWraps[j - line_count] = FALSE; 3973 if (can_clear((char_u *)" ")) 3974 lineclear(temp, (int)Columns, clear_attr); 3975 else 3976 lineinvalid(temp, (int)Columns); 3977 } 3978 } 3979 3980 #ifdef FEAT_GUI_HAIKU 3981 vim_unlock_screen(); 3982 #endif 3983 3984 if (screen_attr != clear_attr) 3985 screen_stop_highlight(); 3986 if (clear_attr != 0) 3987 screen_start_highlight(clear_attr); 3988 3989 // redraw the characters 3990 if (type == USE_REDRAW) 3991 redraw_block(row, end, wp); 3992 else if (type == USE_T_CD) // delete the lines 3993 { 3994 windgoto(cursor_row, cursor_col); 3995 out_str(T_CD); 3996 screen_start(); // don't know where cursor is now 3997 } 3998 else if (type == USE_T_CDL) 3999 { 4000 windgoto(cursor_row, cursor_col); 4001 term_delete_lines(line_count); 4002 screen_start(); // don't know where cursor is now 4003 } 4004 /* 4005 * Deleting lines at top of the screen or scroll region: Just scroll 4006 * the whole screen (scroll region) up by outputting newlines on the 4007 * last line. 4008 */ 4009 else if (type == USE_NL) 4010 { 4011 windgoto(cursor_end - 1, cursor_col); 4012 for (i = line_count; --i >= 0; ) 4013 out_char('\n'); // cursor will remain on same line 4014 } 4015 else 4016 { 4017 for (i = line_count; --i >= 0; ) 4018 { 4019 if (type == USE_T_DL) 4020 { 4021 windgoto(cursor_row, cursor_col); 4022 out_str(T_DL); // delete a line 4023 } 4024 else // type == USE_T_CE 4025 { 4026 windgoto(cursor_row + i, cursor_col); 4027 out_str(T_CE); // erase a line 4028 } 4029 screen_start(); // don't know where cursor is now 4030 } 4031 } 4032 4033 /* 4034 * If the 'db' flag is set, we need to clear the lines that have been 4035 * scrolled up at the bottom of the region. 4036 */ 4037 if (*T_DB && (type == USE_T_DL || type == USE_T_CDL)) 4038 { 4039 for (i = line_count; i > 0; --i) 4040 { 4041 windgoto(cursor_end - i, cursor_col); 4042 out_str(T_CE); // erase a line 4043 screen_start(); // don't know where cursor is now 4044 } 4045 } 4046 4047 #ifdef FEAT_GUI 4048 gui_can_update_cursor(); 4049 if (gui.in_use) 4050 out_flush(); // always flush after a scroll 4051 #endif 4052 4053 return OK; 4054 } 4055 4056 /* 4057 * Return TRUE when postponing displaying the mode message: when not redrawing 4058 * or inside a mapping. 4059 */ 4060 int 4061 skip_showmode() 4062 { 4063 // Call char_avail() only when we are going to show something, because it 4064 // takes a bit of time. redrawing() may also call char_avail_avail(). 4065 if (global_busy 4066 || msg_silent != 0 4067 || !redrawing() 4068 || (char_avail() && !KeyTyped)) 4069 { 4070 redraw_mode = TRUE; // show mode later 4071 return TRUE; 4072 } 4073 return FALSE; 4074 } 4075 4076 /* 4077 * Show the current mode and ruler. 4078 * 4079 * If clear_cmdline is TRUE, clear the rest of the cmdline. 4080 * If clear_cmdline is FALSE there may be a message there that needs to be 4081 * cleared only if a mode is shown. 4082 * If redraw_mode is TRUE show or clear the mode. 4083 * Return the length of the message (0 if no message). 4084 */ 4085 int 4086 showmode(void) 4087 { 4088 int need_clear; 4089 int length = 0; 4090 int do_mode; 4091 int attr; 4092 int nwr_save; 4093 int sub_attr; 4094 4095 do_mode = ((p_smd && msg_silent == 0) 4096 && ((State & INSERT) 4097 || restart_edit != NUL 4098 || VIsual_active)); 4099 if (do_mode || reg_recording != 0) 4100 { 4101 if (skip_showmode()) 4102 return 0; // show mode later 4103 4104 nwr_save = need_wait_return; 4105 4106 // wait a bit before overwriting an important message 4107 check_for_delay(FALSE); 4108 4109 // if the cmdline is more than one line high, erase top lines 4110 need_clear = clear_cmdline; 4111 if (clear_cmdline && cmdline_row < Rows - 1) 4112 msg_clr_cmdline(); // will reset clear_cmdline 4113 4114 // Position on the last line in the window, column 0 4115 msg_pos_mode(); 4116 cursor_off(); 4117 attr = HL_ATTR(HLF_CM); // Highlight mode 4118 if (do_mode) 4119 { 4120 msg_puts_attr("--", attr); 4121 #if defined(FEAT_XIM) 4122 if ( 4123 # ifdef FEAT_GUI_GTK 4124 preedit_get_status() 4125 # else 4126 im_get_status() 4127 # endif 4128 ) 4129 # ifdef FEAT_GUI_GTK // most of the time, it's not XIM being used 4130 msg_puts_attr(" IM", attr); 4131 # else 4132 msg_puts_attr(" XIM", attr); 4133 # endif 4134 #endif 4135 // CTRL-X in Insert mode 4136 if (edit_submode != NULL && !shortmess(SHM_COMPLETIONMENU)) 4137 { 4138 // These messages can get long, avoid a wrap in a narrow 4139 // window. Prefer showing edit_submode_extra. 4140 length = (Rows - msg_row) * Columns - 3; 4141 if (edit_submode_extra != NULL) 4142 length -= vim_strsize(edit_submode_extra); 4143 if (length > 0) 4144 { 4145 if (edit_submode_pre != NULL) 4146 length -= vim_strsize(edit_submode_pre); 4147 if (length - vim_strsize(edit_submode) > 0) 4148 { 4149 if (edit_submode_pre != NULL) 4150 msg_puts_attr((char *)edit_submode_pre, attr); 4151 msg_puts_attr((char *)edit_submode, attr); 4152 } 4153 if (edit_submode_extra != NULL) 4154 { 4155 msg_puts_attr(" ", attr); // add a space in between 4156 if ((int)edit_submode_highl < (int)HLF_COUNT) 4157 sub_attr = HL_ATTR(edit_submode_highl); 4158 else 4159 sub_attr = attr; 4160 msg_puts_attr((char *)edit_submode_extra, sub_attr); 4161 } 4162 } 4163 } 4164 else 4165 { 4166 if (State & VREPLACE_FLAG) 4167 msg_puts_attr(_(" VREPLACE"), attr); 4168 else if (State & REPLACE_FLAG) 4169 msg_puts_attr(_(" REPLACE"), attr); 4170 else if (State & INSERT) 4171 { 4172 #ifdef FEAT_RIGHTLEFT 4173 if (p_ri) 4174 msg_puts_attr(_(" REVERSE"), attr); 4175 #endif 4176 msg_puts_attr(_(" INSERT"), attr); 4177 } 4178 else if (restart_edit == 'I' || restart_edit == 'A') 4179 msg_puts_attr(_(" (insert)"), attr); 4180 else if (restart_edit == 'R') 4181 msg_puts_attr(_(" (replace)"), attr); 4182 else if (restart_edit == 'V') 4183 msg_puts_attr(_(" (vreplace)"), attr); 4184 #ifdef FEAT_RIGHTLEFT 4185 if (p_hkmap) 4186 msg_puts_attr(_(" Hebrew"), attr); 4187 #endif 4188 #ifdef FEAT_KEYMAP 4189 if (State & LANGMAP) 4190 { 4191 # ifdef FEAT_ARABIC 4192 if (curwin->w_p_arab) 4193 msg_puts_attr(_(" Arabic"), attr); 4194 else 4195 # endif 4196 if (get_keymap_str(curwin, (char_u *)" (%s)", 4197 NameBuff, MAXPATHL)) 4198 msg_puts_attr((char *)NameBuff, attr); 4199 } 4200 #endif 4201 if ((State & INSERT) && p_paste) 4202 msg_puts_attr(_(" (paste)"), attr); 4203 4204 if (VIsual_active) 4205 { 4206 char *p; 4207 4208 // Don't concatenate separate words to avoid translation 4209 // problems. 4210 switch ((VIsual_select ? 4 : 0) 4211 + (VIsual_mode == Ctrl_V) * 2 4212 + (VIsual_mode == 'V')) 4213 { 4214 case 0: p = N_(" VISUAL"); break; 4215 case 1: p = N_(" VISUAL LINE"); break; 4216 case 2: p = N_(" VISUAL BLOCK"); break; 4217 case 4: p = N_(" SELECT"); break; 4218 case 5: p = N_(" SELECT LINE"); break; 4219 default: p = N_(" SELECT BLOCK"); break; 4220 } 4221 msg_puts_attr(_(p), attr); 4222 } 4223 msg_puts_attr(" --", attr); 4224 } 4225 4226 need_clear = TRUE; 4227 } 4228 if (reg_recording != 0 4229 && edit_submode == NULL) // otherwise it gets too long 4230 { 4231 recording_mode(attr); 4232 need_clear = TRUE; 4233 } 4234 4235 mode_displayed = TRUE; 4236 if (need_clear || clear_cmdline || redraw_mode) 4237 msg_clr_eos(); 4238 msg_didout = FALSE; // overwrite this message 4239 length = msg_col; 4240 msg_col = 0; 4241 need_wait_return = nwr_save; // never ask for hit-return for this 4242 } 4243 else if (clear_cmdline && msg_silent == 0) 4244 // Clear the whole command line. Will reset "clear_cmdline". 4245 msg_clr_cmdline(); 4246 else if (redraw_mode) 4247 { 4248 msg_pos_mode(); 4249 msg_clr_eos(); 4250 } 4251 4252 #ifdef FEAT_CMDL_INFO 4253 // In Visual mode the size of the selected area must be redrawn. 4254 if (VIsual_active) 4255 clear_showcmd(); 4256 4257 // If the last window has no status line, the ruler is after the mode 4258 // message and must be redrawn 4259 if (redrawing() && lastwin->w_status_height == 0) 4260 win_redr_ruler(lastwin, TRUE, FALSE); 4261 #endif 4262 redraw_cmdline = FALSE; 4263 redraw_mode = FALSE; 4264 clear_cmdline = FALSE; 4265 4266 return length; 4267 } 4268 4269 /* 4270 * Position for a mode message. 4271 */ 4272 static void 4273 msg_pos_mode(void) 4274 { 4275 msg_col = 0; 4276 msg_row = Rows - 1; 4277 } 4278 4279 /* 4280 * Delete mode message. Used when ESC is typed which is expected to end 4281 * Insert mode (but Insert mode didn't end yet!). 4282 * Caller should check "mode_displayed". 4283 */ 4284 void 4285 unshowmode(int force) 4286 { 4287 /* 4288 * Don't delete it right now, when not redrawing or inside a mapping. 4289 */ 4290 if (!redrawing() || (!force && char_avail() && !KeyTyped)) 4291 redraw_cmdline = TRUE; // delete mode later 4292 else 4293 clearmode(); 4294 } 4295 4296 /* 4297 * Clear the mode message. 4298 */ 4299 void 4300 clearmode(void) 4301 { 4302 int save_msg_row = msg_row; 4303 int save_msg_col = msg_col; 4304 4305 msg_pos_mode(); 4306 if (reg_recording != 0) 4307 recording_mode(HL_ATTR(HLF_CM)); 4308 msg_clr_eos(); 4309 4310 msg_col = save_msg_col; 4311 msg_row = save_msg_row; 4312 } 4313 4314 static void 4315 recording_mode(int attr) 4316 { 4317 msg_puts_attr(_("recording"), attr); 4318 if (!shortmess(SHM_RECORDING)) 4319 { 4320 char s[4]; 4321 4322 sprintf(s, " @%c", reg_recording); 4323 msg_puts_attr(s, attr); 4324 } 4325 } 4326 4327 /* 4328 * Draw the tab pages line at the top of the Vim window. 4329 */ 4330 void 4331 draw_tabline(void) 4332 { 4333 int tabcount = 0; 4334 tabpage_T *tp; 4335 int tabwidth; 4336 int col = 0; 4337 int scol = 0; 4338 int attr; 4339 win_T *wp; 4340 win_T *cwp; 4341 int wincount; 4342 int modified; 4343 int c; 4344 int len; 4345 int attr_sel = HL_ATTR(HLF_TPS); 4346 int attr_nosel = HL_ATTR(HLF_TP); 4347 int attr_fill = HL_ATTR(HLF_TPF); 4348 char_u *p; 4349 int room; 4350 int use_sep_chars = (t_colors < 8 4351 #ifdef FEAT_GUI 4352 && !gui.in_use 4353 #endif 4354 #ifdef FEAT_TERMGUICOLORS 4355 && !p_tgc 4356 #endif 4357 ); 4358 4359 if (ScreenLines == NULL) 4360 return; 4361 redraw_tabline = FALSE; 4362 4363 #ifdef FEAT_GUI_TABLINE 4364 // Take care of a GUI tabline. 4365 if (gui_use_tabline()) 4366 { 4367 gui_update_tabline(); 4368 return; 4369 } 4370 #endif 4371 4372 if (tabline_height() < 1) 4373 return; 4374 4375 #if defined(FEAT_STL_OPT) 4376 clear_TabPageIdxs(); 4377 4378 // Use the 'tabline' option if it's set. 4379 if (*p_tal != NUL) 4380 { 4381 int saved_did_emsg = did_emsg; 4382 4383 // Check for an error. If there is one we would loop in redrawing the 4384 // screen. Avoid that by making 'tabline' empty. 4385 did_emsg = FALSE; 4386 win_redr_custom(NULL, FALSE); 4387 if (did_emsg) 4388 set_string_option_direct((char_u *)"tabline", -1, 4389 (char_u *)"", OPT_FREE, SID_ERROR); 4390 did_emsg |= saved_did_emsg; 4391 } 4392 else 4393 #endif 4394 { 4395 FOR_ALL_TABPAGES(tp) 4396 ++tabcount; 4397 4398 tabwidth = (Columns - 1 + tabcount / 2) / tabcount; 4399 if (tabwidth < 6) 4400 tabwidth = 6; 4401 4402 attr = attr_nosel; 4403 tabcount = 0; 4404 for (tp = first_tabpage; tp != NULL && col < Columns - 4; 4405 tp = tp->tp_next) 4406 { 4407 scol = col; 4408 4409 if (tp->tp_topframe == topframe) 4410 attr = attr_sel; 4411 if (use_sep_chars && col > 0) 4412 screen_putchar('|', 0, col++, attr); 4413 4414 if (tp->tp_topframe != topframe) 4415 attr = attr_nosel; 4416 4417 screen_putchar(' ', 0, col++, attr); 4418 4419 if (tp == curtab) 4420 { 4421 cwp = curwin; 4422 wp = firstwin; 4423 } 4424 else 4425 { 4426 cwp = tp->tp_curwin; 4427 wp = tp->tp_firstwin; 4428 } 4429 4430 modified = FALSE; 4431 for (wincount = 0; wp != NULL; wp = wp->w_next, ++wincount) 4432 if (bufIsChanged(wp->w_buffer)) 4433 modified = TRUE; 4434 if (modified || wincount > 1) 4435 { 4436 if (wincount > 1) 4437 { 4438 vim_snprintf((char *)NameBuff, MAXPATHL, "%d", wincount); 4439 len = (int)STRLEN(NameBuff); 4440 if (col + len >= Columns - 3) 4441 break; 4442 screen_puts_len(NameBuff, len, 0, col, 4443 #if defined(FEAT_SYN_HL) 4444 hl_combine_attr(attr, HL_ATTR(HLF_T)) 4445 #else 4446 attr 4447 #endif 4448 ); 4449 col += len; 4450 } 4451 if (modified) 4452 screen_puts_len((char_u *)"+", 1, 0, col++, attr); 4453 screen_putchar(' ', 0, col++, attr); 4454 } 4455 4456 room = scol - col + tabwidth - 1; 4457 if (room > 0) 4458 { 4459 // Get buffer name in NameBuff[] 4460 get_trans_bufname(cwp->w_buffer); 4461 shorten_dir(NameBuff); 4462 len = vim_strsize(NameBuff); 4463 p = NameBuff; 4464 if (has_mbyte) 4465 while (len > room) 4466 { 4467 len -= ptr2cells(p); 4468 MB_PTR_ADV(p); 4469 } 4470 else if (len > room) 4471 { 4472 p += len - room; 4473 len = room; 4474 } 4475 if (len > Columns - col - 1) 4476 len = Columns - col - 1; 4477 4478 screen_puts_len(p, (int)STRLEN(p), 0, col, attr); 4479 col += len; 4480 } 4481 screen_putchar(' ', 0, col++, attr); 4482 4483 // Store the tab page number in TabPageIdxs[], so that 4484 // jump_to_mouse() knows where each one is. 4485 ++tabcount; 4486 while (scol < col) 4487 TabPageIdxs[scol++] = tabcount; 4488 } 4489 4490 if (use_sep_chars) 4491 c = '_'; 4492 else 4493 c = ' '; 4494 screen_fill(0, 1, col, (int)Columns, c, c, attr_fill); 4495 4496 // Put an "X" for closing the current tab if there are several. 4497 if (first_tabpage->tp_next != NULL) 4498 { 4499 screen_putchar('X', 0, (int)Columns - 1, attr_nosel); 4500 TabPageIdxs[Columns - 1] = -999; 4501 } 4502 } 4503 4504 // Reset the flag here again, in case evaluating 'tabline' causes it to be 4505 // set. 4506 redraw_tabline = FALSE; 4507 } 4508 4509 /* 4510 * Get buffer name for "buf" into NameBuff[]. 4511 * Takes care of special buffer names and translates special characters. 4512 */ 4513 void 4514 get_trans_bufname(buf_T *buf) 4515 { 4516 if (buf_spname(buf) != NULL) 4517 vim_strncpy(NameBuff, buf_spname(buf), MAXPATHL - 1); 4518 else 4519 home_replace(buf, buf->b_fname, NameBuff, MAXPATHL, TRUE); 4520 trans_characters(NameBuff, MAXPATHL); 4521 } 4522 4523 /* 4524 * Get the character to use in a status line. Get its attributes in "*attr". 4525 */ 4526 int 4527 fillchar_status(int *attr, win_T *wp) 4528 { 4529 int fill; 4530 4531 #ifdef FEAT_TERMINAL 4532 if (bt_terminal(wp->w_buffer)) 4533 { 4534 if (wp == curwin) 4535 { 4536 *attr = HL_ATTR(HLF_ST); 4537 fill = fill_stl; 4538 } 4539 else 4540 { 4541 *attr = HL_ATTR(HLF_STNC); 4542 fill = fill_stlnc; 4543 } 4544 } 4545 else 4546 #endif 4547 if (wp == curwin) 4548 { 4549 *attr = HL_ATTR(HLF_S); 4550 fill = fill_stl; 4551 } 4552 else 4553 { 4554 *attr = HL_ATTR(HLF_SNC); 4555 fill = fill_stlnc; 4556 } 4557 // Use fill when there is highlighting, and highlighting of current 4558 // window differs, or the fillchars differ, or this is not the 4559 // current window 4560 if (*attr != 0 && ((HL_ATTR(HLF_S) != HL_ATTR(HLF_SNC) 4561 || wp != curwin || ONE_WINDOW) 4562 || (fill_stl != fill_stlnc))) 4563 return fill; 4564 if (wp == curwin) 4565 return '^'; 4566 return '='; 4567 } 4568 4569 /* 4570 * Get the character to use in a separator between vertically split windows. 4571 * Get its attributes in "*attr". 4572 */ 4573 int 4574 fillchar_vsep(int *attr) 4575 { 4576 *attr = HL_ATTR(HLF_C); 4577 if (*attr == 0 && fill_vert == ' ') 4578 return '|'; 4579 else 4580 return fill_vert; 4581 } 4582 4583 /* 4584 * Return TRUE if redrawing should currently be done. 4585 */ 4586 int 4587 redrawing(void) 4588 { 4589 #ifdef FEAT_EVAL 4590 if (disable_redraw_for_testing) 4591 return 0; 4592 else 4593 #endif 4594 return ((!RedrawingDisabled 4595 #ifdef FEAT_EVAL 4596 || ignore_redraw_flag_for_testing 4597 #endif 4598 ) && !(p_lz && char_avail() && !KeyTyped && !do_redraw)); 4599 } 4600 4601 /* 4602 * Return TRUE if printing messages should currently be done. 4603 */ 4604 int 4605 messaging(void) 4606 { 4607 return (!(p_lz && char_avail() && !KeyTyped)); 4608 } 4609 4610 /* 4611 * Compute columns for ruler and shown command. 'sc_col' is also used to 4612 * decide what the maximum length of a message on the status line can be. 4613 * If there is a status line for the last window, 'sc_col' is independent 4614 * of 'ru_col'. 4615 */ 4616 4617 #define COL_RULER 17 // columns needed by standard ruler 4618 4619 void 4620 comp_col(void) 4621 { 4622 #if defined(FEAT_CMDL_INFO) 4623 int last_has_status = (p_ls == 2 || (p_ls == 1 && !ONE_WINDOW)); 4624 4625 sc_col = 0; 4626 ru_col = 0; 4627 if (p_ru) 4628 { 4629 # ifdef FEAT_STL_OPT 4630 ru_col = (ru_wid ? ru_wid : COL_RULER) + 1; 4631 # else 4632 ru_col = COL_RULER + 1; 4633 # endif 4634 // no last status line, adjust sc_col 4635 if (!last_has_status) 4636 sc_col = ru_col; 4637 } 4638 if (p_sc) 4639 { 4640 sc_col += SHOWCMD_COLS; 4641 if (!p_ru || last_has_status) // no need for separating space 4642 ++sc_col; 4643 } 4644 sc_col = Columns - sc_col; 4645 ru_col = Columns - ru_col; 4646 if (sc_col <= 0) // screen too narrow, will become a mess 4647 sc_col = 1; 4648 if (ru_col <= 0) 4649 ru_col = 1; 4650 #else 4651 sc_col = Columns; 4652 ru_col = Columns; 4653 #endif 4654 #ifdef FEAT_EVAL 4655 set_vim_var_nr(VV_ECHOSPACE, sc_col - 1); 4656 #endif 4657 } 4658 4659 #if defined(FEAT_LINEBREAK) || defined(PROTO) 4660 /* 4661 * Return the width of the 'number' and 'relativenumber' column. 4662 * Caller may need to check if 'number' or 'relativenumber' is set. 4663 * Otherwise it depends on 'numberwidth' and the line count. 4664 */ 4665 int 4666 number_width(win_T *wp) 4667 { 4668 int n; 4669 linenr_T lnum; 4670 4671 if (wp->w_p_rnu && !wp->w_p_nu) 4672 // cursor line shows "0" 4673 lnum = wp->w_height; 4674 else 4675 // cursor line shows absolute line number 4676 lnum = wp->w_buffer->b_ml.ml_line_count; 4677 4678 if (lnum == wp->w_nrwidth_line_count && wp->w_nuw_cached == wp->w_p_nuw) 4679 return wp->w_nrwidth_width; 4680 wp->w_nrwidth_line_count = lnum; 4681 4682 n = 0; 4683 do 4684 { 4685 lnum /= 10; 4686 ++n; 4687 } while (lnum > 0); 4688 4689 // 'numberwidth' gives the minimal width plus one 4690 if (n < wp->w_p_nuw - 1) 4691 n = wp->w_p_nuw - 1; 4692 4693 # ifdef FEAT_SIGNS 4694 // If 'signcolumn' is set to 'number' and there is a sign to display, then 4695 // the minimal width for the number column is 2. 4696 if (n < 2 && get_first_valid_sign(wp) != NULL 4697 && (*wp->w_p_scl == 'n' && *(wp->w_p_scl + 1) == 'u')) 4698 n = 2; 4699 # endif 4700 4701 wp->w_nrwidth_width = n; 4702 wp->w_nuw_cached = wp->w_p_nuw; 4703 return n; 4704 } 4705 #endif 4706 4707 #if defined(FEAT_EVAL) || defined(PROTO) 4708 /* 4709 * Return the current cursor column. This is the actual position on the 4710 * screen. First column is 0. 4711 */ 4712 int 4713 screen_screencol(void) 4714 { 4715 return screen_cur_col; 4716 } 4717 4718 /* 4719 * Return the current cursor row. This is the actual position on the screen. 4720 * First row is 0. 4721 */ 4722 int 4723 screen_screenrow(void) 4724 { 4725 return screen_cur_row; 4726 } 4727 #endif 4728 4729 /* 4730 * Handle setting 'listchars' or 'fillchars'. 4731 * Returns error message, NULL if it's OK. 4732 */ 4733 char * 4734 set_chars_option(char_u **varp) 4735 { 4736 int round, i, len, entries; 4737 char_u *p, *s; 4738 int c1 = 0, c2 = 0, c3 = 0; 4739 struct charstab 4740 { 4741 int *cp; 4742 char *name; 4743 }; 4744 static struct charstab filltab[] = 4745 { 4746 {&fill_stl, "stl"}, 4747 {&fill_stlnc, "stlnc"}, 4748 {&fill_vert, "vert"}, 4749 {&fill_fold, "fold"}, 4750 {&fill_diff, "diff"}, 4751 }; 4752 static struct charstab lcstab[] = 4753 { 4754 {&lcs_eol, "eol"}, 4755 {&lcs_ext, "extends"}, 4756 {&lcs_nbsp, "nbsp"}, 4757 {&lcs_prec, "precedes"}, 4758 {&lcs_space, "space"}, 4759 {&lcs_tab2, "tab"}, 4760 {&lcs_trail, "trail"}, 4761 #ifdef FEAT_CONCEAL 4762 {&lcs_conceal, "conceal"}, 4763 #else 4764 {NULL, "conceal"}, 4765 #endif 4766 }; 4767 struct charstab *tab; 4768 4769 if (varp == &p_lcs) 4770 { 4771 tab = lcstab; 4772 entries = sizeof(lcstab) / sizeof(struct charstab); 4773 } 4774 else 4775 { 4776 tab = filltab; 4777 entries = sizeof(filltab) / sizeof(struct charstab); 4778 } 4779 4780 // first round: check for valid value, second round: assign values 4781 for (round = 0; round <= 1; ++round) 4782 { 4783 if (round > 0) 4784 { 4785 // After checking that the value is valid: set defaults: space for 4786 // 'fillchars', NUL for 'listchars' 4787 for (i = 0; i < entries; ++i) 4788 if (tab[i].cp != NULL) 4789 *(tab[i].cp) = (varp == &p_lcs ? NUL : ' '); 4790 4791 if (varp == &p_lcs) 4792 { 4793 lcs_tab1 = NUL; 4794 lcs_tab3 = NUL; 4795 } 4796 else 4797 fill_diff = '-'; 4798 } 4799 p = *varp; 4800 while (*p) 4801 { 4802 for (i = 0; i < entries; ++i) 4803 { 4804 len = (int)STRLEN(tab[i].name); 4805 if (STRNCMP(p, tab[i].name, len) == 0 4806 && p[len] == ':' 4807 && p[len + 1] != NUL) 4808 { 4809 c2 = c3 = 0; 4810 s = p + len + 1; 4811 c1 = mb_ptr2char_adv(&s); 4812 if (mb_char2cells(c1) > 1) 4813 continue; 4814 if (tab[i].cp == &lcs_tab2) 4815 { 4816 if (*s == NUL) 4817 continue; 4818 c2 = mb_ptr2char_adv(&s); 4819 if (mb_char2cells(c2) > 1) 4820 continue; 4821 if (!(*s == ',' || *s == NUL)) 4822 { 4823 c3 = mb_ptr2char_adv(&s); 4824 if (mb_char2cells(c3) > 1) 4825 continue; 4826 } 4827 } 4828 4829 if (*s == ',' || *s == NUL) 4830 { 4831 if (round) 4832 { 4833 if (tab[i].cp == &lcs_tab2) 4834 { 4835 lcs_tab1 = c1; 4836 lcs_tab2 = c2; 4837 lcs_tab3 = c3; 4838 } 4839 else if (tab[i].cp != NULL) 4840 *(tab[i].cp) = c1; 4841 4842 } 4843 p = s; 4844 break; 4845 } 4846 } 4847 } 4848 4849 if (i == entries) 4850 return e_invarg; 4851 if (*p == ',') 4852 ++p; 4853 } 4854 } 4855 4856 return NULL; // no error 4857 } 4858 4859