X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fevent.c;h=5207e093d23df035ceb9eb520ada9781387c60e4;hb=5563e251c36a1fbda703cf4bc3c8c6ae543829bd;hp=3052e1bf8f6cbd345d2eedaf82786757c6988ae6;hpb=99c6a00cf6cae461f45d8fd3e852a9479f3694bc;p=chaz%2Fopenbox

diff --git a/openbox/event.c b/openbox/event.c
index 3052e1bf..5207e093 100644
--- a/openbox/event.c
+++ b/openbox/event.c
@@ -22,9 +22,8 @@
 #include "window.h"
 #include "openbox.h"
 #include "dock.h"
+#include "actions.h"
 #include "client.h"
-#include "xerror.h"
-#include "prop.h"
 #include "config.h"
 #include "screen.h"
 #include "frame.h"
@@ -32,18 +31,16 @@
 #include "menu.h"
 #include "menuframe.h"
 #include "keyboard.h"
-#include "modkeys.h"
-#include "propwin.h"
 #include "mouse.h"
-#include "mainloop.h"
-#include "framerender.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>
@@ -75,6 +72,7 @@ typedef struct
 {
     ObClient *client;
     Time time;
+    gulong serial;
 } ObFocusDelayData;
 
 typedef struct
@@ -85,23 +83,25 @@ 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 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_time_window_clients(GSList *l, XEvent *e);
 static void event_handle_user_input(ObClient *client, XEvent *e);
 static gboolean is_enter_focus_event_ignored(XEvent *e);
+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 void focus_delay_client_dest(ObClient *client, gpointer data);
 
-/* The time for the current event being processed */
 Time event_curtime = CurrentTime;
+Time event_last_user_time = CurrentTime;
+/*! The serial of the current X event */
 
+static gulong event_curserial;
 static gboolean focus_left_screen = FALSE;
 /*! A list of ObSerialRanges which are to be ignored for mouse enter events */
 static GSList *ignore_serials = NULL;
@@ -120,9 +120,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;
     }
 }
@@ -132,7 +132,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);
@@ -159,9 +159,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:
@@ -178,7 +184,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;
@@ -188,8 +196,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
@@ -227,8 +235,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;
         }
@@ -238,6 +246,12 @@ static void event_set_curtime(XEvent *e)
         break;
     }
 
+    /* watch that if we get an event earlier than the last specified user_time,
+       which can happen if the clock goes backwards, we erase the last
+       specified user_time */
+    if (t && event_last_user_time && event_time_after(event_last_user_time, t))
+        event_last_user_time = CurrentTime;
+
     event_curtime = t;
 }
 
@@ -250,29 +264,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:
-        e->xkey.state = modkeys_only_modifier_masks(e->xkey.state);
 #ifdef XKB
-        if (XkbGetState(ob_display, XkbUseCoreKbd, &xkb_state) == Success) {
-            e->xkey.state = xkb_state.compat_state;
-            break;
-        }
+        /* 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(obt_display, XkbUseCoreKbd, &xkb_state) == Success)
+            e->xkey.state =
+                obt_keyboard_only_modmasks(xkb_state.compat_state);
+        else
 #endif
-        /* 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_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 &= ~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;
@@ -302,7 +321,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)
@@ -323,7 +342,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;
         }
@@ -356,7 +375,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.. */
@@ -412,7 +431,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);
@@ -438,43 +457,44 @@ 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;
-    GSList *timewinclients = NULL;
-    XEvent ee, *e;
-    ObEventData *ed = data;
+    ObMenuFrame *menu = NULL;
 
     /* make a copy we can mangle */
     ee = *ec;
     e = &ee;
 
     window = event_get_window(e);
-    if (e->type != PropertyNotify ||
-        !(timewinclients = propwin_get_clients(window,
-                                               OB_PROPWIN_USER_TIME)))
-        if ((obwin = g_hash_table_lookup(window_map, &window))) {
-            switch (obwin->type) {
-            case Window_Dock:
-                dock = WINDOW_AS_DOCK(obwin);
-                break;
-            case Window_DockApp:
-                dockapp = WINDOW_AS_DOCKAPP(obwin);
-                break;
-            case Window_Client:
-                client = WINDOW_AS_CLIENT(obwin);
-                break;
-            case Window_Menu:
-            case Window_Internal:
-                /* not to be used for events */
-                g_assert_not_reached();
-                break;
-            }
+    if (window == obt_root(ob_screen))
+        /* don't do any lookups, waste of cpu */;
+    else if ((obwin = window_find(window))) {
+        switch (obwin->type) {
+        case OB_WINDOW_CLASS_DOCK:
+            dock = WINDOW_AS_DOCK(obwin);
+            break;
+        case OB_WINDOW_CLASS_CLIENT:
+            client = WINDOW_AS_CLIENT(obwin);
+            break;
+        case OB_WINDOW_CLASS_MENUFRAME:
+            menu = WINDOW_AS_MENUFRAME(obwin);
+            break;
+        case OB_WINDOW_CLASS_INTERNAL:
+            /* we don't do anything with events directly on these windows */
+            break;
         }
+    }
+    else
+        dockapp = dock_find_dockapp(window);
 
     event_set_curtime(e);
+    event_curserial = e->xany.serial;
     event_hack_mods(e);
     if (event_ignore(e, client)) {
         if (ed)
@@ -485,12 +505,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)
         {
@@ -499,7 +514,7 @@ static void event_process(const XEvent *ec, gpointer data)
 
             focus_left_screen = FALSE;
 
-            focus_fallback(FALSE, config_focus_under_mouse, TRUE);
+            focus_fallback(FALSE, config_focus_under_mouse, TRUE, TRUE);
 
             /* We don't get a FocusOut for this case, because it's just moving
                from our Inferior up to us. This happens when iconifying a
@@ -508,15 +523,15 @@ static void event_process(const XEvent *ec, gpointer data)
             /* focus_set_client(NULL) has already been called */
             client_calc_layer(client);
         }
-        if (e->xfocus.detail == NotifyPointerRoot ||
-            e->xfocus.detail == NotifyDetailNone ||
-            e->xfocus.detail == NotifyInferior ||
-            e->xfocus.detail == NotifyNonlinear)
+        else if (e->xfocus.detail == NotifyPointerRoot ||
+                 e->xfocus.detail == NotifyDetailNone ||
+                 e->xfocus.detail == NotifyInferior ||
+                 e->xfocus.detail == NotifyNonlinear)
         {
             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)
@@ -537,12 +552,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.
 
@@ -551,13 +566,14 @@ static void event_process(const XEvent *ec, gpointer data)
                 */
 
                 if (!focus_left_screen)
-                    focus_fallback(FALSE, config_focus_under_mouse, TRUE);
+                    focus_fallback(FALSE, config_focus_under_mouse,
+                                   TRUE, TRUE);
             }
         }
         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.
@@ -576,25 +592,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 {
@@ -605,9 +621,9 @@ 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);
+                focus_fallback(TRUE, config_focus_under_mouse, TRUE, TRUE);
             }
         }
 
@@ -617,22 +633,32 @@ static void event_process(const XEvent *ec, gpointer data)
                section or by focus_fallback */
             client_calc_layer(client);
         }
-    } else if (timewinclients)
-        event_handle_user_time_window_clients(timewinclients, e);
+    }
     else if (client)
         event_handle_client(client, e);
     else if (dockapp)
         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.");
+        obt_keyboard_reload();
+        keyboard_rebind();
+    }
     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);
@@ -643,8 +669,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);
@@ -662,17 +688,17 @@ static void event_process(const XEvent *ec, gpointer data)
         xwc.border_width = e->xconfigurerequest.border_width;
         xwc.sibling = e->xconfigurerequest.above;
         xwc.stack_mode = e->xconfigurerequest.detail;
-       
+
         /* 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)
@@ -680,25 +706,43 @@ static void event_process(const XEvent *ec, gpointer data)
     }
 #endif
 
-    if (e->type == ButtonPress || e->type == ButtonRelease ||
-        e->type == MotionNotify || e->type == KeyPress ||
-        e->type == KeyRelease)
-    {
-        event_handle_user_input(client, e);
+    if (e->type == ButtonPress || e->type == ButtonRelease) {
+        /* If the button press was on some non-root window, or was physically
+           on the root window, the process it */
+        if (window != obt_root(ob_screen) ||
+            e->xbutton.subwindow == None)
+        {
+            event_handle_user_input(client, e);
+        }
+        /* Otherwise only process it if it was physically on an openbox
+           internal window */
+        else {
+            ObWindow *w;
+
+            if ((w = window_find(e->xbutton.subwindow)) &&
+                WINDOW_IS_INTERNAL(w))
+            {
+                event_handle_user_input(client, e);
+            }
+        }
     }
+    else if (e->type == KeyPress || e->type == KeyRelease ||
+             e->type == MotionNotify)
+        event_handle_user_input(client, e);
 
     /* if something happens and it's not from an XEvent, then we don't know
        the time */
     event_curtime = CurrentTime;
+    event_curserial = 0;
 }
 
 static void event_handle_root(XEvent *e)
 {
     Atom msgtype;
-     
+
     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;
 
@@ -706,36 +750,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 == 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:
@@ -757,34 +806,27 @@ 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,
-                                     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;
             data.time = event_curtime;
+            data.serial = event_curserial;
             focus_delay_func(&data);
         }
     }
 }
 
-static void event_handle_user_time_window_clients(GSList *l, XEvent *e)
-{
-    g_assert(e->type == PropertyNotify);
-    if (e->xproperty.atom == prop_atoms.net_wm_user_time) {
-        for (; l; l = g_slist_next(l))
-            client_update_user_time(l->data);
-    }
-}
-
 static void event_handle_client(ObClient *client, XEvent *e)
 {
     XEvent ce;
@@ -792,7 +834,7 @@ static void event_handle_client(ObClient *client, XEvent *e)
     ObFrameContext con;
     static gint px = -1, py = -1;
     static guint pb = 0;
-     
+
     switch (e->type) {
     case ButtonPress:
         /* save where the press occured for the first button pressed */
@@ -809,8 +851,7 @@ static void event_handle_client(ObClient *client, XEvent *e)
            want to deal with them
         */
         if (!(e->xbutton.button == 4 || e->xbutton.button == 5) &&
-            !keyboard_interactively_grabbed() &&
-            !menu_frame_visible)
+            !grab_on_keyboard())
         {
             /* use where the press occured */
             con = frame_context(client, e->xbutton.window, px, py);
@@ -823,23 +864,23 @@ static void event_handle_client(ObClient *client, XEvent *e)
             switch (con) {
             case OB_FRAME_CONTEXT_MAXIMIZE:
                 client->frame->max_press = (e->type == ButtonPress);
-                framerender_frame(client->frame);
+                frame_adjust_state(client->frame);
                 break;
             case OB_FRAME_CONTEXT_CLOSE:
                 client->frame->close_press = (e->type == ButtonPress);
-                framerender_frame(client->frame);
+                frame_adjust_state(client->frame);
                 break;
             case OB_FRAME_CONTEXT_ICONIFY:
                 client->frame->iconify_press = (e->type == ButtonPress);
-                framerender_frame(client->frame);
+                frame_adjust_state(client->frame);
                 break;
             case OB_FRAME_CONTEXT_ALLDESKTOPS:
                 client->frame->desk_press = (e->type == ButtonPress);
-                framerender_frame(client->frame);
-                break; 
+                frame_adjust_state(client->frame);
+                break;
             case OB_FRAME_CONTEXT_SHADE:
                 client->frame->shade_press = (e->type == ButtonPress);
-                framerender_frame(client->frame);
+                frame_adjust_state(client->frame);
                 break;
             default:
                 /* nothing changes with clicks for any other contexts */
@@ -953,11 +994,11 @@ 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 (keyboard_interactively_grabbed())
+            if (grab_on_keyboard())
                 break;
             if (config_focus_follow && config_focus_delay &&
                 /* leave inferior events can happen when the mouse goes onto
@@ -965,9 +1006,9 @@ static void event_handle_client(ObClient *client, XEvent *e)
                    delay is up */
                 e->xcrossing.detail != NotifyInferior)
             {
-                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);
             }
             break;
         default:
@@ -1000,7 +1041,7 @@ static void event_handle_client(ObClient *client, XEvent *e)
             frame_adjust_state(client->frame);
             break;
         case OB_FRAME_CONTEXT_FRAME:
-            if (keyboard_interactively_grabbed())
+            if (grab_on_keyboard())
                 break;
             if (e->xcrossing.mode == NotifyGrab ||
                 e->xcrossing.mode == NotifyUngrab ||
@@ -1009,18 +1050,23 @@ static void event_handle_client(ObClient *client, XEvent *e)
                 is_enter_focus_event_ignored(e))
             {
                 ob_debug_type(OB_DEBUG_FOCUS,
-                              "%sNotify mode %d detail %d on %lx IGNORED\n",
+                              "%sNotify mode %d detail %d serial %lu on %lx "
+                              "IGNORED",
                               (e->type == EnterNotify ? "Enter" : "Leave"),
                               e->xcrossing.mode,
-                              e->xcrossing.detail, client?client->window:0);
+                              e->xcrossing.detail,
+                              e->xcrossing.serial,
+                              client?client->window:0);
             }
             else {
                 ob_debug_type(OB_DEBUG_FOCUS,
-                              "%sNotify mode %d detail %d on %lx, "
-                              "focusing window\n",
+                              "%sNotify mode %d detail %d serial %lu on %lx, "
+                              "focusing window",
                               (e->type == EnterNotify ? "Enter" : "Leave"),
                               e->xcrossing.mode,
-                              e->xcrossing.detail, (client?client->window:0));
+                              e->xcrossing.detail,
+                              e->xcrossing.serial,
+                              (client?client->window:0));
                 if (config_focus_follow)
                     event_enter_client(client);
             }
@@ -1046,10 +1092,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",
+                 "visibile %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)
@@ -1068,26 +1114,33 @@ static void event_handle_client(ObClient *client, XEvent *e)
         if (e->xconfigurerequest.value_mask & CWStackMode) {
             ObClient *sibling = NULL;
             gulong ignore_start;
+            gboolean ok = TRUE;
 
             /* get the sibling */
             if (e->xconfigurerequest.value_mask & CWSibling) {
                 ObWindow *win;
-                win = g_hash_table_lookup(window_map,
-                                          &e->xconfigurerequest.above);
-                if (WINDOW_IS_CLIENT(win) && WINDOW_AS_CLIENT(win) != client)
+                win = window_find(e->xconfigurerequest.above);
+                if (win && WINDOW_IS_CLIENT(win) &&
+                    WINDOW_AS_CLIENT(win) != client)
+                {
                     sibling = WINDOW_AS_CLIENT(win);
+                }
+                else
+                    /* an invalid sibling was specified so don't restack at
+                       all, it won't make sense no matter what we do */
+                    ok = FALSE;
             }
 
-            /* activate it rather than just focus it */
-            if (!config_focus_under_mouse)
-                ignore_start = event_start_ignore_all_enters();
-            stacking_restack_request(client, sibling,
-                                     e->xconfigurerequest.detail,
-                                     TRUE);
-            if (!config_focus_under_mouse)
-                event_end_ignore_all_enters(ignore_start);
+            if (ok) {
+                if (!config_focus_under_mouse)
+                    ignore_start = event_start_ignore_all_enters();
+                stacking_restack_request(client, sibling,
+                                         e->xconfigurerequest.detail);
+                if (!config_focus_under_mouse)
+                    event_end_ignore_all_enters(ignore_start);
+            }
 
-            /* if a stacking change moves the window without resizing */
+            /* a stacking change moves the window without resizing */
             move = TRUE;
         }
 
@@ -1122,7 +1175,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,
@@ -1148,7 +1201,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;
@@ -1160,7 +1213,6 @@ static void event_handle_client(ObClient *client, XEvent *e)
 
         {
             gint lw,lh;
-            gulong ignore_start;
 
             client_try_configure(client, &x, &y, &w, &h, &lw, &lh, FALSE);
 
@@ -1177,27 +1229,25 @@ static void event_handle_client(ObClient *client, XEvent *e)
 
             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);
-            ignore_start = event_start_ignore_all_enters();
-            client_configure(client, x, y, w, h, FALSE, TRUE);
-            event_end_ignore_all_enters(ignore_start);
+            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:
@@ -1213,19 +1263,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);
-     
-        ob_debug("ReparentNotify for window 0x%x\n", client->window);
+        XPutBackEvent(obt_display, e);
+
+        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);
+        client_activate(client, FALSE, TRUE, TRUE, TRUE);
         break;
     case ClientMessage:
         /* validate cuz we query stuff off the client here */
@@ -1234,29 +1284,29 @@ 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) {
+        if (msgtype == OBT_PROP_ATOM(WM_CHANGE_STATE)) {
             /* compress changes into a single change */
-            while (XCheckTypedWindowEvent(ob_display, client->window,
+            while (XCheckTypedWindowEvent(obt_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);
+                    XPutBackEvent(obt_display, &ce);
                     break;
                 }
                 e->xclient = ce.xclient;
             }
             client_set_wm_state(client, e->xclient.data.l[0]);
-        } else if (msgtype == prop_atoms.net_wm_desktop) {
+        } else if (msgtype == OBT_PROP_ATOM(NET_WM_DESKTOP)) {
             /* compress changes into a single change */
-            while (XCheckTypedWindowEvent(ob_display, client->window,
+            while (XCheckTypedWindowEvent(obt_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);
+                    XPutBackEvent(obt_display, &ce);
                     break;
                 }
                 e->xclient = ce.xclient;
@@ -1265,11 +1315,11 @@ static void event_handle_client(ObClient *client, XEvent *e)
                 (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"),
@@ -1283,67 +1333,69 @@ 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) {
-                event_curtime = e->xclient.data.l[1];
-                if (event_curtime == 0)
+                /* 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];*/
+                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, FALSE,
+                              "missing source indication");
+            client_activate(client, 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;
-            gulong ignore_start;
 
             ograv = client->gravity;
 
@@ -1381,30 +1433,26 @@ static void event_handle_client(ObClient *client, XEvent *e)
             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);
 
             client_find_onscreen(client, &x, &y, w, h, FALSE);
 
-            /* ignore enter events caused by these like ob actions do */
-            ignore_start = event_start_ignore_all_enters();
-            client_configure(client, x, y, w, h, FALSE, TRUE);
-            event_end_ignore_all_enters(ignore_start);
+            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)
                     {
@@ -1413,7 +1461,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 ||
@@ -1428,7 +1476,7 @@ static void event_handle_client(ObClient *client, XEvent *e)
                         ignore_start = event_start_ignore_all_enters();
                     /* just raise, don't activate */
                     stacking_restack_request(client, sibling,
-                                             e->xclient.data.l[2], FALSE);
+                                             e->xclient.data.l[2]);
                     if (!config_focus_under_mouse)
                         event_end_ignore_all_enters(ignore_start);
 
@@ -1438,7 +1486,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]);
             }
         }
@@ -1446,9 +1494,9 @@ static void event_handle_client(ObClient *client, XEvent *e)
     case PropertyNotify:
         /* validate cuz we query stuff off the client here */
         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;
 
@@ -1460,28 +1508,28 @@ 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");
+            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);
@@ -1498,35 +1546,40 @@ 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) {
+        else if (msgtype == OBT_PROP_ATOM(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_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) {
-            client_update_user_time(client);
-        }
-        else if (msgtype == prop_atoms.net_wm_user_time_window) {
-            client_update_user_time_window(client);
+        else if (msgtype == OBT_PROP_ATOM(NET_WM_USER_TIME)) {
+            guint32 t;
+            if (client == focus_client &&
+                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)))
+            {
+                event_last_user_time = t;
+            }
         }
 #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
@@ -1537,7 +1590,9 @@ static void event_handle_client(ObClient *client, XEvent *e)
     default:
         ;
 #ifdef SHAPE
-        if (extensions_shape && e->type == extensions_shape_event_basep) {
+        if (obt_display_extension_shape &&
+            e->type == obt_display_extension_shape_basep)
+        {
             client->shaped = ((XShapeEvent*)e)->shaped;
             frame_adjust_shape(client->frame);
         }
@@ -1576,13 +1631,13 @@ 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);
+        dock_unmanage(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);
@@ -1590,7 +1645,7 @@ static void event_handle_dockapp(ObDockApp *app, XEvent *e)
     }
 }
 
-static ObMenuFrame* find_active_menu()
+static ObMenuFrame* find_active_menu(void)
 {
     GList *it;
     ObMenuFrame *ret = NULL;
@@ -1604,7 +1659,7 @@ static ObMenuFrame* find_active_menu()
     return ret;
 }
 
-static ObMenuFrame* find_active_or_last_menu()
+static ObMenuFrame* find_active_or_last_menu(void)
 {
     ObMenuFrame *ret = NULL;
 
@@ -1614,139 +1669,169 @@ static ObMenuFrame* find_active_or_last_menu()
     return ret;
 }
 
-static gboolean event_handle_menu_keyboard(XEvent *ev)
+static gboolean event_handle_menu_input(XEvent *ev)
 {
-    guint keycode, state;
-    gunichar unikey;
-    ObMenuFrame *frame;
-    gboolean ret = TRUE;
-
-    keycode = ev->xkey.keycode;
-    state = ev->xkey.state;
-    unikey = translate_unichar(keycode);
+    gboolean ret = FALSE;
 
-    frame = find_active_or_last_menu();
-    if (frame == NULL)
-        ret = FALSE;
+    if (ev->type == ButtonRelease) {
+        ObMenuEntryFrame *e;
 
-    else if (keycode == ob_keycode(OB_KEY_ESCAPE) && state == 0)
-        menu_frame_hide_all();
-
-    else if (keycode == ob_keycode(OB_KEY_RETURN) && (state == 0 ||
-                                                      state == ControlMask))
-    {
-        /* 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, ev->xkey.time);
+        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();
+        }
+        ret = TRUE;
     }
+    else if (ev->type == MotionNotify) {
+        ObMenuFrame *f;
+        ObMenuEntryFrame *e;
 
-    else if (keycode == ob_keycode(OB_KEY_LEFT) && ev->xkey.state == 0) {
-        /* Left goes to the parent menu */
-        menu_frame_select(frame, NULL, 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;
 
-    else if (keycode == ob_keycode(OB_KEY_RIGHT) && ev->xkey.state == 0) {
-        /* Right goes to the selected submenu */
-        if (frame->child) menu_frame_select_next(frame->child);
-    }
+        keycode = ev->xkey.keycode;
+        state = ev->xkey.state;
+        unikey = obt_keyboard_keycode_to_unichar(keycode);
 
-    else if (keycode == ob_keycode(OB_KEY_UP) && state == 0) {
-        menu_frame_select_previous(frame);
-    }
+        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_DOWN) && state == 0) {
-        menu_frame_select_next(frame);
-    }
+        /* Allow control while going thru the menu */
+        else if (ev->type == KeyPress && (state & ~ControlMask) == 0) {
+            frame->got_press = TRUE;
 
-    /* keyboard accelerator shortcuts. (allow controlmask) */
-    else if ((ev->xkey.state & ~ControlMask) == 0 &&
-             /* was it a valid key? */
-             unikey != 0 &&
-             /* don't bother if the menu is empty. */
-             frame->entries)
-    {
-        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;
-        }
+            if (keycode == ob_keycode(OB_KEY_ESCAPE)) {
+                menu_frame_hide_all();
+                ret = TRUE;
+            }
 
-        it = start;
-        do {
-            ObMenuEntryFrame *e = it->data;
-            gunichar entrykey = 0;
+            else if (keycode == ob_keycode(OB_KEY_LEFT)) {
+                /* Left goes to the parent menu */
+                menu_frame_select(frame, NULL, TRUE);
+                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;
+            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;
+            }
 
-            if (unikey == entrykey) {
-                if (found == NULL) found = e;
-                ++num_found;
+            else if (keycode == ob_keycode(OB_KEY_UP)) {
+                menu_frame_select_previous(frame);
+                ret = TRUE;
             }
 
-            /* next with wraparound */
-            it = g_list_next(it);
-            if (it == NULL) it = frame->entries;
-        } while (it != start);
+            else if (keycode == ob_keycode(OB_KEY_DOWN)) {
+                menu_frame_select_next(frame);
+                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, ev->xkey.time);
-            } else {
-                menu_frame_select(frame, found, TRUE);
-                if (num_found == 1)
+        /* Use KeyRelease events for running things so that the key release
+           doesn't get sent to the focused application.
+
+           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
-            ret = FALSE;
+
+            /* 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;
+                }
+
+                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;
+                }
+            }
+        }
     }
-    else
-        ret = FALSE;
 
     return ret;
 }
 
-static gboolean event_handle_menu(XEvent *ev)
+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,
-                                         ev->xbutton.time);
-            }
-            else
-                menu_frame_hide_all();
-        }
-        break;
     case EnterNotify:
         if ((e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window))) {
             if (e->ignore_enters)
@@ -1770,20 +1855,7 @@ static gboolean event_handle_menu(XEvent *ev)
             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:
-        ret = event_handle_menu_keyboard(ev);
-        break;
     }
-    return ret;
 }
 
 static void event_handle_user_input(ObClient *client, XEvent *e)
@@ -1793,7 +1865,7 @@ static void event_handle_user_input(ObClient *client, XEvent *e)
              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 */
@@ -1802,9 +1874,7 @@ static void event_handle_user_input(ObClient *client, XEvent *e)
 
     /* if the keyboard interactive action uses the event then dont
        use it for bindings. likewise is moveresize uses the event. */
-    if (!keyboard_process_interactive_grab(e, &client) &&
-        !(moveresize_in_progress && moveresize_event(e)))
-    {
+    if (!actions_interactive_input_event(e) && !moveresize_event(e)) {
         if (moveresize_in_progress)
             /* make further actions work on the client being
                moved/resized */
@@ -1840,46 +1910,63 @@ 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;
-    if (focus_client != d->client) {
-        if (client_focus(d->client) && config_focus_raise)
-            stacking_raise(CLIENT_AS_WINDOW(d->client));
-    }
+    event_curserial = d->serial;
+    if (client_focus(d->client) && config_focus_raise)
+        stacking_raise(CLIENT_AS_WINDOW(d->client));
     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);
 }
 
-void event_halt_focus_delay()
+void event_halt_focus_delay(void)
 {
-    ob_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
+    /* ignore all enter events up till the event which caused this to occur */
+    if (event_curserial) event_ignore_enter_range(1, event_curserial);
+    obt_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
 }
 
-gulong event_start_ignore_all_enters()
+gulong event_start_ignore_all_enters(void)
 {
-    XSync(ob_display, FALSE);
-    return LastKnownRequestProcessed(ob_display);
+    return NextRequest(obt_display);
 }
 
-void event_end_ignore_all_enters(gulong start)
+static void event_ignore_enter_range(gulong start, gulong end)
 {
     ObSerialRange *r;
 
     g_assert(start != 0);
-    XSync(ob_display, FALSE);
+    g_assert(end != 0);
 
     r = g_new(ObSerialRange, 1);
     r->start = start;
-    r->end = LastKnownRequestProcessed(ob_display);
+    r->end = end;
     ignore_serials = g_slist_prepend(ignore_serials, r);
 
+    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 */
-    XSync(ob_display, FALSE);
+    OBT_PROP_ERASE(screen_support_win, MOTIF_WM_HINTS);
+}
+
+void event_end_ignore_all_enters(gulong start)
+{
+    /* Use (NextRequest-1) so that we ignore up to the current serial only.
+       Inside event_ignore_enter_range, we increment the serial by one, but if
+       we ignore that serial too, then any enter events generated by mouse
+       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(obt_display)-1);
 }
 
 static gboolean is_enter_focus_event_ignored(XEvent *e)
@@ -1907,22 +1994,28 @@ static gboolean is_enter_focus_event_ignored(XEvent *e)
     return FALSE;
 }
 
-void event_cancel_all_key_grabs()
+void event_cancel_all_key_grabs(void)
 {
-    if (keyboard_interactively_grabbed()) {
-        keyboard_interactive_cancel();
-        ob_debug("KILLED interactive event\n");
+    if (actions_interactive_act_running()) {
+        actions_interactive_cancel_act();
+        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");
     }
     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(obt_display, FALSE);
 }
 
 gboolean event_time_after(Time t1, Time t2)
@@ -1949,3 +2042,15 @@ gboolean event_time_after(Time t1, Time t2)
         /* t2 is in the first half so t1 has to come after it */
         return t1 >= t2 && t1 < (t2 + TIME_HALF);
 }
+
+Time event_get_server_time(void)
+{
+    /* Generate a timestamp */
+    XEvent event;
+
+    XChangeProperty(obt_display, screen_support_win,
+                    OBT_PROP_ATOM(WM_CLASS), OBT_PROP_ATOM(STRING),
+                    8, PropModeAppend, NULL, 0);
+    XWindowEvent(obt_display, screen_support_win, PropertyChangeMask, &event);
+    return event.xproperty.time;
+}