summaryrefslogtreecommitdiffstats
path: root/src/mouse.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 08:50:31 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 08:50:31 +0000
commitaed8ce9da277f5ecffe968b324f242c41c3b752a (patch)
treed2e538394cb7a8a7c42a4aac6ccf1a8e3256999b /src/mouse.c
parentInitial commit. (diff)
downloadvim-aed8ce9da277f5ecffe968b324f242c41c3b752a.tar.xz
vim-aed8ce9da277f5ecffe968b324f242c41c3b752a.zip
Adding upstream version 2:9.0.1378.upstream/2%9.0.1378upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/mouse.c')
-rw-r--r--src/mouse.c3275
1 files changed, 3275 insertions, 0 deletions
diff --git a/src/mouse.c b/src/mouse.c
new file mode 100644
index 0000000..4e8dd4d
--- /dev/null
+++ b/src/mouse.c
@@ -0,0 +1,3275 @@
+/* vi:set ts=8 sts=4 sw=4 noet:
+ *
+ * VIM - Vi IMproved by Bram Moolenaar
+ *
+ * Do ":help uganda" in Vim to read copying and usage conditions.
+ * Do ":help credits" in Vim to see a list of people who contributed.
+ * See README.txt for an overview of the Vim source code.
+ */
+
+/*
+ * mouse.c: mouse handling functions
+ */
+
+#include "vim.h"
+
+/*
+ * Horiziontal and vertical steps used when scrolling.
+ * When negative scroll by a whole page.
+ */
+static long mouse_hor_step = 6;
+static long mouse_vert_step = 3;
+
+ void
+mouse_set_vert_scroll_step(long step)
+{
+ mouse_vert_step = step;
+}
+
+ void
+mouse_set_hor_scroll_step(long step)
+{
+ mouse_hor_step = step;
+}
+
+#ifdef CHECK_DOUBLE_CLICK
+/*
+ * Return the duration from t1 to t2 in milliseconds.
+ */
+ static long
+time_diff_ms(struct timeval *t1, struct timeval *t2)
+{
+ // This handles wrapping of tv_usec correctly without any special case.
+ // Example of 2 pairs (tv_sec, tv_usec) with a duration of 5 ms:
+ // t1 = (1, 998000) t2 = (2, 3000) gives:
+ // (2 - 1) * 1000 + (3000 - 998000) / 1000 -> 5 ms.
+ return (t2->tv_sec - t1->tv_sec) * 1000
+ + (t2->tv_usec - t1->tv_usec) / 1000;
+}
+#endif
+
+/*
+ * Get class of a character for selection: same class means same word.
+ * 0: blank
+ * 1: punctuation groups
+ * 2: normal word character
+ * >2: multi-byte word character.
+ */
+ static int
+get_mouse_class(char_u *p)
+{
+ int c;
+
+ if (has_mbyte && MB_BYTE2LEN(p[0]) > 1)
+ return mb_get_class(p);
+
+ c = *p;
+ if (c == ' ' || c == '\t')
+ return 0;
+
+ if (vim_iswordc(c))
+ return 2;
+
+ // There are a few special cases where we want certain combinations of
+ // characters to be considered as a single word. These are things like
+ // "->", "/ *", "*=", "+=", "&=", "<=", ">=", "!=" etc. Otherwise, each
+ // character is in its own class.
+ if (c != NUL && vim_strchr((char_u *)"-+*/%<>&|^!=", c) != NULL)
+ return 1;
+ return c;
+}
+
+/*
+ * Move "pos" back to the start of the word it's in.
+ */
+ static void
+find_start_of_word(pos_T *pos)
+{
+ char_u *line;
+ int cclass;
+ int col;
+
+ line = ml_get(pos->lnum);
+ cclass = get_mouse_class(line + pos->col);
+
+ while (pos->col > 0)
+ {
+ col = pos->col - 1;
+ col -= (*mb_head_off)(line, line + col);
+ if (get_mouse_class(line + col) != cclass)
+ break;
+ pos->col = col;
+ }
+}
+
+/*
+ * Move "pos" forward to the end of the word it's in.
+ * When 'selection' is "exclusive", the position is just after the word.
+ */
+ static void
+find_end_of_word(pos_T *pos)
+{
+ char_u *line;
+ int cclass;
+ int col;
+
+ line = ml_get(pos->lnum);
+ if (*p_sel == 'e' && pos->col > 0)
+ {
+ --pos->col;
+ pos->col -= (*mb_head_off)(line, line + pos->col);
+ }
+ cclass = get_mouse_class(line + pos->col);
+ while (line[pos->col] != NUL)
+ {
+ col = pos->col + (*mb_ptr2len)(line + pos->col);
+ if (get_mouse_class(line + col) != cclass)
+ {
+ if (*p_sel == 'e')
+ pos->col = col;
+ break;
+ }
+ pos->col = col;
+ }
+}
+
+#if defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_GTK) \
+ || defined(FEAT_GUI_MSWIN) \
+ || defined(FEAT_GUI_PHOTON) \
+ || defined(FEAT_TERM_POPUP_MENU)
+# define USE_POPUP_SETPOS
+# define NEED_VCOL2COL
+
+/*
+ * Translate window coordinates to buffer position without any side effects.
+ * Returns IN_BUFFER and sets "mpos->col" to the column when in buffer text.
+ * The column is one for the first column.
+ */
+ static int
+get_fpos_of_mouse(pos_T *mpos)
+{
+ win_T *wp;
+ int row = mouse_row;
+ int col = mouse_col;
+
+ if (row < 0 || col < 0) // check if it makes sense
+ return IN_UNKNOWN;
+
+ // find the window where the row is in
+ wp = mouse_find_win(&row, &col, FAIL_POPUP);
+ if (wp == NULL)
+ return IN_UNKNOWN;
+ // winpos and height may change in win_enter()!
+ if (row >= wp->w_height) // In (or below) status line
+ return IN_STATUS_LINE;
+ if (col >= wp->w_width) // In vertical separator line
+ return IN_SEP_LINE;
+
+ if (wp != curwin)
+ return IN_UNKNOWN;
+
+ // compute the position in the buffer line from the posn on the screen
+ if (mouse_comp_pos(curwin, &row, &col, &mpos->lnum, NULL))
+ return IN_STATUS_LINE; // past bottom
+
+ mpos->col = vcol2col(wp, mpos->lnum, col);
+
+ mpos->coladd = 0;
+ return IN_BUFFER;
+}
+#endif
+
+/*
+ * Do the appropriate action for the current mouse click in the current mode.
+ * Not used for Command-line mode.
+ *
+ * Normal and Visual Mode:
+ * event modi- position visual change action
+ * fier cursor window
+ * left press - yes end yes
+ * left press C yes end yes "^]" (2)
+ * left press S yes end (popup: extend) yes "*" (2)
+ * left drag - yes start if moved no
+ * left relse - yes start if moved no
+ * middle press - yes if not active no put register
+ * middle press - yes if active no yank and put
+ * right press - yes start or extend yes
+ * right press S yes no change yes "#" (2)
+ * right drag - yes extend no
+ * right relse - yes extend no
+ *
+ * Insert or Replace Mode:
+ * event modi- position visual change action
+ * fier cursor window
+ * left press - yes (cannot be active) yes
+ * left press C yes (cannot be active) yes "CTRL-O^]" (2)
+ * left press S yes (cannot be active) yes "CTRL-O*" (2)
+ * left drag - yes start or extend (1) no CTRL-O (1)
+ * left relse - yes start or extend (1) no CTRL-O (1)
+ * middle press - no (cannot be active) no put register
+ * right press - yes start or extend yes CTRL-O
+ * right press S yes (cannot be active) yes "CTRL-O#" (2)
+ *
+ * (1) only if mouse pointer moved since press
+ * (2) only if click is in same buffer
+ *
+ * Return TRUE if start_arrow() should be called for edit mode.
+ */
+ int
+do_mouse(
+ oparg_T *oap, // operator argument, can be NULL
+ int c, // K_LEFTMOUSE, etc
+ int dir, // Direction to 'put' if necessary
+ long count,
+ int fixindent) // PUT_FIXINDENT if fixing indent necessary
+{
+ static int do_always = FALSE; // ignore 'mouse' setting next time
+ static int got_click = FALSE; // got a click some time back
+
+ int which_button; // MOUSE_LEFT, _MIDDLE or _RIGHT
+ int is_click = FALSE; // If FALSE it's a drag or release event
+ int is_drag = FALSE; // If TRUE it's a drag event
+ int jump_flags = 0; // flags for jump_to_mouse()
+ pos_T start_visual;
+ int moved; // Has cursor moved?
+ int in_status_line; // mouse in status line
+ static int in_tab_line = FALSE; // mouse clicked in tab line
+ int in_sep_line; // mouse in vertical separator line
+ int c1, c2;
+#if defined(FEAT_FOLDING)
+ pos_T save_cursor;
+#endif
+ win_T *old_curwin = curwin;
+ static pos_T orig_cursor;
+ colnr_T leftcol, rightcol;
+ pos_T end_visual;
+ int diff;
+ int old_active = VIsual_active;
+ int old_mode = VIsual_mode;
+ int regname;
+
+#if defined(FEAT_FOLDING)
+ save_cursor = curwin->w_cursor;
+#endif
+
+ // When GUI is active, always recognize mouse events, otherwise:
+ // - Ignore mouse event in normal mode if 'mouse' doesn't include 'n'.
+ // - Ignore mouse event in visual mode if 'mouse' doesn't include 'v'.
+ // - For command line and insert mode 'mouse' is checked before calling
+ // do_mouse().
+ if (do_always)
+ do_always = FALSE;
+ else
+#ifdef FEAT_GUI
+ if (!gui.in_use)
+#endif
+ {
+ if (VIsual_active)
+ {
+ if (!mouse_has(MOUSE_VISUAL))
+ return FALSE;
+ }
+ else if (State == MODE_NORMAL && !mouse_has(MOUSE_NORMAL))
+ return FALSE;
+ }
+
+ for (;;)
+ {
+ which_button = get_mouse_button(KEY2TERMCAP1(c), &is_click, &is_drag);
+ if (is_drag)
+ {
+ // If the next character is the same mouse event then use that
+ // one. Speeds up dragging the status line.
+ // Note: Since characters added to the stuff buffer in the code
+ // below need to come before the next character, do not do this
+ // when the current character was stuffed.
+ if (!KeyStuffed && vpeekc() != NUL)
+ {
+ int nc;
+ int save_mouse_row = mouse_row;
+ int save_mouse_col = mouse_col;
+
+ // Need to get the character, peeking doesn't get the actual
+ // one.
+ nc = safe_vgetc();
+ if (c == nc)
+ continue;
+ vungetc(nc);
+ mouse_row = save_mouse_row;
+ mouse_col = save_mouse_col;
+ }
+ }
+ break;
+ }
+
+ if (c == K_MOUSEMOVE)
+ {
+ // Mouse moved without a button pressed.
+#ifdef FEAT_BEVAL_TERM
+ ui_may_remove_balloon();
+ if (p_bevalterm)
+ {
+ profile_setlimit(p_bdlay, &bevalexpr_due);
+ bevalexpr_due_set = TRUE;
+ }
+#endif
+#ifdef FEAT_PROP_POPUP
+ popup_handle_mouse_moved();
+#endif
+ return FALSE;
+ }
+
+#ifdef FEAT_MOUSESHAPE
+ // May have stopped dragging the status or separator line. The pointer is
+ // most likely still on the status or separator line.
+ if (!is_drag && drag_status_line)
+ {
+ drag_status_line = FALSE;
+ update_mouseshape(SHAPE_IDX_STATUS);
+ }
+ if (!is_drag && drag_sep_line)
+ {
+ drag_sep_line = FALSE;
+ update_mouseshape(SHAPE_IDX_VSEP);
+ }
+#endif
+
+ // Ignore drag and release events if we didn't get a click.
+ if (is_click)
+ got_click = TRUE;
+ else
+ {
+ if (!got_click) // didn't get click, ignore
+ return FALSE;
+ if (!is_drag) // release, reset got_click
+ {
+ got_click = FALSE;
+ if (in_tab_line)
+ {
+ in_tab_line = FALSE;
+ return FALSE;
+ }
+ }
+ }
+
+ // CTRL right mouse button does CTRL-T
+ if (is_click && (mod_mask & MOD_MASK_CTRL) && which_button == MOUSE_RIGHT)
+ {
+ if (State & MODE_INSERT)
+ stuffcharReadbuff(Ctrl_O);
+ if (count > 1)
+ stuffnumReadbuff(count);
+ stuffcharReadbuff(Ctrl_T);
+ got_click = FALSE; // ignore drag&release now
+ return FALSE;
+ }
+
+ // CTRL only works with left mouse button
+ if ((mod_mask & MOD_MASK_CTRL) && which_button != MOUSE_LEFT)
+ return FALSE;
+
+ // When a modifier is down, ignore drag and release events, as well as
+ // multiple clicks and the middle mouse button.
+ // Accept shift-leftmouse drags when 'mousemodel' is "popup.*".
+ if ((mod_mask & (MOD_MASK_SHIFT | MOD_MASK_CTRL | MOD_MASK_ALT
+ | MOD_MASK_META))
+ && (!is_click
+ || (mod_mask & MOD_MASK_MULTI_CLICK)
+ || which_button == MOUSE_MIDDLE)
+ && !((mod_mask & (MOD_MASK_SHIFT|MOD_MASK_ALT))
+ && mouse_model_popup()
+ && which_button == MOUSE_LEFT)
+ && !((mod_mask & MOD_MASK_ALT)
+ && !mouse_model_popup()
+ && which_button == MOUSE_RIGHT)
+ )
+ return FALSE;
+
+ // If the button press was used as the movement command for an operator
+ // (eg "d<MOUSE>"), or it is the middle button that is held down, ignore
+ // drag/release events.
+ if (!is_click && which_button == MOUSE_MIDDLE)
+ return FALSE;
+
+ if (oap != NULL)
+ regname = oap->regname;
+ else
+ regname = 0;
+
+ // Middle mouse button does a 'put' of the selected text
+ if (which_button == MOUSE_MIDDLE)
+ {
+ if (State == MODE_NORMAL)
+ {
+ // If an operator was pending, we don't know what the user wanted
+ // to do. Go back to normal mode: Clear the operator and beep().
+ if (oap != NULL && oap->op_type != OP_NOP)
+ {
+ clearopbeep(oap);
+ return FALSE;
+ }
+
+ // If visual was active, yank the highlighted text and put it
+ // before the mouse pointer position.
+ // In Select mode replace the highlighted text with the clipboard.
+ if (VIsual_active)
+ {
+ if (VIsual_select)
+ {
+ stuffcharReadbuff(Ctrl_G);
+ stuffReadbuff((char_u *)"\"+p");
+ }
+ else
+ {
+ stuffcharReadbuff('y');
+ stuffcharReadbuff(K_MIDDLEMOUSE);
+ }
+ do_always = TRUE; // ignore 'mouse' setting next time
+ return FALSE;
+ }
+ // The rest is below jump_to_mouse()
+ }
+
+ else if ((State & MODE_INSERT) == 0)
+ return FALSE;
+
+ // Middle click in insert mode doesn't move the mouse, just insert the
+ // contents of a register. '.' register is special, can't insert that
+ // with do_put().
+ // Also paste at the cursor if the current mode isn't in 'mouse' (only
+ // happens for the GUI).
+ if ((State & MODE_INSERT) || !mouse_has(MOUSE_NORMAL))
+ {
+ if (regname == '.')
+ insert_reg(regname, TRUE);
+ else
+ {
+#ifdef FEAT_CLIPBOARD
+ if (clip_star.available && regname == 0)
+ regname = '*';
+#endif
+ if ((State & REPLACE_FLAG) && !yank_register_mline(regname))
+ insert_reg(regname, TRUE);
+ else
+ {
+ do_put(regname, NULL, BACKWARD, 1L,
+ fixindent | PUT_CURSEND);
+
+ // Repeat it with CTRL-R CTRL-O r or CTRL-R CTRL-P r
+ AppendCharToRedobuff(Ctrl_R);
+ AppendCharToRedobuff(fixindent ? Ctrl_P : Ctrl_O);
+ AppendCharToRedobuff(regname == 0 ? '"' : regname);
+ }
+ }
+ return FALSE;
+ }
+ }
+
+ // When dragging or button-up stay in the same window.
+ if (!is_click)
+ jump_flags |= MOUSE_FOCUS | MOUSE_DID_MOVE;
+
+ start_visual.lnum = 0;
+
+ if (TabPageIdxs != NULL) // only when initialized
+ {
+ // Check for clicking in the tab page line.
+ if (mouse_row == 0 && firstwin->w_winrow > 0)
+ {
+ if (is_drag)
+ {
+ if (in_tab_line)
+ {
+ c1 = TabPageIdxs[mouse_col];
+ tabpage_move(c1 <= 0 ? 9999 : c1 < tabpage_index(curtab)
+ ? c1 - 1 : c1);
+ }
+ return FALSE;
+ }
+
+ // click in a tab selects that tab page
+ if (is_click && cmdwin_type == 0 && mouse_col < Columns)
+ {
+ in_tab_line = TRUE;
+ c1 = TabPageIdxs[mouse_col];
+ if (c1 >= 0)
+ {
+ if ((mod_mask & MOD_MASK_MULTI_CLICK) == MOD_MASK_2CLICK)
+ {
+ // double click opens new page
+ end_visual_mode_keep_button();
+ tabpage_new();
+ tabpage_move(c1 == 0 ? 9999 : c1 - 1);
+ }
+ else
+ {
+ // Go to specified tab page, or next one if not clicking
+ // on a label.
+ goto_tabpage(c1);
+
+ // It's like clicking on the status line of a window.
+ if (curwin != old_curwin)
+ end_visual_mode_keep_button();
+ }
+ }
+ else
+ {
+ tabpage_T *tp;
+
+ // Close the current or specified tab page.
+ if (c1 == -999)
+ tp = curtab;
+ else
+ tp = find_tabpage(-c1);
+ if (tp == curtab)
+ {
+ if (first_tabpage->tp_next != NULL)
+ tabpage_close(FALSE);
+ }
+ else if (tp != NULL)
+ tabpage_close_other(tp, FALSE);
+ }
+ }
+ return TRUE;
+ }
+ else if (is_drag && in_tab_line)
+ {
+ c1 = TabPageIdxs[mouse_col];
+ tabpage_move(c1 <= 0 ? 9999 : c1 - 1);
+ return FALSE;
+ }
+ }
+
+ // When 'mousemodel' is "popup" or "popup_setpos", translate mouse events:
+ // right button up -> pop-up menu
+ // shift-left button -> right button
+ // alt-left button -> alt-right button
+ if (mouse_model_popup())
+ {
+ if (which_button == MOUSE_RIGHT
+ && !(mod_mask & (MOD_MASK_SHIFT | MOD_MASK_CTRL)))
+ {
+#ifdef USE_POPUP_SETPOS
+# ifdef FEAT_GUI
+ if (gui.in_use)
+ {
+# if defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_GTK) \
+ || defined(FEAT_GUI_PHOTON)
+ if (!is_click)
+ // Ignore right button release events, only shows the popup
+ // menu on the button down event.
+ return FALSE;
+# endif
+# if defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_HAIKU)
+ if (is_click || is_drag)
+ // Ignore right button down and drag mouse events. Windows
+ // only shows the popup menu on the button up event.
+ return FALSE;
+# endif
+ }
+# endif
+# if defined(FEAT_GUI) && defined(FEAT_TERM_POPUP_MENU)
+ else
+# endif
+# if defined(FEAT_TERM_POPUP_MENU)
+ if (!is_click)
+ // Ignore right button release events, only shows the popup
+ // menu on the button down event.
+ return FALSE;
+# endif
+
+ jump_flags = 0;
+ if (STRCMP(p_mousem, "popup_setpos") == 0)
+ {
+ // First set the cursor position before showing the popup
+ // menu.
+ if (VIsual_active)
+ {
+ pos_T m_pos;
+
+ // set MOUSE_MAY_STOP_VIS if we are outside the
+ // selection or the current window (might have false
+ // negative here)
+ if (mouse_row < curwin->w_winrow
+ || mouse_row
+ > (curwin->w_winrow + curwin->w_height))
+ jump_flags = MOUSE_MAY_STOP_VIS;
+ else if (get_fpos_of_mouse(&m_pos) != IN_BUFFER)
+ jump_flags = MOUSE_MAY_STOP_VIS;
+ else
+ {
+ if (VIsual_mode == 'V')
+ {
+ if ((curwin->w_cursor.lnum <= VIsual.lnum
+ && (m_pos.lnum < curwin->w_cursor.lnum
+ || VIsual.lnum < m_pos.lnum))
+ || (VIsual.lnum < curwin->w_cursor.lnum
+ && (m_pos.lnum < VIsual.lnum
+ || curwin->w_cursor.lnum < m_pos.lnum)))
+ {
+ jump_flags = MOUSE_MAY_STOP_VIS;
+ }
+ }
+ else if ((LTOREQ_POS(curwin->w_cursor, VIsual)
+ && (LT_POS(m_pos, curwin->w_cursor)
+ || LT_POS(VIsual, m_pos)))
+ || (LT_POS(VIsual, curwin->w_cursor)
+ && (LT_POS(m_pos, VIsual)
+ || LT_POS(curwin->w_cursor, m_pos))))
+ {
+ jump_flags = MOUSE_MAY_STOP_VIS;
+ }
+ else if (VIsual_mode == Ctrl_V)
+ {
+ getvcols(curwin, &curwin->w_cursor, &VIsual,
+ &leftcol, &rightcol);
+ getvcol(curwin, &m_pos, NULL, &m_pos.col, NULL);
+ if (m_pos.col < leftcol || m_pos.col > rightcol)
+ jump_flags = MOUSE_MAY_STOP_VIS;
+ }
+ }
+ }
+ else
+ jump_flags = MOUSE_MAY_STOP_VIS;
+ }
+ if (jump_flags)
+ {
+ jump_flags = jump_to_mouse(jump_flags, NULL, which_button);
+ update_curbuf(VIsual_active ? UPD_INVERTED : UPD_VALID);
+ setcursor();
+ out_flush(); // Update before showing popup menu
+ }
+# ifdef FEAT_MENU
+ show_popupmenu();
+ got_click = FALSE; // ignore release events
+# endif
+ return (jump_flags & CURSOR_MOVED) != 0;
+#else
+ return FALSE;
+#endif
+ }
+ if (which_button == MOUSE_LEFT
+ && (mod_mask & (MOD_MASK_SHIFT|MOD_MASK_ALT)))
+ {
+ which_button = MOUSE_RIGHT;
+ mod_mask &= ~MOD_MASK_SHIFT;
+ }
+ }
+
+ if ((State & (MODE_NORMAL | MODE_INSERT))
+ && !(mod_mask & (MOD_MASK_SHIFT | MOD_MASK_CTRL)))
+ {
+ if (which_button == MOUSE_LEFT)
+ {
+ if (is_click)
+ {
+ // stop Visual mode for a left click in a window, but not when
+ // on a status line
+ if (VIsual_active)
+ jump_flags |= MOUSE_MAY_STOP_VIS;
+ }
+ else if (mouse_has(MOUSE_VISUAL))
+ jump_flags |= MOUSE_MAY_VIS;
+ }
+ else if (which_button == MOUSE_RIGHT)
+ {
+ if (is_click && VIsual_active)
+ {
+ // Remember the start and end of visual before moving the
+ // cursor.
+ if (LT_POS(curwin->w_cursor, VIsual))
+ {
+ start_visual = curwin->w_cursor;
+ end_visual = VIsual;
+ }
+ else
+ {
+ start_visual = VIsual;
+ end_visual = curwin->w_cursor;
+ }
+ }
+ jump_flags |= MOUSE_FOCUS;
+ if (mouse_has(MOUSE_VISUAL))
+ jump_flags |= MOUSE_MAY_VIS;
+ }
+ }
+
+ // If an operator is pending, ignore all drags and releases until the
+ // next mouse click.
+ if (!is_drag && oap != NULL && oap->op_type != OP_NOP)
+ {
+ got_click = FALSE;
+ oap->motion_type = MCHAR;
+ }
+
+ // When releasing the button let jump_to_mouse() know.
+ if (!is_click && !is_drag)
+ jump_flags |= MOUSE_RELEASED;
+
+ // JUMP!
+ jump_flags = jump_to_mouse(jump_flags,
+ oap == NULL ? NULL : &(oap->inclusive), which_button);
+
+#ifdef FEAT_MENU
+ // A click in the window toolbar has no side effects.
+ if (jump_flags & MOUSE_WINBAR)
+ return FALSE;
+#endif
+ moved = (jump_flags & CURSOR_MOVED);
+ in_status_line = (jump_flags & IN_STATUS_LINE);
+ in_sep_line = (jump_flags & IN_SEP_LINE);
+
+#ifdef FEAT_NETBEANS_INTG
+ if (isNetbeansBuffer(curbuf)
+ && !(jump_flags & (IN_STATUS_LINE | IN_SEP_LINE)))
+ {
+ int key = KEY2TERMCAP1(c);
+
+ if (key == (int)KE_LEFTRELEASE || key == (int)KE_MIDDLERELEASE
+ || key == (int)KE_RIGHTRELEASE)
+ netbeans_button_release(which_button);
+ }
+#endif
+
+ // When jumping to another window, clear a pending operator. That's a bit
+ // friendlier than beeping and not jumping to that window.
+ if (curwin != old_curwin && oap != NULL && oap->op_type != OP_NOP)
+ clearop(oap);
+
+#ifdef FEAT_FOLDING
+ if (mod_mask == 0
+ && !is_drag
+ && (jump_flags & (MOUSE_FOLD_CLOSE | MOUSE_FOLD_OPEN))
+ && which_button == MOUSE_LEFT)
+ {
+ // open or close a fold at this line
+ if (jump_flags & MOUSE_FOLD_OPEN)
+ openFold(curwin->w_cursor.lnum, 1L);
+ else
+ closeFold(curwin->w_cursor.lnum, 1L);
+ // don't move the cursor if still in the same window
+ if (curwin == old_curwin)
+ curwin->w_cursor = save_cursor;
+ }
+#endif
+
+#if defined(FEAT_CLIPBOARD)
+ if ((jump_flags & IN_OTHER_WIN) && !VIsual_active && clip_star.available)
+ {
+ clip_modeless(which_button, is_click, is_drag);
+ return FALSE;
+ }
+#endif
+
+ // Set global flag that we are extending the Visual area with mouse
+ // dragging; temporarily minimize 'scrolloff'.
+ if (VIsual_active && is_drag && get_scrolloff_value())
+ {
+ // In the very first line, allow scrolling one line
+ if (mouse_row == 0)
+ mouse_dragging = 2;
+ else
+ mouse_dragging = 1;
+ }
+
+ // When dragging the mouse above the window, scroll down.
+ if (is_drag && mouse_row < 0 && !in_status_line)
+ {
+ scroll_redraw(FALSE, 1L);
+ mouse_row = 0;
+ }
+
+ if (start_visual.lnum) // right click in visual mode
+ {
+ // When ALT is pressed make Visual mode blockwise.
+ if (mod_mask & MOD_MASK_ALT)
+ VIsual_mode = Ctrl_V;
+
+ // In Visual-block mode, divide the area in four, pick up the corner
+ // that is in the quarter that the cursor is in.
+ if (VIsual_mode == Ctrl_V)
+ {
+ getvcols(curwin, &start_visual, &end_visual, &leftcol, &rightcol);
+ if (curwin->w_curswant > (leftcol + rightcol) / 2)
+ end_visual.col = leftcol;
+ else
+ end_visual.col = rightcol;
+ if (curwin->w_cursor.lnum >=
+ (start_visual.lnum + end_visual.lnum) / 2)
+ end_visual.lnum = start_visual.lnum;
+
+ // move VIsual to the right column
+ start_visual = curwin->w_cursor; // save the cursor pos
+ curwin->w_cursor = end_visual;
+ coladvance(end_visual.col);
+ VIsual = curwin->w_cursor;
+ curwin->w_cursor = start_visual; // restore the cursor
+ }
+ else
+ {
+ // If the click is before the start of visual, change the start.
+ // If the click is after the end of visual, change the end. If
+ // the click is inside the visual, change the closest side.
+ if (LT_POS(curwin->w_cursor, start_visual))
+ VIsual = end_visual;
+ else if (LT_POS(end_visual, curwin->w_cursor))
+ VIsual = start_visual;
+ else
+ {
+ // In the same line, compare column number
+ if (end_visual.lnum == start_visual.lnum)
+ {
+ if (curwin->w_cursor.col - start_visual.col >
+ end_visual.col - curwin->w_cursor.col)
+ VIsual = start_visual;
+ else
+ VIsual = end_visual;
+ }
+
+ // In different lines, compare line number
+ else
+ {
+ diff = (curwin->w_cursor.lnum - start_visual.lnum) -
+ (end_visual.lnum - curwin->w_cursor.lnum);
+
+ if (diff > 0) // closest to end
+ VIsual = start_visual;
+ else if (diff < 0) // closest to start
+ VIsual = end_visual;
+ else // in the middle line
+ {
+ if (curwin->w_cursor.col <
+ (start_visual.col + end_visual.col) / 2)
+ VIsual = end_visual;
+ else
+ VIsual = start_visual;
+ }
+ }
+ }
+ }
+ }
+ // If Visual mode started in insert mode, execute "CTRL-O"
+ else if ((State & MODE_INSERT) && VIsual_active)
+ stuffcharReadbuff(Ctrl_O);
+
+ // Middle mouse click: Put text before cursor.
+ if (which_button == MOUSE_MIDDLE)
+ {
+#ifdef FEAT_CLIPBOARD
+ if (clip_star.available && regname == 0)
+ regname = '*';
+#endif
+ if (yank_register_mline(regname))
+ {
+ if (mouse_past_bottom)
+ dir = FORWARD;
+ }
+ else if (mouse_past_eol)
+ dir = FORWARD;
+
+ if (fixindent)
+ {
+ c1 = (dir == BACKWARD) ? '[' : ']';
+ c2 = 'p';
+ }
+ else
+ {
+ c1 = (dir == FORWARD) ? 'p' : 'P';
+ c2 = NUL;
+ }
+ prep_redo(regname, count, NUL, c1, NUL, c2, NUL);
+
+ // Remember where the paste started, so in edit() Insstart can be set
+ // to this position
+ if (restart_edit != 0)
+ where_paste_started = curwin->w_cursor;
+ do_put(regname, NULL, dir, count, fixindent | PUT_CURSEND);
+ }
+
+#if defined(FEAT_QUICKFIX)
+ // Ctrl-Mouse click or double click in a quickfix window jumps to the
+ // error under the mouse pointer.
+ else if (((mod_mask & MOD_MASK_CTRL)
+ || (mod_mask & MOD_MASK_MULTI_CLICK) == MOD_MASK_2CLICK)
+ && bt_quickfix(curbuf))
+ {
+ if (curwin->w_llist_ref == NULL) // quickfix window
+ do_cmdline_cmd((char_u *)".cc");
+ else // location list window
+ do_cmdline_cmd((char_u *)".ll");
+ got_click = FALSE; // ignore drag&release now
+ }
+#endif
+
+ // Ctrl-Mouse click (or double click in a help window) jumps to the tag
+ // under the mouse pointer.
+ else if ((mod_mask & MOD_MASK_CTRL) || (curbuf->b_help
+ && (mod_mask & MOD_MASK_MULTI_CLICK) == MOD_MASK_2CLICK))
+ {
+ if (State & MODE_INSERT)
+ stuffcharReadbuff(Ctrl_O);
+ stuffcharReadbuff(Ctrl_RSB);
+ got_click = FALSE; // ignore drag&release now
+ }
+
+ // Shift-Mouse click searches for the next occurrence of the word under
+ // the mouse pointer
+ else if ((mod_mask & MOD_MASK_SHIFT))
+ {
+ if ((State & MODE_INSERT) || (VIsual_active && VIsual_select))
+ stuffcharReadbuff(Ctrl_O);
+ if (which_button == MOUSE_LEFT)
+ stuffcharReadbuff('*');
+ else // MOUSE_RIGHT
+ stuffcharReadbuff('#');
+ }
+
+ // Handle double clicks, unless on status line
+ else if (in_status_line)
+ {
+#ifdef FEAT_MOUSESHAPE
+ if ((is_drag || is_click) && !drag_status_line)
+ {
+ drag_status_line = TRUE;
+ update_mouseshape(-1);
+ }
+#endif
+ }
+ else if (in_sep_line)
+ {
+#ifdef FEAT_MOUSESHAPE
+ if ((is_drag || is_click) && !drag_sep_line)
+ {
+ drag_sep_line = TRUE;
+ update_mouseshape(-1);
+ }
+#endif
+ }
+ else if ((mod_mask & MOD_MASK_MULTI_CLICK)
+ && (State & (MODE_NORMAL | MODE_INSERT))
+ && mouse_has(MOUSE_VISUAL))
+ {
+ if (is_click || !VIsual_active)
+ {
+ if (VIsual_active)
+ orig_cursor = VIsual;
+ else
+ {
+ check_visual_highlight();
+ VIsual = curwin->w_cursor;
+ orig_cursor = VIsual;
+ VIsual_active = TRUE;
+ VIsual_reselect = TRUE;
+ // start Select mode if 'selectmode' contains "mouse"
+ may_start_select('o');
+ setmouse();
+ }
+ if ((mod_mask & MOD_MASK_MULTI_CLICK) == MOD_MASK_2CLICK)
+ {
+ // Double click with ALT pressed makes it blockwise.
+ if (mod_mask & MOD_MASK_ALT)
+ VIsual_mode = Ctrl_V;
+ else
+ VIsual_mode = 'v';
+ }
+ else if ((mod_mask & MOD_MASK_MULTI_CLICK) == MOD_MASK_3CLICK)
+ VIsual_mode = 'V';
+ else if ((mod_mask & MOD_MASK_MULTI_CLICK) == MOD_MASK_4CLICK)
+ VIsual_mode = Ctrl_V;
+#ifdef FEAT_CLIPBOARD
+ // Make sure the clipboard gets updated. Needed because start and
+ // end may still be the same, and the selection needs to be owned
+ clip_star.vmode = NUL;
+#endif
+ }
+ // A double click selects a word or a block.
+ if ((mod_mask & MOD_MASK_MULTI_CLICK) == MOD_MASK_2CLICK)
+ {
+ pos_T *pos = NULL;
+ int gc;
+
+ if (is_click)
+ {
+ // If the character under the cursor (skipping white space) is
+ // not a word character, try finding a match and select a (),
+ // {}, [], #if/#endif, etc. block.
+ end_visual = curwin->w_cursor;
+ while (gc = gchar_pos(&end_visual), VIM_ISWHITE(gc))
+ inc(&end_visual);
+ if (oap != NULL)
+ oap->motion_type = MCHAR;
+ if (oap != NULL
+ && VIsual_mode == 'v'
+ && !vim_iswordc(gchar_pos(&end_visual))
+ && EQUAL_POS(curwin->w_cursor, VIsual)
+ && (pos = findmatch(oap, NUL)) != NULL)
+ {
+ curwin->w_cursor = *pos;
+ if (oap->motion_type == MLINE)
+ VIsual_mode = 'V';
+ else if (*p_sel == 'e')
+ {
+ if (LT_POS(curwin->w_cursor, VIsual))
+ ++VIsual.col;
+ else
+ ++curwin->w_cursor.col;
+ }
+ }
+ }
+
+ if (pos == NULL && (is_click || is_drag))
+ {
+ // When not found a match or when dragging: extend to include
+ // a word.
+ if (LT_POS(curwin->w_cursor, orig_cursor))
+ {
+ find_start_of_word(&curwin->w_cursor);
+ find_end_of_word(&VIsual);
+ }
+ else
+ {
+ find_start_of_word(&VIsual);
+ if (*p_sel == 'e' && *ml_get_cursor() != NUL)
+ curwin->w_cursor.col +=
+ (*mb_ptr2len)(ml_get_cursor());
+ find_end_of_word(&curwin->w_cursor);
+ }
+ }
+ curwin->w_set_curswant = TRUE;
+ }
+ if (is_click)
+ redraw_curbuf_later(UPD_INVERTED); // update the inversion
+ }
+ else if (VIsual_active && !old_active)
+ {
+ if (mod_mask & MOD_MASK_ALT)
+ VIsual_mode = Ctrl_V;
+ else
+ VIsual_mode = 'v';
+ }
+
+ // If Visual mode changed show it later.
+ if ((!VIsual_active && old_active && mode_displayed)
+ || (VIsual_active && p_smd && msg_silent == 0
+ && (!old_active || VIsual_mode != old_mode)))
+ redraw_cmdline = TRUE;
+
+ return moved;
+}
+
+ void
+ins_mouse(int c)
+{
+ pos_T tpos;
+ win_T *old_curwin = curwin;
+
+#ifdef FEAT_GUI
+ // When GUI is active, also move/paste when 'mouse' is empty
+ if (!gui.in_use)
+#endif
+ if (!mouse_has(MOUSE_INSERT))
+ return;
+
+ undisplay_dollar();
+ tpos = curwin->w_cursor;
+ if (do_mouse(NULL, c, BACKWARD, 1L, 0))
+ {
+ win_T *new_curwin = curwin;
+
+ if (curwin != old_curwin && win_valid(old_curwin))
+ {
+ // Mouse took us to another window. We need to go back to the
+ // previous one to stop insert there properly.
+ curwin = old_curwin;
+ curbuf = curwin->w_buffer;
+#ifdef FEAT_JOB_CHANNEL
+ if (bt_prompt(curbuf))
+ // Restart Insert mode when re-entering the prompt buffer.
+ curbuf->b_prompt_insert = 'A';
+#endif
+ }
+ start_arrow(curwin == old_curwin ? &tpos : NULL);
+ if (curwin != new_curwin && win_valid(new_curwin))
+ {
+ curwin = new_curwin;
+ curbuf = curwin->w_buffer;
+ }
+ set_can_cindent(TRUE);
+ }
+
+ // redraw status lines (in case another window became active)
+ redraw_statuslines();
+}
+
+/*
+ * Common mouse wheel scrolling, shared between Insert mode and NV modes.
+ * Default action is to scroll mouse_vert_step lines (or mouse_hor_step columns
+ * depending on the scroll direction) or one page when Shift or Ctrl is used.
+ * Direction is indicated by "cap->arg":
+ * K_MOUSEUP - MSCR_UP
+ * K_MOUSEDOWN - MSCR_DOWN
+ * K_MOUSELEFT - MSCR_LEFT
+ * K_MOUSERIGHT - MSCR_RIGHT
+ * "curwin" may have been changed to the window that should be scrolled and
+ * differ from the window that actually has focus.
+ */
+ static void
+do_mousescroll(cmdarg_T *cap)
+{
+ int shift_or_ctrl = mod_mask & (MOD_MASK_SHIFT | MOD_MASK_CTRL);
+
+#ifdef FEAT_TERMINAL
+ if (term_use_loop())
+ // This window is a terminal window, send the mouse event there.
+ // Set "typed" to FALSE to avoid an endless loop.
+ send_keys_to_term(curbuf->b_term, cap->cmdchar, mod_mask, FALSE);
+ else
+#endif
+ if (cap->arg == MSCR_UP || cap->arg == MSCR_DOWN)
+ {
+ // Vertical scrolling
+ if (!(State & MODE_INSERT) && (mouse_vert_step < 0 || shift_or_ctrl))
+ {
+ // whole page up or down
+ onepage(cap->arg == MSCR_UP ? FORWARD : BACKWARD, 1L);
+ }
+ else
+ {
+ if (mouse_vert_step < 0 || shift_or_ctrl)
+ {
+ // whole page up or down
+ cap->count1 = (long)(curwin->w_botline - curwin->w_topline);
+ }
+ // Don't scroll more than half the window height.
+ else if (curwin->w_height < mouse_vert_step * 2)
+ {
+ cap->count1 = curwin->w_height / 2;
+ if (cap->count1 == 0)
+ cap->count1 = 1;
+ }
+ else
+ {
+ cap->count1 = mouse_vert_step;
+ }
+ cap->count0 = cap->count1;
+ nv_scroll_line(cap);
+ }
+
+#ifdef FEAT_PROP_POPUP
+ if (WIN_IS_POPUP(curwin))
+ popup_set_firstline(curwin);
+#endif
+ }
+ else
+ {
+ // Horizontal scrolling
+ long step = (mouse_hor_step < 0 || shift_or_ctrl)
+ ? curwin->w_width : mouse_hor_step;
+ long leftcol = curwin->w_leftcol
+ + (cap->arg == MSCR_RIGHT ? -step : step);
+ if (leftcol < 0)
+ leftcol = 0;
+ do_mousescroll_horiz((long_u)leftcol);
+ }
+ may_trigger_win_scrolled_resized();
+}
+
+/*
+ * Insert mode implementation for scrolling in direction "dir", which is
+ * one of the MSCR_ values.
+ */
+ void
+ins_mousescroll(int dir)
+{
+ cmdarg_T cap;
+ oparg_T oa;
+ CLEAR_FIELD(cap);
+ clear_oparg(&oa);
+ cap.oap = &oa;
+ cap.arg = dir;
+
+ switch (dir)
+ {
+ case MSCR_UP:
+ cap.cmdchar = K_MOUSEUP;
+ break;
+ case MSCR_DOWN:
+ cap.cmdchar = K_MOUSEDOWN;
+ break;
+ case MSCR_LEFT:
+ cap.cmdchar = K_MOUSELEFT;
+ break;
+ case MSCR_RIGHT:
+ cap.cmdchar = K_MOUSERIGHT;
+ break;
+ default:
+ siemsg("Invalid ins_mousescroll() argument: %d", dir);
+ }
+
+ win_T *old_curwin = curwin;
+ if (mouse_row >= 0 && mouse_col >= 0)
+ {
+ // Find the window at the mouse pointer coordinates.
+ // NOTE: Must restore "curwin" to "old_curwin" before returning!
+ int row = mouse_row;
+ int col = mouse_col;
+ curwin = mouse_find_win(&row, &col, FIND_POPUP);
+ if (curwin == NULL)
+ {
+ curwin = old_curwin;
+ return;
+ }
+ curbuf = curwin->w_buffer;
+ }
+
+ if (curwin == old_curwin)
+ {
+ // Don't scroll the current window if the popup menu is visible.
+ if (pum_visible())
+ return;
+
+ undisplay_dollar();
+ }
+
+ linenr_T orig_topline = curwin->w_topline;
+ colnr_T orig_leftcol = curwin->w_leftcol;
+ pos_T orig_cursor = curwin->w_cursor;
+
+ // Call the common mouse scroll function shared with other modes.
+ do_mousescroll(&cap);
+
+ int did_scroll = (orig_topline != curwin->w_topline
+ || orig_leftcol != curwin->w_leftcol);
+
+ curwin->w_redr_status = TRUE;
+ curwin = old_curwin;
+ curbuf = curwin->w_buffer;
+
+ // If the window actually scrolled and the popup menu may overlay the
+ // window, need to redraw it.
+ if (did_scroll && pum_visible())
+ {
+ // TODO: Would be more efficient to only redraw the windows that are
+ // overlapped by the popup menu.
+ redraw_all_later(UPD_NOT_VALID);
+ ins_compl_show_pum();
+ }
+
+ if (!EQUAL_POS(curwin->w_cursor, orig_cursor))
+ {
+ start_arrow(&orig_cursor);
+ set_can_cindent(TRUE);
+ }
+}
+
+/*
+ * Return TRUE if "c" is a mouse key.
+ */
+ int
+is_mouse_key(int c)
+{
+ return c == K_LEFTMOUSE
+ || c == K_LEFTMOUSE_NM
+ || c == K_LEFTDRAG
+ || c == K_LEFTRELEASE
+ || c == K_LEFTRELEASE_NM
+ || c == K_MOUSEMOVE
+ || c == K_MIDDLEMOUSE
+ || c == K_MIDDLEDRAG
+ || c == K_MIDDLERELEASE
+ || c == K_RIGHTMOUSE
+ || c == K_RIGHTDRAG
+ || c == K_RIGHTRELEASE
+ || c == K_MOUSEDOWN
+ || c == K_MOUSEUP
+ || c == K_MOUSELEFT
+ || c == K_MOUSERIGHT
+ || c == K_X1MOUSE
+ || c == K_X1DRAG
+ || c == K_X1RELEASE
+ || c == K_X2MOUSE
+ || c == K_X2DRAG
+ || c == K_X2RELEASE;
+}
+
+static struct mousetable
+{
+ int pseudo_code; // Code for pseudo mouse event
+ int button; // Which mouse button is it?
+ int is_click; // Is it a mouse button click event?
+ int is_drag; // Is it a mouse drag event?
+} mouse_table[] =
+{
+ {(int)KE_LEFTMOUSE, MOUSE_LEFT, TRUE, FALSE},
+#ifdef FEAT_GUI
+ {(int)KE_LEFTMOUSE_NM, MOUSE_LEFT, TRUE, FALSE},
+#endif
+ {(int)KE_LEFTDRAG, MOUSE_LEFT, FALSE, TRUE},
+ {(int)KE_LEFTRELEASE, MOUSE_LEFT, FALSE, FALSE},
+#ifdef FEAT_GUI
+ {(int)KE_LEFTRELEASE_NM, MOUSE_LEFT, FALSE, FALSE},
+#endif
+ {(int)KE_MIDDLEMOUSE, MOUSE_MIDDLE, TRUE, FALSE},
+ {(int)KE_MIDDLEDRAG, MOUSE_MIDDLE, FALSE, TRUE},
+ {(int)KE_MIDDLERELEASE, MOUSE_MIDDLE, FALSE, FALSE},
+ {(int)KE_RIGHTMOUSE, MOUSE_RIGHT, TRUE, FALSE},
+ {(int)KE_RIGHTDRAG, MOUSE_RIGHT, FALSE, TRUE},
+ {(int)KE_RIGHTRELEASE, MOUSE_RIGHT, FALSE, FALSE},
+ {(int)KE_X1MOUSE, MOUSE_X1, TRUE, FALSE},
+ {(int)KE_X1DRAG, MOUSE_X1, FALSE, TRUE},
+ {(int)KE_X1RELEASE, MOUSE_X1, FALSE, FALSE},
+ {(int)KE_X2MOUSE, MOUSE_X2, TRUE, FALSE},
+ {(int)KE_X2DRAG, MOUSE_X2, FALSE, TRUE},
+ {(int)KE_X2RELEASE, MOUSE_X2, FALSE, FALSE},
+ // DRAG without CLICK
+ {(int)KE_MOUSEMOVE, MOUSE_RELEASE, FALSE, TRUE},
+ // RELEASE without CLICK
+ {(int)KE_IGNORE, MOUSE_RELEASE, FALSE, FALSE},
+ {0, 0, 0, 0},
+};
+
+/*
+ * Look up the given mouse code to return the relevant information in the other
+ * arguments. Return which button is down or was released.
+ */
+ int
+get_mouse_button(int code, int *is_click, int *is_drag)
+{
+ int i;
+
+ for (i = 0; mouse_table[i].pseudo_code; i++)
+ if (code == mouse_table[i].pseudo_code)
+ {
+ *is_click = mouse_table[i].is_click;
+ *is_drag = mouse_table[i].is_drag;
+ return mouse_table[i].button;
+ }
+ return 0; // Shouldn't get here
+}
+
+/*
+ * Return the appropriate pseudo mouse event token (KE_LEFTMOUSE etc) based on
+ * the given information about which mouse button is down, and whether the
+ * mouse was clicked, dragged or released.
+ */
+ int
+get_pseudo_mouse_code(
+ int button, // eg MOUSE_LEFT
+ int is_click,
+ int is_drag)
+{
+ int i;
+
+ for (i = 0; mouse_table[i].pseudo_code; i++)
+ if (button == mouse_table[i].button
+ && is_click == mouse_table[i].is_click
+ && is_drag == mouse_table[i].is_drag)
+ {
+#ifdef FEAT_GUI
+ // Trick: a non mappable left click and release has mouse_col -1
+ // or added MOUSE_COLOFF. Used for 'mousefocus' in
+ // gui_mouse_moved()
+ if (mouse_col < 0 || mouse_col > MOUSE_COLOFF)
+ {
+ if (mouse_col < 0)
+ mouse_col = 0;
+ else
+ mouse_col -= MOUSE_COLOFF;
+ if (mouse_table[i].pseudo_code == (int)KE_LEFTMOUSE)
+ return (int)KE_LEFTMOUSE_NM;
+ if (mouse_table[i].pseudo_code == (int)KE_LEFTRELEASE)
+ return (int)KE_LEFTRELEASE_NM;
+ }
+#endif
+ return mouse_table[i].pseudo_code;
+ }
+ return (int)KE_IGNORE; // not recognized, ignore it
+}
+
+# define HMT_NORMAL 1
+# define HMT_NETTERM 2
+# define HMT_DEC 4
+# define HMT_JSBTERM 8
+# define HMT_PTERM 16
+# define HMT_URXVT 32
+# define HMT_GPM 64
+# define HMT_SGR 128
+# define HMT_SGR_REL 256
+static int has_mouse_termcode = 0;
+
+ void
+set_mouse_termcode(
+ int n, // KS_MOUSE, KS_NETTERM_MOUSE or KS_DEC_MOUSE
+ char_u *s)
+{
+ char_u name[2];
+
+ name[0] = n;
+ name[1] = KE_FILLER;
+ add_termcode(name, s, FALSE);
+#ifdef FEAT_MOUSE_JSB
+ if (n == KS_JSBTERM_MOUSE)
+ has_mouse_termcode |= HMT_JSBTERM;
+ else
+#endif
+#ifdef FEAT_MOUSE_NET
+ if (n == KS_NETTERM_MOUSE)
+ has_mouse_termcode |= HMT_NETTERM;
+ else
+#endif
+#ifdef FEAT_MOUSE_DEC
+ if (n == KS_DEC_MOUSE)
+ has_mouse_termcode |= HMT_DEC;
+ else
+#endif
+#ifdef FEAT_MOUSE_PTERM
+ if (n == KS_PTERM_MOUSE)
+ has_mouse_termcode |= HMT_PTERM;
+ else
+#endif
+#ifdef FEAT_MOUSE_URXVT
+ if (n == KS_URXVT_MOUSE)
+ has_mouse_termcode |= HMT_URXVT;
+ else
+#endif
+#ifdef FEAT_MOUSE_GPM
+ if (n == KS_GPM_MOUSE)
+ has_mouse_termcode |= HMT_GPM;
+ else
+#endif
+ if (n == KS_SGR_MOUSE)
+ has_mouse_termcode |= HMT_SGR;
+ else if (n == KS_SGR_MOUSE_RELEASE)
+ has_mouse_termcode |= HMT_SGR_REL;
+ else
+ has_mouse_termcode |= HMT_NORMAL;
+}
+
+#if defined(UNIX) || defined(VMS) || defined(PROTO)
+ void
+del_mouse_termcode(
+ int n) // KS_MOUSE, KS_NETTERM_MOUSE or KS_DEC_MOUSE
+{
+ char_u name[2];
+
+ name[0] = n;
+ name[1] = KE_FILLER;
+ del_termcode(name);
+# ifdef FEAT_MOUSE_JSB
+ if (n == KS_JSBTERM_MOUSE)
+ has_mouse_termcode &= ~HMT_JSBTERM;
+ else
+# endif
+# ifdef FEAT_MOUSE_NET
+ if (n == KS_NETTERM_MOUSE)
+ has_mouse_termcode &= ~HMT_NETTERM;
+ else
+# endif
+# ifdef FEAT_MOUSE_DEC
+ if (n == KS_DEC_MOUSE)
+ has_mouse_termcode &= ~HMT_DEC;
+ else
+# endif
+# ifdef FEAT_MOUSE_PTERM
+ if (n == KS_PTERM_MOUSE)
+ has_mouse_termcode &= ~HMT_PTERM;
+ else
+# endif
+# ifdef FEAT_MOUSE_URXVT
+ if (n == KS_URXVT_MOUSE)
+ has_mouse_termcode &= ~HMT_URXVT;
+ else
+# endif
+# ifdef FEAT_MOUSE_GPM
+ if (n == KS_GPM_MOUSE)
+ has_mouse_termcode &= ~HMT_GPM;
+ else
+# endif
+ if (n == KS_SGR_MOUSE)
+ has_mouse_termcode &= ~HMT_SGR;
+ else if (n == KS_SGR_MOUSE_RELEASE)
+ has_mouse_termcode &= ~HMT_SGR_REL;
+ else
+ has_mouse_termcode &= ~HMT_NORMAL;
+}
+#endif
+
+/*
+ * setmouse() - switch mouse on/off depending on current mode and 'mouse'
+ */
+ void
+setmouse(void)
+{
+ int checkfor;
+
+#ifdef FEAT_MOUSESHAPE
+ update_mouseshape(-1);
+#endif
+
+ // Should be outside proc, but may break MOUSESHAPE
+#ifdef FEAT_GUI
+ // In the GUI the mouse is always enabled.
+ if (gui.in_use)
+ return;
+#endif
+ // be quick when mouse is off
+ if (*p_mouse == NUL || has_mouse_termcode == 0)
+ return;
+
+ // don't switch mouse on when not in raw mode (Ex mode)
+ if (cur_tmode != TMODE_RAW)
+ {
+ mch_setmouse(FALSE);
+ return;
+ }
+
+ if (VIsual_active)
+ checkfor = MOUSE_VISUAL;
+ else if (State == MODE_HITRETURN || State == MODE_ASKMORE
+ || State == MODE_SETWSIZE)
+ checkfor = MOUSE_RETURN;
+ else if (State & MODE_INSERT)
+ checkfor = MOUSE_INSERT;
+ else if (State & MODE_CMDLINE)
+ checkfor = MOUSE_COMMAND;
+ else if (State == MODE_CONFIRM || State == MODE_EXTERNCMD)
+ checkfor = ' '; // don't use mouse for ":confirm" or ":!cmd"
+ else
+ checkfor = MOUSE_NORMAL; // assume normal mode
+
+ if (mouse_has(checkfor))
+ mch_setmouse(TRUE);
+ else
+ mch_setmouse(FALSE);
+}
+
+/*
+ * Return TRUE if
+ * - "c" is in 'mouse', or
+ * - 'a' is in 'mouse' and "c" is in MOUSE_A, or
+ * - the current buffer is a help file and 'h' is in 'mouse' and we are in a
+ * normal editing mode (not at hit-return message).
+ */
+ int
+mouse_has(int c)
+{
+ char_u *p;
+
+ for (p = p_mouse; *p; ++p)
+ switch (*p)
+ {
+ case 'a': if (vim_strchr((char_u *)MOUSE_A, c) != NULL)
+ return TRUE;
+ break;
+ case MOUSE_HELP: if (c != MOUSE_RETURN && curbuf->b_help)
+ return TRUE;
+ break;
+ default: if (c == *p) return TRUE; break;
+ }
+ return FALSE;
+}
+
+/*
+ * Return TRUE when 'mousemodel' is set to "popup" or "popup_setpos".
+ */
+ int
+mouse_model_popup(void)
+{
+ return (p_mousem[0] == 'p');
+}
+
+static win_T *dragwin = NULL; // window being dragged
+
+/*
+ * Reset the window being dragged. To be called when switching tab page.
+ */
+ void
+reset_dragwin(void)
+{
+ dragwin = NULL;
+}
+
+/*
+ * Move the cursor to the specified row and column on the screen.
+ * Change current window if necessary. Returns an integer with the
+ * CURSOR_MOVED bit set if the cursor has moved or unset otherwise.
+ *
+ * The MOUSE_FOLD_CLOSE bit is set when clicked on the '-' in a fold column.
+ * The MOUSE_FOLD_OPEN bit is set when clicked on the '+' in a fold column.
+ *
+ * If flags has MOUSE_FOCUS, then the current window will not be changed, and
+ * if the mouse is outside the window then the text will scroll, or if the
+ * mouse was previously on a status line, then the status line may be dragged.
+ *
+ * If flags has MOUSE_MAY_VIS, then VIsual mode will be started before the
+ * cursor is moved unless the cursor was on a status line.
+ * This function returns one of IN_UNKNOWN, IN_BUFFER, IN_STATUS_LINE or
+ * IN_SEP_LINE depending on where the cursor was clicked.
+ *
+ * If flags has MOUSE_MAY_STOP_VIS, then Visual mode will be stopped, unless
+ * the mouse is on the status line of the same window.
+ *
+ * If flags has MOUSE_DID_MOVE, nothing is done if the mouse didn't move since
+ * the last call.
+ *
+ * If flags has MOUSE_SETPOS, nothing is done, only the current position is
+ * remembered.
+ */
+ int
+jump_to_mouse(
+ int flags,
+ int *inclusive, // used for inclusive operator, can be NULL
+ int which_button) // MOUSE_LEFT, MOUSE_RIGHT, MOUSE_MIDDLE
+{
+ static int on_status_line = 0; // #lines below bottom of window
+ static int on_sep_line = 0; // on separator right of window
+#ifdef FEAT_MENU
+ static int in_winbar = FALSE;
+#endif
+#ifdef FEAT_PROP_POPUP
+ static int in_popup_win = FALSE;
+ static win_T *click_in_popup_win = NULL;
+#endif
+ static int prev_row = -1;
+ static int prev_col = -1;
+ static int did_drag = FALSE; // drag was noticed
+
+ win_T *wp, *old_curwin;
+ pos_T old_cursor;
+ int count;
+ int first;
+ int row = mouse_row;
+ int col = mouse_col;
+ colnr_T col_from_screen = -1;
+#ifdef FEAT_FOLDING
+ int mouse_char = ' ';
+#endif
+
+ mouse_past_bottom = FALSE;
+ mouse_past_eol = FALSE;
+
+ if (flags & MOUSE_RELEASED)
+ {
+ // On button release we may change window focus if positioned on a
+ // status line and no dragging happened.
+ if (dragwin != NULL && !did_drag)
+ flags &= ~(MOUSE_FOCUS | MOUSE_DID_MOVE);
+ dragwin = NULL;
+ did_drag = FALSE;
+#ifdef FEAT_PROP_POPUP
+ if (click_in_popup_win != NULL && popup_dragwin == NULL)
+ popup_close_for_mouse_click(click_in_popup_win);
+
+ popup_dragwin = NULL;
+ click_in_popup_win = NULL;
+#endif
+ }
+
+ if ((flags & MOUSE_DID_MOVE)
+ && prev_row == mouse_row
+ && prev_col == mouse_col)
+ {
+retnomove:
+ // before moving the cursor for a left click which is NOT in a status
+ // line, stop Visual mode
+ if (on_status_line)
+ return IN_STATUS_LINE;
+ if (on_sep_line)
+ return IN_SEP_LINE;
+#ifdef FEAT_MENU
+ if (in_winbar)
+ {
+ // A quick second click may arrive as a double-click, but we use it
+ // as a second click in the WinBar.
+ if ((mod_mask & MOD_MASK_MULTI_CLICK) && !(flags & MOUSE_RELEASED))
+ {
+ wp = mouse_find_win(&row, &col, FAIL_POPUP);
+ if (wp == NULL)
+ return IN_UNKNOWN;
+ winbar_click(wp, col);
+ }
+ return IN_OTHER_WIN | MOUSE_WINBAR;
+ }
+#endif
+ if (flags & MOUSE_MAY_STOP_VIS)
+ {
+ end_visual_mode_keep_button();
+ redraw_curbuf_later(UPD_INVERTED); // delete the inversion
+ }
+#if defined(FEAT_CLIPBOARD)
+ // Continue a modeless selection in another window.
+ if (cmdwin_type != 0 && row < curwin->w_winrow)
+ return IN_OTHER_WIN;
+#endif
+#ifdef FEAT_PROP_POPUP
+ // Continue a modeless selection in a popup window or dragging it.
+ if (in_popup_win)
+ {
+ click_in_popup_win = NULL; // don't close it on release
+ if (popup_dragwin != NULL)
+ {
+ // dragging a popup window
+ popup_drag(popup_dragwin);
+ return IN_UNKNOWN;
+ }
+ return IN_OTHER_WIN;
+ }
+#endif
+ return IN_BUFFER;
+ }
+
+ prev_row = mouse_row;
+ prev_col = mouse_col;
+
+ if (flags & MOUSE_SETPOS)
+ goto retnomove; // ugly goto...
+
+ old_curwin = curwin;
+ old_cursor = curwin->w_cursor;
+
+ if (!(flags & MOUSE_FOCUS))
+ {
+ if (row < 0 || col < 0) // check if it makes sense
+ return IN_UNKNOWN;
+
+ // find the window where the row is in and adjust "row" and "col" to be
+ // relative to top-left of the window
+ wp = mouse_find_win(&row, &col, FIND_POPUP);
+ if (wp == NULL)
+ return IN_UNKNOWN;
+ dragwin = NULL;
+
+#ifdef FEAT_PROP_POPUP
+ // Click in a popup window may start dragging or modeless selection,
+ // but not much else.
+ if (WIN_IS_POPUP(wp))
+ {
+ on_sep_line = 0;
+ on_status_line = 0;
+ in_popup_win = TRUE;
+ if (which_button == MOUSE_LEFT && popup_close_if_on_X(wp, row, col))
+ {
+ return IN_UNKNOWN;
+ }
+ else if (((wp->w_popup_flags & (POPF_DRAG | POPF_RESIZE))
+ && popup_on_border(wp, row, col))
+ || (wp->w_popup_flags & POPF_DRAGALL))
+ {
+ popup_dragwin = wp;
+ popup_start_drag(wp, row, col);
+ return IN_UNKNOWN;
+ }
+ // Only close on release, otherwise it's not possible to drag or do
+ // modeless selection.
+ else if (wp->w_popup_close == POPCLOSE_CLICK
+ && which_button == MOUSE_LEFT)
+ {
+ click_in_popup_win = wp;
+ }
+ else if (which_button == MOUSE_LEFT)
+ // If the click is in the scrollbar, may scroll up/down.
+ popup_handle_scrollbar_click(wp, row, col);
+# ifdef FEAT_CLIPBOARD
+ return IN_OTHER_WIN;
+# else
+ return IN_UNKNOWN;
+# endif
+ }
+ in_popup_win = FALSE;
+ popup_dragwin = NULL;
+#endif
+#ifdef FEAT_MENU
+ if (row == -1)
+ {
+ // A click in the window toolbar does not enter another window or
+ // change Visual highlighting.
+ winbar_click(wp, col);
+ in_winbar = TRUE;
+ return IN_OTHER_WIN | MOUSE_WINBAR;
+ }
+ in_winbar = FALSE;
+#endif
+
+ // winpos and height may change in win_enter()!
+ if (row >= wp->w_height) // In (or below) status line
+ {
+ on_status_line = row - wp->w_height + 1;
+ dragwin = wp;
+ }
+ else
+ on_status_line = 0;
+ if (col >= wp->w_width) // In separator line
+ {
+ on_sep_line = col - wp->w_width + 1;
+ dragwin = wp;
+ }
+ else
+ on_sep_line = 0;
+
+ // The rightmost character of the status line might be a vertical
+ // separator character if there is no connecting window to the right.
+ if (on_status_line && on_sep_line)
+ {
+ if (stl_connected(wp))
+ on_sep_line = 0;
+ else
+ on_status_line = 0;
+ }
+
+ // Before jumping to another buffer, or moving the cursor for a left
+ // click, stop Visual mode.
+ if (VIsual_active
+ && (wp->w_buffer != curwin->w_buffer
+ || (!on_status_line && !on_sep_line
+#ifdef FEAT_FOLDING
+ && (
+# ifdef FEAT_RIGHTLEFT
+ wp->w_p_rl ? col < wp->w_width - wp->w_p_fdc :
+# endif
+ col >= wp->w_p_fdc + (cmdwin_type == 0 && wp == curwin ? 0 : 1)
+ )
+#endif
+ && (flags & MOUSE_MAY_STOP_VIS))))
+ {
+ end_visual_mode_keep_button();
+ redraw_curbuf_later(UPD_INVERTED); // delete the inversion
+ }
+ if (cmdwin_type != 0 && wp != curwin)
+ {
+ // A click outside the command-line window: Use modeless
+ // selection if possible. Allow dragging the status lines.
+ on_sep_line = 0;
+#ifdef FEAT_CLIPBOARD
+ if (on_status_line)
+ return IN_STATUS_LINE;
+ return IN_OTHER_WIN;
+#else
+ row = 0;
+ col += wp->w_wincol;
+ wp = curwin;
+#endif
+ }
+#if defined(FEAT_PROP_POPUP) && defined(FEAT_TERMINAL)
+ if (popup_is_popup(curwin) && curbuf->b_term != NULL)
+ // terminal in popup window: don't jump to another window
+ return IN_OTHER_WIN;
+#endif
+ // Only change window focus when not clicking on or dragging the
+ // status line. Do change focus when releasing the mouse button
+ // (MOUSE_FOCUS was set above if we dragged first).
+ if (dragwin == NULL || (flags & MOUSE_RELEASED))
+ win_enter(wp, TRUE); // can make wp invalid!
+
+ if (curwin != old_curwin)
+ {
+#ifdef CHECK_DOUBLE_CLICK
+ // set topline, to be able to check for double click ourselves
+ set_mouse_topline(curwin);
+#endif
+#ifdef FEAT_TERMINAL
+ // when entering a terminal window may change state
+ term_win_entered();
+#endif
+ }
+ if (on_status_line) // In (or below) status line
+ {
+ // Don't use start_arrow() if we're in the same window
+ if (curwin == old_curwin)
+ return IN_STATUS_LINE;
+ else
+ return IN_STATUS_LINE | CURSOR_MOVED;
+ }
+ if (on_sep_line) // In (or below) status line
+ {
+ // Don't use start_arrow() if we're in the same window
+ if (curwin == old_curwin)
+ return IN_SEP_LINE;
+ else
+ return IN_SEP_LINE | CURSOR_MOVED;
+ }
+
+ curwin->w_cursor.lnum = curwin->w_topline;
+#ifdef FEAT_GUI
+ // remember topline, needed for double click
+ gui_prev_topline = curwin->w_topline;
+# ifdef FEAT_DIFF
+ gui_prev_topfill = curwin->w_topfill;
+# endif
+#endif
+ }
+ else if (on_status_line && which_button == MOUSE_LEFT)
+ {
+ if (dragwin != NULL)
+ {
+ // Drag the status line
+ count = row - W_WINROW(dragwin) - dragwin->w_height + 1
+ - on_status_line;
+ win_drag_status_line(dragwin, count);
+ did_drag |= count;
+ }
+ return IN_STATUS_LINE; // Cursor didn't move
+ }
+ else if (on_sep_line && which_button == MOUSE_LEFT)
+ {
+ if (dragwin != NULL)
+ {
+ // Drag the separator column
+ count = col - dragwin->w_wincol - dragwin->w_width + 1
+ - on_sep_line;
+ win_drag_vsep_line(dragwin, count);
+ did_drag |= count;
+ }
+ return IN_SEP_LINE; // Cursor didn't move
+ }
+#ifdef FEAT_MENU
+ else if (in_winbar)
+ {
+ // After a click on the window toolbar don't start Visual mode.
+ return IN_OTHER_WIN | MOUSE_WINBAR;
+ }
+#endif
+ else // keep_window_focus must be TRUE
+ {
+ // before moving the cursor for a left click, stop Visual mode
+ if (flags & MOUSE_MAY_STOP_VIS)
+ {
+ end_visual_mode_keep_button();
+ redraw_curbuf_later(UPD_INVERTED); // delete the inversion
+ }
+
+#if defined(FEAT_CLIPBOARD)
+ // Continue a modeless selection in another window.
+ if (cmdwin_type != 0 && row < curwin->w_winrow)
+ return IN_OTHER_WIN;
+#endif
+#ifdef FEAT_PROP_POPUP
+ if (in_popup_win)
+ {
+ if (popup_dragwin != NULL)
+ {
+ // dragging a popup window
+ popup_drag(popup_dragwin);
+ return IN_UNKNOWN;
+ }
+ // continue a modeless selection in a popup window
+ click_in_popup_win = NULL;
+ return IN_OTHER_WIN;
+ }
+#endif
+
+ row -= W_WINROW(curwin);
+ col -= curwin->w_wincol;
+
+ // When clicking beyond the end of the window, scroll the screen.
+ // Scroll by however many rows outside the window we are.
+ if (row < 0)
+ {
+ count = 0;
+ for (first = TRUE; curwin->w_topline > 1; )
+ {
+#ifdef FEAT_DIFF
+ if (curwin->w_topfill < diff_check(curwin, curwin->w_topline))
+ ++count;
+ else
+#endif
+ count += plines(curwin->w_topline - 1);
+ if (!first && count > -row)
+ break;
+ first = FALSE;
+#ifdef FEAT_FOLDING
+ (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
+#endif
+#ifdef FEAT_DIFF
+ if (curwin->w_topfill < diff_check(curwin, curwin->w_topline))
+ ++curwin->w_topfill;
+ else
+#endif
+ {
+ --curwin->w_topline;
+#ifdef FEAT_DIFF
+ curwin->w_topfill = 0;
+#endif
+ }
+ }
+#ifdef FEAT_DIFF
+ check_topfill(curwin, FALSE);
+#endif
+ curwin->w_valid &=
+ ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
+ redraw_later(UPD_VALID);
+ row = 0;
+ }
+ else if (row >= curwin->w_height)
+ {
+ count = 0;
+ for (first = TRUE; curwin->w_topline < curbuf->b_ml.ml_line_count; )
+ {
+#ifdef FEAT_DIFF
+ if (curwin->w_topfill > 0)
+ ++count;
+ else
+#endif
+ count += plines(curwin->w_topline);
+ if (!first && count > row - curwin->w_height + 1)
+ break;
+ first = FALSE;
+#ifdef FEAT_FOLDING
+ if (hasFolding(curwin->w_topline, NULL, &curwin->w_topline)
+ && curwin->w_topline == curbuf->b_ml.ml_line_count)
+ break;
+#endif
+#ifdef FEAT_DIFF
+ if (curwin->w_topfill > 0)
+ --curwin->w_topfill;
+ else
+#endif
+ {
+ ++curwin->w_topline;
+#ifdef FEAT_DIFF
+ curwin->w_topfill =
+ diff_check_fill(curwin, curwin->w_topline);
+#endif
+ }
+ }
+#ifdef FEAT_DIFF
+ check_topfill(curwin, FALSE);
+#endif
+ redraw_later(UPD_VALID);
+ curwin->w_valid &=
+ ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
+ row = curwin->w_height - 1;
+ }
+ else if (row == 0)
+ {
+ // When dragging the mouse, while the text has been scrolled up as
+ // far as it goes, moving the mouse in the top line should scroll
+ // the text down (done later when recomputing w_topline).
+ if (mouse_dragging > 0
+ && curwin->w_cursor.lnum
+ == curwin->w_buffer->b_ml.ml_line_count
+ && curwin->w_cursor.lnum == curwin->w_topline)
+ curwin->w_valid &= ~(VALID_TOPLINE);
+ }
+ }
+
+ if (prev_row >= 0 && prev_row < Rows && prev_col >= 0 && prev_col <= Columns
+ && ScreenLines != NULL)
+ {
+ int off = LineOffset[prev_row] + prev_col;
+
+ // Only use ScreenCols[] after the window was redrawn. Mainly matters
+ // for tests, a user would not click before redrawing.
+ // Do not use when 'virtualedit' is active.
+ if (curwin->w_redr_type <= UPD_VALID_NO_UPDATE && !virtual_active())
+ col_from_screen = ScreenCols[off];
+#ifdef FEAT_FOLDING
+ // Remember the character under the mouse, it might be a '-' or '+' in
+ // the fold column.
+ mouse_char = ScreenLines[off];
+#endif
+ }
+
+#ifdef FEAT_FOLDING
+ // Check for position outside of the fold column.
+ if (
+# ifdef FEAT_RIGHTLEFT
+ curwin->w_p_rl ? col < curwin->w_width - curwin->w_p_fdc :
+# endif
+ col >= curwin->w_p_fdc + (cmdwin_type == 0 ? 0 : 1)
+ )
+ mouse_char = ' ';
+#endif
+
+ // compute the position in the buffer line from the posn on the screen
+ if (mouse_comp_pos(curwin, &row, &col, &curwin->w_cursor.lnum, NULL))
+ mouse_past_bottom = TRUE;
+
+ // Start Visual mode before coladvance(), for when 'sel' != "old"
+ if ((flags & MOUSE_MAY_VIS) && !VIsual_active)
+ {
+ check_visual_highlight();
+ VIsual = old_cursor;
+ VIsual_active = TRUE;
+ VIsual_reselect = TRUE;
+ // if 'selectmode' contains "mouse", start Select mode
+ may_start_select('o');
+ setmouse();
+ if (p_smd && msg_silent == 0)
+ redraw_cmdline = TRUE; // show visual mode later
+ }
+
+ if (col_from_screen >= 0)
+ {
+ // Use the column from ScreenCols[], it is accurate also after
+ // concealed characters.
+ curwin->w_cursor.col = col_from_screen;
+ if (col_from_screen == MAXCOL)
+ {
+ curwin->w_curswant = col_from_screen;
+ curwin->w_set_curswant = FALSE; // May still have been TRUE
+ mouse_past_eol = TRUE;
+ if (inclusive != NULL)
+ *inclusive = TRUE;
+ }
+ else
+ {
+ curwin->w_set_curswant = TRUE;
+ if (inclusive != NULL)
+ *inclusive = FALSE;
+ }
+ check_cursor_col();
+ }
+ else
+ {
+ curwin->w_curswant = col;
+ curwin->w_set_curswant = FALSE; // May still have been TRUE
+ if (coladvance(col) == FAIL) // Mouse click beyond end of line
+ {
+ if (inclusive != NULL)
+ *inclusive = TRUE;
+ mouse_past_eol = TRUE;
+ }
+ else if (inclusive != NULL)
+ *inclusive = FALSE;
+ }
+
+ count = IN_BUFFER;
+ if (curwin != old_curwin || curwin->w_cursor.lnum != old_cursor.lnum
+ || curwin->w_cursor.col != old_cursor.col)
+ count |= CURSOR_MOVED; // Cursor has moved
+
+#ifdef FEAT_FOLDING
+ if (mouse_char == curwin->w_fill_chars.foldclosed)
+ count |= MOUSE_FOLD_OPEN;
+ else if (mouse_char != ' ')
+ count |= MOUSE_FOLD_CLOSE;
+#endif
+
+ return count;
+}
+
+/*
+ * Make a horizontal scroll to "leftcol".
+ * Return TRUE if the cursor moved, FALSE otherwise.
+ */
+ int
+do_mousescroll_horiz(long_u leftcol)
+{
+ if (curwin->w_p_wrap)
+ return FALSE; // no wrapping, no scrolling
+
+ if (curwin->w_leftcol == (colnr_T)leftcol)
+ return FALSE; // already there
+
+ // When the line of the cursor is too short, move the cursor to the
+ // longest visible line.
+ if (
+#ifdef FEAT_GUI
+ (!gui.in_use || vim_strchr(p_go, GO_HORSCROLL) == NULL) &&
+#endif
+ !virtual_active()
+ && (long)leftcol > scroll_line_len(curwin->w_cursor.lnum))
+ {
+ curwin->w_cursor.lnum = ui_find_longest_lnum();
+ curwin->w_cursor.col = 0;
+ }
+
+ return set_leftcol((colnr_T)leftcol);
+}
+
+/*
+ * Normal and Visual modes implementation for scrolling in direction
+ * "cap->arg", which is one of the MSCR_ values.
+ */
+ void
+nv_mousescroll(cmdarg_T *cap)
+{
+ win_T *old_curwin = curwin;
+
+ if (mouse_row >= 0 && mouse_col >= 0)
+ {
+ // Find the window at the mouse pointer coordinates.
+ // NOTE: Must restore "curwin" to "old_curwin" before returning!
+ int row = mouse_row;
+ int col = mouse_col;
+ curwin = mouse_find_win(&row, &col, FIND_POPUP);
+ if (curwin == NULL)
+ {
+ curwin = old_curwin;
+ return;
+ }
+
+#ifdef FEAT_PROP_POPUP
+ if (WIN_IS_POPUP(curwin) && !curwin->w_has_scrollbar)
+ {
+ // cannot scroll this popup window
+ curwin = old_curwin;
+ return;
+ }
+#endif
+ curbuf = curwin->w_buffer;
+ }
+
+ // Call the common mouse scroll function shared with other modes.
+ do_mousescroll(cap);
+
+#ifdef FEAT_SYN_HL
+ if (curwin != old_curwin && curwin->w_p_cul)
+ redraw_for_cursorline(curwin);
+#endif
+ curwin->w_redr_status = TRUE;
+ curwin = old_curwin;
+ curbuf = curwin->w_buffer;
+}
+
+/*
+ * Mouse clicks and drags.
+ */
+ void
+nv_mouse(cmdarg_T *cap)
+{
+ (void)do_mouse(cap->oap, cap->cmdchar, BACKWARD, cap->count1, 0);
+}
+
+static int held_button = MOUSE_RELEASE;
+
+ void
+reset_held_button(void)
+{
+ held_button = MOUSE_RELEASE;
+}
+
+/*
+ * Check if typebuf 'tp' contains a terminal mouse code and returns the
+ * modifiers found in typebuf in 'modifiers'.
+ */
+ int
+check_termcode_mouse(
+ char_u *tp,
+ int *slen,
+ char_u *key_name,
+ char_u *modifiers_start,
+ int idx,
+ int *modifiers)
+{
+ int j;
+ char_u *p;
+#if !defined(UNIX) || defined(FEAT_MOUSE_XTERM) || defined(FEAT_GUI) \
+ || defined(FEAT_MOUSE_GPM) || defined(FEAT_SYSMOUSE)
+ char_u bytes[6];
+ int num_bytes;
+#endif
+ int mouse_code = 0; // init for GCC
+ int is_click, is_drag;
+ int is_release, release_is_ambiguous;
+ int wheel_code = 0;
+ int current_button;
+ static int orig_num_clicks = 1;
+ static int orig_mouse_code = 0x0;
+#ifdef CHECK_DOUBLE_CLICK
+ static int orig_mouse_col = 0;
+ static int orig_mouse_row = 0;
+ static struct timeval orig_mouse_time = {0, 0};
+ // time of previous mouse click
+ struct timeval mouse_time; // time of current mouse click
+ long timediff; // elapsed time in msec
+#endif
+
+ is_click = is_drag = is_release = release_is_ambiguous = FALSE;
+
+#if !defined(UNIX) || defined(FEAT_MOUSE_XTERM) || defined(FEAT_GUI) \
+ || defined(FEAT_MOUSE_GPM) || defined(FEAT_SYSMOUSE)
+ if (key_name[0] == KS_MOUSE
+# ifdef FEAT_MOUSE_GPM
+ || key_name[0] == KS_GPM_MOUSE
+# endif
+ )
+ {
+ /*
+ * For xterm we get "<t_mouse>scr", where s == encoded button state:
+ * 0x20 = left button down
+ * 0x21 = middle button down
+ * 0x22 = right button down
+ * 0x23 = any button release
+ * 0x60 = button 4 down (scroll wheel down)
+ * 0x61 = button 5 down (scroll wheel up)
+ * add 0x04 for SHIFT
+ * add 0x08 for ALT
+ * add 0x10 for CTRL
+ * add 0x20 for mouse drag (0x40 is drag with left button)
+ * add 0x40 for mouse move (0x80 is move, 0x81 too)
+ * 0x43 (drag + release) is also move
+ * c == column + ' ' + 1 == column + 33
+ * r == row + ' ' + 1 == row + 33
+ *
+ * The coordinates are passed on through global variables. Ugly, but
+ * this avoids trouble with mouse clicks at an unexpected moment and
+ * allows for mapping them.
+ */
+ for (;;)
+ {
+ // For the GUI and for MS-Windows two bytes each are used for row
+ // and column. Allows for more than 223 columns.
+# if defined(FEAT_GUI) || defined(MSWIN)
+ if (TRUE
+# if defined(FEAT_GUI) && !defined(MSWIN)
+ && gui.in_use
+# endif
+ )
+ {
+ num_bytes = get_bytes_from_buf(tp + *slen, bytes, 5);
+ if (num_bytes == -1) // not enough coordinates
+ return -1;
+ mouse_code = bytes[0];
+ mouse_col = 128 * (bytes[1] - ' ' - 1)
+ + bytes[2] - ' ' - 1;
+ mouse_row = 128 * (bytes[3] - ' ' - 1)
+ + bytes[4] - ' ' - 1;
+ }
+ else
+# endif
+ {
+ num_bytes = get_bytes_from_buf(tp + *slen, bytes, 3);
+ if (num_bytes == -1) // not enough coordinates
+ return -1;
+ mouse_code = bytes[0];
+ mouse_col = bytes[1] - ' ' - 1;
+ mouse_row = bytes[2] - ' ' - 1;
+ }
+ *slen += num_bytes;
+
+ // If the following bytes is also a mouse code and it has the same
+ // code, dump this one and get the next. This makes dragging a
+ // whole lot faster.
+# ifdef FEAT_GUI
+ if (gui.in_use)
+ j = 3;
+ else
+# endif
+ j = get_termcode_len(idx);
+ if (STRNCMP(tp, tp + *slen, (size_t)j) == 0
+ && tp[*slen + j] == mouse_code
+ && tp[*slen + j + 1] != NUL
+ && tp[*slen + j + 2] != NUL
+# ifdef FEAT_GUI
+ && (!gui.in_use
+ || (tp[*slen + j + 3] != NUL
+ && tp[*slen + j + 4] != NUL))
+# endif
+ )
+ *slen += j;
+ else
+ break;
+ }
+ }
+
+ if (key_name[0] == KS_URXVT_MOUSE
+ || key_name[0] == KS_SGR_MOUSE
+ || key_name[0] == KS_SGR_MOUSE_RELEASE)
+ {
+ // URXVT 1015 mouse reporting mode:
+ // Almost identical to xterm mouse mode, except the values are decimal
+ // instead of bytes.
+ //
+ // \033[%d;%d;%dM
+ // ^-- row
+ // ^----- column
+ // ^-------- code
+ //
+ // SGR 1006 mouse reporting mode:
+ // Almost identical to xterm mouse mode, except the values are decimal
+ // instead of bytes.
+ //
+ // \033[<%d;%d;%dM
+ // ^-- row
+ // ^----- column
+ // ^-------- code
+ //
+ // \033[<%d;%d;%dm : mouse release event
+ // ^-- row
+ // ^----- column
+ // ^-------- code
+ p = modifiers_start;
+ if (p == NULL)
+ return -1;
+
+ mouse_code = getdigits(&p);
+ if (*p++ != ';')
+ return -1;
+
+ // when mouse reporting is SGR, add 32 to mouse code
+ if (key_name[0] == KS_SGR_MOUSE
+ || key_name[0] == KS_SGR_MOUSE_RELEASE)
+ mouse_code += 32;
+
+ mouse_col = getdigits(&p) - 1;
+ if (*p++ != ';')
+ return -1;
+
+ mouse_row = getdigits(&p) - 1;
+
+ // The modifiers were the mouse coordinates, not the modifier keys
+ // (alt/shift/ctrl/meta) state.
+ *modifiers = 0;
+ }
+
+ if (key_name[0] == KS_SGR_MOUSE
+ || key_name[0] == KS_SGR_MOUSE_RELEASE)
+ {
+ if (key_name[0] == KS_SGR_MOUSE_RELEASE)
+ {
+ is_release = TRUE;
+ // This is used below to set held_button.
+ mouse_code |= MOUSE_RELEASE;
+ }
+ }
+ else
+ {
+ release_is_ambiguous = TRUE;
+ if ((mouse_code & MOUSE_RELEASE) == MOUSE_RELEASE)
+ is_release = TRUE;
+ }
+
+ if (key_name[0] == KS_MOUSE
+# ifdef FEAT_MOUSE_GPM
+ || key_name[0] == KS_GPM_MOUSE
+# endif
+# ifdef FEAT_MOUSE_URXVT
+ || key_name[0] == KS_URXVT_MOUSE
+# endif
+ || key_name[0] == KS_SGR_MOUSE
+ || key_name[0] == KS_SGR_MOUSE_RELEASE)
+ {
+# if !defined(MSWIN)
+ /*
+ * Handle old style mouse events.
+ * Recognize the xterm mouse wheel, but not in the GUI, the
+ * Linux console with GPM and the MS-DOS or Win32 console
+ * (multi-clicks use >= 0x60).
+ */
+ if (mouse_code >= MOUSEWHEEL_LOW
+# ifdef FEAT_GUI
+ && !gui.in_use
+# endif
+# ifdef FEAT_MOUSE_GPM
+ && key_name[0] != KS_GPM_MOUSE
+# endif
+ )
+ {
+# if defined(UNIX)
+ if (use_xterm_mouse() > 1 && mouse_code >= 0x80)
+ // mouse-move event, using MOUSE_DRAG works
+ mouse_code = MOUSE_DRAG;
+ else
+# endif
+ // Keep the mouse_code before it's changed, so that we
+ // remember that it was a mouse wheel click.
+ wheel_code = mouse_code;
+ }
+# ifdef FEAT_MOUSE_XTERM
+ else if (held_button == MOUSE_RELEASE
+# ifdef FEAT_GUI
+ && !gui.in_use
+# endif
+ && (mouse_code == 0x23 || mouse_code == 0x24
+ || mouse_code == 0x40 || mouse_code == 0x41))
+ {
+ // Apparently 0x23 and 0x24 are used by rxvt scroll wheel.
+ // And 0x40 and 0x41 are used by some xterm emulator.
+ wheel_code = mouse_code - (mouse_code >= 0x40 ? 0x40 : 0x23)
+ + MOUSEWHEEL_LOW;
+ }
+# endif
+
+# if defined(UNIX)
+ else if (use_xterm_mouse() > 1)
+ {
+ if (mouse_code & MOUSE_DRAG_XTERM)
+ mouse_code |= MOUSE_DRAG;
+ }
+# endif
+# ifdef FEAT_XCLIPBOARD
+ else if (!(mouse_code & MOUSE_DRAG & ~MOUSE_CLICK_MASK))
+ {
+ if (is_release)
+ stop_xterm_trace();
+ else
+ start_xterm_trace(mouse_code);
+ }
+# endif
+# endif
+ }
+#endif // !UNIX || FEAT_MOUSE_XTERM
+#ifdef FEAT_MOUSE_NET
+ if (key_name[0] == KS_NETTERM_MOUSE)
+ {
+ int mc, mr;
+
+ // expect a rather limited sequence like: balancing {
+ // \033}6,45\r
+ // '6' is the row, 45 is the column
+ p = tp + *slen;
+ mr = getdigits(&p);
+ if (*p++ != ',')
+ return -1;
+ mc = getdigits(&p);
+ if (*p++ != '\r')
+ return -1;
+
+ mouse_col = mc - 1;
+ mouse_row = mr - 1;
+ mouse_code = MOUSE_LEFT;
+ *slen += (int)(p - (tp + *slen));
+ }
+#endif // FEAT_MOUSE_NET
+#ifdef FEAT_MOUSE_JSB
+ if (key_name[0] == KS_JSBTERM_MOUSE)
+ {
+ int mult, val, iter, button, status;
+
+ /*
+ * JSBTERM Input Model
+ * \033[0~zw uniq escape sequence
+ * (L-x) Left button pressed - not pressed x not reporting
+ * (M-x) Middle button pressed - not pressed x not reporting
+ * (R-x) Right button pressed - not pressed x not reporting
+ * (SDmdu) Single , Double click, m: mouse move, d: button down,
+ * u: button up
+ * ### X cursor position padded to 3 digits
+ * ### Y cursor position padded to 3 digits
+ * (s-x) SHIFT key pressed - not pressed x not reporting
+ * (c-x) CTRL key pressed - not pressed x not reporting
+ * \033\\ terminating sequence
+ */
+ p = tp + *slen;
+ button = mouse_code = 0;
+ switch (*p++)
+ {
+ case 'L': button = 1; break;
+ case '-': break;
+ case 'x': break; // ignore sequence
+ default: return -1; // Unknown Result
+ }
+ switch (*p++)
+ {
+ case 'M': button |= 2; break;
+ case '-': break;
+ case 'x': break; // ignore sequence
+ default: return -1; // Unknown Result
+ }
+ switch (*p++)
+ {
+ case 'R': button |= 4; break;
+ case '-': break;
+ case 'x': break; // ignore sequence
+ default: return -1; // Unknown Result
+ }
+ status = *p++;
+ for (val = 0, mult = 100, iter = 0; iter < 3; iter++,
+ mult /= 10, p++)
+ if (*p >= '0' && *p <= '9')
+ val += (*p - '0') * mult;
+ else
+ return -1;
+ mouse_col = val;
+ for (val = 0, mult = 100, iter = 0; iter < 3; iter++,
+ mult /= 10, p++)
+ if (*p >= '0' && *p <= '9')
+ val += (*p - '0') * mult;
+ else
+ return -1;
+ mouse_row = val;
+ switch (*p++)
+ {
+ case 's': button |= 8; break; // SHIFT key Pressed
+ case '-': break; // Not Pressed
+ case 'x': break; // Not Reporting
+ default: return -1; // Unknown Result
+ }
+ switch (*p++)
+ {
+ case 'c': button |= 16; break; // CTRL key Pressed
+ case '-': break; // Not Pressed
+ case 'x': break; // Not Reporting
+ default: return -1; // Unknown Result
+ }
+ if (*p++ != '\033')
+ return -1;
+ if (*p++ != '\\')
+ return -1;
+ switch (status)
+ {
+ case 'D': // Double Click
+ case 'S': // Single Click
+ if (button & 1) mouse_code |= MOUSE_LEFT;
+ if (button & 2) mouse_code |= MOUSE_MIDDLE;
+ if (button & 4) mouse_code |= MOUSE_RIGHT;
+ if (button & 8) mouse_code |= MOUSE_SHIFT;
+ if (button & 16) mouse_code |= MOUSE_CTRL;
+ break;
+ case 'm': // Mouse move
+ if (button & 1) mouse_code |= MOUSE_LEFT;
+ if (button & 2) mouse_code |= MOUSE_MIDDLE;
+ if (button & 4) mouse_code |= MOUSE_RIGHT;
+ if (button & 8) mouse_code |= MOUSE_SHIFT;
+ if (button & 16) mouse_code |= MOUSE_CTRL;
+ if ((button & 7) != 0)
+ {
+ held_button = mouse_code;
+ mouse_code |= MOUSE_DRAG;
+ }
+ is_drag = TRUE;
+ showmode();
+ break;
+ case 'd': // Button Down
+ if (button & 1) mouse_code |= MOUSE_LEFT;
+ if (button & 2) mouse_code |= MOUSE_MIDDLE;
+ if (button & 4) mouse_code |= MOUSE_RIGHT;
+ if (button & 8) mouse_code |= MOUSE_SHIFT;
+ if (button & 16) mouse_code |= MOUSE_CTRL;
+ break;
+ case 'u': // Button Up
+ is_release = TRUE;
+ if (button & 1)
+ mouse_code |= MOUSE_LEFT;
+ if (button & 2)
+ mouse_code |= MOUSE_MIDDLE;
+ if (button & 4)
+ mouse_code |= MOUSE_RIGHT;
+ if (button & 8)
+ mouse_code |= MOUSE_SHIFT;
+ if (button & 16)
+ mouse_code |= MOUSE_CTRL;
+ break;
+ default: return -1; // Unknown Result
+ }
+
+ *slen += (p - (tp + *slen));
+ }
+#endif // FEAT_MOUSE_JSB
+#ifdef FEAT_MOUSE_DEC
+ if (key_name[0] == KS_DEC_MOUSE)
+ {
+ /*
+ * The DEC Locator Input Model
+ * Netterm delivers the code sequence:
+ * \033[2;4;24;80&w (left button down)
+ * \033[3;0;24;80&w (left button up)
+ * \033[6;1;24;80&w (right button down)
+ * \033[7;0;24;80&w (right button up)
+ * CSI Pe ; Pb ; Pr ; Pc ; Pp & w
+ * Pe is the event code
+ * Pb is the button code
+ * Pr is the row coordinate
+ * Pc is the column coordinate
+ * Pp is the third coordinate (page number)
+ * Pe, the event code indicates what event caused this report
+ * The following event codes are defined:
+ * 0 - request, the terminal received an explicit request for a
+ * locator report, but the locator is unavailable
+ * 1 - request, the terminal received an explicit request for a
+ * locator report
+ * 2 - left button down
+ * 3 - left button up
+ * 4 - middle button down
+ * 5 - middle button up
+ * 6 - right button down
+ * 7 - right button up
+ * 8 - fourth button down
+ * 9 - fourth button up
+ * 10 - locator outside filter rectangle
+ * Pb, the button code, ASCII decimal 0-15 indicating which buttons are
+ * down if any. The state of the four buttons on the locator
+ * correspond to the low four bits of the decimal value, "1" means
+ * button depressed
+ * 0 - no buttons down,
+ * 1 - right,
+ * 2 - middle,
+ * 4 - left,
+ * 8 - fourth
+ * Pr is the row coordinate of the locator position in the page,
+ * encoded as an ASCII decimal value. If Pr is omitted, the locator
+ * position is undefined (outside the terminal window for example).
+ * Pc is the column coordinate of the locator position in the page,
+ * encoded as an ASCII decimal value. If Pc is omitted, the locator
+ * position is undefined (outside the terminal window for example).
+ * Pp is the page coordinate of the locator position encoded as an
+ * ASCII decimal value. The page coordinate may be omitted if the
+ * locator is on page one (the default). We ignore it anyway.
+ */
+ int Pe, Pb, Pr, Pc;
+
+ p = tp + *slen;
+
+ // get event status
+ Pe = getdigits(&p);
+ if (*p++ != ';')
+ return -1;
+
+ // get button status
+ Pb = getdigits(&p);
+ if (*p++ != ';')
+ return -1;
+
+ // get row status
+ Pr = getdigits(&p);
+ if (*p++ != ';')
+ return -1;
+
+ // get column status
+ Pc = getdigits(&p);
+
+ // the page parameter is optional
+ if (*p == ';')
+ {
+ p++;
+ (void)getdigits(&p);
+ }
+ if (*p++ != '&')
+ return -1;
+ if (*p++ != 'w')
+ return -1;
+
+ mouse_code = 0;
+ switch (Pe)
+ {
+ case 0: return -1; // position request while unavailable
+ case 1: // a response to a locator position request includes
+ // the status of all buttons
+ Pb &= 7; // mask off and ignore fourth button
+ if (Pb & 4)
+ mouse_code = MOUSE_LEFT;
+ if (Pb & 2)
+ mouse_code = MOUSE_MIDDLE;
+ if (Pb & 1)
+ mouse_code = MOUSE_RIGHT;
+ if (Pb)
+ {
+ held_button = mouse_code;
+ mouse_code |= MOUSE_DRAG;
+ WantQueryMouse = TRUE;
+ }
+ is_drag = TRUE;
+ showmode();
+ break;
+ case 2: mouse_code = MOUSE_LEFT;
+ WantQueryMouse = TRUE;
+ break;
+ case 3: mouse_code = MOUSE_LEFT;
+ is_release = TRUE;
+ break;
+ case 4: mouse_code = MOUSE_MIDDLE;
+ WantQueryMouse = TRUE;
+ break;
+ case 5: mouse_code = MOUSE_MIDDLE;
+ is_release = TRUE;
+ break;
+ case 6: mouse_code = MOUSE_RIGHT;
+ WantQueryMouse = TRUE;
+ break;
+ case 7: mouse_code = MOUSE_RIGHT;
+ is_release = TRUE;
+ break;
+ case 8: return -1; // fourth button down
+ case 9: return -1; // fourth button up
+ case 10: return -1; // mouse outside of filter rectangle
+ default: return -1; // should never occur
+ }
+
+ mouse_col = Pc - 1;
+ mouse_row = Pr - 1;
+
+ *slen += (int)(p - (tp + *slen));
+ }
+#endif // FEAT_MOUSE_DEC
+#ifdef FEAT_MOUSE_PTERM
+ if (key_name[0] == KS_PTERM_MOUSE)
+ {
+ int button, num_clicks, action;
+
+ p = tp + *slen;
+
+ action = getdigits(&p);
+ if (*p++ != ';')
+ return -1;
+
+ mouse_row = getdigits(&p);
+ if (*p++ != ';')
+ return -1;
+ mouse_col = getdigits(&p);
+ if (*p++ != ';')
+ return -1;
+
+ button = getdigits(&p);
+ mouse_code = 0;
+
+ switch (button)
+ {
+ case 4: mouse_code = MOUSE_LEFT; break;
+ case 1: mouse_code = MOUSE_RIGHT; break;
+ case 2: mouse_code = MOUSE_MIDDLE; break;
+ default: return -1;
+ }
+
+ switch (action)
+ {
+ case 31: // Initial press
+ if (*p++ != ';')
+ return -1;
+
+ num_clicks = getdigits(&p); // Not used
+ break;
+
+ case 32: // Release
+ is_release = TRUE;
+ break;
+
+ case 33: // Drag
+ held_button = mouse_code;
+ mouse_code |= MOUSE_DRAG;
+ break;
+
+ default:
+ return -1;
+ }
+
+ if (*p++ != 't')
+ return -1;
+
+ *slen += (p - (tp + *slen));
+ }
+#endif // FEAT_MOUSE_PTERM
+
+ // Interpret the mouse code
+ current_button = (mouse_code & MOUSE_CLICK_MASK);
+ if (is_release)
+ current_button |= MOUSE_RELEASE;
+
+ if (current_button == MOUSE_RELEASE
+#ifdef FEAT_MOUSE_XTERM
+ && wheel_code == 0
+#endif
+ )
+ {
+ /*
+ * If we get a mouse drag or release event when there is no mouse
+ * button held down (held_button == MOUSE_RELEASE), produce a K_IGNORE
+ * below.
+ * (can happen when you hold down two buttons and then let them go, or
+ * click in the menu bar, but not on a menu, and drag into the text).
+ */
+ if ((mouse_code & MOUSE_DRAG) == MOUSE_DRAG)
+ is_drag = TRUE;
+ current_button = held_button;
+ }
+ else
+ {
+ if (wheel_code == 0)
+ {
+#ifdef CHECK_DOUBLE_CLICK
+# ifdef FEAT_MOUSE_GPM
+ /*
+ * Only for Unix, when GUI not active, we handle multi-clicks here, but
+ * not for GPM mouse events.
+ */
+# ifdef FEAT_GUI
+ if (key_name[0] != KS_GPM_MOUSE && !gui.in_use)
+# else
+ if (key_name[0] != KS_GPM_MOUSE)
+# endif
+# else
+# ifdef FEAT_GUI
+ if (!gui.in_use)
+# endif
+# endif
+ {
+ /*
+ * Compute the time elapsed since the previous mouse click.
+ */
+ gettimeofday(&mouse_time, NULL);
+ if (orig_mouse_time.tv_sec == 0)
+ {
+ /*
+ * Avoid computing the difference between mouse_time
+ * and orig_mouse_time for the first click, as the
+ * difference would be huge and would cause
+ * multiplication overflow.
+ */
+ timediff = p_mouset;
+ }
+ else
+ timediff = time_diff_ms(&orig_mouse_time, &mouse_time);
+ orig_mouse_time = mouse_time;
+ if (mouse_code == orig_mouse_code
+ && timediff < p_mouset
+ && orig_num_clicks != 4
+ && orig_mouse_col == mouse_col
+ && orig_mouse_row == mouse_row
+ && (is_mouse_topline(curwin)
+ // Double click in tab pages line also works
+ // when window contents changes.
+ || (mouse_row == 0 && firstwin->w_winrow > 0))
+ )
+ ++orig_num_clicks;
+ else
+ orig_num_clicks = 1;
+ orig_mouse_col = mouse_col;
+ orig_mouse_row = mouse_row;
+ set_mouse_topline(curwin);
+ }
+# if defined(FEAT_GUI) || defined(FEAT_MOUSE_GPM)
+ else
+ orig_num_clicks = NUM_MOUSE_CLICKS(mouse_code);
+# endif
+#else
+ orig_num_clicks = NUM_MOUSE_CLICKS(mouse_code);
+#endif
+ is_click = TRUE;
+ }
+ orig_mouse_code = mouse_code;
+ }
+ if (!is_drag)
+ held_button = mouse_code & MOUSE_CLICK_MASK;
+
+ /*
+ * Translate the actual mouse event into a pseudo mouse event.
+ * First work out what modifiers are to be used.
+ */
+ if (orig_mouse_code & MOUSE_SHIFT)
+ *modifiers |= MOD_MASK_SHIFT;
+ if (orig_mouse_code & MOUSE_CTRL)
+ *modifiers |= MOD_MASK_CTRL;
+ if (orig_mouse_code & MOUSE_ALT)
+ *modifiers |= MOD_MASK_ALT;
+ if (orig_num_clicks == 2)
+ *modifiers |= MOD_MASK_2CLICK;
+ else if (orig_num_clicks == 3)
+ *modifiers |= MOD_MASK_3CLICK;
+ else if (orig_num_clicks == 4)
+ *modifiers |= MOD_MASK_4CLICK;
+
+ // Work out our pseudo mouse event. Note that MOUSE_RELEASE gets added,
+ // then it's not mouse up/down.
+ key_name[0] = KS_EXTRA;
+ if (wheel_code != 0 && (!is_release || release_is_ambiguous))
+ {
+ if (wheel_code & MOUSE_CTRL)
+ *modifiers |= MOD_MASK_CTRL;
+ if (wheel_code & MOUSE_ALT)
+ *modifiers |= MOD_MASK_ALT;
+
+ if (wheel_code & 1 && wheel_code & 2)
+ key_name[1] = (int)KE_MOUSELEFT;
+ else if (wheel_code & 2)
+ key_name[1] = (int)KE_MOUSERIGHT;
+ else if (wheel_code & 1)
+ key_name[1] = (int)KE_MOUSEUP;
+ else
+ key_name[1] = (int)KE_MOUSEDOWN;
+
+ held_button = MOUSE_RELEASE;
+ }
+ else
+ key_name[1] = get_pseudo_mouse_code(current_button, is_click, is_drag);
+
+
+ // Make sure the mouse position is valid. Some terminals may return weird
+ // values.
+ if (mouse_col >= Columns)
+ mouse_col = Columns - 1;
+ if (mouse_row >= Rows)
+ mouse_row = Rows - 1;
+
+ return 0;
+}
+
+// Functions also used for popup windows.
+
+/*
+ * Compute the buffer line position from the screen position "rowp" / "colp" in
+ * window "win".
+ * "plines_cache" can be NULL (no cache) or an array with "Rows" entries that
+ * caches the plines_win() result from a previous call. Entry is zero if not
+ * computed yet. There must be no text or setting changes since the entry is
+ * put in the cache.
+ * Returns TRUE if the position is below the last line.
+ */
+ int
+mouse_comp_pos(
+ win_T *win,
+ int *rowp,
+ int *colp,
+ linenr_T *lnump,
+ int *plines_cache)
+{
+ int col = *colp;
+ int row = *rowp;
+ linenr_T lnum;
+ int retval = FALSE;
+ int off;
+ int count;
+
+#ifdef FEAT_RIGHTLEFT
+ if (win->w_p_rl)
+ col = win->w_width - 1 - col;
+#endif
+
+ lnum = win->w_topline;
+
+ while (row > 0)
+ {
+ int cache_idx = lnum - win->w_topline;
+
+ // Only "Rows" lines are cached, with folding we'll run out of entries
+ // and use the slow way.
+ if (plines_cache != NULL && cache_idx < Rows
+ && plines_cache[cache_idx] > 0)
+ count = plines_cache[cache_idx];
+ else
+ {
+#ifdef FEAT_DIFF
+ // Don't include filler lines in "count"
+ if (win->w_p_diff
+# ifdef FEAT_FOLDING
+ && !hasFoldingWin(win, lnum, NULL, NULL, TRUE, NULL)
+# endif
+ )
+ {
+ if (lnum == win->w_topline)
+ row -= win->w_topfill;
+ else
+ row -= diff_check_fill(win, lnum);
+ count = plines_win_nofill(win, lnum, FALSE);
+ }
+ else
+#endif
+ count = plines_win(win, lnum, FALSE);
+ if (plines_cache != NULL && cache_idx < Rows)
+ plines_cache[cache_idx] = count;
+ }
+
+ if (win->w_skipcol > 0 && lnum == win->w_topline)
+ {
+ // Adjust for 'smoothscroll' clipping the top screen lines.
+ // A similar formula is used in curs_columns().
+ int width1 = win->w_width - win_col_off(win);
+ int skip_lines = 0;
+ if (win->w_skipcol > width1)
+ skip_lines = (win->w_skipcol - width1)
+ / (width1 + win_col_off2(win)) + 1;
+ else if (win->w_skipcol > 0)
+ skip_lines = 1;
+ count -= skip_lines;
+ }
+
+ if (count > row)
+ break; // Position is in this buffer line.
+#ifdef FEAT_FOLDING
+ (void)hasFoldingWin(win, lnum, NULL, &lnum, TRUE, NULL);
+#endif
+ if (lnum == win->w_buffer->b_ml.ml_line_count)
+ {
+ retval = TRUE;
+ break; // past end of file
+ }
+ row -= count;
+ ++lnum;
+ }
+
+ if (!retval)
+ {
+ // Compute the column without wrapping.
+ off = win_col_off(win) - win_col_off2(win);
+ if (col < off)
+ col = off;
+ col += row * (win->w_width - off);
+
+ // Add skip column for the topline.
+ if (lnum == win->w_topline)
+ col += win->w_skipcol;
+ }
+
+ if (!win->w_p_wrap)
+ col += win->w_leftcol;
+
+ // skip line number and fold column in front of the line
+ col -= win_col_off(win);
+ if (col <= 0)
+ {
+#ifdef FEAT_NETBEANS_INTG
+ // if mouse is clicked on the gutter, then inform the netbeans server
+ if (*colp < win_col_off(win))
+ netbeans_gutter_click(lnum);
+#endif
+ col = 0;
+ }
+
+ *colp = col;
+ *rowp = row;
+ *lnump = lnum;
+ return retval;
+}
+
+/*
+ * Find the window at screen position "*rowp" and "*colp". The positions are
+ * updated to become relative to the top-left of the window.
+ * When "popup" is FAIL_POPUP and the position is in a popup window then NULL
+ * is returned. When "popup" is IGNORE_POPUP then do not even check popup
+ * windows.
+ * Returns NULL when something is wrong.
+ */
+ win_T *
+mouse_find_win(int *rowp, int *colp, mouse_find_T popup UNUSED)
+{
+ frame_T *fp;
+ win_T *wp;
+
+#ifdef FEAT_PROP_POPUP
+ win_T *pwp = NULL;
+
+ if (popup != IGNORE_POPUP)
+ {
+ popup_reset_handled(POPUP_HANDLED_1);
+ while ((wp = find_next_popup(TRUE, POPUP_HANDLED_1)) != NULL)
+ {
+ if (*rowp >= wp->w_winrow && *rowp < wp->w_winrow + popup_height(wp)
+ && *colp >= wp->w_wincol
+ && *colp < wp->w_wincol + popup_width(wp))
+ pwp = wp;
+ }
+ if (pwp != NULL)
+ {
+ if (popup == FAIL_POPUP)
+ return NULL;
+ *rowp -= pwp->w_winrow;
+ *colp -= pwp->w_wincol;
+ return pwp;
+ }
+ }
+#endif
+
+ fp = topframe;
+ *rowp -= firstwin->w_winrow;
+ for (;;)
+ {
+ if (fp->fr_layout == FR_LEAF)
+ break;
+ if (fp->fr_layout == FR_ROW)
+ {
+ for (fp = fp->fr_child; fp->fr_next != NULL; fp = fp->fr_next)
+ {
+ if (*colp < fp->fr_width)
+ break;
+ *colp -= fp->fr_width;
+ }
+ }
+ else // fr_layout == FR_COL
+ {
+ for (fp = fp->fr_child; fp->fr_next != NULL; fp = fp->fr_next)
+ {
+ if (*rowp < fp->fr_height)
+ break;
+ *rowp -= fp->fr_height;
+ }
+ }
+ }
+ // When using a timer that closes a window the window might not actually
+ // exist.
+ FOR_ALL_WINDOWS(wp)
+ if (wp == fp->fr_win)
+ {
+#ifdef FEAT_MENU
+ *rowp -= wp->w_winbar_height;
+#endif
+ return wp;
+ }
+ return NULL;
+}
+
+#if defined(NEED_VCOL2COL) || defined(FEAT_BEVAL) || defined(FEAT_PROP_POPUP) \
+ || defined(FEAT_EVAL) || defined(PROTO)
+/*
+ * Convert a virtual (screen) column to a character column.
+ * The first column is one.
+ */
+ int
+vcol2col(win_T *wp, linenr_T lnum, int vcol)
+{
+ char_u *line;
+ chartabsize_T cts;
+
+ // try to advance to the specified column
+ line = ml_get_buf(wp->w_buffer, lnum, FALSE);
+ init_chartabsize_arg(&cts, wp, lnum, 0, line, line);
+ while (cts.cts_vcol < vcol && *cts.cts_ptr != NUL)
+ {
+ cts.cts_vcol += win_lbr_chartabsize(&cts, NULL);
+ MB_PTR_ADV(cts.cts_ptr);
+ }
+ clear_chartabsize_arg(&cts);
+
+ return (int)(cts.cts_ptr - line);
+}
+#endif
+
+#if defined(FEAT_EVAL) || defined(PROTO)
+/*
+ * "getmousepos()" function.
+ */
+ void
+f_getmousepos(typval_T *argvars UNUSED, typval_T *rettv)
+{
+ dict_T *d;
+ win_T *wp;
+ int row = mouse_row;
+ int col = mouse_col;
+ varnumber_T winid = 0;
+ varnumber_T winrow = 0;
+ varnumber_T wincol = 0;
+ linenr_T lnum = 0;
+ varnumber_T column = 0;
+
+ if (rettv_dict_alloc(rettv) == FAIL)
+ return;
+ d = rettv->vval.v_dict;
+
+ dict_add_number(d, "screenrow", (varnumber_T)mouse_row + 1);
+ dict_add_number(d, "screencol", (varnumber_T)mouse_col + 1);
+
+ wp = mouse_find_win(&row, &col, FIND_POPUP);
+ if (wp != NULL)
+ {
+ int top_off = 0;
+ int left_off = 0;
+ int height = wp->w_height + wp->w_status_height;
+
+# ifdef FEAT_PROP_POPUP
+ if (WIN_IS_POPUP(wp))
+ {
+ top_off = popup_top_extra(wp);
+ left_off = popup_left_extra(wp);
+ height = popup_height(wp);
+ }
+# endif
+ if (row < height)
+ {
+ winid = wp->w_id;
+ winrow = row + 1;
+ wincol = col + 1;
+ row -= top_off;
+ col -= left_off;
+ if (row >= 0 && row < wp->w_height && col >= 0 && col < wp->w_width)
+ {
+ (void)mouse_comp_pos(wp, &row, &col, &lnum, NULL);
+ col = vcol2col(wp, lnum, col);
+ column = col + 1;
+ }
+ }
+ }
+ dict_add_number(d, "winid", winid);
+ dict_add_number(d, "winrow", winrow);
+ dict_add_number(d, "wincol", wincol);
+ dict_add_number(d, "line", (varnumber_T)lnum);
+ dict_add_number(d, "column", column);
+}
+#endif