1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
|
*popup.txt* For Vim version 8.1. Last change: 2019 May 26
VIM REFERENCE MANUAL by Bram Moolenaar
Displaying text in floating window. *popup* *popup-window*
THIS IS UNDER DESIGN - ANYTHING MAY STILL CHANGE
1. Introduction |popup-intro|
2. Functions |popup-functions|
3. Examples |popup-examples|
{not available if the |+eval| feature was disabled at compile time}
{not able to use text properties if the |+textprop| feature was disabled at
compile time}
==============================================================================
1. Introduction *popup-intro*
We are talking about popup windows here, text that goes on top of the regular
windows and is under control of a plugin. You cannot edit the text in the
popup window like with regular windows.
A popup window can be used for such things as:
- briefly show a message without overwriting the command line
- prompt the user with a dialog
- display contextual information while typing
- give extra information for auto-completion
The text in the popup window can be colored with |text-properties|. It is
also possible to use syntax highlighting.
The default color used is "Pmenu". If you prefer something else use the
"highlight" argument or the 'wincolor' option, e.g.: >
hi MyPopupColor ctermbg=lightblue guibg=lightblue
call setwinvar(winid, '&wincolor', 'MyPopupColor')
'hlsearch' and match highlighting are not displayed in a popup window.
A popup window has a window-ID like other windows, but behaves differently.
The size can be up to the whole Vim window and it overlaps other windows.
Popup windows can also overlap each other.
The popup window contains a buffer, and that buffer is always associated with
the popup window. The window cannot be used in Normal, Visual or Insert mode,
it does not get keyboard focus. You can use functions like `setbufline()` to
change the text in the buffer. There are more differences from how this
window and buffer behave compared to regular windows and buffers, see
|popup-buffer|.
If this is not what you are looking for, check out other popup functionality:
- popup menu, see |popup-menu|
- balloon, see |balloon-eval|
WINDOW POSITION AND SIZE *popup-position*
The height of the window is normally equal to the number of, possibly
wrapping, lines in the buffer. It can be limited with the "maxheight"
property. You can use empty lines to increase the height.
The width of the window is normally equal to the longest line in the buffer.
It can be limited with the "maxwidth" property. You can use spaces to
increase the width.
By default the 'wrap' option is set, so that no text disappears. However, if
there is not enough space, some text may be invisible.
TODO:
Example how to use syntax highlighting of a code snippet.
Scrolling: When the screen scrolls up for output of an Ex command, what
happens with popups?
1. Stay where they are. Problem: listed text may go behind and can't be read.
2. Scroll with the page. What if they get updated? Either postpone, or take
the scroll offset into account.
Probably 2. is the best choice.
IMPLEMENTATION:
- Code is in popupwin.c
- Implement list of lines with text properties
- Implement filter.
- Handle screen resize in screenalloc().
- Make redrawing more efficient and avoid flicker.
- Properly figure out the size and position.
- Implement all the unimplemented options and features.
==============================================================================
2. Functions *popup-functions*
THIS IS UNDER DESIGN - ANYTHING MAY STILL CHANGE
[functions to be moved to eval.txt later, keep overview of functions here]
popup_create({text}, {options}) *popup_create()*
Open a popup window showing {text}, which is either:
- a string
- a list of strings
- a list of text lines with text properties
{not implemented yet}
{options} is a dictionary with many possible entries.
See |popup_create-usage| for details.
Returns a window-ID, which can be used with other popup
functions. Use `winbufnr()` to get the number of the buffer
in the window: >
let winid = popup_create('hello', {})
let bufnr = winbufnr(winid)
call setbufline(bufnr, 2, 'second line')
< In case of failure zero is returned.
popup_close({id}) *popup_close()*
Close popup {id}. The window and the associated buffer will
be deleted.
popup_dialog({text}, {options}) *popup_dialog()*
{not implemented yet}
Just like |popup_create()| but with these default options: >
call popup_create({text}, {
\ 'pos': 'center',
\ 'zindex': 200,
\ 'border': [],
\})
< Use {options} to change the properties.
popup_notification({text}, {options}) *popup_notification()*
{not implemented yet}
Show the {text} for 3 seconds at the top of the Vim window.
This works like: >
call popup_create({text}, {
\ 'line': 1,
\ 'col': 10,
\ 'time': 3000,
\ 'tab': -1,
\ 'zindex': 200,
\ 'highlight': 'WarningMsg',
\ 'border': [],
\ })
< Use {options} to change the properties.
popup_atcursor({text}, {options}) *popup_atcursor()*
{not implemented yet}
Show the {text} above the cursor, and close it when the cursor
moves. This works like: >
call popup_create({text}, {
\ 'line': 'cursor-1',
\ 'col': 'cursor',
\ 'moved': 'WORD',
\ })
< Use {options} to change the properties.
popup_menu({text}, {options}) *popup_menu()*
{not implemented yet}
Show the {text} near the cursor, handle selecting one of the
items with cursorkeys, and close it an item is selected with
Space or Enter. {text} should have multiple lines to make this
useful. This works like: >
call popup_create({text}, {
\ 'pos': 'center',
\ 'zindex': 200,
\ 'wrap': 0,
\ 'border': [],
\ 'filter': 'popup_filter_menu',
\ })
< Use {options} to change the properties. Should at least set
"callback" to a function that handles the selected item.
popup_hide({id}) *popup_hide()*
If {id} is a displayed popup, hide it now. If the popup has a
filter it will not be invoked for so long as the popup is
hidden.
If window {id} does not exist nothing happens. If window {id}
exists but is not a popup window an error is given. *E993*
popup_show({id}) *popup_show()*
If {id} is a hidden popup, show it now.
For {id} see `popup_hide()`.
popup_move({id}, {options}) *popup_move()*
{not implemented yet}
Move popup {id} to the position speficied with {options}.
{options} may contain the items from |popup_create()| that
specify the popup position: "line", "col", "pos", "maxheight",
"minheight", "maxwidth" and "minwidth".
For {id} see `popup_hide()`.
popup_filter_menu({id}, {key}) *popup_filter_menu()*
{not implemented yet}
Filter that can be used for a popup. It handles the cursor
keys to move the selected index in the popup. Space and Enter
can be used to select an item. Invokes the "callback" of the
popup menu with the index of the selected line as the second
argument.
popup_filter_yesno({id}, {key}) *popup_filter_yesno()*
{not implemented yet}
Filter that can be used for a popup. It handles only the keys
'y', 'Y' and 'n' or 'N'. Invokes the "callback" of the
popup menu with the 1 for 'y' or 'Y' and zero for 'n' or 'N'
as the second argument. Pressing Esc and CTRL-C works like
pressing 'n'.
popup_setoptions({id}, {options}) *popup_setoptions()*
{not implemented yet}
Override options in popup {id} with entries in {options}.
popup_getoptions({id}) *popup_getoptions()*
{not implemented yet}
Return the {options} for popup {id}.
popup_getposition({id}) *popup_getposition()*
{not implemented yet}
Return the position and size of popup {id}. Returns a Dict
with these entries:
col screen column of the popup, one-based
line screen line of the popup, one-based
width width of the popup in screen cells
height height of the popup in screen cells
win_execute({id}, {command})
{not implemented yet}
Like `execute()` but in the context of window {id}.
The window will temporarily be made the current window,
without triggering autocommands.
Example: >
call win_execute(winid, 'syntax enable')
<
*:popupclear* *:popupc*
:popupc[lear] Emergency solution to a misbehaving plugin: close all popup
windows.
POPUP BUFFER AND WINDOW *popup-buffer*
A new buffer is created to hold the text and text properties of the popup
window. The buffer is always associated with the popup window and
manipulation is restricted:
- the buffer has no name
- 'buftype' is "popup"
- 'swapfile' is off
- 'bufhidden' is "hide"
- 'buflisted' is off
- 'undolevels' is -1: no undo at all
TODO: more
It is possible to change these options, but anything might break then, so
better leave them alone.
The window does have a cursor position, but the cursor is not displayed.
Options can be set on the window with `setwinvar()`, e.g.: >
call setwinvar(winid, '&wrap', 0)
And options can be set on the buffer with `setbufvar()`, e.g.: >
call setbufvar(winbufnr(winid), '&filetype', 'java')
POPUP_CREATE() ARGUMENTS *popup_create-usage*
The first argument of |popup_create()| specifies the text to be displayed, and
optionally text properties. It is in one of three forms:
- a string
- a list of strings
- a list of dictionaries, where each dictionary has these entries:
text String with the text to display.
props A list of text properties. Optional.
Each entry is a dictionary, like the third argument of
|prop_add()|, but specifying the column in the
dictionary with a "col" entry, see below:
|popup-props|.
The second argument of |popup_create()| is a dictionary with options:
line screen line where to position the popup; can use
"cursor", "cursor+1" or "cursor-1" to use the line of
the cursor and add or subtract a number of lines;
default is "cursor-1".
{only number is implemented}
col screen column where to position the popup; can use
"cursor" to use the column of the cursor, "cursor+99"
and "cursor-99" to add or subtract a number of
columns; default is "cursor"
{only number is implemented}
pos "topleft", "topright", "botleft" or "botright":
defines what corner of the popup "line" and "col" are
used for. Default is "botleft". Alternatively
"center" can be used to position the popup in the
center of the Vim window.
{not implemented yet}
flip when TRUE (the default) and the position is relative
to the cursor, flip to below or above the cursor to
avoid overlap with the |popupmenu-completion| or
another popup with a higher "zindex"
{not implemented yet}
maxheight maximum height
minheight minimum height
{not implemented yet}
maxwidth maximum width
minwidth minimum width
{not implemented yet}
hidden when TRUE the popup exists but is not displayed; use
`popup_show()` to unhide it.
{not implemented yet}
tab when -1: display the popup on all tabs; when 0 (the
default): display the popup on the current tab;
otherwise the number of the tab page the popup is
displayed on; when invalid the current tab is used
{only -1 and 0 are implemented}
title text to be displayed above the first item in the
popup, on top of any border
{not implemented yet}
wrap TRUE to make the lines wrap (default TRUE)
{not implemented yet}
highlight highlight group name to use for the text, stored in
the 'wincolor' option
border list with numbers, defining the border thickness
above/right/below/left of the popup; an empty list
uses a border of 1 all around
{not implemented yet}
borderhighlight highlight group name to use for the border
{not implemented yet}
borderchars list with characters, defining the character to use
for the top/right/bottom/left border; optionally
followed by the character to use for the
topright/botright/botleft/topleft corner; an empty
list can be used to show a double line all around
{not implemented yet}
zindex priority for the popup, default 50
time time in milliseconds after which the popup will close;
when omitted |popup_close()| must be used.
moved "cell": close the popup if the cursor moved at least
one screen cell; "word" allows for moving within
|<cword>|, "WORD" allows for moving within |<cWORD>|,
a list with two numbers specifies the start and end
column
{not implemented yet}
filter a callback that can filter typed characters, see
|popup-filter|
{not implemented yet}
callback a callback to be used when the popup closes, e.g. when
using |popup_filter_menu()|, see |popup-callback|.
{not implemented yet}
Depending on the "zindex" the popup goes under or above other popups. The
completion menu (|popup-menu|) has zindex 100. For messages that occur for a
short time the suggestion is to use zindex 1000.
By default text wraps, which causes a line in {lines} to occupy more than one
screen line. When "wrap" is FALSE then the text outside of the popup or
outside of the Vim window will not be displayed, thus truncated.
POPUP TEXT PROPERTIES *popup-props*
These are similar to the third argument of |prop_add()| except:
- "lnum" is always the current line in the list
- "bufnr" is always the buffer of the popup
- "col" is in the Dict instead of a separate argument
- "transparent" is extra
So we get:
col starting column, counted in bytes, use one for the
first column.
length length of text in bytes; can be zero
end_lnum line number for the end of the text
end_col column just after the text; not used when "length" is
present; when {col} and "end_col" are equal, this is a
zero-width text property
id user defined ID for the property; when omitted zero is
used
type name of the text property type, as added with
|prop_type_add()|
transparent do not show these characters, show the text under it;
if there is an border character to the right or below
it will be made transparent as well
{not implemented yet}
POPUP FILTER *popup-filter*
{not implemented yet}
A callback that gets any typed keys while a popup is displayed. The filter is
not invoked when the popup is hidden.
The filter can return TRUE to indicate the key has been handled and is to be
discarded, or FALSE to let Vim handle the key as usual in the current state.
In case it returns FALSE and there is another popup window visible, that
filter is also called. The filter of the popup window with the highest zindex
is called first.
The filter function is called with two arguments: the ID of the popup and the
key.
Some common key actions:
Esc close the popup
cursor keys select another entry
Tab accept current suggestion
A mouse click arrives as <LeftMouse>. The coordinates are in
v:mouse_popup_col and v:mouse_popup_row. The top-left screen cell of the
popup is col 1, row 1 (not counting the border).
Vim provides standard filters |popup_filter_menu()| and
|popup_filter_yesno()|.
POPUP CALLBACK *popup-callback*
{not implemented yet}
A callback that is invoked when the popup closes. Used by
|popup_filter_menu()|. Invoked with two arguments: the ID of the popup and
the result, which would usually be an index in the popup lines, or whatever
the filter wants to pass.
==============================================================================
3. Examples *popup-examples*
TODO
Prompt the user to press y/Y or n/N: >
func MyDialogHandler(id, result)
if a:result
" ... 'y' or 'Y' was pressed
endif
endfunc
call popup_create(['Continue? y/n'], {
\ 'filter': 'popup_filter_yesno',
\ 'callback': 'MyDialogHandler',
\ })
<
vim:tw=78:ts=8:noet:ft=help:norl:
|