mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2026-08-28 10:01:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #9726 from mhinz/nvim_win_get_config

Browse Source 
Closes #9723
This commit is contained in:
Marco Hinz
2019-03-17 02:34:50 +01:00
committed by GitHub
parent 7c38994ff2 b557654f36
commit 9ef8d0d6b0
7 changed files with 272 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
src/nvim/api/vim.c
View File

@@ -1003,35 +1003,35 @@ Buffer nvim_create_buf(Boolean listed, Boolean scratch, Error *err)
/// Exactly one of `external` and `relative` must be specified.
///
/// @param buffer handle of buffer to be displayed in the window
/// @param enter whether the window should be entered (made the current window)
/// @param width width of window (in character cells)
/// @param height height of window (in character cells)
/// @param options dict of options for configuring window positioning
/// accepts the following keys:
/// @param enter whether the window should be entered (made the current window)
/// @param config dictionary for the window configuration accepts these keys:
///
/// `relative`: If set, the window becomes a floating window. The window
/// will be placed with row,col coordinates relative one of the
/// following:
/// "editor" the global editor grid
/// "win" a window. Use 'win' option below to specify window id,
/// or current window will be used by default.
/// "win" a window. Use `win` to specify a window id,
/// or the current window will be used by default.
/// "cursor" the cursor position in current window.
/// `anchor`: the corner of the float that the row,col position defines
/// `win`: When using relative='win', window id of the window where the
/// position is defined.
/// `anchor`: The corner of the float that the row,col position defines:
/// "NW" north-west (default)
/// "NE" north-east
/// "SW" south-west
/// "SE" south-east
/// `focusable`: Whether window can be focused by wincmds and
/// mouse events. Defaults to true. Even if set to false, the window
/// can still be entered using |nvim_set_current_win()| API call.
/// `row`: row position. Screen cell height are used as unit. Can be
/// `height`: window height (in character cells). Minimum of 1.
/// `width`: window width (in character cells). Minimum of 2.
/// `row`: row position. Screen cell height are used as unit. Can be
/// floating point.
/// `col`: column position. Screen cell width is used as unit. Can be
/// floating point.
/// `win`: when using relative='win', window id of the window where the
/// position is defined.
/// `external` GUI should display the window as an external
/// top-level window. Currently accepts no other positioning options
/// together with this.
/// `focusable`: Whether window can be focused by wincmds and
/// mouse events. Defaults to true. Even if set to false, the window
/// can still be entered using |nvim_set_current_win()| API call.
/// `external`: GUI should display the window as an external
/// top-level window. Currently accepts no other positioning
/// configuration together with this.
///
/// With editor positioning row=0, col=0 refers to the top-left corner of the
/// screen-grid and row=Lines-1, Columns-1 refers to the bottom-right corner.
@@ -1047,16 +1047,15 @@ Buffer nvim_create_buf(Boolean listed, Boolean scratch, Error *err)
///
/// @param[out] err Error details, if any
/// @return the window handle or 0 when error
Window nvim_open_win(Buffer buffer, Boolean enter,
Integer width, Integer height,
Dictionary options, Error *err)
Window nvim_open_win(Buffer buffer, Boolean enter, Dictionary config,
Error *err)
FUNC_API_SINCE(6)
{
FloatConfig config = FLOAT_CONFIG_INIT;
if (!parse_float_config(options, &config, false, err)) {
FloatConfig fconfig = FLOAT_CONFIG_INIT;
if (!parse_float_config(config, &fconfig, false, err)) {
return 0;
}
win_T *wp = win_new_float(NULL, (int)width, (int)height, config, err);
win_T *wp = win_new_float(NULL, fconfig, err);
if (!wp) {
return 0;
}

67
src/nvim/api/window.c
View File

@@ -438,14 +438,16 @@ Boolean nvim_win_is_valid(Window window)
/// floating and external windows (including changing a split window to these
/// types).
///
/// See documentation at |nvim_open_win()|, for the meaning of parameters. Pass
/// in -1 for 'witdh' and 'height' to keep exiting size.
/// See documentation at |nvim_open_win()|, for the meaning of parameters.
///
/// When reconfiguring a floating window, absent option keys will not be
/// changed. The following restriction apply: `row`, `col` and `relative`
/// must be reconfigured together. Only changing a subset of these is an error.
void nvim_win_config(Window window, Integer width, Integer height,
Dictionary options, Error *err)
///
/// @param window Window handle
/// @param config Dictionary of window configuration
/// @param[out] err Error details, if any
void nvim_win_set_config(Window window, Dictionary config, Error *err)
FUNC_API_SINCE(6)
{
win_T *win = find_window_by_handle(window, err);
@@ -453,25 +455,70 @@ void nvim_win_config(Window window, Integer width, Integer height,
return;
}
bool new_float = !win->w_floating;
width = width > 0 ? width: win->w_width;
height = height > 0 ? height : win->w_height;
// reuse old values, if not overriden
FloatConfig config = new_float ? FLOAT_CONFIG_INIT : win->w_float_config;
FloatConfig fconfig = new_float ? FLOAT_CONFIG_INIT : win->w_float_config;
if (!parse_float_config(options, &config, !new_float, err)) {
if (!parse_float_config(config, &fconfig, !new_float, err)) {
return;
}
fconfig.height = fconfig.height > 0 ? fconfig.height : win->w_height;
fconfig.width = fconfig.width > 0 ? fconfig.width : win->w_width;
if (new_float) {
if (!win_new_float(win, (int)width, (int)height, config, err)) {
if (!win_new_float(win, fconfig, err)) {
return;
}
redraw_later(NOT_VALID);
} else {
win_config_float(win, (int)width, (int)height, config);
win_config_float(win, fconfig);
win->w_pos_changed = true;
}
}
/// Return window configuration.
///
/// Return a dictionary containing the same config that can be given to
/// |nvim_open_win()|.
///
/// `relative` will be an empty string for normal windows.
///
/// @param window Window handle
/// @param[out] err Error details, if any
/// @return Window configuration
Dictionary nvim_win_get_config(Window window, Error *err)
FUNC_API_SINCE(6)
{
Dictionary rv = ARRAY_DICT_INIT;
win_T *wp = find_window_by_handle(window, err);
if (!wp) {
return rv;
}
PUT(rv, "width", INTEGER_OBJ(wp->w_float_config.width));
PUT(rv, "height", INTEGER_OBJ(wp->w_float_config.height));
PUT(rv, "focusable", BOOLEAN_OBJ(wp->w_float_config.focusable));
PUT(rv, "external", BOOLEAN_OBJ(wp->w_float_config.external));
PUT(rv, "anchor", STRING_OBJ(cstr_to_string(
float_anchor_str[wp->w_float_config.anchor])));
if (wp->w_float_config.relative == kFloatRelativeWindow) {
PUT(rv, "win", INTEGER_OBJ(wp->w_float_config.window));
}
if (wp->w_float_config.external) {
return rv;
}
PUT(rv, "row", FLOAT_OBJ(wp->w_float_config.row));
PUT(rv, "col", FLOAT_OBJ(wp->w_float_config.col));
const char *rel =
wp->w_floating ? float_relative_str[wp->w_float_config.relative] : "";
PUT(rv, "relative", STRING_OBJ(cstr_to_string(rel)));
return rv;
}
/// Close a window.
///
/// This is equivalent to |:close| with count except that it takes a window id.

37
src/nvim/buffer_defs.h
View File

@@ -958,24 +958,32 @@ struct matchitem {
int conceal_char; ///< cchar for Conceal highlighting
};
typedef enum {
kFloatAnchorEast = 1,
kFloatAnchorSouth = 2,
typedef int FloatAnchor;
typedef int FloatRelative;
kFloatAnchorNW = 0,
kFloatAnchorNE = 1,
kFloatAnchorSW = 2,
kFloatAnchorSE = 3,
} FloatAnchor;
enum {
kFloatAnchorEast = 1,
kFloatAnchorSouth = 2,
};
typedef enum {
kFloatRelativeEditor = 0,
kFloatRelativeWindow = 1,
kFloatRelativeCursor = 2,
} FloatRelative;
// NW -> 0
// NE -> kFloatAnchorEast
// SW -> kFloatAnchorSouth
// SE -> kFloatAnchorSouth | kFloatAnchorEast
EXTERN const char *const float_anchor_str[] INIT(= { "NW", "NE", "SW", "SE" });
enum {
kFloatRelativeEditor = 0,
kFloatRelativeWindow = 1,
kFloatRelativeCursor = 2,
};
EXTERN const char *const float_relative_str[] INIT(= { "editor", "window",
"cursor" });
typedef struct {
Window window;
int height, width;
double row, col;
FloatAnchor anchor;
FloatRelative relative;
@@ -983,7 +991,8 @@ typedef struct {
bool focusable;
} FloatConfig;
#define FLOAT_CONFIG_INIT ((FloatConfig){ .row = 0, .col = 0, .anchor = 0, \
#define FLOAT_CONFIG_INIT ((FloatConfig){ .height = 0, .width = 0, \
.row = 0, .col = 0, .anchor = 0, \
.relative = 0, .external = false, \
.focusable = true })

4
src/nvim/ui.c
View File

@@ -460,7 +460,9 @@ void ui_grid_resize(handle_T grid_handle, int width, int height, Error *error)
if (wp->w_floating) {
if (width != wp->w_width && height != wp->w_height) {
win_config_float(wp, (int)width, (int)height, wp->w_float_config);
wp->w_float_config.width = width;
wp->w_float_config.height = height;
win_config_float(wp, wp->w_float_config);
}
} else {
// non-positive indicates no request

152
src/nvim/window.c
View File

@@ -502,10 +502,11 @@ wingotofile:
break;
}
FloatConfig config = FLOAT_CONFIG_INIT;
config.width = curwin->w_width;
config.height = curwin->w_height;
config.external = true;
Error err = ERROR_INIT;
if (!win_new_float(curwin, curwin->w_width, curwin->w_height, config,
&err)) {
if (!win_new_float(curwin, config, &err)) {
EMSG(err.msg);
api_clear_error(&err);
beep_flush();
@@ -538,8 +539,7 @@ static void cmd_with_count(char *cmd, char_u *bufp, size_t bufsize,
/// float. It must then already belong to the current tabpage!
///
/// config must already have been validated!
win_T *win_new_float(win_T *wp, int width, int height, FloatConfig config,
Error *err)
win_T *win_new_float(win_T *wp, FloatConfig fconfig, Error *err)
{
if (wp == NULL) {
wp = win_alloc(lastwin_nofloating(), false);
@@ -571,27 +571,26 @@ win_T *win_new_float(win_T *wp, int width, int height, FloatConfig config,
// TODO(bfredl): use set_option_to() after merging #9110 ?
wp->w_p_nu = false;
wp->w_allbuf_opt.wo_nu = false;
win_config_float(wp, width, height, config);
win_config_float(wp, fconfig);
wp->w_pos_changed = true;
redraw_win_later(wp, VALID);
return wp;
}
void win_config_float(win_T *wp, int width, int height,
FloatConfig config)
void win_config_float(win_T *wp, FloatConfig fconfig)
{
wp->w_height = MAX(height, 1);
wp->w_width = MAX(width, 2);
wp->w_width = MAX(fconfig.width, 2);
wp->w_height = MAX(fconfig.height, 1);
if (config.relative == kFloatRelativeCursor) {
config.relative = kFloatRelativeWindow;
config.row += curwin->w_wrow;
config.col += curwin->w_wcol;
config.window = curwin->handle;
if (fconfig.relative == kFloatRelativeCursor) {
fconfig.relative = kFloatRelativeWindow;
fconfig.row += curwin->w_wrow;
fconfig.col += curwin->w_wcol;
fconfig.window = curwin->handle;
}
bool change_external = config.external != wp->w_float_config.external;
wp->w_float_config = config;
bool change_external = fconfig.external != wp->w_float_config.external;
wp->w_float_config = fconfig;
if (!ui_has(kUIMultigrid)) {
wp->w_height = MIN(wp->w_height, Rows-1);
@@ -614,12 +613,6 @@ static void ui_ext_win_position(win_T *wp)
wp->w_wincol, wp->w_width, wp->w_height);
return;
}
const char *const anchor_str[] = {
"NW",
"NE",
"SW",
"SE"
};
FloatConfig c = wp->w_float_config;
if (!c.external) {
@@ -635,7 +628,7 @@ static void ui_ext_win_position(win_T *wp)
api_clear_error(&dummy);
}
if (ui_has(kUIMultigrid)) {
String anchor = cstr_to_string(anchor_str[c.anchor]);
String anchor = cstr_to_string(float_anchor_str[c.anchor]);
ui_call_win_float_pos(wp->w_grid.handle, wp->handle, anchor, grid->handle,
row, col, c.focusable);
} else {
@@ -672,14 +665,14 @@ static bool parse_float_anchor(String anchor, FloatAnchor *out)
*out = (FloatAnchor)0;
}
char *str = anchor.data;
if (!STRICMP(str, "NW")) {
*out = kFloatAnchorNW;
} else if (!STRICMP(str, "NE")) {
*out = kFloatAnchorNE;
} else if (!STRICMP(str, "SW")) {
*out = kFloatAnchorSW;
} else if (!STRICMP(str, "SE")) {
*out = kFloatAnchorSE;
if (striequal(str, "NW")) {
*out = 0; // NW is the default
} else if (striequal(str, "NE")) {
*out = kFloatAnchorEast;
} else if (striequal(str, "SW")) {
*out = kFloatAnchorSouth;
} else if (striequal(str, "SE")) {
*out = kFloatAnchorSouth | kFloatAnchorEast;
} else {
return false;
}
@@ -692,11 +685,11 @@ static bool parse_float_relative(String relative, FloatRelative *out)
*out = (FloatRelative)0;
}
char *str = relative.data;
if (!STRICMP(str, "editor")) {
if (striequal(str, "editor")) {
*out = kFloatRelativeEditor;
} else if (!STRICMP(str, "win")) {
} else if (striequal(str, "win")) {
*out = kFloatRelativeWindow;
} else if (!STRICMP(str, "cursor")) {
} else if (striequal(str, "cursor")) {
*out = kFloatRelativeCursor;
} else {
return false;
@@ -704,7 +697,7 @@ static bool parse_float_relative(String relative, FloatRelative *out)
return true;
}
bool parse_float_config(Dictionary config, FloatConfig *out, bool reconf,
bool parse_float_config(Dictionary config, FloatConfig *fconfig, bool reconf,
Error *err)
{
bool has_row = false, has_col = false, has_relative = false;
@@ -716,46 +709,62 @@ bool parse_float_config(Dictionary config, FloatConfig *out, bool reconf,
if (!strcmp(key, "row")) {
has_row = true;
if (val.type == kObjectTypeInteger) {
out->row = val.data.integer;
fconfig->row = val.data.integer;
} else if (val.type == kObjectTypeFloat) {
out->row = val.data.floating;
fconfig->row = val.data.floating;
} else {
api_set_error(err, kErrorTypeValidation,
"'row' option has to be Integer or Float");
"'row' key must be Integer or Float");
return false;
}
} else if (!strcmp(key, "col")) {
has_col = true;
if (val.type == kObjectTypeInteger) {
out->col = val.data.integer;
fconfig->col = val.data.integer;
} else if (val.type == kObjectTypeFloat) {
out->col = val.data.floating;
fconfig->col = val.data.floating;
} else {
api_set_error(err, kErrorTypeValidation,
"'col' option has to be Integer or Float");
"'col' key must be Integer or Float");
return false;
}
} else if (strequal(key, "width")) {
if (val.type == kObjectTypeInteger && val.data.integer >= 0) {
fconfig->width = val.data.integer;
} else {
api_set_error(err, kErrorTypeValidation,
"'width' key must be a positive Integer");
return false;
}
} else if (strequal(key, "height")) {
if (val.type == kObjectTypeInteger && val.data.integer >= 0) {
fconfig->height= val.data.integer;
} else {
api_set_error(err, kErrorTypeValidation,
"'height' key must be a positive Integer");
return false;
}
} else if (!strcmp(key, "anchor")) {
if (val.type != kObjectTypeString) {
api_set_error(err, kErrorTypeValidation,
"'anchor' option has to be String");
"'anchor' key must be String");
return false;
}
if (!parse_float_anchor(val.data.string, &out->anchor)) {
if (!parse_float_anchor(val.data.string, &fconfig->anchor)) {
api_set_error(err, kErrorTypeValidation,
"Invalid value of 'anchor' option");
"Invalid value of 'anchor' key");
return false;
}
} else if (!strcmp(key, "relative")) {
has_relative = true;
if (val.type != kObjectTypeString) {
api_set_error(err, kErrorTypeValidation,
"'relative' option has to be String");
"'relative' key must be String");
return false;
}
if (!parse_float_relative(val.data.string, &out->relative)) {
if (!parse_float_relative(val.data.string, &fconfig->relative)) {
api_set_error(err, kErrorTypeValidation,
"Invalid value of 'relative' option");
"Invalid value of 'relative' key");
return false;
}
} else if (!strcmp(key, "win")) {
@@ -763,62 +772,63 @@ bool parse_float_config(Dictionary config, FloatConfig *out, bool reconf,
if (val.type != kObjectTypeInteger
&& val.type != kObjectTypeWindow) {
api_set_error(err, kErrorTypeValidation,
"'win' option has to be Integer or Window");
"'win' key must be Integer or Window");
return false;
}
out->window = val.data.integer;
fconfig->window = val.data.integer;
} else if (!strcmp(key, "external")) {
if (val.type == kObjectTypeInteger) {
out->external = val.data.integer;
fconfig->external = val.data.integer;
} else if (val.type == kObjectTypeBoolean) {
out->external = val.data.boolean;
fconfig->external = val.data.boolean;
} else {
api_set_error(err, kErrorTypeValidation,
"'external' option has to be Boolean");
"'external' key must be Boolean");
return false;
}
has_external = out->external;
has_external = fconfig->external;
} else if (!strcmp(key, "focusable")) {
if (val.type == kObjectTypeInteger) {
out->focusable = val.data.integer;
fconfig->focusable = val.data.integer;
} else if (val.type == kObjectTypeBoolean) {
out->focusable = val.data.boolean;
fconfig->focusable = val.data.boolean;
} else {
api_set_error(err, kErrorTypeValidation,
"'focusable' option has to be Boolean");
"'focusable' key must be Boolean");
return false;
}
} else {
api_set_error(err, kErrorTypeValidation,
"Invalid options key '%s'", key);
"Invalid key '%s'", key);
return false;
}
}
if (has_window && !(has_relative && out->relative == kFloatRelativeWindow)) {
if (has_window && !(has_relative
&& fconfig->relative == kFloatRelativeWindow)) {
api_set_error(err, kErrorTypeValidation,
"'win' option is only valid with relative='win'");
"'win' key is only valid with relative='win'");
return false;
}
if ((has_relative && out->relative == kFloatRelativeWindow)
&& (!has_window || out->window == 0)) {
out->window = curwin->handle;
if ((has_relative && fconfig->relative == kFloatRelativeWindow)
&& (!has_window || fconfig->window == 0)) {
fconfig->window = curwin->handle;
}
if (has_relative && has_external) {
api_set_error(err, kErrorTypeValidation,
"Only one of 'relative' and 'external' should be used");
"Only one of 'relative' and 'external' must be used");
return false;
} else if (!reconf && !has_relative && !has_external) {
api_set_error(err, kErrorTypeValidation,
"One of 'relative' and 'external' must be used");
return false;
} else if (has_relative) {
out->external = false;
fconfig->external = false;
}
if (out->external && !ui_has(kUIMultigrid)) {
if (fconfig->external && !ui_has(kUIMultigrid)) {
api_set_error(err, kErrorTypeValidation,
"UI doesn't support external windows");
return false;
@@ -3810,7 +3820,7 @@ static void tabpage_check_windows(tabpage_T *old_curtab)
for (win_T *wp = firstwin; wp; wp = wp->w_next) {
if (wp->w_floating && !wp->w_float_config.external) {
win_config_float(wp, wp->w_width, wp->w_height, wp->w_float_config);
win_config_float(wp, wp->w_float_config);
}
wp->w_pos_changed = true;
}
@@ -4670,7 +4680,9 @@ int win_comp_pos(void)
// Too often, but when we support anchoring floats to split windows,
// this will be needed
for (win_T *wp = lastwin; wp && wp->w_floating; wp = wp->w_prev) {
win_config_float(wp, wp->w_width, wp->w_height, wp->w_float_config);
wp->w_float_config.width = wp->w_width;
wp->w_float_config.height = wp->w_height;
win_config_float(wp, wp->w_float_config);
}
return row;
@@ -4743,7 +4755,8 @@ void win_setheight_win(int height, win_T *win)
if (win->w_floating) {
if (win->w_float_config.external) {
win_config_float(win, win->w_width, height, win->w_float_config);
win->w_float_config.height = height;
win_config_float(win, win->w_float_config);
} else {
beep_flush();
return;
@@ -4948,7 +4961,8 @@ void win_setwidth_win(int width, win_T *wp)
}
if (wp->w_floating) {
if (wp->w_float_config.external) {
win_config_float(wp, width, wp->w_height, wp->w_float_config);
wp->w_float_config.width = width;
win_config_float(wp, wp->w_float_config);
} else {
beep_flush();
return;