aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/nvim/api/private/helpers.c4
-rw-r--r--src/nvim/api/ui.c2
-rw-r--r--src/nvim/api/ui_events.in.h9
-rw-r--r--src/nvim/api/vim.c78
-rw-r--r--src/nvim/api/window.c38
-rw-r--r--src/nvim/buffer.c8
-rw-r--r--src/nvim/buffer_defs.h31
-rw-r--r--src/nvim/ex_docmd.c12
-rw-r--r--src/nvim/ex_getln.c10
-rw-r--r--src/nvim/globals.h4
-rw-r--r--src/nvim/grid_defs.h7
-rw-r--r--src/nvim/main.c1
-rw-r--r--src/nvim/memory.c7
-rw-r--r--src/nvim/message.c8
-rw-r--r--src/nvim/mouse.c31
-rw-r--r--src/nvim/normal.c2
-rw-r--r--src/nvim/os/input.c1
-rw-r--r--src/nvim/popupmnu.c25
-rw-r--r--src/nvim/popupmnu.h3
-rw-r--r--src/nvim/screen.c77
-rw-r--r--src/nvim/tui/tui.c1
-rw-r--r--src/nvim/ui.c32
-rw-r--r--src/nvim/ui.h3
-rw-r--r--src/nvim/ui_compositor.c113
-rw-r--r--src/nvim/window.c652
25 files changed, 969 insertions, 190 deletions
diff --git a/src/nvim/api/private/helpers.c b/src/nvim/api/private/helpers.c
index 19a3368c1c..c2b382804d 100644
--- a/src/nvim/api/private/helpers.c
+++ b/src/nvim/api/private/helpers.c
@@ -1004,7 +1004,9 @@ static void init_ui_event_metadata(Dictionary *metadata)
Array ui_options = ARRAY_DICT_INIT;
ADD(ui_options, STRING_OBJ(cstr_to_string("rgb")));
for (UIExtension i = 0; i < kUIExtCount; i++) {
- ADD(ui_options, STRING_OBJ(cstr_to_string(ui_ext_names[i])));
+ if (ui_ext_names[i][0] != '_') {
+ ADD(ui_options, STRING_OBJ(cstr_to_string(ui_ext_names[i])));
+ }
}
PUT(*metadata, "ui_options", ARRAY_OBJ(ui_options));
}
diff --git a/src/nvim/api/ui.c b/src/nvim/api/ui.c
index 9e9be588e3..d3cbb46dad 100644
--- a/src/nvim/api/ui.c
+++ b/src/nvim/api/ui.c
@@ -17,6 +17,8 @@
#include "nvim/popupmnu.h"
#include "nvim/cursor_shape.h"
#include "nvim/highlight.h"
+#include "nvim/screen.h"
+#include "nvim/window.h"
#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "api/ui.c.generated.h"
diff --git a/src/nvim/api/ui_events.in.h b/src/nvim/api/ui_events.in.h
index b57cf8d3ef..b89c5b6014 100644
--- a/src/nvim/api/ui_events.in.h
+++ b/src/nvim/api/ui_events.in.h
@@ -76,7 +76,7 @@ void hl_attr_define(Integer id, HlAttrs rgb_attrs, HlAttrs cterm_attrs,
void grid_resize(Integer grid, Integer width, Integer height)
FUNC_API_SINCE(5) FUNC_API_REMOTE_IMPL FUNC_API_COMPOSITOR_IMPL;
void grid_clear(Integer grid)
- FUNC_API_SINCE(5) FUNC_API_REMOTE_IMPL FUNC_API_COMPOSITOR_IMPL;
+ FUNC_API_SINCE(5) FUNC_API_REMOTE_IMPL;
void grid_cursor_goto(Integer grid, Integer row, Integer col)
FUNC_API_SINCE(5) FUNC_API_REMOTE_IMPL FUNC_API_COMPOSITOR_IMPL;
void grid_line(Integer grid, Integer row, Integer col_start, Array data)
@@ -101,8 +101,15 @@ void event(char *name, Array args, bool *args_consumed)
void win_pos(Integer grid, Integer win, Integer startrow,
Integer startcol, Integer width, Integer height)
FUNC_API_SINCE(6) FUNC_API_REMOTE_ONLY;
+void win_float_pos(Integer grid, Window win, String anchor, Integer anchor_grid,
+ Float anchor_row, Float anchor_col, Boolean focusable)
+ FUNC_API_SINCE(6) FUNC_API_REMOTE_ONLY;
+void win_external_pos(Integer grid, Window win)
+ FUNC_API_SINCE(6) FUNC_API_REMOTE_ONLY;
void win_hide(Integer grid)
FUNC_API_SINCE(6) FUNC_API_REMOTE_ONLY;
+void win_close(Integer grid)
+ FUNC_API_SINCE(6) FUNC_API_REMOTE_ONLY;
void win_scroll_over_start(void)
FUNC_API_SINCE(6) FUNC_API_BRIDGE_IMPL FUNC_API_COMPOSITOR_IMPL;
void win_scroll_over_reset(void)
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index 5a4d0a11e7..94d1697083 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -987,6 +987,84 @@ Buffer nvim_create_buf(Boolean listed, Boolean scratch, Error *err)
return buf->b_fnum;
}
+/// Open a new window.
+///
+/// Currently this is used to open floating and external windows.
+/// Floats are windows that are drawn above the split layout, at some anchor
+/// position in some other window. Floats can be draw internally or by external
+/// GUI with the |ui-multigrid| extension. External windows are only supported
+/// with multigrid GUIs, and are displayed as separate top-level windows.
+///
+/// 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:
+/// `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.
+/// "cursor" the cursor position in current window.
+/// `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
+/// 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.
+///
+/// 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.
+/// Floating point values are allowed, but the builtin implementation (used by
+/// TUI and GUIs without multigrid support) will always round down to nearest
+/// integer.
+///
+/// Out-of-bounds values, and configurations that make the float not fit inside
+/// the main editor, are allowed. The builtin implementation will truncate
+/// values so floats are completely within the main screen grid. External GUIs
+/// could let floats hover outside of the main window like a tooltip, but
+/// this should not be used to specify arbitrary WM screen positions.
+///
+/// @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)
+ FUNC_API_SINCE(6)
+{
+ win_T *old = curwin;
+ FloatConfig config = FLOAT_CONFIG_INIT;
+ if (!parse_float_config(options, &config, false, err)) {
+ return 0;
+ }
+ win_T *wp = win_new_float(NULL, (int)width, (int)height, config, err);
+ if (!wp) {
+ return 0;
+ }
+ if (buffer > 0) {
+ nvim_set_current_buf(buffer, err);
+ }
+ if (!enter) {
+ win_enter(old, false);
+ }
+ return wp->handle;
+}
+
/// Gets the current list of tabpage handles.
///
/// @return List of tabpage handles
diff --git a/src/nvim/api/window.c b/src/nvim/api/window.c
index 33857f95b7..e1d84cfc9e 100644
--- a/src/nvim/api/window.c
+++ b/src/nvim/api/window.c
@@ -432,3 +432,41 @@ Boolean nvim_win_is_valid(Window window)
return ret;
}
+
+/// Configure window position. Currently this is only used to configure
+/// 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.
+///
+/// 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)
+ FUNC_API_SINCE(6)
+{
+ win_T *win = find_window_by_handle(window, err);
+ if (!win) {
+ 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;
+
+ if (!parse_float_config(options, &config, !new_float, err)) {
+ return;
+ }
+ if (new_float) {
+ if (!win_new_float(win, (int)width, (int)height, config, err)) {
+ return;
+ }
+ redraw_later(NOT_VALID);
+ } else {
+ win_config_float(win, (int)width, (int)height, config);
+ win->w_pos_changed = true;
+ }
+}
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 6ae239c9c3..6e4e7afeb2 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -474,8 +474,8 @@ void close_buffer(win_T *win, buf_T *buf, int action, int abort_if_last)
return;
}
buf->b_locked--;
- if (abort_if_last && one_window()) {
- /* Autocommands made this the only window. */
+ if (abort_if_last && last_nonfloat(win)) {
+ // Autocommands made this the only window.
EMSG(_(e_auabort));
return;
}
@@ -491,8 +491,8 @@ void close_buffer(win_T *win, buf_T *buf, int action, int abort_if_last)
return;
}
buf->b_locked--;
- if (abort_if_last && one_window()) {
- /* Autocommands made this the only window. */
+ if (abort_if_last && last_nonfloat(win)) {
+ // Autocommands made this the only window.
EMSG(_(e_auabort));
return;
}
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index da1e3ce9c6..48cef9b1e7 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -958,6 +958,35 @@ 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 struct {
+ Window window;
+ double row, col;
+ FloatAnchor anchor;
+ FloatRelative relative;
+ bool external;
+ bool focusable;
+} FloatConfig;
+
+#define FLOAT_CONFIG_INIT ((FloatConfig){ .row = 0, .col = 0, .anchor = 0, \
+ .relative = 0, .external = false, \
+ .focusable = true })
+
/*
* Structure which contains all information that belongs to a window
*
@@ -1221,6 +1250,8 @@ struct window_S {
ScreenGrid w_grid; // the grid specific to the window
bool w_pos_changed; // true if window position changed
+ bool w_floating; ///< whether the window is floating
+ FloatConfig w_float_config;
/*
* w_fraction is the fractional row of the cursor within the window, from
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index bbec977c74..8f9af1c2ec 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -6279,6 +6279,9 @@ void tabpage_close(int forceit)
{
// First close all the windows but the current one. If that worked then
// close the last window in this tab, that will close it.
+ while (curwin->w_floating) {
+ ex_win_close(forceit, curwin, NULL);
+ }
if (!ONE_WINDOW) {
close_others(true, forceit);
}
@@ -6303,8 +6306,8 @@ void tabpage_close_other(tabpage_T *tp, int forceit)
/* Limit to 1000 windows, autocommands may add a window while we close
* one. OK, so I'm paranoid... */
while (++done < 1000) {
- sprintf((char *)prev_idx, "%i", tabpage_index(tp));
- wp = tp->tp_firstwin;
+ snprintf((char *)prev_idx, sizeof(prev_idx), "%i", tabpage_index(tp));
+ wp = tp->tp_lastwin;
ex_win_close(forceit, wp, tp);
/* Autocommands may delete the tab page under our fingers and we may
@@ -6325,6 +6328,7 @@ static void ex_only(exarg_T *eap)
{
win_T *wp;
int wnr;
+
if (eap->addr_count > 0) {
wnr = eap->line2;
for (wp = firstwin; --wnr > 0;) {
@@ -6333,6 +6337,10 @@ static void ex_only(exarg_T *eap)
else
wp = wp->w_next;
}
+ } else {
+ wp = curwin;
+ }
+ if (wp != curwin) {
win_goto(wp);
}
close_others(TRUE, eap->forceit);
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 27bd23a668..a50e18efce 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -3470,11 +3470,13 @@ void redrawcmd(void)
void compute_cmdrow(void)
{
- if (exmode_active || msg_scrolled != 0)
+ if (exmode_active || msg_scrolled != 0) {
cmdline_row = Rows - 1;
- else
- cmdline_row = lastwin->w_winrow + lastwin->w_height
- + lastwin->w_status_height;
+ } else {
+ win_T *wp = lastwin_nofloating();
+ cmdline_row = wp->w_winrow + wp->w_height
+ + wp->w_status_height;
+ }
}
static void cursorcmd(void)
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index 1e2c6eea59..52c5d65512 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -1048,6 +1048,10 @@ EXTERN char_u e_cmdmap_repeated[] INIT(=N_(
"E5521: <Cmd> mapping must end with <CR> before second <Cmd>"));
EXTERN char_u e_cmdmap_key[] INIT(=N_(
"E5522: <Cmd> mapping must not include %s key"));
+EXTERN char_u e_floatonly[] INIT(=N_(
+ "E5601: Cannot close window, only floating window would remain"));
+EXTERN char_u e_floatexchange[] INIT(=N_(
+ "E5602: Cannot exchange or rotate float"));
EXTERN char top_bot_msg[] INIT(= N_("search hit TOP, continuing at BOTTOM"));
diff --git a/src/nvim/grid_defs.h b/src/nvim/grid_defs.h
index d9ccdbbdab..38fc513baa 100644
--- a/src/nvim/grid_defs.h
+++ b/src/nvim/grid_defs.h
@@ -47,6 +47,9 @@ typedef struct {
int Rows;
int Columns;
+ // The state of the grid is valid. Otherwise it needs to be redrawn.
+ bool valid;
+
// offsets for the grid relative to the global screen
int row_offset;
int col_offset;
@@ -58,7 +61,7 @@ typedef struct {
bool comp_disabled;
} ScreenGrid;
-#define SCREEN_GRID_INIT { 0, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, \
- false }
+#define SCREEN_GRID_INIT { 0, NULL, NULL, NULL, NULL, 0, 0, false, 0, 0, 0, \
+ 0, 0, false }
#endif // NVIM_GRID_DEFS_H
diff --git a/src/nvim/main.c b/src/nvim/main.c
index 79513b1c21..5dffca95a2 100644
--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -46,6 +46,7 @@
#include "nvim/os/os_defs.h"
#include "nvim/path.h"
#include "nvim/profile.h"
+#include "nvim/popupmnu.h"
#include "nvim/quickfix.h"
#include "nvim/screen.h"
#include "nvim/state.h"
diff --git a/src/nvim/memory.c b/src/nvim/memory.c
index 0f402611df..4ed816b157 100644
--- a/src/nvim/memory.c
+++ b/src/nvim/memory.c
@@ -572,8 +572,13 @@ void free_all_mem(void)
p_ea = false;
if (first_tabpage->tp_next != NULL)
do_cmdline_cmd("tabonly!");
- if (!ONE_WINDOW)
+
+ if (!ONE_WINDOW) {
+ // to keep things simple, don't perform this
+ // ritual inside a float
+ curwin = firstwin;
do_cmdline_cmd("only!");
+ }
/* Free all spell info. */
spell_free_all();
diff --git a/src/nvim/message.c b/src/nvim/message.c
index 9a0a3565ea..b4aa333a48 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -2771,9 +2771,11 @@ void msg_ext_flush_showmode(void)
{
// Showmode messages doesn't interrupt normal message flow, so we use
// separate event. Still reuse the same chunking logic, for simplicity.
- msg_ext_emit_chunk();
- ui_call_msg_showmode(msg_ext_chunks);
- msg_ext_chunks = (Array)ARRAY_DICT_INIT;
+ if (ui_has(kUIMessages)) {
+ msg_ext_emit_chunk();
+ ui_call_msg_showmode(msg_ext_chunks);
+ msg_ext_chunks = (Array)ARRAY_DICT_INIT;
+ }
}
void msg_ext_clear(bool force)
diff --git a/src/nvim/mouse.c b/src/nvim/mouse.c
index 50dba92eca..6d1a517ce8 100644
--- a/src/nvim/mouse.c
+++ b/src/nvim/mouse.c
@@ -12,6 +12,7 @@
#include "nvim/screen.h"
#include "nvim/syntax.h"
#include "nvim/ui.h"
+#include "nvim/ui_compositor.h"
#include "nvim/os_unix.h"
#include "nvim/fold.h"
#include "nvim/diff.h"
@@ -441,12 +442,6 @@ win_T *mouse_find_win(int *gridp, int *rowp, int *colp)
return wp_grid;
}
- // TODO(bfredl): grid zero will have floats displayed on it, and will
- // be adjusted to float grids.
- if (*gridp == 0) {
- *gridp = DEFAULT_GRID_HANDLE;
- }
-
frame_T *fp;
fp = topframe;
@@ -478,15 +473,31 @@ win_T *mouse_find_win(int *gridp, int *rowp, int *colp)
return NULL;
}
-static win_T *mouse_find_grid_win(int *grid, int *rowp, int *colp)
+static win_T *mouse_find_grid_win(int *gridp, int *rowp, int *colp)
{
- if (*grid > 1) {
- win_T *wp = get_win_by_grid_handle(*grid);
- if (wp && wp->w_grid.chars) {
+ if (*gridp > 1) {
+ win_T *wp = get_win_by_grid_handle(*gridp);
+ if (wp && wp->w_grid.chars
+ && !(wp->w_floating && !wp->w_float_config.focusable)) {
*rowp = MIN(*rowp, wp->w_grid.Rows-1);
*colp = MIN(*colp, wp->w_grid.Columns-1);
return wp;
}
+ } else if (*gridp == 0) {
+ ScreenGrid *grid = ui_comp_mouse_focus(*rowp, *colp);
+ FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
+ if (&wp->w_grid != grid || !wp->w_float_config.focusable) {
+ continue;
+ }
+ *gridp = grid->handle;
+ *rowp -= grid->comp_row;
+ *colp -= grid->comp_col;
+ return wp;
+ }
+
+ // no float found, click on the default grid
+ // TODO(bfredl): grid can be &pum_grid, allow select pum items by mouse?
+ *gridp = DEFAULT_GRID_HANDLE;
}
return NULL;
}
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index d857d1a79e..49eef72a05 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -2200,6 +2200,7 @@ do_mouse (
* one. Speeds up dragging the status line. */
if (vpeekc() != NUL) {
int nc;
+ int save_mouse_grid = mouse_grid;
int save_mouse_row = mouse_row;
int save_mouse_col = mouse_col;
@@ -2209,6 +2210,7 @@ do_mouse (
if (c == nc)
continue;
vungetc(nc);
+ mouse_grid = save_mouse_grid;
mouse_row = save_mouse_row;
mouse_col = save_mouse_col;
}
diff --git a/src/nvim/os/input.c b/src/nvim/os/input.c
index 5e2c9ecb36..8070f4c420 100644
--- a/src/nvim/os/input.c
+++ b/src/nvim/os/input.c
@@ -331,7 +331,6 @@ static unsigned int handle_mouse_event(char **ptr, uint8_t *buf,
uint8_t modifiers = check_multiclick(mouse_code, mouse_grid,
mouse_row, mouse_col);
-
if (modifiers) {
if (buf[1] != KS_MODIFIER) {
// no modifiers in the buffer yet, shift the bytes 3 positions
diff --git a/src/nvim/popupmnu.c b/src/nvim/popupmnu.c
index 3c10b7ae0f..499ee11cad 100644
--- a/src/nvim/popupmnu.c
+++ b/src/nvim/popupmnu.c
@@ -38,16 +38,16 @@ static int pum_base_width; // width of pum items base
static int pum_kind_width; // width of pum items kind column
static int pum_scrollbar; // TRUE when scrollbar present
+static int pum_anchor_grid; // grid where position is defined
static int pum_row; // top row of pum
static int pum_col; // left column of pum
+static bool pum_above; // pum is drawn above cursor line
static bool pum_is_visible = false;
static bool pum_is_drawn = false;
static bool pum_external = false;
static bool pum_invalid = false; // the screen was just cleared
-static ScreenGrid pum_grid = SCREEN_GRID_INIT;
-
#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "popupmnu.c.generated.h"
#endif
@@ -103,9 +103,9 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed)
col = curwin->w_wcol;
}
- int grid = (int)curwin->w_grid.handle;
+ pum_anchor_grid = (int)curwin->w_grid.handle;
if (!ui_has(kUIMultigrid)) {
- grid = (int)default_grid.handle;
+ pum_anchor_grid = (int)default_grid.handle;
row += curwin->w_winrow;
col += curwin->w_wincol;
}
@@ -121,7 +121,7 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed)
ADD(item, STRING_OBJ(cstr_to_string((char *)array[i].pum_info)));
ADD(arr, ARRAY_OBJ(item));
}
- ui_call_popupmenu_show(arr, selected, row, col, grid);
+ ui_call_popupmenu_show(arr, selected, row, col, pum_anchor_grid);
} else {
ui_call_popupmenu_select(selected);
}
@@ -165,6 +165,7 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed)
if (row + 2 >= below_row - pum_height
&& row - above_row > (below_row - above_row) / 2) {
// pum above "row"
+ pum_above = true;
// Leave two lines of context if possible
if (curwin->w_wrow - curwin->w_cline_row >= 2) {
@@ -187,6 +188,7 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed)
}
} else {
// pum below "row"
+ pum_above = false;
// Leave two lines of context if possible
if (curwin->w_cline_row + curwin->w_cline_height - curwin->w_wrow >= 3) {
@@ -360,7 +362,7 @@ void pum_redraw(void)
grid_assign_handle(&pum_grid);
bool moved = ui_comp_put_grid(&pum_grid, pum_row, pum_col-col_off,
- pum_height, grid_width);
+ pum_height, grid_width, false, true);
bool invalid_grid = moved || pum_invalid;
pum_invalid = false;
@@ -371,6 +373,13 @@ void pum_redraw(void)
} else if (invalid_grid) {
grid_invalidate(&pum_grid);
}
+ if (ui_has(kUIMultigrid)) {
+ const char *anchor = pum_above ? "SW" : "NW";
+ int row_off = pum_above ? pum_height : 0;
+ ui_call_win_float_pos(pum_grid.handle, -1, cstr_to_string(anchor),
+ pum_anchor_grid, pum_row-row_off, pum_col-col_off,
+ false);
+ }
// Never display more than we have
@@ -783,6 +792,10 @@ void pum_check_clear(void)
ui_call_popupmenu_hide();
} else {
ui_comp_remove_grid(&pum_grid);
+ if (ui_has(kUIMultigrid)) {
+ ui_call_win_close(pum_grid.handle);
+ ui_call_grid_destroy(pum_grid.handle);
+ }
// TODO(bfredl): consider keeping float grids allocated.
grid_free(&pum_grid);
}
diff --git a/src/nvim/popupmnu.h b/src/nvim/popupmnu.h
index 7e1588dbdd..42e6ef5653 100644
--- a/src/nvim/popupmnu.h
+++ b/src/nvim/popupmnu.h
@@ -1,6 +1,8 @@
#ifndef NVIM_POPUPMNU_H
#define NVIM_POPUPMNU_H
+#include "nvim/macros.h"
+#include "nvim/grid_defs.h"
#include "nvim/types.h"
/// Used for popup menu items.
@@ -11,6 +13,7 @@ typedef struct {
char_u *pum_info; // extra info
} pumitem_T;
+EXTERN ScreenGrid pum_grid INIT(= SCREEN_GRID_INIT);
#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "popupmnu.h.generated.h"
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index 4cfb734cd1..08bb4e4a52 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -148,9 +148,6 @@ typedef struct {
/// Whether to call "ui_call_grid_resize" in win_grid_alloc
static bool send_grid_resize = false;
-/// Highlight ids are no longer valid. Force retransmission
-static bool highlights_invalid = false;
-
static bool conceal_cursor_used = false;
static bool redraw_popupmenu = false;
@@ -197,8 +194,10 @@ void redraw_all_later(int type)
void screen_invalidate_highlights(void)
{
- redraw_all_later(NOT_VALID);
- highlights_invalid = true;
+ FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
+ redraw_win_later(wp, NOT_VALID);
+ wp->w_grid.valid = false;
+ }
}
/*
@@ -338,6 +337,9 @@ void update_screen(int type)
grid_ins_lines(&default_grid, 0, msg_scrolled, (int)Rows,
0, (int)Columns);
FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
+ if (wp->w_floating) {
+ continue;
+ }
if (wp->w_winrow < msg_scrolled) {
if (W_ENDROW(wp) > msg_scrolled
&& wp->w_redr_type < REDRAW_TOP
@@ -361,6 +363,10 @@ void update_screen(int type)
need_wait_return = FALSE;
}
+ if (type >= NOT_VALID) {
+ ui_comp_set_screen_valid(false);
+ }
+ win_ui_flush_positions();
msg_ext_check_prompt();
/* reset cmdline_row now (may have been changed temporarily) */
@@ -376,9 +382,11 @@ void update_screen(int type)
type = NOT_VALID;
// must_redraw may be set indirectly, avoid another redraw later
must_redraw = 0;
- } else if (highlights_invalid) {
+ } else if (!default_grid.valid) {
grid_invalidate(&default_grid);
+ default_grid.valid = true;
}
+ ui_comp_set_screen_valid(true);
if (clear_cmdline) /* going to clear cmdline (done below) */
check_for_delay(FALSE);
@@ -449,7 +457,14 @@ void update_screen(int type)
*/
did_one = FALSE;
search_hl.rm.regprog = NULL;
+
+
FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
+ if (wp->w_redr_type == CLEAR && wp->w_floating && wp->w_grid.chars) {
+ grid_invalidate(&wp->w_grid);
+ wp->w_redr_type = NOT_VALID;
+ }
+
if (wp->w_redr_type != 0) {
if (!did_one) {
did_one = TRUE;
@@ -471,7 +486,6 @@ void update_screen(int type)
}
send_grid_resize = false;
- highlights_invalid = false;
redraw_popupmenu = false;
/* Reset b_mod_set flags. Going through all windows is probably faster
@@ -4236,9 +4250,12 @@ win_line (
/// If UI did not request multigrid support, draw all windows on the
/// default_grid.
///
+/// NB: this function can only been used with window grids in a context where
+/// win_grid_alloc already has been called!
+///
/// If the default_grid is used, adjust window relative positions to global
/// screen positions.
-static void screen_adjust_grid(ScreenGrid **grid, int *row_off, int *col_off)
+void screen_adjust_grid(ScreenGrid **grid, int *row_off, int *col_off)
{
if (!(*grid)->chars && *grid != &default_grid) {
*row_off += (*grid)->row_offset;
@@ -5242,7 +5259,6 @@ void grid_getbytes(ScreenGrid *grid, int row, int col, char_u *bytes,
screen_adjust_grid(&grid, &row, &col);
-
// safety check
if (grid->chars != NULL && row < grid->Rows && col < grid->Columns) {
off = grid->line_offset[row] + col;
@@ -5855,14 +5871,9 @@ void win_grid_alloc(win_T *wp)
int rows = wp->w_height_inner;
int cols = wp->w_width_inner;
- // TODO(bfredl): floating windows should force this to true
- bool want_allocation = ui_has(kUIMultigrid);
+ bool want_allocation = ui_has(kUIMultigrid) || wp->w_floating;
bool has_allocation = (grid->chars != NULL);
- if (want_allocation && has_allocation && highlights_invalid) {
- grid_invalidate(grid);
- }
-
if (grid->Rows != rows) {
wp->w_lines_valid = 0;
xfree(wp->w_lines);
@@ -5874,15 +5885,20 @@ void win_grid_alloc(win_T *wp)
|| grid->Rows != rows
|| grid->Columns != cols) {
if (want_allocation) {
- grid_alloc(grid, rows, cols, true, true);
+ grid_alloc(grid, rows, cols, wp->w_grid.valid, wp->w_grid.valid);
+ grid->valid = true;
} else {
// Single grid mode, all rendering will be redirected to default_grid.
// Only keep track of the size and offset of the window.
grid_free(grid);
grid->Rows = rows;
grid->Columns = cols;
+ grid->valid = false;
}
was_resized = true;
+ } else if (want_allocation && has_allocation && !wp->w_grid.valid) {
+ grid_invalidate(grid);
+ grid->valid = true;
}
grid->row_offset = wp->w_winrow;
@@ -5892,7 +5908,7 @@ void win_grid_alloc(win_T *wp)
// - a grid was just resized
// - screen_resize was called and all grid sizes must be sent
// - the UI wants multigrid event (necessary)
- if ((send_grid_resize || was_resized) && ui_has(kUIMultigrid)) {
+ if ((send_grid_resize || was_resized) && want_allocation) {
ui_call_grid_resize(grid->handle, grid->Columns, grid->Rows);
}
}
@@ -5954,7 +5970,7 @@ retry:
// win_new_shellsize will recompute floats position, but tell the
// compositor to not redraw them yet
- ui_comp_invalidate_screen();
+ ui_comp_set_screen_valid(false);
win_new_shellsize(); /* fit the windows in the new sized shell */
@@ -6108,6 +6124,8 @@ void screenclear(void)
}
ui_call_grid_clear(1); // clear the display
+ ui_comp_set_screen_valid(true);
+
clear_cmdline = false;
mode_displayed = false;
@@ -6116,6 +6134,11 @@ void screenclear(void)
redraw_tabline = true;
redraw_popupmenu = true;
pum_invalidate();
+ FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
+ if (wp->w_floating) {
+ wp->w_redr_type = CLEAR;
+ }
+ }
if (must_redraw == CLEAR) {
must_redraw = NOT_VALID; // no need to clear again
}
@@ -6505,14 +6528,14 @@ int showmode(void)
if (VIsual_active)
clear_showcmd();
- /* If the last window has no status line, the ruler is after the mode
- * message and must be redrawn */
- if (redrawing()
- && lastwin->w_status_height == 0
- )
- win_redr_ruler(lastwin, TRUE);
- redraw_cmdline = FALSE;
- clear_cmdline = FALSE;
+ // If the last window has no status line, the ruler is after the mode
+ // message and must be redrawn
+ win_T *last = lastwin_nofloating();
+ if (redrawing() && last->w_status_height == 0) {
+ win_redr_ruler(last, true);
+ }
+ redraw_cmdline = false;
+ clear_cmdline = false;
return length;
}
@@ -7091,7 +7114,7 @@ void screen_resize(int width, int height)
check_shellsize();
height = Rows;
width = Columns;
- ui_resize(width, height);
+ ui_call_grid_resize(1, width, height);
send_grid_resize = true;
diff --git a/src/nvim/tui/tui.c b/src/nvim/tui/tui.c
index 0b24a3ebf4..e20cf15a79 100644
--- a/src/nvim/tui/tui.c
+++ b/src/nvim/tui/tui.c
@@ -165,6 +165,7 @@ UI *tui_start(void)
memset(ui->ui_ext, 0, sizeof(ui->ui_ext));
ui->ui_ext[kUILinegrid] = true;
+ ui->ui_ext[kUITermColors] = true;
return ui_bridge_attach(ui, tui_main, tui_scheduler);
}
diff --git a/src/nvim/ui.c b/src/nvim/ui.c
index 16370f2d10..d07ea3179e 100644
--- a/src/nvim/ui.c
+++ b/src/nvim/ui.c
@@ -219,11 +219,6 @@ void ui_schedule_refresh(void)
loop_schedule(&main_loop, event_create(ui_refresh_event, 0));
}
-void ui_resize(int width, int height)
-{
- ui_call_grid_resize(1, width, height);
-}
-
void ui_default_colors_set(void)
{
ui_call_default_colors_set(normal_fg, normal_bg, normal_sp,
@@ -249,7 +244,7 @@ void ui_attach_impl(UI *ui)
if (ui_count == MAX_UI_COUNT) {
abort();
}
- if (!ui->ui_ext[kUIMultigrid]) {
+ if (!ui->ui_ext[kUIMultigrid] && !ui->ui_ext[kUIFloatDebug]) {
ui_comp_attach(ui);
}
@@ -299,7 +294,7 @@ void ui_detach_impl(UI *ui)
ui_schedule_refresh();
}
- if (!ui->ui_ext[kUIMultigrid]) {
+ if (!ui->ui_ext[kUIMultigrid] && !ui->ui_ext[kUIFloatDebug]) {
ui_comp_detach(ui);
}
}
@@ -310,7 +305,7 @@ void ui_set_ext_option(UI *ui, UIExtension ext, bool active)
ui_refresh();
return;
}
- if (ui->option_set) {
+ if (ui->option_set && (ui_ext_names[ext][0] != '_' || active)) {
ui->option_set(ui, cstr_as_string((char *)ui_ext_names[ext]),
BOOLEAN_OBJ(active));
}
@@ -383,7 +378,7 @@ int ui_current_col(void)
void ui_flush(void)
{
cmdline_ui_flush();
- win_ui_flush();
+ win_ui_flush_positions();
msg_ext_ui_flush();
if (pending_cursor_update) {
@@ -405,7 +400,6 @@ void ui_flush(void)
ui_call_flush();
}
-
/// Check if current mode has changed.
/// May update the shape of the cursor.
void ui_cursor_shape(void)
@@ -438,7 +432,9 @@ Array ui_array(void)
PUT(info, "height", INTEGER_OBJ(ui->height));
PUT(info, "rgb", BOOLEAN_OBJ(ui->rgb));
for (UIExtension j = 0; j < kUIExtCount; j++) {
- PUT(info, ui_ext_names[j], BOOLEAN_OBJ(ui->ui_ext[j]));
+ if (ui_ext_names[j][0] != '_' || ui->ui_ext[j]) {
+ PUT(info, ui_ext_names[j], BOOLEAN_OBJ(ui->ui_ext[j]));
+ }
}
if (ui->inspect) {
ui->inspect(ui, &info);
@@ -462,8 +458,14 @@ void ui_grid_resize(handle_T grid_handle, int width, int height, Error *error)
return;
}
- // non-positive indicates no request
- wp->w_height_request = (int)MAX(height, 0);
- wp->w_width_request = (int)MAX(width, 0);
- win_set_inner_size(wp);
+ 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);
+ }
+ } else {
+ // non-positive indicates no request
+ wp->w_height_request = (int)MAX(height, 0);
+ wp->w_width_request = (int)MAX(width, 0);
+ win_set_inner_size(wp);
+ }
}
diff --git a/src/nvim/ui.h b/src/nvim/ui.h
index 490cc930b1..3f6b3babad 100644
--- a/src/nvim/ui.h
+++ b/src/nvim/ui.h
@@ -20,6 +20,7 @@ typedef enum {
kUIMultigrid,
kUIHlState,
kUITermColors,
+ kUIFloatDebug,
kUIExtCount,
} UIExtension;
@@ -33,9 +34,9 @@ EXTERN const char *ui_ext_names[] INIT(= {
"ext_multigrid",
"ext_hlstate",
"ext_termcolors",
+ "_debug_float",
});
-
typedef struct ui_t UI;
enum {
diff --git a/src/nvim/ui_compositor.c b/src/nvim/ui_compositor.c
index c7ba0306e4..e52ba437ee 100644
--- a/src/nvim/ui_compositor.c
+++ b/src/nvim/ui_compositor.c
@@ -17,6 +17,7 @@
#include "nvim/ui.h"
#include "nvim/highlight.h"
#include "nvim/memory.h"
+#include "nvim/popupmnu.h"
#include "nvim/ui_compositor.h"
#include "nvim/ugrid.h"
#include "nvim/screen.h"
@@ -55,7 +56,6 @@ void ui_comp_init(void)
compositor->rgb = true;
compositor->grid_resize = ui_comp_grid_resize;
- compositor->grid_clear = ui_comp_grid_clear;
compositor->grid_scroll = ui_comp_grid_scroll;
compositor->grid_cursor_goto = ui_comp_grid_cursor_goto;
compositor->raw_line = ui_comp_raw_line;
@@ -107,10 +107,12 @@ bool ui_comp_should_draw(void)
/// TODO(bfredl): later on the compositor should just use win_float_pos events,
/// though that will require slight event order adjustment: emit the win_pos
/// events in the beginning of update_screen(0), rather than in ui_flush()
-bool ui_comp_put_grid(ScreenGrid *grid, int row, int col, int height, int width)
+bool ui_comp_put_grid(ScreenGrid *grid, int row, int col, int height, int width,
+ bool valid, bool on_top)
{
+ bool moved;
if (grid->comp_index != 0) {
- bool moved = (row != grid->comp_row) || (col != grid->comp_col);
+ moved = (row != grid->comp_row) || (col != grid->comp_col);
if (ui_comp_should_draw()) {
// Redraw the area covered by the old position, and is not covered
// by the new position. Disable the grid so that compose_area() will not
@@ -134,21 +136,41 @@ bool ui_comp_put_grid(ScreenGrid *grid, int row, int col, int height, int width)
}
grid->comp_row = row;
grid->comp_col = col;
- return moved;
- }
+ } else {
+ moved = true;
#ifndef NDEBUG
- for (size_t i = 0; i < kv_size(layers); i++) {
- if (kv_A(layers, i) == grid) {
- assert(false);
+ for (size_t i = 0; i < kv_size(layers); i++) {
+ if (kv_A(layers, i) == grid) {
+ assert(false);
+ }
}
- }
#endif
- // not found: new grid
- kv_push(layers, grid);
- grid->comp_row = row;
- grid->comp_col = col;
- grid->comp_index = kv_size(layers)-1;
- return true;
+
+ size_t insert_at = kv_size(layers);
+ if (kv_A(layers, insert_at-1) == &pum_grid) {
+ insert_at--;
+ }
+ if (insert_at > 1 && !on_top) {
+ insert_at--;
+ }
+ // not found: new grid
+ kv_push(layers, grid);
+ if (insert_at < kv_size(layers)-1) {
+ for (size_t i = kv_size(layers)-1; i > insert_at; i--) {
+ kv_A(layers, i) = kv_A(layers, i-i);
+ }
+ kv_A(layers, insert_at) = grid;
+ }
+
+ grid->comp_row = row;
+ grid->comp_col = col;
+ grid->comp_index = insert_at;
+ }
+ if (moved && valid && ui_comp_should_draw()) {
+ compose_area(grid->comp_row, grid->comp_row+grid->Rows,
+ grid->comp_col, grid->comp_col+grid->Columns);
+ }
+ return moved;
}
void ui_comp_remove_grid(ScreenGrid *grid)
@@ -194,6 +216,26 @@ bool ui_comp_set_grid(handle_T handle)
return false;
}
+static void ui_comp_raise_grid(ScreenGrid *grid, size_t new_index)
+{
+ size_t old_index = grid->comp_index;
+ for (size_t i = old_index; i < new_index; i++) {
+ kv_A(layers, i) = kv_A(layers, i+1);
+ kv_A(layers, i)->comp_index = i;
+ }
+ kv_A(layers, new_index) = grid;
+ grid->comp_index = new_index;
+ for (size_t i = old_index; i < new_index; i++) {
+ ScreenGrid *grid2 = kv_A(layers, i);
+ int startcol = MAX(grid->comp_col, grid2->comp_col);
+ int endcol = MIN(grid->comp_col+grid->Columns,
+ grid2->comp_col+grid2->Columns);
+ compose_area(MAX(grid->comp_row, grid2->comp_row),
+ MIN(grid->comp_row+grid->Rows, grid2->comp_row+grid2->Rows),
+ startcol, endcol);
+ }
+}
+
static void ui_comp_grid_cursor_goto(UI *ui, Integer grid_handle,
Integer r, Integer c)
{
@@ -203,6 +245,18 @@ static void ui_comp_grid_cursor_goto(UI *ui, Integer grid_handle,
int cursor_row = curgrid->comp_row+(int)r;
int cursor_col = curgrid->comp_col+(int)c;
+ // TODO(bfredl): maybe not the best time to do this, for efficiency we
+ // should configure all grids before entering win_update()
+ if (curgrid != &default_grid) {
+ size_t new_index = kv_size(layers)-1;
+ if (kv_A(layers, new_index) == &pum_grid) {
+ new_index--;
+ }
+ if (curgrid->comp_index < new_index) {
+ ui_comp_raise_grid(curgrid, new_index);
+ }
+ }
+
if (cursor_col >= default_grid.Columns || cursor_row >= default_grid.Rows) {
// TODO(bfredl): this happens with 'writedelay', refactor?
// abort();
@@ -211,6 +265,18 @@ static void ui_comp_grid_cursor_goto(UI *ui, Integer grid_handle,
ui_composed_call_grid_cursor_goto(1, cursor_row, cursor_col);
}
+ScreenGrid *ui_comp_mouse_focus(int row, int col)
+{
+ // TODO(bfredl): click "through" unfocusable grids?
+ for (ssize_t i = (ssize_t)kv_size(layers)-1; i > 0; i--) {
+ ScreenGrid *grid = kv_A(layers, i);
+ if (row >= grid->comp_row && row < grid->comp_row+grid->Rows
+ && col >= grid->comp_col && col < grid->comp_col+grid->Columns) {
+ return grid;
+ }
+ }
+ return NULL;
+}
/// Baseline implementation. This is always correct, but we can sometimes
/// do something more efficient (where efficiency means smaller deltas to
@@ -260,7 +326,7 @@ static void compose_line(Integer row, Integer startcol, Integer endcol,
memcpy(attrbuf+(col-startcol), grid->attrs+off, n * sizeof(*attrbuf));
// 'pumblend'
- if (grid != &default_grid && p_pb) {
+ if (grid == &pum_grid && p_pb) {
for (int i = col-(int)startcol; i < until-startcol; i++) {
bool thru = strequal((char *)linebuf[i], " "); // negative space
attrbuf[i] = (sattr_T)hl_blend_attrs(bg_attrs[i], attrbuf[i], thru);
@@ -348,7 +414,8 @@ static void ui_comp_raw_line(UI *ui, Integer grid, Integer row,
assert(row < default_grid.Rows);
assert(clearcol <= default_grid.Columns);
if (flags & kLineFlagInvalid
- || kv_size(layers) > (p_pb ? 1 : curgrid->comp_index+1)) {
+ || kv_size(layers) > curgrid->comp_index+1
+ || (p_pb && curgrid == &pum_grid)) {
compose_line(row, startcol, clearcol, flags);
} else {
ui_composed_call_raw_line(1, row, startcol, endcol, clearcol, clearattr,
@@ -359,17 +426,9 @@ static void ui_comp_raw_line(UI *ui, Integer grid, Integer row,
/// The screen is invalid and will soon be cleared
///
/// Don't redraw floats until screen is cleared
-void ui_comp_invalidate_screen(void)
-{
- valid_screen = false;
-}
-
-static void ui_comp_grid_clear(UI *ui, Integer grid)
+void ui_comp_set_screen_valid(bool valid)
{
- // By design, only first grid uses clearing.
- assert(grid == 1);
- ui_composed_call_grid_clear(1);
- valid_screen = true;
+ valid_screen = valid;
}
// TODO(bfredl): These events are somewhat of a hack. multiline messages
diff --git a/src/nvim/window.c b/src/nvim/window.c
index bb71b12aed..18fad76a95 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -6,6 +6,7 @@
#include <stdbool.h>
#include "nvim/api/private/handle.h"
+#include "nvim/api/private/helpers.h"
#include "nvim/vim.h"
#include "nvim/ascii.h"
#include "nvim/window.h"
@@ -48,6 +49,7 @@
#include "nvim/terminal.h"
#include "nvim/undo.h"
#include "nvim/ui.h"
+#include "nvim/ui_compositor.h"
#include "nvim/os/os.h"
@@ -203,14 +205,24 @@ newwindow:
wp = wp->w_next;
}
} else {
- if (nchar == 'W') { /* go to previous window */
+ if (nchar == 'W') { // go to previous window
wp = curwin->w_prev;
- if (wp == NULL)
- wp = lastwin; /* wrap around */
- } else { /* go to next window */
+ if (wp == NULL) {
+ wp = lastwin; // wrap around
+ }
+ while (wp != NULL && wp->w_floating
+ && !wp->w_float_config.focusable) {
+ wp = wp->w_prev;
+ }
+ } else { // go to next window
wp = curwin->w_next;
- if (wp == NULL)
- wp = firstwin; /* wrap around */
+ while (wp != NULL && wp->w_floating
+ && !wp->w_float_config.focusable) {
+ wp = wp->w_next;
+ }
+ if (wp == NULL) {
+ wp = firstwin; // wrap around
+ }
}
}
win_goto(wp);
@@ -281,7 +293,7 @@ newwindow:
/* cursor to bottom-right window */
case 'b':
case Ctrl_B:
- win_goto(lastwin);
+ win_goto(lastwin_nofloating());
break;
/* cursor to last accessed (previous) window */
@@ -483,6 +495,22 @@ wingotofile:
cmdmod.tab = tabpage_index(curtab) + 1;
nchar = xchar;
goto wingotofile;
+
+ case 'e':
+ if (curwin->w_floating || !ui_has(kUIMultigrid)) {
+ beep_flush();
+ break;
+ }
+ FloatConfig config = FLOAT_CONFIG_INIT;
+ config.external = true;
+ Error err = ERROR_INIT;
+ if (!win_new_float(curwin, curwin->w_width, curwin->w_height, config,
+ &err)) {
+ EMSG(err.msg);
+ api_clear_error(&err);
+ beep_flush();
+ }
+ break;
default:
beep_flush();
break;
@@ -504,6 +532,302 @@ static void cmd_with_count(char *cmd, char_u *bufp, size_t bufsize,
}
}
+/// Create a new float.
+///
+/// if wp == NULL allocate a new window, otherwise turn existing window into a
+/// 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)
+{
+ bool new = false;
+ if (wp == NULL) {
+ new = true;
+ wp = win_alloc(lastwin_nofloating(), false);
+ win_init(wp, curwin, 0);
+ } else {
+ assert(!wp->w_floating);
+ if (firstwin == wp && lastwin_nofloating() == wp) {
+ // last non-float
+ api_set_error(err, kErrorTypeException,
+ "Cannot change last window into float");
+ return NULL;
+ } else if (!win_valid(wp)) {
+ api_set_error(err, kErrorTypeException,
+ "Cannot change window from different tabpage into float");
+ return NULL;
+ }
+ int dir;
+ winframe_remove(wp, &dir, NULL);
+ xfree(wp->w_frame);
+ wp->w_frame = NULL;
+ (void)win_comp_pos(); // recompute window positions
+ win_remove(wp, NULL);
+ win_append(lastwin_nofloating(), wp);
+ }
+ wp->w_floating = 1;
+ wp->w_status_height = 0;
+ wp->w_vsep_width = 0;
+ win_config_float(wp, width, height, config);
+ wp->w_pos_changed = true;
+ redraw_win_later(wp, VALID);
+ if (new) {
+ win_enter(wp, false);
+ }
+ return wp;
+}
+
+void win_config_float(win_T *wp, int width, int height,
+ FloatConfig config)
+{
+ wp->w_height = MAX(height, 1);
+ wp->w_width = MAX(width, 2);
+
+ if (config.relative == kFloatRelativeCursor) {
+ config.relative = kFloatRelativeWindow;
+ config.row += curwin->w_wrow;
+ config.col += curwin->w_wcol;
+ config.window = curwin->handle;
+ }
+
+ wp->w_float_config = config;
+
+ if (!ui_has(kUIMultigrid)) {
+ wp->w_height = MIN(wp->w_height, Rows-1);
+ wp->w_width = MIN(wp->w_width, Columns);
+ }
+
+ win_set_inner_size(wp);
+ must_redraw = MAX(must_redraw, VALID);
+ wp->w_pos_changed = true;
+}
+
+static void ui_ext_win_position(win_T *wp)
+{
+ if (!wp->w_floating) {
+ ui_call_win_pos(wp->w_grid.handle, wp->handle, wp->w_winrow,
+ 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) {
+ ScreenGrid *grid = &default_grid;
+ int row = c.row, col = c.col;
+ if (c.relative == kFloatRelativeWindow) {
+ Error dummy = ERROR_INIT;
+ win_T *win = find_window_by_handle(c.window, &dummy);
+ if (win) {
+ grid = &win->w_grid;
+ screen_adjust_grid(&grid, &row, &col);
+ }
+ api_clear_error(&dummy);
+ }
+ if (ui_has(kUIMultigrid)) {
+ String anchor = cstr_to_string(anchor_str[c.anchor]);
+ ui_call_win_float_pos(wp->w_grid.handle, wp->handle, anchor, grid->handle,
+ row, col, c.focusable);
+ } else {
+ // TODO(bfredl): ideally, compositor should work like any multigrid UI
+ // and use standard win_pos events.
+ bool east = c.anchor & kFloatAnchorEast;
+ bool south = c.anchor & kFloatAnchorSouth;
+
+ row -= (south ? wp->w_height : 0);
+ col -= (east ? wp->w_width : 0);
+ row = MAX(MIN(row, Rows-wp->w_height-1), 0);
+ col = MAX(MIN(col, Columns-wp->w_width), 0);
+ wp->w_winrow = row;
+ wp->w_wincol = col;
+ bool valid = (wp->w_redr_type == 0);
+ bool on_top = (curwin == wp) || !curwin->w_floating;
+ ui_comp_put_grid(&wp->w_grid, row, col, wp->w_height, wp->w_width,
+ valid, on_top);
+ if (!valid) {
+ wp->w_grid.valid = false;
+ redraw_win_later(wp, NOT_VALID);
+ }
+ }
+ } else {
+ ui_call_win_external_pos(wp->w_grid.handle, wp->handle);
+ }
+
+}
+
+
+static bool parse_float_anchor(String anchor, FloatAnchor *out)
+{
+ if (anchor.size == 0) {
+ *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;
+ } else {
+ return false;
+ }
+ return true;
+}
+
+static bool parse_float_relative(String relative, FloatRelative *out)
+{
+ if (relative.size == 0) {
+ *out = (FloatRelative)0;
+ }
+ char *str = relative.data;
+ if (!STRICMP(str, "editor")) {
+ *out = kFloatRelativeEditor;
+ } else if (!STRICMP(str, "win")) {
+ *out = kFloatRelativeWindow;
+ } else if (!STRICMP(str, "cursor")) {
+ *out = kFloatRelativeCursor;
+ } else {
+ return false;
+ }
+ return true;
+}
+
+bool parse_float_config(Dictionary config, FloatConfig *out, bool reconf,
+ Error *err)
+{
+ bool has_row = false, has_col = false, has_relative = false;
+ bool has_external = false, has_window = false;
+
+ for (size_t i = 0; i < config.size; i++) {
+ char *key = config.items[i].key.data;
+ Object val = config.items[i].value;
+ if (!strcmp(key, "row")) {
+ has_row = true;
+ if (val.type == kObjectTypeInteger) {
+ out->row = val.data.integer;
+ } else if (val.type == kObjectTypeFloat) {
+ out->row = val.data.floating;
+ } else {
+ api_set_error(err, kErrorTypeValidation,
+ "'row' option has to be Integer or Float");
+ return false;
+ }
+ } else if (!strcmp(key, "col")) {
+ has_col = true;
+ if (val.type == kObjectTypeInteger) {
+ out->col = val.data.integer;
+ } else if (val.type == kObjectTypeFloat) {
+ out->col = val.data.floating;
+ } else {
+ api_set_error(err, kErrorTypeValidation,
+ "'col' option has to be Integer or Float");
+ return false;
+ }
+ } else if (!strcmp(key, "anchor")) {
+ if (val.type != kObjectTypeString) {
+ api_set_error(err, kErrorTypeValidation,
+ "'anchor' option has to be String");
+ return false;
+ }
+ if (!parse_float_anchor(val.data.string, &out->anchor)) {
+ api_set_error(err, kErrorTypeValidation,
+ "Invalid value of 'anchor' option");
+ 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");
+ return false;
+ }
+ if (!parse_float_relative(val.data.string, &out->relative)) {
+ api_set_error(err, kErrorTypeValidation,
+ "Invalid value of 'relative' option");
+ return false;
+ }
+ } else if (!strcmp(key, "win")) {
+ has_window = true;
+ if (val.type != kObjectTypeInteger
+ && val.type != kObjectTypeWindow) {
+ api_set_error(err, kErrorTypeValidation,
+ "'win' option has to be Integer or Window");
+ return false;
+ }
+ out->window = val.data.integer;
+ } else if (!strcmp(key, "external")) {
+ if (val.type == kObjectTypeInteger) {
+ out->external = val.data.integer;
+ } else if (val.type == kObjectTypeBoolean) {
+ out->external = val.data.boolean;
+ } else {
+ api_set_error(err, kErrorTypeValidation,
+ "'external' option has to be Boolean");
+ return false;
+ }
+ has_external = out->external;
+ } else if (!strcmp(key, "focusable")) {
+ if (val.type == kObjectTypeInteger) {
+ out->focusable = val.data.integer;
+ } else if (val.type == kObjectTypeBoolean) {
+ out->focusable = val.data.boolean;
+ } else {
+ api_set_error(err, kErrorTypeValidation,
+ "'focusable' option has to be Boolean");
+ return false;
+ }
+ } else {
+ api_set_error(err, kErrorTypeValidation,
+ "Invalid options key '%s'", key);
+ return false;
+ }
+ }
+
+ if (has_window && !(has_relative && out->relative == kFloatRelativeWindow)) {
+ api_set_error(err, kErrorTypeValidation,
+ "'win' option 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 && has_external) {
+ api_set_error(err, kErrorTypeValidation,
+ "Only one of 'relative' and 'external' should be used");
+ return false;
+ } else if (has_relative) {
+ out->external = false;
+ } else if (!reconf && !has_relative && !has_external) {
+ api_set_error(err, kErrorTypeValidation,
+ "One of 'relative' and 'external' must be used");
+ return false;
+ }
+
+ if (out->external && !ui_has(kUIMultigrid)) {
+ api_set_error(err, kErrorTypeValidation,
+ "UI doesn't support external windows");
+ return false;
+ }
+
+ if (has_relative != has_row || has_row != has_col) {
+ api_set_error(err, kErrorTypeValidation, "All of 'relative', 'row', and "
+ "'col' has to be specified at once");
+ return false;
+ }
+ return true;
+}
+
/*
* split the current window, implements CTRL-W s and :split
*
@@ -566,16 +890,20 @@ int win_split_ins(int size, int flags, win_T *new_wp, int dir)
int wmh1;
bool did_set_fraction = false;
- if (flags & WSP_TOP)
+ if (flags & WSP_TOP) {
oldwin = firstwin;
- else if (flags & WSP_BOT)
- oldwin = lastwin;
- else
+ } else if (flags & WSP_BOT || curwin->w_floating) {
+ // can't split float, use last nonfloating window instead
+ oldwin = lastwin_nofloating();
+ } else {
oldwin = curwin;
+ }
- /* add a status line when p_ls == 1 and splitting the first window */
- if (ONE_WINDOW && p_ls == 1 && oldwin->w_status_height == 0) {
- if (oldwin->w_height <= p_wmh && new_wp == NULL) {
+ bool new_in_layout = (new_wp == NULL || new_wp->w_floating);
+
+ // add a status line when p_ls == 1 and splitting the first window
+ if (one_nonfloat() && p_ls == 1 && oldwin->w_status_height == 0) {
+ if (oldwin->w_height <= p_wmh && new_in_layout) {
EMSG(_(e_noroom));
return FAIL;
}
@@ -624,7 +952,7 @@ int win_split_ins(int size, int flags, win_T *new_wp, int dir)
available = oldwin->w_frame->fr_width;
needed += minwidth;
}
- if (available < needed && new_wp == NULL) {
+ if (available < needed && new_in_layout) {
EMSG(_(e_noroom));
return FAIL;
}
@@ -702,7 +1030,7 @@ int win_split_ins(int size, int flags, win_T *new_wp, int dir)
available = oldwin->w_frame->fr_height;
needed += minheight;
}
- if (available < needed && new_wp == NULL) {
+ if (available < needed && new_in_layout) {
EMSG(_(e_noroom));
return FAIL;
}
@@ -790,6 +1118,9 @@ int win_split_ins(int size, int flags, win_T *new_wp, int dir)
/* make the contents of the new window the same as the current one */
win_init(wp, curwin, flags);
+ } else if (wp->w_floating) {
+ new_frame(wp);
+ wp->w_floating = false;
}
/*
@@ -1192,7 +1523,13 @@ static void win_exchange(long Prenum)
win_T *wp2;
int temp;
- if (ONE_WINDOW) { /* just one window */
+ if (curwin->w_floating) {
+ EMSG(e_floatexchange);
+ return;
+ }
+
+ if (firstwin == curwin && lastwin_nofloating() == curwin) {
+ // just one window
beep_flush();
return;
}
@@ -1282,7 +1619,13 @@ static void win_rotate(int upwards, int count)
frame_T *frp;
int n;
- if (ONE_WINDOW) { /* nothing to do */
+ if (curwin->w_floating) {
+ EMSG(e_floatexchange);
+ return;
+ }
+
+ if (firstwin == curwin && lastwin_nofloating() == curwin) {
+ // nothing to do
beep_flush();
return;
}
@@ -1355,16 +1698,27 @@ static void win_rotate(int upwards, int count)
*/
static void win_totop(int size, int flags)
{
- int dir;
+ int dir = 0;
int height = curwin->w_height;
- if (ONE_WINDOW) {
+ if (firstwin == curwin && lastwin_nofloating() == curwin) {
beep_flush();
return;
}
- /* Remove the window and frame from the tree of frames. */
- (void)winframe_remove(curwin, &dir, NULL);
+ if (curwin->w_floating) {
+ ui_comp_remove_grid(&curwin->w_grid);
+ if (ui_has(kUIMultigrid)) {
+ curwin->w_pos_changed = true;
+ } else {
+ // No longer a float, a non-multigrid UI shouldn't draw it as such
+ ui_call_win_hide(curwin->w_grid.handle);
+ win_free_grid(curwin, false);
+ }
+ } else {
+ // Remove the window and frame from the tree of frames.
+ (void)winframe_remove(curwin, &dir, NULL);
+ }
win_remove(curwin, NULL);
last_status(FALSE); /* may need to remove last status line */
(void)win_comp_pos(); /* recompute window positions */
@@ -1795,13 +2149,13 @@ static bool last_window(void) FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
}
/// Check that current tab page contains no more then one window other than
-/// "aucmd_win".
+/// "aucmd_win". Only counts floating window if it is current.
bool one_window(void) FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
{
bool seen_one = false;
FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
- if (wp != aucmd_win) {
+ if (wp != aucmd_win && (!wp->w_floating || wp == curwin)) {
if (seen_one) {
return false;
}
@@ -1811,6 +2165,20 @@ bool one_window(void) FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
return true;
}
+/// Like ONE_WINDOW but only considers non-floating windows
+bool one_nonfloat(void) FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
+{
+ return firstwin->w_next == NULL || firstwin->w_next->w_floating;
+}
+
+/// if wp is the last non-floating window
+///
+/// always false for a floating window
+bool last_nonfloat(win_T *wp) FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
+{
+ return firstwin == wp && !(wp->w_next && !wp->w_floating);
+}
+
/// Close the possibly last window in a tab page.
///
/// @param win window to close
@@ -1882,9 +2250,9 @@ int win_close(win_T *win, bool free_buf)
int dir;
bool help_window = false;
tabpage_T *prev_curtab = curtab;
- frame_T *win_frame = win->w_frame->fr_parent;
+ frame_T *win_frame = win->w_floating ? NULL : win->w_frame->fr_parent;
- if (last_window()) {
+ if (last_window() && !win->w_floating) {
EMSG(_("E444: Cannot close last window"));
return FAIL;
}
@@ -1897,10 +2265,17 @@ int win_close(win_T *win, bool free_buf)
EMSG(_("E813: Cannot close autocmd window"));
return FAIL;
}
- if ((firstwin == aucmd_win || lastwin == aucmd_win) && one_window()) {
+ if ((firstwin == aucmd_win || lastwin_nofloating() == aucmd_win)
+ && one_window()) {
EMSG(_("E814: Cannot close window, only autocmd window would remain"));
return FAIL;
}
+ if ((firstwin == win && lastwin_nofloating() == win)
+ && lastwin->w_floating) {
+ // TODO(bfredl): we might close the float also instead
+ EMSG(e_floatonly);
+ return FAIL;
+ }
/* When closing the last window in a tab page first go to another tab page
* and then close the window and the tab page to avoid that curwin and
@@ -1921,7 +2296,15 @@ int win_close(win_T *win, bool free_buf)
* Guess which window is going to be the new current window.
* This may change because of the autocommands (sigh).
*/
- wp = frame2win(win_altframe(win, NULL));
+ if (!win->w_floating) {
+ wp = frame2win(win_altframe(win, NULL));
+ } else {
+ if (win_valid(prevwin)) {
+ wp = prevwin;
+ } else {
+ wp = curtab->tp_firstwin;
+ }
+ }
/*
* Be careful: If autocommands delete the window or cause this window
@@ -1949,6 +2332,27 @@ int win_close(win_T *win, bool free_buf)
return FAIL;
}
+ bool was_floating = win->w_floating;
+ if (ui_has(kUIMultigrid)) {
+ ui_call_win_close(win->w_grid.handle);
+ }
+
+ if (win->w_floating) {
+ ui_comp_remove_grid(&win->w_grid);
+ if (win->w_float_config.external) {
+ for (tabpage_T *tp = first_tabpage; tp != NULL; tp = tp->tp_next) {
+ if (tp == curtab) {
+ continue;
+ }
+ if (tp->tp_curwin == win) {
+ // NB: an autocmd can still abort the closing of this window,
+ // bur carring out this change anyway shouldn't be a catastrophe.
+ tp->tp_curwin = tp->tp_firstwin;
+ }
+ }
+ }
+ }
+
/* Free independent synblock before the buffer is freed. */
if (win->w_buffer != NULL)
@@ -1975,7 +2379,8 @@ int win_close(win_T *win, bool free_buf)
if (only_one_window() && win_valid(win) && win->w_buffer == NULL
&& (last_window() || curtab != prev_curtab
- || close_last_window_tabpage(win, free_buf, prev_curtab))) {
+ || close_last_window_tabpage(win, free_buf, prev_curtab))
+ && !win->w_floating) {
// Autocommands have closed all windows, quit now. Restore
// curwin->w_buffer, otherwise writing ShaDa file may fail.
if (curwin->w_buffer == NULL) {
@@ -1992,7 +2397,7 @@ int win_close(win_T *win, bool free_buf)
}
// Autocommands may have closed the window already, or closed the only
// other window or moved to another tab page.
- if (!win_valid(win) || last_window()
+ if (!win_valid(win) || (!win->w_floating && last_window())
|| close_last_window_tabpage(win, free_buf, prev_curtab)) {
return FAIL;
}
@@ -2041,12 +2446,15 @@ int win_close(win_T *win, bool free_buf)
// using the window.
check_cursor();
}
- if (p_ea && (*p_ead == 'b' || *p_ead == dir)) {
- // If the frame of the closed window contains the new current window,
- // only resize that frame. Otherwise resize all windows.
- win_equal(curwin, curwin->w_frame->fr_parent == win_frame, dir);
- } else {
- win_comp_pos();
+
+ if (!was_floating) {
+ if (p_ea && (*p_ead == 'b' || *p_ead == dir)) {
+ // If the frame of the closed window contains the new current window,
+ // only resize that frame. Otherwise resize all windows.
+ win_equal(curwin, curwin->w_frame->fr_parent == win_frame, dir);
+ } else {
+ win_comp_pos();
+ }
}
if (close_curwin) {
@@ -2167,10 +2575,18 @@ win_free_mem (
frame_T *frp;
win_T *wp;
- /* Remove the window and its frame from the tree of frames. */
- frp = win->w_frame;
- wp = winframe_remove(win, dirp, tp);
- xfree(frp);
+ if (!win->w_floating) {
+ // Remove the window and its frame from the tree of frames.
+ frp = win->w_frame;
+ wp = winframe_remove(win, dirp, tp);
+ xfree(frp);
+ } else {
+ if (win_valid(prevwin)) {
+ wp = prevwin;
+ } else {
+ wp = curtab->tp_firstwin;
+ }
+ }
win_free(win, tp);
/* When deleting the current window of another tab page select a new
@@ -2189,6 +2605,12 @@ void win_free_all(void)
while (first_tabpage->tp_next != NULL)
tabpage_close(TRUE);
+ while (lastwin != NULL && lastwin->w_floating) {
+ win_T *wp = lastwin;
+ win_remove(lastwin, NULL);
+ (void)win_free_mem(wp, &dummy, NULL);
+ }
+
if (aucmd_win != NULL) {
(void)win_free_mem(aucmd_win, &dummy, NULL);
aucmd_win = NULL;
@@ -2870,11 +3292,19 @@ close_others (
win_T *nextwp;
int r;
- if (one_window()) {
+ if (curwin->w_floating) {
+ if (message && !autocmd_busy) {
+ EMSG(e_floatonly);
+ }
+ return;
+ }
+
+ if (one_window() && !lastwin->w_floating) {
if (message
&& !autocmd_busy
- )
+ ) {
MSG(_(m_onlyone));
+ }
return;
}
@@ -3116,9 +3546,7 @@ int win_new_tabpage(int after, char_u *filename)
redraw_all_later(NOT_VALID);
- if (ui_has(kUIMultigrid)) {
- tabpage_check_windows(tp);
- }
+ tabpage_check_windows(tp);
apply_autocmds(EVENT_WINNEW, NULL, NULL, false, curbuf);
apply_autocmds(EVENT_WINENTER, NULL, NULL, false, curbuf);
@@ -3317,7 +3745,7 @@ static void enter_tabpage(tabpage_T *tp, buf_T *old_curbuf, int trigger_enter_au
lastwin = tp->tp_lastwin;
topframe = tp->tp_topframe;
- if (old_curtab != curtab && ui_has(kUIMultigrid)) {
+ if (old_curtab != curtab) {
tabpage_check_windows(old_curtab);
}
@@ -3355,16 +3783,31 @@ static void enter_tabpage(tabpage_T *tp, buf_T *old_curbuf, int trigger_enter_au
redraw_all_later(NOT_VALID);
}
-/// called when changing current tabpage from old_curtab to curtab
+/// tells external UI that windows and inline floats in old_curtab are invisible
+/// and that floats in curtab is now visible.
+///
+/// External floats are considered independent of tabpages. This is
+/// implemented by always moving them to curtab.
static void tabpage_check_windows(tabpage_T *old_curtab)
{
win_T *next_wp;
for (win_T *wp = old_curtab->tp_firstwin; wp; wp = next_wp) {
next_wp = wp->w_next;
+ if (wp->w_floating) {
+ if (wp->w_float_config.external) {
+ win_remove(wp, old_curtab);
+ win_append(lastwin_nofloating(), wp);
+ } else {
+ ui_comp_remove_grid(&wp->w_grid);
+ }
+ }
wp->w_pos_changed = true;
}
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);
+ }
wp->w_pos_changed = true;
}
}
@@ -3577,6 +4020,12 @@ win_goto_ver (
frame_T *foundfr;
foundfr = curwin->w_frame;
+
+ if (curwin->w_floating) {
+ win_goto(prevwin);
+ return;
+ }
+
while (count--) {
/*
* First go upwards in the tree of frames until we find an upwards or
@@ -3636,6 +4085,12 @@ win_goto_hor (
frame_T *foundfr;
foundfr = curwin->w_frame;
+
+ if (curwin->w_floating) {
+ win_goto(prevwin);
+ return;
+ }
+
while (count--) {
/*
* First go upwards in the tree of frames until we find a left or
@@ -3740,6 +4195,7 @@ static void win_enter_ext(win_T *wp, bool undo_sync, int curwin_invalid,
}
curwin = wp;
curbuf = wp->w_buffer;
+
check_cursor();
if (!virtual_active())
curwin->w_cursor.coladd = 0;
@@ -3809,9 +4265,10 @@ static void win_enter_ext(win_T *wp, bool undo_sync, int curwin_invalid,
else if (curwin->w_height == 0)
win_setheight(1);
- /* set window width to desired minimal value */
- if (curwin->w_width < p_wiw && !curwin->w_p_wfw)
+ // set window width to desired minimal value
+ if (curwin->w_width < p_wiw && !curwin->w_p_wfw && !wp->w_floating) {
win_setwidth((int)p_wiw);
+ }
setmouse(); /* in case jumped to/from help buffer */
@@ -3916,6 +4373,7 @@ static win_T *win_alloc(win_T *after, int hidden)
new_wp->w_botline = 2;
new_wp->w_cursor.lnum = 1;
new_wp->w_scbind_pos = 1;
+ new_wp->w_floating = 0;
/* We won't calculate w_fraction until resizing the window */
new_wp->w_fraction = 0;
@@ -4204,6 +4662,13 @@ int win_comp_pos(void)
int col = 0;
frame_comp_pos(topframe, &row, &col);
+
+ // 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);
+ }
+
return row;
}
@@ -4263,8 +4728,6 @@ void win_setheight(int height)
*/
void win_setheight_win(int height, win_T *win)
{
- int row;
-
if (win == curwin) {
/* Always keep current window at least one line high, even when
* 'winminheight' is zero. */
@@ -4274,21 +4737,28 @@ void win_setheight_win(int height, win_T *win)
height = 1;
}
- frame_setheight(win->w_frame, height + win->w_status_height);
+ if (win->w_floating) {
+ if (win->w_float_config.external) {
+ win_config_float(win, win->w_width, height, win->w_float_config);
+ } else {
+ beep_flush();
+ return;
+ }
+ } else {
+ frame_setheight(win->w_frame, height + win->w_status_height);
- /* recompute the window positions */
- row = win_comp_pos();
+ // recompute the window positions
+ int row = win_comp_pos();
- /*
- * If there is extra space created between the last window and the command
- * line, clear it.
- */
- if (full_screen && msg_scrolled == 0 && row < cmdline_row) {
- grid_fill(&default_grid, row, cmdline_row, 0, (int)Columns, ' ', ' ', 0);
+ // If there is extra space created between the last window and the command
+ // line, clear it.
+ if (full_screen && msg_scrolled == 0 && row < cmdline_row) {
+ grid_fill(&default_grid, row, cmdline_row, 0, (int)Columns, ' ', ' ', 0);
+ }
+ cmdline_row = row;
+ msg_row = row;
+ msg_col = 0;
}
- cmdline_row = row;
- msg_row = row;
- msg_col = 0;
redraw_all_later(NOT_VALID);
}
@@ -4358,14 +4828,16 @@ static void frame_setheight(frame_T *curfrp, int height)
if (frp != curfrp)
room -= frame_minheight(frp, NULL);
}
- if (curfrp->fr_width != Columns)
+ if (curfrp->fr_width != Columns) {
room_cmdline = 0;
- else {
- room_cmdline = Rows - p_ch - (lastwin->w_winrow
- + lastwin->w_height +
- lastwin->w_status_height);
- if (room_cmdline < 0)
+ } else {
+ win_T *wp = lastwin_nofloating();
+ room_cmdline = Rows - p_ch - (wp->w_winrow
+ + wp->w_height +
+ wp->w_status_height);
+ if (room_cmdline < 0) {
room_cmdline = 0;
+ }
}
if (height <= room + room_cmdline) {
@@ -4470,11 +4942,19 @@ void win_setwidth_win(int width, win_T *wp)
if (width == 0)
width = 1;
}
+ if (wp->w_floating) {
+ if (wp->w_float_config.external) {
+ win_config_float(wp, width, wp->w_height, wp->w_float_config);
+ } else {
+ beep_flush();
+ return;
+ }
+ } else {
+ frame_setwidth(wp->w_frame, width + wp->w_vsep_width);
- frame_setwidth(wp->w_frame, width + wp->w_vsep_width);
-
- /* recompute the window positions */
- (void)win_comp_pos();
+ // recompute the window positions
+ (void)win_comp_pos();
+ }
redraw_all_later(NOT_VALID);
}
@@ -5015,6 +5495,7 @@ void win_set_inner_size(win_T *wp)
if (!exiting) {
scroll_to_fraction(wp, prev_height);
}
+ redraw_win_later(wp, NOT_VALID); // SOME_VALID??
}
if (width != wp->w_width_inner) {
@@ -5026,6 +5507,7 @@ void win_set_inner_size(win_T *wp)
update_topline();
curs_columns(true); // validate w_wrow
}
+ redraw_win_later(wp, NOT_VALID);
}
if (wp->w_buffer->terminal) {
@@ -5039,9 +5521,7 @@ void win_new_width(win_T *wp, int width)
wp->w_width = width;
win_set_inner_size(wp);
- redraw_win_later(wp, NOT_VALID);
- wp->w_redr_status = TRUE;
-
+ wp->w_redr_status = true;
wp->w_pos_changed = true;
}
@@ -5379,7 +5859,7 @@ int min_rows(void)
/// Check that there is only one window (and only one tab page), not counting a
/// help or preview window, unless it is the current window. Does not count
-/// "aucmd_win".
+/// "aucmd_win". Does not count floats unless it is current.
bool only_one_window(void) FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
{
// If there is another tab page there always is another window.
@@ -5390,7 +5870,7 @@ bool only_one_window(void) FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
int count = 0;
FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
if (wp->w_buffer != NULL
- && (!((bt_help(wp->w_buffer) && !bt_help(curbuf))
+ && (!((bt_help(wp->w_buffer) && !bt_help(curbuf)) || wp->w_floating
|| wp->w_p_pvw) || wp == curwin) && wp != aucmd_win) {
count++;
}
@@ -6080,22 +6560,24 @@ void win_findbuf(typval_T *argvars, list_T *list)
}
}
-void win_ui_flush(void)
+void win_ui_flush_positions(void)
{
- if (!ui_has(kUIMultigrid)) {
- return;
- }
-
FOR_ALL_TAB_WINDOWS(tp, wp) {
if (wp->w_pos_changed && wp->w_grid.chars != NULL) {
if (tp == curtab) {
- ui_call_win_pos(wp->w_grid.handle, wp->handle, wp->w_winrow,
- wp->w_wincol, wp->w_width, wp->w_height);
+ ui_ext_win_position(wp);
} else {
ui_call_win_hide(wp->w_grid.handle);
}
wp->w_pos_changed = false;
}
}
+}
+win_T *lastwin_nofloating(void) {
+ win_T *res = lastwin;
+ while (res->w_floating) {
+ res = res->w_prev;
+ }
+ return res;
}
generated by cgit (git 2.34.1) at 2025-05-09 14:06:01 +0000