@@ -1,172 +1,205 @@ 
 #include "client.h"
 #include "stacking.h"
+#include "frame.h"
 #include "screen.h"
+#include "action.h"
 
 #include <glib.h>
 
-void action_execute(char *path)
+Action *action_new(void (*func)(union ActionData *data))
+{
+    Action *a = g_new(Action, 1);
+    a->func = func;
+
+    /* deal with pointers */
+    if (func == action_execute)
+        a->data.execute.path = NULL;
+
+    return a;
+}
+
+void action_free(Action *a)
+{
+    /* deal with pointers */
+    if (a->func == action_execute)
+        g_free(a->data.execute.path);
+
+    g_free(a);
+}
+
+void action_execute(union ActionData *data)
 {
     GError *e;
-    if (!g_spawn_command_line_async(path, &e)) {
-        g_warning("failed to execute '%s': %s", path, e->message);
+    if (!g_spawn_command_line_async(data->execute.path, &e)) {
+        g_warning("failed to execute '%s': %s",
+                  data->execute.path, e->message);
     }
 }
 
-void action_iconify(Client *c)
+void action_iconify(union ActionData *data)
 {
-    client_iconify(c, TRUE, TRUE);
+    client_iconify(data->client.c, TRUE, TRUE);
 }
 
-void action_raise(Client *c)
+void action_raise(union ActionData *data)
 {
-    stacking_raise(c);
+    stacking_raise(data->client.c);
 }
 
-void action_lower(Client *c)
+void action_lower(union ActionData *data)
 {
-    stacking_lower(c);
+    stacking_lower(data->client.c);
 }
 
-void action_close(Client *c)
+void action_close(union ActionData *data)
 {
-    client_close(c);
+    client_close(data->client.c);
 }
 
-void action_shade(Client *c)
+void action_shade(union ActionData *data)
 {
-    client_shade(c, TRUE);
+    client_shade(data->client.c, TRUE);
 }
 
-void action_unshade(Client *c)
+void action_unshade(union ActionData *data)
 {
-    client_shade(c, FALSE);
+    client_shade(data->client.c, FALSE);
 }
 
-void action_toggle_shade(Client *c)
+void action_toggle_shade(union ActionData *data)
 {
-    client_shade(c, !c->shaded);
+    client_shade(data->client.c, !data->client.c->shaded);
 }
 
-void action_toggle_omnipresent(Client *c)
+void action_toggle_omnipresent(union ActionData *data)
 {
-    client_set_desktop(c, c->desktop == DESKTOP_ALL ?
+    client_set_desktop(data->client.c, data->client.c->desktop == DESKTOP_ALL ?
                        screen_desktop : DESKTOP_ALL);
 }
 
-void action_move_relative(Client *c, int dx, int dy)
+void action_move_relative(union ActionData *data)
 {
-    client_configure(c, Corner_TopLeft, c->area.x + dx, c->area.y + dy,
+    Client *c = data->relative.c;
+    client_configure(c, Corner_TopLeft,
+                     c->area.x + data->relative.dx,
+                     c->area.y + data->relative.dy,
                      c->area.width, c->area.height, TRUE, TRUE);
 }
 
-void action_resize_relative(Client *c, int dx, int dy)
+void action_resize_relative(union ActionData *data)
 {
+    Client *c = data->relative.c;
     client_configure(c, Corner_TopLeft, c->area.x, c->area.y,
-                     c->area.width + dx, c->area.height + dy, TRUE, TRUE);
+                     c->area.width + data->relative.dx,
+                     c->area.height + data->relative.dy, TRUE, TRUE);
 }
 
-void action_maximize_full(Client *c)
+void action_maximize_full(union ActionData *data)
 {
-    client_maximize(c, TRUE, 0, TRUE);
+    client_maximize(data->client.c, TRUE, 0, TRUE);
 }
 
-void action_unmaximize_full(Client *c)
+void action_unmaximize_full(union ActionData *data)
 {
-    client_maximize(c, FALSE, 0, TRUE);
+    client_maximize(data->client.c, FALSE, 0, TRUE);
 }
 
-void action_toggle_maximize_full(Client *c)
+void action_toggle_maximize_full(union ActionData *data)
 {
-    client_maximize(c, !(c->max_horz || c->max_vert), 0, TRUE);
+    client_maximize(data->client.c,
+                    !(data->client.c->max_horz || data->client.c->max_vert),
+                    0, TRUE);
 }
 
-void action_maximize_horz(Client *c)
+void action_maximize_horz(union ActionData *data)
 {
-    client_maximize(c, TRUE, 1, TRUE);
+    client_maximize(data->client.c, TRUE, 1, TRUE);
 }
 
-void action_unmaximize_horz(Client *c)
+void action_unmaximize_horz(union ActionData *data)
 {
-    client_maximize(c, FALSE, 1, TRUE);
+    client_maximize(data->client.c, FALSE, 1, TRUE);
 }
 
-void action_toggle_maximize_horz(Client *c)
+void action_toggle_maximize_horz(union ActionData *data)
 {
-    client_maximize(c, !c->max_horz, 1, TRUE);
+    client_maximize(data->client.c, !data->client.c->max_horz, 1, TRUE);
 }
 
-void action_maximize_vert(Client *c)
+void action_maximize_vert(union ActionData *data)
 {
-    client_maximize(c, TRUE, 2, TRUE);
+    client_maximize(data->client.c, TRUE, 2, TRUE);
 }
 
-void action_unmaximize_vert(Client *c)
+void action_unmaximize_vert(union ActionData *data)
 {
-    client_maximize(c, FALSE, 2, TRUE);
+    client_maximize(data->client.c, FALSE, 2, TRUE);
 }
 
-void action_toggle_maximize_vert(Client *c)
+void action_toggle_maximize_vert(union ActionData *data)
 {
-    client_maximize(c, !c->max_vert, 2, TRUE);
+    client_maximize(data->client.c, !data->client.c->max_vert, 2, TRUE);
 }
 
-void action_send_to_desktop(Client *c, guint desktop)
+void action_send_to_desktop(union ActionData *data)
 {
-    if (desktop < screen_num_desktops || desktop == DESKTOP_ALL)
-        client_set_desktop(c, desktop);
+    if (data->sendto.desktop < screen_num_desktops ||
+        data->sendto.desktop == DESKTOP_ALL)
+        client_set_desktop(data->sendto.c, data->sendto.desktop);
 }
 
-void action_send_to_next_desktop(Client *c, gboolean wrap, gboolean follow)
+void action_send_to_next_desktop(union ActionData *data)
 {
     guint d;
 
     d = screen_desktop + 1;
     if (d >= screen_num_desktops) {
-        if (!wrap) return;
+        if (!data->sendtonextprev.wrap) return;
         d = 0;
     }
-    client_set_desktop(c, d);
-    if (follow) screen_set_desktop(d);
+    client_set_desktop(data->sendtonextprev.c, d);
+    if (data->sendtonextprev.follow) screen_set_desktop(d);
 }
 
-void action_send_to_previous_desktop(Client *c, gboolean wrap, gboolean follow)
+void action_send_to_previous_desktop(union ActionData *data)
 {
     guint d;
 
     d = screen_desktop - 1;
     if (d >= screen_num_desktops) {
-        if (!wrap) return;
+        if (!data->sendtonextprev.wrap) return;
         d = screen_num_desktops - 1;
     }
-    client_set_desktop(c, d);
-    if (follow) screen_set_desktop(d);
+    client_set_desktop(data->sendtonextprev.c, d);
+    if (data->sendtonextprev.follow) screen_set_desktop(d);
 }
 
-void action_desktop(guint desktop)
+void action_desktop(union ActionData *data)
 {
-    if (desktop < screen_num_desktops || desktop == DESKTOP_ALL)
-        screen_set_desktop(desktop);
+    if (data->desktop.desk < screen_num_desktops ||
+        data->desktop.desk == DESKTOP_ALL)
+        screen_set_desktop(data->desktop.desk);
 }
 
-void action_next_desktop(gboolean wrap)
+void action_next_desktop(union ActionData *data)
 {
     guint d;
 
     d = screen_desktop + 1;
     if (d >= screen_num_desktops) {
-        if (!wrap) return;
+        if (!data->nextprevdesktop.wrap) return;
         d = 0;
     }
     screen_set_desktop(d);
 }
 
-void action_previous_desktop(gboolean wrap)
+void action_previous_desktop(union ActionData *data)
 {
     guint d;
 
     d = screen_desktop - 1;
     if (d >= screen_num_desktops) {
-        if (!wrap) return;
+        if (!data->nextprevdesktop.wrap) return;
         d = screen_num_desktops - 1;
     }
     screen_set_desktop(d);
@@ -267,7 +300,7 @@ g_assert_not_reached();
     return 0;
 }
 
-void action_next_desktop_column(gboolean wrap)
+void action_next_desktop_column(union ActionData *data)
 {
     guint r, c, d;
 
@@ -275,7 +308,7 @@ cur_row_col(&r, &c);
     ++c;
     d = translate_row_col(r, c);
     if (d >= screen_num_desktops) {
-        if (!wrap) return;
+        if (!data->nextprevdesktop.wrap) return;
         c = 0;
     }
     if (d >= screen_num_desktops)
@@ -285,7 +318,7 @@ if (d < screen_num_desktops)
         screen_set_desktop(d);
 }
 
-void action_previous_desktop_column(gboolean wrap)
+void action_previous_desktop_column(union ActionData *data)
 {
     guint r, c, d;
 
@@ -293,7 +326,7 @@ cur_row_col(&r, &c);
     --c;
     d = translate_row_col(r, c);
     if (d >= screen_num_desktops) {
-        if (!wrap) return;
+        if (!data->nextprevdesktop.wrap) return;
         c = screen_desktop_layout.columns - 1;
     }
     if (d >= screen_num_desktops)
@@ -303,7 +336,7 @@ if (d < screen_num_desktops)
         screen_set_desktop(d);
 }
 
-void action_next_desktop_row(gboolean wrap)
+void action_next_desktop_row(union ActionData *data)
 {
     guint r, c, d;
 
@@ -311,7 +344,7 @@ cur_row_col(&r, &c);
     ++r;
     d = translate_row_col(r, c);
     if (d >= screen_num_desktops) {
-        if (!wrap) return;
+        if (!data->nextprevdesktop.wrap) return;
         r = 0;
     }
     if (d >= screen_num_desktops)
@@ -321,7 +354,7 @@ if (d < screen_num_desktops)
         screen_set_desktop(d);
 }
 
-void action_previous_desktop_row(gboolean wrap)
+void action_previous_desktop_row(union ActionData *data)
 {
     guint r, c, d;
 
@@ -329,7 +362,7 @@ cur_row_col(&r, &c);
     --r;
     d = translate_row_col(r, c);
     if (d >= screen_num_desktops) {
-        if (!wrap) return;
+        if (!data->nextprevdesktop.wrap) return;
         c = screen_desktop_layout.rows - 1;
     }
     if (d >= screen_num_desktops)
@@ -339,8 +372,29 @@ if (d < screen_num_desktops)
         screen_set_desktop(d);
 }
 
-void action_toggle_decorations(Client *c)
+void action_toggle_decorations(union ActionData *data)
 {
+    Client *c = data->client.c;
     c->disabled_decorations = c->disabled_decorations ? 0 : ~0;
     client_setup_decor_and_functions(c);
 }
+
+void action_move(union ActionData *data)
+{
+    Client *c = data->move.c;
+    int x = data->move.x;
+    int y = data->move.y;
+
+    client_configure(c, Corner_TopLeft, x, y, c->area.width, c->area.height,
+                     TRUE, data->move.final);
+}
+
+void action_resize(union ActionData *data)
+{
+    Client *c = data->resize.c;
+    int w = data->resize.x - c->frame->size.left - c->frame->size.right;
+    int h = data->resize.y - c->frame->size.top - c->frame->size.bottom;
+
+    client_configure(c, data->resize.corner, c->area.x, c->area.y, w, h,
+                     TRUE, data->resize.final);
+}

@@ -3,70 +3,155 @@ #define __action_h
 
 #include "client.h"
 
-typedef enum {
-    Action_Execute,
-    Action_Iconify,
-    Action_Raise,
-    Action_Lower,
-    Action_Close,
-    Action_Shade,
-    Action_Unshade,
-    Action_ToggleShade,
-    Action_ToggleOmnipresent,
-    Action_MoveRelative,
-    Action_ResizeRelative,
-    Action_MaximizeFull,
-    Action_UnmaximizeFull,
-    Action_ToggleMaximizeFull,
-    Action_MaximizeHorz,
-    Action_UnmaximizeHorz,
-    Action_ToggleMaximizeHorz,
-    Action_MaximizeVert,
-    Action_UnmaximizeVert,
-    Action_ToggleMaximizeVert,
-    Action_SendToDesktop,
-    Action_SendToNextDesktop,
-    Action_SendToPreviousDesktop,
-    Action_Desktop,
-    Action_NextDesktop,
-    Action_PreviousDesktop,
-    Action_NextDesktopColumn,
-    Action_PreviousDesktopColumn,
-    Action_NextDesktopRow,
-    Action_PreviousDesktopRow,
-    Action_ToggleDecorations
+/* These have to all have a Client* at the top even if they don't use it, so
+   that I can set it blindly later on. So every function will have a Client*
+   available (possibly NULL though) if it wants it.
+*/
+
+struct AnyAction {
+    Client *c;
+};
+
+struct Execute {
+    Client *c;
+    char *path;
+};
+
+struct ClientAction {
+    Client *c;
+};
+
+struct MoveResizeRelative {
+    Client *c;
+    int dx;
+    int dy;
+};
+
+struct SendToDesktop {
+    Client *c;
+    guint desktop;
+};
+
+struct SendToNextPreviousDesktop {
+    Client *c;
+    gboolean wrap;
+    gboolean follow;
+};
+
+struct Desktop {
+    Client *c;
+    guint desk;
+};
+
+struct NextPreviousDesktop {
+    Client *c;
+    gboolean wrap;
+};
+
+struct Move {
+    Client *c;
+    int x;
+    int y;
+    gboolean final;
+};
+
+struct Resize {
+    Client *c;
+    int x;
+    int y;
+    gboolean final;
+    Corner corner;
+};
+
+union ActionData {
+    struct AnyAction any;
+    struct Execute execute;
+    struct ClientAction client;
+    struct MoveResizeRelative relative;
+    struct SendToDesktop sendto;
+    struct SendToNextPreviousDesktop sendtonextprev;
+    struct Desktop desktop;
+    struct NextPreviousDesktop nextprevdesktop;
+    struct Move move;
+    struct Resize resize;
+};
+
+typedef struct {
+    /* The func member acts like an enum to tell which one of the structs in
+       the data union are valid.
+    */
+    void (*func)(union ActionData *data);
+    union ActionData data;
 } Action;
 
-void action_execute(char *path);
-void action_iconify(Client *c);
-void action_raise(Client *c);
-void action_lower(Client *c);
-void action_close(Client *c);
-void action_shade(Client *c);
-void action_unshade(Client *c);
-void action_toggle_shade(Client *c);
-void action_toggle_omnipresent(Client *c);
-void action_move_relative(Client *c, int dx, int dy);
-void action_resize_relative(Client *c, int dx, int dy);
-void action_maximize_full(Client *c);
-void action_unmaximize_full(Client *c);
-void action_toggle_maximize_full(Client *c);
-void action_maximize_horz(Client *c);
-void action_unmaximize_horz(Client *c);
-void action_toggle_maximize_horz(Client *c);
-void action_maximize_vert(Client *c);
-void action_unmaximize_vert(Client *c);
-void action_toggle_maximize_vert(Client *c);
-void action_send_to_desktop(Client *c, guint desktop);
-void action_send_to_next_desktop(Client *c, gboolean wrap, gboolean follow);
-void action_send_to_previous_desktop(Client *c, gboolean wrap,gboolean follow);
-void action_desktop(guint desktop);
-void action_next_desktop(gboolean wrap);
-void action_previous_desktop(gboolean wrap);
-void action_next_desktop_column(gboolean wrap);
-void action_previous_desktop_column(gboolean wrap);
-void action_next_desktop_row(gboolean wrap);
-void action_previous_desktop_row(gboolean wrap);
-void action_toggle_decorations(Client *c);
+Action *action_new(void (*func)(union ActionData *data));
+void action_free(Action *a);
+
+/* Execute */
+void action_execute(union ActionData *data);
+/* ClientAction */
+void action_iconify(union ActionData *data);
+/* ClientAction */
+void action_raise(union ActionData *data);
+/* ClientAction */
+void action_lower(union ActionData *data);
+/* ClientAction */
+void action_close(union ActionData *data);
+/* ClientAction */
+void action_shade(union ActionData *data);
+/* ClientAction */
+void action_unshade(union ActionData *data);
+/* ClientAction */
+void action_toggle_shade(union ActionData *data);
+/* ClientAction */
+void action_toggle_omnipresent(union ActionData *data);
+/* MoveResizeRelative */
+void action_move_relative(union ActionData *data);
+/* MoveResizeRelative */
+void action_resize_relative(union ActionData *data);
+/* ClientAction */
+void action_maximize_full(union ActionData *data);
+/* ClientAction */
+void action_unmaximize_full(union ActionData *data);
+/* ClientAction */
+void action_toggle_maximize_full(union ActionData *data);
+/* ClientAction */
+void action_maximize_horz(union ActionData *data);
+/* ClientAction */
+void action_unmaximize_horz(union ActionData *data);
+/* ClientAction */
+void action_toggle_maximize_horz(union ActionData *data);
+/* ClientAction */
+void action_maximize_vert(union ActionData *data);
+/* ClientAction */
+void action_unmaximize_vert(union ActionData *data);
+/* ClientAction */
+void action_toggle_maximize_vert(union ActionData *data);
+/* SendToDesktop */
+void action_send_to_desktop(union ActionData *data);
+/* SendToNextPreviousDesktop */
+void action_send_to_next_desktop(union ActionData *data);
+/* SendToNextPreviousDesktop */
+void action_send_to_previous_desktop(union ActionData *data);
+/* Desktop */
+void action_desktop(union ActionData *data);
+/* NextPreviousDesktop */
+void action_next_desktop(union ActionData *data);
+/* NextPreviousDesktop */
+void action_previous_desktop(union ActionData *data);
+/* NextPreviousDesktop */
+void action_next_desktop_column(union ActionData *data);
+/* NextPreviousDesktop */
+void action_previous_desktop_column(union ActionData *data);
+/* NextPreviousDesktop */
+void action_next_desktop_row(union ActionData *data);
+/* NextPreviousDesktop */
+void action_previous_desktop_row(union ActionData *data);
+/* ClientAction */
+void action_toggle_decorations(union ActionData *data);
+/* Move */
+void action_move(union ActionData *data);
+/* Resize */
+void action_resize(union ActionData *data);
 
 #endif

@@ -21,7 +21,7 @@ {
     if (grab) {
         if (pgrabs++ == 0)
             XGrabPointer(ob_display, ob_root, False, 0, GrabModeAsync,
-                         GrabModeSync, FALSE, cur, CurrentTime);
+                         GrabModeAsync, FALSE, cur, CurrentTime);
     } else if (pgrabs > 0) {
         if (--pgrabs == 0)
             XUngrabPointer(ob_display, CurrentTime);

@@ -7,9 +7,9 @@ 
 plugin_LTLIBRARIES=keyboard.la
 
 keyboard_la_LDFLAGS=-module -avoid-version
-keyboard_la_SOURCES=keyboard.c tree.c translate.c keyaction.c
+keyboard_la_SOURCES=keyboard.c tree.c translate.c
 
-noinst_HEADERS=keyboard.h tree.h translate.h keyaction.h
+noinst_HEADERS=keyboard.h tree.h translate.h
 
 MAINTAINERCLEANFILES= Makefile.in
 

@@ -5,7 +5,6 @@ #include "../../kernel/grab.h"
 #include "../../kernel/action.h"
 #include "tree.h"
 #include "keyboard.h"
-#include "keyaction.h"
 #include <glib.h>
 
 KeyBindingTree *firstnode;
@@ -21,6 +20,7 @@ XUngrabKey(ob_display, AnyKey, AnyModifier, ob_root);
     } else {
 	KeyBindingTree *p = firstnode;
 	while (p) {
+            /* XXX grab all lock keys too */
 	    XGrabKey(ob_display, p->key, p->state, ob_root, FALSE,
 		     GrabModeAsync, GrabModeSync);
 	    p = p->next_sibling;
@@ -38,56 +38,43 @@ grab_keyboard(FALSE);
     }
 }
 
-static void clearall()
-{
-    grab_keys(FALSE);
-    tree_destroy(firstnode);
-    firstnode = NULL;
-    grab_keys(TRUE);
-}
-
-static gboolean bind(GList *keylist, KeyAction *action)
+static gboolean kbind(GList *keylist, Action *action)
 {
     KeyBindingTree *tree, *t;
     gboolean conflict;
+
+    g_assert(keylist != NULL);
+    g_assert(action != NULL);
 
     if (!(tree = tree_build(keylist))) {
         g_warning("invalid binding");
         return FALSE;
     }
-
-    t = tree_find(tree, &conflict);
-    if (conflict) {
-        g_warning("conflict with binding");
+    if ((t = tree_find(tree, &conflict)) != NULL) {
+	/* already bound to something */
+	g_warning("keychain is already bound");
         tree_destroy(tree);
         return FALSE;
     }
-    if (t != NULL) {
-	/* already bound to something */
-	g_warning("keychain is already bound");
+    if (conflict) {
+        g_warning("conflict with binding");
         tree_destroy(tree);
         return FALSE;
     }
 
-    /* grab the server here to make sure no key pressed go missed */
+    /* grab the server here to make sure no key presses go missed */
     grab_server(TRUE);
-
     grab_keys(FALSE);
 
-    /* set the function */
+    /* set the action */
     t = tree;
     while (t->first_child) t = t->first_child;
-    t->action.action = action->action;
-    t->action.type[0] = action->type[0];
-    t->action.type[1] = action->type[1];
-    t->action.data[0] = action->data[0];
-    t->action.data[1] = action->data[1];
-
-    /* assimilate this built tree into the main tree */
-    tree_assimilate(tree); /* assimilation destroys/uses the tree */
+    t->action = action;
+    /* assimilate this built tree into the main tree. assimilation
+       destroys/uses the tree */
+    tree_assimilate(tree);
 
     grab_keys(TRUE); 
-
     grab_server(FALSE);
 
     return TRUE;
@@ -117,7 +104,14 @@ XAllowEvents(ob_display, AsyncKeyboard, CurrentTime);
                     }
                     curpos = p;
                 } else {
-                    keyaction_do(&p->action, focus_client);
+                    if (p->action->func != NULL) {
+                        p->action->data.any.c = focus_client;
+
+                        g_assert(!(p->action->func == action_move ||
+                                   p->action->func == action_resize));
+
+                        p->action->func(&p->action->data);
+                    }
 
                     XAllowEvents(ob_display, AsyncKeyboard, CurrentTime);
                     reset_chains();
@@ -132,49 +126,47 @@ 
 static void binddef()
 {
     GList *list = g_list_append(NULL, NULL);
-    KeyAction a;
+    Action *a;
+
+    /* When creating an Action struct, all of the data elements in the
+       appropriate struct need to be set, except the Client*, which will be set
+       at call-time when then action function is used.
+    */
 
     list->data = "C-Right";
-    a.action = Action_NextDesktop;
-    keyaction_set_bool(&a, 0, TRUE);
-    keyaction_set_none(&a, 1);
-    bind(list, &a);
+    a = action_new(action_next_desktop);
+    a->data.nextprevdesktop.wrap = TRUE;
+    kbind(list, a);
 
     list->data = "C-Left";
-    a.action = Action_PreviousDesktop;
-    keyaction_set_bool(&a, 0, TRUE);
-    keyaction_set_none(&a, 1);
-    bind(list, &a);
+    a = action_new(action_previous_desktop);
+    a->data.nextprevdesktop.wrap = TRUE;
+    kbind(list, a);
 
     list->data = "C-1";
-    a.action = Action_Desktop;
-    keyaction_set_uint(&a, 0, 0);
-    keyaction_set_none(&a, 1);
-    bind(list, &a);
+    a = action_new(action_desktop);
+    a->data.desktop.desk = 0;
+    kbind(list, a);
 
-    list->data = "C-2";
-    a.action = Action_Desktop;
-    keyaction_set_uint(&a, 0, 1);
-    keyaction_set_none(&a, 1);
-    bind(list, &a);
+    list->data = "C-2"; 
+    a = action_new(action_desktop);
+    a->data.desktop.desk = 1;
+    kbind(list, a);
 
     list->data = "C-3";
-    a.action = Action_Desktop;
-    keyaction_set_uint(&a, 0, 2);
-    keyaction_set_none(&a, 1);
-    bind(list, &a);
+    a = action_new(action_desktop);
+    a->data.desktop.desk = 2;
+    kbind(list, a);
 
     list->data = "C-4";
-    a.action = Action_Desktop;
-    keyaction_set_uint(&a, 0, 3);
-    keyaction_set_none(&a, 1);
-    bind(list, &a);
+    a = action_new(action_desktop);
+    a->data.desktop.desk = 3;
+    kbind(list, a);
 
     list->data = "C-space";
-    a.action = Action_Execute;
-    keyaction_set_string(&a, 0, "xterm");
-    keyaction_set_none(&a, 1);
-    bind(list, &a);
+    a = action_new(action_execute);
+    a->data.execute.path = g_strdup("xterm");
+    kbind(list, a);
 }
 
 void plugin_startup()
@@ -188,6 +180,10 @@ 
 void plugin_shutdown()
 {
     dispatch_register(0, (EventHandler)press, NULL);
-    clearall();
+
+    grab_keys(FALSE);
+    tree_destroy(firstnode);
+    firstnode = NULL;
+    grab_keys(TRUE);
 }
 

@@ -1,14 +1,15 @@ 
 #ifndef __plugin_keyboard_keybaord_h
 #define __plugin_keyboard_keybaord_h
 
-#include "keyaction.h"
 #include <glib.h>
+
+#include "../../kernel/action.h"
 
 typedef struct KeyBindingTree {
     guint state;
     guint key;
     GList *keylist;
-    KeyAction action;
+    Action *action;
 
     /* the next binding in the tree at the same level */
     struct KeyBindingTree *next_sibling; 

@@ -1,9 +1,8 @@ 
 #include "../../kernel/openbox.h"
-#include "keyboard.h"
 #include <glib.h>
 #include <string.h>
 
-guint keyboard_translate_modifier(char *str)
+static guint translate_modifier(char *str)
 {
     if (!strcmp("Mod1", str) || !strcmp("A", str)) return Mod1Mask;
     else if (!strcmp("Mod2", str)) return Mod2Mask;
@@ -36,7 +35,7 @@ 
     /* figure out the mod mask */
     *state = 0;
     for (i = 0; parsed[i] != l; ++i) {
-	guint m = keyboard_translate_modifier(parsed[i]);
+	guint m = translate_modifier(parsed[i]);
 	if (!m) goto translation_fail;
 	*state |= m;
     }

@@ -3,7 +3,6 @@ #define __plugin_keyboard_translate_h
 
 #include <glib.h>
 
-guint translate_modifier(char *str);
 gboolean translate_key(char *str, guint *state, guint *keycode);
 
 #endif

@@ -1,6 +1,5 @@ 
 #include "keyboard.h"
 #include "translate.h"
-#include "keyaction.h"
 #include <glib.h>
 
 void tree_destroy(KeyBindingTree *tree)
@@ -15,7 +14,7 @@ GList *it;
 	    for (it = tree->keylist; it != NULL; it = it->next)
 		g_free(it->data);
 	    g_list_free(tree->keylist);
-            keyaction_free(&tree->action);
+            action_free(tree->action);
 	}
 	g_free(tree);
 	tree = c;

@@ -4,3 +4,4 @@ Makefile
 Makefile.in
 .libs
 .deps
+translate.lo

@@ -7,9 +7,9 @@ 
 plugin_LTLIBRARIES=mouse.la
 
 mouse_la_LDFLAGS=-module -avoid-version
-mouse_la_SOURCES=mouse.c
+mouse_la_SOURCES=mouse.c translate.c
 
-noinst_HEADERS=
+noinst_HEADERS=mouse.h translate.h
 
 MAINTAINERCLEANFILES= Makefile.in
 

@@ -1,29 +1,385 @@ 
+#include "../../kernel/openbox.h"
 #include "../../kernel/dispatch.h"
+#include "../../kernel/action.h"
+#include "../../kernel/client.h"
+#include "../../kernel/frame.h"
+#include "../../kernel/engine.h"
+#include "translate.h"
+#include "mouse.h"
 #include <glib.h>
 
-void my_powerful_function() {}
+/* GData of GSList*s of PointerBinding*s. */
+static GData *bound_contexts;
+
+struct foreach_grab_temp {
+    Client *client;
+    gboolean grab;
+};
+
+static void grab_button(Client *client, guint state, guint button,
+			GQuark context, gboolean grab)
+{
+    Window win;
+    int mode = GrabModeAsync;
+    unsigned int mask;
+
+    if (context == g_quark_try_string("frame")) {
+	win = client->frame->window;
+	mask = ButtonPressMask | ButtonMotionMask | ButtonReleaseMask;
+    } else if (context == g_quark_try_string("client")) {
+	win = client->frame->plate;
+	mode = GrabModeSync; /* this is handled in pointer_event */
+	mask = ButtonPressMask; /* can't catch more than this with Sync mode
+				   the release event is manufactured in
+				   pointer_fire */
+    } else return;
+
+    if (grab)
+        /* XXX grab all lock keys */
+	XGrabButton(ob_display, button, state, win, FALSE, mask, mode,
+		    GrabModeAsync, None, None);
+    else
+        /* XXX ungrab all lock keys */
+	XUngrabButton(ob_display, button, state, win);
+}
+
+static void foreach_grab(GQuark key, gpointer data, gpointer user_data)
+{
+    struct foreach_grab_temp *d = user_data;
+    GSList *it;
+    for (it = data; it != NULL; it = it->next) {
+	MouseBinding *b = it->data;
+ 	grab_button(d->client, b->state, b->button, key, d->grab);
+    }
+}
+  
+static void grab_for_client(Client *client, gboolean grab)
+{
+    struct foreach_grab_temp bt;
+    bt.client = client;
+    bt.grab = grab;
+    g_datalist_foreach(&bound_contexts, foreach_grab, &bt);
+}
+
+static void grab_all_clients(gboolean grab)
+{
+    GSList *it;
+
+    for (it = client_list; it != NULL; it = it->next)
+	grab_for_client(it->data, grab);
+}
+
+static void foreach_clear(GQuark key, gpointer data, gpointer user_data)
+{
+    GSList *it;
+    user_data = user_data;
+    for (it = data; it != NULL; it = it->next) {
+	int i;
+
+        MouseBinding *b = it->data;
+	for (i = 0; i < NUM_MOUSEACTION; ++i)
+            action_free(b->action[i]);
+        g_free(b);
+    }
+    g_slist_free(data);
+}
+
+static void fire_button(MouseAction a, GQuark context, Client *c, guint state,
+                        guint button)
+{
+    GSList *it;
+    MouseBinding *b;
+
+    for (it = g_datalist_id_get_data(&bound_contexts, context);
+         it != NULL; it = it->next) {
+        b = it->data;
+        if (b->state == state && b->button == button)
+            break;
+    }
+    /* if not bound, then nothing to do! */
+    if (it == NULL) return;
+
+    if (b->action[a] != NULL && b->action[a]->func != NULL) {
+        b->action[a]->data.any.c = c;
+
+        g_assert(!(b->action[a]->func == action_move ||
+                   b->action[a]->func == action_resize));
+
+        b->action[a]->func(&b->action[a]->data);
+    }
+}
+
+/* corner should be the opposite corner of the window in which the pointer
+   clicked, Corner_TopLeft if a good default if there is no client */
+static void fire_motion(MouseAction a, GQuark context, Client *c, guint state,
+                        guint button, int cx, int cy, int cw, int ch,
+                        int dx, int dy, gboolean final, Corner corner)
+{
+    GSList *it;
+    MouseBinding *b;
+
+    for (it = g_datalist_id_get_data(&bound_contexts, context);
+         it != NULL; it = it->next) {
+        b = it->data;
+        if (b->state == state && b->button == button)
+		break;
+    }
+    /* if not bound, then nothing to do! */
+    if (it == NULL) return;
+
+    if (b->action[a] != NULL && b->action[a]->func != NULL) {
+        b->action[a]->data.any.c = c;
+
+        if (b->action[a]->func == action_move) {
+            b->action[a]->data.move.x = cx + dx;
+            b->action[a]->data.move.y = cy + dy;
+            b->action[a]->data.move.final = final;
+        } else if (b->action[a]->func == action_resize) {
+            b->action[a]->data.resize.corner = corner;
+            switch (corner) {
+            case Corner_TopLeft:
+                b->action[a]->data.resize.x = cw + dx;
+                b->action[a]->data.resize.y = ch + dy;
+                break;
+            case Corner_TopRight:
+                b->action[a]->data.resize.x = cw - dx;
+                b->action[a]->data.resize.y = ch + dy;
+                break;
+            case Corner_BottomLeft:
+                b->action[a]->data.resize.x = cw + dx;
+                b->action[a]->data.resize.y = ch - dy;
+                break;
+            case Corner_BottomRight:
+                b->action[a]->data.resize.x = cw - dx;
+                b->action[a]->data.resize.y = ch - dy;
+                break;
+            }
+            b->action[a]->data.resize.final = final;
+        }
+        b->action[a]->func(&b->action[a]->data);
+    }
+}
+
+static Corner pick_corner(int x, int y, int cx, int cy, int cw, int ch)
+{
+    if (x - cx < cw / 2) {
+        if (y - cy < ch / 2)
+            return Corner_BottomRight;
+        else
+            return Corner_TopRight;
+    } else {
+        if (y - cy < ch / 2)
+            return Corner_BottomLeft;
+        else
+            return Corner_TopLeft;
+    }
+}
 
 static void event(ObEvent *e, void *foo)
 {
+    static Time ltime;
+    static int px, py, cx, cy, cw, ch, dx, dy;
+    static guint button = 0, lbutton = 0;
+    static gboolean drag = FALSE;
+    static Corner corner = Corner_TopLeft;
+    gboolean click = FALSE;
+    gboolean dclick = FALSE;
+
     switch (e->type) {
+    case Event_Client_Mapped:
+        grab_for_client(e->data.c.client, TRUE);
+        break;
+
+    case Event_Client_Destroy:
+        grab_for_client(e->data.c.client, FALSE);
+        break;
+
     case Event_X_ButtonPress:
+        if (!button) {
+            if (e->data.x.client == NULL)
+                corner = Corner_TopLeft;
+            else {
+                cx = e->data.x.client->frame->area.x;
+                cy = e->data.x.client->frame->area.y;
+                cw = e->data.x.client->frame->area.width;
+                ch = e->data.x.client->frame->area.height;
+                px = e->data.x.e->xbutton.x_root;
+                py = e->data.x.e->xbutton.y_root;
+                corner = pick_corner(px, py, cx, cy, cw, ch);
+                button = e->data.x.e->xbutton.button;
+            }
+        }
+        fire_button(MouseAction_Press,
+                    engine_get_context(e->data.x.client,
+                                       e->data.x.e->xbutton.window),
+                    e->data.x.client, e->data.x.e->xbutton.state,
+                    e->data.x.e->xbutton.button);
         break;
+
     case Event_X_ButtonRelease:
+        if (e->data.x.e->xbutton.button == button) {
+            /* end drags */
+            if (drag) {
+                fire_motion(MouseAction_Motion,
+                            engine_get_context(e->data.x.client,
+                                               e->data.x.e->xbutton.window),
+                            e->data.x.client, e->data.x.e->xbutton.state,
+                            e->data.x.e->xbutton.button,
+                            cx, cy, cw, ch, dx, dy, TRUE, corner);
+            }
+
+            /* clicks are only valid if its released over the window */
+	    if (e->data.x.e->xbutton.x >= 0 && e->data.x.e->xbutton.y >= 0) {
+		int junk;
+		Window wjunk;
+		guint ujunk, w, h;
+		XGetGeometry(ob_display, e->data.x.e->xbutton.window,
+                             &wjunk, &junk, &junk, &w, &h, &ujunk, &ujunk);
+		if (e->data.x.e->xbutton.x < (signed)w &&
+                    e->data.x.e->xbutton.y < (signed)h) {
+		    click =TRUE;
+                    /* double clicks happen if there were 2 in a row! */
+                    if (lbutton == button &&
+                        e->data.x.e->xbutton.time - 300 <= ltime)
+                        dclick = TRUE;
+                }
+                lbutton = button;
+	    } else
+                lbutton = 0;
+
+            button = 0;
+            ltime = e->data.x.e->xbutton.time;
+        }
+        fire_button(MouseAction_Press,
+                    engine_get_context(e->data.x.client,
+                                       e->data.x.e->xbutton.window),
+                    e->data.x.client, e->data.x.e->xbutton.state,
+                    e->data.x.e->xbutton.button);
+        if (click)
+            fire_button(MouseAction_Click,
+                        engine_get_context(e->data.x.client,
+                                           e->data.x.e->xbutton.window),
+                        e->data.x.client, e->data.x.e->xbutton.state,
+                        e->data.x.e->xbutton.button);
+        if (dclick)
+            fire_button(MouseAction_DClick,
+                        engine_get_context(e->data.x.client,
+                                           e->data.x.e->xbutton.window),
+                        e->data.x.client, e->data.x.e->xbutton.state,
+                        e->data.x.e->xbutton.button);
         break;
+
     case Event_X_MotionNotify:
+        if (button) {
+            drag = TRUE;
+            dx = e->data.x.e->xmotion.x_root - px;
+            dy = e->data.x.e->xmotion.y_root - py;
+            fire_motion(MouseAction_Motion,
+                        engine_get_context(e->data.x.client,
+                                           e->data.x.e->xbutton.window),
+                        e->data.x.client, e->data.x.e->xmotion.state,
+                        button, cx, cy, cw, ch, dx, dy, FALSE, corner);
+        }
         break;
+
     default:
         g_assert_not_reached();
     }
 }
 
+static gboolean mbind(char *buttonstr, char *contextstr, MouseAction mact,
+                      Action *action)
+{
+    guint state, button;
+    GQuark context;
+    MouseBinding *b;
+    GSList *it;
+    guint i;
+
+    if (!translate_button(buttonstr, &state, &button)) {
+        g_warning("invalid button");
+        return FALSE;
+    }
+
+    context = g_quark_try_string(contextstr);
+    if (!context) {
+        g_warning("invalid context");
+        return FALSE;
+    }
+
+    for (it = g_datalist_id_get_data(&bound_contexts, context);
+	 it != NULL; it = it->next){
+	b = it->data;
+	if (b->state == state && b->button == button) {
+	    /* already bound */
+            if (b->action[mact] != NULL) {
+                g_warning("duplicate binding");
+                return FALSE;
+            }
+            b->action[mact] = action;
+            return TRUE;
+	}
+    }
+
+    grab_all_clients(FALSE);
+
+    /* add the binding */
+    b = g_new(MouseBinding, 1);
+    b->state = state;
+    b->button = button;
+    for (i = 0; i < NUM_MOUSEACTION; ++i)
+        if (i != mact)
+            b->action[i] = NULL;
+    b->action[mact] = action;
+    g_datalist_id_set_data(&bound_contexts, context, 
+        g_slist_append(g_datalist_id_get_data(&bound_contexts, context), b));
+
+    grab_all_clients(TRUE);
+
+    return TRUE;
+}
+
+static void binddef()
+{
+    Action *a;
+
+    /* When creating an Action struct, all of the data elements in the
+       appropriate struct need to be set, except the Client*, which will be set
+       at call-time when then action function is used.
+
+       For action_move and action_resize, the 'x', 'y', and 'final' data
+       elements should not be set, as they are set at call-time.       
+    */
+
+    a = action_new(action_move);
+    mbind("1", "titlebar", MouseAction_Motion, a);
+    a = action_new(action_move);
+    mbind("1", "handle", MouseAction_Motion, a);
+    a = action_new(action_move);
+    mbind("A-1", "frame", MouseAction_Motion, a);
+
+    a = action_new(action_resize);
+    mbind("1", "blcorner", MouseAction_Motion, a);
+    a = action_new(action_resize);
+    mbind("1", "brcorner", MouseAction_Motion, a);
+    a = action_new(action_resize);
+    mbind("A-3", "frame", MouseAction_Motion, a);
+}
+
 void plugin_startup()
 {
-    dispatch_register(Event_X_ButtonPress | Event_X_ButtonRelease |
+    dispatch_register(Event_Client_Mapped | Event_Client_Destroy |
+                      Event_X_ButtonPress | Event_X_ButtonRelease |
                       Event_X_MotionNotify, (EventHandler)event, NULL);
+
+    /* XXX parse a config */
+    binddef();
 }
 
 void plugin_shutdown()
 {
     dispatch_register(0, (EventHandler)event, NULL);
+
+    grab_all_clients(FALSE);
+    g_datalist_foreach(&bound_contexts, foreach_clear, NULL);
 }

@@ -0,0 +1,21 @@ 
+#ifndef __plugin_mouse_mouse_h
+#define __plugin_mouse_mouse_h
+
+#include "../../kernel/action.h"
+
+typedef enum {
+    MouseAction_Press,
+    MouseAction_Release,
+    MouseAction_Click,
+    MouseAction_DClick,
+    MouseAction_Motion,
+    NUM_MOUSEACTION
+} MouseAction;
+
+typedef struct {
+    guint state;
+    guint button;
+    Action *action[NUM_MOUSEACTION];
+} MouseBinding;
+
+#endif

@@ -0,0 +1,55 @@ 
+#include "../../kernel/openbox.h"
+#include <glib.h>
+#include <string.h>
+#include <stdlib.h>
+
+static guint translate_modifier(char *str)
+{
+    if (!strcmp("Mod1", str) || !strcmp("A", str)) return Mod1Mask;
+    else if (!strcmp("Mod2", str)) return Mod2Mask;
+    else if (!strcmp("Mod3", str)) return Mod3Mask;
+    else if (!strcmp("Mod4", str) || !strcmp("W", str)) return Mod4Mask;
+    else if (!strcmp("Mod5", str)) return Mod5Mask;
+    else if (!strcmp("C", str)) return ControlMask;
+    else if (!strcmp("S", str)) return ShiftMask;
+    g_warning("Invalid modifier '%s' in binding.", str);
+    return 0;
+}
+
+gboolean translate_button(char *str, guint *state, guint *button)
+{
+    char **parsed;
+    char *l;
+    int i;
+    gboolean ret = FALSE;
+
+    parsed = g_strsplit(str, "-", -1);
+    
+    /* first, find the button (last token) */
+    l = NULL;
+    for (i = 0; parsed[i] != NULL; ++i)
+	l = parsed[i];
+    if (l == NULL)
+	goto translation_fail;
+
+    /* figure out the mod mask */
+    *state = 0;
+    for (i = 0; parsed[i] != l; ++i) {
+	guint m = translate_modifier(parsed[i]);
+	if (!m) goto translation_fail;
+	*state |= m;
+    }
+
+    /* figure out the button */
+    *button = atoi(l);
+    if (!*button) {
+	g_warning("Invalid button '%s' in pointer binding.", l);
+	goto translation_fail;
+    }
+
+    ret = TRUE;
+
+translation_fail:
+    g_strfreev(parsed);
+    return ret;
+}

@@ -0,0 +1,8 @@ 
+#ifndef __plugin_mouse_translate_h
+#define __plugin_mouse_translate_h
+
+#include <glib.h>
+
+gboolean translate_button(char *str, guint *state, guint *keycode);
+
+#endif