X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Ffocus.c;h=42241224534e35fc07f021b0c4f86d4d0d1705c3;hb=8262e1ba669cb8959734892d2657653766f5cc7e;hp=ab9ac057d086dc7a3357402f0655e001f6ccfa36;hpb=a6d9be4f664cefb144e0e7ebc9c49e04bb2714e1;p=chaz%2Fopenbox

diff --git a/openbox/focus.c b/openbox/focus.c
index ab9ac057..42241224 100644
--- a/openbox/focus.c
+++ b/openbox/focus.c
@@ -1,152 +1,255 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
+
+   focus.c for the Openbox window manager
+   Copyright (c) 2006        Mikael Magnusson
+   Copyright (c) 2003-2007   Dana Jansens
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   See the COPYING file for a copy of the GNU General Public License.
+*/
+
+#include "debug.h"
 #include "event.h"
-#include "config.h"
 #include "openbox.h"
+#include "grab.h"
 #include "client.h"
-#include "frame.h"
+#include "config.h"
+#include "focus_cycle.h"
 #include "screen.h"
 #include "prop.h"
-#include "dispatch.h"
+#include "keyboard.h"
 #include "focus.h"
+#include "stacking.h"
 
 #include <X11/Xlib.h>
 #include <glib.h>
 
-Client *focus_client = NULL;
-GList **focus_order = NULL; /* these lists are created when screen_startup
-                               sets the number of desktops */
+#define FOCUS_INDICATOR_WIDTH 6
 
-Window focus_backup = None;
+ObClient *focus_client = NULL;
+GList *focus_order = NULL;
 
-void focus_startup()
+void focus_startup(gboolean reconfig)
 {
-    /* create the window which gets focus when no clients get it. Have to
-       make it override-redirect so we don't try manage it, since it is
-       mapped. */
-    XSetWindowAttributes attrib;
-
-    focus_client = NULL;
-
-    attrib.override_redirect = TRUE;
-    focus_backup = XCreateWindow(ob_display, ob_root,
-				 -100, -100, 1, 1, 0,
-                                 CopyFromParent, InputOutput, CopyFromParent,
-                                 CWOverrideRedirect, &attrib);
-    XMapRaised(ob_display, focus_backup);
+    if (reconfig) return;
 
     /* start with nothing focused */
-    focus_set_client(NULL);
+    focus_nothing();
 }
 
-void focus_shutdown()
+void focus_shutdown(gboolean reconfig)
 {
-    guint i;
-
-    for (i = 0; i < screen_num_desktops; ++i)
-        g_list_free(focus_order[i]);
-    g_free(focus_order);
-    focus_order = NULL;
-
-    XDestroyWindow(ob_display, focus_backup);
+    if (reconfig) return;
 
     /* reset focus to root */
-    XSetInputFocus(ob_display, PointerRoot, RevertToPointerRoot,
-                   event_lasttime);
+    XSetInputFocus(ob_display, PointerRoot, RevertToNone, CurrentTime);
+}
+
+static void push_to_top(ObClient *client)
+{
+    focus_order = g_list_remove(focus_order, client);
+    focus_order = g_list_prepend(focus_order, client);
 }
 
-void focus_set_client(Client *client)
+void focus_set_client(ObClient *client)
 {
     Window active;
-    Client *old;
-    guint desktop;
+
+    ob_debug_type(OB_DEBUG_FOCUS,
+                  "focus_set_client 0x%lx\n", client ? client->window : 0);
+
+    if (focus_client == client)
+        return;
 
     /* uninstall the old colormap, and install the new one */
     screen_install_colormap(focus_client, FALSE);
     screen_install_colormap(client, TRUE);
 
-    if (client == NULL) {
-	/* when nothing will be focused, send focus to the backup target */
-	XSetInputFocus(ob_display, focus_backup, RevertToPointerRoot,
-                       event_lasttime);
-        XSync(ob_display, FALSE);
-    }
+    /* in the middle of cycling..? kill it. */
+    focus_cycle_stop();
 
-    old = focus_client;
     focus_client = client;
 
-    /* move to the top of the list */
     if (client != NULL) {
-        desktop = client->desktop;
-        if (desktop == DESKTOP_ALL) desktop = screen_desktop;
-        focus_order[desktop] = g_list_remove(focus_order[desktop], client);
-        focus_order[desktop] = g_list_prepend(focus_order[desktop], client);
+        /* move to the top of the list */
+        push_to_top(client);
+        /* remove hiliting from the window when it gets focused */
+        client_hilite(client, FALSE);
     }
 
-    /* set the NET_ACTIVE_WINDOW hint */
-    active = client ? client->window : None;
-    PROP_SET32(ob_root, net_active_window, window, active);
-
-    if (focus_client != NULL)
-        dispatch_client(Event_Client_Focus, focus_client, 0, 0);
-    if (old != NULL)
-        dispatch_client(Event_Client_Unfocus, old, 0, 0);
+    /* set the NET_ACTIVE_WINDOW hint, but preserve it on shutdown */
+    if (ob_state() != OB_STATE_EXITING) {
+        active = client ? client->window : None;
+        PROP_SET32(RootWindow(ob_display, ob_screen),
+                   net_active_window, window, active);
+    }
 }
 
-static gboolean focus_under_pointer()
+static ObClient* focus_fallback_target(gboolean allow_refocus)
 {
-    Window w;
-    int i, x, y;
-    guint u;
     GList *it;
+    ObClient *c;
+    ObClient *old = focus_client;
+
+    ob_debug_type(OB_DEBUG_FOCUS, "trying pointer stuff\n");
+    if (config_focus_follow && !config_focus_last)
+        if ((c = client_under_pointer()) &&
+            (allow_refocus || c != old) &&
+            (client_normal(c) &&
+             client_focus(c)))
+        {
+            ob_debug_type(OB_DEBUG_FOCUS, "found in pointer stuff\n");
+            return c;
+        }
+
+    ob_debug_type(OB_DEBUG_FOCUS, "trying omnipresentness\n");
+    if (allow_refocus && old &&
+        old->desktop == DESKTOP_ALL &&
+        client_normal(old) &&
+        client_focus(old))
+    {
+        ob_debug_type(OB_DEBUG_FOCUS, "found in omnipresentness\n");
+        return old;
+    }
+
 
-    if (XQueryPointer(ob_display, ob_root, &w, &w, &x, &y, &i, &i, &u)) {
-        for (it = stacking_list; it != NULL; it = it->next) {
-            Client *c = it->data;
-            if (c->desktop == screen_desktop &&
-                RECT_CONTAINS(c->frame->area, x, y))
-                break;
+    ob_debug_type(OB_DEBUG_FOCUS, "trying the focus order\n");
+    for (it = focus_order; it; it = g_list_next(it)) {
+        c = it->data;
+        /* fallback focus to a window if:
+           1. it is on the current desktop. this ignores omnipresent
+           windows, which are problematic in their own rite.
+           2. it is a normal type window, don't fall back onto a dock or
+           a splashscreen or a desktop window (save the desktop as a
+           backup fallback though)
+        */
+        if (c->desktop == screen_desktop &&
+            client_normal(c) &&
+            (allow_refocus || c != old) &&
+            client_focus(c))
+        {
+            ob_debug_type(OB_DEBUG_FOCUS, "found in focus order\n");
+            return c;
         }
-        if (it != NULL)
-            return client_normal(it->data) && client_focus(it->data);
     }
-    return FALSE;
+
+    ob_debug_type(OB_DEBUG_FOCUS, "trying a desktop window\n");
+    for (it = focus_order; it; it = g_list_next(it)) {
+        c = it->data;
+        /* fallback focus to a window if:
+           1. it is on the current desktop. this ignores omnipresent
+           windows, which are problematic in their own rite.
+           2. it is a normal type window, don't fall back onto a dock or
+           a splashscreen or a desktop window (save the desktop as a
+           backup fallback though)
+        */
+        if (c->type == OB_CLIENT_TYPE_DESKTOP &&
+            (allow_refocus || c != old) &&
+            client_focus(c))
+        {
+            ob_debug_type(OB_DEBUG_FOCUS, "found a desktop window\n");
+            return c;
+        }
+    }
+
+    return NULL;
 }
 
-void focus_fallback(gboolean switching_desks)
+ObClient* focus_fallback(gboolean allow_refocus)
 {
-    ConfigValue focus_follow;
-    GList *it;
-    gboolean under = FALSE;
-    Client *old = NULL;
-
-    old = focus_client;
+    ObClient *new;
 
     /* unfocus any focused clients.. they can be focused by Pointer events
-       and such, and then when I try focus them, I won't get a FocusIn event
-       at all for them.
+       and such, and then when we try focus them, we won't get a FocusIn
+       event at all for them. */
+    focus_nothing();
+
+    new = focus_fallback_target(allow_refocus);
+
+    return new;
+}
+
+void focus_nothing()
+{
+    /* Install our own colormap */
+    if (focus_client != NULL) {
+        screen_install_colormap(focus_client, FALSE);
+        screen_install_colormap(NULL, TRUE);
+    }
+
+    /* Don't set focus_client to NULL here. It will be set to NULL when the
+       FocusOut event comes. Otherwise, if we focus nothing and then focus the
+       same window again, The focus code says nothing changed, but focus_client
+       ends up being NULL anyways.
+    focus_client = NULL;
+    */
+
+    /* if there is a grab going on, then we need to cancel it. if we move
+       focus during the grab, applications will get NotifyWhileGrabbed events
+       and ignore them !
+
+       actions should not rely on being able to move focus during an
+       interactive grab.
     */
-    focus_set_client(NULL);
+    if (keyboard_interactively_grabbed())
+        keyboard_interactive_cancel();
 
-    if (switching_desks) {
-        /* don't skip any windows when switching desktops */
-        old = NULL;
+    /* when nothing will be focused, send focus to the backup target */
+    XSetInputFocus(ob_display, screen_support_win, RevertToPointerRoot,
+                   event_curtime);
+}
+
+void focus_order_remove(ObClient *c)
+{
+    focus_order = g_list_remove(focus_order, c);
+}
+
+void focus_order_to_top(ObClient *c)
+{
+    focus_order = g_list_remove(focus_order, c);
+    if (!c->iconic) {
+        focus_order = g_list_prepend(focus_order, c);
     } else {
-        if (!config_get("focusFollowsMouse", Config_Bool, &focus_follow))
-            g_assert_not_reached();
-        if (focus_follow.bool)
-            under = focus_under_pointer();
+        GList *it;
+
+        /* insert before first iconic window */
+        for (it = focus_order;
+             it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
+        focus_order = g_list_insert_before(focus_order, it, c);
     }
+}
 
-    if (!under) {
-        for (it = focus_order[screen_desktop]; it != NULL; it = it->next) {
-            if (it->data != old && client_normal(it->data)) {
-                /* if we're switching desktops, and we get the already focused
-                   window, then we wont get a FocusIn for it, so just restore
-                   the focus_client so that we know it is focused */
-                if (client_focus(it->data))
-                    break;
-            }
-        }
-        if (it == NULL) /* nothing to focus */
-            focus_set_client(NULL);
+void focus_order_to_bottom(ObClient *c)
+{
+    focus_order = g_list_remove(focus_order, c);
+    if (c->iconic) {
+        focus_order = g_list_append(focus_order, c);
+    } else {
+        GList *it;
+
+        /* insert before first iconic window */
+        for (it = focus_order;
+             it && !((ObClient*)it->data)->iconic; it = g_list_next(it));
+        focus_order = g_list_insert_before(focus_order, it, c);
+    }
+}
+
+ObClient *focus_order_find_first(guint desktop)
+{
+    GList *it;
+    for (it = focus_order; it; it = g_list_next(it)) {
+        ObClient *c = it->data;
+        if (c->desktop == desktop || c->desktop == DESKTOP_ALL)
+            return c;
     }
+    return NULL;
 }