@@ -1,5 +1,6 @@
 #include "client.h"
 #include "focus.h"
+#include "menu.h"
 #include "stacking.h"
 #include "frame.h"
 #include "framerender.h"
@@ -15,10 +16,6 @@ {
     Action *a = g_new0(Action, 1);
     a->func = func;
 
-    /* deal with pointers */
-    if (func == action_execute)
-        a->data.execute.path = NULL;
-
     return a;
 }
 
@@ -29,6 +26,8 @@
     /* deal with pointers */
     if (a->func == action_execute || a->func == action_restart)
         g_free(a->data.execute.path);
+    else if (a->func == action_showmenu)
+        g_free(a->data.showmenu.name);
 
     g_free(a);
 }
@@ -708,7 +707,8 @@ }
 
 void action_showmenu(union ActionData *data)
 {
-    g_message(__FUNCTION__);
+    menu_show(data->showmenu.name, data->showmenu.x, data->showmenu.y,
+              data->showmenu.c);
 }
 
 static void popup_cycle(Client *c, gboolean hide)

@@ -65,7 +65,9 @@ };
 
 struct ShowMenu {
     Client *c;
-    char *menuName;
+    char *name;
+    int x;
+    int y;
 };
 
 struct CycleWindows {
@@ -87,7 +89,7 @@ struct Desktop desktop;
     struct NextPreviousDesktop nextprevdesktop;
     struct Move move;
     struct Resize resize;
-    struct ShowMenu showMenu;
+    struct ShowMenu showmenu;
     struct CycleWindows cycle;
 };
 

@@ -242,7 +242,7 @@
     a = theme_app_hilite_label;
     a->texture[0].data.text.string = text;
 
-    appearance_minsize(a, sz);
+    appearance_minsize(a, &sz->width, &sz->height);
     sz->width += theme_bevel * 2;
     sz->height += theme_bevel * 2;
 }

@@ -1,15 +1,18 @@
-#include <glib.h>
 #include "menu.h"
-#include <assert.h>
+#include "openbox.h"
+#include "render/theme.h"
 
 GHashTable *menu_hash = NULL;
 
-void menu_destroy_hash_key(const gpointer data)
+#define ENTRY_EVENTMASK (EnterWindowMask | LeaveWindowMask | \
+                         ButtonPressMask | ButtonReleaseMask)
+
+void menu_destroy_hash_key(gpointer data)
 {
     g_free(data);
 }
 
-void menu_free_entries(const Menu *menu)
+void menu_free_entries(Menu *menu)
 {
     GList *it;
 
@@ -19,27 +22,44 @@
     g_list_free(menu->entries);
 }
 
-void menu_destroy_hash_value(const gpointer data)
+void menu_destroy_hash_value(gpointer data)
 {
-    const Menu *del_menu = (Menu *)data;
+    Menu *del_menu = (Menu *)data;
+    MenuRenderData *rd = del_menu->render_data;
+
+    menu_free_entries(del_menu);
 
     g_free(del_menu->label);
     g_free(del_menu->name);
 
-    menu_free_entries(del_menu);
+    appearance_free(rd->a_title);
+    XDestroyWindow(ob_display, rd->title);
+    XDestroyWindow(ob_display, rd->frame);
 }
 
-void menu_entry_free(const MenuEntry *entry)
+void menu_entry_free(MenuEntry *entry)
 {
     g_free(entry->label);
     g_free(entry->render_data);
+    action_free(entry->action);
 }
     
 void menu_startup()
 {
+    Menu *m;
+
     menu_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
                                       menu_destroy_hash_key,
                                       menu_destroy_hash_value);
+    m = menu_new("sex menu", "root", NULL);
+    menu_add_entry(m, menu_entry_new("foo shit etc bleh",
+                                     action_from_string("restart")));
+    menu_add_entry(m, menu_entry_new("more shit",
+                                     action_from_string("restart")));
+    menu_add_entry(m, menu_entry_new("",
+                                     action_from_string("restart")));
+    menu_add_entry(m, menu_entry_new("and yet more",
+                                     action_from_string("restart")));
 }
 
 void menu_shutdown()
@@ -47,39 +67,71 @@ {
     g_hash_table_destroy(menu_hash);
 }
 
-Menu *menu_new(const char *label, const char *name, Menu *parent)
+static Window createWindow(Window parent, unsigned long mask,
+			   XSetWindowAttributes *attrib)
 {
-    Menu *new_menu = g_new0(Menu, 1);
-    new_menu->label = g_strdup(label);
-    new_menu->name = g_strdup(name);
-    new_menu->parent = parent;
+    return XCreateWindow(ob_display, parent, 0, 0, 1, 1, 0,
+			 render_depth, InputOutput, render_visual,
+			 mask, attrib);
+                       
+}
 
-    new_menu->entries = NULL;
-    new_menu->shown = FALSE;
-    new_menu->invalid = FALSE;
+Menu *menu_new(char *label, char *name, Menu *parent)
+{
+    XSetWindowAttributes attrib;
+    Menu *self;
+    MenuRenderData *data;
+
+    self = g_new0(Menu, 1);
+    self->label = g_strdup(label);
+    self->name = g_strdup(name);
+    self->parent = parent;
+
+    self->entries = NULL;
+    self->shown = FALSE;
+    self->invalid = FALSE;
     /* default controllers? */
 
-    g_hash_table_insert(menu_hash, g_strdup(name), new_menu);
-    return new_menu;
+    data = g_new(MenuRenderData, 1);
+
+    attrib.override_redirect = TRUE;
+    data->frame = createWindow(ob_root, CWOverrideRedirect, &attrib);
+    data->title = createWindow(data->frame, 0, &attrib);
+    data->items = createWindow(data->frame, 0, &attrib);
+
+    XSetWindowBorderWidth(ob_display, data->frame, theme_bwidth);
+    XSetWindowBorderWidth(ob_display, data->title, theme_bwidth);
+    XSetWindowBorder(ob_display, data->frame, theme_b_color->pixel);
+    XSetWindowBorder(ob_display, data->title, theme_b_color->pixel);
+
+    XMapWindow(ob_display, data->title);
+    XMapWindow(ob_display, data->items);
+
+    data->a_title = appearance_copy(theme_a_menu_title);
+    data->a_items = appearance_copy(theme_a_menu);
+
+    self->render_data = data;
+
+    g_hash_table_insert(menu_hash, g_strdup(name), self);
+    return self;
 }
 
-void menu_free(const char *name)
+void menu_free(char *name)
 {
     g_hash_table_remove(menu_hash, name);
 }
 
-MenuEntry *menu_entry_new_full(const char *label, Action *action,
-                          const MenuEntryRenderType render_type,
-                          gpointer render_data, gpointer submenu)
+MenuEntry *menu_entry_new_full(char *label, Action *action,
+                               MenuEntryRenderType render_type,
+                               gpointer submenu)
 {
     MenuEntry *menu_entry = g_new(MenuEntry, 1);
 
     menu_entry->label = g_strdup(label);
     menu_entry->render_type = render_type;
-    menu_entry->action.func = action->func;
-    menu_entry->action.data = action->data; /*watch out. copying Client * ptr*/
+    menu_entry->action = action;
 
-    menu_entry->render_data = render_data; /*watch out.*/
+    menu_entry->render_data = NULL;
     menu_entry->submenu = submenu;
 
     return menu_entry;
@@ -87,7 +139,7 @@ }
 
 void menu_entry_set_submenu(MenuEntry *entry, Menu *submenu)
 {
-    assert(entry != NULL);
+    g_assert(entry != NULL);
     
     entry->submenu = submenu;
 
@@ -97,10 +149,95 @@ }
 
 void menu_add_entry(Menu *menu, MenuEntry *entry)
 {
-    assert(menu != NULL && entry != NULL);
+    MenuEntryRenderData *data;
+    XSetWindowAttributes attrib;
+
+    g_assert(menu != NULL && entry != NULL && entry->render_data == NULL);
 
     menu->entries = g_list_append(menu->entries, entry);
     entry->parent = menu;
 
+    data = g_new(MenuEntryRenderData, 1);
+    data->item = createWindow(((MenuRenderData*)menu->render_data)->items,
+                              0, &attrib);
+    XMapWindow(ob_display, data->item);
+    data->a_item = appearance_copy(theme_a_menu_item);
+
+    entry->render_data = data;
+
     menu->invalid = TRUE;
 }
+
+void menu_show(char *name, int x, int y, Client *client)
+{
+    Menu *self;
+    MenuRenderData *data;
+    GList *it;
+    int w = 1;
+    int items_h;
+    int item_h = 0, nitems = 0; /* each item, only one is used */
+    int item_y;
+    int bullet_w;
+
+    self = g_hash_table_lookup(menu_hash, name);
+    if (!self) {
+        g_warning("Attempted to show menu '%s' but it does not exist.",
+                  name);
+        return;
+    }
+
+    data = self->render_data;
+
+    /* set texture data and size them mofos out */
+    data->a_title->texture[0].data.text.string = self->label;
+    appearance_minsize(data->a_title, &data->title_min_w, &data->title_h);
+    data->title_min_w += theme_bevel * 2;
+    data->title_h += theme_bevel * 2;
+    w = MAX(w, data->title_min_w);
+
+    for (it = self->entries; it; it = it->next) {
+        MenuEntryRenderData *r = ((MenuEntry*)it->data)->render_data;
+
+        r->a_item->texture[0].data.text.string = ((MenuEntry*)it->data)->label;
+        appearance_minsize(r->a_item, &r->min_w, &item_h);
+        r->min_w += theme_bevel * 2;
+        item_h += theme_bevel * 2;
+        w = MAX(w, r->min_w);
+        ++nitems;
+    }
+    bullet_w = item_h + theme_bevel;
+    w += 2 * bullet_w;
+    items_h = item_h * nitems;
+
+    /* size appearances */
+    RECT_SET(data->a_title->area, 0, 0, w, data->title_h);
+    RECT_SET(data->a_title->texture[0].position, 0, 0, w, data->title_h);
+    RECT_SET(data->a_items->area, 0, 0, w, items_h);
+    for (it = self->entries; it; it = it->next) {
+        MenuEntryRenderData *r = ((MenuEntry*)it->data)->render_data;
+        RECT_SET(r->a_item->area, 0, 0, w, item_h);
+        RECT_SET(r->a_item->texture[0].position, bullet_w, 0,
+                 w - 2 * bullet_w, item_h);
+    }
+
+    /* size windows and paint the suckers */
+    XMoveResizeWindow(ob_display, data->frame, x, y, w,
+                      data->title_h + items_h);
+    XMoveResizeWindow(ob_display, data->title, -theme_bwidth, -theme_bwidth,
+                      w, data->title_h);
+    paint(data->title, data->a_title);
+    XMoveResizeWindow(ob_display, data->items, 0, data->title_h + theme_bwidth,
+                      w, items_h);
+    paint(data->items, data->a_items);
+    for (item_y = 0, it = self->entries; it; item_y += item_h, it = it->next) {
+        MenuEntryRenderData *r = ((MenuEntry*)it->data)->render_data;
+        XMoveResizeWindow(ob_display, r->item, 0, item_y, w, item_h);
+        r->a_item->surface.data.planar.parent = data->a_items;
+        r->a_item->surface.data.planar.parentx = 0;
+        r->a_item->surface.data.planar.parenty = item_y;
+        paint(r->item, r->a_item);
+    }
+
+
+    XMapWindow(ob_display, data->frame);
+}

@@ -2,6 +2,8 @@ #ifndef __menu_h
 #define __menu_h
 
 #include "action.h"
+#include "render/render.h"
+
 #include <glib.h>
 
 typedef struct Menu {
@@ -14,6 +16,7 @@
     /* ? */
     gboolean shown;
     gboolean invalid;
+    gpointer render_data; /* where the engine can store anything it likes */
 
     struct Menu *parent;
 
@@ -25,6 +28,16 @@ void (*mouseover)( /* some bummu */);
     void (*selected)( /* some bummu */);
 } Menu;
 
+typedef struct MenuRenderData {
+    Window frame;
+    Window title;
+    Appearance *a_title;
+    int title_min_w, title_h;
+    Window items;
+    Appearance *a_items;
+    int item_h;
+} MenuRenderData;
+
 typedef enum MenuEntryRenderType {
     MenuEntryRenderType_None = 0,
     MenuEntryRenderType_Submenu = 1 << 0,
@@ -34,12 +47,11 @@
     MenuEntryRenderType_Other = 1 << 7
 } MenuEntryRenderType;
 
-
 typedef struct {
     char *label;
     Menu *parent;
 
-    Action action;    
+    Action *action;    
     
     MenuEntryRenderType render_type;
     gboolean enabled;
@@ -49,17 +61,28 @@
     Menu *submenu;
 } MenuEntry;
 
-Menu *menu_new(const char *label, const char *name, Menu *parent);
-void menu_free(const char *name);
+typedef struct MenuEntryRenderData {
+    Window item;
+    Appearance *a_item;
+    int min_w;
+} MenuEntryRenderData;
 
-MenuEntry *menu_entry_new_full(const char *label, Action *action,
-                               const MenuEntryRenderType render_type,
-                               gpointer render_data, gpointer submenu);
+void menu_startup();
+void menu_shutdown();
+
+Menu *menu_new(char *label, char *name, Menu *parent);
+void menu_free(char *name);
+
+void menu_show(char *name, int x, int y, Client *client);
+
+MenuEntry *menu_entry_new_full(char *label, Action *action,
+                               MenuEntryRenderType render_type,
+                               gpointer submenu);
 
 #define menu_entry_new(label, action) \
-  menu_entry_new(label, action, MenuEntryRenderType_None, NULL, NULL)
+  menu_entry_new_full(label, action, MenuEntryRenderType_None, NULL)
 
-void menu_entry_free(const MenuEntry *entry);
+void menu_entry_free(MenuEntry *entry);
 
 void menu_entry_set_submenu(MenuEntry *entry, Menu *submenu);
 

@@ -1,5 +1,6 @@
 #include "openbox.h"
 #include "event.h"
+#include "menu.h"
 #include "client.h"
 #include "dispatch.h"
 #include "xerror.h"
@@ -178,6 +179,7 @@ theme = theme_load(config_theme);
         g_free(theme);
         if (!theme) return 1;
 
+        menu_startup();
         frame_startup();
 	focus_startup();
 	screen_startup();
@@ -203,6 +205,7 @@ group_shutdown();
 	screen_shutdown();
 	focus_shutdown();
         frame_shutdown();
+        menu_shutdown();
         grab_shutdown();
 	event_shutdown();
         theme_shutdown();

@@ -82,6 +82,8 @@
         /* these use the argument */
         if (action->func == action_execute || action->func == action_restart)
             action->data.execute.path = g_strdup(arg_str);
+        else if (action->func == action_showmenu)
+            action->data.showmenu.name = g_strdup(arg_str);
         if ((action->func == action_desktop ||
              action->func == action_send_to_desktop) &&
             arg_int)

@@ -105,7 +105,7 @@ }
 }
 
 static void fire_button(MouseAction a, Context context, Client *c, guint state,
-                        guint button)
+                        guint button, int x, int y)
 {
     GSList *it;
     MouseBinding *b;
@@ -123,6 +123,11 @@ b->action[a]->data.any.c = c;
 
         g_assert(!(b->action[a]->func == action_move ||
                    b->action[a]->func == action_resize));
+
+        if (b->action[a]->func == action_showmenu) {
+            b->action[a]->data.showmenu.x = x;
+            b->action[a]->data.showmenu.y = y;
+        }
 
         b->action[a]->func(&b->action[a]->data);
     }
@@ -245,7 +250,8 @@ e->data.x.e->xbutton.window);
 
         fire_button(MouseAction_Press, context,
                     e->data.x.client, e->data.x.e->xbutton.state,
-                    e->data.x.e->xbutton.button);
+                    e->data.x.e->xbutton.button,
+                    e->data.x.e->xbutton.x_root, e->data.x.e->xbutton.y_root);
 
         if (context == Context_Client) {
             /* Replay the event, so it goes to the client*/
@@ -295,15 +301,20 @@ ltime = e->data.x.e->xbutton.time;
         }
         fire_button(MouseAction_Release, context,
                     e->data.x.client, e->data.x.e->xbutton.state,
-                    e->data.x.e->xbutton.button);
+                    e->data.x.e->xbutton.button,
+                    e->data.x.e->xbutton.x_root, e->data.x.e->xbutton.y_root);
         if (click)
             fire_button(MouseAction_Click, context,
                         e->data.x.client, e->data.x.e->xbutton.state,
-                        e->data.x.e->xbutton.button);
+                        e->data.x.e->xbutton.button,
+                        e->data.x.e->xbutton.x_root,
+                        e->data.x.e->xbutton.y_root);
         if (dclick)
             fire_button(MouseAction_DClick, context,
                         e->data.x.client, e->data.x.e->xbutton.state,
-                        e->data.x.e->xbutton.button);
+                        e->data.x.e->xbutton.button,
+                        e->data.x.e->xbutton.x_root,
+                        e->data.x.e->xbutton.y_root);
         break;
 
     case Event_X_MotionNotify:

@@ -99,6 +99,8 @@
         /* these use the argument */
         if (action->func == action_execute || action->func == action_restart)
             action->data.execute.path = g_strdup(arg_str);
+        else if (action->func == action_showmenu)
+            action->data.showmenu.name = g_strdup(arg_str);
         if ((action->func == action_desktop ||
              action->func == action_send_to_desktop) &&
             arg_int)