1 /* vi:set ts=8 sts=4 sw=4 noet:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9
10 /*
11 * popupmenu.c: Popup menu (PUM)
12 */
13 #include "vim.h"
14
15 static pumitem_T *pum_array = NULL; // items of displayed pum
16 static int pum_size; // nr of items in "pum_array"
17 static int pum_selected; // index of selected item or -1
18 static int pum_first = 0; // index of top item
19
20 static int call_update_screen = FALSE;
21
22 static int pum_height; // nr of displayed pum items
23 static int pum_width; // width of displayed pum items
24 static int pum_base_width; // width of pum items base
25 static int pum_kind_width; // width of pum items kind column
26 static int pum_extra_width; // width of extra stuff
27 static int pum_scrollbar; // TRUE when scrollbar present
28
29 static int pum_row; // top row of pum
30 static int pum_col; // left column of pum
31
32 static win_T *pum_window = NULL;
33 static int pum_win_row;
34 static int pum_win_height;
35 static int pum_win_col;
36 static int pum_win_wcol;
37 static int pum_win_width;
38
39 // Some parts are not updated when a popup menu is visible. Setting this flag
40 // makes pum_visible() return FALSE even when there is a popup menu.
41 static int pum_pretend_not_visible = FALSE;
42
43 static int pum_set_selected(int n, int repeat);
44
45 #define PUM_DEF_HEIGHT 10
46
47 static void
pum_compute_size(void)48 pum_compute_size(void)
49 {
50 int i;
51 int w;
52
53 // Compute the width of the widest match and the widest extra.
54 pum_base_width = 0;
55 pum_kind_width = 0;
56 pum_extra_width = 0;
57 for (i = 0; i < pum_size; ++i)
58 {
59 if (pum_array[i].pum_text != NULL)
60 {
61 w = vim_strsize(pum_array[i].pum_text);
62 if (pum_base_width < w)
63 pum_base_width = w;
64 }
65 if (pum_array[i].pum_kind != NULL)
66 {
67 w = vim_strsize(pum_array[i].pum_kind) + 1;
68 if (pum_kind_width < w)
69 pum_kind_width = w;
70 }
71 if (pum_array[i].pum_extra != NULL)
72 {
73 w = vim_strsize(pum_array[i].pum_extra) + 1;
74 if (pum_extra_width < w)
75 pum_extra_width = w;
76 }
77 }
78 }
79
80 /*
81 * Show the popup menu with items "array[size]".
82 * "array" must remain valid until pum_undisplay() is called!
83 * When possible the leftmost character is aligned with cursor column.
84 * The menu appears above the screen line "row" or at "row" + "height" - 1.
85 */
86 void
pum_display(pumitem_T * array,int size,int selected)87 pum_display(
88 pumitem_T *array,
89 int size,
90 int selected) // index of initially selected item, none if
91 // out of range
92 {
93 int def_width;
94 int max_width;
95 int context_lines;
96 int cursor_col;
97 int above_row;
98 int below_row;
99 int redo_count = 0;
100 #if defined(FEAT_QUICKFIX)
101 win_T *pvwin;
102 #endif
103
104 do
105 {
106 def_width = p_pw;
107 above_row = 0;
108 below_row = cmdline_row;
109
110 // Pretend the pum is already there to avoid that must_redraw is set
111 // when 'cuc' is on.
112 pum_array = (pumitem_T *)1;
113 validate_cursor_col();
114 pum_array = NULL;
115
116 // Remember the essential parts of the window position and size, so we
117 // can decide when to reposition the popup menu.
118 pum_window = curwin;
119 pum_win_row = curwin->w_wrow + W_WINROW(curwin);
120 pum_win_height = curwin->w_height;
121 pum_win_col = curwin->w_wincol;
122 pum_win_wcol = curwin->w_wcol;
123 pum_win_width = curwin->w_width;
124
125 #if defined(FEAT_QUICKFIX)
126 FOR_ALL_WINDOWS(pvwin)
127 if (pvwin->w_p_pvw)
128 break;
129 if (pvwin != NULL)
130 {
131 if (W_WINROW(pvwin) < W_WINROW(curwin))
132 above_row = W_WINROW(pvwin) + pvwin->w_height;
133 else if (W_WINROW(pvwin) > W_WINROW(curwin) + curwin->w_height)
134 below_row = W_WINROW(pvwin);
135 }
136 #endif
137
138 /*
139 * Figure out the size and position of the pum.
140 */
141 if (size < PUM_DEF_HEIGHT)
142 pum_height = size;
143 else
144 pum_height = PUM_DEF_HEIGHT;
145 if (p_ph > 0 && pum_height > p_ph)
146 pum_height = p_ph;
147
148 // Put the pum below "pum_win_row" if possible. If there are few lines
149 // decide on where there is more room.
150 if (pum_win_row + 2 >= below_row - pum_height
151 && pum_win_row - above_row > (below_row - above_row) / 2)
152 {
153 // pum above "pum_win_row"
154
155 // Leave two lines of context if possible
156 if (curwin->w_wrow - curwin->w_cline_row >= 2)
157 context_lines = 2;
158 else
159 context_lines = curwin->w_wrow - curwin->w_cline_row;
160
161 if (pum_win_row >= size + context_lines)
162 {
163 pum_row = pum_win_row - size - context_lines;
164 pum_height = size;
165 }
166 else
167 {
168 pum_row = 0;
169 pum_height = pum_win_row - context_lines;
170 }
171 if (p_ph > 0 && pum_height > p_ph)
172 {
173 pum_row += pum_height - p_ph;
174 pum_height = p_ph;
175 }
176 }
177 else
178 {
179 // pum below "pum_win_row"
180
181 // Leave two lines of context if possible
182 validate_cheight();
183 if (curwin->w_cline_row
184 + curwin->w_cline_height - curwin->w_wrow >= 3)
185 context_lines = 3;
186 else
187 context_lines = curwin->w_cline_row
188 + curwin->w_cline_height - curwin->w_wrow;
189
190 pum_row = pum_win_row + context_lines;
191 if (size > below_row - pum_row)
192 pum_height = below_row - pum_row;
193 else
194 pum_height = size;
195 if (p_ph > 0 && pum_height > p_ph)
196 pum_height = p_ph;
197 }
198
199 // don't display when we only have room for one line
200 if (pum_height < 1 || (pum_height == 1 && size > 1))
201 return;
202
203 #if defined(FEAT_QUICKFIX)
204 // If there is a preview window above avoid drawing over it.
205 if (pvwin != NULL && pum_row < above_row && pum_height > above_row)
206 {
207 pum_row = above_row;
208 pum_height = pum_win_row - above_row;
209 }
210 #endif
211
212 pum_array = array;
213 pum_size = size;
214 pum_compute_size();
215 max_width = pum_base_width;
216
217 // Calculate column
218 #ifdef FEAT_RIGHTLEFT
219 if (curwin->w_p_rl)
220 cursor_col = curwin->w_wincol + curwin->w_width
221 - curwin->w_wcol - 1;
222 else
223 #endif
224 cursor_col = curwin->w_wincol + curwin->w_wcol;
225
226 // if there are more items than room we need a scrollbar
227 if (pum_height < size)
228 {
229 pum_scrollbar = 1;
230 ++max_width;
231 }
232 else
233 pum_scrollbar = 0;
234
235 if (def_width < max_width)
236 def_width = max_width;
237
238 if (((cursor_col < Columns - p_pw
239 || cursor_col < Columns - max_width)
240 #ifdef FEAT_RIGHTLEFT
241 && !curwin->w_p_rl)
242 || (curwin->w_p_rl
243 && (cursor_col > p_pw || cursor_col > max_width)
244 #endif
245 ))
246 {
247 // align pum with "cursor_col"
248 pum_col = cursor_col;
249
250 // start with the maximum space available
251 #ifdef FEAT_RIGHTLEFT
252 if (curwin->w_p_rl)
253 pum_width = pum_col - pum_scrollbar + 1;
254 else
255 #endif
256 pum_width = Columns - pum_col - pum_scrollbar;
257
258 if (pum_width > max_width + pum_kind_width + pum_extra_width + 1
259 && pum_width > p_pw)
260 {
261 // the width is more than needed for the items, make it
262 // narrower
263 pum_width = max_width + pum_kind_width + pum_extra_width + 1;
264 if (pum_width < p_pw)
265 pum_width = p_pw;
266 }
267 else if (((cursor_col > p_pw || cursor_col > max_width)
268 #ifdef FEAT_RIGHTLEFT
269 && !curwin->w_p_rl)
270 || (curwin->w_p_rl && (cursor_col < Columns - p_pw
271 || cursor_col < Columns - max_width)
272 #endif
273 ))
274 {
275 // align pum edge with "cursor_col"
276 #ifdef FEAT_RIGHTLEFT
277 if (curwin->w_p_rl
278 && W_ENDCOL(curwin) < max_width + pum_scrollbar + 1)
279 {
280 pum_col = cursor_col + max_width + pum_scrollbar + 1;
281 if (pum_col >= Columns)
282 pum_col = Columns - 1;
283 }
284 else if (!curwin->w_p_rl)
285 #endif
286 {
287 if (curwin->w_wincol > Columns - max_width - pum_scrollbar
288 && max_width <= p_pw)
289 {
290 // use full width to end of the screen
291 pum_col = Columns - max_width - pum_scrollbar;
292 if (pum_col < 0)
293 pum_col = 0;
294 }
295 }
296
297 #ifdef FEAT_RIGHTLEFT
298 if (curwin->w_p_rl)
299 pum_width = pum_col - pum_scrollbar + 1;
300 else
301 #endif
302 pum_width = Columns - pum_col - pum_scrollbar;
303
304 if (pum_width < p_pw)
305 {
306 pum_width = p_pw;
307 #ifdef FEAT_RIGHTLEFT
308 if (curwin->w_p_rl)
309 {
310 if (pum_width > pum_col)
311 pum_width = pum_col;
312 }
313 else
314 #endif
315 {
316 if (pum_width >= Columns - pum_col)
317 pum_width = Columns - pum_col - 1;
318 }
319 }
320 else if (pum_width > max_width + pum_kind_width
321 + pum_extra_width + 1
322 && pum_width > p_pw)
323 {
324 pum_width = max_width + pum_kind_width
325 + pum_extra_width + 1;
326 if (pum_width < p_pw)
327 pum_width = p_pw;
328 }
329 }
330
331 }
332 else if (Columns < def_width)
333 {
334 // not enough room, will use what we have
335 #ifdef FEAT_RIGHTLEFT
336 if (curwin->w_p_rl)
337 pum_col = Columns - 1;
338 else
339 #endif
340 pum_col = 0;
341 pum_width = Columns - 1;
342 }
343 else
344 {
345 if (max_width > p_pw)
346 max_width = p_pw; // truncate
347 #ifdef FEAT_RIGHTLEFT
348 if (curwin->w_p_rl)
349 pum_col = max_width - 1;
350 else
351 #endif
352 pum_col = Columns - max_width;
353 pum_width = max_width - pum_scrollbar;
354 }
355
356 // Set selected item and redraw. If the window size changed need to
357 // redo the positioning. Limit this to two times, when there is not
358 // much room the window size will keep changing.
359 } while (pum_set_selected(selected, redo_count) && ++redo_count <= 2);
360
361 pum_redraw();
362 }
363
364 /*
365 * Set a flag that when pum_redraw() is called it first calls update_screen().
366 * This will avoid clearing and redrawing the popup menu, prevent flicker.
367 */
368 void
pum_call_update_screen()369 pum_call_update_screen()
370 {
371 call_update_screen = TRUE;
372
373 // Update the cursor position to be able to compute the popup menu
374 // position. The cursor line length may have changed because of the
375 // inserted completion.
376 curwin->w_valid &= ~(VALID_CROW|VALID_CHEIGHT);
377 validate_cursor();
378 }
379
380 /*
381 * Return TRUE if we are going to redraw the popup menu and the screen position
382 * "row"/"col" is under the popup menu.
383 */
384 int
pum_under_menu(int row,int col,int only_redrawing)385 pum_under_menu(int row, int col, int only_redrawing)
386 {
387 return (!only_redrawing || pum_will_redraw)
388 && row >= pum_row
389 && row < pum_row + pum_height
390 && col >= pum_col - 1
391 && col < pum_col + pum_width + pum_scrollbar;
392 }
393
394 /*
395 * Redraw the popup menu, using "pum_first" and "pum_selected".
396 */
397 void
pum_redraw(void)398 pum_redraw(void)
399 {
400 int row = pum_row;
401 int col;
402 int attr_norm = highlight_attr[HLF_PNI];
403 int attr_select = highlight_attr[HLF_PSI];
404 int attr_scroll = highlight_attr[HLF_PSB];
405 int attr_thumb = highlight_attr[HLF_PST];
406 int attr;
407 int i;
408 int idx;
409 char_u *s;
410 char_u *p = NULL;
411 int totwidth, width, w;
412 int thumb_pos = 0;
413 int thumb_height = 1;
414 int round;
415 int n;
416
417 if (call_update_screen)
418 {
419 call_update_screen = FALSE;
420 // Do not redraw in pum_may_redraw() and don't draw in the area where
421 // the popup menu will be.
422 pum_will_redraw = TRUE;
423 update_screen(0);
424 pum_will_redraw = FALSE;
425 }
426
427 // never display more than we have
428 if (pum_first > pum_size - pum_height)
429 pum_first = pum_size - pum_height;
430
431 if (pum_scrollbar)
432 {
433 thumb_height = pum_height * pum_height / pum_size;
434 if (thumb_height == 0)
435 thumb_height = 1;
436 thumb_pos = (pum_first * (pum_height - thumb_height)
437 + (pum_size - pum_height) / 2)
438 / (pum_size - pum_height);
439 }
440
441 #ifdef FEAT_PROP_POPUP
442 // The popup menu is drawn over popup menus with zindex under
443 // POPUPMENU_ZINDEX.
444 screen_zindex = POPUPMENU_ZINDEX;
445 #endif
446
447 for (i = 0; i < pum_height; ++i)
448 {
449 idx = i + pum_first;
450 attr = (idx == pum_selected) ? attr_select : attr_norm;
451
452 // prepend a space if there is room
453 #ifdef FEAT_RIGHTLEFT
454 if (curwin->w_p_rl)
455 {
456 if (pum_col < curwin->w_wincol + curwin->w_width - 1)
457 screen_putchar(' ', row, pum_col + 1, attr);
458 }
459 else
460 #endif
461 if (pum_col > 0)
462 screen_putchar(' ', row, pum_col - 1, attr);
463
464 // Display each entry, use two spaces for a Tab.
465 // Do this 3 times: For the main text, kind and extra info
466 col = pum_col;
467 totwidth = 0;
468 for (round = 1; round <= 3; ++round)
469 {
470 width = 0;
471 s = NULL;
472 switch (round)
473 {
474 case 1: p = pum_array[idx].pum_text; break;
475 case 2: p = pum_array[idx].pum_kind; break;
476 case 3: p = pum_array[idx].pum_extra; break;
477 }
478 if (p != NULL)
479 for ( ; ; MB_PTR_ADV(p))
480 {
481 if (s == NULL)
482 s = p;
483 w = ptr2cells(p);
484 if (*p == NUL || *p == TAB || totwidth + w > pum_width)
485 {
486 // Display the text that fits or comes before a Tab.
487 // First convert it to printable characters.
488 char_u *st;
489 int saved = *p;
490
491 if (saved != NUL)
492 *p = NUL;
493 st = transstr(s);
494 if (saved != NUL)
495 *p = saved;
496 #ifdef FEAT_RIGHTLEFT
497 if (curwin->w_p_rl)
498 {
499 if (st != NULL)
500 {
501 char_u *rt = reverse_text(st);
502
503 if (rt != NULL)
504 {
505 char_u *rt_start = rt;
506 int size;
507
508 size = vim_strsize(rt);
509 if (size > pum_width)
510 {
511 do
512 {
513 size -= has_mbyte
514 ? (*mb_ptr2cells)(rt) : 1;
515 MB_PTR_ADV(rt);
516 } while (size > pum_width);
517
518 if (size < pum_width)
519 {
520 // Most left character requires
521 // 2-cells but only 1 cell is
522 // available on screen. Put a
523 // '<' on the left of the pum
524 // item
525 *(--rt) = '<';
526 size++;
527 }
528 }
529 screen_puts_len(rt, (int)STRLEN(rt),
530 row, col - size + 1, attr);
531 vim_free(rt_start);
532 }
533 vim_free(st);
534 }
535 col -= width;
536 }
537 else
538 #endif
539 {
540 if (st != NULL)
541 {
542 int size = (int)STRLEN(st);
543 int cells = (*mb_string2cells)(st, size);
544
545 // only draw the text that fits
546 while (size > 0
547 && col + cells > pum_width + pum_col)
548 {
549 --size;
550 if (has_mbyte)
551 {
552 size -= (*mb_head_off)(st, st + size);
553 cells -= (*mb_ptr2cells)(st + size);
554 }
555 else
556 --cells;
557 }
558 screen_puts_len(st, size, row, col, attr);
559 vim_free(st);
560 }
561 col += width;
562 }
563
564 if (*p != TAB)
565 break;
566
567 // Display two spaces for a Tab.
568 #ifdef FEAT_RIGHTLEFT
569 if (curwin->w_p_rl)
570 {
571 screen_puts_len((char_u *)" ", 2, row, col - 1,
572 attr);
573 col -= 2;
574 }
575 else
576 #endif
577 {
578 screen_puts_len((char_u *)" ", 2, row, col, attr);
579 col += 2;
580 }
581 totwidth += 2;
582 s = NULL; // start text at next char
583 width = 0;
584 }
585 else
586 width += w;
587 }
588
589 if (round > 1)
590 n = pum_kind_width + 1;
591 else
592 n = 1;
593
594 // Stop when there is nothing more to display.
595 if (round == 3
596 || (round == 2 && pum_array[idx].pum_extra == NULL)
597 || (round == 1 && pum_array[idx].pum_kind == NULL
598 && pum_array[idx].pum_extra == NULL)
599 || pum_base_width + n >= pum_width)
600 break;
601 #ifdef FEAT_RIGHTLEFT
602 if (curwin->w_p_rl)
603 {
604 screen_fill(row, row + 1, pum_col - pum_base_width - n + 1,
605 col + 1, ' ', ' ', attr);
606 col = pum_col - pum_base_width - n + 1;
607 }
608 else
609 #endif
610 {
611 screen_fill(row, row + 1, col, pum_col + pum_base_width + n,
612 ' ', ' ', attr);
613 col = pum_col + pum_base_width + n;
614 }
615 totwidth = pum_base_width + n;
616 }
617
618 #ifdef FEAT_RIGHTLEFT
619 if (curwin->w_p_rl)
620 screen_fill(row, row + 1, pum_col - pum_width + 1, col + 1, ' ',
621 ' ', attr);
622 else
623 #endif
624 screen_fill(row, row + 1, col, pum_col + pum_width, ' ', ' ',
625 attr);
626 if (pum_scrollbar > 0)
627 {
628 #ifdef FEAT_RIGHTLEFT
629 if (curwin->w_p_rl)
630 screen_putchar(' ', row, pum_col - pum_width,
631 i >= thumb_pos && i < thumb_pos + thumb_height
632 ? attr_thumb : attr_scroll);
633 else
634 #endif
635 screen_putchar(' ', row, pum_col + pum_width,
636 i >= thumb_pos && i < thumb_pos + thumb_height
637 ? attr_thumb : attr_scroll);
638 }
639
640 ++row;
641 }
642
643 #ifdef FEAT_PROP_POPUP
644 screen_zindex = 0;
645 #endif
646 }
647
648 #if (defined(FEAT_PROP_POPUP) && defined(FEAT_QUICKFIX)) || defined(PROTO)
649 /*
650 * Position the info popup relative to the popup menu item.
651 */
652 void
pum_position_info_popup(win_T * wp)653 pum_position_info_popup(win_T *wp)
654 {
655 int col = pum_col + pum_width + pum_scrollbar + 1;
656 int row = pum_row;
657 int botpos = POPPOS_BOTLEFT;
658 int used_maxwidth_opt = FALSE;
659
660 wp->w_popup_pos = POPPOS_TOPLEFT;
661 if (Columns - col < 20 && Columns - col < pum_col)
662 {
663 col = pum_col - 1;
664 wp->w_popup_pos = POPPOS_TOPRIGHT;
665 botpos = POPPOS_BOTRIGHT;
666 wp->w_maxwidth = pum_col - 1;
667 }
668 else
669 wp->w_maxwidth = Columns - col + 1;
670 wp->w_maxwidth -= popup_extra_width(wp);
671 if (wp->w_maxwidth_opt > 0 && wp->w_maxwidth > wp->w_maxwidth_opt)
672 {
673 // option value overrules computed value
674 wp->w_maxwidth = wp->w_maxwidth_opt;
675 used_maxwidth_opt = TRUE;
676 }
677
678 row -= popup_top_extra(wp);
679 if (wp->w_popup_flags & POPF_INFO_MENU)
680 {
681 if (pum_row < pum_win_row)
682 {
683 // menu above cursor line, align with bottom
684 row += pum_height;
685 wp->w_popup_pos = botpos;
686 }
687 else
688 // menu below cursor line, align with top
689 row += 1;
690 }
691 else
692 // align with the selected item
693 row += pum_selected - pum_first + 1;
694
695 wp->w_popup_flags &= ~POPF_HIDDEN;
696 if (wp->w_maxwidth < 10 && !used_maxwidth_opt)
697 // The popup is not going to fit or will overlap with the cursor
698 // position, hide the popup.
699 wp->w_popup_flags |= POPF_HIDDEN;
700 else
701 popup_set_wantpos_rowcol(wp, row, col);
702 }
703 #endif
704
705 /*
706 * Set the index of the currently selected item. The menu will scroll when
707 * necessary. When "n" is out of range don't scroll.
708 * This may be repeated when the preview window is used:
709 * "repeat" == 0: open preview window normally
710 * "repeat" == 1: open preview window but don't set the size
711 * "repeat" == 2: don't open preview window
712 * Returns TRUE when the window was resized and the location of the popup menu
713 * must be recomputed.
714 */
715 static int
pum_set_selected(int n,int repeat UNUSED)716 pum_set_selected(int n, int repeat UNUSED)
717 {
718 int resized = FALSE;
719 int context = pum_height / 2;
720 #ifdef FEAT_QUICKFIX
721 int prev_selected = pum_selected;
722 #endif
723 #if defined(FEAT_PROP_POPUP) && defined(FEAT_QUICKFIX)
724 int has_info = FALSE;
725 #endif
726
727 pum_selected = n;
728
729 if (pum_selected >= 0 && pum_selected < pum_size)
730 {
731 if (pum_first > pum_selected - 4)
732 {
733 // scroll down; when we did a jump it's probably a PageUp then
734 // scroll a whole page
735 if (pum_first > pum_selected - 2)
736 {
737 pum_first -= pum_height - 2;
738 if (pum_first < 0)
739 pum_first = 0;
740 else if (pum_first > pum_selected)
741 pum_first = pum_selected;
742 }
743 else
744 pum_first = pum_selected;
745 }
746 else if (pum_first < pum_selected - pum_height + 5)
747 {
748 // scroll up; when we did a jump it's probably a PageDown then
749 // scroll a whole page
750 if (pum_first < pum_selected - pum_height + 1 + 2)
751 {
752 pum_first += pum_height - 2;
753 if (pum_first < pum_selected - pum_height + 1)
754 pum_first = pum_selected - pum_height + 1;
755 }
756 else
757 pum_first = pum_selected - pum_height + 1;
758 }
759
760 // Give a few lines of context when possible.
761 if (context > 3)
762 context = 3;
763 if (pum_height > 2)
764 {
765 if (pum_first > pum_selected - context)
766 {
767 // scroll down
768 pum_first = pum_selected - context;
769 if (pum_first < 0)
770 pum_first = 0;
771 }
772 else if (pum_first < pum_selected + context - pum_height + 1)
773 {
774 // scroll up
775 pum_first = pum_selected + context - pum_height + 1;
776 }
777 }
778 // adjust for the number of lines displayed
779 if (pum_first > pum_size - pum_height)
780 pum_first = pum_size - pum_height;
781
782 #if defined(FEAT_QUICKFIX)
783 /*
784 * Show extra info in the preview window if there is something and
785 * 'completeopt' contains "preview" or "popup" or "popuphidden".
786 * Skip this when tried twice already.
787 * Skip this also when there is not much room.
788 * NOTE: Be very careful not to sync undo!
789 */
790 if (pum_array[pum_selected].pum_info != NULL
791 && Rows > 10
792 && repeat <= 1
793 && vim_strchr(p_cot, 'p') != NULL)
794 {
795 win_T *curwin_save = curwin;
796 tabpage_T *curtab_save = curtab;
797 int res = OK;
798 # ifdef FEAT_PROP_POPUP
799 use_popup_T use_popup;
800 # else
801 # define use_popup USEPOPUP_NONE
802 # endif
803 # ifdef FEAT_PROP_POPUP
804 has_info = TRUE;
805 if (strstr((char *)p_cot, "popuphidden") != NULL)
806 use_popup = USEPOPUP_HIDDEN;
807 else if (strstr((char *)p_cot, "popup") != NULL)
808 use_popup = USEPOPUP_NORMAL;
809 else
810 use_popup = USEPOPUP_NONE;
811 if (use_popup != USEPOPUP_NONE)
812 // don't use WinEnter or WinLeave autocommands for the info
813 // popup
814 block_autocmds();
815 # endif
816 // Open a preview window and set "curwin" to it.
817 // 3 lines by default, prefer 'previewheight' if set and smaller.
818 g_do_tagpreview = 3;
819 if (p_pvh > 0 && p_pvh < g_do_tagpreview)
820 g_do_tagpreview = p_pvh;
821 ++RedrawingDisabled;
822 // Prevent undo sync here, if an autocommand syncs undo weird
823 // things can happen to the undo tree.
824 ++no_u_sync;
825 resized = prepare_tagpreview(FALSE, FALSE, use_popup);
826 --no_u_sync;
827 --RedrawingDisabled;
828 g_do_tagpreview = 0;
829
830 if (curwin->w_p_pvw
831 # ifdef FEAT_PROP_POPUP
832 || (curwin->w_popup_flags & POPF_INFO)
833 # endif
834 )
835 {
836 if (!resized
837 && curbuf->b_nwindows == 1
838 && curbuf->b_fname == NULL
839 && bt_nofile(curbuf)
840 && curbuf->b_p_bh[0] == 'w')
841 {
842 // Already a "wipeout" buffer, make it empty.
843 while (!BUFEMPTY())
844 ml_delete((linenr_T)1);
845 }
846 else
847 {
848 // Don't want to sync undo in the current buffer.
849 ++no_u_sync;
850 res = do_ecmd(0, NULL, NULL, NULL, ECMD_ONE, 0, NULL);
851 --no_u_sync;
852 if (res == OK)
853 {
854 // Edit a new, empty buffer. Set options for a "wipeout"
855 // buffer.
856 set_option_value((char_u *)"swf", 0L, NULL, OPT_LOCAL);
857 set_option_value((char_u *)"bl", 0L, NULL, OPT_LOCAL);
858 set_option_value((char_u *)"bt", 0L,
859 (char_u *)"nofile", OPT_LOCAL);
860 set_option_value((char_u *)"bh", 0L,
861 (char_u *)"wipe", OPT_LOCAL);
862 set_option_value((char_u *)"diff", 0L,
863 NULL, OPT_LOCAL);
864 }
865 }
866 if (res == OK)
867 {
868 char_u *p, *e;
869 linenr_T lnum = 0;
870
871 for (p = pum_array[pum_selected].pum_info; *p != NUL; )
872 {
873 e = vim_strchr(p, '\n');
874 if (e == NULL)
875 {
876 ml_append(lnum++, p, 0, FALSE);
877 break;
878 }
879 else
880 {
881 *e = NUL;
882 ml_append(lnum++, p, (int)(e - p + 1), FALSE);
883 *e = '\n';
884 p = e + 1;
885 }
886 }
887 // delete the empty last line
888 ml_delete(curbuf->b_ml.ml_line_count);
889
890 // Increase the height of the preview window to show the
891 // text, but no more than 'previewheight' lines.
892 if (repeat == 0 && use_popup == USEPOPUP_NONE)
893 {
894 if (lnum > p_pvh)
895 lnum = p_pvh;
896 if (curwin->w_height < lnum)
897 {
898 win_setheight((int)lnum);
899 resized = TRUE;
900 }
901 }
902
903 curbuf->b_changed = 0;
904 curbuf->b_p_ma = FALSE;
905 if (pum_selected != prev_selected)
906 {
907 # ifdef FEAT_PROP_POPUP
908 curwin->w_firstline = 1;
909 # endif
910 curwin->w_topline = 1;
911 }
912 else if (curwin->w_topline > curbuf->b_ml.ml_line_count)
913 curwin->w_topline = curbuf->b_ml.ml_line_count;
914 curwin->w_cursor.lnum = curwin->w_topline;
915 curwin->w_cursor.col = 0;
916 # ifdef FEAT_PROP_POPUP
917 if (use_popup != USEPOPUP_NONE)
918 {
919 pum_position_info_popup(curwin);
920 if (win_valid(curwin_save))
921 redraw_win_later(curwin_save, SOME_VALID);
922 }
923 # endif
924 if ((curwin != curwin_save && win_valid(curwin_save))
925 || (curtab != curtab_save
926 && valid_tabpage(curtab_save)))
927 {
928 int save_redr_status;
929
930 if (curtab != curtab_save && valid_tabpage(curtab_save))
931 goto_tabpage_tp(curtab_save, FALSE, FALSE);
932
933 // When the first completion is done and the preview
934 // window is not resized, skip the preview window's
935 // status line redrawing.
936 if (ins_compl_active() && !resized)
937 curwin->w_redr_status = FALSE;
938
939 // Return cursor to where we were
940 validate_cursor();
941 redraw_later(SOME_VALID);
942
943 // When the preview window was resized we need to
944 // update the view on the buffer. Only go back to
945 // the window when needed, otherwise it will always be
946 // redrawn.
947 if (resized && win_valid(curwin_save))
948 {
949 ++no_u_sync;
950 win_enter(curwin_save, TRUE);
951 --no_u_sync;
952 update_topline();
953 }
954
955 // Update the screen before drawing the popup menu.
956 // Enable updating the status lines.
957 pum_pretend_not_visible = TRUE;
958
959 // But don't draw text at the new popup menu position,
960 // it causes flicker. When resizing we need to draw
961 // anyway, the position may change later.
962 // Also do not redraw the status line of the original
963 // current window here, to avoid it gets drawn with
964 // StatusLineNC for a moment and cause flicker.
965 pum_will_redraw = !resized;
966 save_redr_status = curwin_save->w_redr_status;
967 curwin_save->w_redr_status = FALSE;
968 update_screen(0);
969 pum_pretend_not_visible = FALSE;
970 pum_will_redraw = FALSE;
971 curwin_save->w_redr_status = save_redr_status;
972
973 if (!resized && win_valid(curwin_save))
974 {
975 # ifdef FEAT_PROP_POPUP
976 win_T *wp = curwin;
977 # endif
978 ++no_u_sync;
979 win_enter(curwin_save, TRUE);
980 --no_u_sync;
981 # ifdef FEAT_PROP_POPUP
982 if (use_popup == USEPOPUP_HIDDEN && win_valid(wp))
983 popup_hide(wp);
984 # endif
985 }
986
987 // May need to update the screen again when there are
988 // autocommands involved.
989 pum_pretend_not_visible = TRUE;
990 pum_will_redraw = !resized;
991 update_screen(0);
992 pum_pretend_not_visible = FALSE;
993 pum_will_redraw = FALSE;
994 call_update_screen = FALSE;
995 }
996 }
997 }
998 # if defined(FEAT_PROP_POPUP) && defined(FEAT_QUICKFIX)
999 if (WIN_IS_POPUP(curwin))
1000 // can't keep focus in a popup window
1001 win_enter(firstwin, TRUE);
1002 # endif
1003 # ifdef FEAT_PROP_POPUP
1004 if (use_popup != USEPOPUP_NONE)
1005 unblock_autocmds();
1006 # endif
1007 }
1008 #endif
1009 }
1010 #if defined(FEAT_PROP_POPUP) && defined(FEAT_QUICKFIX)
1011 if (!has_info)
1012 // hide any popup info window
1013 popup_hide_info();
1014 #endif
1015
1016 return resized;
1017 }
1018
1019 /*
1020 * Undisplay the popup menu (later).
1021 */
1022 void
pum_undisplay(void)1023 pum_undisplay(void)
1024 {
1025 pum_array = NULL;
1026 redraw_all_later(NOT_VALID);
1027 redraw_tabline = TRUE;
1028 status_redraw_all();
1029 #if defined(FEAT_PROP_POPUP) && defined(FEAT_QUICKFIX)
1030 // hide any popup info window
1031 popup_hide_info();
1032 #endif
1033 }
1034
1035 /*
1036 * Clear the popup menu. Currently only resets the offset to the first
1037 * displayed item.
1038 */
1039 void
pum_clear(void)1040 pum_clear(void)
1041 {
1042 pum_first = 0;
1043 }
1044
1045 /*
1046 * Return TRUE if the popup menu is displayed. Used to avoid some redrawing
1047 * that could overwrite it. Overruled when "pum_pretend_not_visible" is set,
1048 * used to redraw the status lines.
1049 */
1050 int
pum_visible(void)1051 pum_visible(void)
1052 {
1053 return !pum_pretend_not_visible && pum_array != NULL;
1054 }
1055
1056 /*
1057 * Return TRUE if the popup can be redrawn in the same position.
1058 */
1059 static int
pum_in_same_position(void)1060 pum_in_same_position(void)
1061 {
1062 return pum_window != curwin
1063 || (pum_win_row == curwin->w_wrow + W_WINROW(curwin)
1064 && pum_win_height == curwin->w_height
1065 && pum_win_col == curwin->w_wincol
1066 && pum_win_width == curwin->w_width);
1067 }
1068
1069 /*
1070 * Return TRUE when pum_may_redraw() will call pum_redraw().
1071 * This means that the pum area should not be overwritten to avoid flicker.
1072 */
1073 int
pum_redraw_in_same_position(void)1074 pum_redraw_in_same_position(void)
1075 {
1076 if (!pum_visible() || pum_will_redraw)
1077 return FALSE; // nothing to do
1078
1079 return pum_in_same_position();
1080 }
1081
1082 /*
1083 * Reposition the popup menu to adjust for window layout changes.
1084 */
1085 void
pum_may_redraw(void)1086 pum_may_redraw(void)
1087 {
1088 pumitem_T *array = pum_array;
1089 int len = pum_size;
1090 int selected = pum_selected;
1091
1092 if (!pum_visible() || pum_will_redraw)
1093 return; // nothing to do
1094
1095 if (pum_in_same_position())
1096 {
1097 // window position didn't change, redraw in the same position
1098 pum_redraw();
1099 }
1100 else
1101 {
1102 int wcol = curwin->w_wcol;
1103
1104 // Window layout changed, recompute the position.
1105 // Use the remembered w_wcol value, the cursor may have moved when a
1106 // completion was inserted, but we want the menu in the same position.
1107 pum_undisplay();
1108 curwin->w_wcol = pum_win_wcol;
1109 curwin->w_valid |= VALID_WCOL;
1110 pum_display(array, len, selected);
1111 curwin->w_wcol = wcol;
1112 }
1113 }
1114
1115 /*
1116 * Return the height of the popup menu, the number of entries visible.
1117 * Only valid when pum_visible() returns TRUE!
1118 */
1119 int
pum_get_height(void)1120 pum_get_height(void)
1121 {
1122 return pum_height;
1123 }
1124
1125 #if defined(FEAT_EVAL) || defined(PROTO)
1126 /*
1127 * Add size information about the pum to "dict".
1128 */
1129 void
pum_set_event_info(dict_T * dict)1130 pum_set_event_info(dict_T *dict)
1131 {
1132 if (!pum_visible())
1133 return;
1134 (void)dict_add_number(dict, "height", pum_height);
1135 (void)dict_add_number(dict, "width", pum_width);
1136 (void)dict_add_number(dict, "row", pum_row);
1137 (void)dict_add_number(dict, "col", pum_col);
1138 (void)dict_add_number(dict, "size", pum_size);
1139 (void)dict_add_bool(dict, "scrollbar",
1140 pum_scrollbar ? VVAL_TRUE : VVAL_FALSE);
1141 }
1142 #endif
1143
1144 #if defined(FEAT_BEVAL_TERM) || defined(FEAT_TERM_POPUP_MENU) || defined(PROTO)
1145 static void
pum_position_at_mouse(int min_width)1146 pum_position_at_mouse(int min_width)
1147 {
1148 if (Rows - mouse_row > pum_size)
1149 {
1150 // Enough space below the mouse row.
1151 pum_row = mouse_row + 1;
1152 if (pum_height > Rows - pum_row)
1153 pum_height = Rows - pum_row;
1154 }
1155 else
1156 {
1157 // Show above the mouse row, reduce height if it does not fit.
1158 pum_row = mouse_row - pum_size;
1159 if (pum_row < 0)
1160 {
1161 pum_height += pum_row;
1162 pum_row = 0;
1163 }
1164 }
1165 if (Columns - mouse_col >= pum_base_width
1166 || Columns - mouse_col > min_width)
1167 // Enough space to show at mouse column.
1168 pum_col = mouse_col;
1169 else
1170 // Not enough space, right align with window.
1171 pum_col = Columns - (pum_base_width > min_width
1172 ? min_width : pum_base_width);
1173
1174 pum_width = Columns - pum_col;
1175 if (pum_width > pum_base_width + 1)
1176 pum_width = pum_base_width + 1;
1177
1178 // Do not redraw at cursor position.
1179 pum_window = NULL;
1180 }
1181
1182 #endif
1183
1184 #if defined(FEAT_BEVAL_TERM) || defined(PROTO)
1185 static pumitem_T *balloon_array = NULL;
1186 static int balloon_arraysize;
1187
1188 # define BALLOON_MIN_WIDTH 50
1189 # define BALLOON_MIN_HEIGHT 10
1190
1191 typedef struct {
1192 char_u *start;
1193 int bytelen;
1194 int cells;
1195 int indent;
1196 } balpart_T;
1197
1198 /*
1199 * Split a string into parts to display in the balloon.
1200 * Aimed at output from gdb. Attempts to split at white space, preserve quoted
1201 * strings and make a struct look good.
1202 * Resulting array is stored in "array" and returns the size of the array.
1203 */
1204 int
split_message(char_u * mesg,pumitem_T ** array)1205 split_message(char_u *mesg, pumitem_T **array)
1206 {
1207 garray_T ga;
1208 char_u *p;
1209 balpart_T *item;
1210 int quoted = FALSE;
1211 int height;
1212 int line;
1213 int item_idx;
1214 int indent = 0;
1215 int max_cells = 0;
1216 int max_height = Rows / 2 - 1;
1217 int long_item_count = 0;
1218 int split_long_items = FALSE;
1219
1220 ga_init2(&ga, sizeof(balpart_T), 20);
1221 p = mesg;
1222
1223 while (*p != NUL)
1224 {
1225 if (ga_grow(&ga, 1) == FAIL)
1226 goto failed;
1227 item = ((balpart_T *)ga.ga_data) + ga.ga_len;
1228 item->start = p;
1229 item->indent = indent;
1230 item->cells = indent * 2;
1231 ++ga.ga_len;
1232 while (*p != NUL)
1233 {
1234 if (*p == '"')
1235 quoted = !quoted;
1236 else if (*p == '\n')
1237 break;
1238 else if (*p == '\\' && p[1] != NUL)
1239 ++p;
1240 else if (!quoted)
1241 {
1242 if ((*p == ',' && p[1] == ' ') || *p == '{' || *p == '}')
1243 {
1244 // Looks like a good point to break.
1245 if (*p == '{')
1246 ++indent;
1247 else if (*p == '}' && indent > 0)
1248 --indent;
1249 ++item->cells;
1250 p = skipwhite(p + 1);
1251 break;
1252 }
1253 }
1254 item->cells += ptr2cells(p);
1255 p += mb_ptr2len(p);
1256 }
1257 item->bytelen = p - item->start;
1258 if (*p == '\n')
1259 ++p;
1260 if (item->cells > max_cells)
1261 max_cells = item->cells;
1262 long_item_count += (item->cells - 1) / BALLOON_MIN_WIDTH;
1263 }
1264
1265 height = 2 + ga.ga_len;
1266
1267 // If there are long items and the height is below the limit: split lines
1268 if (long_item_count > 0 && height + long_item_count <= max_height)
1269 {
1270 split_long_items = TRUE;
1271 height += long_item_count;
1272 }
1273
1274 // Limit to half the window height, it has to fit above or below the mouse
1275 // position.
1276 if (height > max_height)
1277 height = max_height;
1278 *array = ALLOC_CLEAR_MULT(pumitem_T, height);
1279 if (*array == NULL)
1280 goto failed;
1281
1282 // Add an empty line above and below, looks better.
1283 (*array)->pum_text = vim_strsave((char_u *)"");
1284 (*array + height - 1)->pum_text = vim_strsave((char_u *)"");
1285
1286 for (line = 1, item_idx = 0; line < height - 1; ++item_idx)
1287 {
1288 int skip;
1289 int thislen;
1290 int copylen;
1291 int ind;
1292 int cells;
1293
1294 item = ((balpart_T *)ga.ga_data) + item_idx;
1295 if (item->bytelen == 0)
1296 (*array)[line++].pum_text = vim_strsave((char_u *)"");
1297 else
1298 for (skip = 0; skip < item->bytelen; skip += thislen)
1299 {
1300 if (split_long_items && item->cells >= BALLOON_MIN_WIDTH)
1301 {
1302 cells = item->indent * 2;
1303 for (p = item->start + skip;
1304 p < item->start + item->bytelen;
1305 p += mb_ptr2len(p))
1306 if ((cells += ptr2cells(p)) > BALLOON_MIN_WIDTH)
1307 break;
1308 thislen = p - (item->start + skip);
1309 }
1310 else
1311 thislen = item->bytelen;
1312
1313 // put indent at the start
1314 p = alloc(thislen + item->indent * 2 + 1);
1315 if (p == NULL)
1316 {
1317 for (line = 0; line <= height - 1; ++line)
1318 vim_free((*array)[line].pum_text);
1319 vim_free(*array);
1320 goto failed;
1321 }
1322 for (ind = 0; ind < item->indent * 2; ++ind)
1323 p[ind] = ' ';
1324
1325 // exclude spaces at the end of the string
1326 for (copylen = thislen; copylen > 0; --copylen)
1327 if (item->start[skip + copylen - 1] != ' ')
1328 break;
1329
1330 vim_strncpy(p + ind, item->start + skip, copylen);
1331 (*array)[line].pum_text = p;
1332 item->indent = 0; // wrapped line has no indent
1333 ++line;
1334 }
1335 }
1336 ga_clear(&ga);
1337 return height;
1338
1339 failed:
1340 ga_clear(&ga);
1341 return 0;
1342 }
1343
1344 void
ui_remove_balloon(void)1345 ui_remove_balloon(void)
1346 {
1347 if (balloon_array != NULL)
1348 {
1349 pum_undisplay();
1350 while (balloon_arraysize > 0)
1351 vim_free(balloon_array[--balloon_arraysize].pum_text);
1352 VIM_CLEAR(balloon_array);
1353 }
1354 }
1355
1356 /*
1357 * Terminal version of a balloon, uses the popup menu code.
1358 */
1359 void
ui_post_balloon(char_u * mesg,list_T * list)1360 ui_post_balloon(char_u *mesg, list_T *list)
1361 {
1362 ui_remove_balloon();
1363
1364 if (mesg == NULL && list == NULL)
1365 {
1366 pum_undisplay();
1367 return;
1368 }
1369 if (list != NULL)
1370 {
1371 listitem_T *li;
1372 int idx;
1373
1374 balloon_arraysize = list->lv_len;
1375 balloon_array = ALLOC_CLEAR_MULT(pumitem_T, list->lv_len);
1376 if (balloon_array == NULL)
1377 return;
1378 CHECK_LIST_MATERIALIZE(list);
1379 for (idx = 0, li = list->lv_first; li != NULL; li = li->li_next, ++idx)
1380 {
1381 char_u *text = tv_get_string_chk(&li->li_tv);
1382
1383 balloon_array[idx].pum_text = vim_strsave(
1384 text == NULL ? (char_u *)"" : text);
1385 }
1386 }
1387 else
1388 balloon_arraysize = split_message(mesg, &balloon_array);
1389
1390 if (balloon_arraysize > 0)
1391 {
1392 pum_array = balloon_array;
1393 pum_size = balloon_arraysize;
1394 pum_compute_size();
1395 pum_scrollbar = 0;
1396 pum_height = balloon_arraysize;
1397
1398 pum_position_at_mouse(BALLOON_MIN_WIDTH);
1399 pum_selected = -1;
1400 pum_first = 0;
1401 pum_redraw();
1402 }
1403 }
1404
1405 /*
1406 * Called when the mouse moved, may remove any displayed balloon.
1407 */
1408 void
ui_may_remove_balloon(void)1409 ui_may_remove_balloon(void)
1410 {
1411 // For now: remove the balloon whenever the mouse moves to another screen
1412 // cell.
1413 ui_remove_balloon();
1414 }
1415 #endif
1416
1417 #if defined(FEAT_TERM_POPUP_MENU) || defined(PROTO)
1418 /*
1419 * Select the pum entry at the mouse position.
1420 */
1421 static void
pum_select_mouse_pos(void)1422 pum_select_mouse_pos(void)
1423 {
1424 int idx = mouse_row - pum_row;
1425
1426 if (idx < 0 || idx >= pum_size)
1427 pum_selected = -1;
1428 else if (*pum_array[idx].pum_text != NUL)
1429 pum_selected = idx;
1430 }
1431
1432 /*
1433 * Execute the currently selected popup menu item.
1434 */
1435 static void
pum_execute_menu(vimmenu_T * menu,int mode)1436 pum_execute_menu(vimmenu_T *menu, int mode)
1437 {
1438 vimmenu_T *mp;
1439 int idx = 0;
1440 exarg_T ea;
1441
1442 FOR_ALL_CHILD_MENUS(menu, mp)
1443 if ((mp->modes & mp->enabled & mode) && idx++ == pum_selected)
1444 {
1445 CLEAR_FIELD(ea);
1446 execute_menu(&ea, mp, -1);
1447 break;
1448 }
1449 }
1450
1451 /*
1452 * Open the terminal version of the popup menu and don't return until it is
1453 * closed.
1454 */
1455 void
pum_show_popupmenu(vimmenu_T * menu)1456 pum_show_popupmenu(vimmenu_T *menu)
1457 {
1458 vimmenu_T *mp;
1459 int idx = 0;
1460 pumitem_T *array;
1461 # ifdef FEAT_BEVAL_TERM
1462 int save_bevalterm = p_bevalterm;
1463 # endif
1464 int mode;
1465
1466 pum_undisplay();
1467 pum_size = 0;
1468 mode = get_menu_mode_flag();
1469
1470 FOR_ALL_CHILD_MENUS(menu, mp)
1471 if (menu_is_separator(mp->dname)
1472 || (mp->modes & mp->enabled & mode))
1473 ++pum_size;
1474
1475 // When there are only Terminal mode menus, using "popup Edit" results in
1476 // pum_size being zero.
1477 if (pum_size <= 0)
1478 {
1479 emsg(e_menuothermode);
1480 return;
1481 }
1482
1483 array = ALLOC_CLEAR_MULT(pumitem_T, pum_size);
1484 if (array == NULL)
1485 return;
1486
1487 FOR_ALL_CHILD_MENUS(menu, mp)
1488 {
1489 char_u *s = NULL;
1490
1491 // Make a copy of the text, the menu may be redefined in a callback.
1492 if (menu_is_separator(mp->dname))
1493 s = (char_u *)"";
1494 else if (mp->modes & mp->enabled & mode)
1495 s = mp->dname;
1496 if (s != NULL)
1497 {
1498 s = vim_strsave(s);
1499 if (s != NULL)
1500 array[idx++].pum_text = s;
1501 }
1502 }
1503
1504 pum_array = array;
1505 pum_compute_size();
1506 pum_scrollbar = 0;
1507 pum_height = pum_size;
1508 pum_position_at_mouse(20);
1509
1510 pum_selected = -1;
1511 pum_first = 0;
1512 # ifdef FEAT_BEVAL_TERM
1513 p_bevalterm = TRUE; // track mouse movement
1514 mch_setmouse(TRUE);
1515 # endif
1516
1517 for (;;)
1518 {
1519 int c;
1520
1521 pum_redraw();
1522 setcursor_mayforce(TRUE);
1523 out_flush();
1524
1525 c = vgetc();
1526
1527 // Bail out when typing Esc, CTRL-C or some callback closed the popup
1528 // menu.
1529 if (c == ESC || c == Ctrl_C || pum_array == NULL)
1530 break;
1531 else if (c == CAR || c == NL)
1532 {
1533 // enter: select current item, if any, and close
1534 pum_execute_menu(menu, mode);
1535 break;
1536 }
1537 else if (c == 'k' || c == K_UP || c == K_MOUSEUP)
1538 {
1539 // cursor up: select previous item
1540 while (pum_selected > 0)
1541 {
1542 --pum_selected;
1543 if (*array[pum_selected].pum_text != NUL)
1544 break;
1545 }
1546 }
1547 else if (c == 'j' || c == K_DOWN || c == K_MOUSEDOWN)
1548 {
1549 // cursor down: select next item
1550 while (pum_selected < pum_size - 1)
1551 {
1552 ++pum_selected;
1553 if (*array[pum_selected].pum_text != NUL)
1554 break;
1555 }
1556 }
1557 else if (c == K_RIGHTMOUSE)
1558 {
1559 // Right mouse down: reposition the menu.
1560 vungetc(c);
1561 break;
1562 }
1563 else if (c == K_LEFTDRAG || c == K_RIGHTDRAG || c == K_MOUSEMOVE)
1564 {
1565 // mouse moved: select item in the mouse row
1566 pum_select_mouse_pos();
1567 }
1568 else if (c == K_LEFTMOUSE || c == K_LEFTMOUSE_NM || c == K_RIGHTRELEASE)
1569 {
1570 // left mouse click: select clicked item, if any, and close;
1571 // right mouse release: select clicked item, close if any
1572 pum_select_mouse_pos();
1573 if (pum_selected >= 0)
1574 {
1575 pum_execute_menu(menu, mode);
1576 break;
1577 }
1578 if (c == K_LEFTMOUSE || c == K_LEFTMOUSE_NM)
1579 break;
1580 }
1581 }
1582
1583 for (idx = 0; idx < pum_size; ++idx)
1584 vim_free(array[idx].pum_text);
1585 vim_free(array);
1586 pum_undisplay();
1587 # ifdef FEAT_BEVAL_TERM
1588 p_bevalterm = save_bevalterm;
1589 mch_setmouse(TRUE);
1590 # endif
1591 }
1592
1593 void
pum_make_popup(char_u * path_name,int use_mouse_pos)1594 pum_make_popup(char_u *path_name, int use_mouse_pos)
1595 {
1596 vimmenu_T *menu;
1597
1598 if (!use_mouse_pos)
1599 {
1600 // Hack: set mouse position at the cursor so that the menu pops up
1601 // around there.
1602 mouse_row = curwin->w_winrow + curwin->w_wrow;
1603 mouse_col = curwin->w_wincol + curwin->w_wcol;
1604 }
1605
1606 menu = gui_find_menu(path_name);
1607 if (menu != NULL)
1608 pum_show_popupmenu(menu);
1609 }
1610 #endif
1611