X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fclient.c;h=3249fd57e8efa9808484e012732d3aa5e6cac403;hb=276b2be581c6cb138b439537761ff2ca42201805;hp=0f2519cff751e82a36324c57f76995e167e7011a;hpb=365a9fbb69f599990dae1d5e1458dbe58beff161;p=chaz%2Fopenbox

diff --git a/openbox/client.c b/openbox/client.c
index 0f2519cf..3249fd57 100644
--- a/openbox/client.c
+++ b/openbox/client.c
@@ -1,5 +1,6 @@
 #include "client.h"
 #include "dock.h"
+#include "xerror.h"
 #include "startup.h"
 #include "screen.h"
 #include "moveresize.h"
@@ -253,18 +254,19 @@ void client_manage(Window window)
     focus_order_add_new(self);
 
     /* focus the new window? */
-    if (ob_state != State_Starting && config_focus_new &&
+    if (ob_state != OB_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)
+            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
@@ -286,12 +288,12 @@ void client_manage(Window window)
         stacking_add(CLIENT_AS_WINDOW(self));
     }
 
-    screen_update_struts();
+    dispatch_client(Event_Client_New, self, 0, 0);
 
     /* make sure the window is visible */
     client_move_onscreen(self);
 
-    dispatch_client(Event_Client_New, self, 0, 0);
+    screen_update_areas();
 
     client_showhide(self);
 
@@ -345,7 +347,7 @@ void client_unmanage(Client *self)
 
     /* once the client is out of the list, update the struts to remove it's
        influence */
-    screen_update_struts();
+    screen_update_areas();
 
     /* tell our parent(s) that we're gone */
     if (self->transient_for == TRAN_GROUP) { /* transient of group */
@@ -401,7 +403,7 @@ void client_unmanage(Client *self)
     frame_release_client(self->frame, self);
     self->frame = NULL;
      
-    if (ob_state != State_Exiting) {
+    if (ob_state != OB_STATE_EXITING) {
 	/* these values should not be persisted across a window
 	   unmapping/mapping */
 	prop_erase(self->window, prop_atoms.net_wm_desktop);
@@ -438,6 +440,7 @@ void client_move_onscreen(Client *self)
     Rect *a;
     int x = self->frame->area.x, y = self->frame->area.y;
 
+    /* XXX watch for xinerama dead areas */
     a = screen_area(self->desktop);
     if (x >= a->x + a->width - 1)
         x = a->x + a->width - self->frame->area.width;
@@ -450,7 +453,7 @@ void client_move_onscreen(Client *self)
 
     frame_frame_gravity(self->frame, &x, &y); /* get where the client
                                                  should be */
-    client_configure(self , Corner_TopLeft, x, y,
+    client_configure(self, OB_CORNER_TOPLEFT, x, y,
                      self->area.width, self->area.height,
                      TRUE, TRUE);
 }
@@ -585,13 +588,14 @@ static void client_get_area(Client *self)
 
 static void client_get_desktop(Client *self)
 {
-    guint32 d;
+    guint32 d = screen_num_desktops; /* an always-invalid value */
 
     if (PROP_GET32(self->window, net_wm_desktop, cardinal, &d)) {
 	if (d >= screen_num_desktops && d != DESKTOP_ALL)
-	    d = screen_num_desktops - 1;
-	self->desktop = d;
-    } else { 
+	    self->desktop = screen_num_desktops - 1;
+        else
+            self->desktop = d;
+    } else {
         gboolean trdesk = FALSE;
 
        if (self->transient_for) {
@@ -614,6 +618,8 @@ static void client_get_desktop(Client *self)
            /* defaults to the current desktop */
            self->desktop = screen_desktop;
 
+    }
+    if (self->desktop != d) {
         /* set the desktop hint, to make sure that it always exists */
         PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
     }
@@ -1025,11 +1031,8 @@ void client_setup_decor_and_functions(Client *self)
         if (self->type == Type_Desktop && self->desktop != DESKTOP_ALL)
             client_set_desktop(self, DESKTOP_ALL, FALSE);
 
-	/* 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);
+	/* 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)
@@ -1087,19 +1090,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, OB_CORNER_TOPLEFT, self->area.x, self->area.y,
+                     self->area.width, self->area.height, FALSE, TRUE);
 }
 
 void client_update_wmhints(Client *self)
@@ -1117,7 +1114,7 @@ void client_update_wmhints(Client *self)
 
 	/* only do this when first managing the window *AND* when we aren't
            starting up! */
-	if (ob_state != State_Starting && self->frame == NULL)
+	if (ob_state != OB_STATE_STARTING && self->frame == NULL)
             if (hints->flags & StateHint)
                 self->iconic = hints->initial_state == IconicState;
 
@@ -1139,18 +1136,20 @@ void client_update_wmhints(Client *self)
                 group_remove(self->group, self);
                 self->group = NULL;
             }
-            /* i can only have transients from the group if i am not transient
-               myself */
-            if (hints->window_group != None && !self->transient_for) {
+            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 */
@@ -1299,7 +1298,7 @@ void client_update_strut(Client *self)
     /* updating here is pointless while we're being mapped cuz we're not in
        the client list yet */
     if (self->frame)
-	screen_update_struts();
+	screen_update_areas();
 }
 
 void client_update_icons(Client *self)
@@ -1322,7 +1321,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;
 	}
 
@@ -1336,17 +1335,19 @@ void client_update_icons(Client *self)
 	    w = self->icons[j].width = data[i++];
 	    h = self->icons[j].height = data[i++];
 
-	    self->icons[j].data = g_new(pixel32, 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) << default_alpha_offset) +
-                    (((data[i] >> 16) & 0xff) << default_red_offset) +
-                    (((data[i] >> 8) & 0xff) << default_green_offset) +
-                    (((data[i] >> 0) & 0xff) << default_blue_offset);
+                    (((data[i] >> 24) & 0xff) << RrDefaultAlphaOffset) +
+                    (((data[i] >> 16) & 0xff) << RrDefaultRedOffset) +
+                    (((data[i] >> 8) & 0xff) << RrDefaultGreenOffset) +
+                    (((data[i] >> 0) & 0xff) << RrDefaultBlueOffset);
             }
 	    g_assert(i <= num);
 	}
@@ -1357,13 +1358,16 @@ void client_update_icons(Client *self)
         if (num == 2) {
             self->nicons++;
             self->icons = g_new(Icon, self->nicons);
-            if (!render_pixmap_to_rgba(data[0], data[1],
-                                       &self->icons[self->nicons-1].width,
-                                       &self->icons[self->nicons-1].height,
-                                       &self->icons[self->nicons-1].data)) {
+            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 {
@@ -1373,15 +1377,18 @@ void client_update_icons(Client *self)
             if (hints->flags & IconPixmapHint) {
                 self->nicons++;
                 self->icons = g_new(Icon, self->nicons);
-                if (!render_pixmap_to_rgba(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)){
+                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);
         }
@@ -1487,8 +1494,8 @@ static StackLayer calc_layer(Client *self)
     return l;
 }
 
-static void calc_recursive(Client *self, Client *orig, StackLayer l,
-                           gboolean raised)
+static void client_calc_layer_recursive(Client *self, Client *orig,
+                                        StackLayer l, gboolean raised)
 {
     StackLayer old, own;
     GSList *it;
@@ -1498,11 +1505,15 @@ static void calc_recursive(Client *self, Client *orig, StackLayer l,
     self->layer = l > own ? l : own;
 
     for (it = self->transients; it; it = it->next)
-        calc_recursive(it->data, orig, l, raised ? raised : l != old);
+        client_calc_layer_recursive(it->data, orig,
+                                    l, raised ? raised : l != old);
 
     if (!raised && l != old)
-	if (orig->frame) /* only restack if the original window is managed */
-	    stacking_raise(CLIENT_AS_WINDOW(self));
+	if (orig->frame) { /* only restack if the original window is managed */
+            /* XXX add_non_intrusive ever? */
+            stacking_remove(CLIENT_AS_WINDOW(self));
+            stacking_add(CLIENT_AS_WINDOW(self));
+        }
 }
 
 void client_calc_layer(Client *self)
@@ -1513,24 +1524,11 @@ void client_calc_layer(Client *self)
     orig = self;
 
     /* transients take on the layer of their parents */
-    if (self->transient_for) {
-        if (self->transient_for != TRAN_GROUP) {
-            self = self->transient_for;
-        } else {
-            GSList *it;
-
-            for (it = self->group->members; it; it = it->next)
-                if (it->data != self &&
-                    !((Client*)it->data)->transient_for) {
-                    self = it->data;
-                    break;
-                }
-        }
-    }
+    self = client_search_top_transient(self);
 
     l = calc_layer(self);
 
-    calc_recursive(self, orig, l, FALSE);
+    client_calc_layer_recursive(self, orig, l, FALSE);
 }
 
 gboolean client_should_show(Client *self)
@@ -1596,7 +1594,8 @@ static void client_apply_startup_state(Client *self)
     */
 }
 
-void client_configure(Client *self, Corner anchor, int x, int y, int w, int h,
+void client_configure(Client *self, ObCorner anchor,
+                      int x, int y, int w, int h,
 		      gboolean user, gboolean final)
 {
     gboolean moved = FALSE, resized = FALSE;
@@ -1608,21 +1607,50 @@ 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;
+#endif
+        Rect *a;
+        guint i;
+
+        i = client_monitor(self);
+        a = screen_physical_area_monitor(i);
+
+#ifdef VIDMODE
+        if (i == 0 && /* primary head */
+            extensions_vidmode &&
+            XF86VidModeGetViewPort(ob_display, ob_screen, &x, &y) &&
+            /* get the mode last so the mode.privsize isnt freed incorrectly */
+            XF86VidModeGetModeLine(ob_display, ob_screen, &dot, &mode)) {
+            x += a->x;
+            y += a->y;
+            w = mode.hdisplay;
+            h = mode.vdisplay;
+            if (mode.privsize) XFree(mode.private);
+        } else
+#endif
+        {
+            x = a->x;
+            y = a->y;
+            w = a->width;
+            h = a->height;
+        }
+
         user = FALSE; /* ignore that increment etc shit when in fullscreen */
     } else {
+        Rect *a;
+
+        a = screen_area_monitor(self->desktop, client_monitor(self));
+
         /* 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)->width;
+            x = a->x - self->frame->size.left;
+            w = a->width;
         }
         if (self->max_vert) {
-            y = screen_area(self->desktop)->y;
-            h = screen_area(self->desktop)->height -
-                self->frame->size.top - self->frame->size.bottom;
+            y = a->y;
+            h = a->height - self->frame->size.top - self->frame->size.bottom;
         }
     }
 
@@ -1642,16 +1670,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;
@@ -1664,21 +1708,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;
@@ -1693,20 +1734,35 @@ 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) {
-    case Corner_TopLeft:
+    case OB_CORNER_TOPLEFT:
 	break;
-    case Corner_TopRight:
+    case OB_CORNER_TOPRIGHT:
 	x -= w - self->area.width;
 	break;
-    case Corner_BottomLeft:
+    case OB_CORNER_BOTTOMLEFT:
 	y -= h - self->area.height;
 	break;
-    case Corner_BottomRight:
+    case OB_CORNER_BOTTOMRIGHT:
 	x -= w - self->area.width;
 	y -= h - self->area.height;
 	break;
@@ -1717,15 +1773,26 @@ 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;
@@ -1776,14 +1843,14 @@ void client_fullscreen(Client *self, gboolean fs, gboolean savearea)
     } else {
         guint num;
 	gint32 *dimensions;
+        Rect *a;
 
         /* pick some fallbacks... */
-        x = screen_area(self->desktop)->x +
-            screen_area(self->desktop)->width / 4;
-        y = screen_area(self->desktop)->y +
-            screen_area(self->desktop)->height / 4;
-        w = screen_area(self->desktop)->width / 2;
-        h = screen_area(self->desktop)->height / 2;
+        a = screen_area_monitor(self->desktop, 0);
+        x = a->x + a->width / 4;
+        y = a->y + a->height / 4;
+        w = a->width / 2;
+        h = a->height / 2;
 
 	if (PROP_GETA32(self->window, openbox_premax, cardinal,
                         (guint32**)&dimensions, &num)) {
@@ -1799,75 +1866,82 @@ void client_fullscreen(Client *self, gboolean fs, gboolean savearea)
 
     client_setup_decor_and_functions(self);
 
-    client_configure(self, Corner_TopLeft, x, y, w, h, TRUE, TRUE);
+    client_configure(self, OB_CORNER_TOPLEFT, x, y, w, h, TRUE, TRUE);
 
     /* try focus us when we go into fullscreen mode */
     client_focus(self);
 }
 
-void client_iconify(Client *self, gboolean iconic, gboolean curdesk)
+static void client_iconify_recursive(Client *self,
+                                     gboolean iconic, gboolean curdesk)
 {
     GSList *it;
+    gboolean changed = FALSE;
 
-    /* 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;
 
-            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) return;
-        }
-    }
+    if (self->iconic != iconic) {
+        g_message("%sconifying window: 0x%lx", (iconic ? "I" : "Uni"),
+                  self->window);
 
-    if (self->iconic == iconic) return; /* nothing to do */
+        self->iconic = iconic;
 
-    g_message("%sconifying window: 0x%lx", (iconic ? "I" : "Uni"),
-	      self->window);
+        if (iconic) {
+            if (self->functions & Func_Iconify) {
+                self->wmstate = IconicState;
+                self->ignore_unmaps++;
+                /* we unmap the client itself so that we can get MapRequest
+                   events, and because the ICCCM tells us to! */
+                XUnmapWindow(ob_display, self->window);
 
-    self->iconic = iconic;
+                /* 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);
 
-    if (iconic) {
-	self->wmstate = IconicState;
-	self->ignore_unmaps++;
-	/* we unmap the client itself so that we can get MapRequest events,
-	   and because the ICCCM tells us to! */
-	XUnmapWindow(ob_display, self->window);
+                changed = TRUE;
+            }
+        } 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);
+
+            changed = TRUE;
+        }
+    }
 
-        /* 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);
+    if (changed) {
+        client_change_state(self);
+        client_showhide(self);
+        screen_update_areas();
 
-        /* this puts it after the current focused window */
-        focus_order_remove(self);
-        focus_order_add_new(self);
+        dispatch_client(iconic ? Event_Client_Unmapped : Event_Client_Mapped,
+                        self, 0, 0);
     }
-    client_change_state(self);
-    client_showhide(self);
-    screen_update_struts();
-
-    dispatch_client(iconic ? Event_Client_Unmapped : Event_Client_Mapped,
-                    self, 0, 0);
 
     /* iconify all transients */
     for (it = self->transients; it != NULL; it = it->next)
-        if (it->data != self) client_iconify(it->data, iconic, curdesk);
+        if (it->data != self) client_iconify_recursive(it->data,
+                                                       iconic, curdesk);
+}
+
+void client_iconify(Client *self, gboolean iconic, gboolean curdesk)
+{
+    /* move up the transient chain as far as possible first */
+    self = client_search_top_transient(self);
+
+    client_iconify_recursive(client_search_top_transient(self),
+                             iconic, curdesk);
 }
 
 void client_maximize(Client *self, gboolean max, int dir, gboolean savearea)
@@ -1928,17 +2002,17 @@ void client_maximize(Client *self, gboolean max, int dir, gboolean savearea)
     } else {
         guint num;
 	gint32 *dimensions;
+        Rect *a;
 
         /* pick some fallbacks... */
+        a = screen_area_monitor(self->desktop, 0);
         if (dir == 0 || dir == 1) { /* horz */
-            x = screen_area(self->desktop)->x +
-                screen_area(self->desktop)->width / 4;
-            w = screen_area(self->desktop)->width / 2;
+            x = a->x + a->width / 4;
+            w = a->width / 2;
         }
         if (dir == 0 || dir == 2) { /* vert */
-            y = screen_area(self->desktop)->y +
-                screen_area(self->desktop)->height / 4;
-            h = screen_area(self->desktop)->height / 2;
+            y = a->y + a->height / 4;
+            h = a->height / 2;
         }
 
 	if (PROP_GETA32(self->window, openbox_premax, cardinal,
@@ -1969,7 +2043,7 @@ void client_maximize(Client *self, gboolean max, int dir, gboolean savearea)
 
     /* figure out where the client should be going */
     frame_frame_gravity(self->frame, &x, &y);
-    client_configure(self, Corner_TopLeft, x, y, w, h, TRUE, TRUE);
+    client_configure(self, OB_CORNER_TOPLEFT, x, y, w, h, TRUE, TRUE);
 }
 
 void client_shade(Client *self, gboolean shade)
@@ -2018,39 +2092,53 @@ void client_kill(Client *self)
     XKillClient(ob_display, self->window);
 }
 
-void client_set_desktop(Client *self, guint target, gboolean donthide)
+void client_set_desktop_recursive(Client *self,
+                                  guint target, gboolean donthide)
 {
     guint old;
+    GSList *it;
 
-    if (target == self->desktop) return;
-  
-    g_message("Setting desktop %u", target+1);
+    if (target != self->desktop) {
 
-    g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
+        g_message("Setting desktop %u", target+1);
 
-    /* remove from the old desktop(s) */
-    focus_order_remove(self);
+        g_assert(target < screen_num_desktops || target == DESKTOP_ALL);
 
-    old = self->desktop;
-    self->desktop = target;
-    PROP_SET32(self->window, net_wm_desktop, cardinal, target);
-    /* the frame can display the current desktop state */
-    frame_adjust_state(self->frame);
-    /* 'move' the window to the new desktop */
-    if (!donthide)
-        client_showhide(self);
-    /* raise if it was not already on the desktop */
-    if (old != DESKTOP_ALL)
-        stacking_raise(CLIENT_AS_WINDOW(self));
-    screen_update_struts();
-
-    /* add to the new desktop(s) */
-    if (config_focus_new)
-        focus_order_to_top(self);
-    else
-        focus_order_to_bottom(self);
+        /* remove from the old desktop(s) */
+        focus_order_remove(self);
 
-    dispatch_client(Event_Client_Desktop, self, target, old);
+        old = self->desktop;
+        self->desktop = target;
+        PROP_SET32(self->window, net_wm_desktop, cardinal, target);
+        /* the frame can display the current desktop state */
+        frame_adjust_state(self->frame);
+        /* 'move' the window to the new desktop */
+        if (!donthide)
+            client_showhide(self);
+        /* raise if it was not already on the desktop */
+        if (old != DESKTOP_ALL)
+            stacking_raise(CLIENT_AS_WINDOW(self));
+        screen_update_areas();
+
+        /* 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);
+    }
+
+    /* move all transients */
+    for (it = self->transients; it != NULL; it = it->next)
+        if (it->data != self) client_set_desktop_recursive(it->data,
+                                                           target, donthide);
+}
+
+void client_set_desktop(Client *self, guint target, gboolean donthide)
+{
+    client_set_desktop_recursive(client_search_top_transient(self),
+                                 target, donthide);
 }
 
 Client *client_search_modal_child(Client *self)
@@ -2229,18 +2317,15 @@ Client *client_focus_target(Client *self)
     return self;
 }
 
-gboolean client_focus(Client *self)
+gboolean client_can_focus(Client *self)
 {
     XEvent ev;
 
     /* choose the correct target */
     self = client_focus_target(self);
 
-    if (!self->frame->visible) {
-        /* update the focus lists */
-        focus_order_to_top(self);
+    if (!self->frame->visible)
         return FALSE;
-    }
 
     if (!((self->can_focus || self->focus_notify) &&
           (self->desktop == screen_desktop ||
@@ -2266,6 +2351,22 @@ 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 RevertToNone, so
            I choose to use it always, hopefully to find errors quicker, if any
@@ -2357,7 +2458,7 @@ Icon *client_icon(Client *self, int w, int h)
 }
 
 /* this be mostly ripped from fvwm */
-Client *client_find_directional(Client *c, Direction dir) 
+Client *client_find_directional(Client *c, ObDirection dir) 
 {
     int my_cx, my_cy, his_cx, his_cy;
     int offset = 0;
@@ -2412,21 +2513,23 @@ Client *client_find_directional(Client *c, Direction dir)
         }
 
         switch(dir) {
-        case Direction_North :
-        case Direction_South :
-        case Direction_NorthEast :
-        case Direction_SouthWest :
+        case OB_DIRECTION_NORTH:
+        case OB_DIRECTION_SOUTH:
+        case OB_DIRECTION_NORTHEAST:
+        case OB_DIRECTION_SOUTHWEST:
             offset = (his_cx < 0) ? -his_cx : his_cx;
-            distance = (dir == Direction_North || dir == Direction_NorthEast) ?
-                -his_cy : his_cy;
+            distance = ((dir == OB_DIRECTION_NORTH ||
+                        dir == OB_DIRECTION_NORTHEAST) ?
+                        -his_cy : his_cy);
             break;
-        case Direction_East :
-        case Direction_West :
-        case Direction_SouthEast :
-        case Direction_NorthWest :
+        case OB_DIRECTION_EAST:
+        case OB_DIRECTION_WEST:
+        case OB_DIRECTION_SOUTHEAST:
+        case OB_DIRECTION_NORTHWEST:
             offset = (his_cy < 0) ? -his_cy : his_cy;
-            distance = (dir == Direction_West || dir == Direction_NorthWest) ?
-                -his_cx : his_cx;
+            distance = ((dir == OB_DIRECTION_WEST ||
+                        dir == OB_DIRECTION_NORTHWEST) ?
+                        -his_cx : his_cx);
             break;
         }
 
@@ -2465,3 +2568,41 @@ void client_set_layer(Client *self, int layer)
     client_calc_layer(self);
     client_change_state(self); /* reflect this in the state hints */
 }
+
+guint client_monitor(Client *self)
+{
+    guint i;
+
+    for (i = 0; i < screen_num_monitors; ++i) {
+        Rect *area = screen_physical_area_monitor(i);
+        if (RECT_INTERSECTS_RECT(*area, self->frame->area))
+            break;
+    }
+    if (i == screen_num_monitors) i = 0;
+    g_assert(i < screen_num_monitors);
+    return i;
+}
+
+Client *client_search_top_transient(Client *self)
+{
+    /* move up the transient chain as far as possible */
+    if (self->transient_for) {
+        if (self->transient_for != TRAN_GROUP) {
+            return client_search_top_transient(self->transient_for);
+        } else {
+            GSList *it;
+
+            for (it = self->group->members; it; it = it->next) {
+                Client *c = it->data;
+
+                /* checking transient_for prevents infinate loops! */
+                if (c != self && !c->transient_for)
+                    break;
+            }
+            if (it)
+                return it->data;
+        }
+    }
+
+    return self;
+}