mouse and key bindings plugins work. segfault somewhere still on shutdown

12 files changed, 510 insertions, 75 deletions

diff --git a/plugins/keyboard/Makefile.am b/plugins/keyboard/Makefile.am
index 983fd39a..b5ab4151 100644
--- a/plugins/keyboard/Makefile.am
+++ b/plugins/keyboard/Makefile.am
@@ -7,9 +7,9 @@ CPPFLAGS=$(XFT_CFLAGS) $(GLIB_CFLAGS) @CPPFLAGS@ \
 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
 
diff --git a/plugins/keyboard/keyboard.c b/plugins/keyboard/keyboard.c
index 05481b53..141bb5b1 100644
--- a/plugins/keyboard/keyboard.c
+++ b/plugins/keyboard/keyboard.c
@@ -5,7 +5,6 @@
 #include "../../kernel/action.h"
 #include "tree.h"
 #include "keyboard.h"
-#include "keyaction.h"
 #include <glib.h>
 
 KeyBindingTree *firstnode;
@@ -21,6 +20,7 @@ static void grab_keys(gboolean grab)
     } 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 @@ static void reset_chains()
     }
 }
 
-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 @@ static void press(ObEvent *e, void *foo)
                     }
                     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 press(ObEvent *e, void *foo)
 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_startup()
 void plugin_shutdown()
 {
     dispatch_register(0, (EventHandler)press, NULL);
-    clearall();
+
+    grab_keys(FALSE);
+    tree_destroy(firstnode);
+    firstnode = NULL;
+    grab_keys(TRUE);
 }
 
diff --git a/plugins/keyboard/keyboard.h b/plugins/keyboard/keyboard.h
index b183fa38..e2406d93 100644
--- a/plugins/keyboard/keyboard.h
+++ b/plugins/keyboard/keyboard.h
@@ -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; 
diff --git a/plugins/keyboard/translate.c b/plugins/keyboard/translate.c
index 75c077fd..d18c604b 100644
--- a/plugins/keyboard/translate.c
+++ b/plugins/keyboard/translate.c
@@ -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 @@ gboolean translate_key(char *str, guint *state, guint *keycode)
     /* 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;
     }
diff --git a/plugins/keyboard/translate.h b/plugins/keyboard/translate.h
index e0d0bae3..4dae9014 100644
--- a/plugins/keyboard/translate.h
+++ b/plugins/keyboard/translate.h
@@ -3,7 +3,6 @@
 
 #include <glib.h>
 
-guint translate_modifier(char *str);
 gboolean translate_key(char *str, guint *state, guint *keycode);
 
 #endif
diff --git a/plugins/keyboard/tree.c b/plugins/keyboard/tree.c
index b7f51888..ab528376 100644
--- a/plugins/keyboard/tree.c
+++ b/plugins/keyboard/tree.c
@@ -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 @@ void tree_destroy(KeyBindingTree *tree)
 	    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;
diff --git a/plugins/mouse/.cvsignore b/plugins/mouse/.cvsignore
index e76ce200..0acc4c51 100644
--- a/plugins/mouse/.cvsignore
+++ b/plugins/mouse/.cvsignore
@@ -4,3 +4,4 @@ Makefile
 Makefile.in
 .libs
 .deps
+translate.lo
diff --git a/plugins/mouse/Makefile.am b/plugins/mouse/Makefile.am
index d2ead23c..dabf8532 100644
--- a/plugins/mouse/Makefile.am
+++ b/plugins/mouse/Makefile.am
@@ -7,9 +7,9 @@ CPPFLAGS=$(XFT_CFLAGS) $(GLIB_CFLAGS) @CPPFLAGS@ \
 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
 
diff --git a/plugins/mouse/mouse.c b/plugins/mouse/mouse.c
index 7b129c89..5dd39db3 100644
--- a/plugins/mouse/mouse.c
+++ b/plugins/mouse/mouse.c
@@ -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);
 }
diff --git a/plugins/mouse/mouse.h b/plugins/mouse/mouse.h
new file mode 100644
index 00000000..04984886
--- /dev/null
+++ b/plugins/mouse/mouse.h
@@ -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
diff --git a/plugins/mouse/translate.c b/plugins/mouse/translate.c
new file mode 100644
index 00000000..8d4b0d49
--- /dev/null
+++ b/plugins/mouse/translate.c
@@ -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;
+}
diff --git a/plugins/mouse/translate.h b/plugins/mouse/translate.h
new file mode 100644
index 00000000..a2fcfc90
--- /dev/null
+++ b/plugins/mouse/translate.h
@@ -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