Merge pull request #9726 from mhinz/nvim_win_get_config

Closes #9723

5 files changed, 190 insertions, 119 deletions

diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index a773234ea0..ae8404a530 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -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;
   }
diff --git a/src/nvim/api/window.c b/src/nvim/api/window.c
index 157f73c9fa..2204170aab 100644
--- a/src/nvim/api/window.c
+++ b/src/nvim/api/window.c
@@ -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.
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index d35e3b49d8..2f2546b360 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -958,24 +958,32 @@ struct matchitem {
   int conceal_char;         ///< cchar for Conceal highlighting
 };
 
-typedef enum {
-    kFloatAnchorEast = 1,
-    kFloatAnchorSouth = 2,
-
-    kFloatAnchorNW = 0,
-    kFloatAnchorNE = 1,
-    kFloatAnchorSW = 2,
-    kFloatAnchorSE = 3,
-} FloatAnchor;
-
-typedef enum {
-    kFloatRelativeEditor = 0,
-    kFloatRelativeWindow = 1,
-    kFloatRelativeCursor = 2,
-} FloatRelative;
+typedef int FloatAnchor;
+typedef int FloatRelative;
+
+enum {
+  kFloatAnchorEast  = 1,
+  kFloatAnchorSouth = 2,
+};
+
+// 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 })
 
diff --git a/src/nvim/ui.c b/src/nvim/ui.c
index d07ea3179e..0dddfe5f59 100644
--- a/src/nvim/ui.c
+++ b/src/nvim/ui.c
@@ -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
diff --git a/src/nvim/window.c b/src/nvim/window.c
index edb5b06a2e..609d8f1b4f 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -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;