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