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 * ui.c: functions that handle the user interface. 12 * 1. Keyboard input stuff, and a bit of windowing stuff. These are called 13 * before the machine specific stuff (mch_*) so that we can call the GUI 14 * stuff instead if the GUI is running. 15 * 2. Clipboard stuff. 16 * 3. Input buffer stuff. 17 */ 18 19 #include "vim.h" 20 21 #ifdef FEAT_CYGWIN_WIN32_CLIPBOARD 22 # define WIN32_LEAN_AND_MEAN 23 # include <windows.h> 24 # include "winclip.pro" 25 #endif 26 27 void 28 ui_write(char_u *s, int len) 29 { 30 #ifdef FEAT_GUI 31 if (gui.in_use && !gui.dying && !gui.starting) 32 { 33 gui_write(s, len); 34 if (p_wd) 35 gui_wait_for_chars(p_wd); 36 return; 37 } 38 #endif 39 #ifndef NO_CONSOLE 40 /* Don't output anything in silent mode ("ex -s") unless 'verbose' set */ 41 if (!(silent_mode && p_verbose == 0)) 42 { 43 #if defined(FEAT_MBYTE) && !defined(WIN3264) 44 char_u *tofree = NULL; 45 46 if (output_conv.vc_type != CONV_NONE) 47 { 48 /* Convert characters from 'encoding' to 'termencoding'. */ 49 tofree = string_convert(&output_conv, s, &len); 50 if (tofree != NULL) 51 s = tofree; 52 } 53 #endif 54 55 mch_write(s, len); 56 57 #if defined(FEAT_MBYTE) && !defined(WIN3264) 58 if (output_conv.vc_type != CONV_NONE) 59 vim_free(tofree); 60 #endif 61 } 62 #endif 63 } 64 65 #if defined(UNIX) || defined(VMS) || defined(PROTO) || defined(WIN3264) 66 /* 67 * When executing an external program, there may be some typed characters that 68 * are not consumed by it. Give them back to ui_inchar() and they are stored 69 * here for the next call. 70 */ 71 static char_u *ta_str = NULL; 72 static int ta_off; /* offset for next char to use when ta_str != NULL */ 73 static int ta_len; /* length of ta_str when it's not NULL*/ 74 75 void 76 ui_inchar_undo(char_u *s, int len) 77 { 78 char_u *new; 79 int newlen; 80 81 newlen = len; 82 if (ta_str != NULL) 83 newlen += ta_len - ta_off; 84 new = alloc(newlen); 85 if (new != NULL) 86 { 87 if (ta_str != NULL) 88 { 89 mch_memmove(new, ta_str + ta_off, (size_t)(ta_len - ta_off)); 90 mch_memmove(new + ta_len - ta_off, s, (size_t)len); 91 vim_free(ta_str); 92 } 93 else 94 mch_memmove(new, s, (size_t)len); 95 ta_str = new; 96 ta_len = newlen; 97 ta_off = 0; 98 } 99 } 100 #endif 101 102 /* 103 * ui_inchar(): low level input function. 104 * Get characters from the keyboard. 105 * Return the number of characters that are available. 106 * If "wtime" == 0 do not wait for characters. 107 * If "wtime" == -1 wait forever for characters. 108 * If "wtime" > 0 wait "wtime" milliseconds for a character. 109 * 110 * "tb_change_cnt" is the value of typebuf.tb_change_cnt if "buf" points into 111 * it. When typebuf.tb_change_cnt changes (e.g., when a message is received 112 * from a remote client) "buf" can no longer be used. "tb_change_cnt" is NULL 113 * otherwise. 114 */ 115 int 116 ui_inchar( 117 char_u *buf, 118 int maxlen, 119 long wtime, /* don't use "time", MIPS cannot handle it */ 120 int tb_change_cnt) 121 { 122 int retval = 0; 123 124 #if defined(FEAT_GUI) && (defined(UNIX) || defined(VMS)) 125 /* 126 * Use the typeahead if there is any. 127 */ 128 if (ta_str != NULL) 129 { 130 if (maxlen >= ta_len - ta_off) 131 { 132 mch_memmove(buf, ta_str + ta_off, (size_t)ta_len); 133 vim_free(ta_str); 134 ta_str = NULL; 135 return ta_len; 136 } 137 mch_memmove(buf, ta_str + ta_off, (size_t)maxlen); 138 ta_off += maxlen; 139 return maxlen; 140 } 141 #endif 142 143 #ifdef FEAT_PROFILE 144 if (do_profiling == PROF_YES && wtime != 0) 145 prof_inchar_enter(); 146 #endif 147 148 #ifdef NO_CONSOLE_INPUT 149 /* Don't wait for character input when the window hasn't been opened yet. 150 * Do try reading, this works when redirecting stdin from a file. 151 * Must return something, otherwise we'll loop forever. If we run into 152 * this very often we probably got stuck, exit Vim. */ 153 if (no_console_input()) 154 { 155 static int count = 0; 156 157 # ifndef NO_CONSOLE 158 retval = mch_inchar(buf, maxlen, (wtime >= 0 && wtime < 10) 159 ? 10L : wtime, tb_change_cnt); 160 if (retval > 0 || typebuf_changed(tb_change_cnt) || wtime >= 0) 161 goto theend; 162 # endif 163 if (wtime == -1 && ++count == 1000) 164 read_error_exit(); 165 buf[0] = CAR; 166 retval = 1; 167 goto theend; 168 } 169 #endif 170 171 /* If we are going to wait for some time or block... */ 172 if (wtime == -1 || wtime > 100L) 173 { 174 /* ... allow signals to kill us. */ 175 (void)vim_handle_signal(SIGNAL_UNBLOCK); 176 177 /* ... there is no need for CTRL-C to interrupt something, don't let 178 * it set got_int when it was mapped. */ 179 if ((mapped_ctrl_c | curbuf->b_mapped_ctrl_c) & get_real_state()) 180 ctrl_c_interrupts = FALSE; 181 } 182 183 #ifdef FEAT_GUI 184 if (gui.in_use) 185 { 186 if (gui_wait_for_chars(wtime) && !typebuf_changed(tb_change_cnt)) 187 retval = read_from_input_buf(buf, (long)maxlen); 188 } 189 #endif 190 #ifndef NO_CONSOLE 191 # ifdef FEAT_GUI 192 else 193 # endif 194 { 195 retval = mch_inchar(buf, maxlen, wtime, tb_change_cnt); 196 } 197 #endif 198 199 if (wtime == -1 || wtime > 100L) 200 /* block SIGHUP et al. */ 201 (void)vim_handle_signal(SIGNAL_BLOCK); 202 203 ctrl_c_interrupts = TRUE; 204 205 #ifdef NO_CONSOLE_INPUT 206 theend: 207 #endif 208 #ifdef FEAT_PROFILE 209 if (do_profiling == PROF_YES && wtime != 0) 210 prof_inchar_exit(); 211 #endif 212 return retval; 213 } 214 215 /* 216 * return non-zero if a character is available 217 */ 218 int 219 ui_char_avail(void) 220 { 221 #ifdef FEAT_GUI 222 if (gui.in_use) 223 { 224 gui_mch_update(); 225 return input_available(); 226 } 227 #endif 228 #ifndef NO_CONSOLE 229 # ifdef NO_CONSOLE_INPUT 230 if (no_console_input()) 231 return 0; 232 # endif 233 return mch_char_avail(); 234 #else 235 return 0; 236 #endif 237 } 238 239 /* 240 * Delay for the given number of milliseconds. If ignoreinput is FALSE then we 241 * cancel the delay if a key is hit. 242 */ 243 void 244 ui_delay(long msec, int ignoreinput) 245 { 246 #ifdef FEAT_GUI 247 if (gui.in_use && !ignoreinput) 248 gui_wait_for_chars(msec); 249 else 250 #endif 251 mch_delay(msec, ignoreinput); 252 } 253 254 /* 255 * If the machine has job control, use it to suspend the program, 256 * otherwise fake it by starting a new shell. 257 * When running the GUI iconify the window. 258 */ 259 void 260 ui_suspend(void) 261 { 262 #ifdef FEAT_GUI 263 if (gui.in_use) 264 { 265 gui_mch_iconify(); 266 return; 267 } 268 #endif 269 mch_suspend(); 270 } 271 272 #if !defined(UNIX) || !defined(SIGTSTP) || defined(PROTO) || defined(__BEOS__) 273 /* 274 * When the OS can't really suspend, call this function to start a shell. 275 * This is never called in the GUI. 276 */ 277 void 278 suspend_shell(void) 279 { 280 if (*p_sh == NUL) 281 EMSG(_(e_shellempty)); 282 else 283 { 284 MSG_PUTS(_("new shell started\n")); 285 do_shell(NULL, 0); 286 } 287 } 288 #endif 289 290 /* 291 * Try to get the current Vim shell size. Put the result in Rows and Columns. 292 * Use the new sizes as defaults for 'columns' and 'lines'. 293 * Return OK when size could be determined, FAIL otherwise. 294 */ 295 int 296 ui_get_shellsize(void) 297 { 298 int retval; 299 300 #ifdef FEAT_GUI 301 if (gui.in_use) 302 retval = gui_get_shellsize(); 303 else 304 #endif 305 retval = mch_get_shellsize(); 306 307 check_shellsize(); 308 309 /* adjust the default for 'lines' and 'columns' */ 310 if (retval == OK) 311 { 312 set_number_default("lines", Rows); 313 set_number_default("columns", Columns); 314 } 315 return retval; 316 } 317 318 /* 319 * Set the size of the Vim shell according to Rows and Columns, if possible. 320 * The gui_set_shellsize() or mch_set_shellsize() function will try to set the 321 * new size. If this is not possible, it will adjust Rows and Columns. 322 */ 323 void 324 ui_set_shellsize( 325 int mustset UNUSED) /* set by the user */ 326 { 327 #ifdef FEAT_GUI 328 if (gui.in_use) 329 gui_set_shellsize(mustset, TRUE, RESIZE_BOTH); 330 else 331 #endif 332 mch_set_shellsize(); 333 } 334 335 /* 336 * Called when Rows and/or Columns changed. Adjust scroll region and mouse 337 * region. 338 */ 339 void 340 ui_new_shellsize(void) 341 { 342 if (full_screen && !exiting) 343 { 344 #ifdef FEAT_GUI 345 if (gui.in_use) 346 gui_new_shellsize(); 347 else 348 #endif 349 mch_new_shellsize(); 350 } 351 } 352 353 void 354 ui_breakcheck(void) 355 { 356 ui_breakcheck_force(FALSE); 357 } 358 359 /* 360 * When "force" is true also check when the terminal is not in raw mode. 361 * This is useful to read input on channels. 362 */ 363 void 364 ui_breakcheck_force(int force) 365 { 366 int save_us = updating_screen; 367 368 /* We do not want gui_resize_shell() to redraw the screen here. */ 369 ++updating_screen; 370 371 #ifdef FEAT_GUI 372 if (gui.in_use) 373 gui_mch_update(); 374 else 375 #endif 376 mch_breakcheck(force); 377 378 updating_screen = save_us; 379 } 380 381 /***************************************************************************** 382 * Functions for copying and pasting text between applications. 383 * This is always included in a GUI version, but may also be included when the 384 * clipboard and mouse is available to a terminal version such as xterm. 385 * Note: there are some more functions in ops.c that handle selection stuff. 386 * 387 * Also note that the majority of functions here deal with the X 'primary' 388 * (visible - for Visual mode use) selection, and only that. There are no 389 * versions of these for the 'clipboard' selection, as Visual mode has no use 390 * for them. 391 */ 392 393 #if defined(FEAT_CLIPBOARD) || defined(PROTO) 394 395 /* 396 * Selection stuff using Visual mode, for cutting and pasting text to other 397 * windows. 398 */ 399 400 /* 401 * Call this to initialise the clipboard. Pass it FALSE if the clipboard code 402 * is included, but the clipboard can not be used, or TRUE if the clipboard can 403 * be used. Eg unix may call this with FALSE, then call it again with TRUE if 404 * the GUI starts. 405 */ 406 void 407 clip_init(int can_use) 408 { 409 VimClipboard *cb; 410 411 cb = &clip_star; 412 for (;;) 413 { 414 cb->available = can_use; 415 cb->owned = FALSE; 416 cb->start.lnum = 0; 417 cb->start.col = 0; 418 cb->end.lnum = 0; 419 cb->end.col = 0; 420 cb->state = SELECT_CLEARED; 421 422 if (cb == &clip_plus) 423 break; 424 cb = &clip_plus; 425 } 426 } 427 428 /* 429 * Check whether the VIsual area has changed, and if so try to become the owner 430 * of the selection, and free any old converted selection we may still have 431 * lying around. If the VIsual mode has ended, make a copy of what was 432 * selected so we can still give it to others. Will probably have to make sure 433 * this is called whenever VIsual mode is ended. 434 */ 435 void 436 clip_update_selection(VimClipboard *clip) 437 { 438 pos_T start, end; 439 440 /* If visual mode is only due to a redo command ("."), then ignore it */ 441 if (!redo_VIsual_busy && VIsual_active && (State & NORMAL)) 442 { 443 if (LT_POS(VIsual, curwin->w_cursor)) 444 { 445 start = VIsual; 446 end = curwin->w_cursor; 447 #ifdef FEAT_MBYTE 448 if (has_mbyte) 449 end.col += (*mb_ptr2len)(ml_get_cursor()) - 1; 450 #endif 451 } 452 else 453 { 454 start = curwin->w_cursor; 455 end = VIsual; 456 } 457 if (!EQUAL_POS(clip->start, start) 458 || !EQUAL_POS(clip->end, end) 459 || clip->vmode != VIsual_mode) 460 { 461 clip_clear_selection(clip); 462 clip->start = start; 463 clip->end = end; 464 clip->vmode = VIsual_mode; 465 clip_free_selection(clip); 466 clip_own_selection(clip); 467 clip_gen_set_selection(clip); 468 } 469 } 470 } 471 472 void 473 clip_own_selection(VimClipboard *cbd) 474 { 475 /* 476 * Also want to check somehow that we are reading from the keyboard rather 477 * than a mapping etc. 478 */ 479 #ifdef FEAT_X11 480 /* Always own the selection, we might have lost it without being 481 * notified, e.g. during a ":sh" command. */ 482 if (cbd->available) 483 { 484 int was_owned = cbd->owned; 485 486 cbd->owned = (clip_gen_own_selection(cbd) == OK); 487 if (!was_owned && (cbd == &clip_star || cbd == &clip_plus)) 488 { 489 /* May have to show a different kind of highlighting for the 490 * selected area. There is no specific redraw command for this, 491 * just redraw all windows on the current buffer. */ 492 if (cbd->owned 493 && (get_real_state() == VISUAL 494 || get_real_state() == SELECTMODE) 495 && (cbd == &clip_star ? clip_isautosel_star() 496 : clip_isautosel_plus()) 497 && HL_ATTR(HLF_V) != HL_ATTR(HLF_VNC)) 498 redraw_curbuf_later(INVERTED_ALL); 499 } 500 } 501 #else 502 /* Only own the clipboard when we didn't own it yet. */ 503 if (!cbd->owned && cbd->available) 504 cbd->owned = (clip_gen_own_selection(cbd) == OK); 505 #endif 506 } 507 508 void 509 clip_lose_selection(VimClipboard *cbd) 510 { 511 #ifdef FEAT_X11 512 int was_owned = cbd->owned; 513 #endif 514 int visual_selection = FALSE; 515 516 if (cbd == &clip_star || cbd == &clip_plus) 517 visual_selection = TRUE; 518 519 clip_free_selection(cbd); 520 cbd->owned = FALSE; 521 if (visual_selection) 522 clip_clear_selection(cbd); 523 clip_gen_lose_selection(cbd); 524 #ifdef FEAT_X11 525 if (visual_selection) 526 { 527 /* May have to show a different kind of highlighting for the selected 528 * area. There is no specific redraw command for this, just redraw all 529 * windows on the current buffer. */ 530 if (was_owned 531 && (get_real_state() == VISUAL 532 || get_real_state() == SELECTMODE) 533 && (cbd == &clip_star ? 534 clip_isautosel_star() : clip_isautosel_plus()) 535 && HL_ATTR(HLF_V) != HL_ATTR(HLF_VNC)) 536 { 537 update_curbuf(INVERTED_ALL); 538 setcursor(); 539 cursor_on(); 540 out_flush(); 541 # ifdef FEAT_GUI 542 if (gui.in_use) 543 gui_update_cursor(TRUE, FALSE); 544 # endif 545 } 546 } 547 #endif 548 } 549 550 static void 551 clip_copy_selection(VimClipboard *clip) 552 { 553 if (VIsual_active && (State & NORMAL) && clip->available) 554 { 555 clip_update_selection(clip); 556 clip_free_selection(clip); 557 clip_own_selection(clip); 558 if (clip->owned) 559 clip_get_selection(clip); 560 clip_gen_set_selection(clip); 561 } 562 } 563 564 /* 565 * Save and restore clip_unnamed before doing possibly many changes. This 566 * prevents accessing the clipboard very often which might slow down Vim 567 * considerably. 568 */ 569 static int global_change_count = 0; /* if set, inside a start_global_changes */ 570 static int clipboard_needs_update = FALSE; /* clipboard needs to be updated */ 571 static int clip_did_set_selection = TRUE; 572 573 /* 574 * Save clip_unnamed and reset it. 575 */ 576 void 577 start_global_changes(void) 578 { 579 if (++global_change_count > 1) 580 return; 581 clip_unnamed_saved = clip_unnamed; 582 clipboard_needs_update = FALSE; 583 584 if (clip_did_set_selection) 585 { 586 clip_unnamed = FALSE; 587 clip_did_set_selection = FALSE; 588 } 589 } 590 591 /* 592 * Return TRUE if setting the clipboard was postponed, it already contains the 593 * right text. 594 */ 595 int 596 is_clipboard_needs_update() 597 { 598 return clipboard_needs_update; 599 } 600 601 /* 602 * Restore clip_unnamed and set the selection when needed. 603 */ 604 void 605 end_global_changes(void) 606 { 607 if (--global_change_count > 0) 608 /* recursive */ 609 return; 610 if (!clip_did_set_selection) 611 { 612 clip_did_set_selection = TRUE; 613 clip_unnamed = clip_unnamed_saved; 614 clip_unnamed_saved = FALSE; 615 if (clipboard_needs_update) 616 { 617 /* only store something in the clipboard, 618 * if we have yanked anything to it */ 619 if (clip_unnamed & CLIP_UNNAMED) 620 { 621 clip_own_selection(&clip_star); 622 clip_gen_set_selection(&clip_star); 623 } 624 if (clip_unnamed & CLIP_UNNAMED_PLUS) 625 { 626 clip_own_selection(&clip_plus); 627 clip_gen_set_selection(&clip_plus); 628 } 629 } 630 } 631 clipboard_needs_update = FALSE; 632 } 633 634 /* 635 * Called when Visual mode is ended: update the selection. 636 */ 637 void 638 clip_auto_select(void) 639 { 640 if (clip_isautosel_star()) 641 clip_copy_selection(&clip_star); 642 if (clip_isautosel_plus()) 643 clip_copy_selection(&clip_plus); 644 } 645 646 /* 647 * Return TRUE if automatic selection of Visual area is desired for the * 648 * register. 649 */ 650 int 651 clip_isautosel_star(void) 652 { 653 return ( 654 #ifdef FEAT_GUI 655 gui.in_use ? (vim_strchr(p_go, GO_ASEL) != NULL) : 656 #endif 657 clip_autoselect_star); 658 } 659 660 /* 661 * Return TRUE if automatic selection of Visual area is desired for the + 662 * register. 663 */ 664 int 665 clip_isautosel_plus(void) 666 { 667 return ( 668 #ifdef FEAT_GUI 669 gui.in_use ? (vim_strchr(p_go, GO_ASELPLUS) != NULL) : 670 #endif 671 clip_autoselect_plus); 672 } 673 674 675 /* 676 * Stuff for general mouse selection, without using Visual mode. 677 */ 678 679 static int clip_compare_pos(int row1, int col1, int row2, int col2); 680 static void clip_invert_area(int, int, int, int, int how); 681 static void clip_invert_rectangle(int row, int col, int height, int width, int invert); 682 static void clip_get_word_boundaries(VimClipboard *, int, int); 683 static int clip_get_line_end(int); 684 static void clip_update_modeless_selection(VimClipboard *, int, int, 685 int, int); 686 687 /* flags for clip_invert_area() */ 688 #define CLIP_CLEAR 1 689 #define CLIP_SET 2 690 #define CLIP_TOGGLE 3 691 692 /* 693 * Start, continue or end a modeless selection. Used when editing the 694 * command-line and in the cmdline window. 695 */ 696 void 697 clip_modeless(int button, int is_click, int is_drag) 698 { 699 int repeat; 700 701 repeat = ((clip_star.mode == SELECT_MODE_CHAR 702 || clip_star.mode == SELECT_MODE_LINE) 703 && (mod_mask & MOD_MASK_2CLICK)) 704 || (clip_star.mode == SELECT_MODE_WORD 705 && (mod_mask & MOD_MASK_3CLICK)); 706 if (is_click && button == MOUSE_RIGHT) 707 { 708 /* Right mouse button: If there was no selection, start one. 709 * Otherwise extend the existing selection. */ 710 if (clip_star.state == SELECT_CLEARED) 711 clip_start_selection(mouse_col, mouse_row, FALSE); 712 clip_process_selection(button, mouse_col, mouse_row, repeat); 713 } 714 else if (is_click) 715 clip_start_selection(mouse_col, mouse_row, repeat); 716 else if (is_drag) 717 { 718 /* Don't try extending a selection if there isn't one. Happens when 719 * button-down is in the cmdline and them moving mouse upwards. */ 720 if (clip_star.state != SELECT_CLEARED) 721 clip_process_selection(button, mouse_col, mouse_row, repeat); 722 } 723 else /* release */ 724 clip_process_selection(MOUSE_RELEASE, mouse_col, mouse_row, FALSE); 725 } 726 727 /* 728 * Compare two screen positions ala strcmp() 729 */ 730 static int 731 clip_compare_pos( 732 int row1, 733 int col1, 734 int row2, 735 int col2) 736 { 737 if (row1 > row2) return(1); 738 if (row1 < row2) return(-1); 739 if (col1 > col2) return(1); 740 if (col1 < col2) return(-1); 741 return(0); 742 } 743 744 /* 745 * Start the selection 746 */ 747 void 748 clip_start_selection(int col, int row, int repeated_click) 749 { 750 VimClipboard *cb = &clip_star; 751 752 if (cb->state == SELECT_DONE) 753 clip_clear_selection(cb); 754 755 row = check_row(row); 756 col = check_col(col); 757 #ifdef FEAT_MBYTE 758 col = mb_fix_col(col, row); 759 #endif 760 761 cb->start.lnum = row; 762 cb->start.col = col; 763 cb->end = cb->start; 764 cb->origin_row = (short_u)cb->start.lnum; 765 cb->state = SELECT_IN_PROGRESS; 766 767 if (repeated_click) 768 { 769 if (++cb->mode > SELECT_MODE_LINE) 770 cb->mode = SELECT_MODE_CHAR; 771 } 772 else 773 cb->mode = SELECT_MODE_CHAR; 774 775 #ifdef FEAT_GUI 776 /* clear the cursor until the selection is made */ 777 if (gui.in_use) 778 gui_undraw_cursor(); 779 #endif 780 781 switch (cb->mode) 782 { 783 case SELECT_MODE_CHAR: 784 cb->origin_start_col = cb->start.col; 785 cb->word_end_col = clip_get_line_end((int)cb->start.lnum); 786 break; 787 788 case SELECT_MODE_WORD: 789 clip_get_word_boundaries(cb, (int)cb->start.lnum, cb->start.col); 790 cb->origin_start_col = cb->word_start_col; 791 cb->origin_end_col = cb->word_end_col; 792 793 clip_invert_area((int)cb->start.lnum, cb->word_start_col, 794 (int)cb->end.lnum, cb->word_end_col, CLIP_SET); 795 cb->start.col = cb->word_start_col; 796 cb->end.col = cb->word_end_col; 797 break; 798 799 case SELECT_MODE_LINE: 800 clip_invert_area((int)cb->start.lnum, 0, (int)cb->start.lnum, 801 (int)Columns, CLIP_SET); 802 cb->start.col = 0; 803 cb->end.col = Columns; 804 break; 805 } 806 807 cb->prev = cb->start; 808 809 #ifdef DEBUG_SELECTION 810 printf("Selection started at (%u,%u)\n", cb->start.lnum, cb->start.col); 811 #endif 812 } 813 814 /* 815 * Continue processing the selection 816 */ 817 void 818 clip_process_selection( 819 int button, 820 int col, 821 int row, 822 int_u repeated_click) 823 { 824 VimClipboard *cb = &clip_star; 825 int diff; 826 int slen = 1; /* cursor shape width */ 827 828 if (button == MOUSE_RELEASE) 829 { 830 /* Check to make sure we have something selected */ 831 if (cb->start.lnum == cb->end.lnum && cb->start.col == cb->end.col) 832 { 833 #ifdef FEAT_GUI 834 if (gui.in_use) 835 gui_update_cursor(FALSE, FALSE); 836 #endif 837 cb->state = SELECT_CLEARED; 838 return; 839 } 840 841 #ifdef DEBUG_SELECTION 842 printf("Selection ended: (%u,%u) to (%u,%u)\n", cb->start.lnum, 843 cb->start.col, cb->end.lnum, cb->end.col); 844 #endif 845 if (clip_isautosel_star() 846 || ( 847 #ifdef FEAT_GUI 848 gui.in_use ? (vim_strchr(p_go, GO_ASELML) != NULL) : 849 #endif 850 clip_autoselectml)) 851 clip_copy_modeless_selection(FALSE); 852 #ifdef FEAT_GUI 853 if (gui.in_use) 854 gui_update_cursor(FALSE, FALSE); 855 #endif 856 857 cb->state = SELECT_DONE; 858 return; 859 } 860 861 row = check_row(row); 862 col = check_col(col); 863 #ifdef FEAT_MBYTE 864 col = mb_fix_col(col, row); 865 #endif 866 867 if (col == (int)cb->prev.col && row == cb->prev.lnum && !repeated_click) 868 return; 869 870 /* 871 * When extending the selection with the right mouse button, swap the 872 * start and end if the position is before half the selection 873 */ 874 if (cb->state == SELECT_DONE && button == MOUSE_RIGHT) 875 { 876 /* 877 * If the click is before the start, or the click is inside the 878 * selection and the start is the closest side, set the origin to the 879 * end of the selection. 880 */ 881 if (clip_compare_pos(row, col, (int)cb->start.lnum, cb->start.col) < 0 882 || (clip_compare_pos(row, col, 883 (int)cb->end.lnum, cb->end.col) < 0 884 && (((cb->start.lnum == cb->end.lnum 885 && cb->end.col - col > col - cb->start.col)) 886 || ((diff = (cb->end.lnum - row) - 887 (row - cb->start.lnum)) > 0 888 || (diff == 0 && col < (int)(cb->start.col + 889 cb->end.col) / 2))))) 890 { 891 cb->origin_row = (short_u)cb->end.lnum; 892 cb->origin_start_col = cb->end.col - 1; 893 cb->origin_end_col = cb->end.col; 894 } 895 else 896 { 897 cb->origin_row = (short_u)cb->start.lnum; 898 cb->origin_start_col = cb->start.col; 899 cb->origin_end_col = cb->start.col; 900 } 901 if (cb->mode == SELECT_MODE_WORD && !repeated_click) 902 cb->mode = SELECT_MODE_CHAR; 903 } 904 905 /* set state, for when using the right mouse button */ 906 cb->state = SELECT_IN_PROGRESS; 907 908 #ifdef DEBUG_SELECTION 909 printf("Selection extending to (%d,%d)\n", row, col); 910 #endif 911 912 if (repeated_click && ++cb->mode > SELECT_MODE_LINE) 913 cb->mode = SELECT_MODE_CHAR; 914 915 switch (cb->mode) 916 { 917 case SELECT_MODE_CHAR: 918 /* If we're on a different line, find where the line ends */ 919 if (row != cb->prev.lnum) 920 cb->word_end_col = clip_get_line_end(row); 921 922 /* See if we are before or after the origin of the selection */ 923 if (clip_compare_pos(row, col, cb->origin_row, 924 cb->origin_start_col) >= 0) 925 { 926 if (col >= (int)cb->word_end_col) 927 clip_update_modeless_selection(cb, cb->origin_row, 928 cb->origin_start_col, row, (int)Columns); 929 else 930 { 931 #ifdef FEAT_MBYTE 932 if (has_mbyte && mb_lefthalve(row, col)) 933 slen = 2; 934 #endif 935 clip_update_modeless_selection(cb, cb->origin_row, 936 cb->origin_start_col, row, col + slen); 937 } 938 } 939 else 940 { 941 #ifdef FEAT_MBYTE 942 if (has_mbyte 943 && mb_lefthalve(cb->origin_row, cb->origin_start_col)) 944 slen = 2; 945 #endif 946 if (col >= (int)cb->word_end_col) 947 clip_update_modeless_selection(cb, row, cb->word_end_col, 948 cb->origin_row, cb->origin_start_col + slen); 949 else 950 clip_update_modeless_selection(cb, row, col, 951 cb->origin_row, cb->origin_start_col + slen); 952 } 953 break; 954 955 case SELECT_MODE_WORD: 956 /* If we are still within the same word, do nothing */ 957 if (row == cb->prev.lnum && col >= (int)cb->word_start_col 958 && col < (int)cb->word_end_col && !repeated_click) 959 return; 960 961 /* Get new word boundaries */ 962 clip_get_word_boundaries(cb, row, col); 963 964 /* Handle being after the origin point of selection */ 965 if (clip_compare_pos(row, col, cb->origin_row, 966 cb->origin_start_col) >= 0) 967 clip_update_modeless_selection(cb, cb->origin_row, 968 cb->origin_start_col, row, cb->word_end_col); 969 else 970 clip_update_modeless_selection(cb, row, cb->word_start_col, 971 cb->origin_row, cb->origin_end_col); 972 break; 973 974 case SELECT_MODE_LINE: 975 if (row == cb->prev.lnum && !repeated_click) 976 return; 977 978 if (clip_compare_pos(row, col, cb->origin_row, 979 cb->origin_start_col) >= 0) 980 clip_update_modeless_selection(cb, cb->origin_row, 0, row, 981 (int)Columns); 982 else 983 clip_update_modeless_selection(cb, row, 0, cb->origin_row, 984 (int)Columns); 985 break; 986 } 987 988 cb->prev.lnum = row; 989 cb->prev.col = col; 990 991 #ifdef DEBUG_SELECTION 992 printf("Selection is: (%u,%u) to (%u,%u)\n", cb->start.lnum, 993 cb->start.col, cb->end.lnum, cb->end.col); 994 #endif 995 } 996 997 # if defined(FEAT_GUI) || defined(PROTO) 998 /* 999 * Redraw part of the selection if character at "row,col" is inside of it. 1000 * Only used for the GUI. 1001 */ 1002 void 1003 clip_may_redraw_selection(int row, int col, int len) 1004 { 1005 int start = col; 1006 int end = col + len; 1007 1008 if (clip_star.state != SELECT_CLEARED 1009 && row >= clip_star.start.lnum 1010 && row <= clip_star.end.lnum) 1011 { 1012 if (row == clip_star.start.lnum && start < (int)clip_star.start.col) 1013 start = clip_star.start.col; 1014 if (row == clip_star.end.lnum && end > (int)clip_star.end.col) 1015 end = clip_star.end.col; 1016 if (end > start) 1017 clip_invert_area(row, start, row, end, 0); 1018 } 1019 } 1020 # endif 1021 1022 /* 1023 * Called from outside to clear selected region from the display 1024 */ 1025 void 1026 clip_clear_selection(VimClipboard *cbd) 1027 { 1028 1029 if (cbd->state == SELECT_CLEARED) 1030 return; 1031 1032 clip_invert_area((int)cbd->start.lnum, cbd->start.col, (int)cbd->end.lnum, 1033 cbd->end.col, CLIP_CLEAR); 1034 cbd->state = SELECT_CLEARED; 1035 } 1036 1037 /* 1038 * Clear the selection if any lines from "row1" to "row2" are inside of it. 1039 */ 1040 void 1041 clip_may_clear_selection(int row1, int row2) 1042 { 1043 if (clip_star.state == SELECT_DONE 1044 && row2 >= clip_star.start.lnum 1045 && row1 <= clip_star.end.lnum) 1046 clip_clear_selection(&clip_star); 1047 } 1048 1049 /* 1050 * Called before the screen is scrolled up or down. Adjusts the line numbers 1051 * of the selection. Call with big number when clearing the screen. 1052 */ 1053 void 1054 clip_scroll_selection( 1055 int rows) /* negative for scroll down */ 1056 { 1057 int lnum; 1058 1059 if (clip_star.state == SELECT_CLEARED) 1060 return; 1061 1062 lnum = clip_star.start.lnum - rows; 1063 if (lnum <= 0) 1064 clip_star.start.lnum = 0; 1065 else if (lnum >= screen_Rows) /* scrolled off of the screen */ 1066 clip_star.state = SELECT_CLEARED; 1067 else 1068 clip_star.start.lnum = lnum; 1069 1070 lnum = clip_star.end.lnum - rows; 1071 if (lnum < 0) /* scrolled off of the screen */ 1072 clip_star.state = SELECT_CLEARED; 1073 else if (lnum >= screen_Rows) 1074 clip_star.end.lnum = screen_Rows - 1; 1075 else 1076 clip_star.end.lnum = lnum; 1077 } 1078 1079 /* 1080 * Invert a region of the display between a starting and ending row and column 1081 * Values for "how": 1082 * CLIP_CLEAR: undo inversion 1083 * CLIP_SET: set inversion 1084 * CLIP_TOGGLE: set inversion if pos1 < pos2, undo inversion otherwise. 1085 * 0: invert (GUI only). 1086 */ 1087 static void 1088 clip_invert_area( 1089 int row1, 1090 int col1, 1091 int row2, 1092 int col2, 1093 int how) 1094 { 1095 int invert = FALSE; 1096 1097 if (how == CLIP_SET) 1098 invert = TRUE; 1099 1100 /* Swap the from and to positions so the from is always before */ 1101 if (clip_compare_pos(row1, col1, row2, col2) > 0) 1102 { 1103 int tmp_row, tmp_col; 1104 1105 tmp_row = row1; 1106 tmp_col = col1; 1107 row1 = row2; 1108 col1 = col2; 1109 row2 = tmp_row; 1110 col2 = tmp_col; 1111 } 1112 else if (how == CLIP_TOGGLE) 1113 invert = TRUE; 1114 1115 /* If all on the same line, do it the easy way */ 1116 if (row1 == row2) 1117 { 1118 clip_invert_rectangle(row1, col1, 1, col2 - col1, invert); 1119 } 1120 else 1121 { 1122 /* Handle a piece of the first line */ 1123 if (col1 > 0) 1124 { 1125 clip_invert_rectangle(row1, col1, 1, (int)Columns - col1, invert); 1126 row1++; 1127 } 1128 1129 /* Handle a piece of the last line */ 1130 if (col2 < Columns - 1) 1131 { 1132 clip_invert_rectangle(row2, 0, 1, col2, invert); 1133 row2--; 1134 } 1135 1136 /* Handle the rectangle thats left */ 1137 if (row2 >= row1) 1138 clip_invert_rectangle(row1, 0, row2 - row1 + 1, (int)Columns, 1139 invert); 1140 } 1141 } 1142 1143 /* 1144 * Invert or un-invert a rectangle of the screen. 1145 * "invert" is true if the result is inverted. 1146 */ 1147 static void 1148 clip_invert_rectangle( 1149 int row, 1150 int col, 1151 int height, 1152 int width, 1153 int invert) 1154 { 1155 #ifdef FEAT_GUI 1156 if (gui.in_use) 1157 gui_mch_invert_rectangle(row, col, height, width); 1158 else 1159 #endif 1160 screen_draw_rectangle(row, col, height, width, invert); 1161 } 1162 1163 /* 1164 * Copy the currently selected area into the '*' register so it will be 1165 * available for pasting. 1166 * When "both" is TRUE also copy to the '+' register. 1167 */ 1168 void 1169 clip_copy_modeless_selection(int both UNUSED) 1170 { 1171 char_u *buffer; 1172 char_u *bufp; 1173 int row; 1174 int start_col; 1175 int end_col; 1176 int line_end_col; 1177 int add_newline_flag = FALSE; 1178 int len; 1179 #ifdef FEAT_MBYTE 1180 char_u *p; 1181 #endif 1182 int row1 = clip_star.start.lnum; 1183 int col1 = clip_star.start.col; 1184 int row2 = clip_star.end.lnum; 1185 int col2 = clip_star.end.col; 1186 1187 /* Can't use ScreenLines unless initialized */ 1188 if (ScreenLines == NULL) 1189 return; 1190 1191 /* 1192 * Make sure row1 <= row2, and if row1 == row2 that col1 <= col2. 1193 */ 1194 if (row1 > row2) 1195 { 1196 row = row1; row1 = row2; row2 = row; 1197 row = col1; col1 = col2; col2 = row; 1198 } 1199 else if (row1 == row2 && col1 > col2) 1200 { 1201 row = col1; col1 = col2; col2 = row; 1202 } 1203 #ifdef FEAT_MBYTE 1204 /* correct starting point for being on right halve of double-wide char */ 1205 p = ScreenLines + LineOffset[row1]; 1206 if (enc_dbcs != 0) 1207 col1 -= (*mb_head_off)(p, p + col1); 1208 else if (enc_utf8 && p[col1] == 0) 1209 --col1; 1210 #endif 1211 1212 /* Create a temporary buffer for storing the text */ 1213 len = (row2 - row1 + 1) * Columns + 1; 1214 #ifdef FEAT_MBYTE 1215 if (enc_dbcs != 0) 1216 len *= 2; /* max. 2 bytes per display cell */ 1217 else if (enc_utf8) 1218 len *= MB_MAXBYTES; 1219 #endif 1220 buffer = lalloc((long_u)len, TRUE); 1221 if (buffer == NULL) /* out of memory */ 1222 return; 1223 1224 /* Process each row in the selection */ 1225 for (bufp = buffer, row = row1; row <= row2; row++) 1226 { 1227 if (row == row1) 1228 start_col = col1; 1229 else 1230 start_col = 0; 1231 1232 if (row == row2) 1233 end_col = col2; 1234 else 1235 end_col = Columns; 1236 1237 line_end_col = clip_get_line_end(row); 1238 1239 /* See if we need to nuke some trailing whitespace */ 1240 if (end_col >= Columns && (row < row2 || end_col > line_end_col)) 1241 { 1242 /* Get rid of trailing whitespace */ 1243 end_col = line_end_col; 1244 if (end_col < start_col) 1245 end_col = start_col; 1246 1247 /* If the last line extended to the end, add an extra newline */ 1248 if (row == row2) 1249 add_newline_flag = TRUE; 1250 } 1251 1252 /* If after the first row, we need to always add a newline */ 1253 if (row > row1 && !LineWraps[row - 1]) 1254 *bufp++ = NL; 1255 1256 if (row < screen_Rows && end_col <= screen_Columns) 1257 { 1258 #ifdef FEAT_MBYTE 1259 if (enc_dbcs != 0) 1260 { 1261 int i; 1262 1263 p = ScreenLines + LineOffset[row]; 1264 for (i = start_col; i < end_col; ++i) 1265 if (enc_dbcs == DBCS_JPNU && p[i] == 0x8e) 1266 { 1267 /* single-width double-byte char */ 1268 *bufp++ = 0x8e; 1269 *bufp++ = ScreenLines2[LineOffset[row] + i]; 1270 } 1271 else 1272 { 1273 *bufp++ = p[i]; 1274 if (MB_BYTE2LEN(p[i]) == 2) 1275 *bufp++ = p[++i]; 1276 } 1277 } 1278 else if (enc_utf8) 1279 { 1280 int off; 1281 int i; 1282 int ci; 1283 1284 off = LineOffset[row]; 1285 for (i = start_col; i < end_col; ++i) 1286 { 1287 /* The base character is either in ScreenLinesUC[] or 1288 * ScreenLines[]. */ 1289 if (ScreenLinesUC[off + i] == 0) 1290 *bufp++ = ScreenLines[off + i]; 1291 else 1292 { 1293 bufp += utf_char2bytes(ScreenLinesUC[off + i], bufp); 1294 for (ci = 0; ci < Screen_mco; ++ci) 1295 { 1296 /* Add a composing character. */ 1297 if (ScreenLinesC[ci][off + i] == 0) 1298 break; 1299 bufp += utf_char2bytes(ScreenLinesC[ci][off + i], 1300 bufp); 1301 } 1302 } 1303 /* Skip right halve of double-wide character. */ 1304 if (ScreenLines[off + i + 1] == 0) 1305 ++i; 1306 } 1307 } 1308 else 1309 #endif 1310 { 1311 STRNCPY(bufp, ScreenLines + LineOffset[row] + start_col, 1312 end_col - start_col); 1313 bufp += end_col - start_col; 1314 } 1315 } 1316 } 1317 1318 /* Add a newline at the end if the selection ended there */ 1319 if (add_newline_flag) 1320 *bufp++ = NL; 1321 1322 /* First cleanup any old selection and become the owner. */ 1323 clip_free_selection(&clip_star); 1324 clip_own_selection(&clip_star); 1325 1326 /* Yank the text into the '*' register. */ 1327 clip_yank_selection(MCHAR, buffer, (long)(bufp - buffer), &clip_star); 1328 1329 /* Make the register contents available to the outside world. */ 1330 clip_gen_set_selection(&clip_star); 1331 1332 #ifdef FEAT_X11 1333 if (both) 1334 { 1335 /* Do the same for the '+' register. */ 1336 clip_free_selection(&clip_plus); 1337 clip_own_selection(&clip_plus); 1338 clip_yank_selection(MCHAR, buffer, (long)(bufp - buffer), &clip_plus); 1339 clip_gen_set_selection(&clip_plus); 1340 } 1341 #endif 1342 vim_free(buffer); 1343 } 1344 1345 /* 1346 * Find the starting and ending positions of the word at the given row and 1347 * column. Only white-separated words are recognized here. 1348 */ 1349 #define CHAR_CLASS(c) (c <= ' ' ? ' ' : vim_iswordc(c)) 1350 1351 static void 1352 clip_get_word_boundaries(VimClipboard *cb, int row, int col) 1353 { 1354 int start_class; 1355 int temp_col; 1356 char_u *p; 1357 #ifdef FEAT_MBYTE 1358 int mboff; 1359 #endif 1360 1361 if (row >= screen_Rows || col >= screen_Columns || ScreenLines == NULL) 1362 return; 1363 1364 p = ScreenLines + LineOffset[row]; 1365 #ifdef FEAT_MBYTE 1366 /* Correct for starting in the right halve of a double-wide char */ 1367 if (enc_dbcs != 0) 1368 col -= dbcs_screen_head_off(p, p + col); 1369 else if (enc_utf8 && p[col] == 0) 1370 --col; 1371 #endif 1372 start_class = CHAR_CLASS(p[col]); 1373 1374 temp_col = col; 1375 for ( ; temp_col > 0; temp_col--) 1376 #ifdef FEAT_MBYTE 1377 if (enc_dbcs != 0 1378 && (mboff = dbcs_screen_head_off(p, p + temp_col - 1)) > 0) 1379 temp_col -= mboff; 1380 else 1381 #endif 1382 if (CHAR_CLASS(p[temp_col - 1]) != start_class 1383 #ifdef FEAT_MBYTE 1384 && !(enc_utf8 && p[temp_col - 1] == 0) 1385 #endif 1386 ) 1387 break; 1388 cb->word_start_col = temp_col; 1389 1390 temp_col = col; 1391 for ( ; temp_col < screen_Columns; temp_col++) 1392 #ifdef FEAT_MBYTE 1393 if (enc_dbcs != 0 && dbcs_ptr2cells(p + temp_col) == 2) 1394 ++temp_col; 1395 else 1396 #endif 1397 if (CHAR_CLASS(p[temp_col]) != start_class 1398 #ifdef FEAT_MBYTE 1399 && !(enc_utf8 && p[temp_col] == 0) 1400 #endif 1401 ) 1402 break; 1403 cb->word_end_col = temp_col; 1404 } 1405 1406 /* 1407 * Find the column position for the last non-whitespace character on the given 1408 * line. 1409 */ 1410 static int 1411 clip_get_line_end(int row) 1412 { 1413 int i; 1414 1415 if (row >= screen_Rows || ScreenLines == NULL) 1416 return 0; 1417 for (i = screen_Columns; i > 0; i--) 1418 if (ScreenLines[LineOffset[row] + i - 1] != ' ') 1419 break; 1420 return i; 1421 } 1422 1423 /* 1424 * Update the currently selected region by adding and/or subtracting from the 1425 * beginning or end and inverting the changed area(s). 1426 */ 1427 static void 1428 clip_update_modeless_selection( 1429 VimClipboard *cb, 1430 int row1, 1431 int col1, 1432 int row2, 1433 int col2) 1434 { 1435 /* See if we changed at the beginning of the selection */ 1436 if (row1 != cb->start.lnum || col1 != (int)cb->start.col) 1437 { 1438 clip_invert_area(row1, col1, (int)cb->start.lnum, cb->start.col, 1439 CLIP_TOGGLE); 1440 cb->start.lnum = row1; 1441 cb->start.col = col1; 1442 } 1443 1444 /* See if we changed at the end of the selection */ 1445 if (row2 != cb->end.lnum || col2 != (int)cb->end.col) 1446 { 1447 clip_invert_area((int)cb->end.lnum, cb->end.col, row2, col2, 1448 CLIP_TOGGLE); 1449 cb->end.lnum = row2; 1450 cb->end.col = col2; 1451 } 1452 } 1453 1454 int 1455 clip_gen_own_selection(VimClipboard *cbd) 1456 { 1457 #ifdef FEAT_XCLIPBOARD 1458 # ifdef FEAT_GUI 1459 if (gui.in_use) 1460 return clip_mch_own_selection(cbd); 1461 else 1462 # endif 1463 return clip_xterm_own_selection(cbd); 1464 #else 1465 return clip_mch_own_selection(cbd); 1466 #endif 1467 } 1468 1469 void 1470 clip_gen_lose_selection(VimClipboard *cbd) 1471 { 1472 #ifdef FEAT_XCLIPBOARD 1473 # ifdef FEAT_GUI 1474 if (gui.in_use) 1475 clip_mch_lose_selection(cbd); 1476 else 1477 # endif 1478 clip_xterm_lose_selection(cbd); 1479 #else 1480 clip_mch_lose_selection(cbd); 1481 #endif 1482 } 1483 1484 void 1485 clip_gen_set_selection(VimClipboard *cbd) 1486 { 1487 if (!clip_did_set_selection) 1488 { 1489 /* Updating postponed, so that accessing the system clipboard won't 1490 * hang Vim when accessing it many times (e.g. on a :g comand). */ 1491 if ((cbd == &clip_plus && (clip_unnamed_saved & CLIP_UNNAMED_PLUS)) 1492 || (cbd == &clip_star && (clip_unnamed_saved & CLIP_UNNAMED))) 1493 { 1494 clipboard_needs_update = TRUE; 1495 return; 1496 } 1497 } 1498 #ifdef FEAT_XCLIPBOARD 1499 # ifdef FEAT_GUI 1500 if (gui.in_use) 1501 clip_mch_set_selection(cbd); 1502 else 1503 # endif 1504 clip_xterm_set_selection(cbd); 1505 #else 1506 clip_mch_set_selection(cbd); 1507 #endif 1508 } 1509 1510 void 1511 clip_gen_request_selection(VimClipboard *cbd) 1512 { 1513 #ifdef FEAT_XCLIPBOARD 1514 # ifdef FEAT_GUI 1515 if (gui.in_use) 1516 clip_mch_request_selection(cbd); 1517 else 1518 # endif 1519 clip_xterm_request_selection(cbd); 1520 #else 1521 clip_mch_request_selection(cbd); 1522 #endif 1523 } 1524 1525 int 1526 clip_gen_owner_exists(VimClipboard *cbd UNUSED) 1527 { 1528 #ifdef FEAT_XCLIPBOARD 1529 # ifdef FEAT_GUI_GTK 1530 if (gui.in_use) 1531 return clip_gtk_owner_exists(cbd); 1532 else 1533 # endif 1534 return clip_x11_owner_exists(cbd); 1535 #else 1536 return TRUE; 1537 #endif 1538 } 1539 1540 #endif /* FEAT_CLIPBOARD */ 1541 1542 /***************************************************************************** 1543 * Functions that handle the input buffer. 1544 * This is used for any GUI version, and the unix terminal version. 1545 * 1546 * For Unix, the input characters are buffered to be able to check for a 1547 * CTRL-C. This should be done with signals, but I don't know how to do that 1548 * in a portable way for a tty in RAW mode. 1549 * 1550 * For the client-server code in the console the received keys are put in the 1551 * input buffer. 1552 */ 1553 1554 #if defined(USE_INPUT_BUF) || defined(PROTO) 1555 1556 /* 1557 * Internal typeahead buffer. Includes extra space for long key code 1558 * descriptions which would otherwise overflow. The buffer is considered full 1559 * when only this extra space (or part of it) remains. 1560 */ 1561 #if defined(FEAT_SUN_WORKSHOP) || defined(FEAT_JOB_CHANNEL) \ 1562 || defined(FEAT_CLIENTSERVER) 1563 /* 1564 * Sun WorkShop and NetBeans stuff debugger commands into the input buffer. 1565 * This requires a larger buffer... 1566 * (Madsen) Go with this for remote input as well ... 1567 */ 1568 # define INBUFLEN 4096 1569 #else 1570 # define INBUFLEN 250 1571 #endif 1572 1573 static char_u inbuf[INBUFLEN + MAX_KEY_CODE_LEN]; 1574 static int inbufcount = 0; /* number of chars in inbuf[] */ 1575 1576 /* 1577 * vim_is_input_buf_full(), vim_is_input_buf_empty(), add_to_input_buf(), and 1578 * trash_input_buf() are functions for manipulating the input buffer. These 1579 * are used by the gui_* calls when a GUI is used to handle keyboard input. 1580 */ 1581 1582 int 1583 vim_is_input_buf_full(void) 1584 { 1585 return (inbufcount >= INBUFLEN); 1586 } 1587 1588 int 1589 vim_is_input_buf_empty(void) 1590 { 1591 return (inbufcount == 0); 1592 } 1593 1594 #if defined(FEAT_OLE) || defined(PROTO) 1595 int 1596 vim_free_in_input_buf(void) 1597 { 1598 return (INBUFLEN - inbufcount); 1599 } 1600 #endif 1601 1602 #if defined(FEAT_GUI_GTK) || defined(PROTO) 1603 int 1604 vim_used_in_input_buf(void) 1605 { 1606 return inbufcount; 1607 } 1608 #endif 1609 1610 /* 1611 * Return the current contents of the input buffer and make it empty. 1612 * The returned pointer must be passed to set_input_buf() later. 1613 */ 1614 char_u * 1615 get_input_buf(void) 1616 { 1617 garray_T *gap; 1618 1619 /* We use a growarray to store the data pointer and the length. */ 1620 gap = (garray_T *)alloc((unsigned)sizeof(garray_T)); 1621 if (gap != NULL) 1622 { 1623 /* Add one to avoid a zero size. */ 1624 gap->ga_data = alloc((unsigned)inbufcount + 1); 1625 if (gap->ga_data != NULL) 1626 mch_memmove(gap->ga_data, inbuf, (size_t)inbufcount); 1627 gap->ga_len = inbufcount; 1628 } 1629 trash_input_buf(); 1630 return (char_u *)gap; 1631 } 1632 1633 /* 1634 * Restore the input buffer with a pointer returned from get_input_buf(). 1635 * The allocated memory is freed, this only works once! 1636 */ 1637 void 1638 set_input_buf(char_u *p) 1639 { 1640 garray_T *gap = (garray_T *)p; 1641 1642 if (gap != NULL) 1643 { 1644 if (gap->ga_data != NULL) 1645 { 1646 mch_memmove(inbuf, gap->ga_data, gap->ga_len); 1647 inbufcount = gap->ga_len; 1648 vim_free(gap->ga_data); 1649 } 1650 vim_free(gap); 1651 } 1652 } 1653 1654 #if defined(FEAT_GUI) \ 1655 || defined(FEAT_MOUSE_GPM) || defined(FEAT_SYSMOUSE) \ 1656 || defined(FEAT_XCLIPBOARD) || defined(VMS) \ 1657 || defined(FEAT_CLIENTSERVER) \ 1658 || defined(PROTO) 1659 /* 1660 * Add the given bytes to the input buffer 1661 * Special keys start with CSI. A real CSI must have been translated to 1662 * CSI KS_EXTRA KE_CSI. K_SPECIAL doesn't require translation. 1663 */ 1664 void 1665 add_to_input_buf(char_u *s, int len) 1666 { 1667 if (inbufcount + len > INBUFLEN + MAX_KEY_CODE_LEN) 1668 return; /* Shouldn't ever happen! */ 1669 1670 #ifdef FEAT_HANGULIN 1671 if ((State & (INSERT|CMDLINE)) && hangul_input_state_get()) 1672 if ((len = hangul_input_process(s, len)) == 0) 1673 return; 1674 #endif 1675 1676 while (len--) 1677 inbuf[inbufcount++] = *s++; 1678 } 1679 #endif 1680 1681 #if ((defined(FEAT_XIM) || defined(FEAT_DND)) && defined(FEAT_GUI_GTK)) \ 1682 || defined(FEAT_GUI_MSWIN) \ 1683 || defined(FEAT_GUI_MAC) \ 1684 || (defined(FEAT_MBYTE) && defined(FEAT_MBYTE_IME)) \ 1685 || (defined(FEAT_GUI) && (!defined(USE_ON_FLY_SCROLL) \ 1686 || defined(FEAT_MENU))) \ 1687 || defined(PROTO) 1688 /* 1689 * Add "str[len]" to the input buffer while escaping CSI bytes. 1690 */ 1691 void 1692 add_to_input_buf_csi(char_u *str, int len) 1693 { 1694 int i; 1695 char_u buf[2]; 1696 1697 for (i = 0; i < len; ++i) 1698 { 1699 add_to_input_buf(str + i, 1); 1700 if (str[i] == CSI) 1701 { 1702 /* Turn CSI into K_CSI. */ 1703 buf[0] = KS_EXTRA; 1704 buf[1] = (int)KE_CSI; 1705 add_to_input_buf(buf, 2); 1706 } 1707 } 1708 } 1709 #endif 1710 1711 #if defined(FEAT_HANGULIN) || defined(PROTO) 1712 void 1713 push_raw_key(char_u *s, int len) 1714 { 1715 char_u *tmpbuf; 1716 char_u *inp = s; 1717 1718 /* use the conversion result if possible */ 1719 tmpbuf = hangul_string_convert(s, &len); 1720 if (tmpbuf != NULL) 1721 inp = tmpbuf; 1722 1723 for (; len--; inp++) 1724 { 1725 inbuf[inbufcount++] = *inp; 1726 if (*inp == CSI) 1727 { 1728 /* Turn CSI into K_CSI. */ 1729 inbuf[inbufcount++] = KS_EXTRA; 1730 inbuf[inbufcount++] = (int)KE_CSI; 1731 } 1732 } 1733 vim_free(tmpbuf); 1734 } 1735 #endif 1736 1737 /* Remove everything from the input buffer. Called when ^C is found */ 1738 void 1739 trash_input_buf(void) 1740 { 1741 inbufcount = 0; 1742 } 1743 1744 /* 1745 * Read as much data from the input buffer as possible up to maxlen, and store 1746 * it in buf. 1747 * Note: this function used to be Read() in unix.c 1748 */ 1749 int 1750 read_from_input_buf(char_u *buf, long maxlen) 1751 { 1752 if (inbufcount == 0) /* if the buffer is empty, fill it */ 1753 fill_input_buf(TRUE); 1754 if (maxlen > inbufcount) 1755 maxlen = inbufcount; 1756 mch_memmove(buf, inbuf, (size_t)maxlen); 1757 inbufcount -= maxlen; 1758 if (inbufcount) 1759 mch_memmove(inbuf, inbuf + maxlen, (size_t)inbufcount); 1760 return (int)maxlen; 1761 } 1762 1763 void 1764 fill_input_buf(int exit_on_error UNUSED) 1765 { 1766 #if defined(UNIX) || defined(VMS) || defined(MACOS_X_UNIX) 1767 int len; 1768 int try; 1769 static int did_read_something = FALSE; 1770 # ifdef FEAT_MBYTE 1771 static char_u *rest = NULL; /* unconverted rest of previous read */ 1772 static int restlen = 0; 1773 int unconverted; 1774 # endif 1775 #endif 1776 1777 #ifdef FEAT_GUI 1778 if (gui.in_use 1779 # ifdef NO_CONSOLE_INPUT 1780 /* Don't use the GUI input when the window hasn't been opened yet. 1781 * We get here from ui_inchar() when we should try reading from stdin. */ 1782 && !no_console_input() 1783 # endif 1784 ) 1785 { 1786 gui_mch_update(); 1787 return; 1788 } 1789 #endif 1790 #if defined(UNIX) || defined(VMS) || defined(MACOS_X_UNIX) 1791 if (vim_is_input_buf_full()) 1792 return; 1793 /* 1794 * Fill_input_buf() is only called when we really need a character. 1795 * If we can't get any, but there is some in the buffer, just return. 1796 * If we can't get any, and there isn't any in the buffer, we give up and 1797 * exit Vim. 1798 */ 1799 # ifdef __BEOS__ 1800 /* 1801 * On the BeBox version (for now), all input is secretly performed within 1802 * beos_select() which is called from RealWaitForChar(). 1803 */ 1804 while (!vim_is_input_buf_full() && RealWaitForChar(read_cmd_fd, 0, NULL)) 1805 ; 1806 len = inbufcount; 1807 inbufcount = 0; 1808 # else 1809 1810 # ifdef FEAT_MBYTE 1811 if (rest != NULL) 1812 { 1813 /* Use remainder of previous call, starts with an invalid character 1814 * that may become valid when reading more. */ 1815 if (restlen > INBUFLEN - inbufcount) 1816 unconverted = INBUFLEN - inbufcount; 1817 else 1818 unconverted = restlen; 1819 mch_memmove(inbuf + inbufcount, rest, unconverted); 1820 if (unconverted == restlen) 1821 { 1822 vim_free(rest); 1823 rest = NULL; 1824 } 1825 else 1826 { 1827 restlen -= unconverted; 1828 mch_memmove(rest, rest + unconverted, restlen); 1829 } 1830 inbufcount += unconverted; 1831 } 1832 else 1833 unconverted = 0; 1834 # endif 1835 1836 len = 0; /* to avoid gcc warning */ 1837 for (try = 0; try < 100; ++try) 1838 { 1839 # ifdef VMS 1840 len = vms_read( 1841 # else 1842 len = read(read_cmd_fd, 1843 # endif 1844 (char *)inbuf + inbufcount, (size_t)((INBUFLEN - inbufcount) 1845 # ifdef FEAT_MBYTE 1846 / input_conv.vc_factor 1847 # endif 1848 )); 1849 # if 0 1850 ) /* avoid syntax highlight error */ 1851 # endif 1852 1853 if (len > 0 || got_int) 1854 break; 1855 /* 1856 * If reading stdin results in an error, continue reading stderr. 1857 * This helps when using "foo | xargs vim". 1858 */ 1859 if (!did_read_something && !isatty(read_cmd_fd) && read_cmd_fd == 0) 1860 { 1861 int m = cur_tmode; 1862 1863 /* We probably set the wrong file descriptor to raw mode. Switch 1864 * back to cooked mode, use another descriptor and set the mode to 1865 * what it was. */ 1866 settmode(TMODE_COOK); 1867 #ifdef HAVE_DUP 1868 /* Use stderr for stdin, also works for shell commands. */ 1869 close(0); 1870 ignored = dup(2); 1871 #else 1872 read_cmd_fd = 2; /* read from stderr instead of stdin */ 1873 #endif 1874 settmode(m); 1875 } 1876 if (!exit_on_error) 1877 return; 1878 } 1879 # endif 1880 if (len <= 0 && !got_int) 1881 read_error_exit(); 1882 if (len > 0) 1883 did_read_something = TRUE; 1884 if (got_int) 1885 { 1886 /* Interrupted, pretend a CTRL-C was typed. */ 1887 inbuf[0] = 3; 1888 inbufcount = 1; 1889 } 1890 else 1891 { 1892 # ifdef FEAT_MBYTE 1893 /* 1894 * May perform conversion on the input characters. 1895 * Include the unconverted rest of the previous call. 1896 * If there is an incomplete char at the end it is kept for the next 1897 * time, reading more bytes should make conversion possible. 1898 * Don't do this in the unlikely event that the input buffer is too 1899 * small ("rest" still contains more bytes). 1900 */ 1901 if (input_conv.vc_type != CONV_NONE) 1902 { 1903 inbufcount -= unconverted; 1904 len = convert_input_safe(inbuf + inbufcount, 1905 len + unconverted, INBUFLEN - inbufcount, 1906 rest == NULL ? &rest : NULL, &restlen); 1907 } 1908 # endif 1909 while (len-- > 0) 1910 { 1911 /* 1912 * if a CTRL-C was typed, remove it from the buffer and set got_int 1913 */ 1914 if (inbuf[inbufcount] == 3 && ctrl_c_interrupts) 1915 { 1916 /* remove everything typed before the CTRL-C */ 1917 mch_memmove(inbuf, inbuf + inbufcount, (size_t)(len + 1)); 1918 inbufcount = 0; 1919 got_int = TRUE; 1920 } 1921 ++inbufcount; 1922 } 1923 } 1924 #endif /* UNIX or VMS*/ 1925 } 1926 #endif /* defined(UNIX) || defined(FEAT_GUI) || defined(VMS) */ 1927 1928 /* 1929 * Exit because of an input read error. 1930 */ 1931 void 1932 read_error_exit(void) 1933 { 1934 if (silent_mode) /* Normal way to exit for "ex -s" */ 1935 getout(0); 1936 STRCPY(IObuff, _("Vim: Error reading input, exiting...\n")); 1937 preserve_exit(); 1938 } 1939 1940 #if defined(CURSOR_SHAPE) || defined(PROTO) 1941 /* 1942 * May update the shape of the cursor. 1943 */ 1944 void 1945 ui_cursor_shape_forced(int forced) 1946 { 1947 # ifdef FEAT_GUI 1948 if (gui.in_use) 1949 gui_update_cursor_later(); 1950 else 1951 # endif 1952 term_cursor_mode(forced); 1953 1954 # ifdef MCH_CURSOR_SHAPE 1955 mch_update_cursor(); 1956 # endif 1957 1958 # ifdef FEAT_CONCEAL 1959 conceal_check_cursur_line(); 1960 # endif 1961 } 1962 1963 void 1964 ui_cursor_shape(void) 1965 { 1966 ui_cursor_shape_forced(FALSE); 1967 } 1968 #endif 1969 1970 #if defined(FEAT_CLIPBOARD) || defined(FEAT_GUI) || defined(FEAT_RIGHTLEFT) \ 1971 || defined(FEAT_MBYTE) || defined(PROTO) 1972 /* 1973 * Check bounds for column number 1974 */ 1975 int 1976 check_col(int col) 1977 { 1978 if (col < 0) 1979 return 0; 1980 if (col >= (int)screen_Columns) 1981 return (int)screen_Columns - 1; 1982 return col; 1983 } 1984 1985 /* 1986 * Check bounds for row number 1987 */ 1988 int 1989 check_row(int row) 1990 { 1991 if (row < 0) 1992 return 0; 1993 if (row >= (int)screen_Rows) 1994 return (int)screen_Rows - 1; 1995 return row; 1996 } 1997 #endif 1998 1999 /* 2000 * Stuff for the X clipboard. Shared between VMS and Unix. 2001 */ 2002 2003 #if defined(FEAT_XCLIPBOARD) || defined(FEAT_GUI_X11) || defined(PROTO) 2004 # include <X11/Xatom.h> 2005 # include <X11/Intrinsic.h> 2006 2007 /* 2008 * Open the application context (if it hasn't been opened yet). 2009 * Used for Motif and Athena GUI and the xterm clipboard. 2010 */ 2011 void 2012 open_app_context(void) 2013 { 2014 if (app_context == NULL) 2015 { 2016 XtToolkitInitialize(); 2017 app_context = XtCreateApplicationContext(); 2018 } 2019 } 2020 2021 static Atom vim_atom; /* Vim's own special selection format */ 2022 #ifdef FEAT_MBYTE 2023 static Atom vimenc_atom; /* Vim's extended selection format */ 2024 static Atom utf8_atom; 2025 #endif 2026 static Atom compound_text_atom; 2027 static Atom text_atom; 2028 static Atom targets_atom; 2029 static Atom timestamp_atom; /* Used to get a timestamp */ 2030 2031 void 2032 x11_setup_atoms(Display *dpy) 2033 { 2034 vim_atom = XInternAtom(dpy, VIM_ATOM_NAME, False); 2035 #ifdef FEAT_MBYTE 2036 vimenc_atom = XInternAtom(dpy, VIMENC_ATOM_NAME,False); 2037 utf8_atom = XInternAtom(dpy, "UTF8_STRING", False); 2038 #endif 2039 compound_text_atom = XInternAtom(dpy, "COMPOUND_TEXT", False); 2040 text_atom = XInternAtom(dpy, "TEXT", False); 2041 targets_atom = XInternAtom(dpy, "TARGETS", False); 2042 clip_star.sel_atom = XA_PRIMARY; 2043 clip_plus.sel_atom = XInternAtom(dpy, "CLIPBOARD", False); 2044 timestamp_atom = XInternAtom(dpy, "TIMESTAMP", False); 2045 } 2046 2047 /* 2048 * X Selection stuff, for cutting and pasting text to other windows. 2049 */ 2050 2051 static Boolean clip_x11_convert_selection_cb(Widget w, Atom *sel_atom, Atom *target, Atom *type, XtPointer *value, long_u *length, int *format); 2052 static void clip_x11_lose_ownership_cb(Widget w, Atom *sel_atom); 2053 static void clip_x11_notify_cb(Widget w, Atom *sel_atom, Atom *target); 2054 static void clip_x11_timestamp_cb(Widget w, XtPointer n, XEvent *event, Boolean *cont); 2055 static void clip_x11_request_selection_cb(Widget w, XtPointer success, Atom *sel_atom, Atom *type, XtPointer value, long_u *length, int *format); 2056 2057 /* 2058 * Property callback to get a timestamp for XtOwnSelection. 2059 */ 2060 static void 2061 clip_x11_timestamp_cb( 2062 Widget w, 2063 XtPointer n UNUSED, 2064 XEvent *event, 2065 Boolean *cont UNUSED) 2066 { 2067 Atom actual_type; 2068 int format; 2069 unsigned long nitems, bytes_after; 2070 unsigned char *prop=NULL; 2071 XPropertyEvent *xproperty=&event->xproperty; 2072 2073 /* Must be a property notify, state can't be Delete (True), has to be 2074 * one of the supported selection types. */ 2075 if (event->type != PropertyNotify || xproperty->state 2076 || (xproperty->atom != clip_star.sel_atom 2077 && xproperty->atom != clip_plus.sel_atom)) 2078 return; 2079 2080 if (XGetWindowProperty(xproperty->display, xproperty->window, 2081 xproperty->atom, 0, 0, False, timestamp_atom, &actual_type, &format, 2082 &nitems, &bytes_after, &prop)) 2083 return; 2084 2085 if (prop) 2086 XFree(prop); 2087 2088 /* Make sure the property type is "TIMESTAMP" and it's 32 bits. */ 2089 if (actual_type != timestamp_atom || format != 32) 2090 return; 2091 2092 /* Get the selection, using the event timestamp. */ 2093 if (XtOwnSelection(w, xproperty->atom, xproperty->time, 2094 clip_x11_convert_selection_cb, clip_x11_lose_ownership_cb, 2095 clip_x11_notify_cb) == OK) 2096 { 2097 /* Set the "owned" flag now, there may have been a call to 2098 * lose_ownership_cb in between. */ 2099 if (xproperty->atom == clip_plus.sel_atom) 2100 clip_plus.owned = TRUE; 2101 else 2102 clip_star.owned = TRUE; 2103 } 2104 } 2105 2106 void 2107 x11_setup_selection(Widget w) 2108 { 2109 XtAddEventHandler(w, PropertyChangeMask, False, 2110 /*(XtEventHandler)*/clip_x11_timestamp_cb, (XtPointer)NULL); 2111 } 2112 2113 static void 2114 clip_x11_request_selection_cb( 2115 Widget w UNUSED, 2116 XtPointer success, 2117 Atom *sel_atom, 2118 Atom *type, 2119 XtPointer value, 2120 long_u *length, 2121 int *format) 2122 { 2123 int motion_type = MAUTO; 2124 long_u len; 2125 char_u *p; 2126 char **text_list = NULL; 2127 VimClipboard *cbd; 2128 #ifdef FEAT_MBYTE 2129 char_u *tmpbuf = NULL; 2130 #endif 2131 2132 if (*sel_atom == clip_plus.sel_atom) 2133 cbd = &clip_plus; 2134 else 2135 cbd = &clip_star; 2136 2137 if (value == NULL || *length == 0) 2138 { 2139 clip_free_selection(cbd); /* nothing received, clear register */ 2140 *(int *)success = FALSE; 2141 return; 2142 } 2143 p = (char_u *)value; 2144 len = *length; 2145 if (*type == vim_atom) 2146 { 2147 motion_type = *p++; 2148 len--; 2149 } 2150 2151 #ifdef FEAT_MBYTE 2152 else if (*type == vimenc_atom) 2153 { 2154 char_u *enc; 2155 vimconv_T conv; 2156 int convlen; 2157 2158 motion_type = *p++; 2159 --len; 2160 2161 enc = p; 2162 p += STRLEN(p) + 1; 2163 len -= p - enc; 2164 2165 /* If the encoding of the text is different from 'encoding', attempt 2166 * converting it. */ 2167 conv.vc_type = CONV_NONE; 2168 convert_setup(&conv, enc, p_enc); 2169 if (conv.vc_type != CONV_NONE) 2170 { 2171 convlen = len; /* Need to use an int here. */ 2172 tmpbuf = string_convert(&conv, p, &convlen); 2173 len = convlen; 2174 if (tmpbuf != NULL) 2175 p = tmpbuf; 2176 convert_setup(&conv, NULL, NULL); 2177 } 2178 } 2179 #endif 2180 2181 else if (*type == compound_text_atom 2182 #ifdef FEAT_MBYTE 2183 || *type == utf8_atom 2184 #endif 2185 || ( 2186 #ifdef FEAT_MBYTE 2187 enc_dbcs != 0 && 2188 #endif 2189 *type == text_atom)) 2190 { 2191 XTextProperty text_prop; 2192 int n_text = 0; 2193 int status; 2194 2195 text_prop.value = (unsigned char *)value; 2196 text_prop.encoding = *type; 2197 text_prop.format = *format; 2198 text_prop.nitems = len; 2199 #if defined(FEAT_MBYTE) && defined(X_HAVE_UTF8_STRING) 2200 if (*type == utf8_atom) 2201 status = Xutf8TextPropertyToTextList(X_DISPLAY, &text_prop, 2202 &text_list, &n_text); 2203 else 2204 #endif 2205 status = XmbTextPropertyToTextList(X_DISPLAY, &text_prop, 2206 &text_list, &n_text); 2207 if (status != Success || n_text < 1) 2208 { 2209 *(int *)success = FALSE; 2210 return; 2211 } 2212 p = (char_u *)text_list[0]; 2213 len = STRLEN(p); 2214 } 2215 clip_yank_selection(motion_type, p, (long)len, cbd); 2216 2217 if (text_list != NULL) 2218 XFreeStringList(text_list); 2219 #ifdef FEAT_MBYTE 2220 vim_free(tmpbuf); 2221 #endif 2222 XtFree((char *)value); 2223 *(int *)success = TRUE; 2224 } 2225 2226 void 2227 clip_x11_request_selection( 2228 Widget myShell, 2229 Display *dpy, 2230 VimClipboard *cbd) 2231 { 2232 XEvent event; 2233 Atom type; 2234 static int success; 2235 int i; 2236 time_t start_time; 2237 int timed_out = FALSE; 2238 2239 for (i = 2240 #ifdef FEAT_MBYTE 2241 0 2242 #else 2243 1 2244 #endif 2245 ; i < 6; i++) 2246 { 2247 switch (i) 2248 { 2249 #ifdef FEAT_MBYTE 2250 case 0: type = vimenc_atom; break; 2251 #endif 2252 case 1: type = vim_atom; break; 2253 #ifdef FEAT_MBYTE 2254 case 2: type = utf8_atom; break; 2255 #endif 2256 case 3: type = compound_text_atom; break; 2257 case 4: type = text_atom; break; 2258 default: type = XA_STRING; 2259 } 2260 #ifdef FEAT_MBYTE 2261 if (type == utf8_atom 2262 # if defined(X_HAVE_UTF8_STRING) 2263 && !enc_utf8 2264 # endif 2265 ) 2266 /* Only request utf-8 when 'encoding' is utf8 and 2267 * Xutf8TextPropertyToTextList is available. */ 2268 continue; 2269 #endif 2270 success = MAYBE; 2271 XtGetSelectionValue(myShell, cbd->sel_atom, type, 2272 clip_x11_request_selection_cb, (XtPointer)&success, CurrentTime); 2273 2274 /* Make sure the request for the selection goes out before waiting for 2275 * a response. */ 2276 XFlush(dpy); 2277 2278 /* 2279 * Wait for result of selection request, otherwise if we type more 2280 * characters, then they will appear before the one that requested the 2281 * paste! Don't worry, we will catch up with any other events later. 2282 */ 2283 start_time = time(NULL); 2284 while (success == MAYBE) 2285 { 2286 if (XCheckTypedEvent(dpy, PropertyNotify, &event) 2287 || XCheckTypedEvent(dpy, SelectionNotify, &event) 2288 || XCheckTypedEvent(dpy, SelectionRequest, &event)) 2289 { 2290 /* This is where clip_x11_request_selection_cb() should be 2291 * called. It may actually happen a bit later, so we loop 2292 * until "success" changes. 2293 * We may get a SelectionRequest here and if we don't handle 2294 * it we hang. KDE klipper does this, for example. 2295 * We need to handle a PropertyNotify for large selections. */ 2296 XtDispatchEvent(&event); 2297 continue; 2298 } 2299 2300 /* Time out after 2 to 3 seconds to avoid that we hang when the 2301 * other process doesn't respond. Note that the SelectionNotify 2302 * event may still come later when the selection owner comes back 2303 * to life and the text gets inserted unexpectedly. Don't know 2304 * why that happens or how to avoid that :-(. */ 2305 if (time(NULL) > start_time + 2) 2306 { 2307 timed_out = TRUE; 2308 break; 2309 } 2310 2311 /* Do we need this? Probably not. */ 2312 XSync(dpy, False); 2313 2314 /* Wait for 1 msec to avoid that we eat up all CPU time. */ 2315 ui_delay(1L, TRUE); 2316 } 2317 2318 if (success == TRUE) 2319 return; 2320 2321 /* don't do a retry with another type after timing out, otherwise we 2322 * hang for 15 seconds. */ 2323 if (timed_out) 2324 break; 2325 } 2326 2327 /* Final fallback position - use the X CUT_BUFFER0 store */ 2328 yank_cut_buffer0(dpy, cbd); 2329 } 2330 2331 static Boolean 2332 clip_x11_convert_selection_cb( 2333 Widget w UNUSED, 2334 Atom *sel_atom, 2335 Atom *target, 2336 Atom *type, 2337 XtPointer *value, 2338 long_u *length, 2339 int *format) 2340 { 2341 static char_u *save_result = NULL; 2342 static long_u save_length = 0; 2343 char_u *string; 2344 int motion_type; 2345 VimClipboard *cbd; 2346 int i; 2347 2348 if (*sel_atom == clip_plus.sel_atom) 2349 cbd = &clip_plus; 2350 else 2351 cbd = &clip_star; 2352 2353 if (!cbd->owned) 2354 return False; /* Shouldn't ever happen */ 2355 2356 /* requestor wants to know what target types we support */ 2357 if (*target == targets_atom) 2358 { 2359 static Atom array[7]; 2360 2361 *value = (XtPointer)array; 2362 i = 0; 2363 array[i++] = targets_atom; 2364 #ifdef FEAT_MBYTE 2365 array[i++] = vimenc_atom; 2366 #endif 2367 array[i++] = vim_atom; 2368 #ifdef FEAT_MBYTE 2369 if (enc_utf8) 2370 array[i++] = utf8_atom; 2371 #endif 2372 array[i++] = XA_STRING; 2373 array[i++] = text_atom; 2374 array[i++] = compound_text_atom; 2375 2376 *type = XA_ATOM; 2377 /* This used to be: *format = sizeof(Atom) * 8; but that caused 2378 * crashes on 64 bit machines. (Peter Derr) */ 2379 *format = 32; 2380 *length = i; 2381 return True; 2382 } 2383 2384 if ( *target != XA_STRING 2385 #ifdef FEAT_MBYTE 2386 && *target != vimenc_atom 2387 && (*target != utf8_atom || !enc_utf8) 2388 #endif 2389 && *target != vim_atom 2390 && *target != text_atom 2391 && *target != compound_text_atom) 2392 return False; 2393 2394 clip_get_selection(cbd); 2395 motion_type = clip_convert_selection(&string, length, cbd); 2396 if (motion_type < 0) 2397 return False; 2398 2399 /* For our own format, the first byte contains the motion type */ 2400 if (*target == vim_atom) 2401 (*length)++; 2402 2403 #ifdef FEAT_MBYTE 2404 /* Our own format with encoding: motion 'encoding' NUL text */ 2405 if (*target == vimenc_atom) 2406 *length += STRLEN(p_enc) + 2; 2407 #endif 2408 2409 if (save_length < *length || save_length / 2 >= *length) 2410 *value = XtRealloc((char *)save_result, (Cardinal)*length + 1); 2411 else 2412 *value = save_result; 2413 if (*value == NULL) 2414 { 2415 vim_free(string); 2416 return False; 2417 } 2418 save_result = (char_u *)*value; 2419 save_length = *length; 2420 2421 if (*target == XA_STRING 2422 #ifdef FEAT_MBYTE 2423 || (*target == utf8_atom && enc_utf8) 2424 #endif 2425 ) 2426 { 2427 mch_memmove(save_result, string, (size_t)(*length)); 2428 *type = *target; 2429 } 2430 else if (*target == compound_text_atom || *target == text_atom) 2431 { 2432 XTextProperty text_prop; 2433 char *string_nt = (char *)save_result; 2434 int conv_result; 2435 2436 /* create NUL terminated string which XmbTextListToTextProperty wants */ 2437 mch_memmove(string_nt, string, (size_t)*length); 2438 string_nt[*length] = NUL; 2439 conv_result = XmbTextListToTextProperty(X_DISPLAY, (char **)&string_nt, 2440 1, XCompoundTextStyle, &text_prop); 2441 if (conv_result != Success) 2442 { 2443 vim_free(string); 2444 return False; 2445 } 2446 *value = (XtPointer)(text_prop.value); /* from plain text */ 2447 *length = text_prop.nitems; 2448 *type = compound_text_atom; 2449 XtFree((char *)save_result); 2450 save_result = (char_u *)*value; 2451 save_length = *length; 2452 } 2453 #ifdef FEAT_MBYTE 2454 else if (*target == vimenc_atom) 2455 { 2456 int l = STRLEN(p_enc); 2457 2458 save_result[0] = motion_type; 2459 STRCPY(save_result + 1, p_enc); 2460 mch_memmove(save_result + l + 2, string, (size_t)(*length - l - 2)); 2461 *type = vimenc_atom; 2462 } 2463 #endif 2464 else 2465 { 2466 save_result[0] = motion_type; 2467 mch_memmove(save_result + 1, string, (size_t)(*length - 1)); 2468 *type = vim_atom; 2469 } 2470 *format = 8; /* 8 bits per char */ 2471 vim_free(string); 2472 return True; 2473 } 2474 2475 static void 2476 clip_x11_lose_ownership_cb(Widget w UNUSED, Atom *sel_atom) 2477 { 2478 if (*sel_atom == clip_plus.sel_atom) 2479 clip_lose_selection(&clip_plus); 2480 else 2481 clip_lose_selection(&clip_star); 2482 } 2483 2484 void 2485 clip_x11_lose_selection(Widget myShell, VimClipboard *cbd) 2486 { 2487 XtDisownSelection(myShell, cbd->sel_atom, 2488 XtLastTimestampProcessed(XtDisplay(myShell))); 2489 } 2490 2491 static void 2492 clip_x11_notify_cb(Widget w UNUSED, Atom *sel_atom UNUSED, Atom *target UNUSED) 2493 { 2494 /* To prevent automatically freeing the selection value. */ 2495 } 2496 2497 int 2498 clip_x11_own_selection(Widget myShell, VimClipboard *cbd) 2499 { 2500 /* When using the GUI we have proper timestamps, use the one of the last 2501 * event. When in the console we don't get events (the terminal gets 2502 * them), Get the time by a zero-length append, clip_x11_timestamp_cb will 2503 * be called with the current timestamp. */ 2504 #ifdef FEAT_GUI 2505 if (gui.in_use) 2506 { 2507 if (XtOwnSelection(myShell, cbd->sel_atom, 2508 XtLastTimestampProcessed(XtDisplay(myShell)), 2509 clip_x11_convert_selection_cb, clip_x11_lose_ownership_cb, 2510 clip_x11_notify_cb) == False) 2511 return FAIL; 2512 } 2513 else 2514 #endif 2515 { 2516 if (!XChangeProperty(XtDisplay(myShell), XtWindow(myShell), 2517 cbd->sel_atom, timestamp_atom, 32, PropModeAppend, NULL, 0)) 2518 return FAIL; 2519 } 2520 /* Flush is required in a terminal as nothing else is doing it. */ 2521 XFlush(XtDisplay(myShell)); 2522 return OK; 2523 } 2524 2525 /* 2526 * Send the current selection to the clipboard. Do nothing for X because we 2527 * will fill in the selection only when requested by another app. 2528 */ 2529 void 2530 clip_x11_set_selection(VimClipboard *cbd UNUSED) 2531 { 2532 } 2533 2534 int 2535 clip_x11_owner_exists(VimClipboard *cbd) 2536 { 2537 return XGetSelectionOwner(X_DISPLAY, cbd->sel_atom) != None; 2538 } 2539 #endif 2540 2541 #if defined(FEAT_XCLIPBOARD) || defined(FEAT_GUI_X11) \ 2542 || defined(FEAT_GUI_GTK) || defined(PROTO) 2543 /* 2544 * Get the contents of the X CUT_BUFFER0 and put it in "cbd". 2545 */ 2546 void 2547 yank_cut_buffer0(Display *dpy, VimClipboard *cbd) 2548 { 2549 int nbytes = 0; 2550 char_u *buffer = (char_u *)XFetchBuffer(dpy, &nbytes, 0); 2551 2552 if (nbytes > 0) 2553 { 2554 #ifdef FEAT_MBYTE 2555 int done = FALSE; 2556 2557 /* CUT_BUFFER0 is supposed to be always latin1. Convert to 'enc' when 2558 * using a multi-byte encoding. Conversion between two 8-bit 2559 * character sets usually fails and the text might actually be in 2560 * 'enc' anyway. */ 2561 if (has_mbyte) 2562 { 2563 char_u *conv_buf; 2564 vimconv_T vc; 2565 2566 vc.vc_type = CONV_NONE; 2567 if (convert_setup(&vc, (char_u *)"latin1", p_enc) == OK) 2568 { 2569 conv_buf = string_convert(&vc, buffer, &nbytes); 2570 if (conv_buf != NULL) 2571 { 2572 clip_yank_selection(MCHAR, conv_buf, (long)nbytes, cbd); 2573 vim_free(conv_buf); 2574 done = TRUE; 2575 } 2576 convert_setup(&vc, NULL, NULL); 2577 } 2578 } 2579 if (!done) /* use the text without conversion */ 2580 #endif 2581 clip_yank_selection(MCHAR, buffer, (long)nbytes, cbd); 2582 XFree((void *)buffer); 2583 if (p_verbose > 0) 2584 { 2585 verbose_enter(); 2586 verb_msg((char_u *)_("Used CUT_BUFFER0 instead of empty selection")); 2587 verbose_leave(); 2588 } 2589 } 2590 } 2591 #endif 2592 2593 #if defined(FEAT_MOUSE) || defined(PROTO) 2594 2595 /* 2596 * Move the cursor to the specified row and column on the screen. 2597 * Change current window if necessary. Returns an integer with the 2598 * CURSOR_MOVED bit set if the cursor has moved or unset otherwise. 2599 * 2600 * The MOUSE_FOLD_CLOSE bit is set when clicked on the '-' in a fold column. 2601 * The MOUSE_FOLD_OPEN bit is set when clicked on the '+' in a fold column. 2602 * 2603 * If flags has MOUSE_FOCUS, then the current window will not be changed, and 2604 * if the mouse is outside the window then the text will scroll, or if the 2605 * mouse was previously on a status line, then the status line may be dragged. 2606 * 2607 * If flags has MOUSE_MAY_VIS, then VIsual mode will be started before the 2608 * cursor is moved unless the cursor was on a status line. 2609 * This function returns one of IN_UNKNOWN, IN_BUFFER, IN_STATUS_LINE or 2610 * IN_SEP_LINE depending on where the cursor was clicked. 2611 * 2612 * If flags has MOUSE_MAY_STOP_VIS, then Visual mode will be stopped, unless 2613 * the mouse is on the status line of the same window. 2614 * 2615 * If flags has MOUSE_DID_MOVE, nothing is done if the mouse didn't move since 2616 * the last call. 2617 * 2618 * If flags has MOUSE_SETPOS, nothing is done, only the current position is 2619 * remembered. 2620 */ 2621 int 2622 jump_to_mouse( 2623 int flags, 2624 int *inclusive, /* used for inclusive operator, can be NULL */ 2625 int which_button) /* MOUSE_LEFT, MOUSE_RIGHT, MOUSE_MIDDLE */ 2626 { 2627 static int on_status_line = 0; /* #lines below bottom of window */ 2628 #ifdef FEAT_WINDOWS 2629 static int on_sep_line = 0; /* on separator right of window */ 2630 #endif 2631 static int prev_row = -1; 2632 static int prev_col = -1; 2633 static win_T *dragwin = NULL; /* window being dragged */ 2634 static int did_drag = FALSE; /* drag was noticed */ 2635 2636 win_T *wp, *old_curwin; 2637 pos_T old_cursor; 2638 int count; 2639 int first; 2640 int row = mouse_row; 2641 int col = mouse_col; 2642 #ifdef FEAT_FOLDING 2643 int mouse_char; 2644 #endif 2645 2646 mouse_past_bottom = FALSE; 2647 mouse_past_eol = FALSE; 2648 2649 if (flags & MOUSE_RELEASED) 2650 { 2651 /* On button release we may change window focus if positioned on a 2652 * status line and no dragging happened. */ 2653 if (dragwin != NULL && !did_drag) 2654 flags &= ~(MOUSE_FOCUS | MOUSE_DID_MOVE); 2655 dragwin = NULL; 2656 did_drag = FALSE; 2657 } 2658 2659 if ((flags & MOUSE_DID_MOVE) 2660 && prev_row == mouse_row 2661 && prev_col == mouse_col) 2662 { 2663 retnomove: 2664 /* before moving the cursor for a left click which is NOT in a status 2665 * line, stop Visual mode */ 2666 if (on_status_line) 2667 return IN_STATUS_LINE; 2668 #ifdef FEAT_WINDOWS 2669 if (on_sep_line) 2670 return IN_SEP_LINE; 2671 #endif 2672 if (flags & MOUSE_MAY_STOP_VIS) 2673 { 2674 end_visual_mode(); 2675 redraw_curbuf_later(INVERTED); /* delete the inversion */ 2676 } 2677 #if defined(FEAT_CMDWIN) && defined(FEAT_CLIPBOARD) 2678 /* Continue a modeless selection in another window. */ 2679 if (cmdwin_type != 0 && row < W_WINROW(curwin)) 2680 return IN_OTHER_WIN; 2681 #endif 2682 return IN_BUFFER; 2683 } 2684 2685 prev_row = mouse_row; 2686 prev_col = mouse_col; 2687 2688 if (flags & MOUSE_SETPOS) 2689 goto retnomove; /* ugly goto... */ 2690 2691 #ifdef FEAT_FOLDING 2692 /* Remember the character under the mouse, it might be a '-' or '+' in the 2693 * fold column. */ 2694 if (row >= 0 && row < Rows && col >= 0 && col <= Columns 2695 && ScreenLines != NULL) 2696 mouse_char = ScreenLines[LineOffset[row] + col]; 2697 else 2698 mouse_char = ' '; 2699 #endif 2700 2701 old_curwin = curwin; 2702 old_cursor = curwin->w_cursor; 2703 2704 if (!(flags & MOUSE_FOCUS)) 2705 { 2706 if (row < 0 || col < 0) /* check if it makes sense */ 2707 return IN_UNKNOWN; 2708 2709 #ifdef FEAT_WINDOWS 2710 /* find the window where the row is in */ 2711 wp = mouse_find_win(&row, &col); 2712 #else 2713 wp = firstwin; 2714 #endif 2715 dragwin = NULL; 2716 /* 2717 * winpos and height may change in win_enter()! 2718 */ 2719 if (row >= wp->w_height) /* In (or below) status line */ 2720 { 2721 on_status_line = row - wp->w_height + 1; 2722 dragwin = wp; 2723 } 2724 else 2725 on_status_line = 0; 2726 #ifdef FEAT_WINDOWS 2727 if (col >= wp->w_width) /* In separator line */ 2728 { 2729 on_sep_line = col - wp->w_width + 1; 2730 dragwin = wp; 2731 } 2732 else 2733 on_sep_line = 0; 2734 2735 /* The rightmost character of the status line might be a vertical 2736 * separator character if there is no connecting window to the right. */ 2737 if (on_status_line && on_sep_line) 2738 { 2739 if (stl_connected(wp)) 2740 on_sep_line = 0; 2741 else 2742 on_status_line = 0; 2743 } 2744 #endif 2745 2746 /* Before jumping to another buffer, or moving the cursor for a left 2747 * click, stop Visual mode. */ 2748 if (VIsual_active 2749 && (wp->w_buffer != curwin->w_buffer 2750 || (!on_status_line 2751 #ifdef FEAT_WINDOWS 2752 && !on_sep_line 2753 #endif 2754 #ifdef FEAT_FOLDING 2755 && ( 2756 # ifdef FEAT_RIGHTLEFT 2757 wp->w_p_rl ? col < W_WIDTH(wp) - wp->w_p_fdc : 2758 # endif 2759 col >= wp->w_p_fdc 2760 # ifdef FEAT_CMDWIN 2761 + (cmdwin_type == 0 && wp == curwin ? 0 : 1) 2762 # endif 2763 ) 2764 #endif 2765 && (flags & MOUSE_MAY_STOP_VIS)))) 2766 { 2767 end_visual_mode(); 2768 redraw_curbuf_later(INVERTED); /* delete the inversion */ 2769 } 2770 #ifdef FEAT_CMDWIN 2771 if (cmdwin_type != 0 && wp != curwin) 2772 { 2773 /* A click outside the command-line window: Use modeless 2774 * selection if possible. Allow dragging the status lines. */ 2775 on_sep_line = 0; 2776 # ifdef FEAT_CLIPBOARD 2777 if (on_status_line) 2778 return IN_STATUS_LINE; 2779 return IN_OTHER_WIN; 2780 # else 2781 row = 0; 2782 col += wp->w_wincol; 2783 wp = curwin; 2784 # endif 2785 } 2786 #endif 2787 #ifdef FEAT_WINDOWS 2788 /* Only change window focus when not clicking on or dragging the 2789 * status line. Do change focus when releasing the mouse button 2790 * (MOUSE_FOCUS was set above if we dragged first). */ 2791 if (dragwin == NULL || (flags & MOUSE_RELEASED)) 2792 win_enter(wp, TRUE); /* can make wp invalid! */ 2793 # ifdef CHECK_DOUBLE_CLICK 2794 /* set topline, to be able to check for double click ourselves */ 2795 if (curwin != old_curwin) 2796 set_mouse_topline(curwin); 2797 # endif 2798 #endif 2799 if (on_status_line) /* In (or below) status line */ 2800 { 2801 /* Don't use start_arrow() if we're in the same window */ 2802 if (curwin == old_curwin) 2803 return IN_STATUS_LINE; 2804 else 2805 return IN_STATUS_LINE | CURSOR_MOVED; 2806 } 2807 #ifdef FEAT_WINDOWS 2808 if (on_sep_line) /* In (or below) status line */ 2809 { 2810 /* Don't use start_arrow() if we're in the same window */ 2811 if (curwin == old_curwin) 2812 return IN_SEP_LINE; 2813 else 2814 return IN_SEP_LINE | CURSOR_MOVED; 2815 } 2816 #endif 2817 2818 curwin->w_cursor.lnum = curwin->w_topline; 2819 #ifdef FEAT_GUI 2820 /* remember topline, needed for double click */ 2821 gui_prev_topline = curwin->w_topline; 2822 # ifdef FEAT_DIFF 2823 gui_prev_topfill = curwin->w_topfill; 2824 # endif 2825 #endif 2826 } 2827 else if (on_status_line && which_button == MOUSE_LEFT) 2828 { 2829 #ifdef FEAT_WINDOWS 2830 if (dragwin != NULL) 2831 { 2832 /* Drag the status line */ 2833 count = row - dragwin->w_winrow - dragwin->w_height + 1 2834 - on_status_line; 2835 win_drag_status_line(dragwin, count); 2836 did_drag |= count; 2837 } 2838 #endif 2839 return IN_STATUS_LINE; /* Cursor didn't move */ 2840 } 2841 #ifdef FEAT_WINDOWS 2842 else if (on_sep_line && which_button == MOUSE_LEFT) 2843 { 2844 if (dragwin != NULL) 2845 { 2846 /* Drag the separator column */ 2847 count = col - dragwin->w_wincol - dragwin->w_width + 1 2848 - on_sep_line; 2849 win_drag_vsep_line(dragwin, count); 2850 did_drag |= count; 2851 } 2852 return IN_SEP_LINE; /* Cursor didn't move */ 2853 } 2854 #endif 2855 else /* keep_window_focus must be TRUE */ 2856 { 2857 /* before moving the cursor for a left click, stop Visual mode */ 2858 if (flags & MOUSE_MAY_STOP_VIS) 2859 { 2860 end_visual_mode(); 2861 redraw_curbuf_later(INVERTED); /* delete the inversion */ 2862 } 2863 2864 #if defined(FEAT_CMDWIN) && defined(FEAT_CLIPBOARD) 2865 /* Continue a modeless selection in another window. */ 2866 if (cmdwin_type != 0 && row < W_WINROW(curwin)) 2867 return IN_OTHER_WIN; 2868 #endif 2869 2870 row -= W_WINROW(curwin); 2871 #ifdef FEAT_WINDOWS 2872 col -= W_WINCOL(curwin); 2873 #endif 2874 2875 /* 2876 * When clicking beyond the end of the window, scroll the screen. 2877 * Scroll by however many rows outside the window we are. 2878 */ 2879 if (row < 0) 2880 { 2881 count = 0; 2882 for (first = TRUE; curwin->w_topline > 1; ) 2883 { 2884 #ifdef FEAT_DIFF 2885 if (curwin->w_topfill < diff_check(curwin, curwin->w_topline)) 2886 ++count; 2887 else 2888 #endif 2889 count += plines(curwin->w_topline - 1); 2890 if (!first && count > -row) 2891 break; 2892 first = FALSE; 2893 #ifdef FEAT_FOLDING 2894 (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL); 2895 #endif 2896 #ifdef FEAT_DIFF 2897 if (curwin->w_topfill < diff_check(curwin, curwin->w_topline)) 2898 ++curwin->w_topfill; 2899 else 2900 #endif 2901 { 2902 --curwin->w_topline; 2903 #ifdef FEAT_DIFF 2904 curwin->w_topfill = 0; 2905 #endif 2906 } 2907 } 2908 #ifdef FEAT_DIFF 2909 check_topfill(curwin, FALSE); 2910 #endif 2911 curwin->w_valid &= 2912 ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP); 2913 redraw_later(VALID); 2914 row = 0; 2915 } 2916 else if (row >= curwin->w_height) 2917 { 2918 count = 0; 2919 for (first = TRUE; curwin->w_topline < curbuf->b_ml.ml_line_count; ) 2920 { 2921 #ifdef FEAT_DIFF 2922 if (curwin->w_topfill > 0) 2923 ++count; 2924 else 2925 #endif 2926 count += plines(curwin->w_topline); 2927 if (!first && count > row - curwin->w_height + 1) 2928 break; 2929 first = FALSE; 2930 #ifdef FEAT_FOLDING 2931 if (hasFolding(curwin->w_topline, NULL, &curwin->w_topline) 2932 && curwin->w_topline == curbuf->b_ml.ml_line_count) 2933 break; 2934 #endif 2935 #ifdef FEAT_DIFF 2936 if (curwin->w_topfill > 0) 2937 --curwin->w_topfill; 2938 else 2939 #endif 2940 { 2941 ++curwin->w_topline; 2942 #ifdef FEAT_DIFF 2943 curwin->w_topfill = 2944 diff_check_fill(curwin, curwin->w_topline); 2945 #endif 2946 } 2947 } 2948 #ifdef FEAT_DIFF 2949 check_topfill(curwin, FALSE); 2950 #endif 2951 redraw_later(VALID); 2952 curwin->w_valid &= 2953 ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP); 2954 row = curwin->w_height - 1; 2955 } 2956 else if (row == 0) 2957 { 2958 /* When dragging the mouse, while the text has been scrolled up as 2959 * far as it goes, moving the mouse in the top line should scroll 2960 * the text down (done later when recomputing w_topline). */ 2961 if (mouse_dragging > 0 2962 && curwin->w_cursor.lnum 2963 == curwin->w_buffer->b_ml.ml_line_count 2964 && curwin->w_cursor.lnum == curwin->w_topline) 2965 curwin->w_valid &= ~(VALID_TOPLINE); 2966 } 2967 } 2968 2969 #ifdef FEAT_FOLDING 2970 /* Check for position outside of the fold column. */ 2971 if ( 2972 # ifdef FEAT_RIGHTLEFT 2973 curwin->w_p_rl ? col < W_WIDTH(curwin) - curwin->w_p_fdc : 2974 # endif 2975 col >= curwin->w_p_fdc 2976 # ifdef FEAT_CMDWIN 2977 + (cmdwin_type == 0 ? 0 : 1) 2978 # endif 2979 ) 2980 mouse_char = ' '; 2981 #endif 2982 2983 /* compute the position in the buffer line from the posn on the screen */ 2984 if (mouse_comp_pos(curwin, &row, &col, &curwin->w_cursor.lnum)) 2985 mouse_past_bottom = TRUE; 2986 2987 /* Start Visual mode before coladvance(), for when 'sel' != "old" */ 2988 if ((flags & MOUSE_MAY_VIS) && !VIsual_active) 2989 { 2990 check_visual_highlight(); 2991 VIsual = old_cursor; 2992 VIsual_active = TRUE; 2993 VIsual_reselect = TRUE; 2994 /* if 'selectmode' contains "mouse", start Select mode */ 2995 may_start_select('o'); 2996 setmouse(); 2997 if (p_smd && msg_silent == 0) 2998 redraw_cmdline = TRUE; /* show visual mode later */ 2999 } 3000 3001 curwin->w_curswant = col; 3002 curwin->w_set_curswant = FALSE; /* May still have been TRUE */ 3003 if (coladvance(col) == FAIL) /* Mouse click beyond end of line */ 3004 { 3005 if (inclusive != NULL) 3006 *inclusive = TRUE; 3007 mouse_past_eol = TRUE; 3008 } 3009 else if (inclusive != NULL) 3010 *inclusive = FALSE; 3011 3012 count = IN_BUFFER; 3013 if (curwin != old_curwin || curwin->w_cursor.lnum != old_cursor.lnum 3014 || curwin->w_cursor.col != old_cursor.col) 3015 count |= CURSOR_MOVED; /* Cursor has moved */ 3016 3017 #ifdef FEAT_FOLDING 3018 if (mouse_char == '+') 3019 count |= MOUSE_FOLD_OPEN; 3020 else if (mouse_char != ' ') 3021 count |= MOUSE_FOLD_CLOSE; 3022 #endif 3023 3024 return count; 3025 } 3026 3027 /* 3028 * Compute the position in the buffer line from the posn on the screen in 3029 * window "win". 3030 * Returns TRUE if the position is below the last line. 3031 */ 3032 int 3033 mouse_comp_pos( 3034 win_T *win, 3035 int *rowp, 3036 int *colp, 3037 linenr_T *lnump) 3038 { 3039 int col = *colp; 3040 int row = *rowp; 3041 linenr_T lnum; 3042 int retval = FALSE; 3043 int off; 3044 int count; 3045 3046 #ifdef FEAT_RIGHTLEFT 3047 if (win->w_p_rl) 3048 col = W_WIDTH(win) - 1 - col; 3049 #endif 3050 3051 lnum = win->w_topline; 3052 3053 while (row > 0) 3054 { 3055 #ifdef FEAT_DIFF 3056 /* Don't include filler lines in "count" */ 3057 if (win->w_p_diff 3058 # ifdef FEAT_FOLDING 3059 && !hasFoldingWin(win, lnum, NULL, NULL, TRUE, NULL) 3060 # endif 3061 ) 3062 { 3063 if (lnum == win->w_topline) 3064 row -= win->w_topfill; 3065 else 3066 row -= diff_check_fill(win, lnum); 3067 count = plines_win_nofill(win, lnum, TRUE); 3068 } 3069 else 3070 #endif 3071 count = plines_win(win, lnum, TRUE); 3072 if (count > row) 3073 break; /* Position is in this buffer line. */ 3074 #ifdef FEAT_FOLDING 3075 (void)hasFoldingWin(win, lnum, NULL, &lnum, TRUE, NULL); 3076 #endif 3077 if (lnum == win->w_buffer->b_ml.ml_line_count) 3078 { 3079 retval = TRUE; 3080 break; /* past end of file */ 3081 } 3082 row -= count; 3083 ++lnum; 3084 } 3085 3086 if (!retval) 3087 { 3088 /* Compute the column without wrapping. */ 3089 off = win_col_off(win) - win_col_off2(win); 3090 if (col < off) 3091 col = off; 3092 col += row * (W_WIDTH(win) - off); 3093 /* add skip column (for long wrapping line) */ 3094 col += win->w_skipcol; 3095 } 3096 3097 if (!win->w_p_wrap) 3098 col += win->w_leftcol; 3099 3100 /* skip line number and fold column in front of the line */ 3101 col -= win_col_off(win); 3102 if (col < 0) 3103 { 3104 #ifdef FEAT_NETBEANS_INTG 3105 netbeans_gutter_click(lnum); 3106 #endif 3107 col = 0; 3108 } 3109 3110 *colp = col; 3111 *rowp = row; 3112 *lnump = lnum; 3113 return retval; 3114 } 3115 3116 #if defined(FEAT_WINDOWS) || defined(PROTO) 3117 /* 3118 * Find the window at screen position "*rowp" and "*colp". The positions are 3119 * updated to become relative to the top-left of the window. 3120 */ 3121 win_T * 3122 mouse_find_win(int *rowp, int *colp UNUSED) 3123 { 3124 frame_T *fp; 3125 3126 fp = topframe; 3127 *rowp -= firstwin->w_winrow; 3128 for (;;) 3129 { 3130 if (fp->fr_layout == FR_LEAF) 3131 break; 3132 if (fp->fr_layout == FR_ROW) 3133 { 3134 for (fp = fp->fr_child; fp->fr_next != NULL; fp = fp->fr_next) 3135 { 3136 if (*colp < fp->fr_width) 3137 break; 3138 *colp -= fp->fr_width; 3139 } 3140 } 3141 else /* fr_layout == FR_COL */ 3142 { 3143 for (fp = fp->fr_child; fp->fr_next != NULL; fp = fp->fr_next) 3144 { 3145 if (*rowp < fp->fr_height) 3146 break; 3147 *rowp -= fp->fr_height; 3148 } 3149 } 3150 } 3151 return fp->fr_win; 3152 } 3153 #endif 3154 3155 #if defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_GTK) || defined(FEAT_GUI_MAC) \ 3156 || defined(FEAT_GUI_ATHENA) || defined(FEAT_GUI_MSWIN) \ 3157 || defined(FEAT_GUI_PHOTON) || defined(PROTO) 3158 /* 3159 * Translate window coordinates to buffer position without any side effects 3160 */ 3161 int 3162 get_fpos_of_mouse(pos_T *mpos) 3163 { 3164 win_T *wp; 3165 int row = mouse_row; 3166 int col = mouse_col; 3167 3168 if (row < 0 || col < 0) /* check if it makes sense */ 3169 return IN_UNKNOWN; 3170 3171 #ifdef FEAT_WINDOWS 3172 /* find the window where the row is in */ 3173 wp = mouse_find_win(&row, &col); 3174 #else 3175 wp = firstwin; 3176 #endif 3177 /* 3178 * winpos and height may change in win_enter()! 3179 */ 3180 if (row >= wp->w_height) /* In (or below) status line */ 3181 return IN_STATUS_LINE; 3182 #ifdef FEAT_WINDOWS 3183 if (col >= wp->w_width) /* In vertical separator line */ 3184 return IN_SEP_LINE; 3185 #endif 3186 3187 if (wp != curwin) 3188 return IN_UNKNOWN; 3189 3190 /* compute the position in the buffer line from the posn on the screen */ 3191 if (mouse_comp_pos(curwin, &row, &col, &mpos->lnum)) 3192 return IN_STATUS_LINE; /* past bottom */ 3193 3194 mpos->col = vcol2col(wp, mpos->lnum, col); 3195 3196 if (mpos->col > 0) 3197 --mpos->col; 3198 #ifdef FEAT_VIRTUALEDIT 3199 mpos->coladd = 0; 3200 #endif 3201 return IN_BUFFER; 3202 } 3203 3204 /* 3205 * Convert a virtual (screen) column to a character column. 3206 * The first column is one. 3207 */ 3208 int 3209 vcol2col(win_T *wp, linenr_T lnum, int vcol) 3210 { 3211 /* try to advance to the specified column */ 3212 int count = 0; 3213 char_u *ptr; 3214 char_u *line; 3215 3216 line = ptr = ml_get_buf(wp->w_buffer, lnum, FALSE); 3217 while (count < vcol && *ptr != NUL) 3218 { 3219 count += win_lbr_chartabsize(wp, line, ptr, count, NULL); 3220 MB_PTR_ADV(ptr); 3221 } 3222 return (int)(ptr - line); 3223 } 3224 #endif 3225 3226 #endif /* FEAT_MOUSE */ 3227 3228 #if defined(FEAT_GUI) || defined(WIN3264) || defined(PROTO) 3229 /* 3230 * Called when focus changed. Used for the GUI or for systems where this can 3231 * be done in the console (Win32). 3232 */ 3233 void 3234 ui_focus_change( 3235 int in_focus) /* TRUE if focus gained. */ 3236 { 3237 static time_t last_time = (time_t)0; 3238 int need_redraw = FALSE; 3239 3240 /* When activated: Check if any file was modified outside of Vim. 3241 * Only do this when not done within the last two seconds (could get 3242 * several events in a row). */ 3243 if (in_focus && last_time + 2 < time(NULL)) 3244 { 3245 need_redraw = check_timestamps( 3246 # ifdef FEAT_GUI 3247 gui.in_use 3248 # else 3249 FALSE 3250 # endif 3251 ); 3252 last_time = time(NULL); 3253 } 3254 3255 #ifdef FEAT_AUTOCMD 3256 /* 3257 * Fire the focus gained/lost autocommand. 3258 */ 3259 need_redraw |= apply_autocmds(in_focus ? EVENT_FOCUSGAINED 3260 : EVENT_FOCUSLOST, NULL, NULL, FALSE, curbuf); 3261 #endif 3262 3263 if (need_redraw) 3264 { 3265 /* Something was executed, make sure the cursor is put back where it 3266 * belongs. */ 3267 need_wait_return = FALSE; 3268 3269 if (State & CMDLINE) 3270 redrawcmdline(); 3271 else if (State == HITRETURN || State == SETWSIZE || State == ASKMORE 3272 || State == EXTERNCMD || State == CONFIRM || exmode_active) 3273 repeat_message(); 3274 else if ((State & NORMAL) || (State & INSERT)) 3275 { 3276 if (must_redraw != 0) 3277 update_screen(0); 3278 setcursor(); 3279 } 3280 cursor_on(); /* redrawing may have switched it off */ 3281 out_flush(); 3282 # ifdef FEAT_GUI 3283 if (gui.in_use) 3284 { 3285 gui_update_cursor(FALSE, TRUE); 3286 gui_update_scrollbars(FALSE); 3287 } 3288 # endif 3289 } 3290 #ifdef FEAT_TITLE 3291 /* File may have been changed from 'readonly' to 'noreadonly' */ 3292 if (need_maketitle) 3293 maketitle(); 3294 #endif 3295 } 3296 #endif 3297 3298 #if defined(USE_IM_CONTROL) || defined(PROTO) 3299 /* 3300 * Save current Input Method status to specified place. 3301 */ 3302 void 3303 im_save_status(long *psave) 3304 { 3305 /* Don't save when 'imdisable' is set or "xic" is NULL, IM is always 3306 * disabled then (but might start later). 3307 * Also don't save when inside a mapping, vgetc_im_active has not been set 3308 * then. 3309 * And don't save when the keys were stuffed (e.g., for a "." command). 3310 * And don't save when the GUI is running but our window doesn't have 3311 * input focus (e.g., when a find dialog is open). */ 3312 if (!p_imdisable && KeyTyped && !KeyStuffed 3313 # ifdef FEAT_XIM 3314 && xic != NULL 3315 # endif 3316 # ifdef FEAT_GUI 3317 && (!gui.in_use || gui.in_focus) 3318 # endif 3319 ) 3320 { 3321 /* Do save when IM is on, or IM is off and saved status is on. */ 3322 if (vgetc_im_active) 3323 *psave = B_IMODE_IM; 3324 else if (*psave == B_IMODE_IM) 3325 *psave = B_IMODE_NONE; 3326 } 3327 } 3328 #endif 3329