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(void) 1946 { 1947 # ifdef FEAT_GUI 1948 if (gui.in_use) 1949 gui_update_cursor_later(); 1950 else 1951 # endif 1952 term_cursor_shape(); 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 #endif 1963 1964 #if defined(FEAT_CLIPBOARD) || defined(FEAT_GUI) || defined(FEAT_RIGHTLEFT) \ 1965 || defined(FEAT_MBYTE) || defined(PROTO) 1966 /* 1967 * Check bounds for column number 1968 */ 1969 int 1970 check_col(int col) 1971 { 1972 if (col < 0) 1973 return 0; 1974 if (col >= (int)screen_Columns) 1975 return (int)screen_Columns - 1; 1976 return col; 1977 } 1978 1979 /* 1980 * Check bounds for row number 1981 */ 1982 int 1983 check_row(int row) 1984 { 1985 if (row < 0) 1986 return 0; 1987 if (row >= (int)screen_Rows) 1988 return (int)screen_Rows - 1; 1989 return row; 1990 } 1991 #endif 1992 1993 /* 1994 * Stuff for the X clipboard. Shared between VMS and Unix. 1995 */ 1996 1997 #if defined(FEAT_XCLIPBOARD) || defined(FEAT_GUI_X11) || defined(PROTO) 1998 # include <X11/Xatom.h> 1999 # include <X11/Intrinsic.h> 2000 2001 /* 2002 * Open the application context (if it hasn't been opened yet). 2003 * Used for Motif and Athena GUI and the xterm clipboard. 2004 */ 2005 void 2006 open_app_context(void) 2007 { 2008 if (app_context == NULL) 2009 { 2010 XtToolkitInitialize(); 2011 app_context = XtCreateApplicationContext(); 2012 } 2013 } 2014 2015 static Atom vim_atom; /* Vim's own special selection format */ 2016 #ifdef FEAT_MBYTE 2017 static Atom vimenc_atom; /* Vim's extended selection format */ 2018 static Atom utf8_atom; 2019 #endif 2020 static Atom compound_text_atom; 2021 static Atom text_atom; 2022 static Atom targets_atom; 2023 static Atom timestamp_atom; /* Used to get a timestamp */ 2024 2025 void 2026 x11_setup_atoms(Display *dpy) 2027 { 2028 vim_atom = XInternAtom(dpy, VIM_ATOM_NAME, False); 2029 #ifdef FEAT_MBYTE 2030 vimenc_atom = XInternAtom(dpy, VIMENC_ATOM_NAME,False); 2031 utf8_atom = XInternAtom(dpy, "UTF8_STRING", False); 2032 #endif 2033 compound_text_atom = XInternAtom(dpy, "COMPOUND_TEXT", False); 2034 text_atom = XInternAtom(dpy, "TEXT", False); 2035 targets_atom = XInternAtom(dpy, "TARGETS", False); 2036 clip_star.sel_atom = XA_PRIMARY; 2037 clip_plus.sel_atom = XInternAtom(dpy, "CLIPBOARD", False); 2038 timestamp_atom = XInternAtom(dpy, "TIMESTAMP", False); 2039 } 2040 2041 /* 2042 * X Selection stuff, for cutting and pasting text to other windows. 2043 */ 2044 2045 static Boolean clip_x11_convert_selection_cb(Widget w, Atom *sel_atom, Atom *target, Atom *type, XtPointer *value, long_u *length, int *format); 2046 static void clip_x11_lose_ownership_cb(Widget w, Atom *sel_atom); 2047 static void clip_x11_notify_cb(Widget w, Atom *sel_atom, Atom *target); 2048 static void clip_x11_timestamp_cb(Widget w, XtPointer n, XEvent *event, Boolean *cont); 2049 static void clip_x11_request_selection_cb(Widget w, XtPointer success, Atom *sel_atom, Atom *type, XtPointer value, long_u *length, int *format); 2050 2051 /* 2052 * Property callback to get a timestamp for XtOwnSelection. 2053 */ 2054 static void 2055 clip_x11_timestamp_cb( 2056 Widget w, 2057 XtPointer n UNUSED, 2058 XEvent *event, 2059 Boolean *cont UNUSED) 2060 { 2061 Atom actual_type; 2062 int format; 2063 unsigned long nitems, bytes_after; 2064 unsigned char *prop=NULL; 2065 XPropertyEvent *xproperty=&event->xproperty; 2066 2067 /* Must be a property notify, state can't be Delete (True), has to be 2068 * one of the supported selection types. */ 2069 if (event->type != PropertyNotify || xproperty->state 2070 || (xproperty->atom != clip_star.sel_atom 2071 && xproperty->atom != clip_plus.sel_atom)) 2072 return; 2073 2074 if (XGetWindowProperty(xproperty->display, xproperty->window, 2075 xproperty->atom, 0, 0, False, timestamp_atom, &actual_type, &format, 2076 &nitems, &bytes_after, &prop)) 2077 return; 2078 2079 if (prop) 2080 XFree(prop); 2081 2082 /* Make sure the property type is "TIMESTAMP" and it's 32 bits. */ 2083 if (actual_type != timestamp_atom || format != 32) 2084 return; 2085 2086 /* Get the selection, using the event timestamp. */ 2087 if (XtOwnSelection(w, xproperty->atom, xproperty->time, 2088 clip_x11_convert_selection_cb, clip_x11_lose_ownership_cb, 2089 clip_x11_notify_cb) == OK) 2090 { 2091 /* Set the "owned" flag now, there may have been a call to 2092 * lose_ownership_cb in between. */ 2093 if (xproperty->atom == clip_plus.sel_atom) 2094 clip_plus.owned = TRUE; 2095 else 2096 clip_star.owned = TRUE; 2097 } 2098 } 2099 2100 void 2101 x11_setup_selection(Widget w) 2102 { 2103 XtAddEventHandler(w, PropertyChangeMask, False, 2104 /*(XtEventHandler)*/clip_x11_timestamp_cb, (XtPointer)NULL); 2105 } 2106 2107 static void 2108 clip_x11_request_selection_cb( 2109 Widget w UNUSED, 2110 XtPointer success, 2111 Atom *sel_atom, 2112 Atom *type, 2113 XtPointer value, 2114 long_u *length, 2115 int *format) 2116 { 2117 int motion_type = MAUTO; 2118 long_u len; 2119 char_u *p; 2120 char **text_list = NULL; 2121 VimClipboard *cbd; 2122 #ifdef FEAT_MBYTE 2123 char_u *tmpbuf = NULL; 2124 #endif 2125 2126 if (*sel_atom == clip_plus.sel_atom) 2127 cbd = &clip_plus; 2128 else 2129 cbd = &clip_star; 2130 2131 if (value == NULL || *length == 0) 2132 { 2133 clip_free_selection(cbd); /* nothing received, clear register */ 2134 *(int *)success = FALSE; 2135 return; 2136 } 2137 p = (char_u *)value; 2138 len = *length; 2139 if (*type == vim_atom) 2140 { 2141 motion_type = *p++; 2142 len--; 2143 } 2144 2145 #ifdef FEAT_MBYTE 2146 else if (*type == vimenc_atom) 2147 { 2148 char_u *enc; 2149 vimconv_T conv; 2150 int convlen; 2151 2152 motion_type = *p++; 2153 --len; 2154 2155 enc = p; 2156 p += STRLEN(p) + 1; 2157 len -= p - enc; 2158 2159 /* If the encoding of the text is different from 'encoding', attempt 2160 * converting it. */ 2161 conv.vc_type = CONV_NONE; 2162 convert_setup(&conv, enc, p_enc); 2163 if (conv.vc_type != CONV_NONE) 2164 { 2165 convlen = len; /* Need to use an int here. */ 2166 tmpbuf = string_convert(&conv, p, &convlen); 2167 len = convlen; 2168 if (tmpbuf != NULL) 2169 p = tmpbuf; 2170 convert_setup(&conv, NULL, NULL); 2171 } 2172 } 2173 #endif 2174 2175 else if (*type == compound_text_atom 2176 #ifdef FEAT_MBYTE 2177 || *type == utf8_atom 2178 #endif 2179 || ( 2180 #ifdef FEAT_MBYTE 2181 enc_dbcs != 0 && 2182 #endif 2183 *type == text_atom)) 2184 { 2185 XTextProperty text_prop; 2186 int n_text = 0; 2187 int status; 2188 2189 text_prop.value = (unsigned char *)value; 2190 text_prop.encoding = *type; 2191 text_prop.format = *format; 2192 text_prop.nitems = len; 2193 #if defined(FEAT_MBYTE) && defined(X_HAVE_UTF8_STRING) 2194 if (*type == utf8_atom) 2195 status = Xutf8TextPropertyToTextList(X_DISPLAY, &text_prop, 2196 &text_list, &n_text); 2197 else 2198 #endif 2199 status = XmbTextPropertyToTextList(X_DISPLAY, &text_prop, 2200 &text_list, &n_text); 2201 if (status != Success || n_text < 1) 2202 { 2203 *(int *)success = FALSE; 2204 return; 2205 } 2206 p = (char_u *)text_list[0]; 2207 len = STRLEN(p); 2208 } 2209 clip_yank_selection(motion_type, p, (long)len, cbd); 2210 2211 if (text_list != NULL) 2212 XFreeStringList(text_list); 2213 #ifdef FEAT_MBYTE 2214 vim_free(tmpbuf); 2215 #endif 2216 XtFree((char *)value); 2217 *(int *)success = TRUE; 2218 } 2219 2220 void 2221 clip_x11_request_selection( 2222 Widget myShell, 2223 Display *dpy, 2224 VimClipboard *cbd) 2225 { 2226 XEvent event; 2227 Atom type; 2228 static int success; 2229 int i; 2230 time_t start_time; 2231 int timed_out = FALSE; 2232 2233 for (i = 2234 #ifdef FEAT_MBYTE 2235 0 2236 #else 2237 1 2238 #endif 2239 ; i < 6; i++) 2240 { 2241 switch (i) 2242 { 2243 #ifdef FEAT_MBYTE 2244 case 0: type = vimenc_atom; break; 2245 #endif 2246 case 1: type = vim_atom; break; 2247 #ifdef FEAT_MBYTE 2248 case 2: type = utf8_atom; break; 2249 #endif 2250 case 3: type = compound_text_atom; break; 2251 case 4: type = text_atom; break; 2252 default: type = XA_STRING; 2253 } 2254 #ifdef FEAT_MBYTE 2255 if (type == utf8_atom 2256 # if defined(X_HAVE_UTF8_STRING) 2257 && !enc_utf8 2258 # endif 2259 ) 2260 /* Only request utf-8 when 'encoding' is utf8 and 2261 * Xutf8TextPropertyToTextList is available. */ 2262 continue; 2263 #endif 2264 success = MAYBE; 2265 XtGetSelectionValue(myShell, cbd->sel_atom, type, 2266 clip_x11_request_selection_cb, (XtPointer)&success, CurrentTime); 2267 2268 /* Make sure the request for the selection goes out before waiting for 2269 * a response. */ 2270 XFlush(dpy); 2271 2272 /* 2273 * Wait for result of selection request, otherwise if we type more 2274 * characters, then they will appear before the one that requested the 2275 * paste! Don't worry, we will catch up with any other events later. 2276 */ 2277 start_time = time(NULL); 2278 while (success == MAYBE) 2279 { 2280 if (XCheckTypedEvent(dpy, PropertyNotify, &event) 2281 || XCheckTypedEvent(dpy, SelectionNotify, &event) 2282 || XCheckTypedEvent(dpy, SelectionRequest, &event)) 2283 { 2284 /* This is where clip_x11_request_selection_cb() should be 2285 * called. It may actually happen a bit later, so we loop 2286 * until "success" changes. 2287 * We may get a SelectionRequest here and if we don't handle 2288 * it we hang. KDE klipper does this, for example. 2289 * We need to handle a PropertyNotify for large selections. */ 2290 XtDispatchEvent(&event); 2291 continue; 2292 } 2293 2294 /* Time out after 2 to 3 seconds to avoid that we hang when the 2295 * other process doesn't respond. Note that the SelectionNotify 2296 * event may still come later when the selection owner comes back 2297 * to life and the text gets inserted unexpectedly. Don't know 2298 * why that happens or how to avoid that :-(. */ 2299 if (time(NULL) > start_time + 2) 2300 { 2301 timed_out = TRUE; 2302 break; 2303 } 2304 2305 /* Do we need this? Probably not. */ 2306 XSync(dpy, False); 2307 2308 /* Wait for 1 msec to avoid that we eat up all CPU time. */ 2309 ui_delay(1L, TRUE); 2310 } 2311 2312 if (success == TRUE) 2313 return; 2314 2315 /* don't do a retry with another type after timing out, otherwise we 2316 * hang for 15 seconds. */ 2317 if (timed_out) 2318 break; 2319 } 2320 2321 /* Final fallback position - use the X CUT_BUFFER0 store */ 2322 yank_cut_buffer0(dpy, cbd); 2323 } 2324 2325 static Boolean 2326 clip_x11_convert_selection_cb( 2327 Widget w UNUSED, 2328 Atom *sel_atom, 2329 Atom *target, 2330 Atom *type, 2331 XtPointer *value, 2332 long_u *length, 2333 int *format) 2334 { 2335 static char_u *save_result = NULL; 2336 static long_u save_length = 0; 2337 char_u *string; 2338 int motion_type; 2339 VimClipboard *cbd; 2340 int i; 2341 2342 if (*sel_atom == clip_plus.sel_atom) 2343 cbd = &clip_plus; 2344 else 2345 cbd = &clip_star; 2346 2347 if (!cbd->owned) 2348 return False; /* Shouldn't ever happen */ 2349 2350 /* requestor wants to know what target types we support */ 2351 if (*target == targets_atom) 2352 { 2353 static Atom array[7]; 2354 2355 *value = (XtPointer)array; 2356 i = 0; 2357 array[i++] = targets_atom; 2358 #ifdef FEAT_MBYTE 2359 array[i++] = vimenc_atom; 2360 #endif 2361 array[i++] = vim_atom; 2362 #ifdef FEAT_MBYTE 2363 if (enc_utf8) 2364 array[i++] = utf8_atom; 2365 #endif 2366 array[i++] = XA_STRING; 2367 array[i++] = text_atom; 2368 array[i++] = compound_text_atom; 2369 2370 *type = XA_ATOM; 2371 /* This used to be: *format = sizeof(Atom) * 8; but that caused 2372 * crashes on 64 bit machines. (Peter Derr) */ 2373 *format = 32; 2374 *length = i; 2375 return True; 2376 } 2377 2378 if ( *target != XA_STRING 2379 #ifdef FEAT_MBYTE 2380 && *target != vimenc_atom 2381 && (*target != utf8_atom || !enc_utf8) 2382 #endif 2383 && *target != vim_atom 2384 && *target != text_atom 2385 && *target != compound_text_atom) 2386 return False; 2387 2388 clip_get_selection(cbd); 2389 motion_type = clip_convert_selection(&string, length, cbd); 2390 if (motion_type < 0) 2391 return False; 2392 2393 /* For our own format, the first byte contains the motion type */ 2394 if (*target == vim_atom) 2395 (*length)++; 2396 2397 #ifdef FEAT_MBYTE 2398 /* Our own format with encoding: motion 'encoding' NUL text */ 2399 if (*target == vimenc_atom) 2400 *length += STRLEN(p_enc) + 2; 2401 #endif 2402 2403 if (save_length < *length || save_length / 2 >= *length) 2404 *value = XtRealloc((char *)save_result, (Cardinal)*length + 1); 2405 else 2406 *value = save_result; 2407 if (*value == NULL) 2408 { 2409 vim_free(string); 2410 return False; 2411 } 2412 save_result = (char_u *)*value; 2413 save_length = *length; 2414 2415 if (*target == XA_STRING 2416 #ifdef FEAT_MBYTE 2417 || (*target == utf8_atom && enc_utf8) 2418 #endif 2419 ) 2420 { 2421 mch_memmove(save_result, string, (size_t)(*length)); 2422 *type = *target; 2423 } 2424 else if (*target == compound_text_atom || *target == text_atom) 2425 { 2426 XTextProperty text_prop; 2427 char *string_nt = (char *)save_result; 2428 int conv_result; 2429 2430 /* create NUL terminated string which XmbTextListToTextProperty wants */ 2431 mch_memmove(string_nt, string, (size_t)*length); 2432 string_nt[*length] = NUL; 2433 conv_result = XmbTextListToTextProperty(X_DISPLAY, (char **)&string_nt, 2434 1, XCompoundTextStyle, &text_prop); 2435 if (conv_result != Success) 2436 { 2437 vim_free(string); 2438 return False; 2439 } 2440 *value = (XtPointer)(text_prop.value); /* from plain text */ 2441 *length = text_prop.nitems; 2442 *type = compound_text_atom; 2443 XtFree((char *)save_result); 2444 save_result = (char_u *)*value; 2445 save_length = *length; 2446 } 2447 #ifdef FEAT_MBYTE 2448 else if (*target == vimenc_atom) 2449 { 2450 int l = STRLEN(p_enc); 2451 2452 save_result[0] = motion_type; 2453 STRCPY(save_result + 1, p_enc); 2454 mch_memmove(save_result + l + 2, string, (size_t)(*length - l - 2)); 2455 *type = vimenc_atom; 2456 } 2457 #endif 2458 else 2459 { 2460 save_result[0] = motion_type; 2461 mch_memmove(save_result + 1, string, (size_t)(*length - 1)); 2462 *type = vim_atom; 2463 } 2464 *format = 8; /* 8 bits per char */ 2465 vim_free(string); 2466 return True; 2467 } 2468 2469 static void 2470 clip_x11_lose_ownership_cb(Widget w UNUSED, Atom *sel_atom) 2471 { 2472 if (*sel_atom == clip_plus.sel_atom) 2473 clip_lose_selection(&clip_plus); 2474 else 2475 clip_lose_selection(&clip_star); 2476 } 2477 2478 void 2479 clip_x11_lose_selection(Widget myShell, VimClipboard *cbd) 2480 { 2481 XtDisownSelection(myShell, cbd->sel_atom, 2482 XtLastTimestampProcessed(XtDisplay(myShell))); 2483 } 2484 2485 static void 2486 clip_x11_notify_cb(Widget w UNUSED, Atom *sel_atom UNUSED, Atom *target UNUSED) 2487 { 2488 /* To prevent automatically freeing the selection value. */ 2489 } 2490 2491 int 2492 clip_x11_own_selection(Widget myShell, VimClipboard *cbd) 2493 { 2494 /* When using the GUI we have proper timestamps, use the one of the last 2495 * event. When in the console we don't get events (the terminal gets 2496 * them), Get the time by a zero-length append, clip_x11_timestamp_cb will 2497 * be called with the current timestamp. */ 2498 #ifdef FEAT_GUI 2499 if (gui.in_use) 2500 { 2501 if (XtOwnSelection(myShell, cbd->sel_atom, 2502 XtLastTimestampProcessed(XtDisplay(myShell)), 2503 clip_x11_convert_selection_cb, clip_x11_lose_ownership_cb, 2504 clip_x11_notify_cb) == False) 2505 return FAIL; 2506 } 2507 else 2508 #endif 2509 { 2510 if (!XChangeProperty(XtDisplay(myShell), XtWindow(myShell), 2511 cbd->sel_atom, timestamp_atom, 32, PropModeAppend, NULL, 0)) 2512 return FAIL; 2513 } 2514 /* Flush is required in a terminal as nothing else is doing it. */ 2515 XFlush(XtDisplay(myShell)); 2516 return OK; 2517 } 2518 2519 /* 2520 * Send the current selection to the clipboard. Do nothing for X because we 2521 * will fill in the selection only when requested by another app. 2522 */ 2523 void 2524 clip_x11_set_selection(VimClipboard *cbd UNUSED) 2525 { 2526 } 2527 2528 int 2529 clip_x11_owner_exists(VimClipboard *cbd) 2530 { 2531 return XGetSelectionOwner(X_DISPLAY, cbd->sel_atom) != None; 2532 } 2533 #endif 2534 2535 #if defined(FEAT_XCLIPBOARD) || defined(FEAT_GUI_X11) \ 2536 || defined(FEAT_GUI_GTK) || defined(PROTO) 2537 /* 2538 * Get the contents of the X CUT_BUFFER0 and put it in "cbd". 2539 */ 2540 void 2541 yank_cut_buffer0(Display *dpy, VimClipboard *cbd) 2542 { 2543 int nbytes = 0; 2544 char_u *buffer = (char_u *)XFetchBuffer(dpy, &nbytes, 0); 2545 2546 if (nbytes > 0) 2547 { 2548 #ifdef FEAT_MBYTE 2549 int done = FALSE; 2550 2551 /* CUT_BUFFER0 is supposed to be always latin1. Convert to 'enc' when 2552 * using a multi-byte encoding. Conversion between two 8-bit 2553 * character sets usually fails and the text might actually be in 2554 * 'enc' anyway. */ 2555 if (has_mbyte) 2556 { 2557 char_u *conv_buf; 2558 vimconv_T vc; 2559 2560 vc.vc_type = CONV_NONE; 2561 if (convert_setup(&vc, (char_u *)"latin1", p_enc) == OK) 2562 { 2563 conv_buf = string_convert(&vc, buffer, &nbytes); 2564 if (conv_buf != NULL) 2565 { 2566 clip_yank_selection(MCHAR, conv_buf, (long)nbytes, cbd); 2567 vim_free(conv_buf); 2568 done = TRUE; 2569 } 2570 convert_setup(&vc, NULL, NULL); 2571 } 2572 } 2573 if (!done) /* use the text without conversion */ 2574 #endif 2575 clip_yank_selection(MCHAR, buffer, (long)nbytes, cbd); 2576 XFree((void *)buffer); 2577 if (p_verbose > 0) 2578 { 2579 verbose_enter(); 2580 verb_msg((char_u *)_("Used CUT_BUFFER0 instead of empty selection")); 2581 verbose_leave(); 2582 } 2583 } 2584 } 2585 #endif 2586 2587 #if defined(FEAT_MOUSE) || defined(PROTO) 2588 2589 /* 2590 * Move the cursor to the specified row and column on the screen. 2591 * Change current window if necessary. Returns an integer with the 2592 * CURSOR_MOVED bit set if the cursor has moved or unset otherwise. 2593 * 2594 * The MOUSE_FOLD_CLOSE bit is set when clicked on the '-' in a fold column. 2595 * The MOUSE_FOLD_OPEN bit is set when clicked on the '+' in a fold column. 2596 * 2597 * If flags has MOUSE_FOCUS, then the current window will not be changed, and 2598 * if the mouse is outside the window then the text will scroll, or if the 2599 * mouse was previously on a status line, then the status line may be dragged. 2600 * 2601 * If flags has MOUSE_MAY_VIS, then VIsual mode will be started before the 2602 * cursor is moved unless the cursor was on a status line. 2603 * This function returns one of IN_UNKNOWN, IN_BUFFER, IN_STATUS_LINE or 2604 * IN_SEP_LINE depending on where the cursor was clicked. 2605 * 2606 * If flags has MOUSE_MAY_STOP_VIS, then Visual mode will be stopped, unless 2607 * the mouse is on the status line of the same window. 2608 * 2609 * If flags has MOUSE_DID_MOVE, nothing is done if the mouse didn't move since 2610 * the last call. 2611 * 2612 * If flags has MOUSE_SETPOS, nothing is done, only the current position is 2613 * remembered. 2614 */ 2615 int 2616 jump_to_mouse( 2617 int flags, 2618 int *inclusive, /* used for inclusive operator, can be NULL */ 2619 int which_button) /* MOUSE_LEFT, MOUSE_RIGHT, MOUSE_MIDDLE */ 2620 { 2621 static int on_status_line = 0; /* #lines below bottom of window */ 2622 #ifdef FEAT_WINDOWS 2623 static int on_sep_line = 0; /* on separator right of window */ 2624 #endif 2625 static int prev_row = -1; 2626 static int prev_col = -1; 2627 static win_T *dragwin = NULL; /* window being dragged */ 2628 static int did_drag = FALSE; /* drag was noticed */ 2629 2630 win_T *wp, *old_curwin; 2631 pos_T old_cursor; 2632 int count; 2633 int first; 2634 int row = mouse_row; 2635 int col = mouse_col; 2636 #ifdef FEAT_FOLDING 2637 int mouse_char; 2638 #endif 2639 2640 mouse_past_bottom = FALSE; 2641 mouse_past_eol = FALSE; 2642 2643 if (flags & MOUSE_RELEASED) 2644 { 2645 /* On button release we may change window focus if positioned on a 2646 * status line and no dragging happened. */ 2647 if (dragwin != NULL && !did_drag) 2648 flags &= ~(MOUSE_FOCUS | MOUSE_DID_MOVE); 2649 dragwin = NULL; 2650 did_drag = FALSE; 2651 } 2652 2653 if ((flags & MOUSE_DID_MOVE) 2654 && prev_row == mouse_row 2655 && prev_col == mouse_col) 2656 { 2657 retnomove: 2658 /* before moving the cursor for a left click which is NOT in a status 2659 * line, stop Visual mode */ 2660 if (on_status_line) 2661 return IN_STATUS_LINE; 2662 #ifdef FEAT_WINDOWS 2663 if (on_sep_line) 2664 return IN_SEP_LINE; 2665 #endif 2666 if (flags & MOUSE_MAY_STOP_VIS) 2667 { 2668 end_visual_mode(); 2669 redraw_curbuf_later(INVERTED); /* delete the inversion */ 2670 } 2671 #if defined(FEAT_CMDWIN) && defined(FEAT_CLIPBOARD) 2672 /* Continue a modeless selection in another window. */ 2673 if (cmdwin_type != 0 && row < W_WINROW(curwin)) 2674 return IN_OTHER_WIN; 2675 #endif 2676 return IN_BUFFER; 2677 } 2678 2679 prev_row = mouse_row; 2680 prev_col = mouse_col; 2681 2682 if (flags & MOUSE_SETPOS) 2683 goto retnomove; /* ugly goto... */ 2684 2685 #ifdef FEAT_FOLDING 2686 /* Remember the character under the mouse, it might be a '-' or '+' in the 2687 * fold column. */ 2688 if (row >= 0 && row < Rows && col >= 0 && col <= Columns 2689 && ScreenLines != NULL) 2690 mouse_char = ScreenLines[LineOffset[row] + col]; 2691 else 2692 mouse_char = ' '; 2693 #endif 2694 2695 old_curwin = curwin; 2696 old_cursor = curwin->w_cursor; 2697 2698 if (!(flags & MOUSE_FOCUS)) 2699 { 2700 if (row < 0 || col < 0) /* check if it makes sense */ 2701 return IN_UNKNOWN; 2702 2703 #ifdef FEAT_WINDOWS 2704 /* find the window where the row is in */ 2705 wp = mouse_find_win(&row, &col); 2706 #else 2707 wp = firstwin; 2708 #endif 2709 dragwin = NULL; 2710 /* 2711 * winpos and height may change in win_enter()! 2712 */ 2713 if (row >= wp->w_height) /* In (or below) status line */ 2714 { 2715 on_status_line = row - wp->w_height + 1; 2716 dragwin = wp; 2717 } 2718 else 2719 on_status_line = 0; 2720 #ifdef FEAT_WINDOWS 2721 if (col >= wp->w_width) /* In separator line */ 2722 { 2723 on_sep_line = col - wp->w_width + 1; 2724 dragwin = wp; 2725 } 2726 else 2727 on_sep_line = 0; 2728 2729 /* The rightmost character of the status line might be a vertical 2730 * separator character if there is no connecting window to the right. */ 2731 if (on_status_line && on_sep_line) 2732 { 2733 if (stl_connected(wp)) 2734 on_sep_line = 0; 2735 else 2736 on_status_line = 0; 2737 } 2738 #endif 2739 2740 /* Before jumping to another buffer, or moving the cursor for a left 2741 * click, stop Visual mode. */ 2742 if (VIsual_active 2743 && (wp->w_buffer != curwin->w_buffer 2744 || (!on_status_line 2745 #ifdef FEAT_WINDOWS 2746 && !on_sep_line 2747 #endif 2748 #ifdef FEAT_FOLDING 2749 && ( 2750 # ifdef FEAT_RIGHTLEFT 2751 wp->w_p_rl ? col < W_WIDTH(wp) - wp->w_p_fdc : 2752 # endif 2753 col >= wp->w_p_fdc 2754 # ifdef FEAT_CMDWIN 2755 + (cmdwin_type == 0 && wp == curwin ? 0 : 1) 2756 # endif 2757 ) 2758 #endif 2759 && (flags & MOUSE_MAY_STOP_VIS)))) 2760 { 2761 end_visual_mode(); 2762 redraw_curbuf_later(INVERTED); /* delete the inversion */ 2763 } 2764 #ifdef FEAT_CMDWIN 2765 if (cmdwin_type != 0 && wp != curwin) 2766 { 2767 /* A click outside the command-line window: Use modeless 2768 * selection if possible. Allow dragging the status lines. */ 2769 on_sep_line = 0; 2770 # ifdef FEAT_CLIPBOARD 2771 if (on_status_line) 2772 return IN_STATUS_LINE; 2773 return IN_OTHER_WIN; 2774 # else 2775 row = 0; 2776 col += wp->w_wincol; 2777 wp = curwin; 2778 # endif 2779 } 2780 #endif 2781 #ifdef FEAT_WINDOWS 2782 /* Only change window focus when not clicking on or dragging the 2783 * status line. Do change focus when releasing the mouse button 2784 * (MOUSE_FOCUS was set above if we dragged first). */ 2785 if (dragwin == NULL || (flags & MOUSE_RELEASED)) 2786 win_enter(wp, TRUE); /* can make wp invalid! */ 2787 # ifdef CHECK_DOUBLE_CLICK 2788 /* set topline, to be able to check for double click ourselves */ 2789 if (curwin != old_curwin) 2790 set_mouse_topline(curwin); 2791 # endif 2792 #endif 2793 if (on_status_line) /* In (or below) status line */ 2794 { 2795 /* Don't use start_arrow() if we're in the same window */ 2796 if (curwin == old_curwin) 2797 return IN_STATUS_LINE; 2798 else 2799 return IN_STATUS_LINE | CURSOR_MOVED; 2800 } 2801 #ifdef FEAT_WINDOWS 2802 if (on_sep_line) /* In (or below) status line */ 2803 { 2804 /* Don't use start_arrow() if we're in the same window */ 2805 if (curwin == old_curwin) 2806 return IN_SEP_LINE; 2807 else 2808 return IN_SEP_LINE | CURSOR_MOVED; 2809 } 2810 #endif 2811 2812 curwin->w_cursor.lnum = curwin->w_topline; 2813 #ifdef FEAT_GUI 2814 /* remember topline, needed for double click */ 2815 gui_prev_topline = curwin->w_topline; 2816 # ifdef FEAT_DIFF 2817 gui_prev_topfill = curwin->w_topfill; 2818 # endif 2819 #endif 2820 } 2821 else if (on_status_line && which_button == MOUSE_LEFT) 2822 { 2823 #ifdef FEAT_WINDOWS 2824 if (dragwin != NULL) 2825 { 2826 /* Drag the status line */ 2827 count = row - dragwin->w_winrow - dragwin->w_height + 1 2828 - on_status_line; 2829 win_drag_status_line(dragwin, count); 2830 did_drag |= count; 2831 } 2832 #endif 2833 return IN_STATUS_LINE; /* Cursor didn't move */ 2834 } 2835 #ifdef FEAT_WINDOWS 2836 else if (on_sep_line && which_button == MOUSE_LEFT) 2837 { 2838 if (dragwin != NULL) 2839 { 2840 /* Drag the separator column */ 2841 count = col - dragwin->w_wincol - dragwin->w_width + 1 2842 - on_sep_line; 2843 win_drag_vsep_line(dragwin, count); 2844 did_drag |= count; 2845 } 2846 return IN_SEP_LINE; /* Cursor didn't move */ 2847 } 2848 #endif 2849 else /* keep_window_focus must be TRUE */ 2850 { 2851 /* before moving the cursor for a left click, stop Visual mode */ 2852 if (flags & MOUSE_MAY_STOP_VIS) 2853 { 2854 end_visual_mode(); 2855 redraw_curbuf_later(INVERTED); /* delete the inversion */ 2856 } 2857 2858 #if defined(FEAT_CMDWIN) && defined(FEAT_CLIPBOARD) 2859 /* Continue a modeless selection in another window. */ 2860 if (cmdwin_type != 0 && row < W_WINROW(curwin)) 2861 return IN_OTHER_WIN; 2862 #endif 2863 2864 row -= W_WINROW(curwin); 2865 #ifdef FEAT_WINDOWS 2866 col -= W_WINCOL(curwin); 2867 #endif 2868 2869 /* 2870 * When clicking beyond the end of the window, scroll the screen. 2871 * Scroll by however many rows outside the window we are. 2872 */ 2873 if (row < 0) 2874 { 2875 count = 0; 2876 for (first = TRUE; curwin->w_topline > 1; ) 2877 { 2878 #ifdef FEAT_DIFF 2879 if (curwin->w_topfill < diff_check(curwin, curwin->w_topline)) 2880 ++count; 2881 else 2882 #endif 2883 count += plines(curwin->w_topline - 1); 2884 if (!first && count > -row) 2885 break; 2886 first = FALSE; 2887 #ifdef FEAT_FOLDING 2888 (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL); 2889 #endif 2890 #ifdef FEAT_DIFF 2891 if (curwin->w_topfill < diff_check(curwin, curwin->w_topline)) 2892 ++curwin->w_topfill; 2893 else 2894 #endif 2895 { 2896 --curwin->w_topline; 2897 #ifdef FEAT_DIFF 2898 curwin->w_topfill = 0; 2899 #endif 2900 } 2901 } 2902 #ifdef FEAT_DIFF 2903 check_topfill(curwin, FALSE); 2904 #endif 2905 curwin->w_valid &= 2906 ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP); 2907 redraw_later(VALID); 2908 row = 0; 2909 } 2910 else if (row >= curwin->w_height) 2911 { 2912 count = 0; 2913 for (first = TRUE; curwin->w_topline < curbuf->b_ml.ml_line_count; ) 2914 { 2915 #ifdef FEAT_DIFF 2916 if (curwin->w_topfill > 0) 2917 ++count; 2918 else 2919 #endif 2920 count += plines(curwin->w_topline); 2921 if (!first && count > row - curwin->w_height + 1) 2922 break; 2923 first = FALSE; 2924 #ifdef FEAT_FOLDING 2925 if (hasFolding(curwin->w_topline, NULL, &curwin->w_topline) 2926 && curwin->w_topline == curbuf->b_ml.ml_line_count) 2927 break; 2928 #endif 2929 #ifdef FEAT_DIFF 2930 if (curwin->w_topfill > 0) 2931 --curwin->w_topfill; 2932 else 2933 #endif 2934 { 2935 ++curwin->w_topline; 2936 #ifdef FEAT_DIFF 2937 curwin->w_topfill = 2938 diff_check_fill(curwin, curwin->w_topline); 2939 #endif 2940 } 2941 } 2942 #ifdef FEAT_DIFF 2943 check_topfill(curwin, FALSE); 2944 #endif 2945 redraw_later(VALID); 2946 curwin->w_valid &= 2947 ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP); 2948 row = curwin->w_height - 1; 2949 } 2950 else if (row == 0) 2951 { 2952 /* When dragging the mouse, while the text has been scrolled up as 2953 * far as it goes, moving the mouse in the top line should scroll 2954 * the text down (done later when recomputing w_topline). */ 2955 if (mouse_dragging > 0 2956 && curwin->w_cursor.lnum 2957 == curwin->w_buffer->b_ml.ml_line_count 2958 && curwin->w_cursor.lnum == curwin->w_topline) 2959 curwin->w_valid &= ~(VALID_TOPLINE); 2960 } 2961 } 2962 2963 #ifdef FEAT_FOLDING 2964 /* Check for position outside of the fold column. */ 2965 if ( 2966 # ifdef FEAT_RIGHTLEFT 2967 curwin->w_p_rl ? col < W_WIDTH(curwin) - curwin->w_p_fdc : 2968 # endif 2969 col >= curwin->w_p_fdc 2970 # ifdef FEAT_CMDWIN 2971 + (cmdwin_type == 0 ? 0 : 1) 2972 # endif 2973 ) 2974 mouse_char = ' '; 2975 #endif 2976 2977 /* compute the position in the buffer line from the posn on the screen */ 2978 if (mouse_comp_pos(curwin, &row, &col, &curwin->w_cursor.lnum)) 2979 mouse_past_bottom = TRUE; 2980 2981 /* Start Visual mode before coladvance(), for when 'sel' != "old" */ 2982 if ((flags & MOUSE_MAY_VIS) && !VIsual_active) 2983 { 2984 check_visual_highlight(); 2985 VIsual = old_cursor; 2986 VIsual_active = TRUE; 2987 VIsual_reselect = TRUE; 2988 /* if 'selectmode' contains "mouse", start Select mode */ 2989 may_start_select('o'); 2990 setmouse(); 2991 if (p_smd && msg_silent == 0) 2992 redraw_cmdline = TRUE; /* show visual mode later */ 2993 } 2994 2995 curwin->w_curswant = col; 2996 curwin->w_set_curswant = FALSE; /* May still have been TRUE */ 2997 if (coladvance(col) == FAIL) /* Mouse click beyond end of line */ 2998 { 2999 if (inclusive != NULL) 3000 *inclusive = TRUE; 3001 mouse_past_eol = TRUE; 3002 } 3003 else if (inclusive != NULL) 3004 *inclusive = FALSE; 3005 3006 count = IN_BUFFER; 3007 if (curwin != old_curwin || curwin->w_cursor.lnum != old_cursor.lnum 3008 || curwin->w_cursor.col != old_cursor.col) 3009 count |= CURSOR_MOVED; /* Cursor has moved */ 3010 3011 #ifdef FEAT_FOLDING 3012 if (mouse_char == '+') 3013 count |= MOUSE_FOLD_OPEN; 3014 else if (mouse_char != ' ') 3015 count |= MOUSE_FOLD_CLOSE; 3016 #endif 3017 3018 return count; 3019 } 3020 3021 /* 3022 * Compute the position in the buffer line from the posn on the screen in 3023 * window "win". 3024 * Returns TRUE if the position is below the last line. 3025 */ 3026 int 3027 mouse_comp_pos( 3028 win_T *win, 3029 int *rowp, 3030 int *colp, 3031 linenr_T *lnump) 3032 { 3033 int col = *colp; 3034 int row = *rowp; 3035 linenr_T lnum; 3036 int retval = FALSE; 3037 int off; 3038 int count; 3039 3040 #ifdef FEAT_RIGHTLEFT 3041 if (win->w_p_rl) 3042 col = W_WIDTH(win) - 1 - col; 3043 #endif 3044 3045 lnum = win->w_topline; 3046 3047 while (row > 0) 3048 { 3049 #ifdef FEAT_DIFF 3050 /* Don't include filler lines in "count" */ 3051 if (win->w_p_diff 3052 # ifdef FEAT_FOLDING 3053 && !hasFoldingWin(win, lnum, NULL, NULL, TRUE, NULL) 3054 # endif 3055 ) 3056 { 3057 if (lnum == win->w_topline) 3058 row -= win->w_topfill; 3059 else 3060 row -= diff_check_fill(win, lnum); 3061 count = plines_win_nofill(win, lnum, TRUE); 3062 } 3063 else 3064 #endif 3065 count = plines_win(win, lnum, TRUE); 3066 if (count > row) 3067 break; /* Position is in this buffer line. */ 3068 #ifdef FEAT_FOLDING 3069 (void)hasFoldingWin(win, lnum, NULL, &lnum, TRUE, NULL); 3070 #endif 3071 if (lnum == win->w_buffer->b_ml.ml_line_count) 3072 { 3073 retval = TRUE; 3074 break; /* past end of file */ 3075 } 3076 row -= count; 3077 ++lnum; 3078 } 3079 3080 if (!retval) 3081 { 3082 /* Compute the column without wrapping. */ 3083 off = win_col_off(win) - win_col_off2(win); 3084 if (col < off) 3085 col = off; 3086 col += row * (W_WIDTH(win) - off); 3087 /* add skip column (for long wrapping line) */ 3088 col += win->w_skipcol; 3089 } 3090 3091 if (!win->w_p_wrap) 3092 col += win->w_leftcol; 3093 3094 /* skip line number and fold column in front of the line */ 3095 col -= win_col_off(win); 3096 if (col < 0) 3097 { 3098 #ifdef FEAT_NETBEANS_INTG 3099 netbeans_gutter_click(lnum); 3100 #endif 3101 col = 0; 3102 } 3103 3104 *colp = col; 3105 *rowp = row; 3106 *lnump = lnum; 3107 return retval; 3108 } 3109 3110 #if defined(FEAT_WINDOWS) || defined(PROTO) 3111 /* 3112 * Find the window at screen position "*rowp" and "*colp". The positions are 3113 * updated to become relative to the top-left of the window. 3114 */ 3115 win_T * 3116 mouse_find_win(int *rowp, int *colp UNUSED) 3117 { 3118 frame_T *fp; 3119 3120 fp = topframe; 3121 *rowp -= firstwin->w_winrow; 3122 for (;;) 3123 { 3124 if (fp->fr_layout == FR_LEAF) 3125 break; 3126 if (fp->fr_layout == FR_ROW) 3127 { 3128 for (fp = fp->fr_child; fp->fr_next != NULL; fp = fp->fr_next) 3129 { 3130 if (*colp < fp->fr_width) 3131 break; 3132 *colp -= fp->fr_width; 3133 } 3134 } 3135 else /* fr_layout == FR_COL */ 3136 { 3137 for (fp = fp->fr_child; fp->fr_next != NULL; fp = fp->fr_next) 3138 { 3139 if (*rowp < fp->fr_height) 3140 break; 3141 *rowp -= fp->fr_height; 3142 } 3143 } 3144 } 3145 return fp->fr_win; 3146 } 3147 #endif 3148 3149 #if defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_GTK) || defined(FEAT_GUI_MAC) \ 3150 || defined(FEAT_GUI_ATHENA) || defined(FEAT_GUI_MSWIN) \ 3151 || defined(FEAT_GUI_PHOTON) || defined(PROTO) 3152 /* 3153 * Translate window coordinates to buffer position without any side effects 3154 */ 3155 int 3156 get_fpos_of_mouse(pos_T *mpos) 3157 { 3158 win_T *wp; 3159 int row = mouse_row; 3160 int col = mouse_col; 3161 3162 if (row < 0 || col < 0) /* check if it makes sense */ 3163 return IN_UNKNOWN; 3164 3165 #ifdef FEAT_WINDOWS 3166 /* find the window where the row is in */ 3167 wp = mouse_find_win(&row, &col); 3168 #else 3169 wp = firstwin; 3170 #endif 3171 /* 3172 * winpos and height may change in win_enter()! 3173 */ 3174 if (row >= wp->w_height) /* In (or below) status line */ 3175 return IN_STATUS_LINE; 3176 #ifdef FEAT_WINDOWS 3177 if (col >= wp->w_width) /* In vertical separator line */ 3178 return IN_SEP_LINE; 3179 #endif 3180 3181 if (wp != curwin) 3182 return IN_UNKNOWN; 3183 3184 /* compute the position in the buffer line from the posn on the screen */ 3185 if (mouse_comp_pos(curwin, &row, &col, &mpos->lnum)) 3186 return IN_STATUS_LINE; /* past bottom */ 3187 3188 mpos->col = vcol2col(wp, mpos->lnum, col); 3189 3190 if (mpos->col > 0) 3191 --mpos->col; 3192 #ifdef FEAT_VIRTUALEDIT 3193 mpos->coladd = 0; 3194 #endif 3195 return IN_BUFFER; 3196 } 3197 3198 /* 3199 * Convert a virtual (screen) column to a character column. 3200 * The first column is one. 3201 */ 3202 int 3203 vcol2col(win_T *wp, linenr_T lnum, int vcol) 3204 { 3205 /* try to advance to the specified column */ 3206 int count = 0; 3207 char_u *ptr; 3208 char_u *line; 3209 3210 line = ptr = ml_get_buf(wp->w_buffer, lnum, FALSE); 3211 while (count < vcol && *ptr != NUL) 3212 { 3213 count += win_lbr_chartabsize(wp, line, ptr, count, NULL); 3214 MB_PTR_ADV(ptr); 3215 } 3216 return (int)(ptr - line); 3217 } 3218 #endif 3219 3220 #endif /* FEAT_MOUSE */ 3221 3222 #if defined(FEAT_GUI) || defined(WIN3264) || defined(PROTO) 3223 /* 3224 * Called when focus changed. Used for the GUI or for systems where this can 3225 * be done in the console (Win32). 3226 */ 3227 void 3228 ui_focus_change( 3229 int in_focus) /* TRUE if focus gained. */ 3230 { 3231 static time_t last_time = (time_t)0; 3232 int need_redraw = FALSE; 3233 3234 /* When activated: Check if any file was modified outside of Vim. 3235 * Only do this when not done within the last two seconds (could get 3236 * several events in a row). */ 3237 if (in_focus && last_time + 2 < time(NULL)) 3238 { 3239 need_redraw = check_timestamps( 3240 # ifdef FEAT_GUI 3241 gui.in_use 3242 # else 3243 FALSE 3244 # endif 3245 ); 3246 last_time = time(NULL); 3247 } 3248 3249 #ifdef FEAT_AUTOCMD 3250 /* 3251 * Fire the focus gained/lost autocommand. 3252 */ 3253 need_redraw |= apply_autocmds(in_focus ? EVENT_FOCUSGAINED 3254 : EVENT_FOCUSLOST, NULL, NULL, FALSE, curbuf); 3255 #endif 3256 3257 if (need_redraw) 3258 { 3259 /* Something was executed, make sure the cursor is put back where it 3260 * belongs. */ 3261 need_wait_return = FALSE; 3262 3263 if (State & CMDLINE) 3264 redrawcmdline(); 3265 else if (State == HITRETURN || State == SETWSIZE || State == ASKMORE 3266 || State == EXTERNCMD || State == CONFIRM || exmode_active) 3267 repeat_message(); 3268 else if ((State & NORMAL) || (State & INSERT)) 3269 { 3270 if (must_redraw != 0) 3271 update_screen(0); 3272 setcursor(); 3273 } 3274 cursor_on(); /* redrawing may have switched it off */ 3275 out_flush(); 3276 # ifdef FEAT_GUI 3277 if (gui.in_use) 3278 { 3279 gui_update_cursor(FALSE, TRUE); 3280 gui_update_scrollbars(FALSE); 3281 } 3282 # endif 3283 } 3284 #ifdef FEAT_TITLE 3285 /* File may have been changed from 'readonly' to 'noreadonly' */ 3286 if (need_maketitle) 3287 maketitle(); 3288 #endif 3289 } 3290 #endif 3291 3292 #if defined(USE_IM_CONTROL) || defined(PROTO) 3293 /* 3294 * Save current Input Method status to specified place. 3295 */ 3296 void 3297 im_save_status(long *psave) 3298 { 3299 /* Don't save when 'imdisable' is set or "xic" is NULL, IM is always 3300 * disabled then (but might start later). 3301 * Also don't save when inside a mapping, vgetc_im_active has not been set 3302 * then. 3303 * And don't save when the keys were stuffed (e.g., for a "." command). 3304 * And don't save when the GUI is running but our window doesn't have 3305 * input focus (e.g., when a find dialog is open). */ 3306 if (!p_imdisable && KeyTyped && !KeyStuffed 3307 # ifdef FEAT_XIM 3308 && xic != NULL 3309 # endif 3310 # ifdef FEAT_GUI 3311 && (!gui.in_use || gui.in_focus) 3312 # endif 3313 ) 3314 { 3315 /* Do save when IM is on, or IM is off and saved status is on. */ 3316 if (vgetc_im_active) 3317 *psave = B_IMODE_IM; 3318 else if (*psave == B_IMODE_IM) 3319 *psave = B_IMODE_NONE; 3320 } 3321 } 3322 #endif 3323