X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fevent.c;h=45ae101e7f5a925170efb7fb7829d5509980d15b;hb=567fd15eebdd44e50cef140419dbf7a336708109;hp=f41140eb7cd07477a1a0d71dd5f7a281511a62d4;hpb=c313b219a226c3b968ff312b96120eef0c527d91;p=chaz%2Fopenbox

diff --git a/openbox/event.c b/openbox/event.c
index f41140eb..45ae101e 100644
--- a/openbox/event.c
+++ b/openbox/event.c
@@ -24,8 +24,6 @@
 #include "dock.h"
 #include "actions.h"
 #include "client.h"
-#include "xerror.h"
-#include "prop.h"
 #include "config.h"
 #include "screen.h"
 #include "frame.h"
@@ -34,17 +32,16 @@
 #include "prompt.h"
 #include "menuframe.h"
 #include "keyboard.h"
-#include "modkeys.h"
 #include "mouse.h"
-#include "mainloop.h"
 #include "focus.h"
 #include "focus_cycle.h"
 #include "moveresize.h"
 #include "group.h"
 #include "stacking.h"
-#include "extensions.h"
-#include "translate.h"
 #include "ping.h"
+#include "obt/display.h"
+#include "obt/prop.h"
+#include "obt/keyboard.h"
 
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
@@ -87,18 +84,20 @@ typedef struct
 
 static void event_process(const XEvent *e, gpointer data);
 static void event_handle_root(XEvent *e);
-static gboolean event_handle_menu_keyboard(XEvent *e);
-static gboolean event_handle_menu(XEvent *e);
+static gboolean event_handle_menu_input(XEvent *e);
+static void event_handle_menu(ObMenuFrame *frame, XEvent *e);
+static gboolean event_handle_prompt(ObPrompt *p, XEvent *e);
 static void event_handle_dock(ObDock *s, XEvent *e);
 static void event_handle_dockapp(ObDockApp *app, XEvent *e);
 static void event_handle_client(ObClient *c, XEvent *e);
-static void event_handle_user_input(ObClient *client, XEvent *e);
+static gboolean event_handle_user_input(ObClient *client, XEvent *e);
 static gboolean is_enter_focus_event_ignored(gulong serial);
 static void event_ignore_enter_range(gulong start, gulong end);
 
 static void focus_delay_dest(gpointer data);
 static gboolean focus_delay_cmp(gconstpointer d1, gconstpointer d2);
 static gboolean focus_delay_func(gpointer data);
+static gboolean unfocus_delay_func(gpointer data);
 static void focus_delay_client_dest(ObClient *client, gpointer data);
 
 Time event_curtime = CurrentTime;
@@ -124,9 +123,9 @@ static void ice_watch(IceConn conn, IcePointer data, Bool opening,
 
     if (opening) {
         fd = IceConnectionNumber(conn);
-        ob_main_loop_fd_add(ob_main_loop, fd, ice_handler, conn, NULL);
+        obt_main_loop_fd_add(ob_main_loop, fd, ice_handler, conn, NULL);
     } else {
-        ob_main_loop_fd_remove(ob_main_loop, fd);
+        obt_main_loop_fd_remove(ob_main_loop, fd);
         fd = -1;
     }
 }
@@ -136,7 +135,7 @@ void event_startup(gboolean reconfig)
 {
     if (reconfig) return;
 
-    ob_main_loop_x_add(ob_main_loop, event_process, NULL, NULL);
+    obt_main_loop_x_add(ob_main_loop, event_process, NULL, NULL);
 
 #ifdef USE_SM
     IceAddConnectionWatch(ice_watch, NULL);
@@ -163,9 +162,15 @@ static Window event_get_window(XEvent *e)
     /* pick a window */
     switch (e->type) {
     case SelectionClear:
-        window = RootWindow(ob_display, ob_screen);
+        window = obt_root(ob_screen);
+        break;
+    case CreateNotify:
+        window = e->xcreatewindow.window;
         break;
     case MapRequest:
+        window = e->xmaprequest.window;
+        break;
+    case MapNotify:
         window = e->xmap.window;
         break;
     case UnmapNotify:
@@ -182,7 +187,9 @@ static Window event_get_window(XEvent *e)
         break;
     default:
 #ifdef XKB
-        if (extensions_xkb && e->type == extensions_xkb_event_basep) {
+        if (obt_display_extension_xkb &&
+            e->type == obt_display_extension_xkb_basep)
+        {
             switch (((XkbAnyEvent*)e)->xkb_type) {
             case XkbBellNotify:
                 window = ((XkbBellNotifyEvent*)e)->window;
@@ -192,8 +199,8 @@ static Window event_get_window(XEvent *e)
         } else
 #endif
 #ifdef SYNC
-        if (extensions_sync &&
-            e->type == extensions_sync_event_basep + XSyncAlarmNotify)
+        if (obt_display_extension_sync &&
+            e->type == obt_display_extension_sync_basep + XSyncAlarmNotify)
         {
             window = None;
         } else
@@ -231,8 +238,8 @@ static void event_set_curtime(XEvent *e)
         break;
     default:
 #ifdef SYNC
-        if (extensions_sync &&
-            e->type == extensions_sync_event_basep + XSyncAlarmNotify)
+        if (obt_display_extension_sync &&
+            e->type == obt_display_extension_sync_basep + XSyncAlarmNotify)
         {
             t = ((XSyncAlarmNotifyEvent*)e)->time;
         }
@@ -260,34 +267,34 @@ static void event_hack_mods(XEvent *e)
     switch (e->type) {
     case ButtonPress:
     case ButtonRelease:
-        e->xbutton.state = modkeys_only_modifier_masks(e->xbutton.state);
+        e->xbutton.state = obt_keyboard_only_modmasks(e->xbutton.state);
         break;
     case KeyPress:
-        e->xkey.state = modkeys_only_modifier_masks(e->xkey.state);
+        e->xkey.state = obt_keyboard_only_modmasks(e->xkey.state);
         break;
     case KeyRelease:
 #ifdef XKB
         /* If XKB is present, then the modifiers are all strange from its
            magic.  Our X core protocol stuff won't work, so we use this to
            find what the modifier state is instead. */
-        if (XkbGetState(ob_display, XkbUseCoreKbd, &xkb_state) == Success)
+        if (XkbGetState(obt_display, XkbUseCoreKbd, &xkb_state) == Success)
             e->xkey.state =
-                modkeys_only_modifier_masks(xkb_state.compat_state);
+                obt_keyboard_only_modmasks(xkb_state.compat_state);
         else
 #endif
         {
-            e->xkey.state = modkeys_only_modifier_masks(e->xkey.state);
+            e->xkey.state = obt_keyboard_only_modmasks(e->xkey.state);
             /* remove from the state the mask of the modifier key being
                released, if it is a modifier key being released that is */
-            e->xkey.state &= ~modkeys_keycode_to_mask(e->xkey.keycode);
+            e->xkey.state &= ~obt_keyboard_keycode_to_modmask(e->xkey.keycode);
         }
         break;
     case MotionNotify:
-        e->xmotion.state = modkeys_only_modifier_masks(e->xmotion.state);
+        e->xmotion.state = obt_keyboard_only_modmasks(e->xmotion.state);
         /* compress events */
         {
             XEvent ce;
-            while (XCheckTypedWindowEvent(ob_display, e->xmotion.window,
+            while (XCheckTypedWindowEvent(obt_display, e->xmotion.window,
                                           e->type, &ce)) {
                 e->xmotion.x = ce.xmotion.x;
                 e->xmotion.y = ce.xmotion.y;
@@ -317,7 +324,7 @@ static gboolean wanted_focusevent(XEvent *e, gboolean in_client_only)
 
         /* These are the ones we want.. */
 
-        if (win == RootWindow(ob_display, ob_screen)) {
+        if (win == obt_root(ob_screen)) {
             /* If looking for a focus in on a client, then always return
                FALSE for focus in's to the root window */
             if (in_client_only)
@@ -338,7 +345,7 @@ static gboolean wanted_focusevent(XEvent *e, gboolean in_client_only)
            but has disappeared.
         */
         if (in_client_only) {
-            ObWindow *w = g_hash_table_lookup(window_map, &e->xfocus.window);
+            ObWindow *w = window_find(e->xfocus.window);
             if (!w || !WINDOW_IS_CLIENT(w))
                 return FALSE;
         }
@@ -371,7 +378,7 @@ static gboolean wanted_focusevent(XEvent *e, gboolean in_client_only)
             return FALSE;
 
         /* Focus left the root window revertedto state */
-        if (win == RootWindow(ob_display, ob_screen))
+        if (win == obt_root(ob_screen))
             return FALSE;
 
         /* These are the ones we want.. */
@@ -410,6 +417,7 @@ static void print_focusevent(XEvent *e)
     case NotifyGrab:         modestr="NotifyGrab";         break;
     case NotifyUngrab:       modestr="NotifyUngrab";       break;
     case NotifyWhileGrabbed: modestr="NotifyWhileGrabbed"; break;
+    default:                 g_assert_not_reached();
     }
     switch (detail) {
     case NotifyAncestor:    detailstr="NotifyAncestor";    break;
@@ -420,6 +428,7 @@ static void print_focusevent(XEvent *e)
     case NotifyPointer:     detailstr="NotifyPointer";     break;
     case NotifyPointerRoot: detailstr="NotifyPointerRoot"; break;
     case NotifyDetailNone:  detailstr="NotifyDetailNone";  break;
+    default:                g_assert_not_reached();
     }
 
     if (mode == NotifyGrab || mode == NotifyUngrab)
@@ -427,7 +436,7 @@ static void print_focusevent(XEvent *e)
 
     g_assert(modestr);
     g_assert(detailstr);
-    ob_debug_type(OB_DEBUG_FOCUS, "Focus%s 0x%x mode=%s detail=%s\n",
+    ob_debug_type(OB_DEBUG_FOCUS, "Focus%s 0x%x mode=%s detail=%s",
                   (e->xfocus.type == FocusIn ? "In" : "Out"),
                   win,
                   modestr, detailstr);
@@ -453,43 +462,48 @@ static gboolean event_ignore(XEvent *e, ObClient *client)
 
 static void event_process(const XEvent *ec, gpointer data)
 {
+    XEvent ee, *e;
+    ObEventData *ed = data;
+
     Window window;
     ObClient *client = NULL;
     ObDock *dock = NULL;
     ObDockApp *dockapp = NULL;
     ObWindow *obwin = NULL;
-    XEvent ee, *e;
-    ObEventData *ed = data;
+    ObMenuFrame *menu = NULL;
     ObPrompt *prompt = NULL;
+    gboolean used;
 
     /* make a copy we can mangle */
     ee = *ec;
     e = &ee;
 
     window = event_get_window(e);
-    if ((obwin = g_hash_table_lookup(window_map, &window))) {
+    if (window == obt_root(ob_screen))
+        /* don't do any lookups, waste of cpu */;
+    else if ((obwin = window_find(window))) {
         switch (obwin->type) {
-        case Window_Dock:
+        case OB_WINDOW_CLASS_DOCK:
             dock = WINDOW_AS_DOCK(obwin);
             break;
-        case Window_DockApp:
-            dockapp = WINDOW_AS_DOCKAPP(obwin);
-            break;
-        case Window_Client:
+        case OB_WINDOW_CLASS_CLIENT:
             client = WINDOW_AS_CLIENT(obwin);
+            /* events on clients can be events on prompt windows too */
+            prompt = client->prompt;
             break;
-        case Window_Menu:
-            /* not to be used for events */
-            g_assert_not_reached();
+        case OB_WINDOW_CLASS_MENUFRAME:
+            menu = WINDOW_AS_MENUFRAME(obwin);
             break;
-        case Window_Internal:
+        case OB_WINDOW_CLASS_INTERNAL:
             /* we don't do anything with events directly on these windows */
             break;
-        case Window_Prompt:
+        case OB_WINDOW_CLASS_PROMPT:
             prompt = WINDOW_AS_PROMPT(obwin);
             break;
         }
     }
+    else
+        dockapp = dock_find_dockapp(window);
 
     event_set_curtime(e);
     event_curserial = e->xany.serial;
@@ -503,12 +517,7 @@ static void event_process(const XEvent *ec, gpointer data)
 
     /* deal with it in the kernel */
 
-    if (menu_frame_visible &&
-        (e->type == EnterNotify || e->type == LeaveNotify))
-    {
-        /* crossing events for menu */
-        event_handle_menu(e);
-    } else if (e->type == FocusIn) {
+    if (e->type == FocusIn) {
         if (client &&
             e->xfocus.detail == NotifyInferior)
         {
@@ -533,7 +542,7 @@ static void event_process(const XEvent *ec, gpointer data)
             XEvent ce;
 
             ob_debug_type(OB_DEBUG_FOCUS,
-                          "Focus went to root or pointer root/none\n");
+                          "Focus went to root or pointer root/none");
 
             if (e->xfocus.detail == NotifyInferior ||
                 e->xfocus.detail == NotifyNonlinear)
@@ -554,12 +563,12 @@ static void event_process(const XEvent *ec, gpointer data)
                But if the other focus in is something like PointerRoot then we
                still want to fall back.
             */
-            if (XCheckIfEvent(ob_display, &ce, event_look_for_focusin_client,
+            if (XCheckIfEvent(obt_display, &ce, event_look_for_focusin_client,
                               NULL))
             {
-                XPutBackEvent(ob_display, &ce);
+                XPutBackEvent(obt_display, &ce);
                 ob_debug_type(OB_DEBUG_FOCUS,
-                              "  but another FocusIn is coming\n");
+                              "  but another FocusIn is coming");
             } else {
                 /* Focus has been reverted.
 
@@ -575,7 +584,7 @@ static void event_process(const XEvent *ec, gpointer data)
         else if (!client)
         {
             ob_debug_type(OB_DEBUG_FOCUS,
-                          "Focus went to a window that is already gone\n");
+                          "Focus went to a window that is already gone");
 
             /* If you send focus to a window and then it disappears, you can
                get the FocusIn for it, after it is unmanaged.
@@ -594,25 +603,25 @@ static void event_process(const XEvent *ec, gpointer data)
         XEvent ce;
 
         /* Look for the followup FocusIn */
-        if (!XCheckIfEvent(ob_display, &ce, event_look_for_focusin, NULL)) {
+        if (!XCheckIfEvent(obt_display, &ce, event_look_for_focusin, NULL)) {
             /* There is no FocusIn, this means focus went to a window that
                is not being managed, or a window on another screen. */
             Window win, root;
             gint i;
             guint u;
-            xerror_set_ignore(TRUE);
-            if (XGetInputFocus(ob_display, &win, &i) != 0 &&
-                XGetGeometry(ob_display, win, &root, &i,&i,&u,&u,&u,&u) != 0 &&
-                root != RootWindow(ob_display, ob_screen))
+            obt_display_ignore_errors(TRUE);
+            if (XGetInputFocus(obt_display, &win, &i) &&
+                XGetGeometry(obt_display, win, &root, &i,&i,&u,&u,&u,&u) &&
+                root != obt_root(ob_screen))
             {
                 ob_debug_type(OB_DEBUG_FOCUS,
-                              "Focus went to another screen !\n");
+                              "Focus went to another screen !");
                 focus_left_screen = TRUE;
             }
             else
                 ob_debug_type(OB_DEBUG_FOCUS,
-                              "Focus went to a black hole !\n");
-            xerror_set_ignore(FALSE);
+                              "Focus went to a black hole !");
+            obt_display_ignore_errors(FALSE);
             /* nothing is focused */
             focus_set_client(NULL);
         } else {
@@ -623,7 +632,7 @@ static void event_process(const XEvent *ec, gpointer data)
                 /* The FocusIn was ignored, this means it was on a window
                    that isn't a client. */
                 ob_debug_type(OB_DEBUG_FOCUS,
-                              "Focus went to an unmanaged window 0x%x !\n",
+                              "Focus went to an unmanaged window 0x%x !",
                               ce.xfocus.window);
                 focus_fallback(TRUE, config_focus_under_mouse, TRUE, TRUE);
             }
@@ -641,22 +650,27 @@ static void event_process(const XEvent *ec, gpointer data)
         event_handle_dockapp(dockapp, e);
     else if (dock)
         event_handle_dock(dock, e);
-    else if (window == RootWindow(ob_display, ob_screen))
+    else if (menu)
+        event_handle_menu(menu, e);
+    else if (window == obt_root(ob_screen))
         event_handle_root(e);
     else if (e->type == MapRequest)
-        client_manage(window);
+        window_manage(window);
     else if (e->type == MappingNotify) {
         /* keyboard layout changes for modifier mapping changes. reload the
            modifier map, and rebind all the key bindings as appropriate */
-        ob_debug("Kepboard map changed. Reloading keyboard bindings.\n");
-        modkeys_shutdown(TRUE);
-        modkeys_startup(TRUE);
+        ob_debug("Keyboard map changed. Reloading keyboard bindings.");
+        ob_set_state(OB_STATE_RECONFIGURING);
+        obt_keyboard_reload();
         keyboard_rebind();
+        ob_set_state(OB_STATE_RUNNING);
     }
     else if (e->type == ClientMessage) {
         /* This is for _NET_WM_REQUEST_FRAME_EXTENTS messages. They come for
            windows that are not managed yet. */
-        if (e->xclient.message_type == prop_atoms.net_request_frame_extents) {
+        if (e->xclient.message_type ==
+            OBT_PROP_ATOM(NET_REQUEST_FRAME_EXTENTS))
+        {
             /* Pretend to manage the client, getting information used to
                determine its decorations */
             ObClient *c = client_fake_manage(e->xclient.window);
@@ -667,8 +681,8 @@ static void event_process(const XEvent *ec, gpointer data)
             vals[1] = c->frame->size.right;
             vals[2] = c->frame->size.top;
             vals[3] = c->frame->size.bottom;
-            PROP_SETA32(e->xclient.window, net_frame_extents,
-                        cardinal, vals, 4);
+            OBT_PROP_SETA32(e->xclient.window, NET_FRAME_EXTENTS,
+                            CARDINAL, vals, 4);
 
             /* Free the pretend client */
             client_fake_unmanage(c);
@@ -689,14 +703,14 @@ static void event_process(const XEvent *ec, gpointer data)
 
         /* we are not to be held responsible if someone sends us an
            invalid request! */
-        xerror_set_ignore(TRUE);
-        XConfigureWindow(ob_display, window,
+        obt_display_ignore_errors(TRUE);
+        XConfigureWindow(obt_display, window,
                          e->xconfigurerequest.value_mask, &xwc);
-        xerror_set_ignore(FALSE);
+        obt_display_ignore_errors(FALSE);
     }
 #ifdef SYNC
-    else if (extensions_sync &&
-        e->type == extensions_sync_event_basep + XSyncAlarmNotify)
+    else if (obt_display_extension_sync &&
+             e->type == obt_display_extension_sync_basep + XSyncAlarmNotify)
     {
         XSyncAlarmNotifyEvent *se = (XSyncAlarmNotifyEvent*)e;
         if (se->alarm == moveresize_alarm && moveresize_in_progress)
@@ -707,26 +721,29 @@ static void event_process(const XEvent *ec, gpointer data)
     if (e->type == ButtonPress || e->type == ButtonRelease) {
         /* If the button press was on some non-root window, or was physically
            on the root window, then process it */
-        if (window != RootWindow(ob_display, ob_screen) ||
+        if (window != obt_root(ob_screen) ||
             e->xbutton.subwindow == None)
         {
-            event_handle_user_input(client, e);
+            used = event_handle_user_input(client, e);
         }
         /* Otherwise only process it if it was physically on an openbox
            internal window */
         else {
             ObWindow *w;
 
-            if ((w = g_hash_table_lookup(window_map, &e->xbutton.subwindow)) &&
+            if ((w = window_find(e->xbutton.subwindow)) &&
                 WINDOW_IS_INTERNAL(w))
             {
-                event_handle_user_input(client, e);
+                used = event_handle_user_input(client, e);
             }
         }
     }
     else if (e->type == KeyPress || e->type == KeyRelease ||
              e->type == MotionNotify)
-        event_handle_user_input(client, e);
+        used = event_handle_user_input(client, e);
+
+    if (prompt && !used)
+        used = event_handle_prompt(prompt, e);
 
     /* if something happens and it's not from an XEvent, then we don't know
        the time */
@@ -740,7 +757,7 @@ static void event_handle_root(XEvent *e)
 
     switch(e->type) {
     case SelectionClear:
-        ob_debug("Another WM has requested to replace us. Exiting.\n");
+        ob_debug("Another WM has requested to replace us. Exiting.");
         ob_exit_replace();
         break;
 
@@ -748,41 +765,41 @@ static void event_handle_root(XEvent *e)
         if (e->xclient.format != 32) break;
 
         msgtype = e->xclient.message_type;
-        if (msgtype == prop_atoms.net_current_desktop) {
+        if (msgtype == OBT_PROP_ATOM(NET_CURRENT_DESKTOP)) {
             guint d = e->xclient.data.l[0];
             if (d < screen_num_desktops) {
                 event_curtime = e->xclient.data.l[1];
                 if (event_curtime == 0)
                     ob_debug_type(OB_DEBUG_APP_BUGS,
                                   "_NET_CURRENT_DESKTOP message is missing "
-                                  "a timestamp\n");
+                                  "a timestamp");
                 screen_set_desktop(d, TRUE);
             }
-        } else if (msgtype == prop_atoms.net_number_of_desktops) {
+        } else if (msgtype == OBT_PROP_ATOM(NET_NUMBER_OF_DESKTOPS)) {
             guint d = e->xclient.data.l[0];
             if (d > 0 && d <= 1000)
                 screen_set_num_desktops(d);
-        } else if (msgtype == prop_atoms.net_showing_desktop) {
+        } else if (msgtype == OBT_PROP_ATOM(NET_SHOWING_DESKTOP)) {
             screen_show_desktop(e->xclient.data.l[0] != 0, NULL);
-        } else if (msgtype == prop_atoms.ob_control) {
-            ob_debug("OB_CONTROL: %d\n", e->xclient.data.l[0]);
+        } else if (msgtype == OBT_PROP_ATOM(OB_CONTROL)) {
+            ob_debug("OB_CONTROL: %d", e->xclient.data.l[0]);
             if (e->xclient.data.l[0] == 1)
                 ob_reconfigure();
             else if (e->xclient.data.l[0] == 2)
                 ob_restart();
             else if (e->xclient.data.l[0] == 3)
                 ob_exit(0);
-        } else if (msgtype == prop_atoms.wm_protocols) {
-            if ((Atom)e->xclient.data.l[0] == prop_atoms.net_wm_ping)
+        } else if (msgtype == OBT_PROP_ATOM(WM_PROTOCOLS)) {
+            if ((Atom)e->xclient.data.l[0] == OBT_PROP_ATOM(NET_WM_PING))
                 ping_got_pong(e->xclient.data.l[1]);
         }
         break;
     case PropertyNotify:
-        if (e->xproperty.atom == prop_atoms.net_desktop_names) {
-            ob_debug("UPDATE DESKTOP NAMES\n");
+        if (e->xproperty.atom == OBT_PROP_ATOM(NET_DESKTOP_NAMES)) {
+            ob_debug("UPDATE DESKTOP NAMES");
             screen_update_desktop_names();
         }
-        else if (e->xproperty.atom == prop_atoms.net_desktop_layout)
+        else if (e->xproperty.atom == OBT_PROP_ATOM(NET_DESKTOP_LAYOUT))
             screen_update_layout();
         break;
     case ConfigureNotify:
@@ -810,17 +827,17 @@ void event_enter_client(ObClient *client)
         if (config_focus_delay) {
             ObFocusDelayData *data;
 
-            ob_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
+            obt_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
 
             data = g_new(ObFocusDelayData, 1);
             data->client = client;
             data->time = event_curtime;
             data->serial = event_curserial;
 
-            ob_main_loop_timeout_add(ob_main_loop,
-                                     config_focus_delay * 1000,
-                                     focus_delay_func,
-                                     data, focus_delay_cmp, focus_delay_dest);
+            obt_main_loop_timeout_add(ob_main_loop,
+                                      config_focus_delay * 1000,
+                                      focus_delay_func,
+                                      data, focus_delay_cmp, focus_delay_dest);
         } else {
             ObFocusDelayData data;
             data.client = client;
@@ -831,13 +848,101 @@ void event_enter_client(ObClient *client)
     }
 }
 
+void event_leave_client(ObClient *client)
+{
+    g_assert(config_focus_follow);
+
+    if (is_enter_focus_event_ignored(event_curserial)) {
+        ob_debug_type(OB_DEBUG_FOCUS, "Ignoring leave event with serial %lu\n"
+                      "on client 0x%x", event_curserial, client->window);
+        return;
+    }
+
+    if (client == focus_client) {
+        if (config_focus_delay) {
+            ObFocusDelayData *data;
+
+            obt_main_loop_timeout_remove(ob_main_loop, unfocus_delay_func);
+
+            data = g_new(ObFocusDelayData, 1);
+            data->client = client;
+            data->time = event_curtime;
+            data->serial = event_curserial;
+
+            obt_main_loop_timeout_add(ob_main_loop,
+                                      config_focus_delay * 1000,
+                                      unfocus_delay_func,
+                                      data, focus_delay_cmp, focus_delay_dest);
+        } else {
+            ObFocusDelayData data;
+            data.client = client;
+            data.time = event_curtime;
+            data.serial = event_curserial;
+            unfocus_delay_func(&data);
+        }
+    }
+}
+
+static gboolean *context_to_button(ObFrame *f, ObFrameContext con, gboolean press)
+{
+    if (press) {
+        switch (con) {
+        case OB_FRAME_CONTEXT_MAXIMIZE:
+            return &f->max_press;
+        case OB_FRAME_CONTEXT_CLOSE:
+            return &f->close_press;
+        case OB_FRAME_CONTEXT_ICONIFY:
+            return &f->iconify_press;
+        case OB_FRAME_CONTEXT_ALLDESKTOPS:
+            return &f->desk_press;
+        case OB_FRAME_CONTEXT_SHADE:
+            return &f->shade_press;
+        default:
+            return NULL;
+        }
+    } else {
+        switch (con) {
+        case OB_FRAME_CONTEXT_MAXIMIZE:
+            return &f->max_hover;
+        case OB_FRAME_CONTEXT_CLOSE:
+            return &f->close_hover;
+        case OB_FRAME_CONTEXT_ICONIFY:
+            return &f->iconify_hover;
+        case OB_FRAME_CONTEXT_ALLDESKTOPS:
+            return &f->desk_hover;
+        case OB_FRAME_CONTEXT_SHADE:
+            return &f->shade_hover;
+        default:
+            return NULL;
+        }
+    }
+}
+
+static void compress_client_message_event(XEvent *e, XEvent *ce, Window window,
+                                          Atom msgtype)
+{
+    /* compress changes into a single change */
+    while (XCheckTypedWindowEvent(obt_display, window, e->type, ce)) {
+        /* XXX: it would be nice to compress ALL messages of a
+           type, not just messages in a row without other
+           message types between. */
+        if (ce->xclient.message_type != msgtype) {
+            XPutBackEvent(obt_display, ce);
+            break;
+        }
+        e->xclient = ce->xclient;
+    }
+}
+
 static void event_handle_client(ObClient *client, XEvent *e)
 {
     XEvent ce;
     Atom msgtype;
     ObFrameContext con;
+    gboolean *but;
     static gint px = -1, py = -1;
     static guint pb = 0;
+    static ObFrameContext pcon = OB_FRAME_CONTEXT_NONE;
 
     switch (e->type) {
     case ButtonPress:
@@ -846,11 +951,15 @@ static void event_handle_client(ObClient *client, XEvent *e)
             pb = e->xbutton.button;
             px = e->xbutton.x;
             py = e->xbutton.y;
+
+            pcon = frame_context(client, e->xbutton.window, px, py);
+            pcon = mouse_button_frame_context(pcon, e->xbutton.button,
+                                              e->xbutton.state);
         }
     case ButtonRelease:
         /* Wheel buttons don't draw because they are an instant click, so it
            is a waste of resources to go drawing it.
-           if the user is doing an intereactive thing, or has a menu open then
+           if the user is doing an interactive thing, or has a menu open then
            the mouse is grabbed (possibly) and if we get these events we don't
            want to deal with them
         */
@@ -862,33 +971,16 @@ static void event_handle_client(ObClient *client, XEvent *e)
             con = mouse_button_frame_context(con, e->xbutton.button,
                                              e->xbutton.state);
 
-            if (e->type == ButtonRelease && e->xbutton.button == pb)
-                pb = 0, px = py = -1;
+            /* button presses on CLIENT_CONTEXTs are not accompanied by a
+               release because they are Replayed to the client */
+            if ((e->type == ButtonRelease || CLIENT_CONTEXT(con, client)) &&
+                e->xbutton.button == pb)
+                pb = 0, px = py = -1, pcon = OB_FRAME_CONTEXT_NONE;
 
-            switch (con) {
-            case OB_FRAME_CONTEXT_MAXIMIZE:
-                client->frame->max_press = (e->type == ButtonPress);
-                frame_adjust_state(client->frame);
-                break;
-            case OB_FRAME_CONTEXT_CLOSE:
-                client->frame->close_press = (e->type == ButtonPress);
-                frame_adjust_state(client->frame);
-                break;
-            case OB_FRAME_CONTEXT_ICONIFY:
-                client->frame->iconify_press = (e->type == ButtonPress);
-                frame_adjust_state(client->frame);
-                break;
-            case OB_FRAME_CONTEXT_ALLDESKTOPS:
-                client->frame->desk_press = (e->type == ButtonPress);
+            but = context_to_button(client->frame, con, TRUE);
+            if (but) {
+                *but = (e->type == ButtonPress);
                 frame_adjust_state(client->frame);
-                break;
-            case OB_FRAME_CONTEXT_SHADE:
-                client->frame->shade_press = (e->type == ButtonPress);
-                frame_adjust_state(client->frame);
-                break;
-            default:
-                /* nothing changes with clicks for any other contexts */
-                break;
             }
         }
         break;
@@ -908,46 +1000,21 @@ static void event_handle_client(ObClient *client, XEvent *e)
                 client->frame->shade_hover || client->frame->iconify_hover ||
                 client->frame->close_hover)
             {
-                client->frame->max_hover = FALSE;
-                client->frame->desk_hover = FALSE;
-                client->frame->shade_hover = FALSE;
-                client->frame->iconify_hover = FALSE;
-                client->frame->close_hover = FALSE;
-                frame_adjust_state(client->frame);
-            }
-            break;
-        case OB_FRAME_CONTEXT_MAXIMIZE:
-            if (!client->frame->max_hover) {
-                client->frame->max_hover = TRUE;
+                client->frame->max_hover =
+                    client->frame->desk_hover =
+                    client->frame->shade_hover =
+                    client->frame->iconify_hover =
+                    client->frame->close_hover = FALSE;
                 frame_adjust_state(client->frame);
             }
             break;
-        case OB_FRAME_CONTEXT_ALLDESKTOPS:
-            if (!client->frame->desk_hover) {
-                client->frame->desk_hover = TRUE;
-                frame_adjust_state(client->frame);
-            }
-            break;
-        case OB_FRAME_CONTEXT_SHADE:
-            if (!client->frame->shade_hover) {
-                client->frame->shade_hover = TRUE;
-                frame_adjust_state(client->frame);
-            }
-            break;
-        case OB_FRAME_CONTEXT_ICONIFY:
-            if (!client->frame->iconify_hover) {
-                client->frame->iconify_hover = TRUE;
-                frame_adjust_state(client->frame);
-            }
-            break;
-        case OB_FRAME_CONTEXT_CLOSE:
-            if (!client->frame->close_hover) {
-                client->frame->close_hover = TRUE;
+        default:
+            but = context_to_button(client->frame, con, FALSE);
+            if (but && !*but && !pb) {
+                *but = TRUE;
                 frame_adjust_state(client->frame);
             }
             break;
-        default:
-            break;
         }
         break;
     case LeaveNotify:
@@ -958,38 +1025,19 @@ static void event_handle_client(ObClient *client, XEvent *e)
         case OB_FRAME_CONTEXT_TLCORNER:
         case OB_FRAME_CONTEXT_TRCORNER:
             /* we've left the button area inside the titlebar */
-            if (client->frame->max_hover || client->frame->desk_hover ||
-                client->frame->shade_hover || client->frame->iconify_hover ||
-                client->frame->close_hover)
-            {
-                client->frame->max_hover = FALSE;
-                client->frame->desk_hover = FALSE;
-                client->frame->shade_hover = FALSE;
-                client->frame->iconify_hover = FALSE;
+            client->frame->max_hover =
+                client->frame->desk_hover =
+                client->frame->shade_hover =
+                client->frame->iconify_hover =
                 client->frame->close_hover = FALSE;
-                frame_adjust_state(client->frame);
+            if (e->xcrossing.mode == NotifyGrab) {
+                client->frame->max_press =
+                    client->frame->desk_press =
+                    client->frame->shade_press =
+                    client->frame->iconify_press =
+                    client->frame->close_press = FALSE;
             }
             break;
-        case OB_FRAME_CONTEXT_MAXIMIZE:
-            client->frame->max_hover = FALSE;
-            frame_adjust_state(client->frame);
-            break;
-        case OB_FRAME_CONTEXT_ALLDESKTOPS:
-            client->frame->desk_hover = FALSE;
-            frame_adjust_state(client->frame);
-            break;
-        case OB_FRAME_CONTEXT_SHADE:
-            client->frame->shade_hover = FALSE;
-            frame_adjust_state(client->frame);
-            break;
-        case OB_FRAME_CONTEXT_ICONIFY:
-            client->frame->iconify_hover = FALSE;
-            frame_adjust_state(client->frame);
-            break;
-        case OB_FRAME_CONTEXT_CLOSE:
-            client->frame->close_hover = FALSE;
-            frame_adjust_state(client->frame);
-            break;
         case OB_FRAME_CONTEXT_FRAME:
             /* When the mouse leaves an animating window, don't use the
                corresponding enter events. Pretend like the animating window
@@ -998,24 +1046,36 @@ static void event_handle_client(ObClient *client, XEvent *e)
                 event_end_ignore_all_enters(event_start_ignore_all_enters());
 
             ob_debug_type(OB_DEBUG_FOCUS,
-                          "%sNotify mode %d detail %d on %lx\n",
+                          "%sNotify mode %d detail %d on %lx",
                           (e->type == EnterNotify ? "Enter" : "Leave"),
                           e->xcrossing.mode,
                           e->xcrossing.detail, (client?client->window:0));
             if (grab_on_keyboard())
                 break;
-            if (config_focus_follow && config_focus_delay &&
+            if (config_focus_follow &&
                 /* leave inferior events can happen when the mouse goes onto
                    the window's border and then into the window before the
                    delay is up */
                 e->xcrossing.detail != NotifyInferior)
             {
-                ob_main_loop_timeout_remove_data(ob_main_loop,
-                                                 focus_delay_func,
-                                                 client, FALSE);
+                if (config_focus_delay)
+                    obt_main_loop_timeout_remove_data(ob_main_loop,
+                                                      focus_delay_func,
+                                                      client, FALSE);
+                if (config_unfocus_leave)
+                    event_leave_client(client);
             }
             break;
         default:
+            but = context_to_button(client->frame, con, FALSE);
+            if (but) {
+                *but = FALSE;
+                if (e->xcrossing.mode == NotifyGrab) {
+                    but = context_to_button(client->frame, con, TRUE);
+                    *but = FALSE;
+                }
+                frame_adjust_state(client->frame);
+            }
             break;
         }
         break;
@@ -1024,26 +1084,6 @@ static void event_handle_client(ObClient *client, XEvent *e)
         con = frame_context(client, e->xcrossing.window,
                             e->xcrossing.x, e->xcrossing.y);
         switch (con) {
-        case OB_FRAME_CONTEXT_MAXIMIZE:
-            client->frame->max_hover = TRUE;
-            frame_adjust_state(client->frame);
-            break;
-        case OB_FRAME_CONTEXT_ALLDESKTOPS:
-            client->frame->desk_hover = TRUE;
-            frame_adjust_state(client->frame);
-            break;
-        case OB_FRAME_CONTEXT_SHADE:
-            client->frame->shade_hover = TRUE;
-            frame_adjust_state(client->frame);
-            break;
-        case OB_FRAME_CONTEXT_ICONIFY:
-            client->frame->iconify_hover = TRUE;
-            frame_adjust_state(client->frame);
-            break;
-        case OB_FRAME_CONTEXT_CLOSE:
-            client->frame->close_hover = TRUE;
-            frame_adjust_state(client->frame);
-            break;
         case OB_FRAME_CONTEXT_FRAME:
             if (grab_on_keyboard())
                 break;
@@ -1054,7 +1094,7 @@ static void event_handle_client(ObClient *client, XEvent *e)
             {
                 ob_debug_type(OB_DEBUG_FOCUS,
                               "%sNotify mode %d detail %d serial %lu on %lx "
-                              "IGNORED\n",
+                              "IGNORED",
                               (e->type == EnterNotify ? "Enter" : "Leave"),
                               e->xcrossing.mode,
                               e->xcrossing.detail,
@@ -1064,17 +1104,31 @@ static void event_handle_client(ObClient *client, XEvent *e)
             else {
                 ob_debug_type(OB_DEBUG_FOCUS,
                               "%sNotify mode %d detail %d serial %lu on %lx, "
-                              "focusing window\n",
+                              "focusing window",
                               (e->type == EnterNotify ? "Enter" : "Leave"),
                               e->xcrossing.mode,
                               e->xcrossing.detail,
                               e->xcrossing.serial,
                               (client?client->window:0));
-                if (config_focus_follow)
+                if (config_focus_follow) {
+                    if (config_focus_delay)
+                        obt_main_loop_timeout_remove_data(ob_main_loop,
+                                                          unfocus_delay_func,
+                                                          client, FALSE);
                     event_enter_client(client);
+                }
             }
             break;
         default:
+            but = context_to_button(client->frame, con, FALSE);
+            if (but) {
+                *but = TRUE;
+                if (e->xcrossing.mode == NotifyUngrab) {
+                    but = context_to_button(client->frame, con, TRUE);
+                    *but = (con == pcon);
+                }
+                frame_adjust_state(client->frame);
+            }
             break;
         }
         break;
@@ -1095,10 +1149,10 @@ static void event_handle_client(ObClient *client, XEvent *e)
         RECT_TO_DIMS(client->area, x, y, w, h);
 
         ob_debug("ConfigureRequest for \"%s\" desktop %d wmstate %d "
-                 "visibile %d\n"
-                 "                     x %d y %d w %d h %d b %d\n",
+                 "visible %d",
                  client->title,
-                 screen_desktop, client->wmstate, client->frame->visible,
+                 screen_desktop, client->wmstate, client->frame->visible);
+        ob_debug("                     x %d y %d w %d h %d b %d",
                  x, y, w, h, client->border_width);
 
         if (e->xconfigurerequest.value_mask & CWBorderWidth)
@@ -1108,12 +1162,11 @@ static void event_handle_client(ObClient *client, XEvent *e)
                 /* if the border width is changing then that is the same
                    as requesting a resize, but we don't actually change
                    the client's border, so it will change their root
-                   coordiantes (since they include the border width) and
+                   coordinates (since they include the border width) and
                    we need to a notify then */
                 move = TRUE;
             }
 
-
         if (e->xconfigurerequest.value_mask & CWStackMode) {
             ObClient *sibling = NULL;
             gulong ignore_start;
@@ -1122,8 +1175,7 @@ static void event_handle_client(ObClient *client, XEvent *e)
             /* get the sibling */
             if (e->xconfigurerequest.value_mask & CWSibling) {
                 ObWindow *win;
-                win = g_hash_table_lookup(window_map,
-                                          &e->xconfigurerequest.above);
+                win = window_find(e->xconfigurerequest.above);
                 if (win && WINDOW_IS_CLIENT(win) &&
                     WINDOW_AS_CLIENT(win) != client)
                 {
@@ -1153,16 +1205,14 @@ static void event_handle_client(ObClient *client, XEvent *e)
             (e->xconfigurerequest.value_mask & CWWidth) ||
             (e->xconfigurerequest.value_mask & CWHeight))
         {
+            /* don't allow clients to move shaded windows (fvwm does this)
+            */
             if (e->xconfigurerequest.value_mask & CWX) {
-                /* don't allow clients to move shaded windows (fvwm does this)
-                 */
                 if (!client->shaded)
                     x = e->xconfigurerequest.x;
                 move = TRUE;
             }
             if (e->xconfigurerequest.value_mask & CWY) {
-                /* don't allow clients to move shaded windows (fvwm does this)
-                 */
                 if (!client->shaded)
                     y = e->xconfigurerequest.y;
                 move = TRUE;
@@ -1179,7 +1229,7 @@ static void event_handle_client(ObClient *client, XEvent *e)
         }
 
         ob_debug("ConfigureRequest x(%d) %d y(%d) %d w(%d) %d h(%d) %d "
-                 "move %d resize %d\n",
+                 "move %d resize %d",
                  e->xconfigurerequest.value_mask & CWX, x,
                  e->xconfigurerequest.value_mask & CWY, y,
                  e->xconfigurerequest.value_mask & CWWidth, w,
@@ -1205,7 +1255,7 @@ static void event_handle_client(ObClient *client, XEvent *e)
             ob_debug_type(OB_DEBUG_APP_BUGS,
                           "Application %s is trying to move via "
                           "ConfigureRequest to it's root window position "
-                          "but it is not using StaticGravity\n",
+                          "but it is not using StaticGravity",
                           client->title);
             /* don't move it */
             x = client->area.x;
@@ -1216,7 +1266,7 @@ static void event_handle_client(ObClient *client, XEvent *e)
         }
 
         {
-            gint lw,lh;
+            gint lw, lh;
 
             client_try_configure(client, &x, &y, &w, &h, &lw, &lh, FALSE);
 
@@ -1225,33 +1275,32 @@ static void event_handle_client(ObClient *client, XEvent *e)
             if ((e->xconfigurerequest.value_mask & CWWidth &&
                  !(e->xconfigurerequest.value_mask & CWX)))
                 client_gravity_resize_w(client, &x, client->area.width, w);
-            /* if y was not given, then use gravity to figure out the new
-               y.  the reference point should not be moved */
+            /* same for y */
             if ((e->xconfigurerequest.value_mask & CWHeight &&
                  !(e->xconfigurerequest.value_mask & CWY)))
                 client_gravity_resize_h(client, &y, client->area.height,h);
 
             client_find_onscreen(client, &x, &y, w, h, FALSE);
 
-            ob_debug("Granting ConfigureRequest x %d y %d w %d h %d\n",
+            ob_debug("Granting ConfigureRequest x %d y %d w %d h %d",
                      x, y, w, h);
             client_configure(client, x, y, w, h, FALSE, TRUE, TRUE);
         }
         break;
     }
     case UnmapNotify:
+        ob_debug("UnmapNotify for window 0x%x eventwin 0x%x sendevent %d "
+                 "ignores left %d",
+                 client->window, e->xunmap.event, e->xunmap.from_configure,
+                 client->ignore_unmaps);
         if (client->ignore_unmaps) {
             client->ignore_unmaps--;
             break;
         }
-        ob_debug("UnmapNotify for window 0x%x eventwin 0x%x sendevent %d "
-                 "ignores left %d\n",
-                 client->window, e->xunmap.event, e->xunmap.from_configure,
-                 client->ignore_unmaps);
         client_unmanage(client);
         break;
     case DestroyNotify:
-        ob_debug("DestroyNotify for window 0x%x\n", client->window);
+        ob_debug("DestroyNotify for window 0x%x", client->window);
         client_unmanage(client);
         break;
     case ReparentNotify:
@@ -1267,19 +1316,19 @@ static void event_handle_client(ObClient *client, XEvent *e)
 
         /* we don't want the reparent event, put it back on the stack for the
            X server to deal with after we unmanage the window */
-        XPutBackEvent(ob_display, e);
+        XPutBackEvent(obt_display, e);
 
-        ob_debug("ReparentNotify for window 0x%x\n", client->window);
+        ob_debug("ReparentNotify for window 0x%x", client->window);
         client_unmanage(client);
         break;
     case MapRequest:
-        ob_debug("MapRequest for 0x%lx\n", client->window);
+        ob_debug("MapRequest for 0x%lx", client->window);
         if (!client->iconic) break; /* this normally doesn't happen, but if it
                                        does, we don't want it!
                                        it can happen now when the window is on
                                        another desktop, but we still don't
                                        want it! */
-        client_activate(client, FALSE, TRUE, TRUE, TRUE);
+        client_activate(client, FALSE, FALSE, TRUE, TRUE, TRUE);
         break;
     case ClientMessage:
         /* validate cuz we query stuff off the client here */
@@ -1288,42 +1337,20 @@ static void event_handle_client(ObClient *client, XEvent *e)
         if (e->xclient.format != 32) return;
 
         msgtype = e->xclient.message_type;
-        if (msgtype == prop_atoms.wm_change_state) {
-            /* compress changes into a single change */
-            while (XCheckTypedWindowEvent(ob_display, client->window,
-                                          e->type, &ce)) {
-                /* XXX: it would be nice to compress ALL messages of a
-                   type, not just messages in a row without other
-                   message types between. */
-                if (ce.xclient.message_type != msgtype) {
-                    XPutBackEvent(ob_display, &ce);
-                    break;
-                }
-                e->xclient = ce.xclient;
-            }
+        if (msgtype == OBT_PROP_ATOM(WM_CHANGE_STATE)) {
+            compress_client_message_event(e, &ce, client->window, msgtype);
             client_set_wm_state(client, e->xclient.data.l[0]);
-        } else if (msgtype == prop_atoms.net_wm_desktop) {
-            /* compress changes into a single change */
-            while (XCheckTypedWindowEvent(ob_display, client->window,
-                                          e->type, &ce)) {
-                /* XXX: it would be nice to compress ALL messages of a
-                   type, not just messages in a row without other
-                   message types between. */
-                if (ce.xclient.message_type != msgtype) {
-                    XPutBackEvent(ob_display, &ce);
-                    break;
-                }
-                e->xclient = ce.xclient;
-            }
+        } else if (msgtype == OBT_PROP_ATOM(NET_WM_DESKTOP)) {
+            compress_client_message_event(e, &ce, client->window, msgtype);
             if ((unsigned)e->xclient.data.l[0] < screen_num_desktops ||
                 (unsigned)e->xclient.data.l[0] == DESKTOP_ALL)
                 client_set_desktop(client, (unsigned)e->xclient.data.l[0],
                                    FALSE, FALSE);
-        } else if (msgtype == prop_atoms.net_wm_state) {
+        } else if (msgtype == OBT_PROP_ATOM(NET_WM_STATE)) {
             gulong ignore_start;
 
             /* can't compress these */
-            ob_debug("net_wm_state %s %ld %ld for 0x%lx\n",
+            ob_debug("net_wm_state %s %ld %ld for 0x%lx",
                      (e->xclient.data.l[0] == 0 ? "Remove" :
                       e->xclient.data.l[0] == 1 ? "Add" :
                       e->xclient.data.l[0] == 2 ? "Toggle" : "INVALID"),
@@ -1337,68 +1364,65 @@ static void event_handle_client(ObClient *client, XEvent *e)
                              e->xclient.data.l[1], e->xclient.data.l[2]);
             if (!config_focus_under_mouse)
                 event_end_ignore_all_enters(ignore_start);
-        } else if (msgtype == prop_atoms.net_close_window) {
-            ob_debug("net_close_window for 0x%lx\n", client->window);
+        } else if (msgtype == OBT_PROP_ATOM(NET_CLOSE_WINDOW)) {
+            ob_debug("net_close_window for 0x%lx", client->window);
             client_close(client);
-        } else if (msgtype == prop_atoms.net_active_window) {
-            ob_debug("net_active_window for 0x%lx source=%s\n",
+        } else if (msgtype == OBT_PROP_ATOM(NET_ACTIVE_WINDOW)) {
+            ob_debug("net_active_window for 0x%lx source=%s",
                      client->window,
                      (e->xclient.data.l[0] == 0 ? "unknown" :
                       (e->xclient.data.l[0] == 1 ? "application" :
                        (e->xclient.data.l[0] == 2 ? "user" : "INVALID"))));
             /* XXX make use of data.l[2] !? */
             if (e->xclient.data.l[0] == 1 || e->xclient.data.l[0] == 2) {
-                /* don't use the user's timestamp for client_focus, cuz if it's
-                   an old broken timestamp (happens all the time) then focus
-                   won't move even though we're trying to move it
-                  event_curtime = e->xclient.data.l[1];*/
+                event_curtime = e->xclient.data.l[1];
                 if (e->xclient.data.l[1] == 0)
                     ob_debug_type(OB_DEBUG_APP_BUGS,
                                   "_NET_ACTIVE_WINDOW message for window %s is"
-                                  " missing a timestamp\n", client->title);
+                                  " missing a timestamp", client->title);
             } else
                 ob_debug_type(OB_DEBUG_APP_BUGS,
                               "_NET_ACTIVE_WINDOW message for window %s is "
-                              "missing source indication\n");
-            client_activate(client, TRUE, TRUE, TRUE,
+                              "missing source indication", client->title);
+            client_activate(client, FALSE, FALSE, TRUE, TRUE,
                             (e->xclient.data.l[0] == 0 ||
                              e->xclient.data.l[0] == 2));
-        } else if (msgtype == prop_atoms.net_wm_moveresize) {
-            ob_debug("net_wm_moveresize for 0x%lx direction %d\n",
+        } else if (msgtype == OBT_PROP_ATOM(NET_WM_MOVERESIZE)) {
+            ob_debug("net_wm_moveresize for 0x%lx direction %d",
                      client->window, e->xclient.data.l[2]);
             if ((Atom)e->xclient.data.l[2] ==
-                prop_atoms.net_wm_moveresize_size_topleft ||
+                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPLEFT) ||
                 (Atom)e->xclient.data.l[2] ==
-                prop_atoms.net_wm_moveresize_size_top ||
+                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOP) ||
                 (Atom)e->xclient.data.l[2] ==
-                prop_atoms.net_wm_moveresize_size_topright ||
+                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPRIGHT) ||
                 (Atom)e->xclient.data.l[2] ==
-                prop_atoms.net_wm_moveresize_size_right ||
+                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_RIGHT) ||
                 (Atom)e->xclient.data.l[2] ==
-                prop_atoms.net_wm_moveresize_size_right ||
+                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_RIGHT) ||
                 (Atom)e->xclient.data.l[2] ==
-                prop_atoms.net_wm_moveresize_size_bottomright ||
+                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT) ||
                 (Atom)e->xclient.data.l[2] ==
-                prop_atoms.net_wm_moveresize_size_bottom ||
+                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOM) ||
                 (Atom)e->xclient.data.l[2] ==
-                prop_atoms.net_wm_moveresize_size_bottomleft ||
+                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT) ||
                 (Atom)e->xclient.data.l[2] ==
-                prop_atoms.net_wm_moveresize_size_left ||
+                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_LEFT) ||
                 (Atom)e->xclient.data.l[2] ==
-                prop_atoms.net_wm_moveresize_move ||
+                OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE) ||
                 (Atom)e->xclient.data.l[2] ==
-                prop_atoms.net_wm_moveresize_size_keyboard ||
+                OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_KEYBOARD) ||
                 (Atom)e->xclient.data.l[2] ==
-                prop_atoms.net_wm_moveresize_move_keyboard) {
-
+                OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE_KEYBOARD))
+            {
                 moveresize_start(client, e->xclient.data.l[0],
                                  e->xclient.data.l[1], e->xclient.data.l[3],
                                  e->xclient.data.l[2]);
             }
             else if ((Atom)e->xclient.data.l[2] ==
-                     prop_atoms.net_wm_moveresize_cancel)
+                     OBT_PROP_ATOM(NET_WM_MOVERESIZE_CANCEL))
                 moveresize_end(TRUE);
-        } else if (msgtype == prop_atoms.net_moveresize_window) {
+        } else if (msgtype == OBT_PROP_ATOM(NET_MOVERESIZE_WINDOW)) {
             gint ograv, x, y, w, h;
 
             ograv = client->gravity;
@@ -1429,15 +1453,14 @@ static void event_handle_client(ObClient *client, XEvent *e)
             if (e->xclient.data.l[0] & 1 << 11) {
                 h = e->xclient.data.l[4];
 
-                /* if y was not given, then use gravity to figure out the new
-                   y.  the reference point should not be moved */
+                /* same for y */
                 if (!(e->xclient.data.l[0] & 1 << 9))
                     client_gravity_resize_h(client, &y, client->area.height,h);
             }
             else
                 h = client->area.height;
 
-            ob_debug("MOVERESIZE x %d %d y %d %d (gravity %d)\n",
+            ob_debug("MOVERESIZE x %d %d y %d %d (gravity %d)",
                      e->xclient.data.l[0] & 1 << 8, x,
                      e->xclient.data.l[0] & 1 << 9, y,
                      client->gravity);
@@ -1447,17 +1470,16 @@ static void event_handle_client(ObClient *client, XEvent *e)
             client_configure(client, x, y, w, h, FALSE, TRUE, FALSE);
 
             client->gravity = ograv;
-        } else if (msgtype == prop_atoms.net_restack_window) {
+        } else if (msgtype == OBT_PROP_ATOM(NET_RESTACK_WINDOW)) {
             if (e->xclient.data.l[0] != 2) {
                 ob_debug_type(OB_DEBUG_APP_BUGS,
                               "_NET_RESTACK_WINDOW sent for window %s with "
-                              "invalid source indication %ld\n",
+                              "invalid source indication %ld",
                               client->title, e->xclient.data.l[0]);
             } else {
                 ObClient *sibling = NULL;
                 if (e->xclient.data.l[1]) {
-                    ObWindow *win = g_hash_table_lookup
-                        (window_map, &e->xclient.data.l[1]);
+                    ObWindow *win = window_find(e->xclient.data.l[1]);
                     if (WINDOW_IS_CLIENT(win) &&
                         WINDOW_AS_CLIENT(win) != client)
                     {
@@ -1466,7 +1488,7 @@ static void event_handle_client(ObClient *client, XEvent *e)
                     if (sibling == NULL)
                         ob_debug_type(OB_DEBUG_APP_BUGS,
                                       "_NET_RESTACK_WINDOW sent for window %s "
-                                      "with invalid sibling 0x%x\n",
+                                      "with invalid sibling 0x%x",
                                  client->title, e->xclient.data.l[1]);
                 }
                 if (e->xclient.data.l[2] == Below ||
@@ -1491,7 +1513,7 @@ static void event_handle_client(ObClient *client, XEvent *e)
                 } else
                     ob_debug_type(OB_DEBUG_APP_BUGS,
                                   "_NET_RESTACK_WINDOW sent for window %s "
-                                  "with invalid detail %d\n",
+                                  "with invalid detail %d",
                                   client->title, e->xclient.data.l[2]);
             }
         }
@@ -1501,7 +1523,7 @@ static void event_handle_client(ObClient *client, XEvent *e)
         if (!client_validate(client)) break;
 
         /* compress changes to a single property into a single change */
-        while (XCheckTypedWindowEvent(ob_display, client->window,
+        while (XCheckTypedWindowEvent(obt_display, client->window,
                                       e->type, &ce)) {
             Atom a, b;
 
@@ -1513,36 +1535,58 @@ static void event_handle_client(ObClient *client, XEvent *e)
 
             if (a == b)
                 continue;
-            if ((a == prop_atoms.net_wm_name ||
-                 a == prop_atoms.wm_name ||
-                 a == prop_atoms.net_wm_icon_name ||
-                 a == prop_atoms.wm_icon_name)
+            if ((a == OBT_PROP_ATOM(NET_WM_NAME) ||
+                 a == OBT_PROP_ATOM(WM_NAME) ||
+                 a == OBT_PROP_ATOM(NET_WM_ICON_NAME) ||
+                 a == OBT_PROP_ATOM(WM_ICON_NAME))
                 &&
-                (b == prop_atoms.net_wm_name ||
-                 b == prop_atoms.wm_name ||
-                 b == prop_atoms.net_wm_icon_name ||
-                 b == prop_atoms.wm_icon_name)) {
+                (b == OBT_PROP_ATOM(NET_WM_NAME) ||
+                 b == OBT_PROP_ATOM(WM_NAME) ||
+                 b == OBT_PROP_ATOM(NET_WM_ICON_NAME) ||
+                 b == OBT_PROP_ATOM(WM_ICON_NAME))) {
                 continue;
             }
-            if (a == prop_atoms.net_wm_icon &&
-                b == prop_atoms.net_wm_icon)
+            if (a == OBT_PROP_ATOM(NET_WM_ICON) &&
+                b == OBT_PROP_ATOM(NET_WM_ICON))
                 continue;
 
-            XPutBackEvent(ob_display, &ce);
+            XPutBackEvent(obt_display, &ce);
             break;
         }
 
         msgtype = e->xproperty.atom;
         if (msgtype == XA_WM_NORMAL_HINTS) {
-            ob_debug("Update NORMAL hints\n");
+            int x, y, w, h, lw, lh;
+
+            ob_debug("Update NORMAL hints");
             client_update_normal_hints(client);
             /* normal hints can make a window non-resizable */
             client_setup_decor_and_functions(client, FALSE);
 
-            /* make sure the client's sizes are within its bounds, but only
-               reconfigure the window if it needs to. emacs will update its
-               normal hints every time it receives a conigurenotify */
-            client_reconfigure(client, FALSE);
+            x = client->area.x;
+            y = client->area.y;
+            w = client->area.width;
+            h = client->area.height;
+
+            /* apply the new normal hints */
+            client_try_configure(client, &x, &y, &w, &h, &lw, &lh, FALSE);
+            /* make sure the window is visible, and if the window is resized
+               off-screen due to the normal hints changing then this will push
+               it back onto the screen. */
+            client_find_onscreen(client, &x, &y, w, h, FALSE);
+
+            /* make sure the client's sizes are within its bounds, but don't
+               make it reply with a configurenotify unless something changed.
+               emacs will update its normal hints every time it receives a
+               configurenotify */
+            client_configure(client, x, y, w, h, FALSE, TRUE, FALSE);
+        } else if (msgtype == OBT_PROP_ATOM(MOTIF_WM_HINTS)) {
+            client_get_mwm_hints(client);
+            /* This can override some mwm hints */
+            client_get_type_and_transientness(client);
+
+            /* Apply the changes to the window */
+            client_setup_decor_and_functions(client, TRUE);
         } else if (msgtype == XA_WM_HINTS) {
             client_update_wmhints(client);
         } else if (msgtype == XA_WM_TRANSIENT_FOR) {
@@ -1551,32 +1595,30 @@ static void event_handle_client(ObClient *client, XEvent *e)
             /* type may have changed, so update the layer */
             client_calc_layer(client);
             client_setup_decor_and_functions(client, TRUE);
-        } else if (msgtype == prop_atoms.net_wm_name ||
-                   msgtype == prop_atoms.wm_name ||
-                   msgtype == prop_atoms.net_wm_icon_name ||
-                   msgtype == prop_atoms.wm_icon_name) {
+        } else if (msgtype == OBT_PROP_ATOM(NET_WM_NAME) ||
+                   msgtype == OBT_PROP_ATOM(WM_NAME) ||
+                   msgtype == OBT_PROP_ATOM(NET_WM_ICON_NAME) ||
+                   msgtype == OBT_PROP_ATOM(WM_ICON_NAME)) {
             client_update_title(client);
-        } else if (msgtype == prop_atoms.wm_protocols) {
+        } else if (msgtype == OBT_PROP_ATOM(WM_PROTOCOLS)) {
             client_update_protocols(client);
             client_setup_decor_and_functions(client, TRUE);
         }
-        else if (msgtype == prop_atoms.net_wm_strut) {
-            client_update_strut(client);
-        }
-        else if (msgtype == prop_atoms.net_wm_strut_partial) {
+        else if (msgtype == OBT_PROP_ATOM(NET_WM_STRUT) ||
+                 msgtype == OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL)) {
             client_update_strut(client);
         }
-        else if (msgtype == prop_atoms.net_wm_icon) {
+        else if (msgtype == OBT_PROP_ATOM(NET_WM_ICON)) {
             client_update_icons(client);
         }
-        else if (msgtype == prop_atoms.net_wm_icon_geometry) {
+        else if (msgtype == OBT_PROP_ATOM(NET_WM_ICON_GEOMETRY)) {
             client_update_icon_geometry(client);
         }
-        else if (msgtype == prop_atoms.net_wm_user_time) {
+        else if (msgtype == OBT_PROP_ATOM(NET_WM_USER_TIME)) {
             guint32 t;
             if (client == focus_client &&
-                PROP_GET32(client->window, net_wm_user_time, cardinal, &t) &&
-                t && !event_time_after(t, e->xproperty.time) &&
+                OBT_PROP_GET32(client->window, NET_WM_USER_TIME, CARDINAL, &t)
+                && t && !event_time_after(t, e->xproperty.time) &&
                 (!event_last_user_time ||
                  event_time_after(t, event_last_user_time)))
             {
@@ -1584,7 +1626,7 @@ static void event_handle_client(ObClient *client, XEvent *e)
             }
         }
 #ifdef SYNC
-        else if (msgtype == prop_atoms.net_wm_sync_request_counter) {
+        else if (msgtype == OBT_PROP_ATOM(NET_WM_SYNC_REQUEST_COUNTER)) {
             client_update_sync_request_counter(client);
         }
 #endif
@@ -1595,9 +1637,26 @@ static void event_handle_client(ObClient *client, XEvent *e)
     default:
         ;
 #ifdef SHAPE
-        if (extensions_shape && e->type == extensions_shape_event_basep) {
-            client->shaped = ((XShapeEvent*)e)->shaped;
-            frame_adjust_shape(client->frame);
+        {
+            int kind;
+            if (obt_display_extension_shape &&
+                e->type == obt_display_extension_shape_basep)
+            {
+                switch (((XShapeEvent*)e)->kind) {
+                    case ShapeBounding:
+                    case ShapeClip:
+                        client->shaped = ((XShapeEvent*)e)->shaped;
+                        kind = ShapeBounding;
+                        break;
+                    case ShapeInput:
+                        client->shaped_input = ((XShapeEvent*)e)->shaped;
+                        kind = ShapeInput;
+                        break;
+                    default:
+                        g_assert_not_reached();
+                }
+                frame_adjust_shape_kind(client->frame, kind);
+            }
         }
 #endif
     }
@@ -1634,13 +1693,11 @@ static void event_handle_dockapp(ObDockApp *app, XEvent *e)
             app->ignore_unmaps--;
             break;
         }
-        dock_remove(app, TRUE);
+        dock_unmanage(app, TRUE);
         break;
     case DestroyNotify:
-        dock_remove(app, FALSE);
-        break;
     case ReparentNotify:
-        dock_remove(app, FALSE);
+        dock_unmanage(app, FALSE);
         break;
     case ConfigureNotify:
         dock_app_configure(app, e->xconfigure.width, e->xconfigure.height);
@@ -1672,124 +1729,195 @@ static ObMenuFrame* find_active_or_last_menu(void)
     return ret;
 }
 
-static gboolean event_handle_menu_keyboard(XEvent *ev)
+static gboolean event_handle_prompt(ObPrompt *p, XEvent *e)
+{
+    switch (e->type) {
+    case ButtonPress:
+    case ButtonRelease:
+    case MotionNotify:
+        return prompt_mouse_event(p, e);
+        break;
+    case KeyPress:
+        return prompt_key_event(p, e);
+        break;
+    }
+    return FALSE;
+}
+
+static gboolean event_handle_menu_input(XEvent *ev)
 {
-    guint keycode, state;
-    gunichar unikey;
-    ObMenuFrame *frame;
     gboolean ret = FALSE;
 
-    keycode = ev->xkey.keycode;
-    state = ev->xkey.state;
-    unikey = translate_unichar(keycode);
+    if (ev->type == ButtonRelease || ev->type == ButtonPress) {
+        ObMenuEntryFrame *e;
 
-    frame = find_active_or_last_menu();
-    if (frame == NULL)
-        g_assert_not_reached(); /* there is no active menu */
+        if (menu_hide_delay_reached() &&
+            (ev->xbutton.button < 4 || ev->xbutton.button > 5))
+        {
+            if ((e = menu_entry_frame_under(ev->xbutton.x_root,
+                                            ev->xbutton.y_root)))
+            {
+                if (ev->type == ButtonPress && e->frame->child)
+                    menu_frame_select(e->frame->child, NULL, TRUE);
+                menu_frame_select(e->frame, e, TRUE);
+                if (ev->type == ButtonRelease)
+                    menu_entry_frame_execute(e, ev->xbutton.state);
+            }
+            else if (ev->type == ButtonRelease)
+                menu_frame_hide_all();
+        }
+        ret = TRUE;
+    }
+    else if (ev->type == MotionNotify) {
+        ObMenuFrame *f;
+        ObMenuEntryFrame *e;
 
-    /* Allow control while going thru the menu */
-    else if (ev->type == KeyPress && (state & ~ControlMask) == 0) {
-        frame->got_press = TRUE;
+        if ((e = menu_entry_frame_under(ev->xmotion.x_root,
+                                        ev->xmotion.y_root)))
+            if (!(f = find_active_menu()) ||
+                f == e->frame ||
+                f->parent == e->frame ||
+                f->child == e->frame)
+                menu_frame_select(e->frame, e, FALSE);
+    }
+    else if (ev->type == KeyPress || ev->type == KeyRelease) {
+        guint keycode, state;
+        gunichar unikey;
+        ObMenuFrame *frame;
 
-        if (keycode == ob_keycode(OB_KEY_ESCAPE)) {
-            menu_frame_hide_all();
-            ret = TRUE;
-        }
+        keycode = ev->xkey.keycode;
+        state = ev->xkey.state;
+        unikey = obt_keyboard_keycode_to_unichar(keycode);
 
-        else if (keycode == ob_keycode(OB_KEY_LEFT)) {
-            /* Left goes to the parent menu */
-            menu_frame_select(frame, NULL, TRUE);
-            ret = TRUE;
-        }
+        frame = find_active_or_last_menu();
+        if (frame == NULL)
+            g_assert_not_reached(); /* there is no active menu */
 
-        else if (keycode == ob_keycode(OB_KEY_RIGHT)) {
-            /* Right goes to the selected submenu */
-            if (frame->child) menu_frame_select_next(frame->child);
-            ret = TRUE;
-        }
+        /* Allow control while going thru the menu */
+        else if (ev->type == KeyPress && (state & ~ControlMask) == 0) {
+            frame->got_press = TRUE;
 
-        else if (keycode == ob_keycode(OB_KEY_UP)) {
-            menu_frame_select_previous(frame);
-            ret = TRUE;
-        }
+            if (ob_keycode_match(keycode, OB_KEY_ESCAPE)) {
+                menu_frame_hide_all();
+                ret = TRUE;
+            }
 
-        else if (keycode == ob_keycode(OB_KEY_DOWN)) {
-            menu_frame_select_next(frame);
-            ret = TRUE;
-        }
-    }
+            else if (ob_keycode_match(keycode, OB_KEY_LEFT)) {
+                /* Left goes to the parent menu */
+                if (frame->parent) {
+                    /* remove focus from the child */
+                    menu_frame_select(frame, NULL, TRUE);
+                    /* and put it in the parent */
+                    menu_frame_select(frame->parent, frame->parent->selected,
+                                      TRUE);
+                }
+                ret = TRUE;
+            }
+
+            else if (ob_keycode_match(keycode, OB_KEY_RIGHT)) {
+                /* Right goes to the selected submenu */
+                if (frame->selected->entry->type == OB_MENU_ENTRY_TYPE_SUBMENU)
+                {
+                    /* make sure it is visible */
+                    menu_frame_select(frame, frame->selected, TRUE);
+                    menu_frame_select_next(frame->child);
+                }
+                ret = TRUE;
+            }
 
-    /* Use KeyRelease events for running things so that the key release doesn't
-       get sent to the focused application.
+            else if (ob_keycode_match(keycode, OB_KEY_UP)) {
+                menu_frame_select_previous(frame);
+                ret = TRUE;
+            }
 
-       Allow ControlMask only, and don't bother if the menu is empty */
-    else if (ev->type == KeyRelease && (state & ~ControlMask) == 0 &&
-             frame->entries && frame->got_press)
-    {
-        if (keycode == ob_keycode(OB_KEY_RETURN)) {
-            /* Enter runs the active item or goes into the submenu.
-               Control-Enter runs it without closing the menu. */
-            if (frame->child)
-                menu_frame_select_next(frame->child);
-            else if (frame->selected)
-                menu_entry_frame_execute(frame->selected, state);
-
-            ret = TRUE;
-        }
+            else if (ob_keycode_match(keycode, OB_KEY_DOWN)) {
+                menu_frame_select_next(frame);
+                ret = TRUE;
+            }
 
-        /* keyboard accelerator shortcuts. (if it was a valid key) */
-        else if (unikey != 0) {
-            GList *start;
-            GList *it;
-            ObMenuEntryFrame *found = NULL;
-            guint num_found = 0;
-
-            /* start after the selected one */
-            start = frame->entries;
-            if (frame->selected) {
-                for (it = start; frame->selected != it->data;
-                     it = g_list_next(it))
-                    g_assert(it != NULL); /* nothing was selected? */
-                /* next with wraparound */
-                start = g_list_next(it);
-                if (start == NULL) start = frame->entries;
+            else if (ob_keycode_match(keycode, OB_KEY_HOME)) {
+                menu_frame_select_first(frame);
+                ret = TRUE;
             }
 
-            it = start;
-            do {
-                ObMenuEntryFrame *e = it->data;
-                gunichar entrykey = 0;
+            else if (ob_keycode_match(keycode, OB_KEY_END)) {
+                menu_frame_select_last(frame);
+                ret = TRUE;
+            }
+        }
 
-                if (e->entry->type == OB_MENU_ENTRY_TYPE_NORMAL)
-                    entrykey = e->entry->data.normal.shortcut;
-                else if (e->entry->type == OB_MENU_ENTRY_TYPE_SUBMENU)
-                    entrykey = e->entry->data.submenu.submenu->shortcut;
+        /* Use KeyRelease events for running things so that the key release
+           doesn't get sent to the focused application.
 
-                if (unikey == entrykey) {
-                    if (found == NULL) found = e;
-                    ++num_found;
-                }
+           Allow ControlMask only, and don't bother if the menu is empty */
+        else if (ev->type == KeyRelease && (state & ~ControlMask) == 0 &&
+                 frame->entries && frame->got_press)
+        {
+            if (ob_keycode_match(keycode, OB_KEY_RETURN)) {
+                /* Enter runs the active item or goes into the submenu.
+                   Control-Enter runs it without closing the menu. */
+                if (frame->child)
+                    menu_frame_select_next(frame->child);
+                else if (frame->selected)
+                    menu_entry_frame_execute(frame->selected, state);
 
-                /* next with wraparound */
-                it = g_list_next(it);
-                if (it == NULL) it = frame->entries;
-            } while (it != start);
+                ret = TRUE;
+            }
 
-            if (found) {
-                if (found->entry->type == OB_MENU_ENTRY_TYPE_NORMAL &&
-                    num_found == 1)
-                {
-                    menu_frame_select(frame, found, TRUE);
-                    usleep(50000); /* highlight the item for a short bit so the
-                                      user can see what happened */
-                    menu_entry_frame_execute(found, state);
-                } else {
-                    menu_frame_select(frame, found, TRUE);
-                    if (num_found == 1)
-                        menu_frame_select_next(frame->child);
+            /* keyboard accelerator shortcuts. (if it was a valid key) */
+            else if (unikey != 0) {
+                GList *start;
+                GList *it;
+                ObMenuEntryFrame *found = NULL;
+                guint num_found = 0;
+
+                /* start after the selected one */
+                start = frame->entries;
+                if (frame->selected) {
+                    for (it = start; frame->selected != it->data;
+                         it = g_list_next(it))
+                        g_assert(it != NULL); /* nothing was selected? */
+                    /* next with wraparound */
+                    start = g_list_next(it);
+                    if (start == NULL) start = frame->entries;
                 }
 
-                ret = TRUE;
+                it = start;
+                do {
+                    ObMenuEntryFrame *e = it->data;
+                    gunichar entrykey = 0;
+
+                    if (e->entry->type == OB_MENU_ENTRY_TYPE_NORMAL)
+                        entrykey = e->entry->data.normal.shortcut;
+                    else if (e->entry->type == OB_MENU_ENTRY_TYPE_SUBMENU)
+                        entrykey = e->entry->data.submenu.submenu->shortcut;
+
+                    if (unikey == entrykey) {
+                        if (found == NULL) found = e;
+                        ++num_found;
+                    }
+
+                    /* next with wraparound */
+                    it = g_list_next(it);
+                    if (it == NULL) it = frame->entries;
+                } while (it != start);
+
+                if (found) {
+                    if (found->entry->type == OB_MENU_ENTRY_TYPE_NORMAL &&
+                        num_found == 1)
+                    {
+                        menu_frame_select(frame, found, TRUE);
+                        usleep(50000); /* highlight the item for a short bit so
+                                          the user can see what happened */
+                        menu_entry_frame_execute(found, state);
+                    } else {
+                        menu_frame_select(frame, found, TRUE);
+                        if (num_found == 1)
+                            menu_frame_select_next(frame->child);
+                    }
+
+                    ret = TRUE;
+                }
             }
         }
     }
@@ -1797,27 +1925,21 @@ static gboolean event_handle_menu_keyboard(XEvent *ev)
     return ret;
 }
 
-static gboolean event_handle_menu(XEvent *ev)
+static Bool event_look_for_menu_enter(Display *d, XEvent *ev, XPointer arg)
+{
+    ObMenuFrame *f = (ObMenuFrame*)arg;
+    ObMenuEntryFrame *e;
+    return ev->type == EnterNotify &&
+        (e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window)) &&
+        !e->ignore_enters && e->frame == f;
+}
+
+static void event_handle_menu(ObMenuFrame *frame, XEvent *ev)
 {
     ObMenuFrame *f;
     ObMenuEntryFrame *e;
-    gboolean ret = TRUE;
 
     switch (ev->type) {
-    case ButtonRelease:
-        if (menu_hide_delay_reached() &&
-            (ev->xbutton.button < 4 || ev->xbutton.button > 5))
-        {
-            if ((e = menu_entry_frame_under(ev->xbutton.x_root,
-                                            ev->xbutton.y_root)))
-            {
-                menu_frame_select(e->frame, e, TRUE);
-                menu_entry_frame_execute(e, ev->xbutton.state);
-            }
-            else
-                menu_frame_hide_all();
-        }
-        break;
     case EnterNotify:
         if ((e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window))) {
             if (e->ignore_enters)
@@ -1834,64 +1956,59 @@ static gboolean event_handle_menu(XEvent *ev)
         if (ev->xcrossing.detail == NotifyInferior)
             break;
 
-        if ((e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window)) &&
-            (f = find_active_menu()) && f->selected == e &&
-            e->entry->type != OB_MENU_ENTRY_TYPE_SUBMENU)
+        if ((e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window)))
         {
-            menu_frame_select(e->frame, NULL, FALSE);
+            XEvent ce;
+
+            /* check if an EnterNotify event is coming, and if not, then select
+               nothing in the menu */
+            if (XCheckIfEvent(obt_display, &ce, event_look_for_menu_enter,
+                              (XPointer)e->frame))
+                XPutBackEvent(obt_display, &ce);
+            else
+                menu_frame_select(e->frame, NULL, FALSE);
         }
         break;
-    case MotionNotify:
-        if ((e = menu_entry_frame_under(ev->xmotion.x_root,
-                                        ev->xmotion.y_root)))
-            if (!(f = find_active_menu()) ||
-                f == e->frame ||
-                f->parent == e->frame ||
-                f->child == e->frame)
-                menu_frame_select(e->frame, e, FALSE);
-        break;
-    case KeyPress:
-    case KeyRelease:
-        ret = event_handle_menu_keyboard(ev);
-        break;
     }
-    return ret;
 }
 
-static void event_handle_user_input(ObClient *client, XEvent *e)
+static gboolean event_handle_user_input(ObClient *client, XEvent *e)
 {
     g_assert(e->type == ButtonPress || e->type == ButtonRelease ||
              e->type == MotionNotify || e->type == KeyPress ||
              e->type == KeyRelease);
 
     if (menu_frame_visible) {
-        if (event_handle_menu(e))
+        if (event_handle_menu_input(e))
             /* don't use the event if the menu used it, but if the menu
                didn't use it and it's a keypress that is bound, it will
                close the menu and be used */
-            return;
+            return TRUE;
     }
 
     /* if the keyboard interactive action uses the event then dont
        use it for bindings. likewise is moveresize uses the event. */
-    if (!actions_interactive_input_event(e) && !moveresize_event(e)) {
-        if (moveresize_in_progress)
-            /* make further actions work on the client being
-               moved/resized */
-            client = moveresize_client;
-
-        if (e->type == ButtonPress ||
-            e->type == ButtonRelease ||
-            e->type == MotionNotify)
-        {
-            /* the frame may not be "visible" but they can still click on it
-               in the case where it is animating before disappearing */
-            if (!client || !frame_iconify_animating(client->frame))
-                mouse_event(client, e);
-        } else
-            keyboard_event((focus_cycle_target ? focus_cycle_target :
-                            (client ? client : focus_client)), e);
-    }
+    if (actions_interactive_input_event(e) || moveresize_event(e))
+        return TRUE;
+
+    if (moveresize_in_progress)
+        /* make further actions work on the client being
+           moved/resized */
+        client = moveresize_client;
+
+    if (e->type == ButtonPress ||
+        e->type == ButtonRelease ||
+        e->type == MotionNotify)
+    {
+        /* the frame may not be "visible" but they can still click on it
+           in the case where it is animating before disappearing */
+        if (!client || !frame_iconify_animating(client->frame))
+            return mouse_event(client, e);
+    } else
+        return keyboard_event((focus_cycle_target ? focus_cycle_target :
+                               (client ? client : focus_client)), e);
+
+    return FALSE;
 }
 
 static void focus_delay_dest(gpointer data)
@@ -1910,9 +2027,6 @@ static gboolean focus_delay_func(gpointer data)
     ObFocusDelayData *d = data;
     Time old = event_curtime;
 
-    /* don't move focus and kill the menu or the move/resize */
-    if (menu_frame_visible || moveresize_in_progress) return FALSE;
-
     event_curtime = d->time;
     event_curserial = d->serial;
     if (client_focus(d->client) && config_focus_raise)
@@ -1921,22 +2035,37 @@ static gboolean focus_delay_func(gpointer data)
     return FALSE; /* no repeat */
 }
 
+static gboolean unfocus_delay_func(gpointer data)
+{
+    ObFocusDelayData *d = data;
+    Time old = event_curtime;
+
+    event_curtime = d->time;
+    event_curserial = d->serial;
+    focus_nothing();
+    event_curtime = old;
+    return FALSE; /* no repeat */
+}
+
 static void focus_delay_client_dest(ObClient *client, gpointer data)
 {
-    ob_main_loop_timeout_remove_data(ob_main_loop, focus_delay_func,
-                                     client, FALSE);
+    obt_main_loop_timeout_remove_data(ob_main_loop, focus_delay_func,
+                                      client, FALSE);
+    obt_main_loop_timeout_remove_data(ob_main_loop, unfocus_delay_func,
+                                      client, FALSE);
 }
 
 void event_halt_focus_delay(void)
 {
     /* ignore all enter events up till the event which caused this to occur */
     if (event_curserial) event_ignore_enter_range(1, event_curserial);
-    ob_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
+    obt_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
+    obt_main_loop_timeout_remove(ob_main_loop, unfocus_delay_func);
 }
 
 gulong event_start_ignore_all_enters(void)
 {
-    return NextRequest(ob_display);
+    return NextRequest(obt_display);
 }
 
 static void event_ignore_enter_range(gulong start, gulong end)
@@ -1951,11 +2080,11 @@ static void event_ignore_enter_range(gulong start, gulong end)
     r->end = end;
     ignore_serials = g_slist_prepend(ignore_serials, r);
 
-    ob_debug_type(OB_DEBUG_FOCUS, "ignoring enters from %lu until %lu\n",
+    ob_debug_type(OB_DEBUG_FOCUS, "ignoring enters from %lu until %lu",
                   r->start, r->end);
 
     /* increment the serial so we don't ignore events we weren't meant to */
-    PROP_ERASE(screen_support_win, motif_wm_hints);
+    OBT_PROP_ERASE(screen_support_win, MOTIF_WM_HINTS);
 }
 
 void event_end_ignore_all_enters(gulong start)
@@ -1966,7 +2095,7 @@ void event_end_ignore_all_enters(gulong start)
        movement will be ignored until we create some further network traffic.
        Instead ignore up to NextRequest-1, then when we increment the serial,
        we will be *past* the range of ignored serials */
-    event_ignore_enter_range(start, NextRequest(ob_display)-1);
+    event_ignore_enter_range(start, NextRequest(obt_display)-1);
 }
 
 static gboolean is_enter_focus_event_ignored(gulong serial)
@@ -1993,27 +2122,27 @@ void event_cancel_all_key_grabs(void)
 {
     if (actions_interactive_act_running()) {
         actions_interactive_cancel_act();
-        ob_debug("KILLED interactive action\n");
+        ob_debug("KILLED interactive action");
     }
     else if (menu_frame_visible) {
         menu_frame_hide_all();
-        ob_debug("KILLED open menus\n");
+        ob_debug("KILLED open menus");
     }
     else if (moveresize_in_progress) {
         moveresize_end(TRUE);
-        ob_debug("KILLED interactive moveresize\n");
+        ob_debug("KILLED interactive moveresize");
     }
     else if (grab_on_keyboard()) {
         ungrab_keyboard();
-        ob_debug("KILLED active grab on keyboard\n");
+        ob_debug("KILLED active grab on keyboard");
     }
     else
         ungrab_passive_key();
 
-    XSync(ob_display, FALSE);
+    XSync(obt_display, FALSE);
 }
 
-gboolean event_time_after(Time t1, Time t2)
+gboolean event_time_after(guint32 t1, guint32 t2)
 {
     g_assert(t1 != CurrentTime);
     g_assert(t2 != CurrentTime);
@@ -2026,8 +2155,10 @@ gboolean event_time_after(Time t1, Time t2)
       - http://tronche.com/gui/x/xlib/input/pointer-grabbing.html
     */
 
-    /* TIME_HALF is half of the number space of a Time type variable */
-#define TIME_HALF (Time)(1 << (sizeof(Time)*8-1))
+    /* TIME_HALF is not half of the number space of a Time type variable.
+     * Rather, it is half the number space of a timestamp value, which is
+     * always 32 bits. */
+#define TIME_HALF (guint32)(1 << 31)
 
     if (t2 >= TIME_HALF)
         /* t2 is in the second half so t1 might wrap around and be smaller than
@@ -2043,9 +2174,9 @@ Time event_get_server_time(void)
     /* Generate a timestamp */
     XEvent event;
 
-    XChangeProperty(ob_display, screen_support_win,
-                    prop_atoms.wm_class, prop_atoms.string,
+    XChangeProperty(obt_display, screen_support_win,
+                    OBT_PROP_ATOM(WM_CLASS), OBT_PROP_ATOM(STRING),
                     8, PropModeAppend, NULL, 0);
-    XWindowEvent(ob_display, screen_support_win, PropertyChangeMask, &event);
+    XWindowEvent(obt_display, screen_support_win, PropertyChangeMask, &event);
     return event.xproperty.time;
 }