X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fclient.c;h=87cdba96973d61b55cef4f8f76bcff33ea6bbcee;hb=069e9607fa433190307bb8242294a109e88165de;hp=dd1f96420eaa79c22b08fe34b15ffe0dd40b2a48;hpb=c4fb053f2fe774d3cbf17b10d761666b3c85a60f;p=chaz%2Fopenbox

diff --git a/openbox/client.c b/openbox/client.c
index dd1f9642..87cdba96 100644
--- a/openbox/client.c
+++ b/openbox/client.c
@@ -1,4 +1,7 @@
 #include "client.h"
+#include "dock.h"
+#include "xerror.h"
+#include "startup.h"
 #include "screen.h"
 #include "moveresize.h"
 #include "prop.h"
@@ -12,6 +15,8 @@
 #include "openbox.h"
 #include "group.h"
 #include "config.h"
+#include "menu.h"
+#include "render/render.h"
 
 #include <glib.h>
 #include <X11/Xutil.h>
@@ -24,10 +29,6 @@
 				ButtonMotionMask)
 
 GList      *client_list      = NULL;
-GHashTable *client_map       = NULL;
-
-static Window *client_startup_stack_order = NULL;
-static guint  client_startup_stack_size = 0;
 
 static void client_get_all(Client *self);
 static void client_toggle_border(Client *self, gboolean show);
@@ -40,30 +41,15 @@ static void client_get_gravity(Client *self);
 static void client_showhide(Client *self);
 static void client_change_allowed_actions(Client *self);
 static void client_change_state(Client *self);
-static void client_move_onscreen(Client *self);
-static Client *search_focus_tree(Client *node, Client *skip);
 static void client_apply_startup_state(Client *self);
-static Client *search_modal_tree(Client *node, Client *skip);
-
-static guint map_hash(Window *w) { return *w; }
-static gboolean map_key_comp(Window *w1, Window *w2) { return *w1 == *w2; }
 
 void client_startup()
 {
-    client_map = g_hash_table_new((GHashFunc)map_hash,
-				  (GEqualFunc)map_key_comp);
-
-    /* save the stacking order on startup! */
-    PROP_GETA32(ob_root, net_client_list_stacking, window,
-                (guint32**)&client_startup_stack_order,
-                &client_startup_stack_size);
-
     client_set_list();
 }
 
 void client_shutdown()
 {
-    g_hash_table_destroy(client_map);
 }
 
 void client_set_list()
@@ -89,6 +75,37 @@ void client_set_list()
     stacking_set_list();
 }
 
+/*
+void client_foreach_transient(Client *self, ClientForeachFunc func, void *data)
+{
+    GSList *it;
+
+    for (it = self->transients; it; it = it->next) {
+        if (!func(it->data, data)) return;
+        client_foreach_transient(it->data, func, data);
+    }
+}
+
+void client_foreach_ancestor(Client *self, ClientForeachFunc func, void *data)
+{
+    if (self->transient_for) {
+        if (self->transient_for != TRAN_GROUP) {
+            if (!func(self->transient_for, data)) return;
+            client_foreach_ancestor(self->transient_for, func, data);
+        } else {
+            GSList *it;
+
+            for (it = self->group->members; it; it = it->next)
+                if (it->data != self &&
+                    !((Client*)it->data)->transient_for) {
+                    if (!func(it->data, data)) return;
+                    client_foreach_ancestor(it->data, func, data);
+                }
+        }
+    }
+}
+*/
+
 void client_manage_all()
 {
     unsigned int i, j, nchild;
@@ -130,19 +147,31 @@ void client_manage_all()
        why with stacking_lower? Why, because then windows who aren't in the
        stacking list are on the top where you can see them instead of buried
        at the bottom! */
-    for (i = client_startup_stack_size; i > 0; --i) {
-        Client *c;
-
-        w = client_startup_stack_order[i-1];
-        c = g_hash_table_lookup(client_map, &w);
-        if (c) stacking_lower(c);
+    for (i = startup_stack_size; i > 0; --i) {
+        ObWindow *obw;
+
+        w = startup_stack_order[i-1];
+        obw = g_hash_table_lookup(window_map, &w);
+        if (obw) {
+            g_assert(WINDOW_IS_CLIENT(obw));
+            stacking_lower(CLIENT_AS_WINDOW(obw));
+        }
     }
-    g_free(client_startup_stack_order);
-    client_startup_stack_order = NULL;
-    client_startup_stack_size = 0;
+    g_free(startup_stack_order);
+    startup_stack_order = NULL;
+    startup_stack_size = 0;
 
-    if (config_focus_new)
-        focus_fallback(Fallback_NoFocus);
+    if (config_focus_new) {
+        ObWindow *active;
+
+        active = g_hash_table_lookup(window_map, &startup_active);
+        if (active) {
+            g_assert(WINDOW_IS_CLIENT(active));
+            if (!client_focus(WINDOW_AS_CLIENT(active)))
+                focus_fallback(Fallback_NoFocus);
+        } else
+            focus_fallback(Fallback_NoFocus);
+    }
 }
 
 void client_manage(Window window)
@@ -151,9 +180,8 @@ void client_manage(Window window)
     XEvent e;
     XWindowAttributes attrib;
     XSetWindowAttributes attrib_set;
-/*    XWMHints *wmhint; */
-    guint i;
-    gboolean f;
+    XWMHints *wmhint;
+    gboolean activate = FALSE;
 
     grab_server(TRUE);
 
@@ -174,18 +202,18 @@ void client_manage(Window window)
 	return; /* don't manage it */
     }
   
-/*    /\* is the window a docking app *\/
+    /* is the window a docking app */
     if ((wmhint = XGetWMHints(ob_display, window))) {
 	if ((wmhint->flags & StateHint) &&
 	    wmhint->initial_state == WithdrawnState) {
-	    /\* XXX: make dock apps work! *\/
+            dock_add(window, wmhint);
             grab_server(FALSE);
 	    XFree(wmhint);
 	    return;
 	}
 	XFree(wmhint);
     }
-*/
+
     g_message("Managing window: %lx", window);
 
     /* choose the events we want to receive on the CLIENT window */
@@ -198,6 +226,7 @@ void client_manage(Window window)
     /* create the Client struct, and populate it from the hints on the
        window */
     self = g_new(Client, 1);
+    self->obwin.type = Window_Client;
     self->window = window;
     client_get_all(self);
 
@@ -216,66 +245,66 @@ void client_manage(Window window)
     client_apply_startup_state(self);
 
     grab_server(FALSE);
-     
+
+    /* add to client list/map */
     client_list = g_list_append(client_list, self);
-    stacking_list = g_list_append(stacking_list, self);
-    g_assert(!g_hash_table_lookup(client_map, &self->window));
-    g_hash_table_insert(client_map, &self->window, self);
+    g_hash_table_insert(window_map, &self->window, self);
 
     /* update the focus lists */
-    if (self->desktop == DESKTOP_ALL) {
-        for (i = 0; i < screen_num_desktops; ++i)
-            focus_order[i] = g_list_append(focus_order[i], self);
+    focus_order_add_new(self);
+
+    /* focus the new window? */
+    if (ob_state != State_Starting && config_focus_new &&
+        (self->type == Type_Normal || self->type == Type_Dialog)) {
+        gboolean group_foc = FALSE;
+        
+        if (self->group) {
+            GSList *it;
+
+            for (it = self->group->members; it; it = it->next) {
+                if (client_focused(it->data)) {
+                    group_foc = TRUE;
+                    break;
+                }
+            }
+        }
+        /* note the check against Type_Normal/Dialog, not client_normal(self),
+           which would also include other types. in this case we want more
+           strict rules for focus */
+        if ((group_foc ||
+             (!self->transient_for && (!self->group ||
+                                       !self->group->members->next))) ||
+            client_search_focus_tree_full(self) ||
+            !focus_client ||
+            !client_normal(focus_client)) {
+            /* activate the window */
+            stacking_add(CLIENT_AS_WINDOW(self));
+            activate = TRUE;
+        } else {
+            /* try to not get in the way */
+            stacking_add_nonintrusive(CLIENT_AS_WINDOW(self));
+        }
     } else {
-        i = self->desktop;
-        focus_order[i] = g_list_append(focus_order[i], self);
+        stacking_add(CLIENT_AS_WINDOW(self));
     }
 
-    stacking_raise(self);
-
     screen_update_struts();
 
+    /* make sure the window is visible */
+    client_move_onscreen(self);
+
     dispatch_client(Event_Client_New, self, 0, 0);
 
     client_showhide(self);
 
-    /* focus the new window? */
-    if (ob_state != State_Starting && client_normal(self)) {
-        f = FALSE;
-
-        if (self->transient_for) {
-            if (self->transient_for != TRAN_GROUP) {/* transient of a window */
-                if (focus_client == self->transient_for) {
-                    client_focus(self);
-                    f = TRUE;
-                }
-            } else { /* transient of a group */
-                GSList *it;
-
-                for (it = self->group->members; it; it = it->next)
-                    if (focus_client == it->data) {
-                        client_focus(self);
-                        f = TRUE;
-                        break;
-                    }
-            }
-        }
-        /* note the check against Type_Normal, not client_normal(self), which
-           would also include dialog types. in this case we want more strict
-           rules for focus */
-        if (!f && config_focus_new && self->type == Type_Normal)
-            client_focus(self);
-    }
+    if (activate) client_activate(self);
 
     /* update the list hints */
     client_set_list();
 
-    /* make sure the window is visible */
-    client_move_onscreen(self);
-
     dispatch_client(Event_Client_Mapped, self, 0, 0);
 
-    g_message("Managed window 0x%lx", window);
+    g_message("Managed window 0x%lx (%s)", window, self->class);
 }
 
 void client_unmanage_all()
@@ -284,13 +313,19 @@ void client_unmanage_all()
 	client_unmanage(client_list->data);
 }
 
+/* called by client_unmanage() to close any menus referencing this client */
+void client_close_menus(gpointer key, gpointer value, gpointer self)
+{
+    if (((Menu *)value)->client == (Client *)self)
+        menu_hide((Menu *)value);
+}
+
 void client_unmanage(Client *self)
 {
-    guint i;
     int j;
     GSList *it;
 
-    g_message("Unmanaging window: %lx", self->window);
+    g_message("Unmanaging window: %lx (%s)", self->window, self->class);
 
     dispatch_client(Event_Client_Destroy, self, 0, 0);
     g_assert(self != NULL);
@@ -304,17 +339,11 @@ void client_unmanage(Client *self)
     frame_hide(self->frame);
 
     client_list = g_list_remove(client_list, self);
-    stacking_list = g_list_remove(stacking_list, self);
-    g_hash_table_remove(client_map, &self->window);
+    stacking_remove(self);
+    g_hash_table_remove(window_map, &self->window);
 
     /* update the focus lists */
-    if (self->desktop == DESKTOP_ALL) {
-        for (i = 0; i < screen_num_desktops; ++i)
-            focus_order[i] = g_list_remove(focus_order[i], self);
-    } else {
-        i = self->desktop;
-        focus_order[i] = g_list_remove(focus_order[i], self);
-    }
+    focus_order_remove(self);
 
     /* once the client is out of the list, update the struts to remove it's
        influence */
@@ -344,8 +373,18 @@ void client_unmanage(Client *self)
     if (moveresize_client == self)
         moveresize_end(TRUE);
 
-    if (focus_client == self)
+    /* close any windows that are attached to this window */
+    g_hash_table_foreach(menu_hash, client_close_menus, self);
+
+    
+    if (focus_client == self) {
+        XEvent e;
+
+        /* focus the last focused window on the desktop, and ignore enter
+           events from the unmap so it doesnt mess with the focus */
+        while (XCheckTypedEvent(ob_display, EnterNotify, &e));
         client_unfocus(self);
+    }
 
     /* remove from its group */
     if (self->group) {
@@ -376,6 +415,7 @@ void client_unmanage(Client *self)
 	    XMapWindow(ob_display, self->window);
     }
 
+
     g_message("Unmanaged window 0x%lx", self->window);
 
     /* free all data allocated in the client struct */
@@ -395,7 +435,7 @@ void client_unmanage(Client *self)
     client_set_list();
 }
 
-static void client_move_onscreen(Client *self)
+void client_move_onscreen(Client *self)
 {
     Rect *a;
     int x = self->frame->area.x, y = self->frame->area.y;
@@ -411,7 +451,7 @@ static void client_move_onscreen(Client *self)
         y = a->y;
 
     frame_frame_gravity(self->frame, &x, &y); /* get where the client
-                                              should be */
+                                                 should be */
     client_configure(self , Corner_TopLeft, x, y,
                      self->area.width, self->area.height,
                      TRUE, TRUE);
@@ -492,6 +532,7 @@ static void client_get_all(Client *self)
     /* defaults */
     self->frame = NULL;
     self->title = self->icon_title = NULL;
+    self->title_count = 1;
     self->name = self->class = self->role = NULL;
     self->wmstate = NormalState;
     self->transient = FALSE;
@@ -525,11 +566,9 @@ static void client_get_all(Client *self)
     client_setup_decor_and_functions(self);
   
     client_update_title(self);
-    client_update_icon_title(self);
     client_update_class(self);
     client_update_strut(self);
     client_update_icons(self);
-    client_update_kwm_icon(self);
 
     client_change_state(self);
 }
@@ -566,7 +605,7 @@ static void client_get_desktop(Client *self)
 
                 for (it = self->group->members; it; it = it->next)
                     if (it->data != self &&
-                        ((Client*)it->data)->transient_for != TRAN_GROUP) {
+                        !((Client*)it->data)->transient_for) {
                         self->desktop = ((Client*)it->data)->desktop;
                         trdesk = TRUE;
                         break;
@@ -644,22 +683,25 @@ void client_update_transient_for(Client *self)
     Window t = None;
     Client *c = NULL;
 
-    if (XGetTransientForHint(ob_display, self->window, &t) &&
-	t != self->window) { /* cant be transient to itself! */
+    if (XGetTransientForHint(ob_display, self->window, &t)) {
 	self->transient = TRUE;
-	c = g_hash_table_lookup(client_map, &t);
-	g_assert(c != self);/* if this happens then we need to check for it*/
-
-	if (!c && self->group) {
-	    /* not transient to a client, see if it is transient for a
-	       group */
-	    if (t == self->group->leader ||
-		t == None ||
-		t == ob_root) {
-		/* window is a transient for its group! */
-                c = TRAN_GROUP;
-	    }
-	}
+        if (t != self->window) { /* cant be transient to itself! */
+            c = g_hash_table_lookup(window_map, &t);
+            /* if this happens then we need to check for it*/
+            g_assert(c != self);
+            g_assert(!c || WINDOW_IS_CLIENT(c));
+            
+            if (!c && self->group) {
+                /* not transient to a client, see if it is transient for a
+                   group */
+                if (t == self->group->leader ||
+                    t == None ||
+                    t == ob_root) {
+                    /* window is a transient for its group! */
+                    c = TRAN_GROUP;
+                }
+            }
+        }
     } else
 	self->transient = FALSE;
 
@@ -670,7 +712,8 @@ void client_update_transient_for(Client *self)
 
 	    /* remove from old parents */
             for (it = self->group->members; it; it = it->next)
-                if (it->data != self)
+                if (it->data != self &&
+                    !((Client*)it->data)->transient_for)
                     ((Client*)it->data)->transients =
                         g_slist_remove(((Client*)it->data)->transients, self);
         } else if (self->transient_for != NULL) { /* transient of window */
@@ -684,9 +727,22 @@ void client_update_transient_for(Client *self)
 
 	    /* add to new parents */
             for (it = self->group->members; it; it = it->next)
-                if (it->data != self)
+                if (it->data != self &&
+                    !((Client*)it->data)->transient_for)
                     ((Client*)it->data)->transients =
                         g_slist_append(((Client*)it->data)->transients, self);
+
+            /* remove all transients which are in the group, that causes
+               circlular pointer hell of doom */
+            for (it = self->group->members; it; it = it->next) {
+                GSList *sit, *next;
+                for (sit = self->transients; sit; sit = next) {
+                    next = sit->next;
+                    if (sit->data == it->data)
+                        self->transients = g_slist_remove(self->transients,
+                                                          sit->data);
+                }
+            }
         } else if (self->transient_for != NULL) { /* transient of window */
 	    /* add to new parent */
 	    self->transient_for->transients =
@@ -762,10 +818,6 @@ void client_get_type(Client *self)
 	else
 	    self->type = Type_Normal;
     }
-
-    /* this makes sure that these windows appear on all desktops */
-    if (self->type == Type_Desktop)
-	self->desktop = DESKTOP_ALL;
 }
 
 void client_update_protocols(Client *self)
@@ -971,11 +1023,16 @@ void client_setup_decor_and_functions(Client *self)
     client_change_allowed_actions(self);
 
     if (self->frame) {
-	/* change the decors on the frame, and with more/less decorations,
-           we may also need to be repositioned */
-	frame_adjust_area(self->frame, TRUE, TRUE);
-	/* with new decor, the window's maximized size may change */
-	client_remaximize(self);
+        /* this makes sure that these windows appear on all desktops */
+        if (self->type == Type_Desktop && self->desktop != DESKTOP_ALL)
+            client_set_desktop(self, DESKTOP_ALL, FALSE);
+
+	/* adjust the client's decorations, etc. */
+	client_reconfigure(self);
+    } else {
+        /* this makes sure that these windows appear on all desktops */
+        if (self->type == Type_Desktop && self->desktop != DESKTOP_ALL)
+            self->desktop = DESKTOP_ALL;
     }
 }
 
@@ -984,7 +1041,9 @@ static void client_change_allowed_actions(Client *self)
     guint32 actions[9];
     int num = 0;
 
-    actions[num++] = prop_atoms.net_wm_action_change_desktop;
+    /* desktop windows are kept on all desktops */
+    if (self->type != Type_Desktop)
+        actions[num++] = prop_atoms.net_wm_action_change_desktop;
 
     if (self->functions & Func_Shade)
 	actions[num++] = prop_atoms.net_wm_action_shade;
@@ -1027,19 +1086,13 @@ static void client_change_allowed_actions(Client *self)
     }
 }
 
-void client_remaximize(Client *self)
+void client_reconfigure(Client *self)
 {
-    int dir;
-    if (self->max_horz && self->max_vert)
-	dir = 0;
-    else if (self->max_horz)
-	dir = 1;
-    else if (self->max_vert)
-	dir = 2;
-    else
-	return; /* not maximized */
-    self->max_horz = self->max_vert = FALSE;
-    client_maximize(self, TRUE, dir, FALSE);
+    /* by making this pass FALSE for user, we avoid the emacs event storm where
+       every configurenotify causes an update in its normal hints, i think this
+       is generally what we want anyways... */
+    client_configure(self, Corner_TopLeft, self->area.x, self->area.y,
+                     self->area.width, self->area.height, FALSE, TRUE);
 }
 
 void client_update_wmhints(Client *self)
@@ -1074,26 +1127,30 @@ void client_update_wmhints(Client *self)
             if (self->group != NULL) {
                 /* remove transients of the group */
                 for (it = self->group->members; it; it = it->next)
-                    if (it->data != self &&
-                        ((Client*)it->data)->transient_for == TRAN_GROUP) {
-                        self->transients = g_slist_remove(self->transients,
-                                                          it->data);
-                    }
+                    self->transients = g_slist_remove(self->transients,
+                                                      it->data);
                 group_remove(self->group, self);
                 self->group = NULL;
             }
             if (hints->window_group != None) {
                 self->group = group_add(hints->window_group, self);
 
-                /* add other transients of the group that are already
-                   set up */
-                for (it = self->group->members; it; it = it->next)
-                    if (it->data != self &&
-                        ((Client*)it->data)->transient_for == TRAN_GROUP)
-                        self->transients = g_slist_append(self->transients,
-                                                          it->data);
+                /* i can only have transients from the group if i am not
+                   transient myself */
+                if (!self->transient_for) {
+                    /* add other transients of the group that are already
+                       set up */
+                    for (it = self->group->members; it; it = it->next)
+                        if (it->data != self &&
+                            ((Client*)it->data)->transient_for == TRAN_GROUP)
+                            self->transients = g_slist_append(self->transients,
+                                                              it->data);
+                }
             }
 
+            /* the WM_HINTS can contain an icon */
+            client_update_icons(self);
+
             /* because the self->transient flag wont change from this call,
                we don't need to update the window's type and such, only its
                transient_for, and the transients lists of other windows in
@@ -1101,23 +1158,6 @@ void client_update_wmhints(Client *self)
             client_update_transient_for(self);
         }
 
-        client_update_kwm_icon(self);
-        /* try get the kwm icon first, this is a fallback only */
-        if (self->pixmap_icon == None) {
-            if (hints->flags & IconPixmapHint) {
-                if (self->pixmap_icon == None) {
-                    self->pixmap_icon = hints->icon_pixmap;
-                    if (hints->flags & IconMaskHint)
-                        self->pixmap_icon_mask = hints->icon_mask;
-                    else
-                        self->pixmap_icon_mask = None;
-
-                    if (self->frame)
-                        frame_adjust_icon(self->frame);
-                }
-            }
-	}
-
 	XFree(hints);
     }
 
@@ -1134,7 +1174,11 @@ void client_update_wmhints(Client *self)
 
 void client_update_title(Client *self)
 {
+    GList *it;
+    guint32 nums;
+    guint i;
     char *data = NULL;
+    gboolean read_title;
 
     g_free(self->title);
      
@@ -1145,6 +1189,29 @@ void client_update_title(Client *self)
 	    data = g_strdup("Unnamed Window");
 
     /* look for duplicates and append a number */
+    nums = 0;
+    for (it = client_list; it; it = it->next)
+        if (it->data != self) {
+            Client *c = it->data;
+            if (0 == strncmp(c->title, data, strlen(data)))
+                nums |= 1 << c->title_count;
+        }
+    /* find first free number */
+    for (i = 1; i <= 32; ++i)
+        if (!(nums & (1 << i))) {
+            if (self->title_count == 1 || i == 1)
+                self->title_count = i;
+            break;
+        }
+    /* dont display the number for the first window */
+    if (self->title_count > 1) {
+        char *vdata, *ndata;
+        ndata = g_strdup_printf(" - [%u]", self->title_count);
+        vdata = g_strconcat(data, ndata, NULL);
+        g_free(ndata);
+        g_free(data);
+        data = vdata;
+    }
 
     PROP_SETS(self->window, net_wm_visible_name, data);
 
@@ -1152,19 +1219,29 @@ void client_update_title(Client *self)
 
     if (self->frame)
 	frame_adjust_title(self->frame);
-}
-
-void client_update_icon_title(Client *self)
-{
-    char *data = NULL;
 
+    /* update the icon title */
+    data = NULL;
     g_free(self->icon_title);
-     
+
+    read_title = TRUE;
     /* try netwm */
     if (!PROP_GETS(self->window, net_wm_icon_name, utf8, &data))
 	/* try old x stuff */
-	if (!PROP_GETS(self->window, wm_icon_name, locale, &data))
-            data = g_strdup("Unnamed Window");
+	if (!PROP_GETS(self->window, wm_icon_name, locale, &data)) {
+            data = g_strdup(self->title);
+            read_title = FALSE;
+        }
+
+    /* append the title count, dont display the number for the first window */
+    if (read_title && self->title_count > 1) {
+        char *vdata, *ndata;
+        ndata = g_strdup_printf(" - [%u]", self->title_count);
+        vdata = g_strconcat(data, ndata, NULL);
+        g_free(ndata);
+        g_free(data);
+        data = vdata;
+    }
 
     PROP_SETS(self->window, net_wm_visible_icon_name, data);
 
@@ -1240,7 +1317,7 @@ void client_update_icons(Client *self)
 	    w = data[i++];
 	    h = data[i++];
 	    i += w * h;
-	    if (i > num) break;
+	    if (i > num || w*h == 0) break;
 	    ++self->nicons;
 	}
 
@@ -1249,36 +1326,70 @@ void client_update_icons(Client *self)
 	/* store the icons */
 	i = 0;
 	for (j = 0; j < self->nicons; ++j) {
+            guint x, y, t;
+
 	    w = self->icons[j].width = data[i++];
 	    h = self->icons[j].height = data[i++];
-	    self->icons[j].data =
-		g_memdup(&data[i], w * h * sizeof(gulong));
-	    i += w * h;
+
+            if (w*h == 0) continue;
+
+	    self->icons[j].data = g_new(RrPixel32, w * h);
+            for (x = 0, y = 0, t = 0; t < w * h; ++t, ++x, ++i) {
+                if (x >= w) {
+                    x = 0;
+                    ++y;
+                }
+                self->icons[j].data[t] =
+                    (((data[i] >> 24) & 0xff) << RrDefaultAlphaOffset) +
+                    (((data[i] >> 16) & 0xff) << RrDefaultRedOffset) +
+                    (((data[i] >> 8) & 0xff) << RrDefaultGreenOffset) +
+                    (((data[i] >> 0) & 0xff) << RrDefaultBlueOffset);
+            }
 	    g_assert(i <= num);
 	}
 
 	g_free(data);
-    }
-
-    if (self->frame)
-	frame_adjust_icon(self->frame);
-}
-
-void client_update_kwm_icon(Client *self)
-{
-    guint num;
-    guint32 *data;
-
-    if (!PROP_GETA32(self->window, kwm_win_icon, kwm_win_icon, &data, &num)) {
-	self->pixmap_icon = self->pixmap_icon_mask = None;
-    } else {
+    } else if (PROP_GETA32(self->window, kwm_win_icon,
+                           kwm_win_icon, &data, &num)) {
         if (num == 2) {
-            self->pixmap_icon = data[0];
-            self->pixmap_icon_mask = data[1];
-        } else
-            self->pixmap_icon = self->pixmap_icon_mask = None;
-	g_free(data);
+            self->nicons++;
+            self->icons = g_new(Icon, self->nicons);
+            xerror_set_ignore(TRUE);
+            if (!RrPixmapToRGBA(ob_rr_inst,
+                                data[0], data[1],
+                                &self->icons[self->nicons-1].width,
+                                &self->icons[self->nicons-1].height,
+                                &self->icons[self->nicons-1].data)) {
+                g_free(&self->icons[self->nicons-1]);
+                self->nicons--;
+            }
+            xerror_set_ignore(FALSE);
+        }
+        g_free(data);
+    } else {
+        XWMHints *hints;
+
+        if ((hints = XGetWMHints(ob_display, self->window))) {
+            if (hints->flags & IconPixmapHint) {
+                self->nicons++;
+                self->icons = g_new(Icon, self->nicons);
+                xerror_set_ignore(TRUE);
+                if (!RrPixmapToRGBA(ob_rr_inst,
+                                    hints->icon_pixmap,
+                                    (hints->flags & IconMaskHint ?
+                                     hints->icon_mask : None),
+                                    &self->icons[self->nicons-1].width,
+                                    &self->icons[self->nicons-1].height,
+                                    &self->icons[self->nicons-1].data)){
+                    g_free(&self->icons[self->nicons-1]);
+                    self->nicons--;
+                }
+                xerror_set_ignore(FALSE);
+            }
+            XFree(hints);
+        }
     }
+
     if (self->frame)
 	frame_adjust_icon(self->frame);
 }
@@ -1322,40 +1433,87 @@ static void client_change_state(Client *self)
 	frame_adjust_state(self->frame);
 }
 
-static Client *search_focus_tree(Client *node, Client *skip)
+Client *client_search_focus_tree(Client *self)
 {
     GSList *it;
     Client *ret;
 
-    for (it = node->transients; it != NULL; it = it->next) {
-	Client *c = it->data;
-	if (c == skip) continue; /* circular? */
-	if ((ret = search_focus_tree(c, skip))) return ret;
-	if (client_focused(c)) return c;
+    for (it = self->transients; it != NULL; it = it->next) {
+	if (client_focused(it->data)) return it->data;
+	if ((ret = client_search_focus_tree(it->data))) return ret;
     }
     return NULL;
 }
 
-static void calc_recursive(Client *self, StackLayer l, gboolean raised)
+Client *client_search_focus_tree_full(Client *self)
+{
+    if (self->transient_for) {
+        if (self->transient_for != TRAN_GROUP) {
+            return client_search_focus_tree_full(self->transient_for);
+        } else {
+            GSList *it;
+            gboolean recursed = FALSE;
+        
+            for (it = self->group->members; it; it = it->next)
+                if (!((Client*)it->data)->transient_for) {
+                    Client *c;
+                    if ((c = client_search_focus_tree_full(it->data)))
+                        return c;
+                    recursed = TRUE;
+                }
+            if (recursed)
+              return NULL;
+        }
+    }
+
+    /* this function checks the whole tree, the client_search_focus_tree~
+       does not, so we need to check this window */
+    if (client_focused(self))
+      return self;
+    return client_search_focus_tree(self);
+}
+
+static StackLayer calc_layer(Client *self)
+{
+    StackLayer l;
+
+    if (self->fullscreen) l = Layer_Fullscreen;
+    else if (self->type == Type_Desktop) l = Layer_Desktop;
+    else if (self->type == Type_Dock) {
+        if (!self->below) l = Layer_Top;
+        else l = Layer_Normal;
+    }
+    else if (self->above) l = Layer_Above;
+    else if (self->below) l = Layer_Below;
+    else l = Layer_Normal;
+
+    return l;
+}
+
+static void calc_recursive(Client *self, Client *orig, StackLayer l,
+                           gboolean raised)
 {
-    StackLayer old;
+    StackLayer old, own;
     GSList *it;
 
     old = self->layer;
-    self->layer = l;
+    own = calc_layer(self);
+    self->layer = l > own ? l : own;
 
     for (it = self->transients; it; it = it->next)
-        calc_recursive(it->data, l, raised ? raised : l != old);
+        calc_recursive(it->data, orig, l, raised ? raised : l != old);
 
     if (!raised && l != old)
-	if (self->frame)
-	    stacking_raise(self);
+	if (orig->frame) /* only restack if the original window is managed */
+	    stacking_raise(CLIENT_AS_WINDOW(self));
 }
 
 void client_calc_layer(Client *self)
 {
     StackLayer l;
-    gboolean f;
+    Client *orig;
+
+    orig = self;
 
     /* transients take on the layer of their parents */
     if (self->transient_for) {
@@ -1366,34 +1524,16 @@ void client_calc_layer(Client *self)
 
             for (it = self->group->members; it; it = it->next)
                 if (it->data != self &&
-                    ((Client*)it->data)->transient_for != TRAN_GROUP) {
+                    !((Client*)it->data)->transient_for) {
                     self = it->data;
                     break;
                 }
         }
     }
 
-    /* is us or one of our transients focused? */
-    if (client_focused(self))
-        f = TRUE;
-    else if (search_focus_tree(self, self))
-        f = TRUE;
-    else
-        f = FALSE;
-
-    if (self->iconic) l = Layer_Icon;
-    /* fullscreen windows are only in the fullscreen layer while focused */
-    else if (self->fullscreen && f) l = Layer_Fullscreen;
-    else if (self->type == Type_Desktop) l = Layer_Desktop;
-    else if (self->type == Type_Dock) {
-        if (!self->below) l = Layer_Top;
-        else l = Layer_Normal;
-    }
-    else if (self->above) l = Layer_Above;
-    else if (self->below) l = Layer_Below;
-    else l = Layer_Normal;
+    l = calc_layer(self);
 
-    calc_recursive(self, l, FALSE);
+    calc_recursive(self, orig, l, FALSE);
 }
 
 gboolean client_should_show(Client *self)
@@ -1471,10 +1611,25 @@ void client_configure(Client *self, Corner anchor, int x, int y, int w, int h,
 
     /* set the size and position if fullscreen */
     if (self->fullscreen) {
-	x = 0;
-	y = 0;
-	w = screen_physical_size.width;
-	h = screen_physical_size.height;
+#ifdef VIDMODE
+        int dot;
+        XF86VidModeModeLine mode;
+
+        if (XF86VidModeGetModeLine(ob_display, ob_screen, &dot, &mode)) {
+            w = mode.hdisplay;
+            h = mode.vdisplay;
+            if (mode.privsize) XFree(mode.private);
+        } else {
+#else
+            w = screen_physical_size.width;
+            h = screen_physical_size.height;
+#endif
+#ifdef VIDMODE
+        }
+        if (!XF86VidModeGetViewPort(ob_display, ob_screen, &x, &y)) {
+            x = y = 0;
+#endif
+        }
         user = FALSE; /* ignore that increment etc shit when in fullscreen */
     } else {
         /* set the size and position if maximized */
@@ -1505,16 +1660,32 @@ void client_configure(Client *self, Corner anchor, int x, int y, int w, int h,
     }
 
     if (!(w == self->area.width && h == self->area.height)) {
-        w -= self->base_size.width;
-        h -= self->base_size.height;
+        int basew, baseh, minw, minh;
+
+        /* base size is substituted with min size if not specified */
+        if (self->base_size.width || self->base_size.height) {
+            basew = self->base_size.width;
+            baseh = self->base_size.height;
+        } else {
+            basew = self->min_size.width;
+            baseh = self->min_size.height;
+        }
+        /* min size is substituted with base size if not specified */
+        if (self->min_size.width || self->min_size.height) {
+            minw = self->min_size.width;
+            minh = self->min_size.height;
+        } else {
+            minw = self->base_size.width;
+            minh = self->base_size.height;
+        }
 
         if (user) {
             /* for interactive resizing. have to move half an increment in each
                direction. */
 
             /* how far we are towards the next size inc */
-            int mw = w % self->size_inc.width; 
-            int mh = h % self->size_inc.height;
+            int mw = (w - basew) % self->size_inc.width; 
+            int mh = (h - baseh) % self->size_inc.height;
             /* amount to add */
             int aw = self->size_inc.width / 2;
             int ah = self->size_inc.height / 2;
@@ -1527,21 +1698,18 @@ void client_configure(Client *self, Corner anchor, int x, int y, int w, int h,
             h += ah;
     
             /* if this is a user-requested resize, then check against min/max
-               sizes and aspect ratios */
+               sizes */
 
             /* smaller than min size or bigger than max size? */
             if (w > self->max_size.width) w = self->max_size.width;
-            if (w < self->min_size.width) w = self->min_size.width;
+            if (w < minw) w = minw;
             if (h > self->max_size.height) h = self->max_size.height;
-            if (h < self->min_size.height) h = self->min_size.height;
-
-            /* adjust the height ot match the width for the aspect ratios */
-            if (self->min_ratio)
-                if (h * self->min_ratio > w) h = (int)(w / self->min_ratio);
-            if (self->max_ratio)
-                if (h * self->max_ratio < w) h = (int)(w / self->max_ratio);
+            if (h < minh) h = minh;
         }
 
+        w -= basew;
+        h -= baseh;
+
         /* keep to the increments */
         w /= self->size_inc.width;
         h /= self->size_inc.height;
@@ -1556,8 +1724,23 @@ void client_configure(Client *self, Corner anchor, int x, int y, int w, int h,
         w *= self->size_inc.width;
         h *= self->size_inc.height;
 
-        w += self->base_size.width;
-        h += self->base_size.height;
+        w += basew;
+        h += baseh;
+
+        if (user) {
+            /* adjust the height to match the width for the aspect ratios.
+             for this, min size is not substituted for base size ever. */
+            w -= self->base_size.width;
+            h -= self->base_size.height;
+
+            if (self->min_ratio)
+                if (h * self->min_ratio > w) h = (int)(w / self->min_ratio);
+            if (self->max_ratio)
+                if (h * self->max_ratio < w) h = (int)(w / self->max_ratio);
+
+            w += self->base_size.width;
+            h += self->base_size.height;
+        }
     }
 
     switch (anchor) {
@@ -1580,30 +1763,39 @@ void client_configure(Client *self, Corner anchor, int x, int y, int w, int h,
 
     RECT_SET(self->area, x, y, w, h);
 
-    if (resized)
+    /* for app-requested resizes, always resize if 'resized' is true.
+       for user-requested ones, only resize if final is true, or when
+       resizing in opaque mode */
+    if ((!user && resized) ||
+        (user && (final || (resized && config_opaque_resize))))
 	XResizeWindow(ob_display, self->window, w, h);
 
     /* move/resize the frame to match the request */
     if (self->frame) {
+        if (self->decorations != self->frame->decorations)
+            moved = resized = TRUE;
+
         if (moved || resized)
             frame_adjust_area(self->frame, moved, resized);
 
-        if (!user || final) {
+        /* If you send this and the client hasn't changed you end up with buggy
+           clients (emacs) freaking out, cuz they send back a configure every
+           time they receive this event, which resends them this event... etc.
+        */
+        if ((!user && moved) || (user && final)) {
             XEvent event;
             event.type = ConfigureNotify;
             event.xconfigure.display = ob_display;
             event.xconfigure.event = self->window;
             event.xconfigure.window = self->window;
     
-            /* root window coords with border in mind */
-            event.xconfigure.x = x - self->border_width +
-                self->frame->size.left;
-            event.xconfigure.y = y - self->border_width +
-                self->frame->size.top;
+            /* root window real coords */
+            event.xconfigure.x = self->frame->area.x + self->frame->size.left;
+            event.xconfigure.y = self->frame->area.y + self->frame->size.top;
     
-            event.xconfigure.width = self->area.width;
-            event.xconfigure.height = self->area.height;
-            event.xconfigure.border_width = self->border_width;
+            event.xconfigure.width = w;
+            event.xconfigure.height = h;
+            event.xconfigure.border_width = 0;
             event.xconfigure.above = self->frame->plate;
             event.xconfigure.override_redirect = FALSE;
             XSendEvent(event.xconfigure.display, event.xconfigure.window,
@@ -1674,31 +1866,27 @@ void client_iconify(Client *self, gboolean iconic, gboolean curdesk)
 {
     GSList *it;
 
-    /* move up the transient chain as far as possible first if deiconifying */
-    if (!iconic)
-        while (self->transient_for) {
-            if (self->transient_for != TRAN_GROUP) {
-                if (self->transient_for->iconic == iconic)
-                    break;
-                self = self->transient_for;
-            } else {
-                GSList *it;
-
-                /* the check for TRAN_GROUP is to prevent an infinate loop with
-                   2 transients of the same group at the head of the group's
-                   members list */
-                for (it = self->group->members; it; it = it->next) {
-                    Client *c = it->data;
+    /* move up the transient chain as far as possible first */
+    if (self->transient_for) {
+        if (self->transient_for != TRAN_GROUP) {
+            if (self->transient_for->iconic != iconic) {
+                client_iconify(self->transient_for, iconic, curdesk);
+                return;
+            }
+        } else {
+            GSList *it;
 
-                    if (c != self && c->transient_for->iconic != iconic &&
-                        c->transient_for != TRAN_GROUP) {
-                        self = it->data;
-                        break;
-                    }
+            for (it = self->group->members; it; it = it->next) {
+                Client *c = it->data;
+                if (c != self && c->iconic != iconic &&
+                    !c->transient_for) {
+                    client_iconify(it->data, iconic, curdesk);
+                    break;
                 }
-                if (it == NULL) break;
             }
+            if (it != NULL) return;
         }
+    }
 
     if (self->iconic == iconic) return; /* nothing to do */
 
@@ -1713,11 +1901,24 @@ void client_iconify(Client *self, gboolean iconic, gboolean curdesk)
 	/* we unmap the client itself so that we can get MapRequest events,
 	   and because the ICCCM tells us to! */
 	XUnmapWindow(ob_display, self->window);
+
+        /* update the focus lists.. iconic windows go to the bottom of the
+         list, put the new iconic window at the 'top of the bottom'. */
+        focus_order_to_top(self);
     } else {
 	if (curdesk)
 	    client_set_desktop(self, screen_desktop, FALSE);
 	self->wmstate = self->shaded ? IconicState : NormalState;
 	XMapWindow(ob_display, self->window);
+
+        /* this puts it after the current focused window */
+        focus_order_remove(self);
+        focus_order_add_new(self);
+
+        /* this is here cuz with the VIDMODE extension, the viewport can change
+           while a fullscreen window is iconic, and when it uniconifies, it
+           would be nice if it did so to the new position of the viewport */
+        client_reconfigure(self);
     }
     client_change_state(self);
     client_showhide(self);
@@ -1881,14 +2082,17 @@ void client_kill(Client *self)
 
 void client_set_desktop(Client *self, guint target, gboolean donthide)
 {
-    guint old, i;
+    guint old;
 
     if (target == self->desktop) return;
   
-    g_message("Setting desktop %u", target);
+    g_message("Setting desktop %u", target+1);
 
     g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
 
+    /* remove from the old desktop(s) */
+    focus_order_remove(self);
+
     old = self->desktop;
     self->desktop = target;
     PROP_SET32(self->window, net_wm_desktop, cardinal, target);
@@ -1899,51 +2103,31 @@ void client_set_desktop(Client *self, guint target, gboolean donthide)
         client_showhide(self);
     /* raise if it was not already on the desktop */
     if (old != DESKTOP_ALL)
-        stacking_raise(self);
+        stacking_raise(CLIENT_AS_WINDOW(self));
     screen_update_struts();
 
-    /* update the focus lists */
-    if (old == DESKTOP_ALL) {
-        for (i = 0; i < screen_num_desktops; ++i)
-            focus_order[i] = g_list_remove(focus_order[i], self);
-    } else
-        focus_order[old] = g_list_remove(focus_order[old], self);
-    if (target == DESKTOP_ALL) {
-        for (i = 0; i < screen_num_desktops; ++i) {
-            if (config_focus_new)
-                focus_order[i] = g_list_prepend(focus_order[i], self);
-            else
-                focus_order[i] = g_list_append(focus_order[i], self);
-        }
-    } else {
-        if (config_focus_new)
-            focus_order[target] = g_list_prepend(focus_order[target], self);
-        else
-            focus_order[target] = g_list_append(focus_order[target], self);
-    }
+    /* add to the new desktop(s) */
+    if (config_focus_new)
+        focus_order_to_top(self);
+    else
+        focus_order_to_bottom(self);
 
     dispatch_client(Event_Client_Desktop, self, target, old);
 }
 
-static Client *search_modal_tree(Client *node, Client *skip)
+Client *client_search_modal_child(Client *self)
 {
     GSList *it;
     Client *ret;
   
-    for (it = node->transients; it != NULL; it = it->next) {
+    for (it = self->transients; it != NULL; it = it->next) {
 	Client *c = it->data;
-	if (c == skip) continue; /* circular? */
-	if ((ret = search_modal_tree(c, skip))) return ret;
+	if ((ret = client_search_modal_child(c))) return ret;
 	if (c->modal) return c;
     }
     return NULL;
 }
 
-Client *client_find_modal_child(Client *self)
-{
-    return search_modal_tree(self, self);
-}
-
 gboolean client_validate(Client *self)
 {
     XEvent e; 
@@ -2094,7 +2278,7 @@ void client_set_state(Client *self, Atom action, long data1, long data2)
     if (shaded != self->shaded)
 	client_shade(self, shaded);
     client_calc_layer(self);
-    client_change_state(self); /* change the hint to relect these changes */
+    client_change_state(self); /* change the hint to reflect these changes */
 }
 
 Client *client_focus_target(Client *self)
@@ -2102,43 +2286,25 @@ Client *client_focus_target(Client *self)
     Client *child;
      
     /* if we have a modal child, then focus it, not us */
-    child = client_find_modal_child(self);
+    child = client_search_modal_child(self);
     if (child) return child;
     return self;
 }
 
-gboolean client_focusable(Client *self)
-{
-    /* won't try focus if the client doesn't want it, or if the window isn't
-       visible on the screen */
-    return self->frame->visible &&
-        (self->can_focus || self->focus_notify);
-}
-
-gboolean client_focus(Client *self)
+gboolean client_can_focus(Client *self)
 {
     XEvent ev;
-    guint i;
 
     /* choose the correct target */
     self = client_focus_target(self);
 
-    if (self->desktop != DESKTOP_ALL && self->desktop != screen_desktop) {
-        /* update the focus lists */
-        if (self->desktop == DESKTOP_ALL) {
-            for (i = 0; i < screen_num_desktops; ++i) {
-                focus_order[i] = g_list_remove(focus_order[i], self);
-                focus_order[i] = g_list_prepend(focus_order[i], self);
-            }
-        } else {
-            i = self->desktop;
-            focus_order[i] = g_list_remove(focus_order[i], self);
-            focus_order[i] = g_list_prepend(focus_order[i], self);
-        }
+    if (!self->frame->visible)
         return FALSE;
-    }
 
-    if (!client_focusable(self))
+    if (!((self->can_focus || self->focus_notify) &&
+          (self->desktop == screen_desktop ||
+           self->desktop == DESKTOP_ALL) &&
+          !self->iconic))
 	return FALSE;
 
     /* do a check to see if the window has already been unmapped or destroyed
@@ -2159,8 +2325,24 @@ gboolean client_focus(Client *self)
 	}
     }
 
+    return TRUE;
+}
+
+gboolean client_focus(Client *self)
+{
+    /* choose the correct target */
+    self = client_focus_target(self);
+
+    if (!client_can_focus(self)) {
+        if (!self->frame->visible) {
+            /* update the focus lists */
+            focus_order_to_top(self);
+        }
+        return FALSE;
+    }
+
     if (self->can_focus)
-        /* RevertToPointerRoot causes much more headache than TevertToNone, so
+        /* RevertToPointerRoot causes much more headache than RevertToNone, so
            I choose to use it always, hopefully to find errors quicker, if any
            are left. (I hate X. I hate focus events.) */
 	XSetInputFocus(ob_display, self->window, RevertToPointerRoot,
@@ -2182,7 +2364,9 @@ gboolean client_focus(Client *self)
     }
 
 #ifdef DEBUG_FOCUS
-    g_message("focusing %lx", self->window);
+    g_message("%sively focusing %lx at %d", (self->can_focus ? "act" : "pass"),
+              self->window, (int)
+              event_lasttime);
 #endif
 
     /* Cause the FocusIn to come back to us. Important for desktop switches,
@@ -2196,11 +2380,27 @@ void client_unfocus(Client *self)
 {
     g_assert(focus_client == self);
 #ifdef DEBUG_FOCUS
-    g_message("client_unfocus");
+    g_message("client_unfocus for %lx", self->window);
 #endif
     focus_fallback(Fallback_Unfocusing);
 }
 
+void client_activate(Client *self)
+{
+    if (client_normal(self) && screen_showing_desktop)
+        screen_show_desktop(FALSE);
+    if (self->iconic)
+        client_iconify(self, FALSE, TRUE);
+    else if (!self->frame->visible)
+        /* if its not visible for other reasons, then don't mess
+           with it */
+        return;
+    if (self->shaded)
+        client_shade(self, FALSE);
+    client_focus(self);
+    stacking_raise(CLIENT_AS_WINDOW(self));
+}
+
 gboolean client_focused(Client *self)
 {
     return self == focus_client;
@@ -2230,3 +2430,113 @@ Icon *client_icon(Client *self, int w, int h)
         return &self->icons[si];
     return &self->icons[li];
 }
+
+/* this be mostly ripped from fvwm */
+Client *client_find_directional(Client *c, Direction dir) 
+{
+    int my_cx, my_cy, his_cx, his_cy;
+    int offset = 0;
+    int distance = 0;
+    int score, best_score;
+    Client *best_client, *cur;
+    GList *it;
+
+    if(!client_list)
+        return NULL;
+
+    /* first, find the centre coords of the currently focused window */
+    my_cx = c->frame->area.x + c->frame->area.width / 2;
+    my_cy = c->frame->area.y + c->frame->area.height / 2;
+
+    best_score = -1;
+    best_client = NULL;
+
+    for(it = g_list_first(client_list); it; it = it->next) {
+        cur = it->data;
+
+        /* the currently selected window isn't interesting */
+        if(cur == c)
+            continue;
+        if (!client_normal(cur))
+            continue;
+        if(c->desktop != cur->desktop && cur->desktop != DESKTOP_ALL)
+            continue;
+        if(cur->iconic)
+            continue;
+	if(client_focus_target(cur) == cur &&
+           !(cur->can_focus || cur->focus_notify))
+            continue;
+
+        /* find the centre coords of this window, from the
+         * currently focused window's point of view */
+        his_cx = (cur->frame->area.x - my_cx)
+            + cur->frame->area.width / 2;
+        his_cy = (cur->frame->area.y - my_cy)
+            + cur->frame->area.height / 2;
+
+        if(dir > 3) { 
+            int tx;
+            /* Rotate the diagonals 45 degrees counterclockwise.
+             * To do this, multiply the matrix /+h +h\ with the
+             * vector (x y).                   \-h +h/
+             * h = sqrt(0.5). We can set h := 1 since absolute
+             * distance doesn't matter here. */
+            tx = his_cx + his_cy;
+            his_cy = -his_cx + his_cy;
+            his_cx = tx;
+        }
+
+        switch(dir) {
+        case Direction_North :
+        case Direction_South :
+        case Direction_NorthEast :
+        case Direction_SouthWest :
+            offset = (his_cx < 0) ? -his_cx : his_cx;
+            distance = (dir == Direction_North || dir == Direction_NorthEast) ?
+                -his_cy : his_cy;
+            break;
+        case Direction_East :
+        case Direction_West :
+        case Direction_SouthEast :
+        case Direction_NorthWest :
+            offset = (his_cy < 0) ? -his_cy : his_cy;
+            distance = (dir == Direction_West || dir == Direction_NorthWest) ?
+                -his_cx : his_cx;
+            break;
+        }
+
+        /* the target must be in the requested direction */
+        if(distance <= 0)
+            continue;
+
+        /* Calculate score for this window.  The smaller the better. */
+        score = distance + offset;
+
+        /* windows more than 45 degrees off the direction are
+         * heavily penalized and will only be chosen if nothing
+         * else within a million pixels */
+        if(offset > distance)
+            score += 1000000;
+
+        if(best_score == -1 || score < best_score)
+            best_client = cur,
+                best_score = score;
+    }
+
+    return best_client;
+}
+
+void client_set_layer(Client *self, int layer)
+{
+    if (layer < 0) {
+        self->below = TRUE;
+        self->above = FALSE;
+    } else if (layer == 0) {
+        self->below = self->above = FALSE;
+    } else {
+        self->below = FALSE;
+        self->above = TRUE;
+    }
+    client_calc_layer(self);
+    client_change_state(self); /* reflect this in the state hints */
+}