Adding upstream version 2:9.0.1378.upstream/2%9.0.1378upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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