X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fevent.c;h=f276a07921f8c66a0f8d223078cdb43f97cb80cb;hb=911ad76372394715f7eae88c96eeb6d06396f3be;hp=67afabc994a6d222895625d3569c3c04f270c86b;hpb=5a3a7668d9e3ebe995603fadd2da22cbe1c31c83;p=chaz%2Fopenbox

diff --git a/openbox/event.c b/openbox/event.c
index 67afabc9..f276a079 100644
--- a/openbox/event.c
+++ b/openbox/event.c
@@ -71,7 +71,6 @@ typedef struct
 } ObFocusDelayData;
 
 static void event_process(const XEvent *e, gpointer data);
-static void event_client_dest(ObClient *client, gpointer data);
 static void event_handle_root(XEvent *e);
 static void event_handle_menu(XEvent *e);
 static void event_handle_dock(ObDock *s, XEvent *e);
@@ -79,6 +78,8 @@ static void event_handle_dockapp(ObDockApp *app, XEvent *e);
 static void event_handle_client(ObClient *c, XEvent *e);
 static void event_handle_group(ObGroup *g, XEvent *e);
 
+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);
 
@@ -104,11 +105,6 @@ static guint ignore_enter_focus = 0;
 
 static gboolean menu_can_hide;
 
-static ObFocusDelayData focus_delay_data = { .client = NULL,
-                                             .time = CurrentTime };
-
-
-
 #ifdef USE_SM
 static void ice_handler(gint fd, gpointer conn)
 {
@@ -167,7 +163,6 @@ void event_startup(gboolean reconfig)
 #endif
 
     client_add_destructor(focus_delay_client_dest, NULL);
-    client_add_destructor(event_client_dest, NULL);
 }
 
 void event_shutdown(gboolean reconfig)
@@ -179,7 +174,6 @@ void event_shutdown(gboolean reconfig)
 #endif
 
     client_remove_destructor(focus_delay_client_dest);
-    client_remove_destructor(event_client_dest);
     XFreeModifiermap(modmap);
 }
 
@@ -396,15 +390,8 @@ static Bool look_for_focusin(Display *d, XEvent *e, XPointer arg)
 static gboolean event_ignore(XEvent *e, ObClient *client)
 {
     switch(e->type) {
-    case EnterNotify:
-    case LeaveNotify:
-        return keyboard_interactively_grabbed();
     case FocusIn:
     case FocusOut:
-        /* I don't think this should ever happen with our event masks, but
-           if it does, we don't want it. */
-        if (client == NULL)
-            return TRUE;
         if (!wanted_focusevent(e))
             return TRUE;
         break;
@@ -449,29 +436,6 @@ static void event_process(const XEvent *ec, gpointer data)
             }
         }
 
-    if (e->type == FocusIn || e->type == FocusOut) {
-        gint mode = e->xfocus.mode;
-        gint detail = e->xfocus.detail;
-        Window window = e->xfocus.window;
-        if (detail == NotifyVirtual) {
-            ob_debug_type(OB_DEBUG_FOCUS,
-                          "FOCUS %s NOTIFY VIRTUAL window 0x%x\n",
-                          (e->type == FocusIn ? "IN" : "OUT"), window);
-        }
-
-        else if (detail == NotifyNonlinearVirtual) {
-            ob_debug_type(OB_DEBUG_FOCUS,
-                          "FOCUS %s NOTIFY NONLINVIRTUAL window 0x%x\n",
-                          (e->type == FocusIn ? "IN" : "OUT"), window);
-        }
-
-        else
-            ob_debug_type(OB_DEBUG_FOCUS,
-                          "UNKNOWN FOCUS %s (d %d, m %d) window 0x%x\n",
-                          (e->type == FocusIn ? "IN" : "OUT"),
-                          detail, mode, window);
-    }
-
     event_set_curtime(e);
     event_hack_mods(e);
     if (event_ignore(e, client)) {
@@ -488,6 +452,62 @@ static void event_process(const XEvent *ec, gpointer data)
     {
         /* crossing events for menu */
         event_handle_menu(e);
+    } else if (e->type == FocusIn) {
+        if (e->xfocus.detail == NotifyPointerRoot ||
+                   e->xfocus.detail == NotifyDetailNone) {
+            ob_debug_type(OB_DEBUG_FOCUS, "Focus went to root\n");
+            /* Focus has been reverted to the root window or nothing
+               FocusOut events come after UnmapNotify, so we don't need to
+               worry about focusing an invalid window
+             */
+            focus_fallback(TRUE);
+        } else if (e->xfocus.detail == NotifyInferior) {
+            ob_debug_type(OB_DEBUG_FOCUS, "Focus went to parent\n");
+            /* Focus has been reverted to parent, which is our frame window,
+               or the root window
+               FocusOut events come after UnmapNotify, so we don't need to
+               worry about focusing an invalid window
+            */
+            focus_fallback(TRUE);
+        } else if (client && client != focus_client) {
+            frame_adjust_focus(client->frame, TRUE);
+            focus_set_client(client);
+            client_calc_layer(client);
+        }
+    } else if (e->type == FocusOut) {
+        gboolean nomove = FALSE;
+        XEvent ce;
+
+        ob_debug_type(OB_DEBUG_FOCUS, "FocusOut Event\n");
+
+        /* Look for the followup FocusIn */
+        if (!XCheckIfEvent(ob_display, &ce, 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. */
+            ob_debug_type(OB_DEBUG_FOCUS, "Focus went to a black hole !\n");
+            /* nothing is focused */
+            focus_set_client(NULL);
+        } else if (ce.xany.window == e->xany.window) {
+            /* If focus didn't actually move anywhere, there is nothing to do*/
+            nomove = TRUE;
+        } else {
+            /* Focus did move, so process the FocusIn event */
+            ObEventData ed = { .ignored = FALSE };
+            event_process(&ce, &ed);
+            if (ed.ignored) {
+                /* 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",
+                              ce.xfocus.window);
+                focus_fallback(TRUE);
+            }
+        }
+
+        if (client && !nomove) {
+            frame_adjust_focus(client->frame, FALSE);
+            client_calc_layer(client);
+        }
     } else if (group)
         event_handle_group(group, e);
     else if (client)
@@ -542,15 +562,14 @@ static void event_process(const XEvent *ec, gpointer data)
                 ob_main_loop_timeout_add(ob_main_loop,
                                          config_menu_hide_delay * 1000,
                                          menu_hide_delay_func,
-                                         NULL, NULL);
+                                         NULL, g_direct_equal, NULL);
 
                 if (e->type == ButtonPress || e->type == ButtonRelease ||
-                    e->type == MotionNotify)
+                    e->type == MotionNotify) {
                     mouse_event(client, e);
-                else if (e->type == KeyPress) {
+                } else if (e->type == KeyPress) {
                     keyboard_event((focus_cycle_target ? focus_cycle_target :
-                                    (focus_hilite ? focus_hilite : client)),
-                                   e);
+                                    client), e);
                 }
             }
         }
@@ -627,19 +646,23 @@ void event_enter_client(ObClient *client)
 
     if (client_normal(client) && client_can_focus(client)) {
         if (config_focus_delay) {
+            ObFocusDelayData *data;
+
             ob_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
 
-            focus_delay_data.client = client;
-            focus_delay_data.time = event_curtime;
+            data = g_new(ObFocusDelayData, 1);
+            data->client = client;
+            data->time = event_curtime;
 
             ob_main_loop_timeout_add(ob_main_loop,
                                      config_focus_delay,
                                      focus_delay_func,
-                                     NULL, NULL);
+                                     data, focus_delay_cmp, focus_delay_dest);
         } else {
-            focus_delay_data.client = client;
-            focus_delay_data.time = event_curtime;
-            focus_delay_func(NULL);
+            ObFocusDelayData data;
+            data.client = client;
+            data.time = event_curtime;
+            focus_delay_func(&data);
         }
     }
 }
@@ -689,53 +712,6 @@ static void event_handle_client(ObClient *client, XEvent *e)
             }
         }
         break;
-    case FocusIn:
-        if (client != focus_client) {
-            focus_set_client(client);
-            frame_adjust_focus(client->frame, TRUE);
-            client_calc_layer(client);
-        }
-        break;
-    case FocusOut:
-        /* Look for the followup FocusIn */
-        if (!XCheckIfEvent(ob_display, &ce, 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. */
-            ob_debug_type(OB_DEBUG_FOCUS, "Focus went to a black hole !\n");
-        } else if (ce.xany.window == e->xany.window) {
-            /* If focus didn't actually move anywhere, there is nothing to do*/
-            break;
-        } else if (ce.xfocus.detail == NotifyPointerRoot ||
-                 ce.xfocus.detail == NotifyDetailNone) {
-            ob_debug_type(OB_DEBUG_FOCUS, "Focus went to root\n");
-            /* Focus has been reverted to the root window or nothing, so fall
-               back to something other than the window which just had it. */
-            focus_fallback(FALSE);
-        } else if (ce.xfocus.detail == NotifyInferior) {
-            ob_debug_type(OB_DEBUG_FOCUS, "Focus went to parent\n");
-            /* Focus has been reverted to parent, which is our frame window,
-               or the root window, so fall back to something other than the
-               window which had it. */
-            focus_fallback(FALSE);
-        } else {
-            /* Focus did move, so process the FocusIn event */
-            ObEventData ed = { .ignored = FALSE };
-            event_process(&ce, &ed);
-            if (ed.ignored) {
-                /* 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",
-                              ce.xfocus.window);
-                focus_fallback(TRUE);
-            }
-        }
-
-        /* This client is no longer focused, so show that */
-        focus_hilite = NULL;
-        frame_adjust_focus(client->frame, FALSE);
-        client_calc_layer(client);
-        break;
     case LeaveNotify:
         con = frame_context(client, e->xcrossing.window);
         switch (con) {
@@ -760,11 +736,12 @@ static void event_handle_client(ObClient *client, XEvent *e)
             frame_adjust_state(client->frame);
             break;
         case OB_FRAME_CONTEXT_FRAME:
-            if (config_focus_follow && config_focus_delay &&
-                focus_delay_data.client == client)
-            {
-                event_halt_focus_delay();
-            }
+            if (keyboard_interactively_grabbed())
+                break;
+            if (config_focus_follow && config_focus_delay)
+                ob_main_loop_timeout_remove_data(ob_main_loop,
+                                                 focus_delay_func,
+                                                 client, FALSE);
             break;
         default:
             break;
@@ -802,6 +779,8 @@ static void event_handle_client(ObClient *client, XEvent *e)
             frame_adjust_state(client->frame);
             break;
         case OB_FRAME_CONTEXT_FRAME:
+            if (keyboard_interactively_grabbed())
+                break;
             if (e->xcrossing.mode == NotifyGrab ||
                 e->xcrossing.mode == NotifyUngrab)
             {
@@ -1340,13 +1319,26 @@ static gboolean menu_hide_delay_func(gpointer data)
     return FALSE; /* no repeat */
 }
 
+static void focus_delay_dest(gpointer data)
+{
+    g_free(data);
+}
+
+static gboolean focus_delay_cmp(gconstpointer d1, gconstpointer d2)
+{
+    const ObFocusDelayData *f1 = d1;
+    return f1->client == d2;
+}
+
 static gboolean focus_delay_func(gpointer data)
 {
+    ObFocusDelayData *d = data;
     Time old = event_curtime;
-    event_curtime = focus_delay_data.time;
-    if (focus_client != focus_delay_data.client) {
-        if (client_focus(focus_delay_data.client) && config_focus_raise)
-            client_raise(focus_delay_data.client);
+
+    event_curtime = d->time;
+    if (focus_client != d->client) {
+        if (client_focus(d->client) && config_focus_raise)
+            client_raise(d->client);
     }
     event_curtime = old;
     return FALSE; /* no repeat */
@@ -1354,19 +1346,12 @@ static gboolean focus_delay_func(gpointer data)
 
 static void focus_delay_client_dest(ObClient *client, gpointer data)
 {
-    if (focus_delay_data.client == client)
-        event_halt_focus_delay();
-}
-
-static void event_client_dest(ObClient *client, gpointer data)
-{
-    if (client == focus_hilite)
-        focus_hilite = NULL;
+    ob_main_loop_timeout_remove_data(ob_main_loop, focus_delay_func,
+                                     client, FALSE);
 }
 
 void event_halt_focus_delay()
 {
-    focus_delay_data.client = NULL;
     ob_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
 }