Merge branch 'vim-with-runtime' into feat/var-tabstops
[vim_extended.git] / src / popupmnu.c
blob9dce37848b281691b10627cccc2a9e05224d7006
1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
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 */
11 * popupmnu.c: Popup menu (PUM)
13 #include "vim.h"
15 #if defined(FEAT_INS_EXPAND) || defined(PROTO)
17 static pumitem_T *pum_array = NULL; /* items of displayed pum */
18 static int pum_size; /* nr of items in "pum_array" */
19 static int pum_selected; /* index of selected item or -1 */
20 static int pum_first = 0; /* index of top item */
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_scrollbar; /* TRUE when scrollbar present */
28 static int pum_row; /* top row of pum */
29 static int pum_col; /* left column of pum */
31 static int pum_do_redraw = FALSE; /* do redraw anyway */
33 static int pum_set_selected __ARGS((int n, int repeat));
35 #define PUM_DEF_HEIGHT 10
36 #define PUM_DEF_WIDTH 15
39 * Show the popup menu with items "array[size]".
40 * "array" must remain valid until pum_undisplay() is called!
41 * When possible the leftmost character is aligned with screen column "col".
42 * The menu appears above the screen line "row" or at "row" + "height" - 1.
44 void
45 pum_display(array, size, selected)
46 pumitem_T *array;
47 int size;
48 int selected; /* index of initially selected item, none if
49 out of range */
51 int w;
52 int def_width;
53 int max_width;
54 int kind_width;
55 int extra_width;
56 int i;
57 int top_clear;
58 int row;
59 int context_lines;
60 int col;
61 int above_row = cmdline_row;
62 int redo_count = 0;
64 redo:
65 def_width = PUM_DEF_WIDTH;
66 max_width = 0;
67 kind_width = 0;
68 extra_width = 0;
70 /* Pretend the pum is already there to avoid that must_redraw is set when
71 * 'cuc' is on. */
72 pum_array = (pumitem_T *)1;
73 validate_cursor_col();
74 pum_array = NULL;
76 row = curwin->w_wrow + W_WINROW(curwin);
78 if (firstwin->w_p_pvw)
79 top_clear = firstwin->w_height;
80 else
81 top_clear = 0;
83 /* When the preview window is at the bottom stop just above it. Also
84 * avoid drawing over the status line so that it's clear there is a window
85 * boundary. */
86 if (lastwin->w_p_pvw)
87 above_row -= lastwin->w_height + lastwin->w_status_height + 1;
90 * Figure out the size and position of the pum.
92 if (size < PUM_DEF_HEIGHT)
93 pum_height = size;
94 else
95 pum_height = PUM_DEF_HEIGHT;
96 if (p_ph > 0 && pum_height > p_ph)
97 pum_height = p_ph;
99 /* Put the pum below "row" if possible. If there are few lines decide on
100 * where there is more room. */
101 if (row + 2 >= above_row - pum_height
102 && row > (above_row - top_clear) / 2)
104 /* pum above "row" */
106 /* Leave two lines of context if possible */
107 if (curwin->w_wrow - curwin->w_cline_row >= 2)
108 context_lines = 2;
109 else
110 context_lines = curwin->w_wrow - curwin->w_cline_row;
112 if (row >= size + context_lines)
114 pum_row = row - size - context_lines;
115 pum_height = size;
117 else
119 pum_row = 0;
120 pum_height = row - context_lines;
122 if (p_ph > 0 && pum_height > p_ph)
124 pum_row += pum_height - p_ph;
125 pum_height = p_ph;
128 else
130 /* pum below "row" */
132 /* Leave two lines of context if possible */
133 if (curwin->w_cline_row + curwin->w_cline_height - curwin->w_wrow >= 3)
134 context_lines = 3;
135 else
136 context_lines = curwin->w_cline_row
137 + curwin->w_cline_height - curwin->w_wrow;
139 pum_row = row + context_lines;
140 if (size > above_row - pum_row)
141 pum_height = above_row - pum_row;
142 else
143 pum_height = size;
144 if (p_ph > 0 && pum_height > p_ph)
145 pum_height = p_ph;
148 /* don't display when we only have room for one line */
149 if (pum_height < 1 || (pum_height == 1 && size > 1))
150 return;
152 /* If there is a preview window at the top avoid drawing over it. */
153 if (firstwin->w_p_pvw
154 && pum_row < firstwin->w_height
155 && pum_height > firstwin->w_height + 4)
157 pum_row += firstwin->w_height;
158 pum_height -= firstwin->w_height;
161 /* Compute the width of the widest match and the widest extra. */
162 for (i = 0; i < size; ++i)
164 w = vim_strsize(array[i].pum_text);
165 if (max_width < w)
166 max_width = w;
167 if (array[i].pum_kind != NULL)
169 w = vim_strsize(array[i].pum_kind) + 1;
170 if (kind_width < w)
171 kind_width = w;
173 if (array[i].pum_extra != NULL)
175 w = vim_strsize(array[i].pum_extra) + 1;
176 if (extra_width < w)
177 extra_width = w;
180 pum_base_width = max_width;
181 pum_kind_width = kind_width;
183 /* Calculate column */
184 #ifdef FEAT_RIGHTLEFT
185 if (curwin->w_p_rl)
186 col = W_WINCOL(curwin) + W_WIDTH(curwin) - curwin->w_wcol - 1;
187 else
188 #endif
189 col = W_WINCOL(curwin) + curwin->w_wcol;
191 /* if there are more items than room we need a scrollbar */
192 if (pum_height < size)
194 pum_scrollbar = 1;
195 ++max_width;
197 else
198 pum_scrollbar = 0;
200 if (def_width < max_width)
201 def_width = max_width;
203 if (((col < Columns - PUM_DEF_WIDTH || col < Columns - max_width)
204 #ifdef FEAT_RIGHTLEFT
205 && !curwin->w_p_rl)
206 || (curwin->w_p_rl && (col > PUM_DEF_WIDTH || col > max_width)
207 #endif
210 /* align pum column with "col" */
211 pum_col = col;
213 #ifdef FEAT_RIGHTLEFT
214 if (curwin->w_p_rl)
215 pum_width = pum_col - pum_scrollbar + 1;
216 else
217 #endif
218 pum_width = Columns - pum_col - pum_scrollbar;
220 if (pum_width > max_width + kind_width + extra_width + 1
221 && pum_width > PUM_DEF_WIDTH)
223 pum_width = max_width + kind_width + extra_width + 1;
224 if (pum_width < PUM_DEF_WIDTH)
225 pum_width = PUM_DEF_WIDTH;
228 else if (Columns < def_width)
230 /* not enough room, will use what we have */
231 #ifdef FEAT_RIGHTLEFT
232 if (curwin->w_p_rl)
233 pum_col = Columns - 1;
234 else
235 #endif
236 pum_col = 0;
237 pum_width = Columns - 1;
239 else
241 if (max_width > PUM_DEF_WIDTH)
242 max_width = PUM_DEF_WIDTH; /* truncate */
243 #ifdef FEAT_RIGHTLEFT
244 if (curwin->w_p_rl)
245 pum_col = max_width - 1;
246 else
247 #endif
248 pum_col = Columns - max_width;
249 pum_width = max_width - pum_scrollbar;
252 pum_array = array;
253 pum_size = size;
255 /* Set selected item and redraw. If the window size changed need to redo
256 * the positioning. Limit this to two times, when there is not much
257 * room the window size will keep changing. */
258 if (pum_set_selected(selected, redo_count) && ++redo_count <= 2)
259 goto redo;
263 * Redraw the popup menu, using "pum_first" and "pum_selected".
265 void
266 pum_redraw()
268 int row = pum_row;
269 int col;
270 int attr_norm = highlight_attr[HLF_PNI];
271 int attr_select = highlight_attr[HLF_PSI];
272 int attr_scroll = highlight_attr[HLF_PSB];
273 int attr_thumb = highlight_attr[HLF_PST];
274 int attr;
275 int i;
276 int idx;
277 char_u *s;
278 char_u *p = NULL;
279 int totwidth, width, w;
280 int thumb_pos = 0;
281 int thumb_heigth = 1;
282 int round;
283 int n;
285 if (pum_scrollbar)
287 thumb_heigth = pum_height * pum_height / pum_size;
288 if (thumb_heigth == 0)
289 thumb_heigth = 1;
290 thumb_pos = (pum_first * (pum_height - thumb_heigth)
291 + (pum_size - pum_height) / 2)
292 / (pum_size - pum_height);
295 for (i = 0; i < pum_height; ++i)
297 idx = i + pum_first;
298 attr = (idx == pum_selected) ? attr_select : attr_norm;
300 /* prepend a space if there is room */
301 #ifdef FEAT_RIGHTLEFT
302 if (curwin->w_p_rl)
304 if (pum_col < W_WINCOL(curwin) + W_WIDTH(curwin) - 1)
305 screen_putchar(' ', row, pum_col + 1, attr);
307 else
308 #endif
309 if (pum_col > 0)
310 screen_putchar(' ', row, pum_col - 1, attr);
312 /* Display each entry, use two spaces for a Tab.
313 * Do this 3 times: For the main text, kind and extra info */
314 col = pum_col;
315 totwidth = 0;
316 for (round = 1; round <= 3; ++round)
318 width = 0;
319 s = NULL;
320 switch (round)
322 case 1: p = pum_array[idx].pum_text; break;
323 case 2: p = pum_array[idx].pum_kind; break;
324 case 3: p = pum_array[idx].pum_extra; break;
326 if (p != NULL)
327 for ( ; ; mb_ptr_adv(p))
329 if (s == NULL)
330 s = p;
331 w = ptr2cells(p);
332 if (*p == NUL || *p == TAB || totwidth + w > pum_width)
334 /* Display the text that fits or comes before a Tab.
335 * First convert it to printable characters. */
336 char_u *st;
337 int saved = *p;
339 *p = NUL;
340 st = transstr(s);
341 *p = saved;
342 #ifdef FEAT_RIGHTLEFT
343 if (curwin->w_p_rl)
345 if (st != NULL)
347 char_u *rt = reverse_text(st);
349 if (rt != NULL)
351 char_u *rt_start = rt;
352 int size;
354 size = vim_strsize(rt);
355 if (size > pum_width)
359 size -= has_mbyte
360 ? (*mb_ptr2cells)(rt) : 1;
361 mb_ptr_adv(rt);
362 } while (size > pum_width);
364 if (size < pum_width)
366 /* Most left character requires
367 * 2-cells but only 1 cell is
368 * available on screen. Put a
369 * '<' on the left of the pum
370 * item */
371 *(--rt) = '<';
372 size++;
375 screen_puts_len(rt, (int)STRLEN(rt),
376 row, col - size + 1, attr);
377 vim_free(rt_start);
379 vim_free(st);
381 col -= width;
383 else
384 #endif
386 if (st != NULL)
388 screen_puts_len(st, (int)STRLEN(st), row, col,
389 attr);
390 vim_free(st);
392 col += width;
395 if (*p != TAB)
396 break;
398 /* Display two spaces for a Tab. */
399 #ifdef FEAT_RIGHTLEFT
400 if (curwin->w_p_rl)
402 screen_puts_len((char_u *)" ", 2, row, col - 1,
403 attr);
404 col -= 2;
406 else
407 #endif
409 screen_puts_len((char_u *)" ", 2, row, col, attr);
410 col += 2;
412 totwidth += 2;
413 s = NULL; /* start text at next char */
414 width = 0;
416 else
417 width += w;
420 if (round > 1)
421 n = pum_kind_width + 1;
422 else
423 n = 1;
425 /* Stop when there is nothing more to display. */
426 if (round == 3
427 || (round == 2 && pum_array[idx].pum_extra == NULL)
428 || (round == 1 && pum_array[idx].pum_kind == NULL
429 && pum_array[idx].pum_extra == NULL)
430 || pum_base_width + n >= pum_width)
431 break;
432 #ifdef FEAT_RIGHTLEFT
433 if (curwin->w_p_rl)
435 screen_fill(row, row + 1, pum_col - pum_base_width - n + 1,
436 col + 1, ' ', ' ', attr);
437 col = pum_col - pum_base_width - n + 1;
439 else
440 #endif
442 screen_fill(row, row + 1, col, pum_col + pum_base_width + n,
443 ' ', ' ', attr);
444 col = pum_col + pum_base_width + n;
446 totwidth = pum_base_width + n;
449 #ifdef FEAT_RIGHTLEFT
450 if (curwin->w_p_rl)
451 screen_fill(row, row + 1, pum_col - pum_width + 1, col + 1, ' ',
452 ' ', attr);
453 else
454 #endif
455 screen_fill(row, row + 1, col, pum_col + pum_width, ' ', ' ',
456 attr);
457 if (pum_scrollbar > 0)
459 #ifdef FEAT_RIGHTLEFT
460 if (curwin->w_p_rl)
461 screen_putchar(' ', row, pum_col - pum_width,
462 i >= thumb_pos && i < thumb_pos + thumb_heigth
463 ? attr_thumb : attr_scroll);
464 else
465 #endif
466 screen_putchar(' ', row, pum_col + pum_width,
467 i >= thumb_pos && i < thumb_pos + thumb_heigth
468 ? attr_thumb : attr_scroll);
471 ++row;
475 #if 0 /* not used yet */
477 * Return the index of the currently selected item.
480 pum_get_selected()
482 return pum_selected;
484 #endif
487 * Set the index of the currently selected item. The menu will scroll when
488 * necessary. When "n" is out of range don't scroll.
489 * This may be repeated when the preview window is used:
490 * "repeat" == 0: open preview window normally
491 * "repeat" == 1: open preview window but don't set the size
492 * "repeat" == 2: don't open preview window
493 * Returns TRUE when the window was resized and the location of the popup menu
494 * must be recomputed.
496 static int
497 pum_set_selected(n, repeat)
498 int n;
499 int repeat;
501 int resized = FALSE;
502 int context = pum_height / 2;
504 pum_selected = n;
506 if (pum_selected >= 0 && pum_selected < pum_size)
508 if (pum_first > pum_selected - 4)
510 /* scroll down; when we did a jump it's probably a PageUp then
511 * scroll a whole page */
512 if (pum_first > pum_selected - 2)
514 pum_first -= pum_height - 2;
515 if (pum_first < 0)
516 pum_first = 0;
517 else if (pum_first > pum_selected)
518 pum_first = pum_selected;
520 else
521 pum_first = pum_selected;
523 else if (pum_first < pum_selected - pum_height + 5)
525 /* scroll up; when we did a jump it's probably a PageDown then
526 * scroll a whole page */
527 if (pum_first < pum_selected - pum_height + 1 + 2)
529 pum_first += pum_height - 2;
530 if (pum_first < pum_selected - pum_height + 1)
531 pum_first = pum_selected - pum_height + 1;
533 else
534 pum_first = pum_selected - pum_height + 1;
537 /* Give a few lines of context when possible. */
538 if (context > 3)
539 context = 3;
540 if (pum_height > 2)
542 if (pum_first > pum_selected - context)
544 /* scroll down */
545 pum_first = pum_selected - context;
546 if (pum_first < 0)
547 pum_first = 0;
549 else if (pum_first < pum_selected + context - pum_height + 1)
551 /* scroll up */
552 pum_first = pum_selected + context - pum_height + 1;
556 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
558 * Show extra info in the preview window if there is something and
559 * 'completeopt' contains "preview".
560 * Skip this when tried twice already.
561 * Skip this also when there is not much room.
562 * NOTE: Be very careful not to sync undo!
564 if (pum_array[pum_selected].pum_info != NULL
565 && Rows > 10
566 && repeat <= 1
567 && vim_strchr(p_cot, 'p') != NULL)
569 win_T *curwin_save = curwin;
570 int res = OK;
572 /* Open a preview window. 3 lines by default. */
573 g_do_tagpreview = 3;
574 resized = prepare_tagpreview(FALSE);
575 g_do_tagpreview = 0;
577 if (curwin->w_p_pvw)
579 if (curbuf->b_fname == NULL
580 && curbuf->b_p_bt[0] == 'n' && curbuf->b_p_bt[2] == 'f'
581 && curbuf->b_p_bh[0] == 'w')
583 /* Already a "wipeout" buffer, make it empty. */
584 while (!bufempty())
585 ml_delete((linenr_T)1, FALSE);
587 else
589 /* Don't want to sync undo in the current buffer. */
590 ++no_u_sync;
591 res = do_ecmd(0, NULL, NULL, NULL, ECMD_ONE, 0, NULL);
592 --no_u_sync;
593 if (res == OK)
595 /* Edit a new, empty buffer. Set options for a "wipeout"
596 * buffer. */
597 set_option_value((char_u *)"swf", 0L, NULL, OPT_LOCAL);
598 set_option_value((char_u *)"bt", 0L,
599 (char_u *)"nofile", OPT_LOCAL);
600 set_option_value((char_u *)"bh", 0L,
601 (char_u *)"wipe", OPT_LOCAL);
602 set_option_value((char_u *)"diff", 0L,
603 NULL, OPT_LOCAL);
606 if (res == OK)
608 char_u *p, *e;
609 linenr_T lnum = 0;
611 for (p = pum_array[pum_selected].pum_info; *p != NUL; )
613 e = vim_strchr(p, '\n');
614 if (e == NULL)
616 ml_append(lnum++, p, 0, FALSE);
617 break;
619 else
621 *e = NUL;
622 ml_append(lnum++, p, (int)(e - p + 1), FALSE);
623 *e = '\n';
624 p = e + 1;
628 /* Increase the height of the preview window to show the
629 * text, but no more than 'previewheight' lines. */
630 if (repeat == 0)
632 if (lnum > p_pvh)
633 lnum = p_pvh;
634 if (curwin->w_height < lnum)
636 win_setheight((int)lnum);
637 resized = TRUE;
641 curbuf->b_changed = 0;
642 curbuf->b_p_ma = FALSE;
643 curwin->w_cursor.lnum = 1;
644 curwin->w_cursor.col = 0;
646 if (curwin != curwin_save && win_valid(curwin_save))
648 /* Return cursor to where we were */
649 validate_cursor();
650 redraw_later(SOME_VALID);
652 /* When the preview window was resized we need to
653 * update the view on the buffer. Only go back to
654 * the window when needed, otherwise it will always be
655 * redraw. */
656 if (resized)
658 win_enter(curwin_save, TRUE);
659 update_topline();
662 /* Update the screen before drawing the popup menu.
663 * Enable updating the status lines. */
664 pum_do_redraw = TRUE;
665 update_screen(0);
666 pum_do_redraw = FALSE;
668 if (!resized && win_valid(curwin_save))
669 win_enter(curwin_save, TRUE);
671 /* May need to update the screen again when there are
672 * autocommands involved. */
673 pum_do_redraw = TRUE;
674 update_screen(0);
675 pum_do_redraw = FALSE;
680 #endif
683 /* Never display more than we have */
684 if (pum_first > pum_size - pum_height)
685 pum_first = pum_size - pum_height;
687 if (!resized)
688 pum_redraw();
690 return resized;
694 * Undisplay the popup menu (later).
696 void
697 pum_undisplay()
699 pum_array = NULL;
700 redraw_all_later(SOME_VALID);
701 #ifdef FEAT_WINDOWS
702 redraw_tabline = TRUE;
703 #endif
704 status_redraw_all();
708 * Clear the popup menu. Currently only resets the offset to the first
709 * displayed item.
711 void
712 pum_clear()
714 pum_first = 0;
718 * Return TRUE if the popup menu is displayed.
719 * Overruled when "pum_do_redraw" is set, used to redraw the status lines.
722 pum_visible()
724 return !pum_do_redraw && pum_array != NULL;
728 * Return the height of the popup menu, the number of entries visible.
729 * Only valid when pum_visible() returns TRUE!
732 pum_get_height()
734 return pum_height;
737 #endif