X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fmenu.c;h=7c49cedbe3d411b22b7fbb0647d7bb37aeeb332d;hb=HEAD;hp=ccf9df9238b1798b33780511cf32742825d90cf8;hpb=ea6258ce0f8b4e7af8d44f2e540eb25ccfe8955b;p=chaz%2Fopenbox diff --git a/openbox/menu.c b/openbox/menu.c index ccf9df92..7c49cedb 100644 --- a/openbox/menu.c +++ b/openbox/menu.c @@ -1,623 +1,812 @@ +/* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*- + + menu.c for the Openbox window manager + Copyright (c) 2006 Mikael Magnusson + Copyright (c) 2003-2007 Dana Jansens + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + See the COPYING file for a copy of the GNU General Public License. +*/ + +#include "debug.h" #include "menu.h" #include "openbox.h" #include "stacking.h" -#include "client.h" #include "grab.h" +#include "client.h" +#include "config.h" +#include "actions.h" #include "screen.h" +#include "menuframe.h" +#include "keyboard.h" #include "geom.h" -#include "plugin.h" #include "misc.h" +#include "client_menu.h" +#include "client_list_menu.h" +#include "client_list_combined_menu.h" +#include "gettext.h" +#include "obt/xml.h" +#include "obt/paths.h" -GHashTable *menu_hash = NULL; -GList *menu_visible = NULL; - -#define FRAME_EVENTMASK (ButtonPressMask |ButtonMotionMask | EnterWindowMask |\ - LeaveWindowMask) -#define TITLE_EVENTMASK (ButtonPressMask | ButtonMotionMask) -#define ENTRY_EVENTMASK (EnterWindowMask | LeaveWindowMask | \ - ButtonPressMask | ButtonReleaseMask) +typedef struct _ObMenuParseState ObMenuParseState; -static void parse_menu(xmlDocPtr doc, xmlNodePtr node, void *data) +struct _ObMenuParseState { - parse_menu_full(doc, node, data, TRUE); + ObMenu *parent; + ObMenu *pipe_creator; +}; + +static GHashTable *menu_hash = NULL; +static ObtXmlInst *menu_parse_inst; +static ObMenuParseState menu_parse_state; +static gboolean menu_can_hide = FALSE; +static guint menu_timeout_id = 0; + +static void menu_destroy_hash_value(ObMenu *self); +static void parse_menu_item(xmlNodePtr node, gpointer data); +static void parse_menu_separator(xmlNodePtr node, gpointer data); +static void parse_menu(xmlNodePtr node, gpointer data); +static gunichar parse_shortcut(const gchar *label, gboolean allow_shortcut, + gchar **strippedlabel, guint *position, + gboolean *always_show); + +void menu_startup(gboolean reconfig) +{ + gboolean loaded = FALSE; + GSList *it; + + menu_hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, + (GDestroyNotify)menu_destroy_hash_value); + + client_list_menu_startup(reconfig); + client_list_combined_menu_startup(reconfig); + client_menu_startup(); + + menu_parse_inst = obt_xml_instance_new(); + + menu_parse_state.parent = NULL; + menu_parse_state.pipe_creator = NULL; + obt_xml_register(menu_parse_inst, "menu", parse_menu, &menu_parse_state); + obt_xml_register(menu_parse_inst, "item", parse_menu_item, + &menu_parse_state); + obt_xml_register(menu_parse_inst, "separator", + parse_menu_separator, &menu_parse_state); + + for (it = config_menu_files; it; it = g_slist_next(it)) { + if (obt_xml_load_config_file(menu_parse_inst, + "openbox", + it->data, + "openbox_menu")) + { + loaded = TRUE; + obt_xml_tree_from_root(menu_parse_inst); + obt_xml_close(menu_parse_inst); + } + else if (obt_xml_load_file(menu_parse_inst, + it->data, + "openbox_menu")) + { + loaded = TRUE; + obt_xml_tree_from_root(menu_parse_inst); + obt_xml_close(menu_parse_inst); + } + else + g_message(_("Unable to find a valid menu file \"%s\""), + (const gchar*)it->data); + } + if (!loaded) { + if (obt_xml_load_config_file(menu_parse_inst, + "openbox", + "menu.xml", + "openbox_menu")) + { + obt_xml_tree_from_root(menu_parse_inst); + obt_xml_close(menu_parse_inst); + } else + g_message(_("Unable to find a valid menu file \"%s\""), + "menu.xml"); + } + + g_assert(menu_parse_state.parent == NULL); } +void menu_shutdown(gboolean reconfig) +{ + obt_xml_instance_unref(menu_parse_inst); + menu_parse_inst = NULL; -void parse_menu_full(xmlDocPtr doc, xmlNodePtr node, void *data, - gboolean newmenu) + menu_frame_hide_all(); + + client_list_combined_menu_shutdown(reconfig); + client_list_menu_shutdown(reconfig); + + g_hash_table_destroy(menu_hash); + menu_hash = NULL; +} + +static gboolean menu_pipe_submenu(gpointer key, gpointer val, gpointer data) { - Action *act; - xmlNodePtr nact; + ObMenu *menu = val; + return menu->pipe_creator != NULL; +} - gchar *id = NULL, *title = NULL, *label = NULL, *plugin; - ObMenu *menu = NULL, *parent; +static void clear_cache(gpointer key, gpointer val, gpointer data) +{ + ObMenu *menu = val; + if (menu->execute) + menu_clear_entries(menu); +} - if (newmenu == TRUE) { - if (!parse_attr_string("id", node->parent, &id)) - goto parse_menu_fail; - if (!parse_attr_string("label", node->parent, &title)) - goto parse_menu_fail; +void menu_clear_pipe_caches(void) +{ + /* delete any pipe menus' submenus */ + g_hash_table_foreach_remove(menu_hash, menu_pipe_submenu, NULL); + /* empty the top level pipe menus */ + g_hash_table_foreach(menu_hash, clear_cache, NULL); +} - g_message("menu label %s", title); +void menu_pipe_execute(ObMenu *self) +{ + gchar *output; + GError *err = NULL; - menu = menu_new(title, id, data ? *((ObMenu**)data) : NULL); + if (!self->execute) + return; + if (self->entries) /* the entries are already created and cached */ + return; - if (data) - *((ObMenu**)data) = menu; - } else { - menu = (ObMenu *)data; + if (!g_spawn_command_line_sync(self->execute, &output, NULL, NULL, &err)) { + g_message(_("Failed to execute command for pipe-menu \"%s\": %s"), + self->execute, err->message); + g_error_free(err); + return; } - - while (node) { - if (!xmlStrcasecmp(node->name, (const xmlChar*) "menu")) { - if (parse_attr_string("plugin", node, &plugin)) { - PluginMenuCreateData data = { - .doc = doc, - .node = node, - .parent = menu - }; - parent = plugin_create(plugin, &data); - g_free(plugin); - } else { - parent = menu; - parse_menu(doc, node->xmlChildrenNode, &parent); - menu_add_entry(menu, menu_entry_new_submenu(parent->label, - parent)); - } - } - else if (!xmlStrcasecmp(node->name, (const xmlChar*) "item")) { - if (parse_attr_string("label", node, &label)) { - if ((nact = parse_find_node("action", node->xmlChildrenNode))) - act = action_parse(doc, nact); - else - act = NULL; - if (act) - menu_add_entry(menu, menu_entry_new(label, act)); - else - menu_add_entry(menu, menu_entry_new_separator(label)); - g_free(label); - } - } - node = node->next; + if (obt_xml_load_mem(menu_parse_inst, output, strlen(output), + "openbox_pipe_menu")) + { + menu_parse_state.pipe_creator = self; + menu_parse_state.parent = self; + obt_xml_tree_from_root(menu_parse_inst); + obt_xml_close(menu_parse_inst); + } else { + g_message(_("Invalid output from pipe-menu \"%s\""), self->execute); } -parse_menu_fail: - g_free(id); - g_free(title); + g_free(output); } -void menu_control_show(ObMenu *self, int x, int y, ObClient *client); - -void menu_destroy_hash_key(ObMenu *menu) +static ObMenu* menu_from_name(gchar *name) { - g_free(menu); + ObMenu *self = NULL; + + g_assert(name != NULL); + + if (!(self = g_hash_table_lookup(menu_hash, name))) + g_message(_("Attempted to access menu \"%s\" but it does not exist"), + name); + return self; } -void menu_destroy_hash_value(ObMenu *self) +#define VALID_SHORTCUT(c) (((c) >= '0' && (c) <= '9') || \ + ((c) >= 'A' && (c) <= 'Z') || \ + ((c) >= 'a' && (c) <= 'z')) + +static gunichar parse_shortcut(const gchar *label, gboolean allow_shortcut, + gchar **strippedlabel, guint *position, + gboolean *always_show) { - GList *it; + gunichar shortcut = 0; - for (it = self->entries; it; it = it->next) - menu_entry_free(it->data); - g_list_free(self->entries); + *position = 0; + *always_show = FALSE; - g_free(self->label); - g_free(self->name); + g_assert(strippedlabel != NULL); + + if (label == NULL) { + *strippedlabel = NULL; + } else { + gchar *i; + gboolean escape; - g_hash_table_remove(window_map, &self->title); - g_hash_table_remove(window_map, &self->frame); - g_hash_table_remove(window_map, &self->items); + *strippedlabel = g_strdup(label); - stacking_remove(self); + /* if allow_shortcut is false, then you can't use the '_', instead you + have to just use the first valid character + */ - RrAppearanceFree(self->a_title); - RrAppearanceFree(self->a_items); - XDestroyWindow(ob_display, self->title); - XDestroyWindow(ob_display, self->frame); - XDestroyWindow(ob_display, self->items); + /* allow __ to escape an underscore */ + i = *strippedlabel; + do { + escape = FALSE; + i = strchr(i, '_'); + if (i && *(i+1) == '_') { + gchar *j; - g_free(self); + /* remove the escape '_' from the string */ + for (j = i; *j != '\0'; ++j) + *j = *(j+1); + + ++i; + escape = TRUE; + } + } while (escape); + + if (allow_shortcut && i != NULL) { + /* there is an underscore in the string */ + + /* you have to use a printable ascii character for shortcuts + don't allow space either, so you can have like "a _ b" + */ + if (VALID_SHORTCUT(*(i+1))) { + shortcut = g_unichar_tolower(g_utf8_get_char(i+1)); + *position = i - *strippedlabel; + *always_show = TRUE; + + /* remove the '_' from the string */ + for (; *i != '\0'; ++i) + *i = *(i+1); + } else if (*(i+1) == '\0') { + /* no default shortcut if the '_' is the last character + (eg. "Exit_") for menu entries that you don't want + to be executed by mistake + */ + *i = '\0'; + } + } else { + /* there is no underscore, so find the first valid character to use + instead */ + + for (i = *strippedlabel; *i != '\0'; ++i) + if (VALID_SHORTCUT(*i)) { + *position = i - *strippedlabel; + shortcut = g_unichar_tolower(g_utf8_get_char(i)); + break; + } + } + } + return shortcut; } -void menu_entry_free(ObMenuEntry *self) +static void parse_menu_item(xmlNodePtr node, gpointer data) { - g_free(self->label); - action_free(self->action); - - g_hash_table_remove(window_map, &self->item); + ObMenuParseState *state = data; + gchar *label; + gchar *icon; + ObMenuEntry *e; + + if (state->parent) { + /* Don't try to extract "icon" attribute if icons in user-defined + menus are not enabled. */ + + if (obt_xml_attr_string_unstripped(node, "label", &label)) { + xmlNodePtr c; + GSList *acts = NULL; + + c = obt_xml_find_node(node->children, "action"); + while (c) { + ObActionsAct *action = actions_parse(c); + if (action) + acts = g_slist_append(acts, action); + c = obt_xml_find_node(c->next, "action"); + } + e = menu_add_normal(state->parent, -1, label, acts, TRUE); + + if (config_menu_show_icons && + obt_xml_attr_string(node, "icon", &icon)) + { + e->data.normal.icon = RrImageNewFromName(ob_rr_icons, icon); - RrAppearanceFree(self->a_item); - RrAppearanceFree(self->a_disabled); - RrAppearanceFree(self->a_hilite); - XDestroyWindow(ob_display, self->item); + if (e->data.normal.icon) + e->data.normal.icon_alpha = 0xff; - g_free(self); + g_free(icon); + } + g_free(label); + } + } } - -void menu_startup() + +static void parse_menu_separator(xmlNodePtr node, gpointer data) { -/* - ObMenu *m; - ObMenu *s; - ObMenu *t; - Action *a; -*/ + ObMenuParseState *state = data; - menu_hash = g_hash_table_new_full(g_str_hash, g_str_equal, - (GDestroyNotify)menu_destroy_hash_key, - (GDestroyNotify)menu_destroy_hash_value); + if (state->parent) { + gchar *label; - parse_register("menu", parse_menu, NULL); - -/* - m = menu_new("sex menu", "root", NULL); - - a = action_from_string("execute"); - a->data.execute.path = g_strdup("xterm"); - menu_add_entry(m, menu_entry_new("xterm", a)); - a = action_from_string("restart"); - menu_add_entry(m, menu_entry_new("restart", a)); - menu_add_entry(m, menu_entry_new_separator("--")); - a = action_from_string("exit"); - menu_add_entry(m, menu_entry_new("exit", a)); -*/ + if (!obt_xml_attr_string_unstripped(node, "label", &label)) + label = NULL; - /* - s = menu_new("subsex menu", "submenu", m); - a = action_from_string("execute"); - a->data.execute.path = g_strdup("xclock"); - menu_add_entry(s, menu_entry_new("xclock", a)); + menu_add_separator(state->parent, -1, label); + g_free(label); + } +} - menu_add_entry(m, menu_entry_new_submenu("subz", s)); +static void parse_menu(xmlNodePtr node, gpointer data) +{ + ObMenuParseState *state = data; + gchar *name = NULL, *title = NULL, *script = NULL; + ObMenu *menu; + ObMenuEntry *e; + gchar *icon; - s = menu_new("empty", "chub", m); - menu_add_entry(m, menu_entry_new_submenu("empty", s)); + if (!obt_xml_attr_string(node, "id", &name)) + goto parse_menu_fail; - s = menu_new("", "s-club", m); - menu_add_entry(m, menu_entry_new_submenu("empty", s)); + if (!g_hash_table_lookup(menu_hash, name)) { + if (!obt_xml_attr_string_unstripped(node, "label", &title)) + goto parse_menu_fail; - s = menu_new(NULL, "h-club", m); - menu_add_entry(m, menu_entry_new_submenu("empty", s)); + if ((menu = menu_new(name, title, TRUE, NULL))) { + menu->pipe_creator = state->pipe_creator; + if (obt_xml_attr_string(node, "execute", &script)) { + menu->execute = obt_paths_expand_tilde(script); + } else { + ObMenu *old; - s = menu_new(NULL, "g-club", m); + old = state->parent; + state->parent = menu; + obt_xml_tree(menu_parse_inst, node->children); + state->parent = old; + } + } + } - a = action_from_string("execute"); - a->data.execute.path = g_strdup("xterm"); - menu_add_entry(s, menu_entry_new("xterm", a)); - a = action_from_string("restart"); - menu_add_entry(s, menu_entry_new("restart", a)); - menu_add_entry(s, menu_entry_new_separator("--")); - a = action_from_string("exit"); - menu_add_entry(s, menu_entry_new("exit", a)); + if (state->parent) { + e = menu_add_submenu(state->parent, -1, name); - menu_add_entry(m, menu_entry_new_submenu("long", s)); - */ -} + if (config_menu_show_icons && + obt_xml_attr_string(node, "icon", &icon)) + { + e->data.submenu.icon = RrImageNewFromName(ob_rr_icons, icon); -void menu_shutdown() -{ - g_hash_table_destroy(menu_hash); -} + if (e->data.submenu.icon) + e->data.submenu.icon_alpha = 0xff; -static Window createWindow(Window parent, unsigned long mask, - XSetWindowAttributes *attrib) -{ - return XCreateWindow(ob_display, parent, 0, 0, 1, 1, 0, - RrDepth(ob_rr_inst), InputOutput, - RrVisual(ob_rr_inst), mask, attrib); - + g_free(icon); + } + } + +parse_menu_fail: + g_free(name); + g_free(title); + g_free(script); } -ObMenu *menu_new_full(char *label, char *name, ObMenu *parent, - menu_controller_show show, menu_controller_update update) +ObMenu* menu_new(const gchar *name, const gchar *title, + gboolean allow_shortcut_selection, gpointer data) { - XSetWindowAttributes attrib; ObMenu *self; - self = g_new0(ObMenu, 1); - self->obwin.type = Window_Menu; - self->label = g_strdup(label); + self = g_slice_new0(ObMenu); self->name = g_strdup(name); - self->parent = parent; - self->open_submenu = NULL; + self->data = data; + + self->shortcut = parse_shortcut(title, allow_shortcut_selection, + &self->title, &self->shortcut_position, + &self->shortcut_always_show); + self->collate_key = g_utf8_collate_key(self->title, -1); + + g_hash_table_replace(menu_hash, self->name, self); - self->entries = NULL; - self->shown = FALSE; - self->invalid = TRUE; + /* Each menu has a single more_menu. When the menu spills past what + can fit on the screen, a new menu frame entry is created from this + more_menu, and a new menu frame for the submenu is created for this + menu, also pointing to the more_menu. - /* default controllers */ - self->show = show; - self->hide = NULL; - self->update = update; - self->mouseover = NULL; - self->selected = NULL; + This can be done multiple times using the same more_menu. - self->plugin = NULL; - self->plugin_data = NULL; + more_menu->more_menu will always be NULL, since there is only 1 for + each menu. */ + self->more_menu = g_slice_new0(ObMenu); + self->more_menu->name = _("More..."); + self->more_menu->title = _("More..."); + self->more_menu->collate_key = "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"; + self->more_menu->data = data; + self->more_menu->shortcut = g_unichar_tolower(g_utf8_get_char("M")); - attrib.override_redirect = TRUE; - attrib.event_mask = FRAME_EVENTMASK; - self->frame = createWindow(RootWindow(ob_display, ob_screen), - CWOverrideRedirect|CWEventMask, &attrib); - attrib.event_mask = TITLE_EVENTMASK; - self->title = createWindow(self->frame, CWEventMask, &attrib); - self->items = createWindow(self->frame, 0, &attrib); + return self; +} - self->a_title = self->a_items = NULL; +static void menu_destroy_hash_value(ObMenu *self) +{ + /* make sure its not visible */ + { + GList *it; + ObMenuFrame *f; + + for (it = menu_frame_visible; it; it = g_list_next(it)) { + f = it->data; + if (f->menu == self) + menu_frame_hide_all(); + } + } - XMapWindow(ob_display, self->title); - XMapWindow(ob_display, self->items); + if (self->destroy_func) + self->destroy_func(self, self->data); - g_hash_table_insert(window_map, &self->frame, self); - g_hash_table_insert(window_map, &self->title, self); - g_hash_table_insert(window_map, &self->items, self); - g_hash_table_insert(menu_hash, g_strdup(name), self); + menu_clear_entries(self); + g_free(self->name); + g_free(self->title); + g_free(self->collate_key); + g_free(self->execute); + g_slice_free(ObMenu, self->more_menu); - stacking_add(MENU_AS_WINDOW(self)); - stacking_raise(MENU_AS_WINDOW(self)); + g_slice_free(ObMenu, self); +} - return self; +void menu_free(ObMenu *menu) +{ + if (menu) + g_hash_table_remove(menu_hash, menu->name); } -void menu_free(char *name) +static gboolean menu_hide_delay_func(gpointer data) { - g_hash_table_remove(menu_hash, name); + menu_can_hide = TRUE; + menu_timeout_id = 0; + return FALSE; /* no repeat */ } -ObMenuEntry *menu_entry_new_full(char *label, Action *action, - ObMenuEntryRenderType render_type, - gpointer submenu) +void menu_show(gchar *name, gint x, gint y, gboolean mouse, ObClient *client) { - ObMenuEntry *menu_entry = g_new0(ObMenuEntry, 1); + ObMenu *self; + ObMenuFrame *frame; - menu_entry->label = g_strdup(label); - menu_entry->render_type = render_type; - menu_entry->action = action; + if (!(self = menu_from_name(name)) || + grab_on_keyboard() || grab_on_pointer()) return; - menu_entry->hilite = FALSE; - menu_entry->enabled = TRUE; + /* if the requested menu is already the top visible menu, then don't + bother */ + if (menu_frame_visible) { + frame = menu_frame_visible->data; + if (frame->menu == self) + return; + } - menu_entry->submenu = submenu; + menu_frame_hide_all(); + + /* clear the pipe menus when showing a new menu */ + menu_clear_pipe_caches(); + + frame = menu_frame_new(self, 0, client); + if (!menu_frame_show_topmenu(frame, x, y, mouse)) + menu_frame_free(frame); + else { + if (!mouse) { + /* select the first entry if it's not a submenu and we opened + * the menu with the keyboard, and skip all headers */ + GList *it = frame->entries; + while (it) { + ObMenuEntryFrame *e = it->data; + if (e->entry->type == OB_MENU_ENTRY_TYPE_NORMAL) { + menu_frame_select(frame, e, FALSE); + break; + } else if (e->entry->type == OB_MENU_ENTRY_TYPE_SEPARATOR) + it = g_list_next(it); + else + break; + } + } - return menu_entry; + /* reset the hide timer */ + if (!mouse) + menu_can_hide = TRUE; + else { + menu_can_hide = FALSE; + if (menu_timeout_id) g_source_remove(menu_timeout_id); + menu_timeout_id = g_timeout_add_full(G_PRIORITY_DEFAULT, + config_menu_hide_delay, + menu_hide_delay_func, + NULL, NULL); + } + } } -void menu_entry_set_submenu(ObMenuEntry *entry, ObMenu *submenu) +gboolean menu_hide_delay_reached(void) { - g_assert(entry != NULL); - - entry->submenu = submenu; - - if(entry->parent != NULL) - entry->parent->invalid = TRUE; + return menu_can_hide; } -void menu_add_entry(ObMenu *menu, ObMenuEntry *entry) +static ObMenuEntry* menu_entry_new(ObMenu *menu, ObMenuEntryType type, gint id) { - XSetWindowAttributes attrib; - - g_assert(menu != NULL); - g_assert(entry != NULL); - g_assert(entry->item == None); + ObMenuEntry *self; - menu->entries = g_list_append(menu->entries, entry); - entry->parent = menu; + g_assert(menu); - attrib.event_mask = ENTRY_EVENTMASK; - entry->item = createWindow(menu->items, CWEventMask, &attrib); - XMapWindow(ob_display, entry->item); + self = g_slice_new0(ObMenuEntry); + self->ref = 1; + self->type = type; + self->menu = menu; + self->id = id; - entry->a_item = entry->a_disabled = entry->a_hilite = NULL; + switch (type) { + case OB_MENU_ENTRY_TYPE_NORMAL: + self->data.normal.enabled = TRUE; + break; + case OB_MENU_ENTRY_TYPE_SUBMENU: + case OB_MENU_ENTRY_TYPE_SEPARATOR: + break; + } - menu->invalid = TRUE; + return self; +} - g_hash_table_insert(window_map, &entry->item, menu); +void menu_entry_ref(ObMenuEntry *self) +{ + ++self->ref; } -void menu_show(char *name, int x, int y, ObClient *client) +void menu_entry_unref(ObMenuEntry *self) { - ObMenu *self; - - self = g_hash_table_lookup(menu_hash, name); - if (!self) { - g_warning("Attempted to show menu '%s' but it does not exist.", - name); - return; - } + if (self && --self->ref == 0) { + switch (self->type) { + case OB_MENU_ENTRY_TYPE_NORMAL: + RrImageUnref(self->data.normal.icon); + g_free(self->data.normal.label); + g_free(self->data.normal.collate_key); + while (self->data.normal.actions) { + actions_act_unref(self->data.normal.actions->data); + self->data.normal.actions = + g_slist_delete_link(self->data.normal.actions, + self->data.normal.actions); + } + break; + case OB_MENU_ENTRY_TYPE_SUBMENU: + RrImageUnref(self->data.submenu.icon); + g_free(self->data.submenu.name); + break; + case OB_MENU_ENTRY_TYPE_SEPARATOR: + g_free(self->data.separator.label); + break; + } - menu_show_full(self, x, y, client); -} + g_slice_free(ObMenuEntry, self); + } +} -void menu_show_full(ObMenu *self, int x, int y, ObClient *client) +void menu_clear_entries(ObMenu *self) { - g_assert(self != NULL); - - menu_render(self); - - self->client = client; - - if (!self->shown) { - if (!(self->parent && self->parent->shown)) { - grab_pointer(TRUE, None); - grab_keyboard(TRUE); +#ifdef DEBUG + /* assert that the menu isn't visible */ + { + GList *it; + ObMenuFrame *f; + + for (it = menu_frame_visible; it; it = g_list_next(it)) { + f = it->data; + g_assert(f->menu != self); } - menu_visible = g_list_append(menu_visible, self); } +#endif - if (self->show) { - self->show(self, x, y, client); - } else { - menu_control_show(self, x, y, client); + while (self->entries) { + menu_entry_unref(self->entries->data); + self->entries = g_list_delete_link(self->entries, self->entries); } + self->more_menu->entries = self->entries; /* keep it in sync */ +} + +void menu_entry_remove(ObMenuEntry *self) +{ + self->menu->entries = g_list_remove(self->menu->entries, self); + menu_entry_unref(self); } -void menu_hide(ObMenu *self) { - if (self->shown) { - XUnmapWindow(ob_display, self->frame); - self->shown = FALSE; - if (self->open_submenu) - menu_hide(self->open_submenu); - if (self->parent && self->parent->open_submenu == self) - self->parent->open_submenu = NULL; +ObMenuEntry* menu_add_normal(ObMenu *self, gint id, const gchar *label, + GSList *actions, gboolean allow_shortcut) +{ + ObMenuEntry *e; - if (!(self->parent && self->parent->shown)) { - grab_keyboard(FALSE); - grab_pointer(FALSE, None); - } - menu_visible = g_list_remove(menu_visible, self); - } + e = menu_entry_new(self, OB_MENU_ENTRY_TYPE_NORMAL, id); + e->data.normal.actions = actions; + + menu_entry_set_label(e, label, allow_shortcut); + + self->entries = g_list_append(self->entries, e); + self->more_menu->entries = self->entries; /* keep it in sync */ + return e; } -void menu_clear(ObMenu *self) { - GList *it; - - for (it = self->entries; it; it = it->next) { - ObMenuEntry *entry = it->data; - menu_entry_free(entry); - } - self->entries = NULL; - self->invalid = TRUE; +ObMenuEntry* menu_get_more(ObMenu *self, guint show_from) +{ + ObMenuEntry *e; + e = menu_entry_new(self, OB_MENU_ENTRY_TYPE_SUBMENU, -1); + /* points to itself */ + e->data.submenu.name = g_strdup(self->name); + e->data.submenu.submenu = self; + e->data.submenu.show_from = show_from; + return e; } +ObMenuEntry* menu_add_submenu(ObMenu *self, gint id, const gchar *submenu) +{ + ObMenuEntry *e; + + e = menu_entry_new(self, OB_MENU_ENTRY_TYPE_SUBMENU, id); + e->data.submenu.name = g_strdup(submenu); -ObMenuEntry *menu_find_entry(ObMenu *menu, Window win) + self->entries = g_list_append(self->entries, e); + self->more_menu->entries = self->entries; /* keep it in sync */ + return e; +} + +ObMenuEntry* menu_add_separator(ObMenu *self, gint id, const gchar *label) { - GList *it; + ObMenuEntry *e; - for (it = menu->entries; it; it = it->next) { - ObMenuEntry *entry = it->data; - if (entry->item == win) - return entry; - } - return NULL; + e = menu_entry_new(self, OB_MENU_ENTRY_TYPE_SEPARATOR, id); + + menu_entry_set_label(e, label, FALSE); + + self->entries = g_list_append(self->entries, e); + self->more_menu->entries = self->entries; /* keep it in sync */ + return e; } -ObMenuEntry *menu_find_entry_by_pos(ObMenu *menu, int x, int y) +void menu_set_show_func(ObMenu *self, ObMenuShowFunc func) { - if (x < 0 || x >= menu->size.width || y < 0 || y >= menu->size.height) - return NULL; + self->show_func = func; +} - y -= menu->title_h + ob_rr_theme->bwidth; - if (y < 0) return NULL; - - g_message ("%d %p", y/menu->item_h, g_list_nth_data(menu->entries, y / menu->item_h)); - return g_list_nth_data(menu->entries, y / menu->item_h); +void menu_set_hide_func(ObMenu *self, ObMenuHideFunc func) +{ + self->hide_func = func; } -void menu_entry_fire(ObMenuEntry *self) +void menu_set_update_func(ObMenu *self, ObMenuUpdateFunc func) { - ObMenu *m; + self->update_func = func; +} - if (self->action) { - self->action->data.any.c = self->parent->client; - self->action->func(&self->action->data); +void menu_set_execute_func(ObMenu *self, ObMenuExecuteFunc func) +{ + self->execute_func = func; + self->more_menu->execute_func = func; /* keep it in sync */ +} - /* hide the whole thing */ - m = self->parent; - while (m->parent) m = m->parent; - menu_hide(m); - } +void menu_set_cleanup_func(ObMenu *self, ObMenuCleanupFunc func) +{ + self->cleanup_func = func; } -/* - Default menu controller action for showing. -*/ +void menu_set_destroy_func(ObMenu *self, ObMenuDestroyFunc func) +{ + self->destroy_func = func; +} -void menu_control_show(ObMenu *self, int x, int y, ObClient *client) +void menu_set_place_func(ObMenu *self, ObMenuPlaceFunc func) { - guint i; - Rect *a = NULL; + self->place_func = func; +} - g_assert(!self->invalid); - - for (i = 0; i < screen_num_monitors; ++i) { - a = screen_physical_area_monitor(i); - if (RECT_CONTAINS(*a, x, y)) +ObMenuEntry* menu_find_entry_id(ObMenu *self, gint id) +{ + ObMenuEntry *ret = NULL; + GList *it; + + for (it = self->entries; it; it = g_list_next(it)) { + ObMenuEntry *e = it->data; + + if (e->id == id) { + ret = e; break; + } } - g_assert(a != NULL); - self->xin_area = i; - - POINT_SET(self->location, - MIN(x, a->x + a->width - 1 - self->size.width), - MIN(y, a->y + a->height - 1 - self->size.height)); - XMoveWindow(ob_display, self->frame, self->location.x, self->location.y); - - if (!self->shown) { - XMapWindow(ob_display, self->frame); - stacking_raise(MENU_AS_WINDOW(self)); - self->shown = TRUE; - } else if (self->shown && self->open_submenu) { - menu_hide(self->open_submenu); - } + return ret; } -void menu_control_mouseover(ObMenuEntry *self, gboolean enter) -{ - int x; - Rect *a; - - self->hilite = enter; - - if (enter) { - if (self->parent->open_submenu && self->submenu - != self->parent->open_submenu) - menu_hide(self->parent->open_submenu); - - if (self->submenu && self->parent->open_submenu != self->submenu) { - self->parent->open_submenu = self->submenu; - - /* shouldn't be invalid since it must be displayed */ - g_assert(!self->parent->invalid); - /* TODO: I don't understand why these bevels should be here. - Something must be wrong in the width calculation */ - x = self->parent->location.x + self->parent->size.width + - ob_rr_theme->bwidth - ob_rr_theme->menu_overlap; - - /* need to get the width. is this bad?*/ - menu_render(self->submenu); - - a = screen_physical_area_monitor(self->parent->xin_area); - - if (self->submenu->size.width + x >= a->x + a->width) - x = self->parent->location.x - self->submenu->size.width - - ob_rr_theme->bwidth + ob_rr_theme->menu_overlap; - - menu_show_full(self->submenu, x, - self->parent->location.y + self->y, - self->parent->client); - } +void menu_find_submenus(ObMenu *self) +{ + GList *it; + + for (it = self->entries; it; it = g_list_next(it)) { + ObMenuEntry *e = it->data; + + if (e->type == OB_MENU_ENTRY_TYPE_SUBMENU) + e->data.submenu.submenu = menu_from_name(e->data.submenu.name); } } -ObMenuEntry *menu_control_keyboard_nav(ObMenuEntry *over, ObKey key) +void menu_entry_set_label(ObMenuEntry *self, const gchar *label, + gboolean allow_shortcut) { - GList *it = NULL; - - switch (key) { - case OB_KEY_DOWN: { - if (over != NULL) { - if (over->parent->mouseover) - over->parent->mouseover(over, FALSE); - else - menu_control_mouseover(over, FALSE); - menu_entry_render(over); - - it = over->parent->entries; - while (it != NULL && it->data != over) - it = it->next; - } - - if (it && it->next) - over = (ObMenuEntry *)it->next->data; - else if (over == NULL) { - if (menu_visible && ((ObMenu *)menu_visible->data)->entries) - over = (ObMenuEntry *) - (((ObMenu *)menu_visible->data)->entries)->data; - else - over = NULL; - } else { - over = (over->parent->entries != NULL ? - over->parent->entries->data : NULL); - } - - if (over) { - if (over->parent->mouseover) - over->parent->mouseover(over, TRUE); - else - menu_control_mouseover(over, TRUE); - menu_entry_render(over); - } - + switch (self->type) { + case OB_MENU_ENTRY_TYPE_SEPARATOR: + g_free(self->data.separator.label); + self->data.separator.label = g_strdup(label); break; - } - case OB_KEY_UP: { - if (over != NULL) { - if (over->parent->mouseover) - over->parent->mouseover(over, FALSE); - else - menu_control_mouseover(over, FALSE); - menu_entry_render(over); - - it = g_list_last(over->parent->entries); - while (it != NULL && it->data != over) - it = it->prev; - } - - if (it && it->prev) - over = (ObMenuEntry *)it->prev->data; - else if (over == NULL) { - it = g_list_last(menu_visible); - if (it != NULL) { - it = g_list_last(((ObMenu *)it->data)->entries); - over = (ObMenuEntry *)(it != NULL ? it->data : NULL); - } - } else - over = (over->parent->entries != NULL ? - g_list_last(over->parent->entries)->data : - NULL); - - if (over->parent->mouseover) - over->parent->mouseover(over, TRUE); - else - menu_control_mouseover(over, TRUE); - menu_entry_render(over); + case OB_MENU_ENTRY_TYPE_NORMAL: + g_free(self->data.normal.label); + g_free(self->data.normal.collate_key); + self->data.normal.shortcut = + parse_shortcut(label, allow_shortcut, &self->data.normal.label, + &self->data.normal.shortcut_position, + &self->data.normal.shortcut_always_show); + self->data.normal.collate_key = + g_utf8_collate_key(self->data.normal.label, -1); break; + default: + g_assert_not_reached(); } - case OB_KEY_RETURN: { - if (over == NULL) - return over; +} - if (over->submenu) { - if (over->parent->mouseover) - over->parent->mouseover(over, FALSE); - else - menu_control_mouseover(over, FALSE); - menu_entry_render(over); +void menu_show_all_shortcuts(ObMenu *self, gboolean show) +{ + self->show_all_shortcuts = show; +} - if (over->submenu->entries) - over = over->submenu->entries->data; +static int sort_func(const void *a, const void *b) { + const ObMenuEntry *e[2] = {*(ObMenuEntry**)a, *(ObMenuEntry**)b}; + const gchar *k[2]; + gint i; - if (over->parent->mouseover) - over->parent->mouseover(over, TRUE); - else - menu_control_mouseover(over, TRUE); - menu_entry_render(over); - } + for (i = 0; i < 2; ++i) { + if (e[i]->type == OB_MENU_ENTRY_TYPE_NORMAL) + k[i] = e[i]->data.normal.collate_key; else { - if (over->parent->mouseover) - over->parent->mouseover(over, FALSE); + g_assert(e[i]->type == OB_MENU_ENTRY_TYPE_SUBMENU); + if (e[i]->data.submenu.submenu) + k[i] = e[i]->data.submenu.submenu->collate_key; else - menu_control_mouseover(over, FALSE); - menu_entry_render(over); - - menu_entry_fire(over); + return -1; /* arbitrary really.. the submenu doesn't exist. */ } - break; } - case OB_KEY_ESCAPE: { - if (over != NULL) { - if (over->parent->mouseover) - over->parent->mouseover(over, FALSE); - else - menu_control_mouseover(over, FALSE); - menu_entry_render(over); + return strcmp(k[0], k[1]); +} - menu_hide(over->parent); - } else { - it = g_list_last(menu_visible); - if (it) { - menu_hide((ObMenu *)it->data); - } +/*! + @param start The first entry in the range to sort. + @param end The last entry in the range to sort. +*/ +static void sort_range(ObMenu *self, GList *start, GList *end, guint len) +{ + ObMenuEntry **ar; + GList *it; + guint i; + if (!len) return; + + ar = g_slice_alloc(sizeof(ObMenuEntry*) * len); + for (i = 0, it = start; it != g_list_next(end); ++i, it = g_list_next(it)) + ar[i] = it->data; + qsort(ar, len, sizeof(ObMenuEntry*), sort_func); + for (i = 0, it = start; it != g_list_next(end); ++i, it = g_list_next(it)) + it->data = ar[i]; + g_slice_free1(sizeof(ObMenuEntry*) * len, ar); +} + +void menu_sort_entries(ObMenu *self) +{ + GList *it, *start, *end, *last; + guint len; + + /* need the submenus to know their labels for sorting */ + menu_find_submenus(self); + + start = self->entries; + len = 0; + for (it = self->entries; it; it = g_list_next(it)) { + ObMenuEntry *e = it->data; + if (e->type == OB_MENU_ENTRY_TYPE_SEPARATOR) { + end = g_list_previous(it); + sort_range(self, start, end, len); + + it = g_list_next(it); /* skip over the separator */ + start = it; + len = 0; } - - over = NULL; - break; - } - default: - g_error("Unknown key"); + else + len += 1; + last = it; } - - return over; + sort_range(self, start, last, len); }