X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fclient.c;h=5d897f1c00faf01f78d3956f133ea98815b91b8a;hb=bf32b376b595eab16a300f63937cad1042361eec;hp=b9cebb79f1c4eef04c0ac08d670518182e5f520c;hpb=bfea000a7407e51b5659590415e410a47f6f046b;p=chaz%2Fopenbox

diff --git a/openbox/client.c b/openbox/client.c
index b9cebb79..5d897f1c 100644
--- a/openbox/client.c
+++ b/openbox/client.c
@@ -2,9 +2,11 @@
 #include "screen.h"
 #include "prop.h"
 #include "extensions.h"
+#include "config.h"
 #include "frame.h"
 #include "engine.h"
 #include "event.h"
+#include "grab.h"
 #include "focus.h"
 #include "stacking.h"
 #include "dispatch.h"
@@ -22,6 +24,9 @@
 GSList     *client_list      = NULL;
 GHashTable *client_map       = NULL;
 
+static Window *client_startup_stack_order = NULL;
+static gulong  client_startup_stack_size = 0;
+
 static void client_get_all(Client *self);
 static void client_toggle_border(Client *self, gboolean show);
 static void client_get_area(Client *self);
@@ -37,13 +42,18 @@ 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; }
+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_GET32U(ob_root, net_client_list_stacking, window,
+                client_startup_stack_order, client_startup_stack_size);
+
     client_set_list();
 }
 
@@ -77,6 +87,7 @@ void client_set_list()
 
 void client_manage_all()
 {
+    ConfigValue focus_new;
     unsigned int i, j, nchild;
     Window w, *children;
     XWMHints *wmhints;
@@ -111,6 +122,27 @@ void client_manage_all()
 	}
     }
     XFree(children);
+
+    /* stack them as they were on startup!
+       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);
+        g_message("0x%lx %d", c->window, c->iconic);
+        if (c) stacking_lower(c);
+    }
+    g_free(client_startup_stack_order);
+    client_startup_stack_order = NULL;
+    client_startup_stack_size = 0;
+
+    if (!config_get("focusNew", Config_Bool, &focus_new))
+        g_assert_not_reached();
+    if (focus_new.bool)
+        focus_fallback(FALSE);
 }
 
 void client_manage(Window window)
@@ -120,26 +152,25 @@ void client_manage(Window window)
     XWindowAttributes attrib;
     XSetWindowAttributes attrib_set;
 /*    XWMHints *wmhint; */
-     
-    XGrabServer(ob_display);
-    XSync(ob_display, FALSE);
+    guint i;
+    ConfigValue focus_new;
+
+    grab_server(TRUE);
 
     /* check if it has already been unmapped by the time we started mapping
        the grab does a sync so we don't have to here */
     if (XCheckTypedWindowEvent(ob_display, window, DestroyNotify, &e) ||
 	XCheckTypedWindowEvent(ob_display, window, UnmapNotify, &e)) {
 	XPutBackEvent(ob_display, &e);
-    
-	XUngrabServer(ob_display);
-	XFlush(ob_display);
+
+        grab_server(FALSE);
 	return; /* don't manage it */
     }
 
     /* make sure it isn't an override-redirect window */
     if (!XGetWindowAttributes(ob_display, window, &attrib) ||
 	attrib.override_redirect) {
-	XUngrabServer(ob_display);
-	XFlush(ob_display);
+        grab_server(FALSE);
 	return; /* don't manage it */
     }
   
@@ -148,8 +179,7 @@ void client_manage(Window window)
 	if ((wmhint->flags & StateHint) &&
 	    wmhint->initial_state == WithdrawnState) {
 	    /\* XXX: make dock apps work! *\/
-	    XUngrabServer(ob_display);
-	    XFlush(ob_display);
+            grab_server(FALSE);
 	    XFree(wmhint);
 	    return;
 	}
@@ -184,12 +214,21 @@ void client_manage(Window window)
 
     client_apply_startup_state(client);
 
-    XUngrabServer(ob_display);
-    XFlush(ob_display);
+    grab_server(FALSE);
      
     client_list = g_slist_append(client_list, client);
     stacking_list = g_list_append(stacking_list, client);
-    g_hash_table_insert(client_map, (gpointer)window, client);
+    g_assert(!g_hash_table_lookup(client_map, &client->window));
+    g_hash_table_insert(client_map, &client->window, client);
+
+    /* update the focus lists */
+    if (client->desktop == DESKTOP_ALL) {
+        for (i = 0; i < screen_num_desktops; ++i)
+            focus_order[i] = g_list_append(focus_order[i], client);
+    } else {
+        i = client->desktop;
+        focus_order[i] = g_list_append(focus_order[i], client);
+    }
 
     stacking_raise(client);
 
@@ -201,13 +240,15 @@ void client_manage(Window window)
 
     dispatch_client(Event_Client_Mapped, client, 0, 0);
 
-    /* grab all mouse bindings */
-    /*pointer_grab_all(client, TRUE);XXX*/
+    if (!config_get("focusNew", Config_Bool, &focus_new))
+        g_assert_not_reached();
+    if (ob_state != State_Starting && focus_new.bool)
+        client_focus(client);
 
     /* update the list hints */
     client_set_list();
 
-    g_message("Managed window 0x%lx", window);
+/*    g_message("Managed window 0x%lx", window);*/
 }
 
 void client_unmanage_all()
@@ -218,12 +259,14 @@ void client_unmanage_all()
 
 void client_unmanage(Client *client)
 {
+    guint i;
     int j;
     GSList *it;
 
-    g_message("Unmanaging window: %lx", client->window);
+/*    g_message("Unmanaging window: %lx", client->window);*/
 
     dispatch_client(Event_Client_Destroy, client, 0, 0);
+    g_assert(client != NULL);
 
     /* remove the window from our save set */
     XChangeSaveSet(ob_display, client->window, SetModeDelete);
@@ -231,20 +274,20 @@ void client_unmanage(Client *client)
     /* we dont want events no more */
     XSelectInput(ob_display, client->window, NoEventMask);
 
-    /* ungrab any mouse bindings */
-    /*pointer_grab_all(client, FALSE);XXX*/
-     
     engine_frame_hide(client->frame);
 
-    /* give the client its border back */
-    client_toggle_border(client, TRUE);
-
-    /* reparent the window out of the frame, and free the frame */
-    engine_frame_release_client(client->frame, client);
-     
     client_list = g_slist_remove(client_list, client);
     stacking_list = g_list_remove(stacking_list, client);
-    g_hash_table_remove(client_map, (gpointer)client->window);
+    g_hash_table_remove(client_map, &client->window);
+
+    /* update the focus lists */
+    if (client->desktop == DESKTOP_ALL) {
+        for (i = 0; i < screen_num_desktops; ++i)
+            focus_order[i] = g_list_remove(focus_order[i], client);
+    } else {
+        i = client->desktop;
+        focus_order[i] = g_list_remove(focus_order[i], client);
+    }
 
     /* once the client is out of the list, update the struts to remove it's
        influence */
@@ -261,11 +304,22 @@ void client_unmanage(Client *client)
 	client_calc_layer(it->data);
     }
 
-    /* unfocus the client (calls the focus callbacks) (we're out of the
+    /* dispatch the unmapped event */
+    dispatch_client(Event_Client_Unmapped, client, 0, 0);
+    g_assert(client != NULL);
+
+    /* unfocus the client (dispatchs the focus event) (we're out of the
      transient lists already, so being modal doesn't matter) */
-    if (client->focused)
+    if (client_focused(client))
 	client_unfocus(client);
-    
+
+    /* give the client its border back */
+    client_toggle_border(client, TRUE);
+
+    /* reparent the window out of the frame, and free the frame */
+    engine_frame_release_client(client->frame, client);
+    client->frame = NULL;
+     
     if (ob_state != State_Exiting) {
 	/* these values should not be persisted across a window
 	   unmapping/mapping */
@@ -286,8 +340,8 @@ void client_unmanage(Client *client)
 	g_free(client->icons);
     g_free(client->title);
     g_free(client->icon_title);
-    g_free(client->res_name);
-    g_free(client->res_class);
+    g_free(client->name);
+    g_free(client->class);
     g_free(client->role);
     g_free(client);
      
@@ -370,9 +424,8 @@ static void client_get_all(Client *self)
     /* defaults */
     self->frame = NULL;
     self->title = self->icon_title = NULL;
-    self->res_name = self->res_class = self->role = NULL;
+    self->name = self->class = self->role = NULL;
     self->wmstate = NormalState;
-    self->focused = FALSE;
     self->transient = FALSE;
     self->transients = NULL;
     self->transient_for = NULL;
@@ -512,7 +565,7 @@ void client_update_transient_for(Client *self)
     if (XGetTransientForHint(ob_display, self->window, &t) &&
 	t != self->window) { /* cant be transient to itself! */
 	self->transient = TRUE;
-	c = g_hash_table_lookup(client_map, (gpointer)t);
+	c = g_hash_table_lookup(client_map, &t);
 	g_assert(c != self);/* if this happens then we need to check for it*/
 
 	if (!c /*XXX: && _group*/) {
@@ -533,11 +586,13 @@ void client_update_transient_for(Client *self)
     if (c != self->transient_for) {
 	if (self->transient_for)
 	    /* remove from old parent */
-	    g_slist_remove(self->transient_for->transients, self);
+	    self->transient_for->transients =
+                g_slist_remove(self->transient_for->transients, self);
 	self->transient_for = c;
 	if (self->transient_for)
 	    /* add to new parent */
-	    g_slist_append(self->transient_for->transients, self);
+	    self->transient_for->transients =
+                g_slist_append(self->transient_for->transients, self);
     }
 }
 
@@ -776,7 +831,7 @@ void client_setup_decor_and_functions(Client *self)
 
     /* can't maximize without moving/resizing */
     if (!((self->functions & Func_Move) && (self->functions & Func_Resize)))
-	self->functions &= ~Func_Maximize;
+	self->functions &= ~(Func_Maximize | Func_Fullscreen);
 
     /* finally, user specified disabled decorations are applied to subtract
        decorations */
@@ -802,10 +857,9 @@ void client_setup_decor_and_functions(Client *self)
     client_change_allowed_actions(self);
 
     if (self->frame) {
-	/* change the decors on the frame */
-	engine_frame_adjust_size(self->frame);
-	/* with more/less decorations, we may need to be repositioned */
-	engine_frame_adjust_position(self->frame);
+	/* change the decors on the frame, and with more/less decorations,
+           we may also need to be repositioned */
+	engine_frame_adjust_area(self->frame, TRUE, TRUE);
 	/* with new decor, the window's maximized size may change */
 	client_remaximize(self);
     }
@@ -921,7 +975,7 @@ void client_update_wmhints(Client *self)
 
     if (ur != self->urgent) {
 	self->urgent = ur;
-	g_message("Urgent Hint for 0x%lx: %s\n", self->window,
+	g_message("Urgent Hint for 0x%lx: %s", self->window,
 		  ur ? "ON" : "OFF");
 	/* fire the urgent callback if we're mapped, otherwise, wait until
 	   after we're mapped */
@@ -934,8 +988,7 @@ void client_update_title(Client *self)
 {
     gchar *data = NULL;
 
-    if (self->title != NULL)
-	g_free(self->title);
+    g_free(self->title);
      
     /* try netwm */
     if (!PROP_GETS(self->window, net_wm_name, utf8, data)) {
@@ -969,8 +1022,7 @@ void client_update_icon_title(Client *self)
 {
     gchar *data = NULL;
 
-    if (self->icon_title != NULL)
-	g_free(self->icon_title);
+    g_free(self->icon_title);
      
     /* try netwm */
     if (!PROP_GETS(self->window, net_wm_icon_name, utf8, data)) {
@@ -1003,19 +1055,19 @@ void client_update_class(Client *self)
     gchar *s;
     guint i;
 
-    if (self->res_name) g_free(self->res_name);
-    if (self->res_class) g_free(self->res_class);
+    if (self->name) g_free(self->name);
+    if (self->class) g_free(self->class);
     if (self->role) g_free(self->role);
 
-    self->res_name = self->res_class = self->role = NULL;
+    self->name = self->class = self->role = NULL;
 
     data = g_ptr_array_new();
      
     if (PROP_GETSA(self->window, wm_class, string, data)) {
 	if (data->len > 0)
-	    self->res_name = g_strdup(g_ptr_array_index(data, 0));
+	    self->name = g_strdup(g_ptr_array_index(data, 0));
 	if (data->len > 1)
-	    self->res_class = g_strdup(g_ptr_array_index(data, 1));
+	    self->class = g_strdup(g_ptr_array_index(data, 1));
     }
      
     for (i = 0; i < data->len; ++i)
@@ -1025,8 +1077,8 @@ void client_update_class(Client *self)
     if (PROP_GETS(self->window, wm_window_role, string, s))
 	self->role = g_strdup(s);
 
-    if (self->res_name == NULL) self->res_name = g_strdup("");
-    if (self->res_class == NULL) self->res_class = g_strdup("");
+    if (self->name == NULL) self->name = g_strdup("");
+    if (self->class == NULL) self->class = g_strdup("");
     if (self->role == NULL) self->role = g_strdup("");
 }
 
@@ -1075,8 +1127,8 @@ void client_update_icons(Client *self)
 	/* store the icons */
 	i = 0;
 	for (j = 0; j < self->nicons; ++j) {
-	    w = self->icons[j].w = data[i++];
-	    h = self->icons[j].h = data[i++];
+	    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;
@@ -1086,11 +1138,6 @@ void client_update_icons(Client *self)
 	g_free(data);
     }
 
-    if (self->nicons <= 0) {
-	self->nicons = 1;
-	self->icons = g_new0(Icon, 1);
-    }
-
     if (self->frame)
 	engine_frame_adjust_icon(self->frame);
 }
@@ -1154,11 +1201,11 @@ static Client *search_focus_tree(Client *node, Client *skip)
     GSList *it;
     Client *ret;
 
-    for (it = node->transients; it != NULL; it = g_slist_next(it)) {
+    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 (c->focused) return c;
+	if (client_focused(c)) return c;
     }
     return NULL;
 }
@@ -1271,59 +1318,94 @@ void client_configure(Client *self, Corner anchor, int x, int y, int w, int h,
 {
     gboolean moved = FALSE, resized = FALSE;
 
-    w -= self->base_size.width;
-    h -= self->base_size.height;
+    /* set the size and position if fullscreen */
+    if (self->fullscreen) {
+	x = 0;
+	y = 0;
+	w = screen_physical_size.width;
+	h = screen_physical_size.height;
+    } else {
+        /* set the size and position if maximized */
+        if (self->max_horz) {
+            x = screen_area(self->desktop)->x - self->frame->size.left;
+            w = screen_area(self->desktop)->x +
+                screen_area(self->desktop)->width;
+        }
+        if (self->max_vert) {
+            y = screen_area(self->desktop)->y;
+            h = screen_area(self->desktop)->y +
+                screen_area(self->desktop)->height -
+                self->frame->size.top - self->frame->size.bottom;
+        }
+    }
 
+    /* these override the above states! if you cant move you can't move! */
     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;
-	/* amount to add */
-	int aw = self->size_inc.width / 2;
-	int ah = self->size_inc.height / 2;
-	/* don't let us move into a new size increment */
-	if (mw + aw >= self->size_inc.width)
-	    aw = self->size_inc.width - mw - 1;
-	if (mh + ah >= self->size_inc.height)
-	    ah = self->size_inc.height - mh - 1;
-	w += aw;
-	h += ah;
-    
-	/* if this is a user-requested resize, then check against min/max
-	   sizes and aspect ratios */
-
-	/* 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 (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 (!(self->functions & Func_Move)) {
+            x = self->area.x;
+            y = self->area.y;
+        }
+        if (!(self->functions & Func_Resize)) {
+            w = self->area.width;
+            h = self->area.height;
+        }
     }
 
-    /* keep to the increments */
-    w /= self->size_inc.width;
-    h /= self->size_inc.height;
-
-    /* you cannot resize to nothing */
-    if (w < 1) w = 1;
-    if (h < 1) h = 1;
+    if (!(w == self->area.width && h == self->area.height)) {
+        w -= self->base_size.width;
+        h -= 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;
+            /* amount to add */
+            int aw = self->size_inc.width / 2;
+            int ah = self->size_inc.height / 2;
+            /* don't let us move into a new size increment */
+            if (mw + aw >= self->size_inc.width)
+                aw = self->size_inc.width - mw - 1;
+            if (mh + ah >= self->size_inc.height)
+                ah = self->size_inc.height - mh - 1;
+            w += aw;
+            h += ah;
+    
+            /* if this is a user-requested resize, then check against min/max
+               sizes and aspect ratios */
+
+            /* 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 (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);
+        }
+
+        /* keep to the increments */
+        w /= self->size_inc.width;
+        h /= self->size_inc.height;
+
+        /* you cannot resize to nothing */
+        if (w < 1) w = 1;
+        if (h < 1) h = 1;
   
-    /* store the logical size */
-    SIZE_SET(self->logical_size, w, h);
+        /* store the logical size */
+        SIZE_SET(self->logical_size, w, h);
 
-    w *= self->size_inc.width;
-    h *= self->size_inc.height;
+        w *= self->size_inc.width;
+        h *= self->size_inc.height;
 
-    w += self->base_size.width;
-    h += self->base_size.height;
+        w += self->base_size.width;
+        h += self->base_size.height;
+    }
 
     switch (anchor) {
     case Corner_TopLeft:
@@ -1350,40 +1432,35 @@ void client_configure(Client *self, Corner anchor, int x, int y, int w, int h,
 
     /* move/resize the frame to match the request */
     if (self->frame) {
-	/* Adjust the size and then the position, as required by the EWMH */
-	if (resized)
-	    engine_frame_adjust_size(self->frame);
-	if (moved) {
-	    engine_frame_adjust_position(self->frame);
-
-	    if (!user || final) {
-		XEvent event;
-		event.type = ConfigureNotify;
-		event.xconfigure.display = ob_display;
-		event.xconfigure.event = self->window;
-		event.xconfigure.window = self->window;
+        if (moved || resized)
+            engine_frame_adjust_area(self->frame, moved, resized);
+
+        if (!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 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;
     
-		event.xconfigure.width = self->area.width;
-		event.xconfigure.height = self->area.height;
-		event.xconfigure.border_width = self->border_width;
-		event.xconfigure.above = self->frame->plate;
-		event.xconfigure.override_redirect = FALSE;
-		XSendEvent(event.xconfigure.display, event.xconfigure.window,
-			   FALSE, StructureNotifyMask, &event);
-	    }
+            event.xconfigure.width = self->area.width;
+            event.xconfigure.height = self->area.height;
+            event.xconfigure.border_width = self->border_width;
+            event.xconfigure.above = self->frame->plate;
+            event.xconfigure.override_redirect = FALSE;
+            XSendEvent(event.xconfigure.display, event.xconfigure.window,
+                       FALSE, StructureNotifyMask, &event);
 	}
     }
 }
 
 void client_fullscreen(Client *self, gboolean fs, gboolean savearea)
 {
-    static int saved_func, saved_decor;
     int x, y, w, h;
 
     if (!(self->functions & Func_Fullscreen) || /* can't */
@@ -1394,11 +1471,11 @@ void client_fullscreen(Client *self, gboolean fs, gboolean savearea)
 
     if (fs) {
 	/* save the functions and remove them */
-	saved_func = self->functions;
+	self->pre_fs_func = self->functions;
 	self->functions &= (Func_Close | Func_Fullscreen |
 			    Func_Iconify);
 	/* save the decorations and remove them */
-	saved_decor = self->decorations;
+	self->pre_fs_decor = self->decorations;
 	self->decorations = 0;
 	if (savearea) {
 	    long dimensions[4];
@@ -1410,15 +1487,15 @@ void client_fullscreen(Client *self, gboolean fs, gboolean savearea)
 	    PROP_SET32A(self->window, openbox_premax, cardinal,
 			dimensions, 4);
 	}
-	x = 0;
-	y = 0;
-	w = screen_physical_size.width;
-	h = screen_physical_size.height;
+
+        /* these are not actually used cuz client_configure will set them
+           as appropriate when the window is fullscreened */
+        x = y = w = h = 0;
     } else {
 	long *dimensions;
 
-	self->functions = saved_func;
-	self->decorations = saved_decor;
+	self->functions = self->pre_fs_func;
+	self->decorations = self->pre_fs_decor;
 	  
 	if (PROP_GET32A(self->window, openbox_premax, cardinal,
 			dimensions, 4)) {
@@ -1455,7 +1532,7 @@ void client_iconify(Client *self, gboolean iconic, gboolean curdesk)
 {
     if (self->iconic == iconic) return; /* nothing to do */
 
-    g_message("%sconifying window: 0x%lx\n", (iconic ? "I" : "Uni"),
+    g_message("%sconifying window: 0x%lx", (iconic ? "I" : "Uni"),
 	      self->window);
 
     self->iconic = iconic;
@@ -1475,6 +1552,9 @@ void client_iconify(Client *self, gboolean iconic, gboolean curdesk)
     client_change_state(self);
     client_showhide(self);
     screen_update_struts();
+
+    dispatch_client(iconic ? Event_Client_Unmapped : Event_Client_Mapped,
+                    self, 0, 0);
 }
 
 void client_maximize(Client *self, gboolean max, int dir, gboolean savearea)
@@ -1529,17 +1609,13 @@ void client_maximize(Client *self, gboolean max, int dir, gboolean savearea)
 	    PROP_SET32A(self->window, openbox_premax, cardinal,
 			dimensions, 4);
 	}
-	if (dir == 0 || dir == 1) { /* horz */
-	    x = screen_area(self->desktop)->x - self->frame->size.left;
-	    w = screen_area(self->desktop)->x +
-		screen_area(self->desktop)->width;
-	}
-	if (dir == 0 || dir == 2) { /* vert */
-	    y = screen_area(self->desktop)->y;
-	    h = screen_area(self->desktop)->y +
-		screen_area(self->desktop)->height -
-		self->frame->size.top - self->frame->size.bottom;
-	}
+
+        /* pass the client's current position info. the client_configure
+           will move/size stuff as appropriate for a maximized window */
+        x = self->area.x;
+        y = self->area.y;
+        w = self->area.width;
+        h = self->area.height;
     } else {
 	long *dimensions;
 
@@ -1594,7 +1670,8 @@ void client_shade(Client *self, gboolean shade)
 	self->wmstate = shade ? IconicState : NormalState;
     self->shaded = shade;
     client_change_state(self);
-    engine_frame_adjust_size(self->frame);
+    /* resize the frame to just the titlebar */
+    engine_frame_adjust_area(self->frame, FALSE, FALSE);
 }
 
 void client_close(Client *self)
@@ -1617,24 +1694,27 @@ void client_close(Client *self)
     ce.xclient.window = self->window;
     ce.xclient.format = 32;
     ce.xclient.data.l[0] = prop_atoms.wm_delete_window;
-    ce.xclient.data.l[1] = CurrentTime;
+    ce.xclient.data.l[1] = event_lasttime;
     ce.xclient.data.l[2] = 0l;
     ce.xclient.data.l[3] = 0l;
     ce.xclient.data.l[4] = 0l;
     XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
 }
 
+void client_kill(Client *self)
+{
+    XKillClient(ob_display, self->window);
+}
+
 void client_set_desktop(Client *self, guint target)
 {
-    guint old;
+    guint old, i;
 
     if (target == self->desktop) return;
   
     g_message("Setting desktop %u\n", target);
 
-    if (!(target < screen_num_desktops ||
-	  target == DESKTOP_ALL))
-	return;
+    g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
 
     old = self->desktop;
     self->desktop = target;
@@ -1645,6 +1725,18 @@ void client_set_desktop(Client *self, guint target)
     client_showhide(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);
+        focus_order[target] = g_list_prepend(focus_order[target], self);
+    } else {
+        focus_order[old] = g_list_remove(focus_order[old], self);
+        if (target == DESKTOP_ALL)
+            for (i = 0; i < screen_num_desktops; ++i)
+                focus_order[i] = g_list_prepend(focus_order[i], self);
+    }
+
     dispatch_client(Event_Client_Desktop, self, target, old);
 }
 
@@ -1853,9 +1945,10 @@ gboolean client_focus(Client *self)
 	    return FALSE;
 	}
     }
-     
+
     if (self->can_focus)
-	XSetInputFocus(ob_display, self->window, RevertToNone, CurrentTime);
+	XSetInputFocus(ob_display, self->window, RevertToPointerRoot,
+                       event_lasttime);
 
     if (self->focus_notify) {
 	XEvent ce;
@@ -1872,12 +1965,47 @@ gboolean client_focus(Client *self)
 	XSendEvent(ob_display, self->window, FALSE, NoEventMask, &ce);
     }
 
-    /*XSync(ob_display, FALSE); XXX Why sync? */
+    g_message("focusing %lx", self->window);
+
+    /* Cause the FocusIn to come back to us. Important for desktop switches,
+       since otherwise we'll have no FocusIn on the queue and send it off to
+       the focus_backup. */
+    XSync(ob_display, FALSE);
     return TRUE;
 }
 
 void client_unfocus(Client *self)
 {
     g_assert(focus_client == self);
-    focus_set_client(NULL);
+    focus_fallback(FALSE);
+}
+
+gboolean client_focused(Client *self)
+{
+    return self == focus_client;
+}
+
+Icon *client_icon(Client *self, int w, int h)
+{
+    int i;
+    /* si is the smallest image >= req */
+    /* li is the largest image < req */
+    unsigned long size, smallest = 0xffffffff, largest = 0, si = 0, li = 0;
+
+    if (!self->nicons) return NULL;
+
+    for (i = 0; i < self->nicons; ++i) {
+        size = self->icons[i].width * self->icons[i].height;
+        if (size < smallest && size >= (unsigned)(w * h)) {
+            smallest = size;
+            si = i;
+        }
+        if (size > largest && size <= (unsigned)(w * h)) {
+            largest = size;
+            li = i;
+        }
+    }
+    if (largest == 0) /* didnt find one smaller than the requested size */
+        return &self->icons[si];
+    return &self->icons[li];
 }