| /* vi:set ts=8 sts=4 sw=4: |
| * |
| * VIM - Vi IMproved by Bram Moolenaar |
| * GUI/Motif support by Robert Webb |
| * |
| * Do ":help uganda" in Vim to read copying and usage conditions. |
| * Do ":help credits" in Vim to see a list of people who contributed. |
| * See README.txt for an overview of the Vim source code. |
| */ |
| |
| /* |
| * Code for menus. Used for the GUI and 'wildmenu'. |
| */ |
| |
| #include "vim.h" |
| |
| #if defined(FEAT_MENU) || defined(PROTO) |
| |
| #define MENUDEPTH 10 /* maximum depth of menus */ |
| |
| #ifdef FEAT_GUI_W32 |
| static int add_menu_path __ARGS((char_u *, vimmenu_T *, int *, char_u *, int)); |
| #else |
| static int add_menu_path __ARGS((char_u *, vimmenu_T *, int *, char_u *)); |
| #endif |
| static int menu_nable_recurse __ARGS((vimmenu_T *menu, char_u *name, int modes, int enable)); |
| static int remove_menu __ARGS((vimmenu_T **, char_u *, int, int silent)); |
| static void free_menu __ARGS((vimmenu_T **menup)); |
| static void free_menu_string __ARGS((vimmenu_T *, int)); |
| static int show_menus __ARGS((char_u *, int)); |
| static void show_menus_recursive __ARGS((vimmenu_T *, int, int)); |
| static int menu_name_equal __ARGS((char_u *name, vimmenu_T *menu)); |
| static int menu_namecmp __ARGS((char_u *name, char_u *mname)); |
| static int get_menu_cmd_modes __ARGS((char_u *, int, int *, int *)); |
| static char_u *popup_mode_name __ARGS((char_u *name, int idx)); |
| static char_u *menu_text __ARGS((char_u *text, int *mnemonic, char_u **actext)); |
| #ifdef FEAT_GUI |
| static int get_menu_mode __ARGS((void)); |
| static void gui_update_menus_recurse __ARGS((vimmenu_T *, int)); |
| #endif |
| |
| #if defined(FEAT_GUI_W32) && defined(FEAT_TEAROFF) |
| static void gui_create_tearoffs_recurse __ARGS((vimmenu_T *menu, const char_u *pname, int *pri_tab, int pri_idx)); |
| static void gui_add_tearoff __ARGS((char_u *tearpath, int *pri_tab, int pri_idx)); |
| static void gui_destroy_tearoffs_recurse __ARGS((vimmenu_T *menu)); |
| static int s_tearoffs = FALSE; |
| #endif |
| |
| static int menu_is_hidden __ARGS((char_u *name)); |
| #if defined(FEAT_CMDL_COMPL) || (defined(FEAT_GUI_W32) && defined(FEAT_TEAROFF)) |
| static int menu_is_tearoff __ARGS((char_u *name)); |
| #endif |
| |
| #if defined(FEAT_MULTI_LANG) || defined(FEAT_TOOLBAR) |
| static char_u *menu_skip_part __ARGS((char_u *p)); |
| #endif |
| #ifdef FEAT_MULTI_LANG |
| static char_u *menutrans_lookup __ARGS((char_u *name, int len)); |
| #endif |
| |
| /* The character for each menu mode */ |
| static char_u menu_mode_chars[] = {'n', 'v', 's', 'o', 'i', 'c', 't'}; |
| |
| static char_u e_notsubmenu[] = N_("E327: Part of menu-item path is not sub-menu"); |
| static char_u e_othermode[] = N_("E328: Menu only exists in another mode"); |
| static char_u e_nomenu[] = N_("E329: No menu \"%s\""); |
| |
| #ifdef FEAT_TOOLBAR |
| static const char *toolbar_names[] = |
| { |
| /* 0 */ "New", "Open", "Save", "Undo", "Redo", |
| /* 5 */ "Cut", "Copy", "Paste", "Print", "Help", |
| /* 10 */ "Find", "SaveAll", "SaveSesn", "NewSesn", "LoadSesn", |
| /* 15 */ "RunScript", "Replace", "WinClose", "WinMax", "WinMin", |
| /* 20 */ "WinSplit", "Shell", "FindPrev", "FindNext", "FindHelp", |
| /* 25 */ "Make", "TagJump", "RunCtags", "WinVSplit", "WinMaxWidth", |
| /* 30 */ "WinMinWidth", "Exit" |
| }; |
| # define TOOLBAR_NAME_COUNT (sizeof(toolbar_names) / sizeof(char *)) |
| #endif |
| |
| /* |
| * Do the :menu command and relatives. |
| */ |
| void |
| ex_menu(eap) |
| exarg_T *eap; /* Ex command arguments */ |
| { |
| char_u *menu_path; |
| int modes; |
| char_u *map_to; |
| int noremap; |
| int silent = FALSE; |
| int special = FALSE; |
| int unmenu; |
| char_u *map_buf; |
| char_u *arg; |
| char_u *p; |
| int i; |
| #if defined(FEAT_GUI) && !defined(FEAT_GUI_GTK) |
| int old_menu_height; |
| # if defined(FEAT_TOOLBAR) && !defined(FEAT_GUI_W32) && !defined(FEAT_GUI_W16) |
| int old_toolbar_height; |
| # endif |
| #endif |
| int pri_tab[MENUDEPTH + 1]; |
| int enable = MAYBE; /* TRUE for "menu enable", FALSE for "menu |
| * disable */ |
| #ifdef FEAT_MULTI_LANG |
| char_u *tofree = NULL; |
| char_u *new_cmd; |
| #endif |
| #ifdef FEAT_TOOLBAR |
| char_u *icon = NULL; |
| #endif |
| vimmenu_T menuarg; |
| |
| modes = get_menu_cmd_modes(eap->cmd, eap->forceit, &noremap, &unmenu); |
| arg = eap->arg; |
| |
| for (;;) |
| { |
| if (STRNCMP(arg, "<script>", 8) == 0) |
| { |
| noremap = REMAP_SCRIPT; |
| arg = skipwhite(arg + 8); |
| continue; |
| } |
| if (STRNCMP(arg, "<silent>", 8) == 0) |
| { |
| silent = TRUE; |
| arg = skipwhite(arg + 8); |
| continue; |
| } |
| if (STRNCMP(arg, "<special>", 9) == 0) |
| { |
| special = TRUE; |
| arg = skipwhite(arg + 9); |
| continue; |
| } |
| break; |
| } |
| |
| |
| /* Locate an optional "icon=filename" argument. */ |
| if (STRNCMP(arg, "icon=", 5) == 0) |
| { |
| arg += 5; |
| #ifdef FEAT_TOOLBAR |
| icon = arg; |
| #endif |
| while (*arg != NUL && *arg != ' ') |
| { |
| if (*arg == '\\') |
| STRMOVE(arg, arg + 1); |
| mb_ptr_adv(arg); |
| } |
| if (*arg != NUL) |
| { |
| *arg++ = NUL; |
| arg = skipwhite(arg); |
| } |
| } |
| |
| /* |
| * Fill in the priority table. |
| */ |
| for (p = arg; *p; ++p) |
| if (!VIM_ISDIGIT(*p) && *p != '.') |
| break; |
| if (vim_iswhite(*p)) |
| { |
| for (i = 0; i < MENUDEPTH && !vim_iswhite(*arg); ++i) |
| { |
| pri_tab[i] = getdigits(&arg); |
| if (pri_tab[i] == 0) |
| pri_tab[i] = 500; |
| if (*arg == '.') |
| ++arg; |
| } |
| arg = skipwhite(arg); |
| } |
| else if (eap->addr_count && eap->line2 != 0) |
| { |
| pri_tab[0] = eap->line2; |
| i = 1; |
| } |
| else |
| i = 0; |
| while (i < MENUDEPTH) |
| pri_tab[i++] = 500; |
| pri_tab[MENUDEPTH] = -1; /* mark end of the table */ |
| |
| /* |
| * Check for "disable" or "enable" argument. |
| */ |
| if (STRNCMP(arg, "enable", 6) == 0 && vim_iswhite(arg[6])) |
| { |
| enable = TRUE; |
| arg = skipwhite(arg + 6); |
| } |
| else if (STRNCMP(arg, "disable", 7) == 0 && vim_iswhite(arg[7])) |
| { |
| enable = FALSE; |
| arg = skipwhite(arg + 7); |
| } |
| |
| /* |
| * If there is no argument, display all menus. |
| */ |
| if (*arg == NUL) |
| { |
| show_menus(arg, modes); |
| return; |
| } |
| |
| #ifdef FEAT_TOOLBAR |
| /* |
| * Need to get the toolbar icon index before doing the translation. |
| */ |
| menuarg.iconidx = -1; |
| menuarg.icon_builtin = FALSE; |
| if (menu_is_toolbar(arg)) |
| { |
| menu_path = menu_skip_part(arg); |
| if (*menu_path == '.') |
| { |
| p = menu_skip_part(++menu_path); |
| if (STRNCMP(menu_path, "BuiltIn", 7) == 0) |
| { |
| if (skipdigits(menu_path + 7) == p) |
| { |
| menuarg.iconidx = atoi((char *)menu_path + 7); |
| if (menuarg.iconidx >= (int)TOOLBAR_NAME_COUNT) |
| menuarg.iconidx = -1; |
| else |
| menuarg.icon_builtin = TRUE; |
| } |
| } |
| else |
| { |
| for (i = 0; i < (int)TOOLBAR_NAME_COUNT; ++i) |
| if (STRNCMP(toolbar_names[i], menu_path, p - menu_path) |
| == 0) |
| { |
| menuarg.iconidx = i; |
| break; |
| } |
| } |
| } |
| } |
| #endif |
| |
| #ifdef FEAT_MULTI_LANG |
| /* |
| * Translate menu names as specified with ":menutrans" commands. |
| */ |
| menu_path = arg; |
| while (*menu_path) |
| { |
| /* find the end of one part and check if it should be translated */ |
| p = menu_skip_part(menu_path); |
| map_to = menutrans_lookup(menu_path, (int)(p - menu_path)); |
| if (map_to != NULL) |
| { |
| /* found a match: replace with the translated part */ |
| i = (int)STRLEN(map_to); |
| new_cmd = alloc((unsigned)STRLEN(arg) + i + 1); |
| if (new_cmd == NULL) |
| break; |
| mch_memmove(new_cmd, arg, menu_path - arg); |
| mch_memmove(new_cmd + (menu_path - arg), map_to, (size_t)i); |
| STRCPY(new_cmd + (menu_path - arg) + i, p); |
| p = new_cmd + (menu_path - arg) + i; |
| vim_free(tofree); |
| tofree = new_cmd; |
| arg = new_cmd; |
| } |
| if (*p != '.') |
| break; |
| menu_path = p + 1; |
| } |
| #endif |
| |
| /* |
| * Isolate the menu name. |
| * Skip the menu name, and translate <Tab> into a real TAB. |
| */ |
| menu_path = arg; |
| if (*menu_path == '.') |
| { |
| EMSG2(_(e_invarg2), menu_path); |
| goto theend; |
| } |
| |
| while (*arg && !vim_iswhite(*arg)) |
| { |
| if ((*arg == '\\' || *arg == Ctrl_V) && arg[1] != NUL) |
| arg++; |
| else if (STRNICMP(arg, "<TAB>", 5) == 0) |
| { |
| *arg = TAB; |
| STRMOVE(arg + 1, arg + 5); |
| } |
| arg++; |
| } |
| if (*arg != NUL) |
| *arg++ = NUL; |
| arg = skipwhite(arg); |
| map_to = arg; |
| |
| /* |
| * If there is only a menu name, display menus with that name. |
| */ |
| if (*map_to == NUL && !unmenu && enable == MAYBE) |
| { |
| show_menus(menu_path, modes); |
| goto theend; |
| } |
| else if (*map_to != NUL && (unmenu || enable != MAYBE)) |
| { |
| EMSG(_(e_trailing)); |
| goto theend; |
| } |
| #if defined(FEAT_GUI) && !(defined(FEAT_GUI_GTK) || defined(FEAT_GUI_PHOTON)) |
| old_menu_height = gui.menu_height; |
| # if defined(FEAT_TOOLBAR) && !defined(FEAT_GUI_W32) && !defined(FEAT_GUI_W16) |
| old_toolbar_height = gui.toolbar_height; |
| # endif |
| #endif |
| |
| if (enable != MAYBE) |
| { |
| /* |
| * Change sensitivity of the menu. |
| * For the PopUp menu, remove a menu for each mode separately. |
| * Careful: menu_nable_recurse() changes menu_path. |
| */ |
| if (STRCMP(menu_path, "*") == 0) /* meaning: do all menus */ |
| menu_path = (char_u *)""; |
| |
| if (menu_is_popup(menu_path)) |
| { |
| for (i = 0; i < MENU_INDEX_TIP; ++i) |
| if (modes & (1 << i)) |
| { |
| p = popup_mode_name(menu_path, i); |
| if (p != NULL) |
| { |
| menu_nable_recurse(root_menu, p, MENU_ALL_MODES, |
| enable); |
| vim_free(p); |
| } |
| } |
| } |
| menu_nable_recurse(root_menu, menu_path, modes, enable); |
| } |
| else if (unmenu) |
| { |
| /* |
| * Delete menu(s). |
| */ |
| if (STRCMP(menu_path, "*") == 0) /* meaning: remove all menus */ |
| menu_path = (char_u *)""; |
| |
| /* |
| * For the PopUp menu, remove a menu for each mode separately. |
| */ |
| if (menu_is_popup(menu_path)) |
| { |
| for (i = 0; i < MENU_INDEX_TIP; ++i) |
| if (modes & (1 << i)) |
| { |
| p = popup_mode_name(menu_path, i); |
| if (p != NULL) |
| { |
| remove_menu(&root_menu, p, MENU_ALL_MODES, TRUE); |
| vim_free(p); |
| } |
| } |
| } |
| |
| /* Careful: remove_menu() changes menu_path */ |
| remove_menu(&root_menu, menu_path, modes, FALSE); |
| } |
| else |
| { |
| /* |
| * Add menu(s). |
| * Replace special key codes. |
| */ |
| if (STRICMP(map_to, "<nop>") == 0) /* "<Nop>" means nothing */ |
| { |
| map_to = (char_u *)""; |
| map_buf = NULL; |
| } |
| else if (modes & MENU_TIP_MODE) |
| map_buf = NULL; /* Menu tips are plain text. */ |
| else |
| map_to = replace_termcodes(map_to, &map_buf, FALSE, TRUE, special); |
| menuarg.modes = modes; |
| #ifdef FEAT_TOOLBAR |
| menuarg.iconfile = icon; |
| #endif |
| menuarg.noremap[0] = noremap; |
| menuarg.silent[0] = silent; |
| add_menu_path(menu_path, &menuarg, pri_tab, map_to |
| #ifdef FEAT_GUI_W32 |
| , TRUE |
| #endif |
| ); |
| |
| /* |
| * For the PopUp menu, add a menu for each mode separately. |
| */ |
| if (menu_is_popup(menu_path)) |
| { |
| for (i = 0; i < MENU_INDEX_TIP; ++i) |
| if (modes & (1 << i)) |
| { |
| p = popup_mode_name(menu_path, i); |
| if (p != NULL) |
| { |
| /* Include all modes, to make ":amenu" work */ |
| menuarg.modes = modes; |
| #ifdef FEAT_TOOLBAR |
| menuarg.iconfile = NULL; |
| menuarg.iconidx = -1; |
| menuarg.icon_builtin = FALSE; |
| #endif |
| add_menu_path(p, &menuarg, pri_tab, map_to |
| #ifdef FEAT_GUI_W32 |
| , TRUE |
| #endif |
| ); |
| vim_free(p); |
| } |
| } |
| } |
| |
| vim_free(map_buf); |
| } |
| |
| #if defined(FEAT_GUI) && !(defined(FEAT_GUI_GTK)) |
| /* If the menubar height changed, resize the window */ |
| if (gui.in_use |
| && (gui.menu_height != old_menu_height |
| # if defined(FEAT_TOOLBAR) && !defined(FEAT_GUI_W32) && !defined(FEAT_GUI_W16) |
| || gui.toolbar_height != old_toolbar_height |
| # endif |
| )) |
| gui_set_shellsize(FALSE, FALSE, RESIZE_VERT); |
| #endif |
| |
| theend: |
| #ifdef FEAT_MULTI_LANG |
| vim_free(tofree); |
| #else |
| ; |
| #endif |
| } |
| |
| /* |
| * Add the menu with the given name to the menu hierarchy |
| */ |
| static int |
| add_menu_path(menu_path, menuarg, pri_tab, call_data |
| #ifdef FEAT_GUI_W32 |
| , addtearoff |
| #endif |
| ) |
| char_u *menu_path; |
| vimmenu_T *menuarg; /* passes modes, iconfile, iconidx, |
| icon_builtin, silent[0], noremap[0] */ |
| int *pri_tab; |
| char_u *call_data; |
| #ifdef FEAT_GUI_W32 |
| int addtearoff; /* may add tearoff item */ |
| #endif |
| { |
| char_u *path_name; |
| int modes = menuarg->modes; |
| vimmenu_T **menup; |
| vimmenu_T *menu = NULL; |
| vimmenu_T *parent; |
| vimmenu_T **lower_pri; |
| char_u *p; |
| char_u *name; |
| char_u *dname; |
| char_u *next_name; |
| int i; |
| int c; |
| #ifdef FEAT_GUI |
| int idx; |
| int new_idx; |
| #endif |
| int pri_idx = 0; |
| int old_modes = 0; |
| int amenu; |
| |
| /* Make a copy so we can stuff around with it, since it could be const */ |
| path_name = vim_strsave(menu_path); |
| if (path_name == NULL) |
| return FAIL; |
| menup = &root_menu; |
| parent = NULL; |
| name = path_name; |
| while (*name) |
| { |
| /* Get name of this element in the menu hierarchy, and the simplified |
| * name (without mnemonic and accelerator text). */ |
| next_name = menu_name_skip(name); |
| dname = menu_text(name, NULL, NULL); |
| if (dname == NULL) |
| goto erret; |
| if (*dname == NUL) |
| { |
| /* Only a mnemonic or accelerator is not valid. */ |
| EMSG(_("E792: Empty menu name")); |
| goto erret; |
| } |
| |
| /* See if it's already there */ |
| lower_pri = menup; |
| #ifdef FEAT_GUI |
| idx = 0; |
| new_idx = 0; |
| #endif |
| menu = *menup; |
| while (menu != NULL) |
| { |
| if (menu_name_equal(name, menu) || menu_name_equal(dname, menu)) |
| { |
| if (*next_name == NUL && menu->children != NULL) |
| { |
| if (!sys_menu) |
| EMSG(_("E330: Menu path must not lead to a sub-menu")); |
| goto erret; |
| } |
| if (*next_name != NUL && menu->children == NULL |
| #ifdef FEAT_GUI_W32 |
| && addtearoff |
| #endif |
| ) |
| { |
| if (!sys_menu) |
| EMSG(_(e_notsubmenu)); |
| goto erret; |
| } |
| break; |
| } |
| menup = &menu->next; |
| |
| /* Count menus, to find where this one needs to be inserted. |
| * Ignore menus that are not in the menubar (PopUp and Toolbar) */ |
| if (parent != NULL || menu_is_menubar(menu->name)) |
| { |
| #ifdef FEAT_GUI |
| ++idx; |
| #endif |
| if (menu->priority <= pri_tab[pri_idx]) |
| { |
| lower_pri = menup; |
| #ifdef FEAT_GUI |
| new_idx = idx; |
| #endif |
| } |
| } |
| menu = menu->next; |
| } |
| |
| if (menu == NULL) |
| { |
| if (*next_name == NUL && parent == NULL) |
| { |
| EMSG(_("E331: Must not add menu items directly to menu bar")); |
| goto erret; |
| } |
| |
| if (menu_is_separator(dname) && *next_name != NUL) |
| { |
| EMSG(_("E332: Separator cannot be part of a menu path")); |
| goto erret; |
| } |
| |
| /* Not already there, so lets add it */ |
| menu = (vimmenu_T *)alloc_clear((unsigned)sizeof(vimmenu_T)); |
| if (menu == NULL) |
| goto erret; |
| |
| menu->modes = modes; |
| menu->enabled = MENU_ALL_MODES; |
| menu->name = vim_strsave(name); |
| /* separate mnemonic and accelerator text from actual menu name */ |
| menu->dname = menu_text(name, &menu->mnemonic, &menu->actext); |
| menu->priority = pri_tab[pri_idx]; |
| menu->parent = parent; |
| #ifdef FEAT_GUI_MOTIF |
| menu->sensitive = TRUE; /* the default */ |
| #endif |
| #ifdef FEAT_BEVAL_TIP |
| menu->tip = NULL; |
| #endif |
| #ifdef FEAT_GUI_ATHENA |
| menu->image = None; /* X-Windows definition for NULL*/ |
| #endif |
| |
| /* |
| * Add after menu that has lower priority. |
| */ |
| menu->next = *lower_pri; |
| *lower_pri = menu; |
| |
| old_modes = 0; |
| |
| #ifdef FEAT_TOOLBAR |
| menu->iconidx = menuarg->iconidx; |
| menu->icon_builtin = menuarg->icon_builtin; |
| if (*next_name == NUL && menuarg->iconfile != NULL) |
| menu->iconfile = vim_strsave(menuarg->iconfile); |
| #endif |
| #if defined(FEAT_GUI_W32) && defined(FEAT_TEAROFF) |
| /* the tearoff item must be present in the modes of each item. */ |
| if (parent != NULL && menu_is_tearoff(parent->children->dname)) |
| parent->children->modes |= modes; |
| #endif |
| } |
| else |
| { |
| old_modes = menu->modes; |
| |
| /* |
| * If this menu option was previously only available in other |
| * modes, then make sure it's available for this one now |
| * Also enable a menu when it's created or changed. |
| */ |
| #ifdef FEAT_GUI_W32 |
| /* If adding a tearbar (addtearoff == FALSE) don't update modes */ |
| if (addtearoff) |
| #endif |
| { |
| menu->modes |= modes; |
| menu->enabled |= modes; |
| } |
| } |
| |
| #ifdef FEAT_GUI |
| /* |
| * Add the menu item when it's used in one of the modes, but not when |
| * only a tooltip is defined. |
| */ |
| if ((old_modes & MENU_ALL_MODES) == 0 |
| && (menu->modes & MENU_ALL_MODES) != 0) |
| { |
| if (gui.in_use) /* Otherwise it will be added when GUI starts */ |
| { |
| if (*next_name == NUL) |
| { |
| /* Real menu item, not sub-menu */ |
| gui_mch_add_menu_item(menu, new_idx); |
| |
| /* Want to update menus now even if mode not changed */ |
| force_menu_update = TRUE; |
| } |
| else |
| { |
| /* Sub-menu (not at end of path yet) */ |
| gui_mch_add_menu(menu, new_idx); |
| } |
| } |
| |
| # if defined(FEAT_GUI_W32) & defined(FEAT_TEAROFF) |
| /* When adding a new submenu, may add a tearoff item */ |
| if ( addtearoff |
| && *next_name |
| && vim_strchr(p_go, GO_TEAROFF) != NULL |
| && menu_is_menubar(name)) |
| { |
| char_u *tearpath; |
| |
| /* |
| * The pointers next_name & path_name refer to a string with |
| * \'s and ^V's stripped out. But menu_path is a "raw" |
| * string, so we must correct for special characters. |
| */ |
| tearpath = alloc((unsigned int)STRLEN(menu_path) + TEAR_LEN + 2); |
| if (tearpath != NULL) |
| { |
| char_u *s; |
| int idx; |
| |
| STRCPY(tearpath, menu_path); |
| idx = (int)(next_name - path_name - 1); |
| for (s = tearpath; *s && s < tearpath + idx; mb_ptr_adv(s)) |
| { |
| if ((*s == '\\' || *s == Ctrl_V) && s[1]) |
| { |
| ++idx; |
| ++s; |
| } |
| } |
| tearpath[idx] = NUL; |
| gui_add_tearoff(tearpath, pri_tab, pri_idx); |
| vim_free(tearpath); |
| } |
| } |
| # endif |
| } |
| #endif /* FEAT_GUI */ |
| |
| menup = &menu->children; |
| parent = menu; |
| name = next_name; |
| vim_free(dname); |
| dname = NULL; |
| if (pri_tab[pri_idx + 1] != -1) |
| ++pri_idx; |
| } |
| vim_free(path_name); |
| |
| /* |
| * Only add system menu items which have not been defined yet. |
| * First check if this was an ":amenu". |
| */ |
| amenu = ((modes & (MENU_NORMAL_MODE | MENU_INSERT_MODE)) == |
| (MENU_NORMAL_MODE | MENU_INSERT_MODE)); |
| if (sys_menu) |
| modes &= ~old_modes; |
| |
| if (menu != NULL && modes) |
| { |
| #ifdef FEAT_GUI |
| menu->cb = gui_menu_cb; |
| #endif |
| p = (call_data == NULL) ? NULL : vim_strsave(call_data); |
| |
| /* loop over all modes, may add more than one */ |
| for (i = 0; i < MENU_MODES; ++i) |
| { |
| if (modes & (1 << i)) |
| { |
| /* free any old menu */ |
| free_menu_string(menu, i); |
| |
| /* For "amenu", may insert an extra character. |
| * Don't do this if adding a tearbar (addtearoff == FALSE). |
| * Don't do this for "<Nop>". */ |
| c = 0; |
| if (amenu && call_data != NULL && *call_data != NUL |
| #ifdef FEAT_GUI_W32 |
| && addtearoff |
| #endif |
| ) |
| { |
| switch (1 << i) |
| { |
| case MENU_VISUAL_MODE: |
| case MENU_SELECT_MODE: |
| case MENU_OP_PENDING_MODE: |
| case MENU_CMDLINE_MODE: |
| c = Ctrl_C; |
| break; |
| case MENU_INSERT_MODE: |
| c = Ctrl_O; |
| break; |
| } |
| } |
| |
| if (c) |
| { |
| menu->strings[i] = alloc((unsigned)(STRLEN(call_data) + 4)); |
| if (menu->strings[i] != NULL) |
| { |
| menu->strings[i][0] = c; |
| STRCPY(menu->strings[i] + 1, call_data); |
| if (c == Ctrl_C) |
| { |
| int len = (int)STRLEN(menu->strings[i]); |
| |
| /* Append CTRL-\ CTRL-G to obey 'insertmode'. */ |
| menu->strings[i][len] = Ctrl_BSL; |
| menu->strings[i][len + 1] = Ctrl_G; |
| menu->strings[i][len + 2] = NUL; |
| } |
| } |
| } |
| else |
| menu->strings[i] = p; |
| menu->noremap[i] = menuarg->noremap[0]; |
| menu->silent[i] = menuarg->silent[0]; |
| } |
| } |
| #if defined(FEAT_TOOLBAR) && !defined(FEAT_GUI_W32) \ |
| && (defined(FEAT_BEVAL) || defined(FEAT_GUI_GTK)) |
| /* Need to update the menu tip. */ |
| if (modes & MENU_TIP_MODE) |
| gui_mch_menu_set_tip(menu); |
| #endif |
| } |
| return OK; |
| |
| erret: |
| vim_free(path_name); |
| vim_free(dname); |
| |
| /* Delete any empty submenu we added before discovering the error. Repeat |
| * for higher levels. */ |
| while (parent != NULL && parent->children == NULL) |
| { |
| if (parent->parent == NULL) |
| menup = &root_menu; |
| else |
| menup = &parent->parent->children; |
| for ( ; *menup != NULL && *menup != parent; menup = &((*menup)->next)) |
| ; |
| if (*menup == NULL) /* safety check */ |
| break; |
| parent = parent->parent; |
| free_menu(menup); |
| } |
| return FAIL; |
| } |
| |
| /* |
| * Set the (sub)menu with the given name to enabled or disabled. |
| * Called recursively. |
| */ |
| static int |
| menu_nable_recurse(menu, name, modes, enable) |
| vimmenu_T *menu; |
| char_u *name; |
| int modes; |
| int enable; |
| { |
| char_u *p; |
| |
| if (menu == NULL) |
| return OK; /* Got to bottom of hierarchy */ |
| |
| /* Get name of this element in the menu hierarchy */ |
| p = menu_name_skip(name); |
| |
| /* Find the menu */ |
| while (menu != NULL) |
| { |
| if (*name == NUL || *name == '*' || menu_name_equal(name, menu)) |
| { |
| if (*p != NUL) |
| { |
| if (menu->children == NULL) |
| { |
| EMSG(_(e_notsubmenu)); |
| return FAIL; |
| } |
| if (menu_nable_recurse(menu->children, p, modes, enable) |
| == FAIL) |
| return FAIL; |
| } |
| else |
| if (enable) |
| menu->enabled |= modes; |
| else |
| menu->enabled &= ~modes; |
| |
| /* |
| * When name is empty, we are doing all menu items for the given |
| * modes, so keep looping, otherwise we are just doing the named |
| * menu item (which has been found) so break here. |
| */ |
| if (*name != NUL && *name != '*') |
| break; |
| } |
| menu = menu->next; |
| } |
| if (*name != NUL && *name != '*' && menu == NULL) |
| { |
| EMSG2(_(e_nomenu), name); |
| return FAIL; |
| } |
| |
| #ifdef FEAT_GUI |
| /* Want to update menus now even if mode not changed */ |
| force_menu_update = TRUE; |
| #endif |
| |
| return OK; |
| } |
| |
| /* |
| * Remove the (sub)menu with the given name from the menu hierarchy |
| * Called recursively. |
| */ |
| static int |
| remove_menu(menup, name, modes, silent) |
| vimmenu_T **menup; |
| char_u *name; |
| int modes; |
| int silent; /* don't give error messages */ |
| { |
| vimmenu_T *menu; |
| vimmenu_T *child; |
| char_u *p; |
| |
| if (*menup == NULL) |
| return OK; /* Got to bottom of hierarchy */ |
| |
| /* Get name of this element in the menu hierarchy */ |
| p = menu_name_skip(name); |
| |
| /* Find the menu */ |
| while ((menu = *menup) != NULL) |
| { |
| if (*name == NUL || menu_name_equal(name, menu)) |
| { |
| if (*p != NUL && menu->children == NULL) |
| { |
| if (!silent) |
| EMSG(_(e_notsubmenu)); |
| return FAIL; |
| } |
| if ((menu->modes & modes) != 0x0) |
| { |
| #if defined(FEAT_GUI_W32) & defined(FEAT_TEAROFF) |
| /* |
| * If we are removing all entries for this menu,MENU_ALL_MODES, |
| * Then kill any tearoff before we start |
| */ |
| if (*p == NUL && modes == MENU_ALL_MODES) |
| { |
| if (IsWindow(menu->tearoff_handle)) |
| DestroyWindow(menu->tearoff_handle); |
| } |
| #endif |
| if (remove_menu(&menu->children, p, modes, silent) == FAIL) |
| return FAIL; |
| } |
| else if (*name != NUL) |
| { |
| if (!silent) |
| EMSG(_(e_othermode)); |
| return FAIL; |
| } |
| |
| /* |
| * When name is empty, we are removing all menu items for the given |
| * modes, so keep looping, otherwise we are just removing the named |
| * menu item (which has been found) so break here. |
| */ |
| if (*name != NUL) |
| break; |
| |
| /* Remove the menu item for the given mode[s]. If the menu item |
| * is no longer valid in ANY mode, delete it */ |
| menu->modes &= ~modes; |
| if (modes & MENU_TIP_MODE) |
| free_menu_string(menu, MENU_INDEX_TIP); |
| if ((menu->modes & MENU_ALL_MODES) == 0) |
| free_menu(menup); |
| else |
| menup = &menu->next; |
| } |
| else |
| menup = &menu->next; |
| } |
| if (*name != NUL) |
| { |
| if (menu == NULL) |
| { |
| if (!silent) |
| EMSG2(_(e_nomenu), name); |
| return FAIL; |
| } |
| |
| |
| /* Recalculate modes for menu based on the new updated children */ |
| menu->modes &= ~modes; |
| #if defined(FEAT_GUI_W32) & defined(FEAT_TEAROFF) |
| if ((s_tearoffs) && (menu->children != NULL)) /* there's a tear bar.. */ |
| child = menu->children->next; /* don't count tearoff bar */ |
| else |
| #endif |
| child = menu->children; |
| for ( ; child != NULL; child = child->next) |
| menu->modes |= child->modes; |
| if (modes & MENU_TIP_MODE) |
| { |
| free_menu_string(menu, MENU_INDEX_TIP); |
| #if defined(FEAT_TOOLBAR) && !defined(FEAT_GUI_W32) \ |
| && (defined(FEAT_BEVAL) || defined(FEAT_GUI_GTK)) |
| /* Need to update the menu tip. */ |
| if (gui.in_use) |
| gui_mch_menu_set_tip(menu); |
| #endif |
| } |
| if ((menu->modes & MENU_ALL_MODES) == 0) |
| { |
| /* The menu item is no longer valid in ANY mode, so delete it */ |
| #if defined(FEAT_GUI_W32) & defined(FEAT_TEAROFF) |
| if (s_tearoffs && menu->children != NULL) /* there's a tear bar.. */ |
| free_menu(&menu->children); |
| #endif |
| *menup = menu; |
| free_menu(menup); |
| } |
| } |
| |
| return OK; |
| } |
| |
| /* |
| * Free the given menu structure and remove it from the linked list. |
| */ |
| static void |
| free_menu(menup) |
| vimmenu_T **menup; |
| { |
| int i; |
| vimmenu_T *menu; |
| |
| menu = *menup; |
| |
| #ifdef FEAT_GUI |
| /* Free machine specific menu structures (only when already created) */ |
| /* Also may rebuild a tearoff'ed menu */ |
| if (gui.in_use) |
| gui_mch_destroy_menu(menu); |
| #endif |
| |
| /* Don't change *menup until after calling gui_mch_destroy_menu(). The |
| * MacOS code needs the original structure to properly delete the menu. */ |
| *menup = menu->next; |
| vim_free(menu->name); |
| vim_free(menu->dname); |
| vim_free(menu->actext); |
| #ifdef FEAT_TOOLBAR |
| vim_free(menu->iconfile); |
| # ifdef FEAT_GUI_MOTIF |
| vim_free(menu->xpm_fname); |
| # endif |
| #endif |
| for (i = 0; i < MENU_MODES; i++) |
| free_menu_string(menu, i); |
| vim_free(menu); |
| |
| #ifdef FEAT_GUI |
| /* Want to update menus now even if mode not changed */ |
| force_menu_update = TRUE; |
| #endif |
| } |
| |
| /* |
| * Free the menu->string with the given index. |
| */ |
| static void |
| free_menu_string(menu, idx) |
| vimmenu_T *menu; |
| int idx; |
| { |
| int count = 0; |
| int i; |
| |
| for (i = 0; i < MENU_MODES; i++) |
| if (menu->strings[i] == menu->strings[idx]) |
| count++; |
| if (count == 1) |
| vim_free(menu->strings[idx]); |
| menu->strings[idx] = NULL; |
| } |
| |
| /* |
| * Show the mapping associated with a menu item or hierarchy in a sub-menu. |
| */ |
| static int |
| show_menus(path_name, modes) |
| char_u *path_name; |
| int modes; |
| { |
| char_u *p; |
| char_u *name; |
| vimmenu_T *menu; |
| vimmenu_T *parent = NULL; |
| |
| menu = root_menu; |
| name = path_name = vim_strsave(path_name); |
| if (path_name == NULL) |
| return FAIL; |
| |
| /* First, find the (sub)menu with the given name */ |
| while (*name) |
| { |
| p = menu_name_skip(name); |
| while (menu != NULL) |
| { |
| if (menu_name_equal(name, menu)) |
| { |
| /* Found menu */ |
| if (*p != NUL && menu->children == NULL) |
| { |
| EMSG(_(e_notsubmenu)); |
| vim_free(path_name); |
| return FAIL; |
| } |
| else if ((menu->modes & modes) == 0x0) |
| { |
| EMSG(_(e_othermode)); |
| vim_free(path_name); |
| return FAIL; |
| } |
| break; |
| } |
| menu = menu->next; |
| } |
| if (menu == NULL) |
| { |
| EMSG2(_(e_nomenu), name); |
| vim_free(path_name); |
| return FAIL; |
| } |
| name = p; |
| parent = menu; |
| menu = menu->children; |
| } |
| vim_free(path_name); |
| |
| /* Now we have found the matching menu, and we list the mappings */ |
| /* Highlight title */ |
| MSG_PUTS_TITLE(_("\n--- Menus ---")); |
| |
| show_menus_recursive(parent, modes, 0); |
| return OK; |
| } |
| |
| /* |
| * Recursively show the mappings associated with the menus under the given one |
| */ |
| static void |
| show_menus_recursive(menu, modes, depth) |
| vimmenu_T *menu; |
| int modes; |
| int depth; |
| { |
| int i; |
| int bit; |
| |
| if (menu != NULL && (menu->modes & modes) == 0x0) |
| return; |
| |
| if (menu != NULL) |
| { |
| msg_putchar('\n'); |
| if (got_int) /* "q" hit for "--more--" */ |
| return; |
| for (i = 0; i < depth; i++) |
| MSG_PUTS(" "); |
| if (menu->priority) |
| { |
| msg_outnum((long)menu->priority); |
| MSG_PUTS(" "); |
| } |
| /* Same highlighting as for directories!? */ |
| msg_outtrans_attr(menu->name, hl_attr(HLF_D)); |
| } |
| |
| if (menu != NULL && menu->children == NULL) |
| { |
| for (bit = 0; bit < MENU_MODES; bit++) |
| if ((menu->modes & modes & (1 << bit)) != 0) |
| { |
| msg_putchar('\n'); |
| if (got_int) /* "q" hit for "--more--" */ |
| return; |
| for (i = 0; i < depth + 2; i++) |
| MSG_PUTS(" "); |
| msg_putchar(menu_mode_chars[bit]); |
| if (menu->noremap[bit] == REMAP_NONE) |
| msg_putchar('*'); |
| else if (menu->noremap[bit] == REMAP_SCRIPT) |
| msg_putchar('&'); |
| else |
| msg_putchar(' '); |
| if (menu->silent[bit]) |
| msg_putchar('s'); |
| else |
| msg_putchar(' '); |
| if ((menu->modes & menu->enabled & (1 << bit)) == 0) |
| msg_putchar('-'); |
| else |
| msg_putchar(' '); |
| MSG_PUTS(" "); |
| if (*menu->strings[bit] == NUL) |
| msg_puts_attr((char_u *)"<Nop>", hl_attr(HLF_8)); |
| else |
| msg_outtrans_special(menu->strings[bit], FALSE); |
| } |
| } |
| else |
| { |
| if (menu == NULL) |
| { |
| menu = root_menu; |
| depth--; |
| } |
| else |
| menu = menu->children; |
| |
| /* recursively show all children. Skip PopUp[nvoci]. */ |
| for (; menu != NULL && !got_int; menu = menu->next) |
| if (!menu_is_hidden(menu->dname)) |
| show_menus_recursive(menu, modes, depth + 1); |
| } |
| } |
| |
| #ifdef FEAT_CMDL_COMPL |
| |
| /* |
| * Used when expanding menu names. |
| */ |
| static vimmenu_T *expand_menu = NULL; |
| static int expand_modes = 0x0; |
| static int expand_emenu; /* TRUE for ":emenu" command */ |
| |
| /* |
| * Work out what to complete when doing command line completion of menu names. |
| */ |
| char_u * |
| set_context_in_menu_cmd(xp, cmd, arg, forceit) |
| expand_T *xp; |
| char_u *cmd; |
| char_u *arg; |
| int forceit; |
| { |
| char_u *after_dot; |
| char_u *p; |
| char_u *path_name = NULL; |
| char_u *name; |
| int unmenu; |
| vimmenu_T *menu; |
| int expand_menus; |
| |
| xp->xp_context = EXPAND_UNSUCCESSFUL; |
| |
| |
| /* Check for priority numbers, enable and disable */ |
| for (p = arg; *p; ++p) |
| if (!VIM_ISDIGIT(*p) && *p != '.') |
| break; |
| |
| if (!vim_iswhite(*p)) |
| { |
| if (STRNCMP(arg, "enable", 6) == 0 |
| && (arg[6] == NUL || vim_iswhite(arg[6]))) |
| p = arg + 6; |
| else if (STRNCMP(arg, "disable", 7) == 0 |
| && (arg[7] == NUL || vim_iswhite(arg[7]))) |
| p = arg + 7; |
| else |
| p = arg; |
| } |
| |
| while (*p != NUL && vim_iswhite(*p)) |
| ++p; |
| |
| arg = after_dot = p; |
| |
| for (; *p && !vim_iswhite(*p); ++p) |
| { |
| if ((*p == '\\' || *p == Ctrl_V) && p[1] != NUL) |
| p++; |
| else if (*p == '.') |
| after_dot = p + 1; |
| } |
| |
| /* ":tearoff" and ":popup" only use menus, not entries */ |
| expand_menus = !((*cmd == 't' && cmd[1] == 'e') || *cmd == 'p'); |
| expand_emenu = (*cmd == 'e'); |
| if (expand_menus && vim_iswhite(*p)) |
| return NULL; /* TODO: check for next command? */ |
| if (*p == NUL) /* Complete the menu name */ |
| { |
| /* |
| * With :unmenu, you only want to match menus for the appropriate mode. |
| * With :menu though you might want to add a menu with the same name as |
| * one in another mode, so match menus from other modes too. |
| */ |
| expand_modes = get_menu_cmd_modes(cmd, forceit, NULL, &unmenu); |
| if (!unmenu) |
| expand_modes = MENU_ALL_MODES; |
| |
| menu = root_menu; |
| if (after_dot != arg) |
| { |
| path_name = alloc((unsigned)(after_dot - arg)); |
| if (path_name == NULL) |
| return NULL; |
| vim_strncpy(path_name, arg, after_dot - arg - 1); |
| } |
| name = path_name; |
| while (name != NULL && *name) |
| { |
| p = menu_name_skip(name); |
| while (menu != NULL) |
| { |
| if (menu_name_equal(name, menu)) |
| { |
| /* Found menu */ |
| if ((*p != NUL && menu->children == NULL) |
| || ((menu->modes & expand_modes) == 0x0)) |
| { |
| /* |
| * Menu path continues, but we have reached a leaf. |
| * Or menu exists only in another mode. |
| */ |
| vim_free(path_name); |
| return NULL; |
| } |
| break; |
| } |
| menu = menu->next; |
| } |
| if (menu == NULL) |
| { |
| /* No menu found with the name we were looking for */ |
| vim_free(path_name); |
| return NULL; |
| } |
| name = p; |
| menu = menu->children; |
| } |
| vim_free(path_name); |
| |
| xp->xp_context = expand_menus ? EXPAND_MENUNAMES : EXPAND_MENUS; |
| xp->xp_pattern = after_dot; |
| expand_menu = menu; |
| } |
| else /* We're in the mapping part */ |
| xp->xp_context = EXPAND_NOTHING; |
| return NULL; |
| } |
| |
| /* |
| * Function given to ExpandGeneric() to obtain the list of (sub)menus (not |
| * entries). |
| */ |
| char_u * |
| get_menu_name(xp, idx) |
| expand_T *xp UNUSED; |
| int idx; |
| { |
| static vimmenu_T *menu = NULL; |
| char_u *str; |
| |
| if (idx == 0) /* first call: start at first item */ |
| menu = expand_menu; |
| |
| /* Skip PopUp[nvoci]. */ |
| while (menu != NULL && (menu_is_hidden(menu->dname) |
| || menu_is_separator(menu->dname) |
| || menu_is_tearoff(menu->dname) |
| || menu->children == NULL)) |
| menu = menu->next; |
| |
| if (menu == NULL) /* at end of linked list */ |
| return NULL; |
| |
| if (menu->modes & expand_modes) |
| str = menu->dname; |
| else |
| str = (char_u *)""; |
| |
| /* Advance to next menu entry. */ |
| menu = menu->next; |
| |
| return str; |
| } |
| |
| /* |
| * Function given to ExpandGeneric() to obtain the list of menus and menu |
| * entries. |
| */ |
| char_u * |
| get_menu_names(xp, idx) |
| expand_T *xp UNUSED; |
| int idx; |
| { |
| static vimmenu_T *menu = NULL; |
| static char_u tbuffer[256]; /*hack*/ |
| char_u *str; |
| |
| if (idx == 0) /* first call: start at first item */ |
| menu = expand_menu; |
| |
| /* Skip Browse-style entries, popup menus and separators. */ |
| while (menu != NULL |
| && ( menu_is_hidden(menu->dname) |
| || (expand_emenu && menu_is_separator(menu->dname)) |
| || menu_is_tearoff(menu->dname) |
| #ifndef FEAT_BROWSE |
| || menu->dname[STRLEN(menu->dname) - 1] == '.' |
| #endif |
| )) |
| menu = menu->next; |
| |
| if (menu == NULL) /* at end of linked list */ |
| return NULL; |
| |
| if (menu->modes & expand_modes) |
| { |
| if (menu->children != NULL) |
| { |
| STRCPY(tbuffer, menu->dname); |
| /* hack on menu separators: use a 'magic' char for the separator |
| * so that '.' in names gets escaped properly */ |
| STRCAT(tbuffer, "\001"); |
| str = tbuffer; |
| } |
| else |
| str = menu->dname; |
| } |
| else |
| str = (char_u *)""; |
| |
| /* Advance to next menu entry. */ |
| menu = menu->next; |
| |
| return str; |
| } |
| #endif /* FEAT_CMDL_COMPL */ |
| |
| /* |
| * Skip over this element of the menu path and return the start of the next |
| * element. Any \ and ^Vs are removed from the current element. |
| * "name" may be modified. |
| */ |
| char_u * |
| menu_name_skip(name) |
| char_u *name; |
| { |
| char_u *p; |
| |
| for (p = name; *p && *p != '.'; mb_ptr_adv(p)) |
| { |
| if (*p == '\\' || *p == Ctrl_V) |
| { |
| STRMOVE(p, p + 1); |
| if (*p == NUL) |
| break; |
| } |
| } |
| if (*p) |
| *p++ = NUL; |
| return p; |
| } |
| |
| /* |
| * Return TRUE when "name" matches with menu "menu". The name is compared in |
| * two ways: raw menu name and menu name without '&'. ignore part after a TAB. |
| */ |
| static int |
| menu_name_equal(name, menu) |
| char_u *name; |
| vimmenu_T *menu; |
| { |
| return (menu_namecmp(name, menu->name) || menu_namecmp(name, menu->dname)); |
| } |
| |
| static int |
| menu_namecmp(name, mname) |
| char_u *name; |
| char_u *mname; |
| { |
| int i; |
| |
| for (i = 0; name[i] != NUL && name[i] != TAB; ++i) |
| if (name[i] != mname[i]) |
| break; |
| return ((name[i] == NUL || name[i] == TAB) |
| && (mname[i] == NUL || mname[i] == TAB)); |
| } |
| |
| /* |
| * Return the modes specified by the given menu command (eg :menu! returns |
| * MENU_CMDLINE_MODE | MENU_INSERT_MODE). |
| * If "noremap" is not NULL, then the flag it points to is set according to |
| * whether the command is a "nore" command. |
| * If "unmenu" is not NULL, then the flag it points to is set according to |
| * whether the command is an "unmenu" command. |
| */ |
| static int |
| get_menu_cmd_modes(cmd, forceit, noremap, unmenu) |
| char_u *cmd; |
| int forceit; /* Was there a "!" after the command? */ |
| int *noremap; |
| int *unmenu; |
| { |
| int modes; |
| |
| switch (*cmd++) |
| { |
| case 'v': /* vmenu, vunmenu, vnoremenu */ |
| modes = MENU_VISUAL_MODE | MENU_SELECT_MODE; |
| break; |
| case 'x': /* xmenu, xunmenu, xnoremenu */ |
| modes = MENU_VISUAL_MODE; |
| break; |
| case 's': /* smenu, sunmenu, snoremenu */ |
| modes = MENU_SELECT_MODE; |
| break; |
| case 'o': /* omenu */ |
| modes = MENU_OP_PENDING_MODE; |
| break; |
| case 'i': /* imenu */ |
| modes = MENU_INSERT_MODE; |
| break; |
| case 't': |
| modes = MENU_TIP_MODE; /* tmenu */ |
| break; |
| case 'c': /* cmenu */ |
| modes = MENU_CMDLINE_MODE; |
| break; |
| case 'a': /* amenu */ |
| modes = MENU_INSERT_MODE | MENU_CMDLINE_MODE | MENU_NORMAL_MODE |
| | MENU_VISUAL_MODE | MENU_SELECT_MODE |
| | MENU_OP_PENDING_MODE; |
| break; |
| case 'n': |
| if (*cmd != 'o') /* nmenu, not noremenu */ |
| { |
| modes = MENU_NORMAL_MODE; |
| break; |
| } |
| /* FALLTHROUGH */ |
| default: |
| --cmd; |
| if (forceit) /* menu!! */ |
| modes = MENU_INSERT_MODE | MENU_CMDLINE_MODE; |
| else /* menu */ |
| modes = MENU_NORMAL_MODE | MENU_VISUAL_MODE | MENU_SELECT_MODE |
| | MENU_OP_PENDING_MODE; |
| } |
| |
| if (noremap != NULL) |
| *noremap = (*cmd == 'n' ? REMAP_NONE : REMAP_YES); |
| if (unmenu != NULL) |
| *unmenu = (*cmd == 'u'); |
| return modes; |
| } |
| |
| /* |
| * Modify a menu name starting with "PopUp" to include the mode character. |
| * Returns the name in allocated memory (NULL for failure). |
| */ |
| static char_u * |
| popup_mode_name(name, idx) |
| char_u *name; |
| int idx; |
| { |
| char_u *p; |
| int len = (int)STRLEN(name); |
| |
| p = vim_strnsave(name, len + 1); |
| if (p != NULL) |
| { |
| mch_memmove(p + 6, p + 5, (size_t)(len - 4)); |
| p[5] = menu_mode_chars[idx]; |
| } |
| return p; |
| } |
| |
| #if defined(FEAT_GUI) || defined(PROTO) |
| /* |
| * Return the index into the menu->strings or menu->noremap arrays for the |
| * current state. Returns MENU_INDEX_INVALID if there is no mapping for the |
| * given menu in the current mode. |
| */ |
| int |
| get_menu_index(menu, state) |
| vimmenu_T *menu; |
| int state; |
| { |
| int idx; |
| |
| if ((state & INSERT)) |
| idx = MENU_INDEX_INSERT; |
| else if (state & CMDLINE) |
| idx = MENU_INDEX_CMDLINE; |
| #ifdef FEAT_VISUAL |
| else if (VIsual_active) |
| { |
| if (VIsual_select) |
| idx = MENU_INDEX_SELECT; |
| else |
| idx = MENU_INDEX_VISUAL; |
| } |
| #endif |
| else if (state == HITRETURN || state == ASKMORE) |
| idx = MENU_INDEX_CMDLINE; |
| else if (finish_op) |
| idx = MENU_INDEX_OP_PENDING; |
| else if ((state & NORMAL)) |
| idx = MENU_INDEX_NORMAL; |
| else |
| idx = MENU_INDEX_INVALID; |
| |
| if (idx != MENU_INDEX_INVALID && menu->strings[idx] == NULL) |
| idx = MENU_INDEX_INVALID; |
| return idx; |
| } |
| #endif |
| |
| /* |
| * Duplicate the menu item text and then process to see if a mnemonic key |
| * and/or accelerator text has been identified. |
| * Returns a pointer to allocated memory, or NULL for failure. |
| * If mnemonic != NULL, *mnemonic is set to the character after the first '&'. |
| * If actext != NULL, *actext is set to the text after the first TAB. |
| */ |
| static char_u * |
| menu_text(str, mnemonic, actext) |
| char_u *str; |
| int *mnemonic; |
| char_u **actext; |
| { |
| char_u *p; |
| char_u *text; |
| |
| /* Locate accelerator text, after the first TAB */ |
| p = vim_strchr(str, TAB); |
| if (p != NULL) |
| { |
| if (actext != NULL) |
| *actext = vim_strsave(p + 1); |
| text = vim_strnsave(str, (int)(p - str)); |
| } |
| else |
| text = vim_strsave(str); |
| |
| /* Find mnemonic characters "&a" and reduce "&&" to "&". */ |
| for (p = text; p != NULL; ) |
| { |
| p = vim_strchr(p, '&'); |
| if (p != NULL) |
| { |
| if (p[1] == NUL) /* trailing "&" */ |
| break; |
| if (mnemonic != NULL && p[1] != '&') |
| #if !defined(__MVS__) || defined(MOTIF390_MNEMONIC_FIXED) |
| *mnemonic = p[1]; |
| #else |
| { |
| /* |
| * Well there is a bug in the Motif libraries on OS390 Unix. |
| * The mnemonic keys needs to be converted to ASCII values |
| * first. |
| * This behavior has been seen in 2.8 and 2.9. |
| */ |
| char c = p[1]; |
| __etoa_l(&c, 1); |
| *mnemonic = c; |
| } |
| #endif |
| STRMOVE(p, p + 1); |
| p = p + 1; |
| } |
| } |
| return text; |
| } |
| |
| /* |
| * Return TRUE if "name" can be a menu in the MenuBar. |
| */ |
| int |
| menu_is_menubar(name) |
| char_u *name; |
| { |
| return (!menu_is_popup(name) |
| && !menu_is_toolbar(name) |
| && *name != MNU_HIDDEN_CHAR); |
| } |
| |
| /* |
| * Return TRUE if "name" is a popup menu name. |
| */ |
| int |
| menu_is_popup(name) |
| char_u *name; |
| { |
| return (STRNCMP(name, "PopUp", 5) == 0); |
| } |
| |
| #if (defined(FEAT_GUI_MOTIF) && (XmVersion <= 1002)) || defined(PROTO) |
| /* |
| * Return TRUE if "name" is part of a popup menu. |
| */ |
| int |
| menu_is_child_of_popup(menu) |
| vimmenu_T *menu; |
| { |
| while (menu->parent != NULL) |
| menu = menu->parent; |
| return menu_is_popup(menu->name); |
| } |
| #endif |
| |
| /* |
| * Return TRUE if "name" is a toolbar menu name. |
| */ |
| int |
| menu_is_toolbar(name) |
| char_u *name; |
| { |
| return (STRNCMP(name, "ToolBar", 7) == 0); |
| } |
| |
| /* |
| * Return TRUE if the name is a menu separator identifier: Starts and ends |
| * with '-' |
| */ |
| int |
| menu_is_separator(name) |
| char_u *name; |
| { |
| return (name[0] == '-' && name[STRLEN(name) - 1] == '-'); |
| } |
| |
| /* |
| * Return TRUE if the menu is hidden: Starts with ']' |
| */ |
| static int |
| menu_is_hidden(name) |
| char_u *name; |
| { |
| return (name[0] == ']') || (menu_is_popup(name) && name[5] != NUL); |
| } |
| |
| #if defined(FEAT_CMDL_COMPL) \ |
| || (defined(FEAT_GUI_W32) && defined(FEAT_TEAROFF)) |
| /* |
| * Return TRUE if the menu is the tearoff menu. |
| */ |
| static int |
| menu_is_tearoff(name) |
| char_u *name UNUSED; |
| { |
| #ifdef FEAT_GUI |
| return (STRCMP(name, TEAR_STRING) == 0); |
| #else |
| return FALSE; |
| #endif |
| } |
| #endif |
| |
| #ifdef FEAT_GUI |
| |
| static int |
| get_menu_mode() |
| { |
| #ifdef FEAT_VISUAL |
| if (VIsual_active) |
| { |
| if (VIsual_select) |
| return MENU_INDEX_SELECT; |
| return MENU_INDEX_VISUAL; |
| } |
| #endif |
| if (State & INSERT) |
| return MENU_INDEX_INSERT; |
| if ((State & CMDLINE) || State == ASKMORE || State == HITRETURN) |
| return MENU_INDEX_CMDLINE; |
| if (finish_op) |
| return MENU_INDEX_OP_PENDING; |
| if (State & NORMAL) |
| return MENU_INDEX_NORMAL; |
| if (State & LANGMAP) /* must be a "r" command, like Insert mode */ |
| return MENU_INDEX_INSERT; |
| return MENU_INDEX_INVALID; |
| } |
| |
| /* |
| * Check that a pointer appears in the menu tree. Used to protect from using |
| * a menu that was deleted after it was selected but before the event was |
| * handled. |
| * Return OK or FAIL. Used recursively. |
| */ |
| int |
| check_menu_pointer(root, menu_to_check) |
| vimmenu_T *root; |
| vimmenu_T *menu_to_check; |
| { |
| vimmenu_T *p; |
| |
| for (p = root; p != NULL; p = p->next) |
| if (p == menu_to_check |
| || (p->children != NULL |
| && check_menu_pointer(p->children, menu_to_check) == OK)) |
| return OK; |
| return FAIL; |
| } |
| |
| /* |
| * After we have started the GUI, then we can create any menus that have been |
| * defined. This is done once here. add_menu_path() may have already been |
| * called to define these menus, and may be called again. This function calls |
| * itself recursively. Should be called at the top level with: |
| * gui_create_initial_menus(root_menu, NULL); |
| */ |
| void |
| gui_create_initial_menus(menu) |
| vimmenu_T *menu; |
| { |
| int idx = 0; |
| |
| while (menu != NULL) |
| { |
| /* Don't add a menu when only a tip was defined. */ |
| if (menu->modes & MENU_ALL_MODES) |
| { |
| if (menu->children != NULL) |
| { |
| gui_mch_add_menu(menu, idx); |
| gui_create_initial_menus(menu->children); |
| } |
| else |
| gui_mch_add_menu_item(menu, idx); |
| } |
| menu = menu->next; |
| ++idx; |
| } |
| } |
| |
| /* |
| * Used recursively by gui_update_menus (see below) |
| */ |
| static void |
| gui_update_menus_recurse(menu, mode) |
| vimmenu_T *menu; |
| int mode; |
| { |
| int grey; |
| |
| while (menu) |
| { |
| if ((menu->modes & menu->enabled & mode) |
| #if defined(FEAT_GUI_W32) && defined(FEAT_TEAROFF) |
| || menu_is_tearoff(menu->dname) |
| #endif |
| ) |
| grey = FALSE; |
| else |
| grey = TRUE; |
| #ifdef FEAT_GUI_ATHENA |
| /* Hiding menus doesn't work for Athena, it can cause a crash. */ |
| gui_mch_menu_grey(menu, grey); |
| #else |
| /* Never hide a toplevel menu, it may make the menubar resize or |
| * disappear. Same problem for ToolBar items. */ |
| if (vim_strchr(p_go, GO_GREY) != NULL || menu->parent == NULL |
| # ifdef FEAT_TOOLBAR |
| || menu_is_toolbar(menu->parent->name) |
| # endif |
| ) |
| gui_mch_menu_grey(menu, grey); |
| else |
| gui_mch_menu_hidden(menu, grey); |
| #endif |
| gui_update_menus_recurse(menu->children, mode); |
| menu = menu->next; |
| } |
| } |
| |
| /* |
| * Make sure only the valid menu items appear for this mode. If |
| * force_menu_update is not TRUE, then we only do this if the mode has changed |
| * since last time. If "modes" is not 0, then we use these modes instead. |
| */ |
| void |
| gui_update_menus(modes) |
| int modes; |
| { |
| static int prev_mode = -1; |
| int mode = 0; |
| |
| if (modes != 0x0) |
| mode = modes; |
| else |
| { |
| mode = get_menu_mode(); |
| if (mode == MENU_INDEX_INVALID) |
| mode = 0; |
| else |
| mode = (1 << mode); |
| } |
| |
| if (force_menu_update || mode != prev_mode) |
| { |
| gui_update_menus_recurse(root_menu, mode); |
| gui_mch_draw_menubar(); |
| prev_mode = mode; |
| force_menu_update = FALSE; |
| #ifdef FEAT_GUI_W32 |
| /* This can leave a tearoff as active window - make sure we |
| * have the focus <negri>*/ |
| gui_mch_activate_window(); |
| #endif |
| } |
| } |
| |
| #if defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_MOTIF) \ |
| || defined(FEAT_GUI_GTK) || defined(FEAT_GUI_PHOTON) || defined(PROTO) |
| /* |
| * Check if a key is used as a mnemonic for a toplevel menu. |
| * Case of the key is ignored. |
| */ |
| int |
| gui_is_menu_shortcut(key) |
| int key; |
| { |
| vimmenu_T *menu; |
| |
| if (key < 256) |
| key = TOLOWER_LOC(key); |
| for (menu = root_menu; menu != NULL; menu = menu->next) |
| if (menu->mnemonic == key |
| || (menu->mnemonic < 256 && TOLOWER_LOC(menu->mnemonic) == key)) |
| return TRUE; |
| return FALSE; |
| } |
| #endif |
| |
| /* |
| * Display the Special "PopUp" menu as a pop-up at the current mouse |
| * position. The "PopUpn" menu is for Normal mode, "PopUpi" for Insert mode, |
| * etc. |
| */ |
| void |
| gui_show_popupmenu() |
| { |
| vimmenu_T *menu; |
| int mode; |
| |
| mode = get_menu_mode(); |
| if (mode == MENU_INDEX_INVALID) |
| return; |
| mode = menu_mode_chars[mode]; |
| |
| #ifdef FEAT_AUTOCMD |
| { |
| char_u ename[2]; |
| |
| ename[0] = mode; |
| ename[1] = NUL; |
| apply_autocmds(EVENT_MENUPOPUP, ename, NULL, FALSE, curbuf); |
| } |
| #endif |
| |
| for (menu = root_menu; menu != NULL; menu = menu->next) |
| if (STRNCMP("PopUp", menu->name, 5) == 0 && menu->name[5] == mode) |
| break; |
| |
| /* Only show a popup when it is defined and has entries */ |
| if (menu != NULL && menu->children != NULL) |
| gui_mch_show_popupmenu(menu); |
| } |
| #endif /* FEAT_GUI */ |
| |
| #if (defined(FEAT_GUI_W32) && defined(FEAT_TEAROFF)) || defined(PROTO) |
| |
| /* |
| * Deal with tearoff items that are added like a menu item. |
| * Currently only for Win32 GUI. Others may follow later. |
| */ |
| |
| void |
| gui_mch_toggle_tearoffs(int enable) |
| { |
| int pri_tab[MENUDEPTH + 1]; |
| int i; |
| |
| if (enable) |
| { |
| for (i = 0; i < MENUDEPTH; ++i) |
| pri_tab[i] = 500; |
| pri_tab[MENUDEPTH] = -1; |
| gui_create_tearoffs_recurse(root_menu, (char_u *)"", pri_tab, 0); |
| } |
| else |
| gui_destroy_tearoffs_recurse(root_menu); |
| s_tearoffs = enable; |
| } |
| |
| /* |
| * Recursively add tearoff items |
| */ |
| static void |
| gui_create_tearoffs_recurse(menu, pname, pri_tab, pri_idx) |
| vimmenu_T *menu; |
| const char_u *pname; |
| int *pri_tab; |
| int pri_idx; |
| { |
| char_u *newpname = NULL; |
| int len; |
| char_u *s; |
| char_u *d; |
| |
| if (pri_tab[pri_idx + 1] != -1) |
| ++pri_idx; |
| while (menu != NULL) |
| { |
| if (menu->children != NULL && menu_is_menubar(menu->name)) |
| { |
| /* Add the menu name to the menu path. Insert a backslash before |
| * dots (it's used to separate menu names). */ |
| len = (int)STRLEN(pname) + (int)STRLEN(menu->name); |
| for (s = menu->name; *s; ++s) |
| if (*s == '.' || *s == '\\') |
| ++len; |
| newpname = alloc(len + TEAR_LEN + 2); |
| if (newpname != NULL) |
| { |
| STRCPY(newpname, pname); |
| d = newpname + STRLEN(newpname); |
| for (s = menu->name; *s; ++s) |
| { |
| if (*s == '.' || *s == '\\') |
| *d++ = '\\'; |
| *d++ = *s; |
| } |
| *d = NUL; |
| |
| /* check if tearoff already exists */ |
| if (STRCMP(menu->children->name, TEAR_STRING) != 0) |
| { |
| gui_add_tearoff(newpname, pri_tab, pri_idx - 1); |
| *d = NUL; /* remove TEAR_STRING */ |
| } |
| |
| STRCAT(newpname, "."); |
| gui_create_tearoffs_recurse(menu->children, newpname, |
| pri_tab, pri_idx); |
| vim_free(newpname); |
| } |
| } |
| menu = menu->next; |
| } |
| } |
| |
| /* |
| * Add tear-off menu item for a submenu. |
| * "tearpath" is the menu path, and must have room to add TEAR_STRING. |
| */ |
| static void |
| gui_add_tearoff(tearpath, pri_tab, pri_idx) |
| char_u *tearpath; |
| int *pri_tab; |
| int pri_idx; |
| { |
| char_u *tbuf; |
| int t; |
| vimmenu_T menuarg; |
| |
| tbuf = alloc(5 + (unsigned int)STRLEN(tearpath)); |
| if (tbuf != NULL) |
| { |
| tbuf[0] = K_SPECIAL; |
| tbuf[1] = K_SECOND(K_TEAROFF); |
| tbuf[2] = K_THIRD(K_TEAROFF); |
| STRCPY(tbuf + 3, tearpath); |
| STRCAT(tbuf + 3, "\r"); |
| |
| STRCAT(tearpath, "."); |
| STRCAT(tearpath, TEAR_STRING); |
| |
| /* Priority of tear-off is always 1 */ |
| t = pri_tab[pri_idx + 1]; |
| pri_tab[pri_idx + 1] = 1; |
| |
| #ifdef FEAT_TOOLBAR |
| menuarg.iconfile = NULL; |
| menuarg.iconidx = -1; |
| menuarg.icon_builtin = FALSE; |
| #endif |
| menuarg.noremap[0] = REMAP_NONE; |
| menuarg.silent[0] = TRUE; |
| |
| menuarg.modes = MENU_ALL_MODES; |
| add_menu_path(tearpath, &menuarg, pri_tab, tbuf, FALSE); |
| |
| menuarg.modes = MENU_TIP_MODE; |
| add_menu_path(tearpath, &menuarg, pri_tab, |
| (char_u *)_("Tear off this menu"), FALSE); |
| |
| pri_tab[pri_idx + 1] = t; |
| vim_free(tbuf); |
| } |
| } |
| |
| /* |
| * Recursively destroy tearoff items |
| */ |
| static void |
| gui_destroy_tearoffs_recurse(menu) |
| vimmenu_T *menu; |
| { |
| while (menu) |
| { |
| if (menu->children) |
| { |
| /* check if tearoff exists */ |
| if (STRCMP(menu->children->name, TEAR_STRING) == 0) |
| { |
| /* Disconnect the item and free the memory */ |
| free_menu(&menu->children); |
| } |
| if (menu->children != NULL) /* if not the last one */ |
| gui_destroy_tearoffs_recurse(menu->children); |
| } |
| menu = menu->next; |
| } |
| } |
| |
| #endif /* FEAT_GUI_W32 && FEAT_TEAROFF */ |
| |
| /* |
| * Given a menu descriptor, e.g. "File.New", find it in the menu hierarchy and |
| * execute it. |
| */ |
| void |
| ex_emenu(eap) |
| exarg_T *eap; |
| { |
| vimmenu_T *menu; |
| char_u *name; |
| char_u *saved_name; |
| char_u *p; |
| int idx; |
| char_u *mode; |
| |
| saved_name = vim_strsave(eap->arg); |
| if (saved_name == NULL) |
| return; |
| |
| menu = root_menu; |
| name = saved_name; |
| while (*name) |
| { |
| /* Find in the menu hierarchy */ |
| p = menu_name_skip(name); |
| |
| while (menu != NULL) |
| { |
| if (menu_name_equal(name, menu)) |
| { |
| if (*p == NUL && menu->children != NULL) |
| { |
| EMSG(_("E333: Menu path must lead to a menu item")); |
| menu = NULL; |
| } |
| else if (*p != NUL && menu->children == NULL) |
| { |
| EMSG(_(e_notsubmenu)); |
| menu = NULL; |
| } |
| break; |
| } |
| menu = menu->next; |
| } |
| if (menu == NULL || *p == NUL) |
| break; |
| menu = menu->children; |
| name = p; |
| } |
| vim_free(saved_name); |
| if (menu == NULL) |
| { |
| EMSG2(_("E334: Menu not found: %s"), eap->arg); |
| return; |
| } |
| |
| /* Found the menu, so execute. |
| * Use the Insert mode entry when returning to Insert mode. */ |
| if (restart_edit |
| #ifdef FEAT_EVAL |
| && !current_SID |
| #endif |
| ) |
| { |
| mode = (char_u *)"Insert"; |
| idx = MENU_INDEX_INSERT; |
| } |
| else if (eap->addr_count) |
| { |
| pos_T tpos; |
| |
| mode = (char_u *)"Visual"; |
| idx = MENU_INDEX_VISUAL; |
| |
| /* GEDDES: This is not perfect - but it is a |
| * quick way of detecting whether we are doing this from a |
| * selection - see if the range matches up with the visual |
| * select start and end. */ |
| if ((curbuf->b_visual.vi_start.lnum == eap->line1) |
| && (curbuf->b_visual.vi_end.lnum) == eap->line2) |
| { |
| /* Set it up for visual mode - equivalent to gv. */ |
| VIsual_mode = curbuf->b_visual.vi_mode; |
| tpos = curbuf->b_visual.vi_end; |
| curwin->w_cursor = curbuf->b_visual.vi_start; |
| curwin->w_curswant = curbuf->b_visual.vi_curswant; |
| } |
| else |
| { |
| /* Set it up for line-wise visual mode */ |
| VIsual_mode = 'V'; |
| curwin->w_cursor.lnum = eap->line1; |
| curwin->w_cursor.col = 1; |
| tpos.lnum = eap->line2; |
| tpos.col = MAXCOL; |
| #ifdef FEAT_VIRTUALEDIT |
| tpos.coladd = 0; |
| #endif |
| } |
| |
| /* Activate visual mode */ |
| VIsual_active = TRUE; |
| VIsual_reselect = TRUE; |
| check_cursor(); |
| VIsual = curwin->w_cursor; |
| curwin->w_cursor = tpos; |
| |
| check_cursor(); |
| |
| /* Adjust the cursor to make sure it is in the correct pos |
| * for exclusive mode */ |
| if (*p_sel == 'e' && gchar_cursor() != NUL) |
| ++curwin->w_cursor.col; |
| } |
| else |
| { |
| mode = (char_u *)"Normal"; |
| idx = MENU_INDEX_NORMAL; |
| } |
| |
| if (idx != MENU_INDEX_INVALID && menu->strings[idx] != NULL) |
| { |
| /* When executing a script or function execute the commands right now. |
| * Otherwise put them in the typeahead buffer. */ |
| #ifdef FEAT_EVAL |
| if (current_SID != 0) |
| exec_normal_cmd(menu->strings[idx], menu->noremap[idx], |
| menu->silent[idx]); |
| else |
| #endif |
| ins_typebuf(menu->strings[idx], menu->noremap[idx], 0, |
| TRUE, menu->silent[idx]); |
| } |
| else |
| EMSG2(_("E335: Menu not defined for %s mode"), mode); |
| } |
| |
| #if defined(FEAT_GUI_MSWIN) \ |
| || (defined(FEAT_GUI_GTK) && defined(FEAT_MENU)) \ |
| || defined(FEAT_BEVAL_TIP) || defined(PROTO) |
| /* |
| * Given a menu descriptor, e.g. "File.New", find it in the menu hierarchy. |
| */ |
| vimmenu_T * |
| gui_find_menu(path_name) |
| char_u *path_name; |
| { |
| vimmenu_T *menu = NULL; |
| char_u *name; |
| char_u *saved_name; |
| char_u *p; |
| |
| menu = root_menu; |
| |
| saved_name = vim_strsave(path_name); |
| if (saved_name == NULL) |
| return NULL; |
| |
| name = saved_name; |
| while (*name) |
| { |
| /* find the end of one dot-separated name and put a NUL at the dot */ |
| p = menu_name_skip(name); |
| |
| while (menu != NULL) |
| { |
| if (STRCMP(name, menu->name) == 0 || STRCMP(name, menu->dname) == 0) |
| { |
| if (menu->children == NULL) |
| { |
| /* found a menu item instead of a sub-menu */ |
| if (*p == NUL) |
| EMSG(_("E336: Menu path must lead to a sub-menu")); |
| else |
| EMSG(_(e_notsubmenu)); |
| menu = NULL; |
| goto theend; |
| } |
| if (*p == NUL) /* found a full match */ |
| goto theend; |
| break; |
| } |
| menu = menu->next; |
| } |
| if (menu == NULL) /* didn't find it */ |
| break; |
| |
| /* Found a match, search the sub-menu. */ |
| menu = menu->children; |
| name = p; |
| } |
| |
| if (menu == NULL) |
| EMSG(_("E337: Menu not found - check menu names")); |
| theend: |
| vim_free(saved_name); |
| return menu; |
| } |
| #endif |
| |
| #ifdef FEAT_MULTI_LANG |
| /* |
| * Translation of menu names. Just a simple lookup table. |
| */ |
| |
| typedef struct |
| { |
| char_u *from; /* English name */ |
| char_u *from_noamp; /* same, without '&' */ |
| char_u *to; /* translated name */ |
| } menutrans_T; |
| |
| static garray_T menutrans_ga = {0, 0, 0, 0, NULL}; |
| #endif |
| |
| /* |
| * ":menutrans". |
| * This function is also defined without the +multi_lang feature, in which |
| * case the commands are ignored. |
| */ |
| void |
| ex_menutranslate(eap) |
| exarg_T *eap UNUSED; |
| { |
| #ifdef FEAT_MULTI_LANG |
| char_u *arg = eap->arg; |
| menutrans_T *tp; |
| int i; |
| char_u *from, *from_noamp, *to; |
| |
| if (menutrans_ga.ga_itemsize == 0) |
| ga_init2(&menutrans_ga, (int)sizeof(menutrans_T), 5); |
| |
| /* |
| * ":menutrans clear": clear all translations. |
| */ |
| if (STRNCMP(arg, "clear", 5) == 0 && ends_excmd(*skipwhite(arg + 5))) |
| { |
| tp = (menutrans_T *)menutrans_ga.ga_data; |
| for (i = 0; i < menutrans_ga.ga_len; ++i) |
| { |
| vim_free(tp[i].from); |
| vim_free(tp[i].from_noamp); |
| vim_free(tp[i].to); |
| } |
| ga_clear(&menutrans_ga); |
| # ifdef FEAT_EVAL |
| /* Delete all "menutrans_" global variables. */ |
| del_menutrans_vars(); |
| # endif |
| } |
| else |
| { |
| /* ":menutrans from to": add translation */ |
| from = arg; |
| arg = menu_skip_part(arg); |
| to = skipwhite(arg); |
| *arg = NUL; |
| arg = menu_skip_part(to); |
| if (arg == to) |
| EMSG(_(e_invarg)); |
| else |
| { |
| if (ga_grow(&menutrans_ga, 1) == OK) |
| { |
| tp = (menutrans_T *)menutrans_ga.ga_data; |
| from = vim_strsave(from); |
| if (from != NULL) |
| { |
| from_noamp = menu_text(from, NULL, NULL); |
| to = vim_strnsave(to, (int)(arg - to)); |
| if (from_noamp != NULL && to != NULL) |
| { |
| tp[menutrans_ga.ga_len].from = from; |
| tp[menutrans_ga.ga_len].from_noamp = from_noamp; |
| tp[menutrans_ga.ga_len].to = to; |
| ++menutrans_ga.ga_len; |
| } |
| else |
| { |
| vim_free(from); |
| vim_free(from_noamp); |
| vim_free(to); |
| } |
| } |
| } |
| } |
| } |
| #endif |
| } |
| |
| #if defined(FEAT_MULTI_LANG) || defined(FEAT_TOOLBAR) |
| /* |
| * Find the character just after one part of a menu name. |
| */ |
| static char_u * |
| menu_skip_part(p) |
| char_u *p; |
| { |
| while (*p != NUL && *p != '.' && !vim_iswhite(*p)) |
| { |
| if ((*p == '\\' || *p == Ctrl_V) && p[1] != NUL) |
| ++p; |
| ++p; |
| } |
| return p; |
| } |
| #endif |
| |
| #ifdef FEAT_MULTI_LANG |
| /* |
| * Lookup part of a menu name in the translations. |
| * Return a pointer to the translation or NULL if not found. |
| */ |
| static char_u * |
| menutrans_lookup(name, len) |
| char_u *name; |
| int len; |
| { |
| menutrans_T *tp = (menutrans_T *)menutrans_ga.ga_data; |
| int i; |
| char_u *dname; |
| |
| for (i = 0; i < menutrans_ga.ga_len; ++i) |
| if (STRNCMP(name, tp[i].from, len) == 0 && tp[i].from[len] == NUL) |
| return tp[i].to; |
| |
| /* Now try again while ignoring '&' characters. */ |
| i = name[len]; |
| name[len] = NUL; |
| dname = menu_text(name, NULL, NULL); |
| name[len] = i; |
| if (dname != NULL) |
| { |
| for (i = 0; i < menutrans_ga.ga_len; ++i) |
| if (STRCMP(dname, tp[i].from_noamp) == 0) |
| { |
| vim_free(dname); |
| return tp[i].to; |
| } |
| vim_free(dname); |
| } |
| |
| return NULL; |
| } |
| #endif /* FEAT_MULTI_LANG */ |
| |
| #endif /* FEAT_MENU */ |