Mercurial > hg > RemoteEditor > vim7

comparison src/menu.c @ 0:76efa0be13f1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial revision
author atsuki
date Sat, 10 Nov 2007 15:07:22 +0900
parents
children 6a13985590e6
comparison
equal deleted inserted replaced
-1:000000000000 0:76efa0be13f1
1 /* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 * GUI/Motif support by Robert Webb
5 *
6 * Do ":help uganda" in Vim to read copying and usage conditions.
7 * Do ":help credits" in Vim to see a list of people who contributed.
8 * See README.txt for an overview of the Vim source code.
9 */
10
11 /*
12 * Code for menus. Used for the GUI and 'wildmenu'.
13 */
14
15 #include "vim.h"
16
17 #if defined(FEAT_MENU) || defined(PROTO)
18
19 #define MENUDEPTH 10 /* maximum depth of menus */
20
21 #ifdef FEAT_GUI_W32
22 static int add_menu_path __ARGS((char_u *, vimmenu_T *, int *, char_u *, int));
23 #else
24 static int add_menu_path __ARGS((char_u *, vimmenu_T *, int *, char_u *));
25 #endif
26 static int menu_nable_recurse __ARGS((vimmenu_T *menu, char_u *name, int modes, int enable));
27 static int remove_menu __ARGS((vimmenu_T **, char_u *, int, int silent));
28 static void free_menu __ARGS((vimmenu_T **menup));
29 static void free_menu_string __ARGS((vimmenu_T *, int));
30 static int show_menus __ARGS((char_u *, int));
31 static void show_menus_recursive __ARGS((vimmenu_T *, int, int));
32 static int menu_name_equal __ARGS((char_u *name, vimmenu_T *menu));
33 static int menu_namecmp __ARGS((char_u *name, char_u *mname));
34 static int get_menu_cmd_modes __ARGS((char_u *, int, int *, int *));
35 static char_u *popup_mode_name __ARGS((char_u *name, int idx));
36 static char_u *menu_text __ARGS((char_u *text, int *mnemonic, char_u **actext));
37 #ifdef FEAT_GUI
38 static int get_menu_mode __ARGS((void));
39 static void gui_update_menus_recurse __ARGS((vimmenu_T *, int));
40 #endif
41
42 #if defined(FEAT_GUI_W32) && defined(FEAT_TEAROFF)
43 static void gui_create_tearoffs_recurse __ARGS((vimmenu_T *menu, const char_u *pname, int *pri_tab, int pri_idx));
44 static void gui_add_tearoff __ARGS((char_u *tearpath, int *pri_tab, int pri_idx));
45 static void gui_destroy_tearoffs_recurse __ARGS((vimmenu_T *menu));
46 static int s_tearoffs = FALSE;
47 #endif
48
49 static int menu_is_hidden __ARGS((char_u *name));
50 #if defined(FEAT_CMDL_COMPL) || (defined(FEAT_GUI_W32) && defined(FEAT_TEAROFF))
51 static int menu_is_tearoff __ARGS((char_u *name));
52 #endif
53
54 #if defined(FEAT_MULTI_LANG) || defined(FEAT_TOOLBAR)
55 static char_u *menu_skip_part __ARGS((char_u *p));
56 #endif
57 #ifdef FEAT_MULTI_LANG
58 static char_u *menutrans_lookup __ARGS((char_u *name, int len));
59 #endif
60
61 /* The character for each menu mode */
62 static char_u menu_mode_chars[] = {'n', 'v', 's', 'o', 'i', 'c', 't'};
63
64 static char_u e_notsubmenu[] = N_("E327: Part of menu-item path is not sub-menu");
65 static char_u e_othermode[] = N_("E328: Menu only exists in another mode");
66 static char_u e_nomenu[] = N_("E329: No menu \"%s\"");
67
68 #ifdef FEAT_TOOLBAR
69 static const char *toolbar_names[] =
70 {
71 /* 0 */ "New", "Open", "Save", "Undo", "Redo",
72 /* 5 */ "Cut", "Copy", "Paste", "Print", "Help",
73 /* 10 */ "Find", "SaveAll", "SaveSesn", "NewSesn", "LoadSesn",
74 /* 15 */ "RunScript", "Replace", "WinClose", "WinMax", "WinMin",
75 /* 20 */ "WinSplit", "Shell", "FindPrev", "FindNext", "FindHelp",
76 /* 25 */ "Make", "TagJump", "RunCtags", "WinVSplit", "WinMaxWidth",
77 /* 30 */ "WinMinWidth", "Exit"
78 };
79 # define TOOLBAR_NAME_COUNT (sizeof(toolbar_names) / sizeof(char *))
80 #endif
81
82 /*
83 * Do the :menu command and relatives.
84 */
85 void
86 ex_menu(eap)
87 exarg_T *eap; /* Ex command arguments */
88 {
89 char_u *menu_path;
90 int modes;
91 char_u *map_to;
92 int noremap;
93 int silent = FALSE;
94 int special = FALSE;
95 int unmenu;
96 char_u *map_buf;
97 char_u *arg;
98 char_u *p;
99 int i;
100 #if defined(FEAT_GUI) && !defined(FEAT_GUI_GTK)
101 int old_menu_height;
102 # if defined(FEAT_TOOLBAR) && !defined(FEAT_GUI_W32) && !defined(FEAT_GUI_W16)
103 int old_toolbar_height;
104 # endif
105 #endif
106 int pri_tab[MENUDEPTH + 1];
107 int enable = MAYBE; /* TRUE for "menu enable", FALSE for "menu
108 * disable */
109 #ifdef FEAT_MULTI_LANG
110 char_u *tofree = NULL;
111 char_u *new_cmd;
112 #endif
113 #ifdef FEAT_TOOLBAR
114 char_u *icon = NULL;
115 #endif
116 vimmenu_T menuarg;
117
118 modes = get_menu_cmd_modes(eap->cmd, eap->forceit, &noremap, &unmenu);
119 arg = eap->arg;
120
121 for (;;)
122 {
123 if (STRNCMP(arg, "<script>", 8) == 0)
124 {
125 noremap = REMAP_SCRIPT;
126 arg = skipwhite(arg + 8);
127 continue;
128 }
129 if (STRNCMP(arg, "<silent>", 8) == 0)
130 {
131 silent = TRUE;
132 arg = skipwhite(arg + 8);
133 continue;
134 }
135 if (STRNCMP(arg, "<special>", 9) == 0)
136 {
137 special = TRUE;
138 arg = skipwhite(arg + 9);
139 continue;
140 }
141 break;
142 }
143
144
145 /* Locate an optional "icon=filename" argument. */
146 if (STRNCMP(arg, "icon=", 5) == 0)
147 {
148 arg += 5;
149 #ifdef FEAT_TOOLBAR
150 icon = arg;
151 #endif
152 while (*arg != NUL && *arg != ' ')
153 {
154 if (*arg == '\\')
155 mch_memmove(arg, arg + 1, STRLEN(arg));
156 mb_ptr_adv(arg);
157 }
158 if (*arg != NUL)
159 {
160 *arg++ = NUL;
161 arg = skipwhite(arg);
162 }
163 }
164
165 /*
166 * Fill in the priority table.
167 */
168 for (p = arg; *p; ++p)
169 if (!VIM_ISDIGIT(*p) && *p != '.')
170 break;
171 if (vim_iswhite(*p))
172 {
173 for (i = 0; i < MENUDEPTH && !vim_iswhite(*arg); ++i)
174 {
175 pri_tab[i] = getdigits(&arg);
176 if (pri_tab[i] == 0)
177 pri_tab[i] = 500;
178 if (*arg == '.')
179 ++arg;
180 }
181 arg = skipwhite(arg);
182 }
183 else if (eap->addr_count && eap->line2 != 0)
184 {
185 pri_tab[0] = eap->line2;
186 i = 1;
187 }
188 else
189 i = 0;
190 while (i < MENUDEPTH)
191 pri_tab[i++] = 500;
192 pri_tab[MENUDEPTH] = -1; /* mark end of the table */
193
194 /*
195 * Check for "disable" or "enable" argument.
196 */
197 if (STRNCMP(arg, "enable", 6) == 0 && vim_iswhite(arg[6]))
198 {
199 enable = TRUE;
200 arg = skipwhite(arg + 6);
201 }
202 else if (STRNCMP(arg, "disable", 7) == 0 && vim_iswhite(arg[7]))
203 {
204 enable = FALSE;
205 arg = skipwhite(arg + 7);
206 }
207
208 /*
209 * If there is no argument, display all menus.
210 */
211 if (*arg == NUL)
212 {
213 show_menus(arg, modes);
214 return;
215 }
216
217 #ifdef FEAT_TOOLBAR
218 /*
219 * Need to get the toolbar icon index before doing the translation.
220 */
221 menuarg.iconidx = -1;
222 menuarg.icon_builtin = FALSE;
223 if (menu_is_toolbar(arg))
224 {
225 menu_path = menu_skip_part(arg);
226 if (*menu_path == '.')
227 {
228 p = menu_skip_part(++menu_path);
229 if (STRNCMP(menu_path, "BuiltIn", 7) == 0)
230 {
231 if (skipdigits(menu_path + 7) == p)
232 {
233 menuarg.iconidx = atoi((char *)menu_path + 7);
234 if (menuarg.iconidx >= TOOLBAR_NAME_COUNT)
235 menuarg.iconidx = -1;
236 else
237 menuarg.icon_builtin = TRUE;
238 }
239 }
240 else
241 {
242 for (i = 0; i < TOOLBAR_NAME_COUNT; ++i)
243 if (STRNCMP(toolbar_names[i], menu_path, p - menu_path)
244 == 0)
245 {
246 menuarg.iconidx = i;
247 break;
248 }
249 }
250 }
251 }
252 #endif
253
254 #ifdef FEAT_MULTI_LANG
255 /*
256 * Translate menu names as specified with ":menutrans" commands.
257 */
258 menu_path = arg;
259 while (*menu_path)
260 {
261 /* find the end of one part and check if it should be translated */
262 p = menu_skip_part(menu_path);
263 map_to = menutrans_lookup(menu_path, (int)(p - menu_path));
264 if (map_to != NULL)
265 {
266 /* found a match: replace with the translated part */
267 i = (int)STRLEN(map_to);
268 new_cmd = alloc((unsigned)STRLEN(arg) + i + 1);
269 if (new_cmd == NULL)
270 break;
271 mch_memmove(new_cmd, arg, menu_path - arg);
272 mch_memmove(new_cmd + (menu_path - arg), map_to, (size_t)i);
273 STRCPY(new_cmd + (menu_path - arg) + i, p);
274 p = new_cmd + (menu_path - arg) + i;
275 vim_free(tofree);
276 tofree = new_cmd;
277 arg = new_cmd;
278 }
279 if (*p != '.')
280 break;
281 menu_path = p + 1;
282 }
283 #endif
284
285 /*
286 * Isolate the menu name.
287 * Skip the menu name, and translate <Tab> into a real TAB.
288 */
289 menu_path = arg;
290 if (*menu_path == '.')
291 {
292 EMSG2(_(e_invarg2), menu_path);
293 goto theend;
294 }
295
296 while (*arg && !vim_iswhite(*arg))
297 {
298 if ((*arg == '\\' || *arg == Ctrl_V) && arg[1] != NUL)
299 arg++;
300 else if (STRNICMP(arg, "<TAB>", 5) == 0)
301 {
302 *arg = TAB;
303 mch_memmove(arg + 1, arg + 5, STRLEN(arg + 4));
304 }
305 arg++;
306 }
307 if (*arg != NUL)
308 *arg++ = NUL;
309 arg = skipwhite(arg);
310 map_to = arg;
311
312 /*
313 * If there is only a menu name, display menus with that name.
314 */
315 if (*map_to == NUL && !unmenu && enable == MAYBE)
316 {
317 show_menus(menu_path, modes);
318 goto theend;
319 }
320 else if (*map_to != NUL && (unmenu || enable != MAYBE))
321 {
322 EMSG(_(e_trailing));
323 goto theend;
324 }
325 #if defined(FEAT_GUI) && !(defined(FEAT_GUI_GTK) || defined(FEAT_GUI_PHOTON))
326 old_menu_height = gui.menu_height;
327 # if defined(FEAT_TOOLBAR) && !defined(FEAT_GUI_W32) && !defined(FEAT_GUI_W16)
328 old_toolbar_height = gui.toolbar_height;
329 # endif
330 #endif
331
332 if (enable != MAYBE)
333 {
334 /*
335 * Change sensitivity of the menu.
336 * For the PopUp menu, remove a menu for each mode separately.
337 * Careful: menu_nable_recurse() changes menu_path.
338 */
339 if (STRCMP(menu_path, "*") == 0) /* meaning: do all menus */
340 menu_path = (char_u *)"";
341
342 if (menu_is_popup(menu_path))
343 {
344 for (i = 0; i < MENU_INDEX_TIP; ++i)
345 if (modes & (1 << i))
346 {
347 p = popup_mode_name(menu_path, i);
348 if (p != NULL)
349 {
350 menu_nable_recurse(root_menu, p, MENU_ALL_MODES,
351 enable);
352 vim_free(p);
353 }
354 }
355 }
356 menu_nable_recurse(root_menu, menu_path, modes, enable);
357 }
358 else if (unmenu)
359 {
360 /*
361 * Delete menu(s).
362 */
363 if (STRCMP(menu_path, "*") == 0) /* meaning: remove all menus */
364 menu_path = (char_u *)"";
365
366 /*
367 * For the PopUp menu, remove a menu for each mode separately.
368 */
369 if (menu_is_popup(menu_path))
370 {
371 for (i = 0; i < MENU_INDEX_TIP; ++i)
372 if (modes & (1 << i))
373 {
374 p = popup_mode_name(menu_path, i);
375 if (p != NULL)
376 {
377 remove_menu(&root_menu, p, MENU_ALL_MODES, TRUE);
378 vim_free(p);
379 }
380 }
381 }
382
383 /* Careful: remove_menu() changes menu_path */
384 remove_menu(&root_menu, menu_path, modes, FALSE);
385 }
386 else
387 {
388 /*
389 * Add menu(s).
390 * Replace special key codes.
391 */
392 if (STRICMP(map_to, "<nop>") == 0) /* "<Nop>" means nothing */
393 {
394 map_to = (char_u *)"";
395 map_buf = NULL;
396 }
397 else if (modes & MENU_TIP_MODE)
398 map_buf = NULL; /* Menu tips are plain text. */
399 else
400 map_to = replace_termcodes(map_to, &map_buf, FALSE, TRUE, special);
401 menuarg.modes = modes;
402 #ifdef FEAT_TOOLBAR
403 menuarg.iconfile = icon;
404 #endif
405 menuarg.noremap[0] = noremap;
406 menuarg.silent[0] = silent;
407 add_menu_path(menu_path, &menuarg, pri_tab, map_to
408 #ifdef FEAT_GUI_W32
409 , TRUE
410 #endif
411 );
412
413 /*
414 * For the PopUp menu, add a menu for each mode separately.
415 */
416 if (menu_is_popup(menu_path))
417 {
418 for (i = 0; i < MENU_INDEX_TIP; ++i)
419 if (modes & (1 << i))
420 {
421 p = popup_mode_name(menu_path, i);
422 if (p != NULL)
423 {
424 /* Include all modes, to make ":amenu" work */
425 menuarg.modes = modes;
426 #ifdef FEAT_TOOLBAR
427 menuarg.iconfile = NULL;
428 menuarg.iconidx = -1;
429 menuarg.icon_builtin = FALSE;
430 #endif
431 add_menu_path(p, &menuarg, pri_tab, map_to
432 #ifdef FEAT_GUI_W32
433 , TRUE
434 #endif
435 );
436 vim_free(p);
437 }
438 }
439 }
440
441 vim_free(map_buf);
442 }
443
444 #if defined(FEAT_GUI) && !(defined(FEAT_GUI_GTK))
445 /* If the menubar height changed, resize the window */
446 if (gui.in_use
447 && (gui.menu_height != old_menu_height
448 # if defined(FEAT_TOOLBAR) && !defined(FEAT_GUI_W32) && !defined(FEAT_GUI_W16)
449 || gui.toolbar_height != old_toolbar_height
450 # endif
451 ))
452 gui_set_shellsize(FALSE, FALSE, RESIZE_VERT);
453 #endif
454
455 theend:
456 #ifdef FEAT_MULTI_LANG
457 vim_free(tofree);
458 #else
459 ;
460 #endif
461 }
462
463 /*
464 * Add the menu with the given name to the menu hierarchy
465 */
466 static int
467 add_menu_path(menu_path, menuarg, pri_tab, call_data
468 #ifdef FEAT_GUI_W32
469 , addtearoff
470 #endif
471 )
472 char_u *menu_path;
473 vimmenu_T *menuarg; /* passes modes, iconfile, iconidx,
474 icon_builtin, silent[0], noremap[0] */
475 int *pri_tab;
476 char_u *call_data;
477 #ifdef FEAT_GUI_W32
478 int addtearoff; /* may add tearoff item */
479 #endif
480 {
481 char_u *path_name;
482 int modes = menuarg->modes;
483 vimmenu_T **menup;
484 vimmenu_T *menu = NULL;
485 vimmenu_T *parent;
486 vimmenu_T **lower_pri;
487 char_u *p;
488 char_u *name;
489 char_u *dname;
490 char_u *next_name;
491 int i;
492 int c;
493 #ifdef FEAT_GUI
494 int idx;
495 int new_idx;
496 #endif
497 int pri_idx = 0;
498 int old_modes = 0;
499 int amenu;
500
501 /* Make a copy so we can stuff around with it, since it could be const */
502 path_name = vim_strsave(menu_path);
503 if (path_name == NULL)
504 return FAIL;
505 menup = &root_menu;
506 parent = NULL;
507 name = path_name;
508 while (*name)
509 {
510 /* Get name of this element in the menu hierarchy, and the simplified
511 * name (without mnemonic and accelerator text). */
512 next_name = menu_name_skip(name);
513 dname = menu_text(name, NULL, NULL);
514 if (dname == NULL)
515 goto erret;
516 if (*dname == NUL)
517 {
518 /* Only a mnemonic or accelerator is not valid. */
519 EMSG(_("E792: Empty menu name"));
520 goto erret;
521 }
522
523 /* See if it's already there */
524 lower_pri = menup;
525 #ifdef FEAT_GUI
526 idx = 0;
527 new_idx = 0;
528 #endif
529 menu = *menup;
530 while (menu != NULL)
531 {
532 if (menu_name_equal(name, menu) || menu_name_equal(dname, menu))
533 {
534 if (*next_name == NUL && menu->children != NULL)
535 {
536 if (!sys_menu)
537 EMSG(_("E330: Menu path must not lead to a sub-menu"));
538 goto erret;
539 }
540 if (*next_name != NUL && menu->children == NULL
541 #ifdef FEAT_GUI_W32
542 && addtearoff
543 #endif
544 )
545 {
546 if (!sys_menu)
547 EMSG(_(e_notsubmenu));
548 goto erret;
549 }
550 break;
551 }
552 menup = &menu->next;
553
554 /* Count menus, to find where this one needs to be inserted.
555 * Ignore menus that are not in the menubar (PopUp and Toolbar) */
556 if (parent != NULL || menu_is_menubar(menu->name))
557 {
558 #ifdef FEAT_GUI
559 ++idx;
560 #endif
561 if (menu->priority <= pri_tab[pri_idx])
562 {
563 lower_pri = menup;
564 #ifdef FEAT_GUI
565 new_idx = idx;
566 #endif
567 }
568 }
569 menu = menu->next;
570 }
571
572 if (menu == NULL)
573 {
574 if (*next_name == NUL && parent == NULL)
575 {
576 EMSG(_("E331: Must not add menu items directly to menu bar"));
577 goto erret;
578 }
579
580 if (menu_is_separator(dname) && *next_name != NUL)
581 {
582 EMSG(_("E332: Separator cannot be part of a menu path"));
583 goto erret;
584 }
585
586 /* Not already there, so lets add it */
587 menu = (vimmenu_T *)alloc_clear((unsigned)sizeof(vimmenu_T));
588 if (menu == NULL)
589 goto erret;
590
591 menu->modes = modes;
592 menu->enabled = MENU_ALL_MODES;
593 menu->name = vim_strsave(name);
594 /* separate mnemonic and accelerator text from actual menu name */
595 menu->dname = menu_text(name, &menu->mnemonic, &menu->actext);
596 menu->priority = pri_tab[pri_idx];
597 menu->parent = parent;
598 #ifdef FEAT_GUI_MOTIF
599 menu->sensitive = TRUE; /* the default */
600 #endif
601 #ifdef FEAT_BEVAL_TIP
602 menu->tip = NULL;
603 #endif
604 #ifdef FEAT_GUI_ATHENA
605 menu->image = None; /* X-Windows definition for NULL*/
606 #endif
607
608 /*
609 * Add after menu that has lower priority.
610 */
611 menu->next = *lower_pri;
612 *lower_pri = menu;
613
614 old_modes = 0;
615
616 #ifdef FEAT_TOOLBAR
617 menu->iconidx = menuarg->iconidx;
618 menu->icon_builtin = menuarg->icon_builtin;
619 if (*next_name == NUL && menuarg->iconfile != NULL)
620 menu->iconfile = vim_strsave(menuarg->iconfile);
621 #endif
622 #if defined(FEAT_GUI_W32) && defined(FEAT_TEAROFF)
623 /* the tearoff item must be present in the modes of each item. */
624 if (parent != NULL && menu_is_tearoff(parent->children->dname))
625 parent->children->modes |= modes;
626 #endif
627 }
628 else
629 {
630 old_modes = menu->modes;
631
632 /*
633 * If this menu option was previously only available in other
634 * modes, then make sure it's available for this one now
635 * Also enable a menu when it's created or changed.
636 */
637 #ifdef FEAT_GUI_W32
638 /* If adding a tearbar (addtearoff == FALSE) don't update modes */
639 if (addtearoff)
640 #endif
641 {
642 menu->modes |= modes;
643 menu->enabled |= modes;
644 }
645 }
646
647 #ifdef FEAT_GUI
648 /*
649 * Add the menu item when it's used in one of the modes, but not when
650 * only a tooltip is defined.
651 */
652 if ((old_modes & MENU_ALL_MODES) == 0
653 && (menu->modes & MENU_ALL_MODES) != 0)
654 {
655 if (gui.in_use) /* Otherwise it will be added when GUI starts */
656 {
657 if (*next_name == NUL)
658 {
659 /* Real menu item, not sub-menu */
660 gui_mch_add_menu_item(menu, new_idx);
661
662 /* Want to update menus now even if mode not changed */
663 force_menu_update = TRUE;
664 }
665 else
666 {
667 /* Sub-menu (not at end of path yet) */
668 gui_mch_add_menu(menu, new_idx);
669 }
670 }
671
672 # if defined(FEAT_GUI_W32) & defined(FEAT_TEAROFF)
673 /* When adding a new submenu, may add a tearoff item */
674 if ( addtearoff
675 && *next_name
676 && vim_strchr(p_go, GO_TEAROFF) != NULL
677 && menu_is_menubar(name))
678 {
679 char_u *tearpath;
680
681 /*
682 * The pointers next_name & path_name refer to a string with
683 * \'s and ^V's stripped out. But menu_path is a "raw"
684 * string, so we must correct for special characters.
685 */
686 tearpath = alloc((unsigned int)STRLEN(menu_path) + TEAR_LEN + 2);
687 if (tearpath != NULL)
688 {
689 char_u *s;
690 int idx;
691
692 STRCPY(tearpath, menu_path);
693 idx = (int)(next_name - path_name - 1);
694 for (s = tearpath; *s && s < tearpath + idx; mb_ptr_adv(s))
695 {
696 if ((*s == '\\' || *s == Ctrl_V) && s[1])
697 {
698 ++idx;
699 ++s;
700 }
701 }
702 tearpath[idx] = NUL;
703 gui_add_tearoff(tearpath, pri_tab, pri_idx);
704 vim_free(tearpath);
705 }
706 }
707 # endif
708 }
709 #endif /* FEAT_GUI */
710
711 menup = &menu->children;
712 parent = menu;
713 name = next_name;
714 vim_free(dname);
715 dname = NULL;
716 if (pri_tab[pri_idx + 1] != -1)
717 ++pri_idx;
718 }
719 vim_free(path_name);
720
721 /*
722 * Only add system menu items which have not been defined yet.
723 * First check if this was an ":amenu".
724 */
725 amenu = ((modes & (MENU_NORMAL_MODE | MENU_INSERT_MODE)) ==
726 (MENU_NORMAL_MODE | MENU_INSERT_MODE));
727 if (sys_menu)
728 modes &= ~old_modes;
729
730 if (menu != NULL && modes)
731 {
732 #ifdef FEAT_GUI
733 menu->cb = gui_menu_cb;
734 #endif
735 p = (call_data == NULL) ? NULL : vim_strsave(call_data);
736
737 /* loop over all modes, may add more than one */
738 for (i = 0; i < MENU_MODES; ++i)
739 {
740 if (modes & (1 << i))
741 {
742 /* free any old menu */
743 free_menu_string(menu, i);
744
745 /* For "amenu", may insert an extra character.
746 * Don't do this if adding a tearbar (addtearoff == FALSE).
747 * Don't do this for "<Nop>". */
748 c = 0;
749 if (amenu && call_data != NULL && *call_data != NUL
750 #ifdef FEAT_GUI_W32
751 && addtearoff
752 #endif
753 )
754 {
755 switch (1 << i)
756 {
757 case MENU_VISUAL_MODE:
758 case MENU_SELECT_MODE:
759 case MENU_OP_PENDING_MODE:
760 case MENU_CMDLINE_MODE:
761 c = Ctrl_C;
762 break;
763 case MENU_INSERT_MODE:
764 c = Ctrl_O;
765 break;
766 }
767 }
768
769 if (c)
770 {
771 menu->strings[i] = alloc((unsigned)(STRLEN(call_data) + 4));
772 if (menu->strings[i] != NULL)
773 {
774 menu->strings[i][0] = c;
775 STRCPY(menu->strings[i] + 1, call_data);
776 if (c == Ctrl_C)
777 {
778 int len = (int)STRLEN(menu->strings[i]);
779
780 /* Append CTRL-\ CTRL-G to obey 'insertmode'. */
781 menu->strings[i][len] = Ctrl_BSL;
782 menu->strings[i][len + 1] = Ctrl_G;
783 menu->strings[i][len + 2] = NUL;
784 }
785 }
786 }
787 else
788 menu->strings[i] = p;
789 menu->noremap[i] = menuarg->noremap[0];
790 menu->silent[i] = menuarg->silent[0];
791 }
792 }
793 #if defined(FEAT_TOOLBAR) && !defined(FEAT_GUI_W32) \
794 && (defined(FEAT_BEVAL) || defined(FEAT_GUI_GTK))
795 /* Need to update the menu tip. */
796 if (modes & MENU_TIP_MODE)
797 gui_mch_menu_set_tip(menu);
798 #endif
799 }
800 return OK;
801
802 erret:
803 vim_free(path_name);
804 vim_free(dname);
805
806 /* Delete any empty submenu we added before discovering the error. Repeat
807 * for higher levels. */
808 while (parent != NULL && parent->children == NULL)
809 {
810 if (parent->parent == NULL)
811 menup = &root_menu;
812 else
813 menup = &parent->parent->children;
814 for ( ; *menup != NULL && *menup != parent; menup = &((*menup)->next))
815 ;
816 if (*menup == NULL) /* safety check */
817 break;
818 parent = parent->parent;
819 free_menu(menup);
820 }
821 return FAIL;
822 }
823
824 /*
825 * Set the (sub)menu with the given name to enabled or disabled.
826 * Called recursively.
827 */
828 static int
829 menu_nable_recurse(menu, name, modes, enable)
830 vimmenu_T *menu;
831 char_u *name;
832 int modes;
833 int enable;
834 {
835 char_u *p;
836
837 if (menu == NULL)
838 return OK; /* Got to bottom of hierarchy */
839
840 /* Get name of this element in the menu hierarchy */
841 p = menu_name_skip(name);
842
843 /* Find the menu */
844 while (menu != NULL)
845 {
846 if (*name == NUL || *name == '*' || menu_name_equal(name, menu))
847 {
848 if (*p != NUL)
849 {
850 if (menu->children == NULL)
851 {
852 EMSG(_(e_notsubmenu));
853 return FAIL;
854 }
855 if (menu_nable_recurse(menu->children, p, modes, enable)
856 == FAIL)
857 return FAIL;
858 }
859 else
860 if (enable)
861 menu->enabled |= modes;
862 else
863 menu->enabled &= ~modes;
864
865 /*
866 * When name is empty, we are doing all menu items for the given
867 * modes, so keep looping, otherwise we are just doing the named
868 * menu item (which has been found) so break here.
869 */
870 if (*name != NUL && *name != '*')
871 break;
872 }
873 menu = menu->next;
874 }
875 if (*name != NUL && *name != '*' && menu == NULL)
876 {
877 EMSG2(_(e_nomenu), name);
878 return FAIL;
879 }
880
881 #ifdef FEAT_GUI
882 /* Want to update menus now even if mode not changed */
883 force_menu_update = TRUE;
884 #endif
885
886 return OK;
887 }
888
889 /*
890 * Remove the (sub)menu with the given name from the menu hierarchy
891 * Called recursively.
892 */
893 static int
894 remove_menu(menup, name, modes, silent)
895 vimmenu_T **menup;
896 char_u *name;
897 int modes;
898 int silent; /* don't give error messages */
899 {
900 vimmenu_T *menu;
901 vimmenu_T *child;
902 char_u *p;
903
904 if (*menup == NULL)
905 return OK; /* Got to bottom of hierarchy */
906
907 /* Get name of this element in the menu hierarchy */
908 p = menu_name_skip(name);
909
910 /* Find the menu */
911 while ((menu = *menup) != NULL)
912 {
913 if (*name == NUL || menu_name_equal(name, menu))
914 {
915 if (*p != NUL && menu->children == NULL)
916 {
917 if (!silent)
918 EMSG(_(e_notsubmenu));
919 return FAIL;
920 }
921 if ((menu->modes & modes) != 0x0)
922 {
923 #if defined(FEAT_GUI_W32) & defined(FEAT_TEAROFF)
924 /*
925 * If we are removing all entries for this menu,MENU_ALL_MODES,
926 * Then kill any tearoff before we start
927 */
928 if (*p == NUL && modes == MENU_ALL_MODES)
929 {
930 if (IsWindow(menu->tearoff_handle))
931 DestroyWindow(menu->tearoff_handle);
932 }
933 #endif
934 if (remove_menu(&menu->children, p, modes, silent) == FAIL)
935 return FAIL;
936 }
937 else if (*name != NUL)
938 {
939 if (!silent)
940 EMSG(_(e_othermode));
941 return FAIL;
942 }
943
944 /*
945 * When name is empty, we are removing all menu items for the given
946 * modes, so keep looping, otherwise we are just removing the named
947 * menu item (which has been found) so break here.
948 */
949 if (*name != NUL)
950 break;
951
952 /* Remove the menu item for the given mode[s]. If the menu item
953 * is no longer valid in ANY mode, delete it */
954 menu->modes &= ~modes;
955 if (modes & MENU_TIP_MODE)
956 free_menu_string(menu, MENU_INDEX_TIP);
957 if ((menu->modes & MENU_ALL_MODES) == 0)
958 free_menu(menup);
959 else
960 menup = &menu->next;
961 }
962 else
963 menup = &menu->next;
964 }
965 if (*name != NUL)
966 {
967 if (menu == NULL)
968 {
969 if (!silent)
970 EMSG2(_(e_nomenu), name);
971 return FAIL;
972 }
973
974
975 /* Recalculate modes for menu based on the new updated children */
976 menu->modes &= ~modes;
977 #if defined(FEAT_GUI_W32) & defined(FEAT_TEAROFF)
978 if ((s_tearoffs) && (menu->children != NULL)) /* there's a tear bar.. */
979 child = menu->children->next; /* don't count tearoff bar */
980 else
981 #endif
982 child = menu->children;
983 for ( ; child != NULL; child = child->next)
984 menu->modes |= child->modes;
985 if (modes & MENU_TIP_MODE)
986 {
987 free_menu_string(menu, MENU_INDEX_TIP);
988 #if defined(FEAT_TOOLBAR) && !defined(FEAT_GUI_W32) \
989 && (defined(FEAT_BEVAL) || defined(FEAT_GUI_GTK))
990 /* Need to update the menu tip. */
991 if (gui.in_use)
992 gui_mch_menu_set_tip(menu);
993 #endif
994 }
995 if ((menu->modes & MENU_ALL_MODES) == 0)
996 {
997 /* The menu item is no longer valid in ANY mode, so delete it */
998 #if defined(FEAT_GUI_W32) & defined(FEAT_TEAROFF)
999 if (s_tearoffs && menu->children != NULL) /* there's a tear bar.. */
1000 free_menu(&menu->children);
1001 #endif
1002 *menup = menu;
1003 free_menu(menup);
1004 }
1005 }
1006
1007 return OK;
1008 }
1009
1010 /*
1011 * Free the given menu structure and remove it from the linked list.
1012 */
1013 static void
1014 free_menu(menup)
1015 vimmenu_T **menup;
1016 {
1017 int i;
1018 vimmenu_T *menu;
1019
1020 menu = *menup;
1021
1022 #ifdef FEAT_GUI
1023 /* Free machine specific menu structures (only when already created) */
1024 /* Also may rebuild a tearoff'ed menu */
1025 if (gui.in_use)
1026 gui_mch_destroy_menu(menu);
1027 #endif
1028
1029 /* Don't change *menup until after calling gui_mch_destroy_menu(). The
1030 * MacOS code needs the original structure to properly delete the menu. */
1031 *menup = menu->next;
1032 vim_free(menu->name);
1033 vim_free(menu->dname);
1034 vim_free(menu->actext);
1035 #ifdef FEAT_TOOLBAR
1036 vim_free(menu->iconfile);
1037 # ifdef FEAT_GUI_MOTIF
1038 vim_free(menu->xpm_fname);
1039 # endif
1040 #endif
1041 for (i = 0; i < MENU_MODES; i++)
1042 free_menu_string(menu, i);
1043 vim_free(menu);
1044
1045 #ifdef FEAT_GUI
1046 /* Want to update menus now even if mode not changed */
1047 force_menu_update = TRUE;
1048 #endif
1049 }
1050
1051 /*
1052 * Free the menu->string with the given index.
1053 */
1054 static void
1055 free_menu_string(menu, idx)
1056 vimmenu_T *menu;
1057 int idx;
1058 {
1059 int count = 0;
1060 int i;
1061
1062 for (i = 0; i < MENU_MODES; i++)
1063 if (menu->strings[i] == menu->strings[idx])
1064 count++;
1065 if (count == 1)
1066 vim_free(menu->strings[idx]);
1067 menu->strings[idx] = NULL;
1068 }
1069
1070 /*
1071 * Show the mapping associated with a menu item or hierarchy in a sub-menu.
1072 */
1073 static int
1074 show_menus(path_name, modes)
1075 char_u *path_name;
1076 int modes;
1077 {
1078 char_u *p;
1079 char_u *name;
1080 vimmenu_T *menu;
1081 vimmenu_T *parent = NULL;
1082
1083 menu = root_menu;
1084 name = path_name = vim_strsave(path_name);
1085 if (path_name == NULL)
1086 return FAIL;
1087
1088 /* First, find the (sub)menu with the given name */
1089 while (*name)
1090 {
1091 p = menu_name_skip(name);
1092 while (menu != NULL)
1093 {
1094 if (menu_name_equal(name, menu))
1095 {
1096 /* Found menu */
1097 if (*p != NUL && menu->children == NULL)
1098 {
1099 EMSG(_(e_notsubmenu));
1100 vim_free(path_name);
1101 return FAIL;
1102 }
1103 else if ((menu->modes & modes) == 0x0)
1104 {
1105 EMSG(_(e_othermode));
1106 vim_free(path_name);
1107 return FAIL;
1108 }
1109 break;
1110 }
1111 menu = menu->next;
1112 }
1113 if (menu == NULL)
1114 {
1115 EMSG2(_(e_nomenu), name);
1116 vim_free(path_name);
1117 return FAIL;
1118 }
1119 name = p;
1120 parent = menu;
1121 menu = menu->children;
1122 }
1123
1124 /* Now we have found the matching menu, and we list the mappings */
1125 /* Highlight title */
1126 MSG_PUTS_TITLE(_("\n--- Menus ---"));
1127
1128 show_menus_recursive(parent, modes, 0);
1129 return OK;
1130 }
1131
1132 /*
1133 * Recursively show the mappings associated with the menus under the given one
1134 */
1135 static void
1136 show_menus_recursive(menu, modes, depth)
1137 vimmenu_T *menu;
1138 int modes;
1139 int depth;
1140 {
1141 int i;
1142 int bit;
1143
1144 if (menu != NULL && (menu->modes & modes) == 0x0)
1145 return;
1146
1147 if (menu != NULL)
1148 {
1149 msg_putchar('\n');
1150 if (got_int) /* "q" hit for "--more--" */
1151 return;
1152 for (i = 0; i < depth; i++)
1153 MSG_PUTS(" ");
1154 if (menu->priority)
1155 {
1156 msg_outnum((long)menu->priority);
1157 MSG_PUTS(" ");
1158 }
1159 /* Same highlighting as for directories!? */
1160 msg_outtrans_attr(menu->name, hl_attr(HLF_D));
1161 }
1162
1163 if (menu != NULL && menu->children == NULL)
1164 {
1165 for (bit = 0; bit < MENU_MODES; bit++)
1166 if ((menu->modes & modes & (1 << bit)) != 0)
1167 {
1168 msg_putchar('\n');
1169 if (got_int) /* "q" hit for "--more--" */
1170 return;
1171 for (i = 0; i < depth + 2; i++)
1172 MSG_PUTS(" ");
1173 msg_putchar(menu_mode_chars[bit]);
1174 if (menu->noremap[bit] == REMAP_NONE)
1175 msg_putchar('*');
1176 else if (menu->noremap[bit] == REMAP_SCRIPT)
1177 msg_putchar('&');
1178 else
1179 msg_putchar(' ');
1180 if (menu->silent[bit])
1181 msg_putchar('s');
1182 else
1183 msg_putchar(' ');
1184 if ((menu->modes & menu->enabled & (1 << bit)) == 0)
1185 msg_putchar('-');
1186 else
1187 msg_putchar(' ');
1188 MSG_PUTS(" ");
1189 if (*menu->strings[bit] == NUL)
1190 msg_puts_attr((char_u *)"<Nop>", hl_attr(HLF_8));
1191 else
1192 msg_outtrans_special(menu->strings[bit], FALSE);
1193 }
1194 }
1195 else
1196 {
1197 if (menu == NULL)
1198 {
1199 menu = root_menu;
1200 depth--;
1201 }
1202 else
1203 menu = menu->children;
1204
1205 /* recursively show all children. Skip PopUp[nvoci]. */
1206 for (; menu != NULL && !got_int; menu = menu->next)
1207 if (!menu_is_hidden(menu->dname))
1208 show_menus_recursive(menu, modes, depth + 1);
1209 }
1210 }
1211
1212 #ifdef FEAT_CMDL_COMPL
1213
1214 /*
1215 * Used when expanding menu names.
1216 */
1217 static vimmenu_T *expand_menu = NULL;
1218 static int expand_modes = 0x0;
1219 static int expand_emenu; /* TRUE for ":emenu" command */
1220
1221 /*
1222 * Work out what to complete when doing command line completion of menu names.
1223 */
1224 char_u *
1225 set_context_in_menu_cmd(xp, cmd, arg, forceit)
1226 expand_T *xp;
1227 char_u *cmd;
1228 char_u *arg;
1229 int forceit;
1230 {
1231 char_u *after_dot;
1232 char_u *p;
1233 char_u *path_name = NULL;
1234 char_u *name;
1235 int unmenu;
1236 vimmenu_T *menu;
1237 int expand_menus;
1238
1239 xp->xp_context = EXPAND_UNSUCCESSFUL;
1240
1241
1242 /* Check for priority numbers, enable and disable */
1243 for (p = arg; *p; ++p)
1244 if (!VIM_ISDIGIT(*p) && *p != '.')
1245 break;
1246
1247 if (!vim_iswhite(*p))
1248 {
1249 if (STRNCMP(arg, "enable", 6) == 0
1250 && (arg[6] == NUL || vim_iswhite(arg[6])))
1251 p = arg + 6;
1252 else if (STRNCMP(arg, "disable", 7) == 0
1253 && (arg[7] == NUL || vim_iswhite(arg[7])))
1254 p = arg + 7;
1255 else
1256 p = arg;
1257 }
1258
1259 while (*p != NUL && vim_iswhite(*p))
1260 ++p;
1261
1262 arg = after_dot = p;
1263
1264 for (; *p && !vim_iswhite(*p); ++p)
1265 {
1266 if ((*p == '\\' || *p == Ctrl_V) && p[1] != NUL)
1267 p++;
1268 else if (*p == '.')
1269 after_dot = p + 1;
1270 }
1271
1272 /* ":tearoff" and ":popup" only use menus, not entries */
1273 expand_menus = !((*cmd == 't' && cmd[1] == 'e') || *cmd == 'p');
1274 expand_emenu = (*cmd == 'e');
1275 if (expand_menus && vim_iswhite(*p))
1276 return NULL; /* TODO: check for next command? */
1277 if (*p == NUL) /* Complete the menu name */
1278 {
1279 /*
1280 * With :unmenu, you only want to match menus for the appropriate mode.
1281 * With :menu though you might want to add a menu with the same name as
1282 * one in another mode, so match menus from other modes too.
1283 */
1284 expand_modes = get_menu_cmd_modes(cmd, forceit, NULL, &unmenu);
1285 if (!unmenu)
1286 expand_modes = MENU_ALL_MODES;
1287
1288 menu = root_menu;
1289 if (after_dot != arg)
1290 {
1291 path_name = alloc((unsigned)(after_dot - arg));
1292 if (path_name == NULL)
1293 return NULL;
1294 vim_strncpy(path_name, arg, after_dot - arg - 1);
1295 }
1296 name = path_name;
1297 while (name != NULL && *name)
1298 {
1299 p = menu_name_skip(name);
1300 while (menu != NULL)
1301 {
1302 if (menu_name_equal(name, menu))
1303 {
1304 /* Found menu */
1305 if ((*p != NUL && menu->children == NULL)
1306 || ((menu->modes & expand_modes) == 0x0))
1307 {
1308 /*
1309 * Menu path continues, but we have reached a leaf.
1310 * Or menu exists only in another mode.
1311 */
1312 vim_free(path_name);
1313 return NULL;
1314 }
1315 break;
1316 }
1317 menu = menu->next;
1318 }
1319 if (menu == NULL)
1320 {
1321 /* No menu found with the name we were looking for */
1322 vim_free(path_name);
1323 return NULL;
1324 }
1325 name = p;
1326 menu = menu->children;
1327 }
1328 vim_free(path_name);
1329
1330 xp->xp_context = expand_menus ? EXPAND_MENUNAMES : EXPAND_MENUS;
1331 xp->xp_pattern = after_dot;
1332 expand_menu = menu;
1333 }
1334 else /* We're in the mapping part */
1335 xp->xp_context = EXPAND_NOTHING;
1336 return NULL;
1337 }
1338
1339 /*
1340 * Function given to ExpandGeneric() to obtain the list of (sub)menus (not
1341 * entries).
1342 */
1343 /*ARGSUSED*/
1344 char_u *
1345 get_menu_name(xp, idx)
1346 expand_T *xp;
1347 int idx;
1348 {
1349 static vimmenu_T *menu = NULL;
1350 char_u *str;
1351
1352 if (idx == 0) /* first call: start at first item */
1353 menu = expand_menu;
1354
1355 /* Skip PopUp[nvoci]. */
1356 while (menu != NULL && (menu_is_hidden(menu->dname)
1357 || menu_is_separator(menu->dname)
1358 || menu_is_tearoff(menu->dname)
1359 || menu->children == NULL))
1360 menu = menu->next;
1361
1362 if (menu == NULL) /* at end of linked list */
1363 return NULL;
1364
1365 if (menu->modes & expand_modes)
1366 str = menu->dname;
1367 else
1368 str = (char_u *)"";
1369
1370 /* Advance to next menu entry. */
1371 menu = menu->next;
1372
1373 return str;
1374 }
1375
1376 /*
1377 * Function given to ExpandGeneric() to obtain the list of menus and menu
1378 * entries.
1379 */
1380 /*ARGSUSED*/
1381 char_u *
1382 get_menu_names(xp, idx)
1383 expand_T *xp;
1384 int idx;
1385 {
1386 static vimmenu_T *menu = NULL;
1387 static char_u tbuffer[256]; /*hack*/
1388 char_u *str;
1389
1390 if (idx == 0) /* first call: start at first item */
1391 menu = expand_menu;
1392
1393 /* Skip Browse-style entries, popup menus and separators. */
1394 while (menu != NULL
1395 && ( menu_is_hidden(menu->dname)
1396 || (expand_emenu && menu_is_separator(menu->dname))
1397 || menu_is_tearoff(menu->dname)
1398 #ifndef FEAT_BROWSE
1399 || menu->dname[STRLEN(menu->dname) - 1] == '.'
1400 #endif
1401 ))
1402 menu = menu->next;
1403
1404 if (menu == NULL) /* at end of linked list */
1405 return NULL;
1406
1407 if (menu->modes & expand_modes)
1408 {
1409 if (menu->children != NULL)
1410 {
1411 STRCPY(tbuffer, menu->dname);
1412 /* hack on menu separators: use a 'magic' char for the separator
1413 * so that '.' in names gets escaped properly */
1414 STRCAT(tbuffer, "\001");
1415 str = tbuffer;
1416 }
1417 else
1418 str = menu->dname;
1419 }
1420 else
1421 str = (char_u *)"";
1422
1423 /* Advance to next menu entry. */
1424 menu = menu->next;
1425
1426 return str;
1427 }
1428 #endif /* FEAT_CMDL_COMPL */
1429
1430 /*
1431 * Skip over this element of the menu path and return the start of the next
1432 * element. Any \ and ^Vs are removed from the current element.
1433 * "name" may be modified.
1434 */
1435 char_u *
1436 menu_name_skip(name)
1437 char_u *name;
1438 {
1439 char_u *p;
1440
1441 for (p = name; *p && *p != '.'; mb_ptr_adv(p))
1442 {
1443 if (*p == '\\' || *p == Ctrl_V)
1444 {
1445 mch_memmove(p, p + 1, STRLEN(p));
1446 if (*p == NUL)
1447 break;
1448 }
1449 }
1450 if (*p)
1451 *p++ = NUL;
1452 return p;
1453 }
1454
1455 /*
1456 * Return TRUE when "name" matches with menu "menu". The name is compared in
1457 * two ways: raw menu name and menu name without '&'. ignore part after a TAB.
1458 */
1459 static int
1460 menu_name_equal(name, menu)
1461 char_u *name;
1462 vimmenu_T *menu;
1463 {
1464 return (menu_namecmp(name, menu->name) || menu_namecmp(name, menu->dname));
1465 }
1466
1467 static int
1468 menu_namecmp(name, mname)
1469 char_u *name;
1470 char_u *mname;
1471 {
1472 int i;
1473
1474 for (i = 0; name[i] != NUL && name[i] != TAB; ++i)
1475 if (name[i] != mname[i])
1476 break;
1477 return ((name[i] == NUL || name[i] == TAB)
1478 && (mname[i] == NUL || mname[i] == TAB));
1479 }
1480
1481 /*
1482 * Return the modes specified by the given menu command (eg :menu! returns
1483 * MENU_CMDLINE_MODE | MENU_INSERT_MODE).
1484 * If "noremap" is not NULL, then the flag it points to is set according to
1485 * whether the command is a "nore" command.
1486 * If "unmenu" is not NULL, then the flag it points to is set according to
1487 * whether the command is an "unmenu" command.
1488 */
1489 static int
1490 get_menu_cmd_modes(cmd, forceit, noremap, unmenu)
1491 char_u *cmd;
1492 int forceit; /* Was there a "!" after the command? */
1493 int *noremap;
1494 int *unmenu;
1495 {
1496 int modes;
1497
1498 switch (*cmd++)
1499 {
1500 case 'v': /* vmenu, vunmenu, vnoremenu */
1501 modes = MENU_VISUAL_MODE | MENU_SELECT_MODE;
1502 break;
1503 case 'x': /* xmenu, xunmenu, xnoremenu */
1504 modes = MENU_VISUAL_MODE;
1505 break;
1506 case 's': /* smenu, sunmenu, snoremenu */
1507 modes = MENU_SELECT_MODE;
1508 break;
1509 case 'o': /* omenu */
1510 modes = MENU_OP_PENDING_MODE;
1511 break;
1512 case 'i': /* imenu */
1513 modes = MENU_INSERT_MODE;
1514 break;
1515 case 't':
1516 modes = MENU_TIP_MODE; /* tmenu */
1517 break;
1518 case 'c': /* cmenu */
1519 modes = MENU_CMDLINE_MODE;
1520 break;
1521 case 'a': /* amenu */
1522 modes = MENU_INSERT_MODE | MENU_CMDLINE_MODE | MENU_NORMAL_MODE
1523 | MENU_VISUAL_MODE | MENU_SELECT_MODE
1524 | MENU_OP_PENDING_MODE;
1525 break;
1526 case 'n':
1527 if (*cmd != 'o') /* nmenu, not noremenu */
1528 {
1529 modes = MENU_NORMAL_MODE;
1530 break;
1531 }
1532 /* FALLTHROUGH */
1533 default:
1534 --cmd;
1535 if (forceit) /* menu!! */
1536 modes = MENU_INSERT_MODE | MENU_CMDLINE_MODE;
1537 else /* menu */
1538 modes = MENU_NORMAL_MODE | MENU_VISUAL_MODE | MENU_SELECT_MODE
1539 | MENU_OP_PENDING_MODE;
1540 }
1541
1542 if (noremap != NULL)
1543 *noremap = (*cmd == 'n' ? REMAP_NONE : REMAP_YES);
1544 if (unmenu != NULL)
1545 *unmenu = (*cmd == 'u');
1546 return modes;
1547 }
1548
1549 /*
1550 * Modify a menu name starting with "PopUp" to include the mode character.
1551 * Returns the name in allocated memory (NULL for failure).
1552 */
1553 static char_u *
1554 popup_mode_name(name, idx)
1555 char_u *name;
1556 int idx;
1557 {
1558 char_u *p;
1559 int len = (int)STRLEN(name);
1560
1561 p = vim_strnsave(name, len + 1);
1562 if (p != NULL)
1563 {
1564 mch_memmove(p + 6, p + 5, (size_t)(len - 4));
1565 p[5] = menu_mode_chars[idx];
1566 }
1567 return p;
1568 }
1569
1570 #if defined(FEAT_GUI) || defined(PROTO)
1571 /*
1572 * Return the index into the menu->strings or menu->noremap arrays for the
1573 * current state. Returns MENU_INDEX_INVALID if there is no mapping for the
1574 * given menu in the current mode.
1575 */
1576 int
1577 get_menu_index(menu, state)
1578 vimmenu_T *menu;
1579 int state;
1580 {
1581 int idx;
1582
1583 if ((state & INSERT))
1584 idx = MENU_INDEX_INSERT;
1585 else if (state & CMDLINE)
1586 idx = MENU_INDEX_CMDLINE;
1587 #ifdef FEAT_VISUAL
1588 else if (VIsual_active)
1589 {
1590 if (VIsual_select)
1591 idx = MENU_INDEX_SELECT;
1592 else
1593 idx = MENU_INDEX_VISUAL;
1594 }
1595 #endif
1596 else if (state == HITRETURN || state == ASKMORE)
1597 idx = MENU_INDEX_CMDLINE;
1598 else if (finish_op)
1599 idx = MENU_INDEX_OP_PENDING;
1600 else if ((state & NORMAL))
1601 idx = MENU_INDEX_NORMAL;
1602 else
1603 idx = MENU_INDEX_INVALID;
1604
1605 if (idx != MENU_INDEX_INVALID && menu->strings[idx] == NULL)
1606 idx = MENU_INDEX_INVALID;
1607 return idx;
1608 }
1609 #endif
1610
1611 /*
1612 * Duplicate the menu item text and then process to see if a mnemonic key
1613 * and/or accelerator text has been identified.
1614 * Returns a pointer to allocated memory, or NULL for failure.
1615 * If mnemonic != NULL, *mnemonic is set to the character after the first '&'.
1616 * If actext != NULL, *actext is set to the text after the first TAB.
1617 */
1618 static char_u *
1619 menu_text(str, mnemonic, actext)
1620 char_u *str;
1621 int *mnemonic;
1622 char_u **actext;
1623 {
1624 char_u *p;
1625 char_u *text;
1626
1627 /* Locate accelerator text, after the first TAB */
1628 p = vim_strchr(str, TAB);
1629 if (p != NULL)
1630 {
1631 if (actext != NULL)
1632 *actext = vim_strsave(p + 1);
1633 text = vim_strnsave(str, (int)(p - str));
1634 }
1635 else
1636 text = vim_strsave(str);
1637
1638 /* Find mnemonic characters "&a" and reduce "&&" to "&". */
1639 for (p = text; p != NULL; )
1640 {
1641 p = vim_strchr(p, '&');
1642 if (p != NULL)
1643 {
1644 if (p[1] == NUL) /* trailing "&" */
1645 break;
1646 if (mnemonic != NULL && p[1] != '&')
1647 #if !defined(__MVS__) || defined(MOTIF390_MNEMONIC_FIXED)
1648 *mnemonic = p[1];
1649 #else
1650 {
1651 /*
1652 * Well there is a bug in the Motif libraries on OS390 Unix.
1653 * The mnemonic keys needs to be converted to ASCII values
1654 * first.
1655 * This behavior has been seen in 2.8 and 2.9.
1656 */
1657 char c = p[1];
1658 __etoa_l(&c, 1);
1659 *mnemonic = c;
1660 }
1661 #endif
1662 mch_memmove(p, p + 1, STRLEN(p));
1663 p = p + 1;
1664 }
1665 }
1666 return text;
1667 }
1668
1669 /*
1670 * Return TRUE if "name" can be a menu in the MenuBar.
1671 */
1672 int
1673 menu_is_menubar(name)
1674 char_u *name;
1675 {
1676 return (!menu_is_popup(name)
1677 && !menu_is_toolbar(name)
1678 && *name != MNU_HIDDEN_CHAR);
1679 }
1680
1681 /*
1682 * Return TRUE if "name" is a popup menu name.
1683 */
1684 int
1685 menu_is_popup(name)
1686 char_u *name;
1687 {
1688 return (STRNCMP(name, "PopUp", 5) == 0);
1689 }
1690
1691 #if (defined(FEAT_GUI_MOTIF) && (XmVersion <= 1002)) || defined(PROTO)
1692 /*
1693 * Return TRUE if "name" is part of a popup menu.
1694 */
1695 int
1696 menu_is_child_of_popup(menu)
1697 vimmenu_T *menu;
1698 {
1699 while (menu->parent != NULL)
1700 menu = menu->parent;
1701 return menu_is_popup(menu->name);
1702 }
1703 #endif
1704
1705 /*
1706 * Return TRUE if "name" is a toolbar menu name.
1707 */
1708 int
1709 menu_is_toolbar(name)
1710 char_u *name;
1711 {
1712 return (STRNCMP(name, "ToolBar", 7) == 0);
1713 }
1714
1715 /*
1716 * Return TRUE if the name is a menu separator identifier: Starts and ends
1717 * with '-'
1718 */
1719 int
1720 menu_is_separator(name)
1721 char_u *name;
1722 {
1723 return (name[0] == '-' && name[STRLEN(name) - 1] == '-');
1724 }
1725
1726 /*
1727 * Return TRUE if the menu is hidden: Starts with ']'
1728 */
1729 static int
1730 menu_is_hidden(name)
1731 char_u *name;
1732 {
1733 return (name[0] == ']') || (menu_is_popup(name) && name[5] != NUL);
1734 }
1735
1736 #if defined(FEAT_CMDL_COMPL) \
1737 || (defined(FEAT_GUI_W32) && defined(FEAT_TEAROFF))
1738 /*
1739 * Return TRUE if the menu is the tearoff menu.
1740 */
1741 /*ARGSUSED*/
1742 static int
1743 menu_is_tearoff(name)
1744 char_u *name;
1745 {
1746 #ifdef FEAT_GUI
1747 return (STRCMP(name, TEAR_STRING) == 0);
1748 #else
1749 return FALSE;
1750 #endif
1751 }
1752 #endif
1753
1754 #ifdef FEAT_GUI
1755
1756 static int
1757 get_menu_mode()
1758 {
1759 #ifdef FEAT_VISUAL
1760 if (VIsual_active)
1761 {
1762 if (VIsual_select)
1763 return MENU_INDEX_SELECT;
1764 return MENU_INDEX_VISUAL;
1765 }
1766 #endif
1767 if (State & INSERT)
1768 return MENU_INDEX_INSERT;
1769 if ((State & CMDLINE) || State == ASKMORE || State == HITRETURN)
1770 return MENU_INDEX_CMDLINE;
1771 if (finish_op)
1772 return MENU_INDEX_OP_PENDING;
1773 if (State & NORMAL)
1774 return MENU_INDEX_NORMAL;
1775 if (State & LANGMAP) /* must be a "r" command, like Insert mode */
1776 return MENU_INDEX_INSERT;
1777 return MENU_INDEX_INVALID;
1778 }
1779
1780 /*
1781 * Check that a pointer appears in the menu tree. Used to protect from using
1782 * a menu that was deleted after it was selected but before the event was
1783 * handled.
1784 * Return OK or FAIL. Used recursively.
1785 */
1786 int
1787 check_menu_pointer(root, menu_to_check)
1788 vimmenu_T *root;
1789 vimmenu_T *menu_to_check;
1790 {
1791 vimmenu_T *p;
1792
1793 for (p = root; p != NULL; p = p->next)
1794 if (p == menu_to_check
1795 || (p->children != NULL
1796 && check_menu_pointer(p->children, menu_to_check) == OK))
1797 return OK;
1798 return FAIL;
1799 }
1800
1801 /*
1802 * After we have started the GUI, then we can create any menus that have been
1803 * defined. This is done once here. add_menu_path() may have already been
1804 * called to define these menus, and may be called again. This function calls
1805 * itself recursively. Should be called at the top level with:
1806 * gui_create_initial_menus(root_menu, NULL);
1807 */
1808 void
1809 gui_create_initial_menus(menu)
1810 vimmenu_T *menu;
1811 {
1812 int idx = 0;
1813
1814 while (menu != NULL)
1815 {
1816 /* Don't add a menu when only a tip was defined. */
1817 if (menu->modes & MENU_ALL_MODES)
1818 {
1819 if (menu->children != NULL)
1820 {
1821 gui_mch_add_menu(menu, idx);
1822 gui_create_initial_menus(menu->children);
1823 }
1824 else
1825 gui_mch_add_menu_item(menu, idx);
1826 }
1827 menu = menu->next;
1828 ++idx;
1829 }
1830 }
1831
1832 /*
1833 * Used recursively by gui_update_menus (see below)
1834 */
1835 static void
1836 gui_update_menus_recurse(menu, mode)
1837 vimmenu_T *menu;
1838 int mode;
1839 {
1840 int grey;
1841
1842 while (menu)
1843 {
1844 if ((menu->modes & menu->enabled & mode)
1845 #if defined(FEAT_GUI_W32) && defined(FEAT_TEAROFF)
1846 || menu_is_tearoff(menu->dname)
1847 #endif
1848 )
1849 grey = FALSE;
1850 else
1851 grey = TRUE;
1852 #ifdef FEAT_GUI_ATHENA
1853 /* Hiding menus doesn't work for Athena, it can cause a crash. */
1854 gui_mch_menu_grey(menu, grey);
1855 #else
1856 /* Never hide a toplevel menu, it may make the menubar resize or
1857 * disappear. Same problem for ToolBar items. */
1858 if (vim_strchr(p_go, GO_GREY) != NULL || menu->parent == NULL
1859 # ifdef FEAT_TOOLBAR
1860 || menu_is_toolbar(menu->parent->name)
1861 # endif
1862 )
1863 gui_mch_menu_grey(menu, grey);
1864 else
1865 gui_mch_menu_hidden(menu, grey);
1866 #endif
1867 gui_update_menus_recurse(menu->children, mode);
1868 menu = menu->next;
1869 }
1870 }
1871
1872 /*
1873 * Make sure only the valid menu items appear for this mode. If
1874 * force_menu_update is not TRUE, then we only do this if the mode has changed
1875 * since last time. If "modes" is not 0, then we use these modes instead.
1876 */
1877 void
1878 gui_update_menus(modes)
1879 int modes;
1880 {
1881 static int prev_mode = -1;
1882 int mode = 0;
1883
1884 if (modes != 0x0)
1885 mode = modes;
1886 else
1887 {
1888 mode = get_menu_mode();
1889 if (mode == MENU_INDEX_INVALID)
1890 mode = 0;
1891 else
1892 mode = (1 << mode);
1893 }
1894
1895 if (force_menu_update || mode != prev_mode)
1896 {
1897 gui_update_menus_recurse(root_menu, mode);
1898 gui_mch_draw_menubar();
1899 prev_mode = mode;
1900 force_menu_update = FALSE;
1901 #ifdef FEAT_GUI_W32
1902 /* This can leave a tearoff as active window - make sure we
1903 * have the focus <negri>*/
1904 gui_mch_activate_window();
1905 #endif
1906 }
1907 }
1908
1909 #if defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_MOTIF) \
1910 || defined(FEAT_GUI_GTK) || defined(FEAT_GUI_PHOTON) || defined(PROTO)
1911 /*
1912 * Check if a key is used as a mnemonic for a toplevel menu.
1913 * Case of the key is ignored.
1914 */
1915 int
1916 gui_is_menu_shortcut(key)
1917 int key;
1918 {
1919 vimmenu_T *menu;
1920
1921 if (key < 256)
1922 key = TOLOWER_LOC(key);
1923 for (menu = root_menu; menu != NULL; menu = menu->next)
1924 if (menu->mnemonic == key
1925 || (menu->mnemonic < 256 && TOLOWER_LOC(menu->mnemonic) == key))
1926 return TRUE;
1927 return FALSE;
1928 }
1929 #endif
1930
1931 /*
1932 * Display the Special "PopUp" menu as a pop-up at the current mouse
1933 * position. The "PopUpn" menu is for Normal mode, "PopUpi" for Insert mode,
1934 * etc.
1935 */
1936 void
1937 gui_show_popupmenu()
1938 {
1939 vimmenu_T *menu;
1940 int mode;
1941
1942 mode = get_menu_mode();
1943 if (mode == MENU_INDEX_INVALID)
1944 return;
1945 mode = menu_mode_chars[mode];
1946
1947 #ifdef FEAT_AUTOCMD
1948 {
1949 char_u ename[2];
1950
1951 ename[0] = mode;
1952 ename[1] = NUL;
1953 apply_autocmds(EVENT_MENUPOPUP, ename, NULL, FALSE, curbuf);
1954 }
1955 #endif
1956
1957 for (menu = root_menu; menu != NULL; menu = menu->next)
1958 if (STRNCMP("PopUp", menu->name, 5) == 0 && menu->name[5] == mode)
1959 break;
1960
1961 /* Only show a popup when it is defined and has entries */
1962 if (menu != NULL && menu->children != NULL)
1963 gui_mch_show_popupmenu(menu);
1964 }
1965 #endif /* FEAT_GUI */
1966
1967 #if (defined(FEAT_GUI_W32) && defined(FEAT_TEAROFF)) || defined(PROTO)
1968
1969 /*
1970 * Deal with tearoff items that are added like a menu item.
1971 * Currently only for Win32 GUI. Others may follow later.
1972 */
1973
1974 void
1975 gui_mch_toggle_tearoffs(int enable)
1976 {
1977 int pri_tab[MENUDEPTH + 1];
1978 int i;
1979
1980 if (enable)
1981 {
1982 for (i = 0; i < MENUDEPTH; ++i)
1983 pri_tab[i] = 500;
1984 pri_tab[MENUDEPTH] = -1;
1985 gui_create_tearoffs_recurse(root_menu, (char_u *)"", pri_tab, 0);
1986 }
1987 else
1988 gui_destroy_tearoffs_recurse(root_menu);
1989 s_tearoffs = enable;
1990 }
1991
1992 /*
1993 * Recursively add tearoff items
1994 */
1995 static void
1996 gui_create_tearoffs_recurse(menu, pname, pri_tab, pri_idx)
1997 vimmenu_T *menu;
1998 const char_u *pname;
1999 int *pri_tab;
2000 int pri_idx;
2001 {
2002 char_u *newpname = NULL;
2003 int len;
2004 char_u *s;
2005 char_u *d;
2006
2007 if (pri_tab[pri_idx + 1] != -1)
2008 ++pri_idx;
2009 while (menu != NULL)
2010 {
2011 if (menu->children != NULL && menu_is_menubar(menu->name))
2012 {
2013 /* Add the menu name to the menu path. Insert a backslash before
2014 * dots (it's used to separate menu names). */
2015 len = (int)STRLEN(pname) + (int)STRLEN(menu->name);
2016 for (s = menu->name; *s; ++s)
2017 if (*s == '.' || *s == '\\')
2018 ++len;
2019 newpname = alloc(len + TEAR_LEN + 2);
2020 if (newpname != NULL)
2021 {
2022 STRCPY(newpname, pname);
2023 d = newpname + STRLEN(newpname);
2024 for (s = menu->name; *s; ++s)
2025 {
2026 if (*s == '.' || *s == '\\')
2027 *d++ = '\\';
2028 *d++ = *s;
2029 }
2030 *d = NUL;
2031
2032 /* check if tearoff already exists */
2033 if (STRCMP(menu->children->name, TEAR_STRING) != 0)
2034 {
2035 gui_add_tearoff(newpname, pri_tab, pri_idx - 1);
2036 *d = NUL; /* remove TEAR_STRING */
2037 }
2038
2039 STRCAT(newpname, ".");
2040 gui_create_tearoffs_recurse(menu->children, newpname,
2041 pri_tab, pri_idx);
2042 vim_free(newpname);
2043 }
2044 }
2045 menu = menu->next;
2046 }
2047 }
2048
2049 /*
2050 * Add tear-off menu item for a submenu.
2051 * "tearpath" is the menu path, and must have room to add TEAR_STRING.
2052 */
2053 static void
2054 gui_add_tearoff(tearpath, pri_tab, pri_idx)
2055 char_u *tearpath;
2056 int *pri_tab;
2057 int pri_idx;
2058 {
2059 char_u *tbuf;
2060 int t;
2061 vimmenu_T menuarg;
2062
2063 tbuf = alloc(5 + (unsigned int)STRLEN(tearpath));
2064 if (tbuf != NULL)
2065 {
2066 tbuf[0] = K_SPECIAL;
2067 tbuf[1] = K_SECOND(K_TEAROFF);
2068 tbuf[2] = K_THIRD(K_TEAROFF);
2069 STRCPY(tbuf + 3, tearpath);
2070 STRCAT(tbuf + 3, "\r");
2071
2072 STRCAT(tearpath, ".");
2073 STRCAT(tearpath, TEAR_STRING);
2074
2075 /* Priority of tear-off is always 1 */
2076 t = pri_tab[pri_idx + 1];
2077 pri_tab[pri_idx + 1] = 1;
2078
2079 #ifdef FEAT_TOOLBAR
2080 menuarg.iconfile = NULL;
2081 menuarg.iconidx = -1;
2082 menuarg.icon_builtin = FALSE;
2083 #endif
2084 menuarg.noremap[0] = REMAP_NONE;
2085 menuarg.silent[0] = TRUE;
2086
2087 menuarg.modes = MENU_ALL_MODES;
2088 add_menu_path(tearpath, &menuarg, pri_tab, tbuf, FALSE);
2089
2090 menuarg.modes = MENU_TIP_MODE;
2091 add_menu_path(tearpath, &menuarg, pri_tab,
2092 (char_u *)_("Tear off this menu"), FALSE);
2093
2094 pri_tab[pri_idx + 1] = t;
2095 vim_free(tbuf);
2096 }
2097 }
2098
2099 /*
2100 * Recursively destroy tearoff items
2101 */
2102 static void
2103 gui_destroy_tearoffs_recurse(menu)
2104 vimmenu_T *menu;
2105 {
2106 while (menu)
2107 {
2108 if (menu->children)
2109 {
2110 /* check if tearoff exists */
2111 if (STRCMP(menu->children->name, TEAR_STRING) == 0)
2112 {
2113 /* Disconnect the item and free the memory */
2114 free_menu(&menu->children);
2115 }
2116 if (menu->children != NULL) /* if not the last one */
2117 gui_destroy_tearoffs_recurse(menu->children);
2118 }
2119 menu = menu->next;
2120 }
2121 }
2122
2123 #endif /* FEAT_GUI_W32 && FEAT_TEAROFF */
2124
2125 /*
2126 * Given a menu descriptor, e.g. "File.New", find it in the menu hierarchy and
2127 * execute it.
2128 */
2129 void
2130 ex_emenu(eap)
2131 exarg_T *eap;
2132 {
2133 vimmenu_T *menu;
2134 char_u *name;
2135 char_u *saved_name;
2136 char_u *p;
2137 int idx;
2138 char_u *mode;
2139
2140 saved_name = vim_strsave(eap->arg);
2141 if (saved_name == NULL)
2142 return;
2143
2144 menu = root_menu;
2145 name = saved_name;
2146 while (*name)
2147 {
2148 /* Find in the menu hierarchy */
2149 p = menu_name_skip(name);
2150
2151 while (menu != NULL)
2152 {
2153 if (menu_name_equal(name, menu))
2154 {
2155 if (*p == NUL && menu->children != NULL)
2156 {
2157 EMSG(_("E333: Menu path must lead to a menu item"));
2158 menu = NULL;
2159 }
2160 else if (*p != NUL && menu->children == NULL)
2161 {
2162 EMSG(_(e_notsubmenu));
2163 menu = NULL;
2164 }
2165 break;
2166 }
2167 menu = menu->next;
2168 }
2169 if (menu == NULL || *p == NUL)
2170 break;
2171 menu = menu->children;
2172 name = p;
2173 }
2174 vim_free(saved_name);
2175 if (menu == NULL)
2176 {
2177 EMSG2(_("E334: Menu not found: %s"), eap->arg);
2178 return;
2179 }
2180
2181 /* Found the menu, so execute.
2182 * Use the Insert mode entry when returning to Insert mode. */
2183 if (restart_edit
2184 #ifdef FEAT_EVAL
2185 && !current_SID
2186 #endif
2187 )
2188 {
2189 mode = (char_u *)"Insert";
2190 idx = MENU_INDEX_INSERT;
2191 }
2192 else if (eap->addr_count)
2193 {
2194 pos_T tpos;
2195
2196 mode = (char_u *)"Visual";
2197 idx = MENU_INDEX_VISUAL;
2198
2199 /* GEDDES: This is not perfect - but it is a
2200 * quick way of detecting whether we are doing this from a
2201 * selection - see if the range matches up with the visual
2202 * select start and end. */
2203 if ((curbuf->b_visual.vi_start.lnum == eap->line1)
2204 && (curbuf->b_visual.vi_end.lnum) == eap->line2)
2205 {
2206 /* Set it up for visual mode - equivalent to gv. */
2207 VIsual_mode = curbuf->b_visual.vi_mode;
2208 tpos = curbuf->b_visual.vi_end;
2209 curwin->w_cursor = curbuf->b_visual.vi_start;
2210 curwin->w_curswant = curbuf->b_visual.vi_curswant;
2211 }
2212 else
2213 {
2214 /* Set it up for line-wise visual mode */
2215 VIsual_mode = 'V';
2216 curwin->w_cursor.lnum = eap->line1;
2217 curwin->w_cursor.col = 1;
2218 tpos.lnum = eap->line2;
2219 tpos.col = MAXCOL;
2220 #ifdef FEAT_VIRTUALEDIT
2221 tpos.coladd = 0;
2222 #endif
2223 }
2224
2225 /* Activate visual mode */
2226 VIsual_active = TRUE;
2227 VIsual_reselect = TRUE;
2228 check_cursor();
2229 VIsual = curwin->w_cursor;
2230 curwin->w_cursor = tpos;
2231
2232 check_cursor();
2233
2234 /* Adjust the cursor to make sure it is in the correct pos
2235 * for exclusive mode */
2236 if (*p_sel == 'e' && gchar_cursor() != NUL)
2237 ++curwin->w_cursor.col;
2238 }
2239 else
2240 {
2241 mode = (char_u *)"Normal";
2242 idx = MENU_INDEX_NORMAL;
2243 }
2244
2245 if (idx != MENU_INDEX_INVALID && menu->strings[idx] != NULL)
2246 {
2247 /* When executing a script or function execute the commands right now.
2248 * Otherwise put them in the typeahead buffer. */
2249 #ifdef FEAT_EVAL
2250 if (current_SID != 0)
2251 exec_normal_cmd(menu->strings[idx], menu->noremap[idx],
2252 menu->silent[idx]);
2253 else
2254 #endif
2255 ins_typebuf(menu->strings[idx], menu->noremap[idx], 0,
2256 TRUE, menu->silent[idx]);
2257 }
2258 else
2259 EMSG2(_("E335: Menu not defined for %s mode"), mode);
2260 }
2261
2262 #if defined(FEAT_GUI_MSWIN) \
2263 || (defined(FEAT_GUI_GTK) && defined(FEAT_MENU)) \
2264 || defined(FEAT_BEVAL_TIP) || defined(PROTO)
2265 /*
2266 * Given a menu descriptor, e.g. "File.New", find it in the menu hierarchy.
2267 */
2268 vimmenu_T *
2269 gui_find_menu(path_name)
2270 char_u *path_name;
2271 {
2272 vimmenu_T *menu = NULL;
2273 char_u *name;
2274 char_u *saved_name;
2275 char_u *p;
2276
2277 menu = root_menu;
2278
2279 saved_name = vim_strsave(path_name);
2280 if (saved_name == NULL)
2281 return NULL;
2282
2283 name = saved_name;
2284 while (*name)
2285 {
2286 /* find the end of one dot-separated name and put a NUL at the dot */
2287 p = menu_name_skip(name);
2288
2289 while (menu != NULL)
2290 {
2291 if (STRCMP(name, menu->name) == 0 || STRCMP(name, menu->dname) == 0)
2292 {
2293 if (menu->children == NULL)
2294 {
2295 /* found a menu item instead of a sub-menu */
2296 if (*p == NUL)
2297 EMSG(_("E336: Menu path must lead to a sub-menu"));
2298 else
2299 EMSG(_(e_notsubmenu));
2300 menu = NULL;
2301 goto theend;
2302 }
2303 if (*p == NUL) /* found a full match */
2304 goto theend;
2305 break;
2306 }
2307 menu = menu->next;
2308 }
2309 if (menu == NULL) /* didn't find it */
2310 break;
2311
2312 /* Found a match, search the sub-menu. */
2313 menu = menu->children;
2314 name = p;
2315 }
2316
2317 if (menu == NULL)
2318 EMSG(_("E337: Menu not found - check menu names"));
2319 theend:
2320 vim_free(saved_name);
2321 return menu;
2322 }
2323 #endif
2324
2325 #ifdef FEAT_MULTI_LANG
2326 /*
2327 * Translation of menu names. Just a simple lookup table.
2328 */
2329
2330 typedef struct
2331 {
2332 char_u *from; /* English name */
2333 char_u *from_noamp; /* same, without '&' */
2334 char_u *to; /* translated name */
2335 } menutrans_T;
2336
2337 static garray_T menutrans_ga = {0, 0, 0, 0, NULL};
2338 #endif
2339
2340 /*
2341 * ":menutrans".
2342 * This function is also defined without the +multi_lang feature, in which
2343 * case the commands are ignored.
2344 */
2345 /*ARGSUSED*/
2346 void
2347 ex_menutranslate(eap)
2348 exarg_T *eap;
2349 {
2350 #ifdef FEAT_MULTI_LANG
2351 char_u *arg = eap->arg;
2352 menutrans_T *tp;
2353 int i;
2354 char_u *from, *from_noamp, *to;
2355
2356 if (menutrans_ga.ga_itemsize == 0)
2357 ga_init2(&menutrans_ga, (int)sizeof(menutrans_T), 5);
2358
2359 /*
2360 * ":menutrans clear": clear all translations.
2361 */
2362 if (STRNCMP(arg, "clear", 5) == 0 && ends_excmd(*skipwhite(arg + 5)))
2363 {
2364 tp = (menutrans_T *)menutrans_ga.ga_data;
2365 for (i = 0; i < menutrans_ga.ga_len; ++i)
2366 {
2367 vim_free(tp[i].from);
2368 vim_free(tp[i].from_noamp);
2369 vim_free(tp[i].to);
2370 }
2371 ga_clear(&menutrans_ga);
2372 # ifdef FEAT_EVAL
2373 /* Delete all "menutrans_" global variables. */
2374 del_menutrans_vars();
2375 # endif
2376 }
2377 else
2378 {
2379 /* ":menutrans from to": add translation */
2380 from = arg;
2381 arg = menu_skip_part(arg);
2382 to = skipwhite(arg);
2383 *arg = NUL;
2384 arg = menu_skip_part(to);
2385 if (arg == to)
2386 EMSG(_(e_invarg));
2387 else
2388 {
2389 if (ga_grow(&menutrans_ga, 1) == OK)
2390 {
2391 tp = (menutrans_T *)menutrans_ga.ga_data;
2392 from = vim_strsave(from);
2393 if (from != NULL)
2394 {
2395 from_noamp = menu_text(from, NULL, NULL);
2396 to = vim_strnsave(to, (int)(arg - to));
2397 if (from_noamp != NULL && to != NULL)
2398 {
2399 tp[menutrans_ga.ga_len].from = from;
2400 tp[menutrans_ga.ga_len].from_noamp = from_noamp;
2401 tp[menutrans_ga.ga_len].to = to;
2402 ++menutrans_ga.ga_len;
2403 }
2404 else
2405 {
2406 vim_free(from);
2407 vim_free(from_noamp);
2408 vim_free(to);
2409 }
2410 }
2411 }
2412 }
2413 }
2414 #endif
2415 }
2416
2417 #if defined(FEAT_MULTI_LANG) || defined(FEAT_TOOLBAR)
2418 /*
2419 * Find the character just after one part of a menu name.
2420 */
2421 static char_u *
2422 menu_skip_part(p)
2423 char_u *p;
2424 {
2425 while (*p != NUL && *p != '.' && !vim_iswhite(*p))
2426 {
2427 if ((*p == '\\' || *p == Ctrl_V) && p[1] != NUL)
2428 ++p;
2429 ++p;
2430 }
2431 return p;
2432 }
2433 #endif
2434
2435 #ifdef FEAT_MULTI_LANG
2436 /*
2437 * Lookup part of a menu name in the translations.
2438 * Return a pointer to the translation or NULL if not found.
2439 */
2440 static char_u *
2441 menutrans_lookup(name, len)
2442 char_u *name;
2443 int len;
2444 {
2445 menutrans_T *tp = (menutrans_T *)menutrans_ga.ga_data;
2446 int i;
2447 char_u *dname;
2448
2449 for (i = 0; i < menutrans_ga.ga_len; ++i)
2450 if (STRNCMP(name, tp[i].from, len) == 0 && tp[i].from[len] == NUL)
2451 return tp[i].to;
2452
2453 /* Now try again while ignoring '&' characters. */
2454 i = name[len];
2455 name[len] = NUL;
2456 dname = menu_text(name, NULL, NULL);
2457 name[len] = i;
2458 if (dname != NULL)
2459 {
2460 for (i = 0; i < menutrans_ga.ga_len; ++i)
2461 if (STRCMP(dname, tp[i].from_noamp) == 0)
2462 {
2463 vim_free(dname);
2464 return tp[i].to;
2465 }
2466 vim_free(dname);
2467 }
2468
2469 return NULL;
2470 }
2471 #endif /* FEAT_MULTI_LANG */
2472
2473 #endif /* FEAT_MENU */