| /* | |
| * GraphApp - Cross-Platform Graphics Programming Library. | |
| * | |
| * File: menus.c -- creating menus, menubars, etc. | |
| * Platform: Windows Version: 2.35 Date: 1998/04/04 | |
| * | |
| * Version: 1.00 Changes: Original version by Lachlan Patrick. | |
| * Version: 2.00 Changes: New object class system. | |
| * Version: 2.15 Changes: Added submenu creation function. | |
| * Version: 2.20 Changes: New menuitem constructor. | |
| * Version: 2.30 Changes: Modified the shortcut key selector. | |
| * Version: 2.35 Changes: New reference count technique. | |
| */ | |
| /* Copyright (C) 1993-1998 Lachlan Patrick | |
| This file is part of GraphApp, a cross-platform C graphics library. | |
| GraphApp is free software; you can redistribute it and/or modify it | |
| under the terms of the GNU Library General Public License. | |
| GraphApp is distributed in the hope that it will be useful, but | |
| WITHOUT ANY WARRANTY. | |
| See the file COPYLIB.TXT for details. | |
| */ | |
| /* | |
| * When you create menubars, menus and menuitems, they are added | |
| * to the currentwindow. Menus are added to the current_menubar and | |
| * menuitems are added to the current_menu. | |
| */ | |
| /* Copyright (C) 2004 The R Foundation | |
| Change for R - Chris Jackson. Enabled menu shortcut keys, don't | |
| execute shortcut if menu item is grayed out */ | |
| #include "internal.h" | |
| /*#include "config.h" */ | |
| #include <wchar.h> | |
| #define mbs_init(x) memset(&x,0,sizeof(x)) | |
| size_t Rf_mbrtowc(wchar_t *wc, const char *s, size_t n, mbstate_t *ps); | |
| /* | |
| * Menu variables. | |
| */ | |
| PROTECTED int menus_active = 1; | |
| PROTECTED menubar current_menubar = NULL; | |
| PROTECTED menu current_menu = NULL; | |
| static int id = MinMenuID; | |
| PROTECTED HACCEL hAccel = 0; | |
| /* | |
| * Initialise menus. Actually, all we do here is load accelerators. | |
| * The accelarator resource must have the name "ACCELS". | |
| * If there are no accelerator resources, hAccel will be zero. | |
| */ | |
| PROTECTED | |
| void init_menus(void) | |
| { | |
| if (this_instance != 0) | |
| hAccel = LoadAccelerators(this_instance, "ACCELS"); | |
| } | |
| /* | |
| * Find the position of a menu on its parent menubar. | |
| * Return zero for the first menu, one for the next etc. | |
| */ | |
| static int find_menu_position(menu parent, char *name) | |
| { | |
| menu m, first; | |
| int which = 0; | |
| first = m = parent->child; | |
| if (first) { | |
| do { | |
| if (strcmp(m->text, name) == 0) | |
| break; | |
| which ++; | |
| m = m->next; | |
| } while (m != first); | |
| } | |
| return which; | |
| } | |
| /* | |
| * Private menu deletion function. | |
| */ | |
| static void private_delmenu(menu m) | |
| { | |
| window w = parentwindow(m); | |
| if (m->kind == MenuitemObject) | |
| RemoveMenu(m->parent->handle, m->id, MF_BYCOMMAND); | |
| else if (m->kind == MenuObject) { | |
| DeleteMenu(m->parent->handle, | |
| find_menu_position(m->parent, m->text), | |
| MF_BYPOSITION); | |
| } | |
| else | |
| DestroyMenu(m->handle); | |
| if (w) | |
| DrawMenuBar(w->handle); | |
| } | |
| /* | |
| * Find a char within a string. | |
| * Return -1 if not found, or a number from 0 to strlen(str)-1 | |
| * to indicate where the char is. | |
| */ | |
| char *Rf_strchr(const char *s, int c); /* from util.c, MBCS-aware */ | |
| static int find_char(int ch, const char *str) | |
| { | |
| char *p; | |
| p = Rf_strchr(str, ch); | |
| if(!p) return -1; else return p - str; | |
| } | |
| /* | |
| * This function forms a search string, to look for the best | |
| * letter to underline in a menu item. It first tries the | |
| * accelerator key, then the uppercase letters from the menu name, | |
| * then the digits, and finally the lowercase letters. | |
| * It ignores spaces. | |
| */ | |
| static void set_search_string(char *search, const char *name, int key) | |
| { | |
| int source; | |
| int dest = 0; | |
| int mb_len; | |
| mbstate_t mb_st; | |
| /* handle a couple of special cases first */ | |
| if (! string_diff(name, "Cut")) search[dest++] = 't'; | |
| if (! string_diff(name, "Exit")) search[dest++] = 'x'; | |
| if (! string_diff(name, "?")) search[dest++] = '?'; | |
| { | |
| /* If there is an '&' in the string, use the next letter first */ | |
| char *p = strchr(name, '&'); | |
| if (p && *(p+1)) search[dest++] = *(p+1); | |
| } | |
| /* add the accelerator key if it is in the name string */ | |
| if (key) { | |
| key = toupper(key); | |
| if (find_char(key, name) >= 0) | |
| search[dest++] = (char) key; | |
| else { | |
| key = tolower(key); | |
| if (find_char(key, name) >= 0) | |
| search[dest++] = (char) key; | |
| } | |
| } | |
| /* add the uppercase letters */ | |
| for (source=0; name[source]; source++) { | |
| mbs_init(mb_st); | |
| mb_len = Rf_mbrtowc(NULL, name + source, MB_CUR_MAX,&mb_st); | |
| if (mb_len > 1) source += mb_len-1; | |
| else | |
| if (isupper(name[source])) search[dest++] = name[source]; | |
| } | |
| /* add the digits */ | |
| for (source=0; name[source]; source++) { | |
| mbs_init(mb_st); | |
| mb_len = Rf_mbrtowc(NULL, name + source, MB_CUR_MAX,&mb_st); | |
| if (mb_len > 1) source += mb_len-1; | |
| else | |
| if (isdigit(name[source])) search[dest++] = name[source]; | |
| } | |
| /* add the lowercase letters */ | |
| for (source=0; name[source]; source++) { | |
| mbs_init(mb_st); | |
| mb_len = Rf_mbrtowc(NULL, name + source, MB_CUR_MAX,&mb_st); | |
| if (mb_len > 1) source += mb_len-1; | |
| else | |
| if (islower(name[source])) search[dest++] = name[source]; | |
| } | |
| /* end the search string */ | |
| search[dest] = '\0'; | |
| } | |
| /* | |
| * Look through the list of siblings of the given object, and | |
| * find a shortcut key from the search string which hasn't already | |
| * been used by some other object. Return the valid shortcut char, | |
| * or else zero if we can't find one. | |
| */ | |
| static int find_shortcut(object me, char *search) | |
| { | |
| int source; | |
| object first, obj; | |
| first = me->parent->child; | |
| for (source = 0; search[source]; source++) | |
| { | |
| int mb_len; | |
| mbstate_t mb_st; | |
| mbs_init(mb_st); | |
| mb_len = Rf_mbrtowc(NULL, search + source, MB_CUR_MAX, &mb_st); | |
| if ( mb_len > 1 ) { | |
| source += mb_len - 1; | |
| } else | |
| /* for each character in the search string */ | |
| /* look through every sibling object */ | |
| for (obj = first; obj; obj = obj->next) | |
| { | |
| if (obj == me) /* at end of list, success! */ | |
| return search[source]; | |
| /* use uppercase comparisons */ | |
| if (obj->shortcut == toupper(search[source])) | |
| break; /* can't use this shortcut */ | |
| } | |
| } | |
| return 0; | |
| } | |
| /* | |
| * Take "Open..." and 'O' and produce the string "Open...\tCtrl+O". | |
| * This function also sets an object's shortcut key, which is the | |
| * underlined letter in a menu item in Windows or X-Windows. | |
| */ | |
| static void setmenustring(object obj, char *buf, const char *name, int key) | |
| { | |
| char search[256]; | |
| int ch, where, source, dest = 0; | |
| char *extra = "\tCtrl+"; | |
| set_search_string(search, name, key); | |
| ch = find_shortcut(obj, search); | |
| if (ch) /* found a valid shortcut key */ | |
| { | |
| obj->shortcut = toupper(ch); /* case-insensitive */ | |
| where = find_char(ch, name); | |
| for (source=0; source < where; source++) | |
| { | |
| int mb_len; | |
| int i; | |
| mbstate_t mb_st; | |
| mbs_init(mb_st); | |
| mb_len = Rf_mbrtowc(NULL, name + source, MB_CUR_MAX, &mb_st); | |
| if ( mb_len > 1 ) { | |
| for (i = 0 ; i < mb_len ; i++) | |
| buf[dest++] = name[source+i]; | |
| source += mb_len-1; | |
| } else if(name[source] == '&') { | |
| /* skip it */ | |
| } else | |
| buf[dest++] = name[source]; | |
| } | |
| buf[dest++] = '&'; | |
| for (; name[source]; source++) | |
| buf[dest++] = name[source]; | |
| } | |
| else /* no shortcut key, just copy the name string except '&' */ | |
| { | |
| for (source = 0; name[source]; source++) | |
| if(name[source] != '&') buf[dest++] = name[source]; | |
| } | |
| if (key) { | |
| for (source=0; extra[source]; source++) | |
| buf[dest++] = extra[source]; | |
| buf[dest++] = key; | |
| } | |
| buf[dest] = '\0'; | |
| } | |
| /* | |
| * Menu functions. | |
| */ | |
| menubar newmenubar(actionfn adjust_menus) | |
| { | |
| object obj; | |
| HMENU hm; | |
| if (! current_window) { | |
| current_window = simple_window(); | |
| show(current_window); | |
| } | |
| hm = CreateMenu(); | |
| obj = new_object(MenubarObject, hm, current_window); | |
| if (obj) { | |
| current_window->menubar = obj; | |
| obj->menubar = NULL; | |
| obj->die = private_delmenu; | |
| obj->id = id++; | |
| obj->action = adjust_menus; | |
| obj->text = new_string("Menubar"); | |
| current_menubar = obj; | |
| SetMenu(current_window->handle, hm); | |
| } | |
| return (menubar) obj; | |
| } | |
| BOOL myAppendMenu(HMENU h, UINT flags, UINT_PTR id, LPCTSTR name) | |
| { | |
| if(localeCP > 0 && (localeCP != GetACP())) { | |
| wchar_t wc[100]; | |
| mbstowcs(wc, name, 100); | |
| return AppendMenuW(h, flags, id, wc); | |
| } else | |
| return AppendMenuA(h, flags, id, name); | |
| } | |
| menu newsubmenu(menu parent, const char *name) | |
| { | |
| object obj; | |
| HMENU hm; | |
| UINT flags = MF_POPUP; | |
| char str[256]; | |
| if (! parent) { | |
| if (! current_menubar) | |
| current_menubar = newmenubar(NULL); | |
| parent = current_menubar; | |
| } | |
| if (! parent) | |
| return NULL; | |
| if (! name) | |
| name = ""; | |
| if (name[0] == '\t') { | |
| name += 1; | |
| flags |= MF_HELP; | |
| } | |
| if (parent->kind == WindowObject) | |
| hm = CreatePopupMenu(); | |
| else | |
| hm = CreateMenu(); | |
| obj = new_object(MenuObject, hm, parent); | |
| if (obj) { | |
| obj->die = private_delmenu; | |
| obj->id = id++; | |
| obj->text = new_string(name); | |
| setmenustring(obj, str, name, 0); | |
| name = str; | |
| current_menu = obj; | |
| } | |
| if (parent->kind != WindowObject) | |
| myAppendMenu(parent->handle, flags, (UINT_PTR) hm, name); | |
| if (parent == current_menubar) | |
| DrawMenuBar(current_menubar->parent->handle); | |
| return (menu) obj; | |
| } | |
| menu newmenu(const char *name) | |
| { | |
| return newsubmenu(current_menubar, name); | |
| } | |
| menuitem newmenuitem(const char *name, int key, menufn fn) | |
| { | |
| object obj; | |
| UINT flags; | |
| char str[256]; | |
| if (! current_menu) | |
| current_menu = newmenu("Special"); | |
| if (! current_menu) | |
| return NULL; | |
| if (! name) | |
| name = "-"; /* separator */ | |
| key = toupper(key); /* make it uppercase */ | |
| obj = new_object(MenuitemObject, 0, current_menu); | |
| if (obj) { | |
| obj->die = private_delmenu; | |
| obj->id = id++; | |
| obj->key = key; | |
| obj->action = fn; | |
| obj->value = 0; | |
| obj->text = new_string(name); | |
| obj->state |= Enabled; | |
| if (name[0] == '-') { | |
| flags = MF_SEPARATOR; | |
| name = NULL; | |
| } else { | |
| flags = MF_STRING; | |
| setmenustring(obj, str, name, key); | |
| name = str; | |
| } | |
| myAppendMenu(current_menu->handle, flags, obj->id, name); | |
| } | |
| return (menuitem) obj; | |
| } | |
| /* | |
| * Find various parent objects of a menu (or any object). | |
| */ | |
| #if 0 | |
| PROTECTED | |
| object parent_menubar(object obj) | |
| { | |
| while (obj) { | |
| if (obj->kind == MenubarObject) | |
| break; | |
| obj = obj->parent; | |
| } | |
| return obj; | |
| } | |
| PROTECTED | |
| object parent_menu(object obj) | |
| { | |
| while (obj) { | |
| if (obj->kind == MenuObject) | |
| break; | |
| obj = obj->parent; | |
| } | |
| return obj; | |
| } | |
| #endif | |
| /* | |
| * The adjust_menu function is called just after the program | |
| * receives a WM_INITMENU message. This message is sent even if | |
| * the user is attempting to use the system menu, which is nice. | |
| * We use this function to keep menubars and menus up-to-date by | |
| * calling their respective action functions. | |
| */ | |
| PROTECTED | |
| void adjust_menu(WPARAM wParam) | |
| { | |
| object obj; | |
| obj = find_by_handle((HANDLE)wParam); | |
| if (obj) { | |
| activatecontrol(obj); | |
| if (obj->kind == MenubarObject) | |
| DrawMenuBar(obj->parent->handle); | |
| } | |
| } | |
| /* | |
| * Handle the menu selection. wParam is what WM_[SYS]COMMAND sets | |
| * it to i.e. the object id number. The menus will already have | |
| * received WM_INITMENU messages so they will be up-to-date. | |
| */ | |
| PROTECTED | |
| void handle_menu_id (WPARAM wParam) | |
| { | |
| object obj; | |
| obj = find_by_id(wParam); | |
| if (obj) | |
| activatecontrol(obj); | |
| } | |
| /* | |
| * Handle a menu accelerator key. The key will be a normal char, | |
| * in the range of 0..9 or A..Z (not a..z because we use KEYDOWNs). | |
| * Uses a recursive function to call the menu adjustor functions | |
| * in order from menubar down to popup menu. | |
| */ | |
| static void adjust_menus_top_down(object obj) | |
| { | |
| /* Recursively step up the list. */ | |
| if (! obj) | |
| return; | |
| adjust_menus_top_down(obj->parent); | |
| /* Adjust menubar then child menus as we descend. */ | |
| if (obj->kind == MenubarObject) { | |
| activatecontrol(obj); | |
| DrawMenuBar(obj->parent->handle); | |
| } | |
| else if (obj->kind == MenuObject) | |
| activatecontrol(obj); | |
| } | |
| /* Only search for the key within the menus of the focused window. | |
| If key is not found fall through to user's key handler. CJ */ | |
| PROTECTED | |
| int handle_menu_key(WPARAM wParam) | |
| { | |
| object win, obj; | |
| win = find_by_handle(GetFocus()); | |
| if (win) { | |
| if (win->kind != WindowObject) | |
| win = win->parent; | |
| obj = find_by_key(win, wParam); | |
| if (obj) { | |
| adjust_menus_top_down(obj); | |
| if (isenabled(obj)) /* Don't do menu actions which are greyed out. CJ */ | |
| activatecontrol(obj); | |
| return 1; | |
| } | |
| } | |
| return 0; | |
| } |