X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fmenu.c;h=69a5fe5aa4010d6da5bdbdeb95830a6070c9c2f6;hb=d77c8f62f2f908cfe1d09686a35dce1ccaf65aec;hp=0f2eff429925e1f4744415c32f43e995d0013611;hpb=c90da6da781932c2d178bfb7e39ec1d5003543b7;p=chaz%2Fopenbox diff --git a/openbox/menu.c b/openbox/menu.c index 0f2eff42..69a5fe5a 100644 --- a/openbox/menu.c +++ b/openbox/menu.c @@ -1,611 +1,479 @@ +/* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*- + + menu.c for the Openbox window manager + Copyright (c) 2003 Ben 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 "config.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 "parser/parse.h" -GHashTable *menu_hash = NULL; -GList *menu_visible = NULL; +typedef struct _ObMenuParseState ObMenuParseState; -#define FRAME_EVENTMASK (ButtonPressMask |ButtonMotionMask | EnterWindowMask |\ - LeaveWindowMask) -#define TITLE_EVENTMASK (ButtonPressMask | ButtonMotionMask) -#define ENTRY_EVENTMASK (EnterWindowMask | LeaveWindowMask | \ - ButtonPressMask | ButtonReleaseMask) - -static void parse_menu(xmlDocPtr doc, xmlNodePtr node, void *data) +struct _ObMenuParseState +{ + ObMenu *parent; + ObMenu *pipe_creator; +}; + +static GHashTable *menu_hash = NULL; +static ObParseInst *menu_parse_inst; +static ObMenuParseState menu_parse_state; + +static void menu_destroy_hash_value(ObMenu *self); +static void parse_menu_item(ObParseInst *i, xmlDocPtr doc, xmlNodePtr node, + gpointer data); +static void parse_menu_separator(ObParseInst *i, + xmlDocPtr doc, xmlNodePtr node, + gpointer data); +static void parse_menu(ObParseInst *i, xmlDocPtr doc, xmlNodePtr node, + gpointer data); + +static void client_dest(ObClient *client, gpointer data) { - parse_menu_full(doc, node, data, TRUE); + /* menus can be associated with a client, so close any that are since + we are disappearing now */ + menu_frame_hide_all_client(client); } - -void parse_menu_full(xmlDocPtr doc, xmlNodePtr node, void *data, - gboolean newmenu) +void menu_startup(gboolean reconfig) { - ObAction *act; - xmlNodePtr nact; + xmlDocPtr doc; + xmlNodePtr node; + gboolean loaded = FALSE; + GSList *it; - gchar *id = NULL, *title = NULL, *label = NULL, *plugin; - ObMenu *menu = NULL, *parent; + menu_hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, + (GDestroyNotify)menu_destroy_hash_value); - if (newmenu == TRUE) { - if (!parse_attr_string("id", node, &id)) - goto parse_menu_fail; - if (!parse_attr_string("label", node, &title)) - goto parse_menu_fail; - ob_debug("menu label %s\n", title); - - if (parse_attr_string("plugin", node, &plugin)) { - PluginMenuCreateData data; - data.doc = doc; - data.node = node; - data.parent = menu; - - if (plugin_open_reopen(plugin)) - parent = plugin_create(plugin, &data); - g_free(plugin); - } else - menu = menu_new(title, id, data ? *((ObMenu**)data) : NULL); - - if (data) - *((ObMenu**)data) = menu; - } else { - menu = (ObMenu *)data; - } + client_list_menu_startup(reconfig); + client_menu_startup(); - node = node->xmlChildrenNode; - - while (node) { - if (!xmlStrcasecmp(node->name, (const xmlChar*) "menu")) { - if (parse_attr_string("plugin", node, &plugin)) { - PluginMenuCreateData data; - data.doc = doc; - data.node = node; - data.parent = menu; - if (plugin_open_reopen(plugin)) - parent = plugin_create(plugin, &data); - g_free(plugin); - } else { - parent = menu; - parse_menu(doc, node, &parent); - menu_add_entry(menu, menu_entry_new_submenu(parent->label, - parent)); - } + menu_parse_inst = parse_startup(); + + menu_parse_state.parent = NULL; + menu_parse_state.pipe_creator = NULL; + parse_register(menu_parse_inst, "menu", parse_menu, &menu_parse_state); + parse_register(menu_parse_inst, "item", parse_menu_item, + &menu_parse_state); + parse_register(menu_parse_inst, "separator", + parse_menu_separator, &menu_parse_state); + for (it = config_menu_files; it; it = g_slist_next(it)) { + if (parse_load_menu(it->data, &doc, &node)) { + loaded = TRUE; + parse_tree(menu_parse_inst, doc, node->children); + xmlFreeDoc(doc); } - 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); - } + } + if (!loaded) { + if (parse_load_menu("menu.xml", &doc, &node)) { + parse_tree(menu_parse_inst, doc, node->children); + xmlFreeDoc(doc); } - node = node->next; } + + g_assert(menu_parse_state.parent == NULL); -parse_menu_fail: - g_free(id); - g_free(title); + if (!reconfig) + client_add_destructor(client_dest, NULL); } -void menu_control_show(ObMenu *self, int x, int y, ObClient *client); - -void menu_destroy_hash_key(ObMenu *menu) +void menu_shutdown(gboolean reconfig) { - g_free(menu); + if (!reconfig) + client_remove_destructor(client_dest); + + parse_shutdown(menu_parse_inst); + menu_parse_inst = NULL; + + client_list_menu_shutdown(reconfig); + + menu_frame_hide_all(); + g_hash_table_destroy(menu_hash); + menu_hash = NULL; } -void menu_destroy_hash_value(ObMenu *self) +static gboolean menu_pipe_submenu(gpointer key, gpointer val, gpointer data) { - GList *it; + ObMenu *menu = val; + return menu->pipe_creator == data; +} - for (it = self->entries; it; it = it->next) - menu_entry_free(it->data); - g_list_free(self->entries); +void menu_pipe_execute(ObMenu *self) +{ + xmlDocPtr doc; + xmlNodePtr node; + gchar *output; + GError *err = NULL; - g_free(self->label); - g_free(self->name); + if (!self->execute) + return; - g_hash_table_remove(window_map, &self->title); - g_hash_table_remove(window_map, &self->frame); - g_hash_table_remove(window_map, &self->items); + if (!g_spawn_command_line_sync(self->execute, &output, NULL, NULL, &err)) { + g_warning("Failed to execute command for pipe-menu: %s", err->message); + g_error_free(err); + return; + } - stacking_remove(self); + if (parse_load_mem(output, strlen(output), + "openbox_pipe_menu", &doc, &node)) + { + g_hash_table_foreach_remove(menu_hash, menu_pipe_submenu, self); + menu_clear_entries(self); - RrAppearanceFree(self->a_title); - RrAppearanceFree(self->a_items); - XDestroyWindow(ob_display, self->title); - XDestroyWindow(ob_display, self->frame); - XDestroyWindow(ob_display, self->items); + menu_parse_state.pipe_creator = self; + menu_parse_state.parent = self; + parse_tree(menu_parse_inst, doc, node->children); + xmlFreeDoc(doc); + } else { + g_warning("Invalid output from pipe-menu: %s", self->execute); + } - g_free(self); + g_free(output); } -void menu_entry_free(ObMenuEntry *self) +static ObMenu* menu_from_name(gchar *name) { - g_free(self->label); - action_free(self->action); + ObMenu *self = NULL; - g_hash_table_remove(window_map, &self->item); + g_assert(name != NULL); - RrAppearanceFree(self->a_item); - RrAppearanceFree(self->a_disabled); - RrAppearanceFree(self->a_hilite); - RrAppearanceFree(self->a_submenu); - XDestroyWindow(ob_display, self->item); - XDestroyWindow(ob_display, self->submenu_pic); - g_free(self); -} - -void menu_startup() -{ - menu_hash = g_hash_table_new_full(g_str_hash, g_str_equal, - (GDestroyNotify)menu_destroy_hash_key, - (GDestroyNotify)menu_destroy_hash_value); - - parse_register("menu", parse_menu, NULL); + if (!(self = g_hash_table_lookup(menu_hash, name))) + g_warning("Attempted to access menu '%s' but it does not exist.", + name); + return self; +} +static void parse_menu_item(ObParseInst *i, xmlDocPtr doc, xmlNodePtr node, + gpointer data) +{ + ObMenuParseState *state = data; + gchar *label; + + if (state->parent) { + if (parse_attr_string("label", node, &label)) { + GSList *acts = NULL; + + for (node = node->children; node; node = node->next) + if (!xmlStrcasecmp(node->name, (const xmlChar*) "action")) { + ObAction *a = action_parse + (i, doc, node, OB_USER_ACTION_MENU_SELECTION); + if (a) + acts = g_slist_append(acts, a); + } + menu_add_normal(state->parent, -1, label, acts); + g_free(label); + } + } } -void menu_shutdown() +static void parse_menu_separator(ObParseInst *i, + xmlDocPtr doc, xmlNodePtr node, + gpointer data) { - g_hash_table_destroy(menu_hash); + ObMenuParseState *state = data; + + if (state->parent) + menu_add_separator(state->parent, -1); } -static Window createWindow(Window parent, unsigned long mask, - XSetWindowAttributes *attrib) +static void parse_menu(ObParseInst *i, xmlDocPtr doc, xmlNodePtr node, + gpointer data) { - return XCreateWindow(ob_display, parent, 0, 0, 1, 1, 0, - RrDepth(ob_rr_inst), InputOutput, - RrVisual(ob_rr_inst), mask, attrib); - + ObMenuParseState *state = data; + gchar *name = NULL, *title = NULL, *script = NULL; + ObMenu *menu; + + if (!parse_attr_string("id", node, &name)) + goto parse_menu_fail; + + if (!g_hash_table_lookup(menu_hash, name)) { + if (!parse_attr_string("label", node, &title)) + goto parse_menu_fail; + + if ((menu = menu_new(name, title, NULL))) { + menu->pipe_creator = state->pipe_creator; + if (parse_attr_string("execute", node, &script)) { + menu->execute = parse_expand_tilde(script); + } else { + ObMenu *old; + + old = state->parent; + state->parent = menu; + parse_tree(i, doc, node->children); + state->parent = old; + } + } + } + + if (state->parent) + menu_add_submenu(state->parent, -1, name); + +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, - menu_controller_selected selected, - menu_controller_hide hide, - menu_controller_mouseover mouseover) +ObMenu* menu_new(gchar *name, gchar *title, gpointer data) { - XSetWindowAttributes attrib; ObMenu *self; self = g_new0(ObMenu, 1); - self->obwin.type = Window_Menu; - self->label = g_strdup(label); self->name = g_strdup(name); - self->parent = parent; - self->open_submenu = NULL; - self->over = NULL; - - self->entries = NULL; - self->shown = FALSE; - self->invalid = TRUE; - - /* default controllers */ - self->show = (show != NULL ? show : menu_show_full); - self->hide = (hide != NULL ? hide : menu_hide); - self->update = (update != NULL ? update : menu_render); - self->mouseover = (mouseover != NULL ? mouseover : - menu_control_mouseover); - self->selected = (selected != NULL ? selected : menu_entry_fire); - - self->plugin = NULL; - self->plugin_data = NULL; - - 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); - - self->a_title = self->a_items = NULL; - - XMapWindow(ob_display, self->title); - XMapWindow(ob_display, self->items); - - 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); - - stacking_add(MENU_AS_WINDOW(self)); - stacking_raise(MENU_AS_WINDOW(self)); + self->title = g_strdup(title); + self->data = data; - return self; -} + g_hash_table_replace(menu_hash, self->name, self); -void menu_free(char *name) -{ - g_hash_table_remove(menu_hash, name); + return self; } -ObMenuEntry *menu_entry_new_full(char *label, ObAction *action, - ObMenuEntryRenderType render_type, - gpointer submenu) +static void menu_destroy_hash_value(ObMenu *self) { - ObMenuEntry *menu_entry = g_new0(ObMenuEntry, 1); - - menu_entry->label = g_strdup(label); - menu_entry->render_type = render_type; - menu_entry->action = action; + /* 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(); + } + } - menu_entry->hilite = FALSE; - menu_entry->enabled = TRUE; + if (self->destroy_func) + self->destroy_func(self, self->data); - menu_entry->submenu = submenu; + menu_clear_entries(self); + g_free(self->name); + g_free(self->title); + g_free(self->execute); - return menu_entry; + g_free(self); } -void menu_entry_set_submenu(ObMenuEntry *entry, ObMenu *submenu) +void menu_free(ObMenu *menu) { - g_assert(entry != NULL); - - entry->submenu = submenu; - - if(entry->parent != NULL) - entry->parent->invalid = TRUE; + g_hash_table_remove(menu_hash, menu->name); } -void menu_add_entry(ObMenu *menu, ObMenuEntry *entry) +void menu_show(gchar *name, gint x, gint y, ObClient *client) { - XSetWindowAttributes attrib; - - g_assert(menu != NULL); - g_assert(entry != NULL); - g_assert(entry->item == None); - - menu->entries = g_list_append(menu->entries, entry); - entry->parent = menu; + ObMenu *self; + ObMenuFrame *frame; + guint i; - attrib.event_mask = ENTRY_EVENTMASK; - entry->item = createWindow(menu->items, CWEventMask, &attrib); - entry->submenu_pic = createWindow(menu->items, CWEventMask, &attrib); - XMapWindow(ob_display, entry->item); - XMapWindow(ob_display, entry->submenu_pic); + if (!(self = menu_from_name(name)) + || keyboard_interactively_grabbed()) return; - entry->a_item = entry->a_disabled = entry->a_hilite = entry->a_submenu - = NULL; + /* 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->invalid = TRUE; + menu_frame_hide_all(); - g_hash_table_insert(window_map, &entry->item, menu); - g_hash_table_insert(window_map, &entry->submenu_pic, menu); + frame = menu_frame_new(self, client); + if (client && x < 0 && y < 0) { + x = client->frame->area.x + client->frame->size.left; + y = client->frame->area.y + client->frame->size.top; + menu_frame_move(frame, x, y); + } else + menu_frame_move(frame, + x - ob_rr_theme->bwidth, y - ob_rr_theme->bwidth); + for (i = 0; i < screen_num_monitors; ++i) { + Rect *a = screen_physical_area_monitor(i); + if (RECT_CONTAINS(*a, x, y)) { + frame->monitor = i; + break; + } + } + if (!menu_frame_show(frame, NULL)) + menu_frame_free(frame); + else if (frame->entries) { + ObMenuEntryFrame *e = frame->entries->data; + if (e->entry->type == OB_MENU_ENTRY_TYPE_NORMAL && + e->entry->data.normal.enabled) + menu_frame_select(frame, e); + } } -void menu_show(char *name, int x, int y, ObClient *client) +static ObMenuEntry* menu_entry_new(ObMenu *menu, ObMenuEntryType type, gint id) { - 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; - } + ObMenuEntry *self; - menu_show_full(self, x, y, client); -} + g_assert(menu); -void menu_show_full(ObMenu *self, int x, int y, ObClient *client) -{ - g_assert(self != NULL); - - self->update(self); - - self->client = client; + self = g_new0(ObMenuEntry, 1); + self->type = type; + self->menu = menu; + self->id = id; - if (!self->shown) { - if (!(self->parent && self->parent->shown)) { - grab_pointer(TRUE, None); - grab_keyboard(TRUE); - } - menu_visible = g_list_append(menu_visible, self); + 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_control_show(self, x, y, client); + return self; } -void menu_hide(ObMenu *self) { - if (self->shown) { - XUnmapWindow(ob_display, self->frame); - self->shown = FALSE; - if (self->open_submenu) - self->open_submenu->hide(self->open_submenu); - if (self->parent && self->parent->open_submenu == self) { - self->parent->open_submenu = NULL; +void menu_entry_free(ObMenuEntry *self) +{ + if (self) { + switch (self->type) { + case OB_MENU_ENTRY_TYPE_NORMAL: + g_free(self->data.normal.label); + while (self->data.normal.actions) { + action_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: + g_free(self->data.submenu.name); + break; + case OB_MENU_ENTRY_TYPE_SEPARATOR: + break; } - if (!(self->parent && self->parent->shown)) { - grab_keyboard(FALSE); - grab_pointer(FALSE, None); - } - menu_visible = g_list_remove(menu_visible, self); - if (self->over) { - ((ObMenuEntry *)self->over->data)->hilite = FALSE; - menu_entry_render(self->over->data); - self->over = NULL; - } + g_free(self); } } -void menu_clear(ObMenu *self) { - GList *it; - - for (it = self->entries; it; it = it->next) { - ObMenuEntry *entry = it->data; - menu_entry_free(entry); +void menu_clear_entries(ObMenu *self) +{ +#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); + } } - self->entries = NULL; - self->invalid = TRUE; -} +#endif + while (self->entries) { + menu_entry_free(self->entries->data); + self->entries = g_list_delete_link(self->entries, self->entries); + } +} -ObMenuEntry *menu_find_entry(ObMenu *menu, Window win) +void menu_entry_remove(ObMenuEntry *self) { - GList *it; - - for (it = menu->entries; it; it = it->next) { - ObMenuEntry *entry = it->data; - if (entry->item == win) - return entry; - } - return NULL; + self->menu->entries = g_list_remove(self->menu->entries, self); + menu_entry_free(self); } -ObMenuEntry *menu_find_entry_by_submenu(ObMenu *menu, ObMenu *submenu) +ObMenuEntry* menu_add_normal(ObMenu *self, gint id, gchar *label, + GSList *actions) { - GList *it; + ObMenuEntry *e; - for (it = menu->entries; it; it = it->next) { - ObMenuEntry *entry = it->data; - if (entry->submenu == submenu) - return entry; - } - return NULL; + e = menu_entry_new(self, OB_MENU_ENTRY_TYPE_NORMAL, id); + e->data.normal.label = g_strdup(label); + e->data.normal.actions = actions; + + self->entries = g_list_append(self->entries, e); + return e; } -ObMenuEntry *menu_find_entry_by_pos(ObMenu *menu, int x, int y) +ObMenuEntry* menu_add_submenu(ObMenu *self, gint id, gchar *submenu) { - if (x < 0 || x >= menu->size.width || y < 0 || y >= menu->size.height) - return NULL; + ObMenuEntry *e; - y -= menu->title_h + ob_rr_theme->bwidth; - if (y < 0) return NULL; - - ob_debug("%d %p\n", 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); + e = menu_entry_new(self, OB_MENU_ENTRY_TYPE_SUBMENU, id); + e->data.submenu.name = g_strdup(submenu); + + self->entries = g_list_append(self->entries, e); + return e; } -void menu_entry_fire(ObMenuEntry *self, unsigned int button, unsigned int x, - unsigned int y) +ObMenuEntry* menu_add_separator(ObMenu *self, gint id) { - ObMenu *m; - - /* ignore wheel scrolling */ - if (button == 4 || button == 5) return; + ObMenuEntry *e; - if (self->action) { - self->action->data.any.c = self->parent->client; - self->action->func(&self->action->data); + e = menu_entry_new(self, OB_MENU_ENTRY_TYPE_SEPARATOR, id); - /* hide the whole thing */ - m = self->parent; - while (m->parent) m = m->parent; - m->hide(m); - } + self->entries = g_list_append(self->entries, e); + return e; } -/* - Default menu controller action for showing. -*/ - -void menu_control_show(ObMenu *self, int x, int y, ObClient *client) +void menu_set_update_func(ObMenu *self, ObMenuUpdateFunc func) { - guint i; - Rect *a = NULL; - - g_assert(!self->invalid); - - for (i = 0; i < screen_num_monitors; ++i) { - a = screen_physical_area_monitor(i); - if (RECT_CONTAINS(*a, x, y)) - 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) { - self->open_submenu->hide(self->open_submenu); - } + self->update_func = func; } -void menu_control_mouseover(ObMenuEntry *self, gboolean enter) +void menu_set_execute_func(ObMenu *self, ObMenuExecuteFunc func) { - int x; - Rect *a; - ObMenuEntry *e; + self->execute_func = func; +} - g_assert(self != NULL); - - if (enter) { - /* TODO: we prolly don't need open_submenu */ - if (self->parent->open_submenu && self->submenu - != self->parent->open_submenu) - { - e = (ObMenuEntry *) self->parent->over->data; - e->hilite = FALSE; - menu_entry_render(e); - self->parent->open_submenu->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?*/ - self->parent->update(self->submenu); - - a = screen_physical_area_monitor(self->parent->xin_area); - - if (self->submenu->size.width + x >= a->x + a->width) { - int newparentx = a->x + a->width - - self->submenu->size.width - - self->parent->size.width - - ob_rr_theme->bwidth - - ob_rr_theme->menu_overlap; - - x = a->x + a->width - self->submenu->size.width - - ob_rr_theme->menu_overlap; - XWarpPointer(ob_display, None, None, 0, 0, 0, 0, - newparentx - self->parent->location.x, 0); - - menu_show_full(self->parent, newparentx, - self->parent->location.y, self->parent->client); - } - - menu_show_full(self->submenu, x, - self->parent->location.y + self->y, - self->parent->client); - } - self->hilite = TRUE; - self->parent->over = g_list_find(self->parent->entries, self); - - } else - self->hilite = FALSE; - - menu_entry_render(self); +void menu_set_destroy_func(ObMenu *self, ObMenuDestroyFunc func) +{ + self->destroy_func = func; } -void menu_control_keyboard_nav(unsigned int key) +ObMenuEntry* menu_find_entry_id(ObMenu *self, gint id) { - static ObMenu *current_menu = NULL; - ObMenuEntry *e = NULL; - - ObKey obkey = OB_NUM_KEYS; - - /* hrmm. could be fixed */ - if (key == ob_keycode(OB_KEY_DOWN)) - obkey = OB_KEY_DOWN; - else if (key == ob_keycode(OB_KEY_UP)) - obkey = OB_KEY_UP; - else if (key == ob_keycode(OB_KEY_RIGHT)) /* fuck */ - obkey = OB_KEY_RIGHT; - else if (key == ob_keycode(OB_KEY_LEFT)) /* users */ - obkey = OB_KEY_LEFT; - else if (key == ob_keycode(OB_KEY_RETURN)) - obkey = OB_KEY_RETURN; + ObMenuEntry *ret = NULL; + GList *it; - - if (current_menu == NULL) - current_menu = menu_visible->data; - - switch (obkey) { - case OB_KEY_DOWN: { - if (current_menu->over) { - current_menu->mouseover(current_menu->over->data, FALSE); - current_menu->over = (current_menu->over->next != NULL ? - current_menu->over->next : - current_menu->entries); - } - else - current_menu->over = current_menu->entries; + for (it = self->entries; it; it = g_list_next(it)) { + ObMenuEntry *e = it->data; - if (current_menu->over) - current_menu->mouseover(current_menu->over->data, TRUE); - - break; - } - case OB_KEY_UP: { - if (current_menu->over) { - current_menu->mouseover(current_menu->over->data, FALSE); - current_menu->over = (current_menu->over->prev != NULL ? - current_menu->over->prev : - g_list_last(current_menu->entries)); - } else - current_menu->over = g_list_last(current_menu->entries); - - if (current_menu->over) - current_menu->mouseover(current_menu->over->data, TRUE); - - break; - } - case OB_KEY_RIGHT: { - if (current_menu->over == NULL) - return; - e = (ObMenuEntry *)current_menu->over->data; - if (e->submenu) { - current_menu->mouseover(e, TRUE); - current_menu = e->submenu; - current_menu->over = current_menu->entries; - if (current_menu->over) - current_menu->mouseover(current_menu->over->data, TRUE); + if (e->id == id) { + ret = e; + break; } - break; } + return ret; +} - case OB_KEY_RETURN: { - if (current_menu->over == NULL) - return; - e = (ObMenuEntry *)current_menu->over->data; +void menu_find_submenus(ObMenu *self) +{ + GList *it; - current_menu->mouseover(e, FALSE); - current_menu->over = NULL; - /* zero is enter */ - menu_entry_fire(e, 0, 0, 0); - } - - case OB_KEY_LEFT: { - if (current_menu->over != NULL) { - current_menu->mouseover(current_menu->over->data, FALSE); - current_menu->over = NULL; - } - - current_menu->hide(current_menu); + for (it = self->entries; it; it = g_list_next(it)) { + ObMenuEntry *e = it->data; - if (current_menu->parent) - current_menu = current_menu->parent; - - break; - } - default: - ((ObMenu *)menu_visible->data)->hide(menu_visible->data); - current_menu = NULL; + if (e->type == OB_MENU_ENTRY_TYPE_SUBMENU) + e->data.submenu.submenu = menu_from_name(e->data.submenu.name); } - return; -} - -void menu_noop() -{ - /* This noop brought to you by OLS 2003 Email Garden. */ }