src/popupmnu.c

   1 /* vi:set ts=8 sts=4 sw=4:
   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  * popupmnu.c: Popup menu (PUM)
  12  */
  13 #include "vim.h"
  14
  15 #if defined(FEAT_INS_EXPAND) || defined(PROTO)
  16
  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 */
  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_scrollbar;               /* TRUE when scrollbar present */
  27
  28 static int pum_row;                     /* top row of pum */
  29 static int pum_col;                     /* left column of pum */
  30
  31 static int pum_do_redraw = FALSE;       /* do redraw anyway */
  32
  33 static int pum_set_selected __ARGS((int n, int repeat));
  34
  35 #define PUM_DEF_HEIGHT 10
  36 #define PUM_DEF_WIDTH  15
  37
  38 /*
  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.
  43  */
  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 */
  50 {
  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;
  63
  64 redo:
  65     def_width = PUM_DEF_WIDTH;
  66     max_width = 0;
  67     kind_width = 0;
  68     extra_width = 0;
  69
  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;
  75
  76     row = curwin->w_wrow + W_WINROW(curwin);
  77
  78     if (firstwin->w_p_pvw)
  79         top_clear = firstwin->w_height;
  80     else
  81         top_clear = 0;
  82
  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;
  88
  89     /*
  90      * Figure out the size and position of the pum.
  91      */
  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;
  98
  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)
 103     {
 104         /* pum above "row" */
 105
 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;
 111
 112         if (row >= size + context_lines)
 113         {
 114             pum_row = row - size - context_lines;
 115             pum_height = size;
 116         }
 117         else
 118         {
 119             pum_row = 0;
 120             pum_height = row - context_lines;
 121         }
 122         if (p_ph > 0 && pum_height > p_ph)
 123         {
 124             pum_row += pum_height - p_ph;
 125             pum_height = p_ph;
 126         }
 127     }
 128     else
 129     {
 130         /* pum below "row" */
 131
 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;
 138
 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;
 146     }
 147
 148     /* don't display when we only have room for one line */
 149     if (pum_height < 1 || (pum_height == 1 && size > 1))
 150         return;
 151
 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)
 156     {
 157         pum_row += firstwin->w_height;
 158         pum_height -= firstwin->w_height;
 159     }
 160
 161     /* Compute the width of the widest match and the widest extra. */
 162     for (i = 0; i < size; ++i)
 163     {
 164         w = vim_strsize(array[i].pum_text);
 165         if (max_width < w)
 166             max_width = w;
 167         if (array[i].pum_kind != NULL)
 168         {
 169             w = vim_strsize(array[i].pum_kind) + 1;
 170             if (kind_width < w)
 171                 kind_width = w;
 172         }
 173         if (array[i].pum_extra != NULL)
 174         {
 175             w = vim_strsize(array[i].pum_extra) + 1;
 176             if (extra_width < w)
 177                 extra_width = w;
 178         }
 179     }
 180     pum_base_width = max_width;
 181     pum_kind_width = kind_width;
 182
 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;
 190
 191     /* if there are more items than room we need a scrollbar */
 192     if (pum_height < size)
 193     {
 194         pum_scrollbar = 1;
 195         ++max_width;
 196     }
 197     else
 198         pum_scrollbar = 0;
 199
 200     if (def_width < max_width)
 201         def_width = max_width;
 202
 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
 208        ))
 209     {
 210         /* align pum column with "col" */
 211         pum_col = col;
 212
 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;
 219
 220         if (pum_width > max_width + kind_width + extra_width + 1
 221                                                  && pum_width > PUM_DEF_WIDTH)
 222         {
 223             pum_width = max_width + kind_width + extra_width + 1;
 224             if (pum_width < PUM_DEF_WIDTH)
 225                 pum_width = PUM_DEF_WIDTH;
 226         }
 227     }
 228     else if (Columns < def_width)
 229     {
 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;
 238     }
 239     else
 240     {
 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;
 250     }
 251
 252     pum_array = array;
 253     pum_size = size;
 254
 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;
 260 }
 261
 262 /*
 263  * Redraw the popup menu, using "pum_first" and "pum_selected".
 264  */
 265     void
 266 pum_redraw()
 267 {
 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;
 284
 285     if (pum_scrollbar)
 286     {
 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);
 293     }
 294
 295     for (i = 0; i < pum_height; ++i)
 296     {
 297         idx = i + pum_first;
 298         attr = (idx == pum_selected) ? attr_select : attr_norm;
 299
 300         /* prepend a space if there is room */
 301 #ifdef FEAT_RIGHTLEFT
 302         if (curwin->w_p_rl)
 303         {
 304             if (pum_col < W_WINCOL(curwin) + W_WIDTH(curwin) - 1)
 305                 screen_putchar(' ', row, pum_col + 1, attr);
 306         }
 307         else
 308 #endif
 309             if (pum_col > 0)
 310                 screen_putchar(' ', row, pum_col - 1, attr);
 311
 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)
 317         {
 318             width = 0;
 319             s = NULL;
 320             switch (round)
 321             {
 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;
 325             }
 326             if (p != NULL)
 327                 for ( ; ; mb_ptr_adv(p))
 328                 {
 329                     if (s == NULL)
 330                         s = p;
 331                     w = ptr2cells(p);
 332                     if (*p == NUL || *p == TAB || totwidth + w > pum_width)
 333                     {
 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;
 338
 339                         *p = NUL;
 340                         st = transstr(s);
 341                         *p = saved;
 342 #ifdef FEAT_RIGHTLEFT
 343                         if (curwin->w_p_rl)
 344                         {
 345                             if (st != NULL)
 346                             {
 347                                 char_u  *rt = reverse_text(st);
 348                                 char_u  *rt_saved = rt;
 349                                 int     len, j;
 350
 351                                 if (rt != NULL)
 352                                 {
 353                                     len = (int)STRLEN(rt);
 354                                     if (len > pum_width)
 355                                     {
 356                                         for (j = pum_width; j < len; ++j)
 357                                             mb_ptr_adv(rt);
 358                                         len = pum_width;
 359                                     }
 360                                     screen_puts_len(rt, len, row,
 361                                                         col - len + 1, attr);
 362                                     vim_free(rt_saved);
 363                                 }
 364                                 vim_free(st);
 365                             }
 366                             col -= width;
 367                         }
 368                         else
 369 #endif
 370                         {
 371                             if (st != NULL)
 372                             {
 373                                 screen_puts_len(st, (int)STRLEN(st), row, col,
 374                                                                         attr);
 375                                 vim_free(st);
 376                             }
 377                             col += width;
 378                         }
 379
 380                         if (*p != TAB)
 381                             break;
 382
 383                         /* Display two spaces for a Tab. */
 384 #ifdef FEAT_RIGHTLEFT
 385                         if (curwin->w_p_rl)
 386                         {
 387                             screen_puts_len((char_u *)"  ", 2, row, col - 1,
 388                                                                         attr);
 389                             col -= 2;
 390                         }
 391                         else
 392 #endif
 393                         {
 394                             screen_puts_len((char_u *)"  ", 2, row, col, attr);
 395                             col += 2;
 396                         }
 397                         totwidth += 2;
 398                         s = NULL;           /* start text at next char */
 399                         width = 0;
 400                     }
 401                     else
 402                         width += w;
 403                 }
 404
 405             if (round > 1)
 406                 n = pum_kind_width + 1;
 407             else
 408                 n = 1;
 409
 410             /* Stop when there is nothing more to display. */
 411             if (round == 3
 412                     || (round == 2 && pum_array[idx].pum_extra == NULL)
 413                     || (round == 1 && pum_array[idx].pum_kind == NULL
 414                                           && pum_array[idx].pum_extra == NULL)
 415                     || pum_base_width + n >= pum_width)
 416                 break;
 417 #ifdef FEAT_RIGHTLEFT
 418             if (curwin->w_p_rl)
 419             {
 420                 screen_fill(row, row + 1, pum_col - pum_base_width - n + 1,
 421                                                     col + 1, ' ', ' ', attr);
 422                 col = pum_col - pum_base_width - n + 1;
 423             }
 424             else
 425 #endif
 426             {
 427                 screen_fill(row, row + 1, col, pum_col + pum_base_width + n,
 428                                                               ' ', ' ', attr);
 429                 col = pum_col + pum_base_width + n;
 430             }
 431             totwidth = pum_base_width + n;
 432         }
 433
 434 #ifdef FEAT_RIGHTLEFT
 435         if (curwin->w_p_rl)
 436             screen_fill(row, row + 1, pum_col - pum_width + 1, col + 1, ' ',
 437                                                                     ' ', attr);
 438         else
 439 #endif
 440             screen_fill(row, row + 1, col, pum_col + pum_width, ' ', ' ',
 441                                                                         attr);
 442         if (pum_scrollbar > 0)
 443         {
 444 #ifdef FEAT_RIGHTLEFT
 445             if (curwin->w_p_rl)
 446                 screen_putchar(' ', row, pum_col - pum_width,
 447                         i >= thumb_pos && i < thumb_pos + thumb_heigth
 448                                                   ? attr_thumb : attr_scroll);
 449             else
 450 #endif
 451                 screen_putchar(' ', row, pum_col + pum_width,
 452                         i >= thumb_pos && i < thumb_pos + thumb_heigth
 453                                                   ? attr_thumb : attr_scroll);
 454         }
 455
 456         ++row;
 457     }
 458 }
 459
 460 #if 0 /* not used yet */
 461 /*
 462  * Return the index of the currently selected item.
 463  */
 464     int
 465 pum_get_selected()
 466 {
 467     return pum_selected;
 468 }
 469 #endif
 470
 471 /*
 472  * Set the index of the currently selected item.  The menu will scroll when
 473  * necessary.  When "n" is out of range don't scroll.
 474  * This may be repeated when the preview window is used:
 475  * "repeat" == 0: open preview window normally
 476  * "repeat" == 1: open preview window but don't set the size
 477  * "repeat" == 2: don't open preview window
 478  * Returns TRUE when the window was resized and the location of the popup menu
 479  * must be recomputed.
 480  */
 481     static int
 482 pum_set_selected(n, repeat)
 483     int     n;
 484     int     repeat;
 485 {
 486     int     resized = FALSE;
 487     int     context = pum_height / 2;
 488
 489     pum_selected = n;
 490
 491     if (pum_selected >= 0 && pum_selected < pum_size)
 492     {
 493         if (pum_first > pum_selected - 4)
 494         {
 495             /* scroll down; when we did a jump it's probably a PageUp then
 496              * scroll a whole page */
 497             if (pum_first > pum_selected - 2)
 498             {
 499                 pum_first -= pum_height - 2;
 500                 if (pum_first < 0)
 501                     pum_first = 0;
 502                 else if (pum_first > pum_selected)
 503                     pum_first = pum_selected;
 504             }
 505             else
 506                 pum_first = pum_selected;
 507         }
 508         else if (pum_first < pum_selected - pum_height + 5)
 509         {
 510             /* scroll up; when we did a jump it's probably a PageDown then
 511              * scroll a whole page */
 512             if (pum_first < pum_selected - pum_height + 1 + 2)
 513             {
 514                 pum_first += pum_height - 2;
 515                 if (pum_first < pum_selected - pum_height + 1)
 516                     pum_first = pum_selected - pum_height + 1;
 517             }
 518             else
 519                 pum_first = pum_selected - pum_height + 1;
 520         }
 521
 522         /* Give a few lines of context when possible. */
 523         if (context > 3)
 524             context = 3;
 525         if (pum_height > 2)
 526         {
 527             if (pum_first > pum_selected - context)
 528             {
 529                 /* scroll down */
 530                 pum_first = pum_selected - context;
 531                 if (pum_first < 0)
 532                     pum_first = 0;
 533             }
 534             else if (pum_first < pum_selected + context - pum_height + 1)
 535             {
 536                 /* scroll up */
 537                 pum_first = pum_selected + context - pum_height + 1;
 538             }
 539         }
 540
 541 #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
 542         /*
 543          * Show extra info in the preview window if there is something and
 544          * 'completeopt' contains "preview".
 545          * Skip this when tried twice already.
 546          * Skip this also when there is not much room.
 547          * NOTE: Be very careful not to sync undo!
 548          */
 549         if (pum_array[pum_selected].pum_info != NULL
 550                 && Rows > 10
 551                 && repeat <= 1
 552                 && vim_strchr(p_cot, 'p') != NULL)
 553         {
 554             win_T       *curwin_save = curwin;
 555             int         res = OK;
 556
 557             /* Open a preview window.  3 lines by default. */
 558             g_do_tagpreview = 3;
 559             resized = prepare_tagpreview(FALSE);
 560             g_do_tagpreview = 0;
 561
 562             if (curwin->w_p_pvw)
 563             {
 564                 if (curbuf->b_fname == NULL
 565                         && curbuf->b_p_bt[0] == 'n' && curbuf->b_p_bt[2] == 'f'
 566                         && curbuf->b_p_bh[0] == 'w')
 567                 {
 568                     /* Already a "wipeout" buffer, make it empty. */
 569                     while (!bufempty())
 570                         ml_delete((linenr_T)1, FALSE);
 571                 }
 572                 else
 573                 {
 574                     /* Don't want to sync undo in the current buffer. */
 575                     ++no_u_sync;
 576                     res = do_ecmd(0, NULL, NULL, NULL, ECMD_ONE, 0);
 577                     --no_u_sync;
 578                     if (res == OK)
 579                     {
 580                         /* Edit a new, empty buffer. Set options for a "wipeout"
 581                          * buffer. */
 582                         set_option_value((char_u *)"swf", 0L, NULL, OPT_LOCAL);
 583                         set_option_value((char_u *)"bt", 0L,
 584                                                (char_u *)"nofile", OPT_LOCAL);
 585                         set_option_value((char_u *)"bh", 0L,
 586                                                  (char_u *)"wipe", OPT_LOCAL);
 587                         set_option_value((char_u *)"diff", 0L,
 588                                                              NULL, OPT_LOCAL);
 589                     }
 590                 }
 591                 if (res == OK)
 592                 {
 593                     char_u      *p, *e;
 594                     linenr_T    lnum = 0;
 595
 596                     for (p = pum_array[pum_selected].pum_info; *p != NUL; )
 597                     {
 598                         e = vim_strchr(p, '\n');
 599                         if (e == NULL)
 600                         {
 601                             ml_append(lnum++, p, 0, FALSE);
 602                             break;
 603                         }
 604                         else
 605                         {
 606                             *e = NUL;
 607                             ml_append(lnum++, p, (int)(e - p + 1), FALSE);
 608                             *e = '\n';
 609                             p = e + 1;
 610                         }
 611                     }
 612
 613                     /* Increase the height of the preview window to show the
 614                      * text, but no more than 'previewheight' lines. */
 615                     if (repeat == 0)
 616                     {
 617                         if (lnum > p_pvh)
 618                             lnum = p_pvh;
 619                         if (curwin->w_height < lnum)
 620                         {
 621                             win_setheight((int)lnum);
 622                             resized = TRUE;
 623                         }
 624                     }
 625
 626                     curbuf->b_changed = 0;
 627                     curbuf->b_p_ma = FALSE;
 628                     curwin->w_cursor.lnum = 0;
 629                     curwin->w_cursor.col = 0;
 630
 631                     if (curwin != curwin_save && win_valid(curwin_save))
 632                     {
 633                         /* Return cursor to where we were */
 634                         validate_cursor();
 635                         redraw_later(SOME_VALID);
 636
 637                         /* When the preview window was resized we need to
 638                          * update the view on the buffer.  Only go back to
 639                          * the window when needed, otherwise it will always be
 640                          * redraw. */
 641                         if (resized)
 642                         {
 643                             win_enter(curwin_save, TRUE);
 644                             update_topline();
 645                         }
 646
 647                         /* Update the screen before drawing the popup menu.
 648                          * Enable updating the status lines. */
 649                         pum_do_redraw = TRUE;
 650                         update_screen(0);
 651                         pum_do_redraw = FALSE;
 652
 653                         if (!resized && win_valid(curwin_save))
 654                             win_enter(curwin_save, TRUE);
 655
 656                         /* May need to update the screen again when there are
 657                          * autocommands involved. */
 658                         pum_do_redraw = TRUE;
 659                         update_screen(0);
 660                         pum_do_redraw = FALSE;
 661                     }
 662                 }
 663             }
 664         }
 665 #endif
 666     }
 667
 668     /* Never display more than we have */
 669     if (pum_first > pum_size - pum_height)
 670         pum_first = pum_size - pum_height;
 671
 672     if (!resized)
 673         pum_redraw();
 674
 675     return resized;
 676 }
 677
 678 /*
 679  * Undisplay the popup menu (later).
 680  */
 681     void
 682 pum_undisplay()
 683 {
 684     pum_array = NULL;
 685     redraw_all_later(SOME_VALID);
 686 #ifdef FEAT_WINDOWS
 687     redraw_tabline = TRUE;
 688 #endif
 689     status_redraw_all();
 690 }
 691
 692 /*
 693  * Clear the popup menu.  Currently only resets the offset to the first
 694  * displayed item.
 695  */
 696     void
 697 pum_clear()
 698 {
 699     pum_first = 0;
 700 }
 701
 702 /*
 703  * Return TRUE if the popup menu is displayed.
 704  * Overruled when "pum_do_redraw" is set, used to redraw the status lines.
 705  */
 706     int
 707 pum_visible()
 708 {
 709     return !pum_do_redraw && pum_array != NULL;
 710 }
 711
 712 /*
 713  * Return the height of the popup menu, the number of entries visible.
 714  * Only valid when pum_visible() returns TRUE!
 715  */
 716     int
 717 pum_get_height()
 718 {
 719     return pum_height;
 720 }
 721
 722 #endif