Remove double newlines.

[chaz/openbox] / openbox / focus.c

diff --git a/openbox/focus.c b/openbox/focus.c
index 303388bec210d146accfe5cdf10585f96bc83ebb..63eb2ccaf88ac7520d074c1b3abb9a71c6a9abff 100644 (file)
--- a/openbox/focus.c
+++ b/openbox/focus.c
@@ -23,6 +23,7 @@
 #include "grab.h"
 #include "client.h"
 #include "config.h"
 #include "grab.h"
 #include "client.h"
 #include "config.h"

+#include "group.h"

 #include "focus_cycle.h"
 #include "screen.h"
 #include "prop.h"
 #include "focus_cycle.h"
 #include "screen.h"
 #include "prop.h"


@@ -56,6 +57,14 @@ void focus_shutdown(gboolean reconfig)
 
 static void push_to_top(ObClient *client)
 {
 
 static void push_to_top(ObClient *client)
 {

+    ObClient *p;
+
+    /* if it is modal for a single window, then put that window at the top
+       of the focus order first, so it will be right after ours. the same is
+       done with stacking */
+    if (client->modal && (p = client_direct_parent(client)))
+        push_to_top(p);
+

     focus_order = g_list_remove(focus_order, client);
     focus_order = g_list_prepend(focus_order, client);
 }
     focus_order = g_list_remove(focus_order, client);
     focus_order = g_list_prepend(focus_order, client);
 }


@@ -121,12 +130,12 @@ static ObClient* focus_fallback_target(gboolean allow_refocus,
            1. it is on the current desktop. this ignores omnipresent
            windows, which are problematic in their own rite, unless they are
            specifically allowed
            1. it is on the current desktop. this ignores omnipresent
            windows, which are problematic in their own rite, unless they are
            specifically allowed

-           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)
+           2. it is a valid auto-focus target
+           3. it is not shaded

         */
         if ((allow_omnipresent || c->desktop == screen_desktop) &&
         */
         if ((allow_omnipresent || c->desktop == screen_desktop) &&

-            client_normal(c) &&
+            focus_valid_target(c, TRUE, FALSE, FALSE, FALSE, FALSE) &&
+            !c->shaded &&

             (allow_refocus || client_focus_target(c) != old) &&
             client_focus(c))
         {
             (allow_refocus || client_focus_target(c) != old) &&
             client_focus(c))
         {


@@ -145,7 +154,7 @@ static ObClient* focus_fallback_target(gboolean allow_refocus,
            a splashscreen or a desktop window (save the desktop as a
            backup fallback though)
         */
            a splashscreen or a desktop window (save the desktop as a
            backup fallback though)
         */

-        if (c->type == OB_CLIENT_TYPE_DESKTOP &&
+        if (focus_valid_target(c, TRUE, FALSE, FALSE, FALSE, TRUE) &&

             (allow_refocus || client_focus_target(c) != old) &&
             client_focus(c))
         {
             (allow_refocus || client_focus_target(c) != old) &&
             client_focus(c))
         {


@@ -158,7 +167,7 @@ static ObClient* focus_fallback_target(gboolean allow_refocus,
 }
 
 ObClient* focus_fallback(gboolean allow_refocus, gboolean allow_pointer,
 }
 
 ObClient* focus_fallback(gboolean allow_refocus, gboolean allow_pointer,

-                         gboolean allow_omnipresent)
+                         gboolean allow_omnipresent, gboolean focus_lost)

 {
     ObClient *new;
     ObClient *old = focus_client;
 {
     ObClient *new;
     ObClient *old = focus_client;


@@ -166,7 +175,8 @@ ObClient* focus_fallback(gboolean allow_refocus, gboolean allow_pointer,
     /* unfocus any focused clients.. they can be focused by Pointer events
        and such, and then when we try focus them, we won't get a FocusIn
        event at all for them. */
     /* unfocus any focused clients.. they can be focused by Pointer events
        and such, and then when we try focus them, we won't get a FocusIn
        event at all for them. */

-    focus_nothing();
+    if (focus_lost)
+        focus_nothing();

 
     new = focus_fallback_target(allow_refocus, allow_pointer,
                                 allow_omnipresent, old);
 
     new = focus_fallback_target(allow_refocus, allow_pointer,
                                 allow_omnipresent, old);


@@ -176,7 +186,7 @@ ObClient* focus_fallback(gboolean allow_refocus, gboolean allow_pointer,
     return new;
 }
 
     return new;
 }
 

-void focus_nothing()
+void focus_nothing(void)

 {
     /* Install our own colormap */
     if (focus_client != NULL) {
 {
     /* Install our own colormap */
     if (focus_client != NULL) {


@@ -187,13 +197,6 @@ void focus_nothing()
     /* nothing is focused, update the colormap and _the root property_ */
     focus_set_client(NULL);
 
     /* nothing is focused, update the colormap and _the root property_ */
     focus_set_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.
-    */

     event_cancel_all_key_grabs();
 
     /* when nothing will be focused, send focus to the backup target */
     event_cancel_all_key_grabs();
 
     /* when nothing will be focused, send focus to the backup target */


@@ -267,3 +270,92 @@ ObClient *focus_order_find_first(guint desktop)
     }
     return NULL;
 }
     }
     return NULL;
 }

+
+/*! Returns if a focus target has valid group siblings that can be cycled
+  to in its place */
+static gboolean focus_target_has_siblings(ObClient *ft,
+                                          gboolean iconic_windows,
+                                          gboolean all_desktops)
+
+{
+    GSList *it;
+
+    if (!ft->group) return FALSE;
+
+    for (it = ft->group->members; it; it = g_slist_next(it)) {
+        ObClient *c = it->data;
+        /* check that it's not a helper window to avoid infinite recursion */
+        if (c != ft && c->type == OB_CLIENT_TYPE_NORMAL &&
+            focus_valid_target(c, TRUE, iconic_windows, all_desktops,
+                               FALSE, FALSE))
+        {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+gboolean focus_valid_target(ObClient *ft,
+                            gboolean helper_windows,
+                            gboolean iconic_windows,
+                            gboolean all_desktops,
+                            gboolean dock_windows,
+                            gboolean desktop_windows)
+{
+    gboolean ok = FALSE;
+
+    /* it's on this desktop unless you want all desktops.
+
+       do this check first because it will usually filter out the most
+       windows */
+    ok = (all_desktops || ft->desktop == screen_desktop ||
+          ft->desktop == DESKTOP_ALL);
+
+    /* the window can receive focus somehow */
+    ok = ok && (ft->can_focus || ft->focus_notify);
+
+    /* the window is not iconic, or we're allowed to go to iconic ones */
+    ok = ok && (iconic_windows || !ft->iconic);
+
+    /* it's the right type of window */
+    if (dock_windows || desktop_windows)
+        ok = ok && ((dock_windows && ft->type == OB_CLIENT_TYPE_DOCK) ||
+                    (desktop_windows && ft->type == OB_CLIENT_TYPE_DESKTOP));
+    /* modal windows are important and can always get focus if they are
+       visible and stuff, so don't change 'ok' based on their type */
+    else if (!ft->modal)
+        /* normal non-helper windows are valid targets */
+        ok = ok &&
+            ((client_normal(ft) && !client_helper(ft))
+             ||
+             /* helper windows are valid targets if... */
+             (client_helper(ft) &&
+              /* ...a window in its group already has focus and we want to
+                 include helper windows ... */
+              ((focus_client && ft->group == focus_client->group &&
+                helper_windows) ||
+               /* ... or if there are no other windows in its group
+                  that can be focused instead */
+               !focus_target_has_siblings(ft, iconic_windows, all_desktops))));
+
+    /* it's not set to skip the taskbar (but this only applies to normal typed
+       windows, and is overridden if the window is modal) */
+    ok = ok && (ft->type != OB_CLIENT_TYPE_NORMAL ||
+                ft->modal ||
+                !ft->skip_taskbar);
+
+    /* it's not going to just send focus off somewhere else (modal window),
+       unless that modal window is not one of our valid targets, then let
+       you choose this window and bring the modal one here */
+    {
+        ObClient *cft = client_focus_target(ft);
+        ok = ok && (ft == cft || !focus_valid_target(cft,
+                                                     TRUE,
+                                                     iconic_windows,
+                                                     all_desktops,
+                                                     dock_windows,
+                                                     desktop_windows));
+    }
+
+    return ok;
+}