kevin/neovim
1
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2024-12-25 13:45:15 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #3871 from ZyX-I/tabline-clicks

Browse Source 
Allow running random code on tabline clicks
This commit is contained in:
Justin M. Keyes 2016-02-01 22:31:02 -05:00
commit 5308585adf
12 changed files with 481 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
runtime/doc/eval.txt
View File

@ -7063,6 +7063,7 @@ statusline Compiled with support for 'statusline', 'rulerformat'
syntax Compiled with syntax highlighting support |syntax|.
syntax_items There are active syntax highlighting items for the
current buffer.
tablineat 'tabline' option accepts %@Func@ items.
tag_binary Compiled with binary searching in tags files
|tag-binary-search|.
tag_old_static Compiled with support for old static tags

38
runtime/doc/options.txt
View File

@ -6011,11 +6011,39 @@ A jump table for the options with a short description can be found at |Q_op|.
( - Start of item group. Can be used for setting the width and
alignment of a section. Must be followed by %) somewhere.
) - End of item group. No width fields allowed.
T N For 'tabline': start of tab page N label. Use %T after the last
label. This information is used for mouse clicks.
X N For 'tabline': start of close tab N label. Use %X after the
label, e.g.: %3Xclose%X. Use %999X for a "close current tab"
mark. This information is used for mouse clicks.
T N For 'tabline': start of tab page N label. Use %T or %X to end
the label. Clicking this label with left mouse button switches
to the specified tab page.
X N For 'tabline': start of close tab N label. Use %X or %T to end
the label, e.g.: %3Xclose%X. Use %999X for a "close current
tab" label. Clicking this label with left mouse button closes
specified tab page.
@ N For 'tabline': start of execute function label. Use %X or %T to
end the label, e.g.: %10@SwitchBuffer@foo.c%X. Clicking this
label runs specified function: in the example when clicking once
using left mouse button on "foo.c" "SwitchBuffer(10, 1, 'l',
' ')" expression will be run. Function receives the
following arguments in order:
1. minwid field value or zero if no N was specified
2. number of mouse clicks to detect multiple clicks
3. mouse button used: "l", "r" or "m" for left, right or middle
button respectively; one should not rely on third argument
being only "l", "r" or "m": any other non-empty string value
that contains only ASCII lower case letters may be expected
for other mouse buttons
4. modifiers pressed: string which contains "s" if shift
modifier was pressed, "c" for control, "a" for alt and "m"
for meta; currently if modifier is not pressed string
contains space instead, but one should not rely on presence
of spaces or specific order of modifiers: use |stridx()| to
test whether some modifier is present; string is guaranteed
to contain only ASCII letters and spaces, one letter per
modifier; "?" modifier may also be present, but its presence
is a bug that denotes that new mouse button recognition was
added without modifying code that reacts on mouse clicks on
this label.
Note: to test whether your version of Neovim contains this
feature use `has('tablineat')`.
< - Where to truncate line if too long. Default is at the start.
No width fields allowed.
= - Separation point between left and right aligned items.

1
runtime/doc/various.txt
View File

@ -363,6 +363,7 @@ N *+startuptime* |--startuptime| argument
N *+statusline* Options 'statusline', 'rulerformat' and special
formats of 'titlestring' and 'iconstring'
N *+syntax* Syntax highlighting |syntax|
N *+tablineat* 'tabline' option recognizing %@Func@ items.
N *+tag_binary* binary searching in tags file |tag-binary-search|
N *+tag_old_static* old method for static tags |tag-old-static|
m *+tag_any_white* any white space allowed in tags file |tag-any-white|

67
src/nvim/buffer.c
View File

@ -22,6 +22,7 @@
#include "nvim/api/private/handle.h"
#include "nvim/ascii.h"
#include "nvim/assert.h"
#include "nvim/vim.h"
#include "nvim/buffer.h"
#include "nvim/charset.h"
@ -2826,7 +2827,7 @@ typedef enum {
/// @param fillchar Character to use when filling empty space in the statusline
/// @param maxwidth The maximum width to make the statusline
/// @param hltab HL attributes (can be NULL)
/// @param tabtab tab page nrs (can be NULL)
/// @param tabtab Tab clicks definition (can be NULL).
///
/// @return The final width of the statusline
int build_stl_str_hl(
@ -2838,13 +2839,15 @@ int build_stl_str_hl(
int fillchar,
int maxwidth,
struct stl_hlrec *hltab,
struct stl_hlrec *tabtab
StlClickRecord *tabtab
)
{
int groupitem[STL_MAX_ITEM];
struct stl_item {
// Where the item starts in the status line output buffer
char_u *start;
char_u *start;
// Function to run for ClickFunc items.
char *cmd;
// The minimum width of the item
int minwid;
// The maximum width of the item
@ -2856,10 +2859,10 @@ int build_stl_str_hl(
Middle,
Highlight,
TabPage,
ClickFunc,
Trunc
} type;
} item[STL_MAX_ITEM];
} type;
} item[STL_MAX_ITEM];
#define TMPLEN 70
char_u tmp[TMPLEN];
char_u *usefmt = fmt;
@ -3164,6 +3167,24 @@ int build_stl_str_hl(
continue;
}
if (*fmt_p == STL_CLICK_FUNC) {
fmt_p++;
char *t = (char *) fmt_p;
while (*fmt_p != STL_CLICK_FUNC && *fmt_p) {
fmt_p++;
}
if (*fmt_p != STL_CLICK_FUNC) {
break;
}
item[curitem].type = ClickFunc;
item[curitem].start = out_p;
item[curitem].cmd = xmemdupz(t, (size_t) (((char *) fmt_p - t)));
item[curitem].minwid = minwid;
fmt_p++;
curitem++;
continue;
}
// Denotes the end of the minwid
// the maxwid may follow immediately after
if (*fmt_p == '.') {
@ -3281,6 +3302,7 @@ int build_stl_str_hl(
}
break;
}
case STL_LINE:
num = (wp->w_buffer->b_ml.ml_flags & ML_EMPTY)
? 0L : (long)(wp->w_cursor.lnum);
@ -3821,16 +3843,37 @@ int build_stl_str_hl(
// Store the info about tab pages labels.
if (tabtab != NULL) {
struct stl_hlrec *sp = tabtab;
StlClickRecord *cur_tab_rec = tabtab;
for (long l = 0; l < itemcnt; l++) {
if (item[l].type == TabPage) {
sp->start = item[l].start;
sp->userhl = item[l].minwid;
sp++;
cur_tab_rec->start = (char *) item[l].start;
if (item[l].minwid == 0) {
cur_tab_rec->def.type = kStlClickDisabled;
cur_tab_rec->def.tabnr = 0;
} else {
int tabnr = item[l].minwid;
if (item[l].minwid > 0) {
cur_tab_rec->def.type = kStlClickTabSwitch;
} else {
cur_tab_rec->def.type = kStlClickTabClose;
tabnr = -tabnr;
}
cur_tab_rec->def.tabnr = tabnr;
}
cur_tab_rec->def.func = NULL;
cur_tab_rec++;
} else if (item[l].type == ClickFunc) {
cur_tab_rec->start = (char *) item[l].start;
cur_tab_rec->def.type = kStlClickFuncRun;
cur_tab_rec->def.tabnr = item[l].minwid;
cur_tab_rec->def.func = item[l].cmd;
cur_tab_rec++;
}
}
sp->start = NULL;
sp->userhl = 0;
cur_tab_rec->start = NULL;
cur_tab_rec->def.type = kStlClickDisabled;
cur_tab_rec->def.tabnr = 0;
cur_tab_rec->def.func = NULL;
}
return width;

1
src/nvim/buffer.h
View File

@ -4,6 +4,7 @@
#include "nvim/window.h"
#include "nvim/pos.h" // for linenr_T
#include "nvim/ex_cmds_defs.h" // for exarg_T
#include "nvim/screen.h" // for StlClickRecord
// Values for buflist_getfile()
enum getf_values {

1
src/nvim/eval.c
View File

@ -10930,6 +10930,7 @@ static void f_has(typval_T *argvars, typval_T *rettv)
#if !defined(UNIX)
"system", // TODO(SplinterOfChaos): This IS defined for UNIX!
#endif
"tablineat",
"tag_binary",
"tag_old_static",
"termresponse",

9
src/nvim/globals.h
View File

@ -159,15 +159,6 @@ EXTERN int Screen_mco INIT(= 0); /* value of p_mco used when
* These are single-width. */
EXTERN schar_T *ScreenLines2 INIT(= NULL);
/*
* Indexes for tab page line:
* N > 0 for label of tab page N
* N == 0 for no label
* N < 0 for closing tab page -N
* N == -999 for closing current tab page
*/
EXTERN short *TabPageIdxs INIT(= NULL);
EXTERN int screen_Rows INIT(= 0); /* actual size of ScreenLines[] */
EXTERN int screen_Columns INIT(= 0); /* actual size of ScreenLines[] */

136
src/nvim/normal.c
View File

@ -2347,8 +2347,9 @@ do_mouse (
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 - 1);
tabpage_move(tab_page_click_defs[mouse_col].type == kStlClickTabClose
? 9999
: tab_page_click_defs[mouse_col].tabnr - 1);
}
return false;
}
@ -2358,41 +2359,114 @@ do_mouse (
&& 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();
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();
c1 = tab_page_click_defs[mouse_col].tabnr;
switch (tab_page_click_defs[mouse_col].type) {
case kStlClickDisabled: {
break;
}
} else if (c1 < 0) {
tabpage_T *tp;
case kStlClickTabClose: {
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);
// 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);
}
break;
}
case kStlClickTabSwitch: {
if ((mod_mask & MOD_MASK_MULTI_CLICK) == MOD_MASK_2CLICK) {
// double click opens new page
end_visual_mode();
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();
}
}
break;
}
case kStlClickFuncRun: {
typval_T argv[] = {
{
.v_lock = VAR_FIXED,
.v_type = VAR_NUMBER,
.vval = {
.v_number = (varnumber_T) tab_page_click_defs[mouse_col].tabnr
},
},
{
.v_lock = VAR_FIXED,
.v_type = VAR_NUMBER,
.vval = {
.v_number = (((mod_mask & MOD_MASK_MULTI_CLICK)
== MOD_MASK_4CLICK)
? 4
: ((mod_mask & MOD_MASK_MULTI_CLICK)
== MOD_MASK_3CLICK)
? 3
: ((mod_mask & MOD_MASK_MULTI_CLICK)
== MOD_MASK_2CLICK)
? 2
: 1)
},
},
{
.v_lock = VAR_FIXED,
.v_type = VAR_STRING,
.vval = { .v_string = (char_u *) (which_button == MOUSE_LEFT
? "l"
: which_button == MOUSE_RIGHT
? "r"
: which_button == MOUSE_MIDDLE
? "m"
: "?") },
},
{
.v_lock = VAR_FIXED,
.v_type = VAR_STRING,
.vval = {
.v_string = (char_u[]) {
(char_u) (mod_mask & MOD_MASK_SHIFT ? 's' : ' '),
(char_u) (mod_mask & MOD_MASK_CTRL ? 'c' : ' '),
(char_u) (mod_mask & MOD_MASK_ALT ? 'a' : ' '),
(char_u) (mod_mask & MOD_MASK_META ? 'm' : ' '),
NUL
}
},
}
};
typval_T rettv;
int doesrange;
(void) call_func((char_u *) tab_page_click_defs[mouse_col].func,
(int) strlen(tab_page_click_defs[mouse_col].func),
&rettv, ARRAY_SIZE(argv), argv,
curwin->w_cursor.lnum, curwin->w_cursor.lnum,
&doesrange, true, NULL);
clear_tv(&rettv);
break;
}
}
}
return true;
} else if (is_drag && in_tab_line) {
c1 = TabPageIdxs[mouse_col];
tabpage_move(c1 <= 0 ? 9999 : c1 - 1);
tabpage_move(tab_page_click_defs[mouse_col].type == kStlClickTabClose
? 9999
: tab_page_click_defs[mouse_col].tabnr - 1);
in_tab_line = false;
return false;
}

90
src/nvim/option_defs.h
View File

@ -209,44 +209,58 @@
#define COM_ALL "nbsmexflrO" /* all flags for 'comments' option */
#define COM_MAX_LEN 50 /* maximum length of a part */
/* flags for 'statusline' option */
#define STL_FILEPATH 'f' /* path of file in buffer */
#define STL_FULLPATH 'F' /* full path of file in buffer */
#define STL_FILENAME 't' /* last part (tail) of file path */
#define STL_COLUMN 'c' /* column og cursor*/
#define STL_VIRTCOL 'v' /* virtual column */
#define STL_VIRTCOL_ALT 'V' /* - with 'if different' display */
#define STL_LINE 'l' /* line number of cursor */
#define STL_NUMLINES 'L' /* number of lines in buffer */
#define STL_BUFNO 'n' /* current buffer number */
#define STL_KEYMAP 'k' /* 'keymap' when active */
#define STL_OFFSET 'o' /* offset of character under cursor*/
#define STL_OFFSET_X 'O' /* - in hexadecimal */
#define STL_BYTEVAL 'b' /* byte value of character */
#define STL_BYTEVAL_X 'B' /* - in hexadecimal */
#define STL_ROFLAG 'r' /* readonly flag */
#define STL_ROFLAG_ALT 'R' /* - other display */
#define STL_HELPFLAG 'h' /* window is showing a help file */
#define STL_HELPFLAG_ALT 'H' /* - other display */
#define STL_FILETYPE 'y' /* 'filetype' */
#define STL_FILETYPE_ALT 'Y' /* - other display */
#define STL_PREVIEWFLAG 'w' /* window is showing the preview buf */
#define STL_PREVIEWFLAG_ALT 'W' /* - other display */
#define STL_MODIFIED 'm' /* modified flag */
#define STL_MODIFIED_ALT 'M' /* - other display */
#define STL_QUICKFIX 'q' /* quickfix window description */
#define STL_PERCENTAGE 'p' /* percentage through file */
#define STL_ALTPERCENT 'P' /* percentage as TOP BOT ALL or NN% */
#define STL_ARGLISTSTAT 'a' /* argument list status as (x of y) */
#define STL_PAGENUM 'N' /* page number (when printing)*/
#define STL_VIM_EXPR '{' /* start of expression to substitute */
#define STL_MIDDLEMARK '=' /* separation between left and right */
#define STL_TRUNCMARK '<' /* truncation mark if line is too long*/
#define STL_USER_HL '*' /* highlight from (User)1..9 or 0 */
#define STL_HIGHLIGHT '#' /* highlight name */
#define STL_TABPAGENR 'T' /* tab page label nr */
#define STL_TABCLOSENR 'X' /* tab page close nr */
#define STL_ALL ((char_u *) "fFtcvVlLknoObBrRhHmYyWwMqpPaN{#")
/// 'statusline' option flags
enum {
STL_FILEPATH = 'f', ///< Path of file in buffer.
STL_FULLPATH = 'F', ///< Full path of file in buffer.
STL_FILENAME = 't', ///< Last part (tail) of file path.
STL_COLUMN = 'c', ///< Column og cursor.
STL_VIRTCOL = 'v', ///< Virtual column.
STL_VIRTCOL_ALT = 'V', ///< - with 'if different' display.
STL_LINE = 'l', ///< Line number of cursor.
STL_NUMLINES = 'L', ///< Number of lines in buffer.
STL_BUFNO = 'n', ///< Current buffer number.
STL_KEYMAP = 'k', ///< 'keymap' when active.
STL_OFFSET = 'o', ///< Offset of character under cursor.
STL_OFFSET_X = 'O', ///< - in hexadecimal.
STL_BYTEVAL = 'b', ///< Byte value of character.
STL_BYTEVAL_X = 'B', ///< - in hexadecimal.
STL_ROFLAG = 'r', ///< Readonly flag.
STL_ROFLAG_ALT = 'R', ///< - other display.
STL_HELPFLAG = 'h', ///< Window is showing a help file.
STL_HELPFLAG_ALT = 'H', ///< - other display.
STL_FILETYPE = 'y', ///< 'filetype'.
STL_FILETYPE_ALT = 'Y', ///< - other display.
STL_PREVIEWFLAG = 'w', ///< Window is showing the preview buf.
STL_PREVIEWFLAG_ALT = 'W', ///< - other display.
STL_MODIFIED = 'm', ///< Modified flag.
STL_MODIFIED_ALT = 'M', ///< - other display.
STL_QUICKFIX = 'q', ///< Quickfix window description.
STL_PERCENTAGE = 'p', ///< Percentage through file.
STL_ALTPERCENT = 'P', ///< Percentage as TOP BOT ALL or NN%.
STL_ARGLISTSTAT = 'a', ///< Argument list status as (x of y).
STL_PAGENUM = 'N', ///< Page number (when printing).
STL_VIM_EXPR = '{', ///< Start of expression to substitute.
STL_MIDDLEMARK = '=', ///< Separation between left and right.
STL_TRUNCMARK = '<', ///< Truncation mark if line is too long.
STL_USER_HL = '*', ///< Highlight from (User)1..9 or 0.
STL_HIGHLIGHT = '#', ///< Highlight name.
STL_TABPAGENR = 'T', ///< Tab page label nr.
STL_TABCLOSENR = 'X', ///< Tab page close nr.
STL_CLICK_FUNC = '@', ///< Click region start.
};
/// C string containing all 'statusline' option flags
#define STL_ALL ((char_u[]) { \
STL_FILEPATH, STL_FULLPATH, STL_FILENAME, STL_COLUMN, STL_VIRTCOL, \
STL_VIRTCOL_ALT, STL_LINE, STL_NUMLINES, STL_BUFNO, STL_KEYMAP, STL_OFFSET, \
STL_OFFSET_X, STL_BYTEVAL, STL_BYTEVAL_X, STL_ROFLAG, STL_ROFLAG_ALT, \
STL_HELPFLAG, STL_HELPFLAG_ALT, STL_FILETYPE, STL_FILETYPE_ALT, \
STL_PREVIEWFLAG, STL_PREVIEWFLAG_ALT, STL_MODIFIED, STL_MODIFIED_ALT, \
STL_QUICKFIX, STL_PERCENTAGE, STL_ALTPERCENT, STL_ARGLISTSTAT, STL_PAGENUM, \
STL_VIM_EXPR, STL_MIDDLEMARK, STL_TRUNCMARK, STL_USER_HL, STL_HIGHLIGHT, \
STL_TABPAGENR, STL_TABCLOSENR, STL_CLICK_FUNC, \
0, \
})
/* flags used for parsed 'wildmode' */
#define WIM_FULL 1

94
src/nvim/screen.c
View File

@ -147,6 +147,9 @@ static foldinfo_T win_foldinfo; /* info for 'foldcolumn' */
*/
static schar_T *current_ScreenLine;
StlClickDefinition *tab_page_click_defs = NULL;
long tab_page_click_defs_size = 0;
# define SCREEN_LINE(r, o, e, c, rl) screen_line((r), (o), (e), (c), (rl))
#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "screen.c.generated.h"
@ -5009,8 +5012,8 @@ win_redr_custom (
char_u *stl;
char_u *p;
struct stl_hlrec hltab[STL_MAX_ITEM];
struct stl_hlrec tabtab[STL_MAX_ITEM];
int use_sandbox = FALSE;
StlClickRecord tabtab[STL_MAX_ITEM];
int use_sandbox = false;
win_T *ewp;
int p_crb_save;
@ -5126,20 +5129,24 @@ win_redr_custom (
screen_puts(p >= buf + len ? (char_u *)"" : p, row, col, curattr);
if (wp == NULL) {
/* Fill the TabPageIdxs[] array for clicking in the tab pagesline. */
// Fill the tab_page_click_defs array for clicking in the tab pages line.
col = 0;
len = 0;
p = buf;
fillchar = 0;
StlClickDefinition cur_click_def = {
.type = kStlClickDisabled,
};
for (n = 0; tabtab[n].start != NULL; n++) {
len += vim_strnsize(p, (int)(tabtab[n].start - p));
while (col < len)
TabPageIdxs[col++] = fillchar;
p = tabtab[n].start;
fillchar = tabtab[n].userhl;
len += vim_strnsize(p, (int)(tabtab[n].start - (char *) p));
while (col < len) {
tab_page_click_defs[col++] = cur_click_def;
}
p = (char_u *) tabtab[n].start;
cur_click_def = tabtab[n].def;
}
while (col < Columns) {
tab_page_click_defs[col++] = cur_click_def;
}
while (col < Columns)
TabPageIdxs[col++] = fillchar;
}
theend:
@ -5958,9 +5965,9 @@ void screenalloc(bool doclear)
sattr_T *new_ScreenAttrs;
unsigned *new_LineOffset;
char_u *new_LineWraps;
short *new_TabPageIdxs;
static int entered = FALSE; /* avoid recursiveness */
static int done_outofmem_msg = FALSE; /* did outofmem message */
StlClickDefinition *new_tab_page_click_defs;
static bool entered = false; // avoid recursiveness
static bool done_outofmem_msg = false;
int retry_count = 0;
const bool l_enc_utf8 = enc_utf8;
const int l_enc_dbcs = enc_dbcs;
@ -6033,7 +6040,8 @@ retry:
new_ScreenAttrs = xmalloc((size_t)((Rows + 1) * Columns * sizeof(sattr_T)));
new_LineOffset = xmalloc((size_t)(Rows * sizeof(unsigned)));
new_LineWraps = xmalloc((size_t)(Rows * sizeof(char_u)));
new_TabPageIdxs = xmalloc((size_t)(Columns * sizeof(short)));
new_tab_page_click_defs = xcalloc(
(size_t) Columns, sizeof(*new_tab_page_click_defs));
FOR_ALL_TAB_WINDOWS(tp, wp) {
win_alloc_lines(wp);
@ -6051,7 +6059,7 @@ retry:
|| new_ScreenAttrs == NULL
|| new_LineOffset == NULL
|| new_LineWraps == NULL
|| new_TabPageIdxs == NULL
|| new_tab_page_click_defs == NULL
|| outofmem) {
if (ScreenLines != NULL || !done_outofmem_msg) {
/* guess the size */
@ -6077,8 +6085,8 @@ retry:
new_LineOffset = NULL;
xfree(new_LineWraps);
new_LineWraps = NULL;
xfree(new_TabPageIdxs);
new_TabPageIdxs = NULL;
xfree(new_tab_page_click_defs);
new_tab_page_click_defs = NULL;
} else {
done_outofmem_msg = FALSE;
@ -6157,7 +6165,8 @@ retry:
ScreenAttrs = new_ScreenAttrs;
LineOffset = new_LineOffset;
LineWraps = new_LineWraps;
TabPageIdxs = new_TabPageIdxs;
tab_page_click_defs = new_tab_page_click_defs;
tab_page_click_defs_size = Columns;
/* It's important that screen_Rows and screen_Columns reflect the actual
* size of ScreenLines[]. Set them before calling anything. */
@ -6196,7 +6205,25 @@ void free_screenlines(void)
xfree(ScreenAttrs);
xfree(LineOffset);
xfree(LineWraps);
xfree(TabPageIdxs);
clear_tab_page_click_defs(tab_page_click_defs, tab_page_click_defs_size);
xfree(tab_page_click_defs);
}
/// Clear tab_page_click_defs table
///
/// @param[out] tpcd Table to clear.
/// @param[in] tpcd_size Size of the table.
void clear_tab_page_click_defs(StlClickDefinition *const tpcd,
const long tpcd_size)
{
if (tpcd != NULL) {
for (long i = 0; i < tpcd_size; i++) {
if (i == 0 || tpcd[i].func != tpcd[i - 1].func) {
xfree(tpcd[i].func);
}
}
}
memset(tpcd, 0, (size_t) tpcd_size * sizeof(tpcd[0]));
}
void screenclear(void)
@ -6804,9 +6831,9 @@ static void draw_tabline(void)
return;
/* Init TabPageIdxs[] to zero: Clicking outside of tabs has no effect. */
for (scol = 0; scol < Columns; ++scol)
TabPageIdxs[scol] = 0;
// Init TabPageIdxs[] to zero: Clicking outside of tabs has no effect.
assert(Columns == tab_page_click_defs_size);
clear_tab_page_click_defs(tab_page_click_defs, tab_page_click_defs_size);
/* Use the 'tabline' option if it's set. */
if (*p_tal != NUL) {
@ -6904,11 +6931,16 @@ static void draw_tabline(void)
}
screen_putchar(' ', 0, col++, attr);
/* Store the tab page number in TabPageIdxs[], so that
* jump_to_mouse() knows where each one is. */
++tabcount;
while (scol < col)
TabPageIdxs[scol++] = tabcount;
// Store the tab page number in tab_page_click_defs[], so that
// jump_to_mouse() knows where each one is.
tabcount++;
while (scol < col) {
tab_page_click_defs[scol++] = (StlClickDefinition) {
.type = kStlClickTabSwitch,
.tabnr = tabcount,
.func = NULL,
};
}
}
if (use_sep_chars)
@ -6920,7 +6952,11 @@ static void draw_tabline(void)
/* Put an "X" for closing the current tab if there are several. */
if (first_tabpage->tp_next != NULL) {
screen_putchar('X', 0, (int)Columns - 1, attr_nosel);
TabPageIdxs[Columns - 1] = -999;
tab_page_click_defs[Columns - 1] = (StlClickDefinition) {
.type = kStlClickTabClose,
.tabnr = 999,
.func = NULL,
};
}
}

23
src/nvim/screen.h
View File

@ -16,6 +16,29 @@
#define NOT_VALID 40 /* buffer needs complete redraw */
#define CLEAR 50 /* screen messed up, clear it */
/// Status line click definition
typedef struct {
enum {
kStlClickDisabled = 0, ///< Clicks to this area are ignored.
kStlClickTabSwitch, ///< Switch to the given tab.
kStlClickTabClose, ///< Close given tab.
kStlClickFuncRun, ///< Run user function.
} type; ///< Type of the click.
int tabnr; ///< Tab page number.
char *func; ///< Function to run.
} StlClickDefinition;
/// Used for tabline clicks
typedef struct {
StlClickDefinition def; ///< Click definition.
const char *start; ///< Location where region starts.
} StlClickRecord;
/// Array defining what should be done when tabline is clicked
extern StlClickDefinition *tab_page_click_defs;
/// Size of the tab_page_click_defs array
extern long tab_page_click_defs_size;
#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "screen.h.generated.h"

169
test/functional/ui/mouse_spec.lua
View File

@ -1,7 +1,8 @@
local helpers = require('test.functional.helpers')
local Screen = require('test.functional.ui.screen')
local clear, feed, nvim = helpers.clear, helpers.feed, helpers.nvim
local clear, feed, meths = helpers.clear, helpers.feed, helpers.meths
local insert, execute = helpers.insert, helpers.execute
local eq, funcs = helpers.eq, helpers.funcs
describe('Mouse input', function()
local screen
@ -13,11 +14,11 @@ describe('Mouse input', function()
before_each(function()
clear()
nvim('set_option', 'mouse', 'a')
nvim('set_option', 'listchars', 'eol:$')
meths.set_option('mouse', 'a')
meths.set_option('listchars', 'eol:$')
-- set mouset to very high value to ensure that even in valgrind/travis,
-- nvim will still pick multiple clicks
nvim('set_option', 'mouset', 5000)
meths.set_option('mouset', 5000)
screen = Screen.new(25, 5)
screen:attach()
screen:set_default_attr_ids({
@ -58,31 +59,149 @@ describe('Mouse input', function()
]])
end)
it('left click in tabline switches to tab', function()
describe('tabline', function()
local tab_attrs = {
tab = { background=Screen.colors.LightGrey, underline=true },
sel = { bold=true },
fill = { reverse=true }
}
execute('%delete')
insert('this is foo')
execute('silent file foo | tabnew | file bar')
insert('this is bar')
screen:expect([[
{tab: + foo }{sel: + bar }{fill: }{tab:X}|
this is ba^r |
~ |
~ |
|
]], tab_attrs)
feed('<LeftMouse><4,0>')
screen:expect([[
{sel: + foo }{tab: + bar }{fill: }{tab:X}|
this is fo^o |
~ |
~ |
|
]], tab_attrs)
it('left click in default tabline (position 4) switches to tab', function()
execute('%delete')
insert('this is foo')
execute('silent file foo | tabnew | file bar')
insert('this is bar')
screen:expect([[
{tab: + foo }{sel: + bar }{fill: }{tab:X}|
this is ba^r |
~ |
~ |
|
]], tab_attrs)
feed('<LeftMouse><4,0>')
screen:expect([[
{sel: + foo }{tab: + bar }{fill: }{tab:X}|
this is fo^o |
~ |
~ |
|
]], tab_attrs)
end)
it('left click in default tabline (position 24) closes tab', function()
meths.set_option('hidden', true)
execute('%delete')
insert('this is foo')
execute('silent file foo | tabnew | file bar')
insert('this is bar')
screen:expect([[
{tab: + foo }{sel: + bar }{fill: }{tab:X}|
this is ba^r |
~ |
~ |
|
]], tab_attrs)
feed('<LeftMouse><24,0>')
screen:expect([[
this is fo^o |
~ |
~ |
~ |
|
]], tab_attrs)
end)
it('double click in default tabline (position 4) opens new tab', function()
meths.set_option('hidden', true)
execute('%delete')
insert('this is foo')
execute('silent file foo | tabnew | file bar')
insert('this is bar')
screen:expect([[
{tab: + foo }{sel: + bar }{fill: }{tab:X}|
this is ba^r |
~ |
~ |
|
]], tab_attrs)
feed('<2-LeftMouse><4,0>')
screen:expect([[
{sel: Name] }{tab: + foo + bar }{fill: }{tab:X}|
^ |
~ |
~ |
|
]], tab_attrs)
end)
describe('%@ label', function()
before_each(function()
execute([[
function Test(...)
let g:reply = a:000
return copy(a:000) " Check for memory leaks: return should be freed
endfunction
]])
execute([[
function Test2(...)
return call('Test', a:000 + [2])
endfunction
]])
meths.set_option('tabline', '%@Test@test%X-%5@Test2@test2')
meths.set_option('showtabline', 2)
screen:expect([[
{fill:test-test2 }|
mouse |
support and selectio^n |
~ |
|
]], tab_attrs)
meths.set_var('reply', {})
end)
local check_reply = function(expected)
eq(expected, meths.get_var('reply'))
meths.set_var('reply', {})
end
local test_click = function(name, click_str, click_num, mouse_button,
modifiers)
it(name .. ' works', function()
eq(1, funcs.has('tablineat'))
feed(click_str .. '<3,0>')
check_reply({0, click_num, mouse_button, modifiers})
feed(click_str .. '<4,0>')
check_reply({})
feed(click_str .. '<6,0>')
check_reply({5, click_num, mouse_button, modifiers, 2})
feed(click_str .. '<13,0>')
check_reply({5, click_num, mouse_button, modifiers, 2})
end)
end
test_click('single left click', '<LeftMouse>', 1, 'l', ' ')
test_click('shifted single left click', '<S-LeftMouse>', 1, 'l', 's ')
test_click('shifted single left click with alt modifier',
'<S-A-LeftMouse>', 1, 'l', 's a ')
test_click('shifted single left click with alt and ctrl modifiers',
'<S-C-A-LeftMouse>', 1, 'l', 'sca ')
-- <C-RightMouse> does not work
test_click('shifted single right click with alt modifier',
'<S-A-RightMouse>', 1, 'r', 's a ')
-- Modifiers do not work with MiddleMouse
test_click('shifted single middle click with alt and ctrl modifiers',
'<MiddleMouse>', 1, 'm', ' ')
-- Modifiers do not work with N-*Mouse
test_click('double left click', '<2-LeftMouse>', 2, 'l', ' ')
test_click('triple left click', '<3-LeftMouse>', 3, 'l', ' ')
test_click('quadruple left click', '<4-LeftMouse>', 4, 'l', ' ')
test_click('double right click', '<2-RightMouse>', 2, 'r', ' ')
test_click('triple right click', '<3-RightMouse>', 3, 'r', ' ')
test_click('quadruple right click', '<4-RightMouse>', 4, 'r', ' ')
test_click('double middle click', '<2-MiddleMouse>', 2, 'm', ' ')
test_click('triple middle click', '<3-MiddleMouse>', 3, 'm', ' ')
test_click('quadruple middle click', '<4-MiddleMouse>', 4, 'm', ' ')
end)
end)
it('left drag changes visual selection', function()
@ -211,7 +330,7 @@ describe('Mouse input', function()
end)
it('ctrl + left click will search for a tag', function()
nvim('set_option', 'tags', './non-existent-tags-file')
meths.set_option('tags', './non-existent-tags-file')
feed('<C-LeftMouse><0,0>')
screen:expect([[
E433: No tags file |