Merge branch 'master' into chaz

[chaz/openbox] / openbox / frame.c

diff --git a/openbox/frame.c b/openbox/frame.c
index 50f0dc61cda6a8465f2c7687d3186996016d60a7..0f2d56ebaf7ce37c6e55c445444f7328afe94ced 100644 (file)
--- a/openbox/frame.c
+++ b/openbox/frame.c
@@ -20,44 +20,30 @@
 #include "frame.h"
 #include "client.h"
 #include "openbox.h"
 #include "frame.h"
 #include "client.h"
 #include "openbox.h"

-#include "extensions.h"
-#include "prop.h"
+#include "grab.h"
+#include "debug.h"

 #include "config.h"
 #include "framerender.h"
 #include "config.h"
 #include "framerender.h"

-#include "mainloop.h"
-#include "focus.h"
+#include "focus_cycle.h"
+#include "focus_cycle_indicator.h"

 #include "moveresize.h"
 #include "screen.h"
 #include "moveresize.h"
 #include "screen.h"

-#include "render/theme.h"
+#include "obrender/theme.h"
+#include "obt/display.h"
+#include "obt/xqueue.h"
+#include "obt/prop.h"

 
 

-#define PLATE_EVENTMASK (SubstructureRedirectMask | FocusChangeMask)

 #define FRAME_EVENTMASK (EnterWindowMask | LeaveWindowMask | \
 #define FRAME_EVENTMASK (EnterWindowMask | LeaveWindowMask | \

-                         ButtonPressMask | ButtonReleaseMask)
+                         ButtonPressMask | ButtonReleaseMask | \
+                         SubstructureRedirectMask | FocusChangeMask)

 #define ELEMENT_EVENTMASK (ButtonPressMask | ButtonReleaseMask | \
 #define ELEMENT_EVENTMASK (ButtonPressMask | ButtonReleaseMask | \

-                           ButtonMotionMask | \
+                           ButtonMotionMask | PointerMotionMask | \

                            EnterWindowMask | LeaveWindowMask)
                            EnterWindowMask | LeaveWindowMask)

-/* The inner window does not need enter/leave events.
-   If it does get them, then it needs its own context for enter events
-   because sloppy focus will focus the window when you enter the inner window
-   from the frame. */
-#define INNER_EVENTMASK (ButtonPressMask)

 
 #define FRAME_ANIMATE_ICONIFY_TIME 150000 /* .15 seconds */
 
 #define FRAME_ANIMATE_ICONIFY_TIME 150000 /* .15 seconds */

-#define FRAME_ANIMATE_ICONIFY_STEP_TIME (G_USEC_PER_SEC / 60) /* 60 Hz */
-
-#define FRAME_HANDLE_Y(f) (f->innersize.top + f->client->area.height + \
-                           f->cbwidth_y)
-
-/* the offsets for the titlebar elements from the edge of the titlebar.
-   negative means from the right edge. */
-gint icon_off;
-gint label_off;
-gint iconify_off;
-gint desk_off;
-gint shade_off;
-gint max_off;
-gint close_off;
+#define FRAME_ANIMATE_ICONIFY_STEP_TIME (1000 / 60) /* 60 Hz */

 
 

+#define FRAME_HANDLE_Y(f) (f->size.top + f->client->area.height + f->cbwidth_b)

 
 static void flash_done(gpointer data);
 static gboolean flash_timeout(gpointer data);
 
 static void flash_done(gpointer data);
 static gboolean flash_timeout(gpointer data);


@@ -66,15 +52,16 @@ static void layout_title(ObFrame *self);
 static void set_theme_statics(ObFrame *self);
 static void free_theme_statics(ObFrame *self);
 static gboolean frame_animate_iconify(gpointer self);
 static void set_theme_statics(ObFrame *self);
 static void free_theme_statics(ObFrame *self);
 static gboolean frame_animate_iconify(gpointer self);

+static void frame_adjust_cursors(ObFrame *self);

 
 static Window createWindow(Window parent, Visual *visual,
                            gulong mask, XSetWindowAttributes *attrib)
 {
 
 static Window createWindow(Window parent, Visual *visual,
                            gulong mask, XSetWindowAttributes *attrib)
 {

-    return XCreateWindow(ob_display, parent, 0, 0, 1, 1, 0,
+    return XCreateWindow(obt_display, parent, 0, 0, 1, 1, 0,

                          (visual ? 32 : RrDepth(ob_rr_inst)), InputOutput,
                          (visual ? visual : RrVisual(ob_rr_inst)),
                          mask, attrib);
                          (visual ? 32 : RrDepth(ob_rr_inst)), InputOutput,
                          (visual ? visual : RrVisual(ob_rr_inst)),
                          mask, attrib);

-                       
+

 }
 
 static Visual *check_32bit_client(ObClient *c)
 }
 
 static Visual *check_32bit_client(ObClient *c)


@@ -82,7 +69,12 @@ static Visual *check_32bit_client(ObClient *c)
     XWindowAttributes wattrib;
     Status ret;
 
     XWindowAttributes wattrib;
     Status ret;
 

-    ret = XGetWindowAttributes(ob_display, c->window, &wattrib);
+    /* we're already running at 32 bit depth, yay. we don't need to use their
+       visual */
+    if (RrDepth(ob_rr_inst) == 32)
+        return NULL;
+
+    ret = XGetWindowAttributes(obt_display, c->window, &wattrib);

     g_assert(ret != BadDrawable);
     g_assert(ret != BadWindow);
 
     g_assert(ret != BadDrawable);
     g_assert(ret != BadWindow);
 


@@ -98,55 +90,68 @@ ObFrame *frame_new(ObClient *client)
     ObFrame *self;
     Visual *visual;
 
     ObFrame *self;
     Visual *visual;
 

-    self = g_new0(ObFrame, 1);
+    self = g_slice_new0(ObFrame);

     self->client = client;
 
     visual = check_32bit_client(client);
 
     /* create the non-visible decor windows */
 
     self->client = client;
 
     visual = check_32bit_client(client);
 
     /* create the non-visible decor windows */
 

-    mask = CWEventMask;
+    mask = 0;

     if (visual) {
         /* client has a 32-bit visual */
     if (visual) {
         /* client has a 32-bit visual */

-        mask |= CWColormap | CWBackPixel | CWBorderPixel;
+        mask = CWColormap | CWBackPixel | CWBorderPixel;

         /* create a colormap with the visual */
         self->colormap = attrib.colormap =
         /* create a colormap with the visual */
         self->colormap = attrib.colormap =

-            XCreateColormap(ob_display,
-                            RootWindow(ob_display, ob_screen),
+            XCreateColormap(obt_display, obt_root(ob_screen),

                             visual, AllocNone);
                             visual, AllocNone);

-        attrib.background_pixel = BlackPixel(ob_display, 0);
-        attrib.border_pixel = BlackPixel(ob_display, 0);
+        attrib.background_pixel = BlackPixel(obt_display, ob_screen);
+        attrib.border_pixel = BlackPixel(obt_display, ob_screen);

     }
     }

-    attrib.event_mask = FRAME_EVENTMASK;
-    self->window = createWindow(RootWindow(ob_display, ob_screen), visual,
+    self->window = createWindow(obt_root(ob_screen), visual,

                                 mask, &attrib);
 
                                 mask, &attrib);
 

-    attrib.event_mask = INNER_EVENTMASK;
-    self->inner = createWindow(self->window, visual, mask, &attrib);
-
-    mask &= ~CWEventMask;
-    self->plate = createWindow(self->inner, visual, mask, &attrib);
-

     /* create the visible decor windows */
 
     /* create the visible decor windows */
 

-    mask = CWEventMask;
+    mask = 0;

     if (visual) {
         /* client has a 32-bit visual */
     if (visual) {
         /* client has a 32-bit visual */

-        mask |= CWColormap | CWBackPixel | CWBorderPixel;
+        mask = CWColormap | CWBackPixel | CWBorderPixel;

         attrib.colormap = RrColormap(ob_rr_inst);
     }
         attrib.colormap = RrColormap(ob_rr_inst);
     }

+
+    self->backback = createWindow(self->window, NULL, mask, &attrib);
+    self->backfront = createWindow(self->backback, NULL, mask, &attrib);
+
+    mask |= CWEventMask;

     attrib.event_mask = ELEMENT_EVENTMASK;
     attrib.event_mask = ELEMENT_EVENTMASK;

-    self->title = createWindow(self->window, NULL, mask, &attrib);
+    self->innerleft = createWindow(self->window, NULL, mask, &attrib);
+    self->innertop = createWindow(self->window, NULL, mask, &attrib);
+    self->innerright = createWindow(self->window, NULL, mask, &attrib);
+    self->innerbottom = createWindow(self->window, NULL, mask, &attrib);

 
 

-    mask |= CWCursor;
-    attrib.cursor = ob_cursor(OB_CURSOR_NORTHWEST);
+    self->innerblb = createWindow(self->innerbottom, NULL, mask, &attrib);
+    self->innerbrb = createWindow(self->innerbottom, NULL, mask, &attrib);
+    self->innerbll = createWindow(self->innerleft, NULL, mask, &attrib);
+    self->innerbrr = createWindow(self->innerright, NULL, mask, &attrib);
+
+    self->title = createWindow(self->window, NULL, mask, &attrib);
+    self->titleleft = createWindow(self->window, NULL, mask, &attrib);
+    self->titletop = createWindow(self->window, NULL, mask, &attrib);
+    self->titletopleft = createWindow(self->window, NULL, mask, &attrib);
+    self->titletopright = createWindow(self->window, NULL, mask, &attrib);
+    self->titleright = createWindow(self->window, NULL, mask, &attrib);
+    self->titlebottom = createWindow(self->window, NULL, mask, &attrib);
+
+    self->topresize = createWindow(self->title, NULL, mask, &attrib);

     self->tltresize = createWindow(self->title, NULL, mask, &attrib);
     self->tllresize = createWindow(self->title, NULL, mask, &attrib);
     self->tltresize = createWindow(self->title, NULL, mask, &attrib);
     self->tllresize = createWindow(self->title, NULL, mask, &attrib);

-    attrib.cursor = ob_cursor(OB_CURSOR_NORTHEAST);

     self->trtresize = createWindow(self->title, NULL, mask, &attrib);
     self->trrresize = createWindow(self->title, NULL, mask, &attrib);
 
     self->trtresize = createWindow(self->title, NULL, mask, &attrib);
     self->trrresize = createWindow(self->title, NULL, mask, &attrib);
 

-    mask &= ~CWCursor;
+    self->left = createWindow(self->window, NULL, mask, &attrib);
+    self->right = createWindow(self->window, NULL, mask, &attrib);
+

     self->label = createWindow(self->title, NULL, mask, &attrib);
     self->max = createWindow(self->title, NULL, mask, &attrib);
     self->close = createWindow(self->title, NULL, mask, &attrib);
     self->label = createWindow(self->title, NULL, mask, &attrib);
     self->max = createWindow(self->title, NULL, mask, &attrib);
     self->close = createWindow(self->title, NULL, mask, &attrib);


@@ -154,115 +159,96 @@ ObFrame *frame_new(ObClient *client)
     self->shade = createWindow(self->title, NULL, mask, &attrib);
     self->icon = createWindow(self->title, NULL, mask, &attrib);
     self->iconify = createWindow(self->title, NULL, mask, &attrib);
     self->shade = createWindow(self->title, NULL, mask, &attrib);
     self->icon = createWindow(self->title, NULL, mask, &attrib);
     self->iconify = createWindow(self->title, NULL, mask, &attrib);

-    self->handle = createWindow(self->window, NULL, mask, &attrib);

 
 

-    mask |= CWCursor;
-    attrib.cursor = ob_cursor(OB_CURSOR_SOUTHWEST);
+    self->handle = createWindow(self->window, NULL, mask, &attrib);

     self->lgrip = createWindow(self->handle, NULL, mask, &attrib);
     self->lgrip = createWindow(self->handle, NULL, mask, &attrib);

-    attrib.cursor = ob_cursor(OB_CURSOR_SOUTHEAST);
-    self->rgrip = createWindow(self->handle, NULL, mask, &attrib); 
+    self->rgrip = createWindow(self->handle, NULL, mask, &attrib);
+
+    self->handleleft = createWindow(self->handle, NULL, mask, &attrib);
+    self->handleright = createWindow(self->handle, NULL, mask, &attrib);
+
+    self->handletop = createWindow(self->window, NULL, mask, &attrib);
+    self->handlebottom = createWindow(self->window, NULL, mask, &attrib);
+    self->lgripleft = createWindow(self->window, NULL, mask, &attrib);
+    self->lgriptop = createWindow(self->window, NULL, mask, &attrib);
+    self->lgripbottom = createWindow(self->window, NULL, mask, &attrib);
+    self->rgripright = createWindow(self->window, NULL, mask, &attrib);
+    self->rgriptop = createWindow(self->window, NULL, mask, &attrib);
+    self->rgripbottom = createWindow(self->window, NULL, mask, &attrib);

 
     self->focused = FALSE;
 
     /* the other stuff is shown based on decor settings */
 
     self->focused = FALSE;
 
     /* the other stuff is shown based on decor settings */

-    XMapWindow(ob_display, self->plate);
-    XMapWindow(ob_display, self->inner);
-    XMapWindow(ob_display, self->lgrip);
-    XMapWindow(ob_display, self->rgrip);
-    XMapWindow(ob_display, self->label);
+    XMapWindow(obt_display, self->label);
+    XMapWindow(obt_display, self->backback);
+    XMapWindow(obt_display, self->backfront);

 
 

-    self->max_press = self->close_press = self->desk_press = 
+    self->max_press = self->close_press = self->desk_press =

         self->iconify_press = self->shade_press = FALSE;
         self->iconify_press = self->shade_press = FALSE;

-    self->max_hover = self->close_hover = self->desk_hover = 
+    self->max_hover = self->close_hover = self->desk_hover =

         self->iconify_hover = self->shade_hover = FALSE;
 
         self->iconify_hover = self->shade_hover = FALSE;
 

+    /* make sure the size will be different the first time, so the extent hints
+       will be set */
+    STRUT_SET(self->oldsize, -1, -1, -1, -1);
+

     set_theme_statics(self);
 
     set_theme_statics(self);
 

-    return (ObFrame*)self;
+    return self;

 }
 
 static void set_theme_statics(ObFrame *self)
 {
     /* set colors/appearance/sizes for stuff that doesn't change */
 }
 
 static void set_theme_statics(ObFrame *self)
 {
     /* set colors/appearance/sizes for stuff that doesn't change */

-    XSetWindowBorder(ob_display, self->window,
-                     RrColorPixel(ob_rr_theme->frame_b_color));
-    XSetWindowBorder(ob_display, self->inner,
-                     RrColorPixel(ob_rr_theme->frame_b_color));
-    XSetWindowBorder(ob_display, self->title,
-                     RrColorPixel(ob_rr_theme->frame_b_color));
-    XSetWindowBorder(ob_display, self->handle,
-                     RrColorPixel(ob_rr_theme->frame_b_color));
-    XSetWindowBorder(ob_display, self->rgrip,
-                     RrColorPixel(ob_rr_theme->frame_b_color));
-    XSetWindowBorder(ob_display, self->lgrip,
-                     RrColorPixel(ob_rr_theme->frame_b_color));
-
-    XResizeWindow(ob_display, self->max,
+    XResizeWindow(obt_display, self->max,

                   ob_rr_theme->button_size, ob_rr_theme->button_size);
                   ob_rr_theme->button_size, ob_rr_theme->button_size);

-    XResizeWindow(ob_display, self->iconify,
+    XResizeWindow(obt_display, self->iconify,

                   ob_rr_theme->button_size, ob_rr_theme->button_size);
                   ob_rr_theme->button_size, ob_rr_theme->button_size);

-    XResizeWindow(ob_display, self->icon,
+    XResizeWindow(obt_display, self->icon,

                   ob_rr_theme->button_size + 2, ob_rr_theme->button_size + 2);
                   ob_rr_theme->button_size + 2, ob_rr_theme->button_size + 2);

-    XResizeWindow(ob_display, self->close,
+    XResizeWindow(obt_display, self->close,

                   ob_rr_theme->button_size, ob_rr_theme->button_size);
                   ob_rr_theme->button_size, ob_rr_theme->button_size);

-    XResizeWindow(ob_display, self->desk,
+    XResizeWindow(obt_display, self->desk,

                   ob_rr_theme->button_size, ob_rr_theme->button_size);
                   ob_rr_theme->button_size, ob_rr_theme->button_size);

-    XResizeWindow(ob_display, self->shade,
+    XResizeWindow(obt_display, self->shade,

                   ob_rr_theme->button_size, ob_rr_theme->button_size);
                   ob_rr_theme->button_size, ob_rr_theme->button_size);

-    if (ob_rr_theme->handle_height > 0) {
-        XResizeWindow(ob_display, self->lgrip,
-                      ob_rr_theme->grip_width, ob_rr_theme->handle_height);
-        XResizeWindow(ob_display, self->rgrip,
-                      ob_rr_theme->grip_width, ob_rr_theme->handle_height);
-    }
-    XResizeWindow(ob_display, self->tltresize,
+    XResizeWindow(obt_display, self->tltresize,

                   ob_rr_theme->grip_width, ob_rr_theme->paddingy + 1);
                   ob_rr_theme->grip_width, ob_rr_theme->paddingy + 1);

-    XResizeWindow(ob_display, self->trtresize,
+    XResizeWindow(obt_display, self->trtresize,

                   ob_rr_theme->grip_width, ob_rr_theme->paddingy + 1);
                   ob_rr_theme->grip_width, ob_rr_theme->paddingy + 1);

-    XResizeWindow(ob_display, self->tllresize,
+    XResizeWindow(obt_display, self->tllresize,

                   ob_rr_theme->paddingx + 1, ob_rr_theme->title_height);
                   ob_rr_theme->paddingx + 1, ob_rr_theme->title_height);

-    XResizeWindow(ob_display, self->trrresize,
+    XResizeWindow(obt_display, self->trrresize,

                   ob_rr_theme->paddingx + 1, ob_rr_theme->title_height);
                   ob_rr_theme->paddingx + 1, ob_rr_theme->title_height);

-
-    /* set up the dynamic appearances */
-    self->a_unfocused_title = RrAppearanceCopy(ob_rr_theme->a_unfocused_title);
-    self->a_focused_title = RrAppearanceCopy(ob_rr_theme->a_focused_title);
-    self->a_unfocused_label = RrAppearanceCopy(ob_rr_theme->a_unfocused_label);
-    self->a_focused_label = RrAppearanceCopy(ob_rr_theme->a_focused_label);
-    self->a_unfocused_handle =
-        RrAppearanceCopy(ob_rr_theme->a_unfocused_handle);
-    self->a_focused_handle = RrAppearanceCopy(ob_rr_theme->a_focused_handle);
-    self->a_icon = RrAppearanceCopy(ob_rr_theme->a_icon);

 }
 
 static void free_theme_statics(ObFrame *self)
 {
 }
 
 static void free_theme_statics(ObFrame *self)
 {

-    RrAppearanceFree(self->a_unfocused_title); 
-    RrAppearanceFree(self->a_focused_title);
-    RrAppearanceFree(self->a_unfocused_label);
-    RrAppearanceFree(self->a_focused_label);
-    RrAppearanceFree(self->a_unfocused_handle);
-    RrAppearanceFree(self->a_focused_handle);
-    RrAppearanceFree(self->a_icon);

 }
 
 void frame_free(ObFrame *self)
 {
     free_theme_statics(self);
 
 }
 
 void frame_free(ObFrame *self)
 {
     free_theme_statics(self);
 

-    XDestroyWindow(ob_display, self->window);
+    XDestroyWindow(obt_display, self->window);

     if (self->colormap)
     if (self->colormap)

-        XFreeColormap(ob_display, self->colormap);
+        XFreeColormap(obt_display, self->colormap);

 
 

-    g_free(self);
+    g_slice_free(ObFrame, self);

 }
 
 void frame_show(ObFrame *self)
 {
     if (!self->visible) {
         self->visible = TRUE;
 }
 
 void frame_show(ObFrame *self)
 {
     if (!self->visible) {
         self->visible = TRUE;

-        XMapWindow(ob_display, self->client->window);
-        XMapWindow(ob_display, self->window);
+        framerender_frame(self);
+        /* Grab the server to make sure that the frame window is mapped before
+           the client gets its MapNotify, i.e. to make sure the client is
+           _visible_ when it gets MapNotify. */
+        grab_server(TRUE);
+        XMapWindow(obt_display, self->client->window);
+        XMapWindow(obt_display, self->window);
+        grab_server(FALSE);

     }
 }
 
     }
 }
 


@@ -271,10 +257,10 @@ void frame_hide(ObFrame *self)
     if (self->visible) {
         self->visible = FALSE;
         if (!frame_iconify_animating(self))
     if (self->visible) {
         self->visible = FALSE;
         if (!frame_iconify_animating(self))

-            XUnmapWindow(ob_display, self->window);
+            XUnmapWindow(obt_display, self->window);

         /* we unmap the client itself so that we can get MapRequest
            events, and because the ICCCM tells us to! */
         /* we unmap the client itself so that we can get MapRequest
            events, and because the ICCCM tells us to! */

-        XUnmapWindow(ob_display, self->client->window);
+        XUnmapWindow(obt_display, self->client->window);

         self->client->ignore_unmaps += 1;
     }
 }
         self->client->ignore_unmaps += 1;
     }
 }


@@ -285,130 +271,331 @@ void frame_adjust_theme(ObFrame *self)
     set_theme_statics(self);
 }
 
     set_theme_statics(self);
 }
 

-void frame_adjust_shape(ObFrame *self)
-{

 #ifdef SHAPE
 #ifdef SHAPE

+void frame_adjust_shape_kind(ObFrame *self, int kind)
+{

     gint num;
     XRectangle xrect[2];
     gint num;
     XRectangle xrect[2];

+    gboolean shaped;

 
 

-    if (!self->client->shaped) {
+    shaped = (kind == ShapeBounding && self->client->shaped);
+#ifdef ShapeInput
+    shaped |= (kind == ShapeInput && self->client->shaped_input);
+#endif
+
+    if (!shaped) {

         /* clear the shape on the frame window */
         /* clear the shape on the frame window */

-        XShapeCombineMask(ob_display, self->window, ShapeBounding,
-                          self->innersize.left,
-                          self->innersize.top,
+        XShapeCombineMask(obt_display, self->window, kind,
+                          self->size.left,
+                          self->size.top,

                           None, ShapeSet);
     } else {
         /* make the frame's shape match the clients */
                           None, ShapeSet);
     } else {
         /* make the frame's shape match the clients */

-        XShapeCombineShape(ob_display, self->window, ShapeBounding,
-                           self->innersize.left,
-                           self->innersize.top,
+        XShapeCombineShape(obt_display, self->window, kind,
+                           self->size.left,
+                           self->size.top,

                            self->client->window,
                            self->client->window,

-                           ShapeBounding, ShapeSet);
+                           kind, ShapeSet);

 
         num = 0;
         if (self->decorations & OB_FRAME_DECOR_TITLEBAR) {
 
         num = 0;
         if (self->decorations & OB_FRAME_DECOR_TITLEBAR) {

-            xrect[0].x = -ob_rr_theme->fbwidth;
-            xrect[0].y = -ob_rr_theme->fbwidth;
-            xrect[0].width = self->width + self->rbwidth * 2;
-            xrect[0].height = ob_rr_theme->title_height +
-                self->bwidth * 2;
+            xrect[0].x = 0;
+            xrect[0].y = 0;
+            xrect[0].width = self->area.width;
+            xrect[0].height = self->size.top;

             ++num;
         }
 
             ++num;
         }
 

-        if (self->decorations & OB_FRAME_DECOR_HANDLE) {
-            xrect[1].x = -ob_rr_theme->fbwidth;
+        if (self->decorations & OB_FRAME_DECOR_HANDLE &&
+            ob_rr_theme->handle_height > 0)
+        {
+            xrect[1].x = 0;

             xrect[1].y = FRAME_HANDLE_Y(self);
             xrect[1].y = FRAME_HANDLE_Y(self);

-            xrect[1].width = self->width + self->rbwidth * 2;
+            xrect[1].width = self->area.width;

             xrect[1].height = ob_rr_theme->handle_height +
                 self->bwidth * 2;
             ++num;
         }
 
             xrect[1].height = ob_rr_theme->handle_height +
                 self->bwidth * 2;
             ++num;
         }
 

-        XShapeCombineRectangles(ob_display, self->window,
+        XShapeCombineRectangles(obt_display, self->window,

                                 ShapeBounding, 0, 0, xrect, num,
                                 ShapeUnion, Unsorted);
     }
                                 ShapeBounding, 0, 0, xrect, num,
                                 ShapeUnion, Unsorted);
     }

+}
+#endif
+
+void frame_adjust_shape(ObFrame *self)
+{
+#ifdef SHAPE
+  frame_adjust_shape_kind(self, ShapeBounding);
+#ifdef ShapeInput
+  frame_adjust_shape_kind(self, ShapeInput);
+#endif

 #endif
 }
 
 void frame_adjust_area(ObFrame *self, gboolean moved,
                        gboolean resized, gboolean fake)
 {
 #endif
 }
 
 void frame_adjust_area(ObFrame *self, gboolean moved,
                        gboolean resized, gboolean fake)
 {

-    Strut oldsize;
-
-    oldsize = self->size;
-

     if (resized) {
     if (resized) {

+        /* do this before changing the frame's status like max_horz max_vert */
+        frame_adjust_cursors(self);
+
+        self->functions = self->client->functions;

         self->decorations = self->client->decorations;
         self->max_horz = self->client->max_horz;
         self->decorations = self->client->decorations;
         self->max_horz = self->client->max_horz;

+        self->max_vert = self->client->max_vert;
+        self->shaded = self->client->shaded;

 
 

-        if (self->decorations & OB_FRAME_DECOR_BORDER) {
-            self->bwidth = ob_rr_theme->fbwidth;
-            self->cbwidth_x = ob_rr_theme->cbwidthx;
-            self->cbwidth_y = ob_rr_theme->cbwidthy;
-        } else {
-            self->bwidth = self->cbwidth_x = self->cbwidth_y = 0;
-        }
-        self->rbwidth = self->bwidth;
+        if (self->decorations & OB_FRAME_DECOR_BORDER)
+            self->bwidth = self->client->undecorated ?
+                ob_rr_theme->ubwidth : ob_rr_theme->fbwidth;
+        else
+            self->bwidth = 0;

 
 

-        if (self->max_horz)
-            self->bwidth = self->cbwidth_x = 0;
+        if (self->decorations & OB_FRAME_DECOR_BORDER &&
+            !self->client->undecorated)
+        {
+            self->cbwidth_l = self->cbwidth_r = ob_rr_theme->cbwidthx;
+            self->cbwidth_t = self->cbwidth_b = ob_rr_theme->cbwidthy;
+        } else
+            self->cbwidth_l = self->cbwidth_t =
+                self->cbwidth_r = self->cbwidth_b = 0;
+
+        if (self->max_horz) {
+            self->cbwidth_l = self->cbwidth_r = 0;
+            self->width = self->client->area.width;
+            if (self->max_vert)
+                self->cbwidth_b = 0;
+        } else
+            self->width = self->client->area.width +
+                self->cbwidth_l + self->cbwidth_r;

 
 

-        STRUT_SET(self->innersize,
-                  self->cbwidth_x,
-                  self->cbwidth_y,
-                  self->cbwidth_x,
-                  self->cbwidth_y);
-        self->width = self->client->area.width + self->cbwidth_x * 2 -
-            (self->max_horz ? self->rbwidth * 2 : 0);
-        self->width = MAX(self->width, 1); /* no lower than 1 */
+        /* some elements are sized based of the width, so don't let them have
+           negative values */
+        self->width = MAX(self->width,
+                          (ob_rr_theme->grip_width + self->bwidth) * 2 + 1);

 
 

-        /* set border widths */
-        if (!fake) {
-            XSetWindowBorderWidth(ob_display, self->window, self->bwidth);
-            XSetWindowBorderWidth(ob_display, self->inner, self->bwidth);
-            XSetWindowBorderWidth(ob_display, self->title,  self->rbwidth);
-            XSetWindowBorderWidth(ob_display, self->handle, self->rbwidth);
-            XSetWindowBorderWidth(ob_display, self->lgrip,  self->rbwidth);
-            XSetWindowBorderWidth(ob_display, self->rgrip,  self->rbwidth);
-        }
+        STRUT_SET(self->size,
+                  self->cbwidth_l + (!self->max_horz ? self->bwidth : 0),
+                  self->cbwidth_t +
+                  (!self->max_horz || !self->max_vert ? self->bwidth : 0),
+                  self->cbwidth_r + (!self->max_horz ? self->bwidth : 0),
+                  self->cbwidth_b +
+                  (!self->max_horz || !self->max_vert ? self->bwidth : 0));

 
         if (self->decorations & OB_FRAME_DECOR_TITLEBAR)
 
         if (self->decorations & OB_FRAME_DECOR_TITLEBAR)

-            self->innersize.top += ob_rr_theme->title_height + self->rbwidth +
-                (self->rbwidth - self->bwidth);
+            self->size.top += ob_rr_theme->title_height + self->bwidth;
+        else if (self->max_horz && self->max_vert) {
+            /* A maximized and undecorated window needs a small border on the
+               top of the window to let the user still undecorate/unmaximize the
+               window via the client menu. */
+            /* XXX This size should probably be a theme option. */
+            self->size.top += 1;
+        }
+

         if (self->decorations & OB_FRAME_DECOR_HANDLE &&
             ob_rr_theme->handle_height > 0)
         if (self->decorations & OB_FRAME_DECOR_HANDLE &&
             ob_rr_theme->handle_height > 0)

-            self->innersize.bottom += ob_rr_theme->handle_height +
-                self->rbwidth + (self->rbwidth - self->bwidth);
-  
+        {
+            self->size.bottom += ob_rr_theme->handle_height + self->bwidth;
+        }
+

         /* position/size and map/unmap all the windows */
 
         if (!fake) {
         /* position/size and map/unmap all the windows */
 
         if (!fake) {

+            gint innercornerheight =
+                ob_rr_theme->grip_width - self->size.bottom;
+
+            if (self->cbwidth_l) {
+                XMoveResizeWindow(obt_display, self->innerleft,
+                                  self->size.left - self->cbwidth_l,
+                                  self->size.top,
+                                  self->cbwidth_l, self->client->area.height);
+
+                XMapWindow(obt_display, self->innerleft);
+            } else
+                XUnmapWindow(obt_display, self->innerleft);
+
+            if (self->cbwidth_l && innercornerheight > 0) {
+                XMoveResizeWindow(obt_display, self->innerbll,
+                                  0,
+                                  self->client->area.height - 
+                                  (ob_rr_theme->grip_width -
+                                   self->size.bottom),
+                                  self->cbwidth_l,
+                                  ob_rr_theme->grip_width - self->size.bottom);
+
+                XMapWindow(obt_display, self->innerbll);
+            } else
+                XUnmapWindow(obt_display, self->innerbll);
+
+            if (self->cbwidth_r) {
+                XMoveResizeWindow(obt_display, self->innerright,
+                                  self->size.left + self->client->area.width,
+                                  self->size.top,
+                                  self->cbwidth_r, self->client->area.height);
+
+                XMapWindow(obt_display, self->innerright);
+            } else
+                XUnmapWindow(obt_display, self->innerright);
+
+            if (self->cbwidth_r && innercornerheight > 0) {
+                XMoveResizeWindow(obt_display, self->innerbrr,
+                                  0,
+                                  self->client->area.height - 
+                                  (ob_rr_theme->grip_width -
+                                   self->size.bottom),
+                                  self->cbwidth_r,
+                                  ob_rr_theme->grip_width - self->size.bottom);
+
+                XMapWindow(obt_display, self->innerbrr);
+            } else
+                XUnmapWindow(obt_display, self->innerbrr);
+
+            if (self->cbwidth_t) {
+                XMoveResizeWindow(obt_display, self->innertop,
+                                  self->size.left - self->cbwidth_l,
+                                  self->size.top - self->cbwidth_t,
+                                  self->client->area.width +
+                                  self->cbwidth_l + self->cbwidth_r,
+                                  self->cbwidth_t);
+
+                XMapWindow(obt_display, self->innertop);
+            } else
+                XUnmapWindow(obt_display, self->innertop);
+
+            if (self->cbwidth_b) {
+                XMoveResizeWindow(obt_display, self->innerbottom,
+                                  self->size.left - self->cbwidth_l,
+                                  self->size.top + self->client->area.height,
+                                  self->client->area.width +
+                                  self->cbwidth_l + self->cbwidth_r,
+                                  self->cbwidth_b);
+
+                XMoveResizeWindow(obt_display, self->innerblb,
+                                  0, 0,
+                                  ob_rr_theme->grip_width + self->bwidth,
+                                  self->cbwidth_b);
+                XMoveResizeWindow(obt_display, self->innerbrb,
+                                  self->client->area.width +
+                                  self->cbwidth_l + self->cbwidth_r -
+                                  (ob_rr_theme->grip_width + self->bwidth),
+                                  0,
+                                  ob_rr_theme->grip_width + self->bwidth,
+                                  self->cbwidth_b);
+
+                XMapWindow(obt_display, self->innerbottom);
+                XMapWindow(obt_display, self->innerblb);
+                XMapWindow(obt_display, self->innerbrb);
+            } else {
+                XUnmapWindow(obt_display, self->innerbottom);
+                XUnmapWindow(obt_display, self->innerblb);
+                XUnmapWindow(obt_display, self->innerbrb);
+            }
+
+            if (self->bwidth) {
+                gint titlesides;
+
+                /* height of titleleft and titleright */
+                titlesides = (!self->max_horz ? ob_rr_theme->grip_width : 0);
+
+                XMoveResizeWindow(obt_display, self->titletop,
+                                  ob_rr_theme->grip_width + self->bwidth, 0,
+                                  /* width + bwidth*2 - bwidth*2 - grips*2 */
+                                  self->width - ob_rr_theme->grip_width * 2,
+                                  self->bwidth);
+                XMoveResizeWindow(obt_display, self->titletopleft,
+                                  0, 0,
+                                  ob_rr_theme->grip_width + self->bwidth,
+                                  self->bwidth);
+                XMoveResizeWindow(obt_display, self->titletopright,
+                                  self->client->area.width +
+                                  self->size.left + self->size.right -
+                                  ob_rr_theme->grip_width - self->bwidth,
+                                  0,
+                                  ob_rr_theme->grip_width + self->bwidth,
+                                  self->bwidth);
+
+                if (titlesides > 0) {
+                    XMoveResizeWindow(obt_display, self->titleleft,
+                                      0, self->bwidth,
+                                      self->bwidth,
+                                      titlesides);
+                    XMoveResizeWindow(obt_display, self->titleright,
+                                      self->client->area.width +
+                                      self->size.left + self->size.right -
+                                      self->bwidth,
+                                      self->bwidth,
+                                      self->bwidth,
+                                      titlesides);
+
+                    XMapWindow(obt_display, self->titleleft);
+                    XMapWindow(obt_display, self->titleright);
+                } else {
+                    XUnmapWindow(obt_display, self->titleleft);
+                    XUnmapWindow(obt_display, self->titleright);
+                }
+
+                XMapWindow(obt_display, self->titletop);
+                XMapWindow(obt_display, self->titletopleft);
+                XMapWindow(obt_display, self->titletopright);
+
+                if (self->decorations & OB_FRAME_DECOR_TITLEBAR) {
+                    XMoveResizeWindow(obt_display, self->titlebottom,
+                                      (self->max_horz ? 0 : self->bwidth),
+                                      ob_rr_theme->title_height + self->bwidth,
+                                      self->width,
+                                      self->bwidth);
+
+                    XMapWindow(obt_display, self->titlebottom);
+                } else
+                    XUnmapWindow(obt_display, self->titlebottom);
+            } else {
+                XUnmapWindow(obt_display, self->titlebottom);
+
+                XUnmapWindow(obt_display, self->titletop);
+                XUnmapWindow(obt_display, self->titletopleft);
+                XUnmapWindow(obt_display, self->titletopright);
+                XUnmapWindow(obt_display, self->titleleft);
+                XUnmapWindow(obt_display, self->titleright);
+            }
+

             if (self->decorations & OB_FRAME_DECOR_TITLEBAR) {
             if (self->decorations & OB_FRAME_DECOR_TITLEBAR) {

-                XMoveResizeWindow(ob_display, self->title,
-                                  -self->bwidth, -self->bwidth,
+                XMoveResizeWindow(obt_display, self->title,
+                                  (self->max_horz ? 0 : self->bwidth),
+                                  self->bwidth,

                                   self->width, ob_rr_theme->title_height);
                                   self->width, ob_rr_theme->title_height);

-                XMapWindow(ob_display, self->title);
+
+                XMapWindow(obt_display, self->title);

 
                 if (self->decorations & OB_FRAME_DECOR_GRIPS) {
 
                 if (self->decorations & OB_FRAME_DECOR_GRIPS) {

-                    XMoveWindow(ob_display, self->tltresize, 0, 0);
-                    XMoveWindow(ob_display, self->tllresize, 0, 0);
-                    XMoveWindow(ob_display, self->trtresize,
+                    XMoveResizeWindow(obt_display, self->topresize,
+                                      ob_rr_theme->grip_width,
+                                      0,
+                                      self->width - ob_rr_theme->grip_width *2,
+                                      ob_rr_theme->paddingy + 1);
+
+                    XMoveWindow(obt_display, self->tltresize, 0, 0);
+                    XMoveWindow(obt_display, self->tllresize, 0, 0);
+                    XMoveWindow(obt_display, self->trtresize,

                                 self->width - ob_rr_theme->grip_width, 0);
                                 self->width - ob_rr_theme->grip_width, 0);

-                    XMoveWindow(ob_display, self->trrresize,
+                    XMoveWindow(obt_display, self->trrresize,

                                 self->width - ob_rr_theme->paddingx - 1, 0);
                                 self->width - ob_rr_theme->paddingx - 1, 0);

-                    XMapWindow(ob_display, self->tltresize);
-                    XMapWindow(ob_display, self->tllresize);
-                    XMapWindow(ob_display, self->trtresize);
-                    XMapWindow(ob_display, self->trrresize);
+
+                    XMapWindow(obt_display, self->topresize);
+                    XMapWindow(obt_display, self->tltresize);
+                    XMapWindow(obt_display, self->tllresize);
+                    XMapWindow(obt_display, self->trtresize);
+                    XMapWindow(obt_display, self->trrresize);

                 } else {
                 } else {

-                    XUnmapWindow(ob_display, self->tltresize);
-                    XUnmapWindow(ob_display, self->tllresize);
-                    XUnmapWindow(ob_display, self->trtresize);
-                    XUnmapWindow(ob_display, self->trrresize);
+                    XUnmapWindow(obt_display, self->topresize);
+                    XUnmapWindow(obt_display, self->tltresize);
+                    XUnmapWindow(obt_display, self->tllresize);
+                    XUnmapWindow(obt_display, self->trtresize);
+                    XUnmapWindow(obt_display, self->trrresize);

                 }
             } else
                 }
             } else

-                XUnmapWindow(ob_display, self->title);
+                XUnmapWindow(obt_display, self->title);

         }
 
         if ((self->decorations & OB_FRAME_DECOR_TITLEBAR))
         }
 
         if ((self->decorations & OB_FRAME_DECOR_TITLEBAR))


@@ -416,54 +603,219 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
             layout_title(self);
 
         if (!fake) {
             layout_title(self);
 
         if (!fake) {

+            gint sidebwidth = self->max_horz ? 0 : self->bwidth;
+
+            if (self->bwidth && self->size.bottom) {
+                XMoveResizeWindow(obt_display, self->handlebottom,
+                                  ob_rr_theme->grip_width +
+                                  self->bwidth + sidebwidth,
+                                  self->size.top + self->client->area.height +
+                                  self->size.bottom - self->bwidth,
+                                  self->width - (ob_rr_theme->grip_width +
+                                                 sidebwidth) * 2,
+                                  self->bwidth);
+
+
+                if (sidebwidth) {
+                    XMoveResizeWindow(obt_display, self->lgripleft,
+                                      0,
+                                      self->size.top +
+                                      self->client->area.height +
+                                      self->size.bottom -
+                                      (!self->max_horz ?
+                                       ob_rr_theme->grip_width :
+                                       self->size.bottom - self->cbwidth_b),
+                                      self->bwidth,
+                                      (!self->max_horz ?
+                                       ob_rr_theme->grip_width :
+                                       self->size.bottom - self->cbwidth_b));
+                    XMoveResizeWindow(obt_display, self->rgripright,
+                                  self->size.left +
+                                      self->client->area.width +
+                                      self->size.right - self->bwidth,
+                                      self->size.top +
+                                      self->client->area.height +
+                                      self->size.bottom -
+                                      (!self->max_horz ?
+                                       ob_rr_theme->grip_width :
+                                       self->size.bottom - self->cbwidth_b),
+                                      self->bwidth,
+                                      (!self->max_horz ?
+                                       ob_rr_theme->grip_width :
+                                       self->size.bottom - self->cbwidth_b));
+
+                    XMapWindow(obt_display, self->lgripleft);
+                    XMapWindow(obt_display, self->rgripright);
+                } else {
+                    XUnmapWindow(obt_display, self->lgripleft);
+                    XUnmapWindow(obt_display, self->rgripright);
+                }
+
+                XMoveResizeWindow(obt_display, self->lgripbottom,
+                                  sidebwidth,
+                                  self->size.top + self->client->area.height +
+                                  self->size.bottom - self->bwidth,
+                                  ob_rr_theme->grip_width + self->bwidth,
+                                  self->bwidth);
+                XMoveResizeWindow(obt_display, self->rgripbottom,
+                                  self->size.left + self->client->area.width +
+                                  self->size.right - self->bwidth - sidebwidth-
+                                  ob_rr_theme->grip_width,
+                                  self->size.top + self->client->area.height +
+                                  self->size.bottom - self->bwidth,
+                                  ob_rr_theme->grip_width + self->bwidth,
+                                  self->bwidth);
+
+                XMapWindow(obt_display, self->handlebottom);
+                XMapWindow(obt_display, self->lgripbottom);
+                XMapWindow(obt_display, self->rgripbottom);
+
+                if (self->decorations & OB_FRAME_DECOR_HANDLE &&
+                    ob_rr_theme->handle_height > 0)
+                {
+                    XMoveResizeWindow(obt_display, self->handletop,
+                                      ob_rr_theme->grip_width +
+                                      self->bwidth + sidebwidth,
+                                      FRAME_HANDLE_Y(self),
+                                      self->width - (ob_rr_theme->grip_width +
+                                                     sidebwidth) * 2,
+                                      self->bwidth);
+                    XMapWindow(obt_display, self->handletop);
+
+                    if (self->decorations & OB_FRAME_DECOR_GRIPS) {
+                        XMoveResizeWindow(obt_display, self->handleleft,
+                                          ob_rr_theme->grip_width,
+                                          0,
+                                          self->bwidth,
+                                          ob_rr_theme->handle_height);
+                        XMoveResizeWindow(obt_display, self->handleright,
+                                          self->width -
+                                          ob_rr_theme->grip_width -
+                                          self->bwidth,
+                                          0,
+                                          self->bwidth,
+                                          ob_rr_theme->handle_height);
+
+                        XMoveResizeWindow(obt_display, self->lgriptop,
+                                          sidebwidth,
+                                          FRAME_HANDLE_Y(self),
+                                          ob_rr_theme->grip_width +
+                                          self->bwidth,
+                                          self->bwidth);
+                        XMoveResizeWindow(obt_display, self->rgriptop,
+                                          self->size.left +
+                                          self->client->area.width +
+                                          self->size.right - self->bwidth -
+                                          sidebwidth - ob_rr_theme->grip_width,
+                                          FRAME_HANDLE_Y(self),
+                                          ob_rr_theme->grip_width +
+                                          self->bwidth,
+                                          self->bwidth);
+
+                        XMapWindow(obt_display, self->handleleft);
+                        XMapWindow(obt_display, self->handleright);
+                        XMapWindow(obt_display, self->lgriptop);
+                        XMapWindow(obt_display, self->rgriptop);
+                    } else {
+                        XUnmapWindow(obt_display, self->handleleft);
+                        XUnmapWindow(obt_display, self->handleright);
+                        XUnmapWindow(obt_display, self->lgriptop);
+                        XUnmapWindow(obt_display, self->rgriptop);
+                    }
+                } else {
+                    XUnmapWindow(obt_display, self->handleleft);
+                    XUnmapWindow(obt_display, self->handleright);
+                    XUnmapWindow(obt_display, self->lgriptop);
+                    XUnmapWindow(obt_display, self->rgriptop);
+
+                    XUnmapWindow(obt_display, self->handletop);
+                }
+            } else {
+                XUnmapWindow(obt_display, self->handleleft);
+                XUnmapWindow(obt_display, self->handleright);
+                XUnmapWindow(obt_display, self->lgriptop);
+                XUnmapWindow(obt_display, self->rgriptop);
+
+                XUnmapWindow(obt_display, self->handletop);
+
+                XUnmapWindow(obt_display, self->handlebottom);
+                XUnmapWindow(obt_display, self->lgripleft);
+                XUnmapWindow(obt_display, self->rgripright);
+                XUnmapWindow(obt_display, self->lgripbottom);
+                XUnmapWindow(obt_display, self->rgripbottom);
+            }
+

             if (self->decorations & OB_FRAME_DECOR_HANDLE &&
                 ob_rr_theme->handle_height > 0)
             {
             if (self->decorations & OB_FRAME_DECOR_HANDLE &&
                 ob_rr_theme->handle_height > 0)
             {

-                XMoveResizeWindow(ob_display, self->handle,
-                                  -self->bwidth, FRAME_HANDLE_Y(self),
+                XMoveResizeWindow(obt_display, self->handle,
+                                  sidebwidth,
+                                  FRAME_HANDLE_Y(self) + self->bwidth,

                                   self->width, ob_rr_theme->handle_height);
                                   self->width, ob_rr_theme->handle_height);

-                XMapWindow(ob_display, self->handle);
+                XMapWindow(obt_display, self->handle);

 
                 if (self->decorations & OB_FRAME_DECOR_GRIPS) {
 
                 if (self->decorations & OB_FRAME_DECOR_GRIPS) {

-                    XMoveWindow(ob_display, self->lgrip,
-                                -self->rbwidth, -self->rbwidth);
-                    XMoveWindow(ob_display, self->rgrip,
-                                -self->rbwidth + self->width -
-                                ob_rr_theme->grip_width, -self->rbwidth);
-                    XMapWindow(ob_display, self->lgrip);
-                    XMapWindow(ob_display, self->rgrip);
+                    XMoveResizeWindow(obt_display, self->lgrip,
+                                      0, 0,
+                                      ob_rr_theme->grip_width,
+                                      ob_rr_theme->handle_height);
+                    XMoveResizeWindow(obt_display, self->rgrip,
+                                      self->width - ob_rr_theme->grip_width,
+                                      0,
+                                      ob_rr_theme->grip_width,
+                                      ob_rr_theme->handle_height);
+
+                    XMapWindow(obt_display, self->lgrip);
+                    XMapWindow(obt_display, self->rgrip);

                 } else {
                 } else {

-                    XUnmapWindow(ob_display, self->lgrip);
-                    XUnmapWindow(ob_display, self->rgrip);
+                    XUnmapWindow(obt_display, self->lgrip);
+                    XUnmapWindow(obt_display, self->rgrip);

                 }
                 }

+            } else {
+                XUnmapWindow(obt_display, self->lgrip);
+                XUnmapWindow(obt_display, self->rgrip);
+
+                XUnmapWindow(obt_display, self->handle);
+            }
+
+            if (self->bwidth && !self->max_horz &&
+                (self->client->area.height + self->size.top +
+                 self->size.bottom) > ob_rr_theme->grip_width * 2)
+            {
+                XMoveResizeWindow(obt_display, self->left,
+                                  0,
+                                  self->bwidth + ob_rr_theme->grip_width,
+                                  self->bwidth,
+                                  self->client->area.height +
+                                  self->size.top + self->size.bottom -
+                                  ob_rr_theme->grip_width * 2);
+
+                XMapWindow(obt_display, self->left);

             } else
             } else

-                XUnmapWindow(ob_display, self->handle);
-
-            /* move and resize the inner border window which contains the plate
-             */
-            XMoveResizeWindow(ob_display, self->inner,
-                              self->innersize.left - self->cbwidth_x -
-                              self->bwidth,
-                              self->innersize.top - self->cbwidth_y -
-                              self->bwidth,
-                              self->client->area.width +
-                              self->cbwidth_x * 2,
-                              self->client->area.height +
-                              self->cbwidth_y * 2);
-
-            /* move the plate */
-            XMoveWindow(ob_display, self->plate,
-                        self->cbwidth_x, self->cbwidth_y);
-
-            /* when the client has StaticGravity, it likes to move around. */
-            XMoveWindow(ob_display, self->client->window, 0, 0);
-        }
+                XUnmapWindow(obt_display, self->left);

 
 

-        STRUT_SET(self->size,
-                  self->innersize.left + self->bwidth,
-                  self->innersize.top + self->bwidth,
-                  self->innersize.right + self->bwidth,
-                  self->innersize.bottom + self->bwidth);
+            if (self->bwidth && !self->max_horz &&
+                (self->client->area.height + self->size.top +
+                 self->size.bottom) > ob_rr_theme->grip_width * 2)
+            {
+                XMoveResizeWindow(obt_display, self->right,
+                                  self->client->area.width + self->cbwidth_l +
+                                  self->cbwidth_r + self->bwidth,
+                                  self->bwidth + ob_rr_theme->grip_width,
+                                  self->bwidth,
+                                  self->client->area.height +
+                                  self->size.top + self->size.bottom -
+                                  ob_rr_theme->grip_width * 2);
+
+                XMapWindow(obt_display, self->right);
+            } else
+                XUnmapWindow(obt_display, self->right);
+
+            XMoveResizeWindow(obt_display, self->backback,
+                              self->size.left, self->size.top,
+                              self->client->area.width,
+                              self->client->area.height);
+        }

     }
 
     /* shading can change without being moved or resized */
     }
 
     /* shading can change without being moved or resized */


@@ -471,192 +823,316 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
                   self->client->area.width +
                   self->size.left + self->size.right,
                   (self->client->shaded ?
                   self->client->area.width +
                   self->size.left + self->size.right,
                   (self->client->shaded ?

-                   ob_rr_theme->title_height + self->rbwidth * 2:
+                   ob_rr_theme->title_height + self->bwidth * 2:

                    self->client->area.height +
                    self->size.top + self->size.bottom));
 
                    self->client->area.height +
                    self->size.top + self->size.bottom));
 

-    if (moved || resized) {
+    if ((moved || resized) && !fake) {

         /* find the new coordinates, done after setting the frame.size, for
            frame_client_gravity. */
         self->area.x = self->client->area.x;
         self->area.y = self->client->area.y;
         /* find the new coordinates, done after setting the frame.size, for
            frame_client_gravity. */
         self->area.x = self->client->area.x;
         self->area.y = self->client->area.y;

-        frame_client_gravity(self, &self->area.x, &self->area.y,
-                             self->client->area.width,
-                             self->client->area.height);
+        frame_client_gravity(self, &self->area.x, &self->area.y);

     }
 
     if (!fake) {
         if (!frame_iconify_animating(self))
             /* move and resize the top level frame.
                shading can change without being moved or resized.
     }
 
     if (!fake) {
         if (!frame_iconify_animating(self))
             /* move and resize the top level frame.
                shading can change without being moved or resized.

-               
+

                but don't do this during an iconify animation. it will be
                reflected afterwards.
             */
                but don't do this during an iconify animation. it will be
                reflected afterwards.
             */

-            XMoveResizeWindow(ob_display, self->window,
-                              self->area.x, self->area.y,
-                              self->area.width - self->bwidth * 2,
-                              self->area.height - self->bwidth * 2);
+            XMoveResizeWindow(obt_display, self->window,
+                              self->area.x,
+                              self->area.y,
+                              self->area.width,
+                              self->area.height);
+
+        /* when the client has StaticGravity, it likes to move around.
+           also this correctly positions the client when it maps.
+           this also needs to be run when the frame's decorations sizes change!
+        */
+        XMoveWindow(obt_display, self->client->window,
+                    self->size.left, self->size.top);

 
         if (resized) {
 
         if (resized) {

+            self->need_render = TRUE;

             framerender_frame(self);
             frame_adjust_shape(self);
         }
 
             framerender_frame(self);
             frame_adjust_shape(self);
         }
 

-        if (!STRUT_EQUAL(self->size, oldsize)) {
+        if (!STRUT_EQUAL(self->size, self->oldsize)) {

             gulong vals[4];
             vals[0] = self->size.left;
             vals[1] = self->size.right;
             vals[2] = self->size.top;
             vals[3] = self->size.bottom;
             gulong vals[4];
             vals[0] = self->size.left;
             vals[1] = self->size.right;
             vals[2] = self->size.top;
             vals[3] = self->size.bottom;

-            PROP_SETA32(self->client->window, net_frame_extents,
-                        cardinal, vals, 4);
-            PROP_SETA32(self->client->window, kde_net_wm_frame_strut,
-                        cardinal, vals, 4);
+            OBT_PROP_SETA32(self->client->window, NET_FRAME_EXTENTS,
+                            CARDINAL, vals, 4);
+            OBT_PROP_SETA32(self->client->window, KDE_NET_WM_FRAME_STRUT,
+                            CARDINAL, vals, 4);
+            self->oldsize = self->size;

         }
 
         /* if this occurs while we are focus cycling, the indicator needs to
            match the changes */
         if (focus_cycle_target == self->client)
         }
 
         /* if this occurs while we are focus cycling, the indicator needs to
            match the changes */
         if (focus_cycle_target == self->client)

-            focus_cycle_draw_indicator();
+            focus_cycle_update_indicator(self->client);

     }
     }

-    if (resized && (self->decorations & OB_FRAME_DECOR_TITLEBAR))
-        XResizeWindow(ob_display, self->label, self->label_width,
+    if (resized && (self->decorations & OB_FRAME_DECOR_TITLEBAR) &&
+        self->label_width)
+    {
+        XResizeWindow(obt_display, self->label, self->label_width,

                       ob_rr_theme->label_height);
                       ob_rr_theme->label_height);

+    }
+}
+
+static void frame_adjust_cursors(ObFrame *self)
+{
+    if ((self->functions & OB_CLIENT_FUNC_RESIZE) !=
+        (self->client->functions & OB_CLIENT_FUNC_RESIZE) ||
+        self->max_horz != self->client->max_horz ||
+        self->max_vert != self->client->max_vert ||
+        self->shaded != self->client->shaded)
+    {
+        gboolean r = (self->client->functions & OB_CLIENT_FUNC_RESIZE) &&
+            !(self->client->max_horz && self->client->max_vert);
+        gboolean topbot = !self->client->max_vert;
+        gboolean sh = self->client->shaded;
+        XSetWindowAttributes a;
+
+        /* these ones turn off when max vert, and some when shaded */
+        a.cursor = ob_cursor(r && topbot && !sh ?
+                             OB_CURSOR_NORTH : OB_CURSOR_NONE);
+        XChangeWindowAttributes(obt_display, self->topresize, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->titletop, CWCursor, &a);
+        a.cursor = ob_cursor(r && topbot ? OB_CURSOR_SOUTH : OB_CURSOR_NONE);
+        XChangeWindowAttributes(obt_display, self->handle, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->handletop, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->handlebottom, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->innerbottom, CWCursor, &a);
+
+        /* these ones change when shaded */
+        a.cursor = ob_cursor(r ? (sh ? OB_CURSOR_WEST : OB_CURSOR_NORTHWEST) :
+                             OB_CURSOR_NONE);
+        XChangeWindowAttributes(obt_display, self->titleleft, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->tltresize, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->tllresize, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->titletopleft, CWCursor, &a);
+        a.cursor = ob_cursor(r ? (sh ? OB_CURSOR_EAST : OB_CURSOR_NORTHEAST) :
+                             OB_CURSOR_NONE);
+        XChangeWindowAttributes(obt_display, self->titleright, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->trtresize, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->trrresize, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->titletopright, CWCursor,&a);
+
+        /* these ones are pretty static */
+        a.cursor = ob_cursor(r ? OB_CURSOR_WEST : OB_CURSOR_NONE);
+        XChangeWindowAttributes(obt_display, self->left, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->innerleft, CWCursor, &a);
+        a.cursor = ob_cursor(r ? OB_CURSOR_EAST : OB_CURSOR_NONE);
+        XChangeWindowAttributes(obt_display, self->right, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->innerright, CWCursor, &a);
+        a.cursor = ob_cursor(r ? OB_CURSOR_SOUTHWEST : OB_CURSOR_NONE);
+        XChangeWindowAttributes(obt_display, self->lgrip, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->handleleft, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->lgripleft, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->lgriptop, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->lgripbottom, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->innerbll, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->innerblb, CWCursor, &a);
+        a.cursor = ob_cursor(r ? OB_CURSOR_SOUTHEAST : OB_CURSOR_NONE);
+        XChangeWindowAttributes(obt_display, self->rgrip, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->handleright, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->rgripright, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->rgriptop, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->rgripbottom, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->innerbrr, CWCursor, &a);
+        XChangeWindowAttributes(obt_display, self->innerbrb, CWCursor, &a);
+    }

 }
 
 void frame_adjust_client_area(ObFrame *self)
 {
 }
 
 void frame_adjust_client_area(ObFrame *self)
 {

-    /* resize the plate */
-    XResizeWindow(ob_display, self->plate,
-                  self->client->area.width, self->client->area.height);
+    /* adjust the window which is there to prevent flashing on unmap */
+    XMoveResizeWindow(obt_display, self->backfront, 0, 0,
+                      self->client->area.width,
+                      self->client->area.height);

 }
 
 void frame_adjust_state(ObFrame *self)
 {
 }
 
 void frame_adjust_state(ObFrame *self)
 {

+    self->need_render = TRUE;

     framerender_frame(self);
 }
 
 void frame_adjust_focus(ObFrame *self, gboolean hilite)
 {
     framerender_frame(self);
 }
 
 void frame_adjust_focus(ObFrame *self, gboolean hilite)
 {

+    ob_debug_type(OB_DEBUG_FOCUS,
+                  "Frame for 0x%x has focus: %d",
+                  self->client->window, hilite);

     self->focused = hilite;
     self->focused = hilite;

+    self->need_render = TRUE;

     framerender_frame(self);
     framerender_frame(self);

-    XFlush(ob_display);
+    XFlush(obt_display);

 }
 
 void frame_adjust_title(ObFrame *self)
 {
 }
 
 void frame_adjust_title(ObFrame *self)
 {

+    self->need_render = TRUE;

     framerender_frame(self);
 }
 
 void frame_adjust_icon(ObFrame *self)
 {
     framerender_frame(self);
 }
 
 void frame_adjust_icon(ObFrame *self)
 {

+    self->need_render = TRUE;

     framerender_frame(self);
 }
 
 void frame_grab_client(ObFrame *self)
 {
     framerender_frame(self);
 }
 
 void frame_grab_client(ObFrame *self)
 {

+    /* DO NOT map the client window here. we used to do that, but it is bogus.
+       we need to set up the client's dimensions and everything before we
+       send a mapnotify or we create race conditions.
+    */
+

     /* reparent the client to the frame */
     /* reparent the client to the frame */

-    XReparentWindow(ob_display, self->client->window, self->plate, 0, 0);
+    XReparentWindow(obt_display, self->client->window, self->window, 0, 0);
+

     /*
       When reparenting the client window, it is usually not mapped yet, since
       this occurs from a MapRequest. However, in the case where Openbox is
     /*
       When reparenting the client window, it is usually not mapped yet, since
       this occurs from a MapRequest. However, in the case where Openbox is

-      starting up, the window is already mapped, so we'll see unmap events for
-      it. There are 2 unmap events generated that we see, one with the 'event'
-      member set the root window, and one set to the client, but both get
-      handled and need to be ignored.
+      starting up, the window is already mapped, so we'll see an unmap event
+      for it.

     */
     if (ob_state() == OB_STATE_STARTING)
     */
     if (ob_state() == OB_STATE_STARTING)

-        self->client->ignore_unmaps += 2;
+        ++self->client->ignore_unmaps;

 
     /* select the event mask on the client's parent (to receive config/map
        req's) the ButtonPress is to catch clicks on the client border */
 
     /* select the event mask on the client's parent (to receive config/map
        req's) the ButtonPress is to catch clicks on the client border */

-    XSelectInput(ob_display, self->plate, PLATE_EVENTMASK);
+    XSelectInput(obt_display, self->window, FRAME_EVENTMASK);

 
 

-    /* map the client so it maps when the frame does */
-    XMapWindow(ob_display, self->client->window);
+    /* set all the windows for the frame in the window_map */
+    window_add(&self->window, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->backback, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->backfront, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->innerleft, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->innertop, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->innerright, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->innerbottom, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->innerblb, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->innerbll, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->innerbrb, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->innerbrr, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->title, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->label, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->max, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->close, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->desk, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->shade, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->icon, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->iconify, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->handle, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->lgrip, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->rgrip, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->topresize, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->tltresize, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->tllresize, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->trtresize, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->trrresize, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->left, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->right, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->titleleft, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->titletop, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->titletopleft, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->titletopright, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->titleright, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->titlebottom, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->handleleft, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->handletop, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->handleright, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->handlebottom, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->lgripleft, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->lgriptop, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->lgripbottom, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->rgripright, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->rgriptop, CLIENT_AS_WINDOW(self->client));
+    window_add(&self->rgripbottom, CLIENT_AS_WINDOW(self->client));
+}

 
 

-    /* adjust the frame to the client's size */
-    frame_adjust_area(self, FALSE, TRUE, FALSE);
+static gboolean find_reparent(XEvent *e, gpointer data)
+{
+    const ObFrame *self = data;

 
 

-    /* set all the windows for the frame in the window_map */
-    g_hash_table_insert(window_map, &self->window, self->client);
-    g_hash_table_insert(window_map, &self->plate, self->client);
-    g_hash_table_insert(window_map, &self->inner, self->client);
-    g_hash_table_insert(window_map, &self->title, self->client);
-    g_hash_table_insert(window_map, &self->label, self->client);
-    g_hash_table_insert(window_map, &self->max, self->client);
-    g_hash_table_insert(window_map, &self->close, self->client);
-    g_hash_table_insert(window_map, &self->desk, self->client);
-    g_hash_table_insert(window_map, &self->shade, self->client);
-    g_hash_table_insert(window_map, &self->icon, self->client);
-    g_hash_table_insert(window_map, &self->iconify, self->client);
-    g_hash_table_insert(window_map, &self->handle, self->client);
-    g_hash_table_insert(window_map, &self->lgrip, self->client);
-    g_hash_table_insert(window_map, &self->rgrip, self->client);
-    g_hash_table_insert(window_map, &self->tltresize, self->client);
-    g_hash_table_insert(window_map, &self->tllresize, self->client);
-    g_hash_table_insert(window_map, &self->trtresize, self->client);
-    g_hash_table_insert(window_map, &self->trrresize, self->client);
+    /* Find ReparentNotify events for the window that aren't being reparented into the
+       frame, thus the client reparenting itself off the frame. */
+    return e->type == ReparentNotify && e->xreparent.window == self->client->window &&
+        e->xreparent.parent != self->window;

 }
 
 void frame_release_client(ObFrame *self)
 {
 }
 
 void frame_release_client(ObFrame *self)
 {

-    XEvent ev;
-    gboolean reparent = TRUE;
-

     /* if there was any animation going on, kill it */
     /* if there was any animation going on, kill it */

-    ob_main_loop_timeout_remove_data(ob_main_loop, frame_animate_iconify,
-                                     self, FALSE);
+    if (self->iconify_animation_timer)
+        g_source_remove(self->iconify_animation_timer);

 
     /* check if the app has already reparented its window away */
 
     /* check if the app has already reparented its window away */

-    while (XCheckTypedWindowEvent(ob_display, self->client->window,
-                                  ReparentNotify, &ev))
-    {
-        /* This check makes sure we don't catch our own reparent action to
-           our frame window. This doesn't count as the app reparenting itself
-           away of course.
-
-           Reparent events that are generated by us are just discarded here.
-           They are of no consequence to us anyhow.
-        */
-        if (ev.xreparent.parent != self->plate) {
-            reparent = FALSE;
-            XPutBackEvent(ob_display, &ev);
-            break;
-        }
-    }
-
-    if (reparent) {
+    if (!xqueue_exists_local(find_reparent, self)) {

         /* according to the ICCCM - if the client doesn't reparent itself,
            then we will reparent the window to root for them */
         /* according to the ICCCM - if the client doesn't reparent itself,
            then we will reparent the window to root for them */

-        XReparentWindow(ob_display, self->client->window,
-                        RootWindow(ob_display, ob_screen),
-                        self->client->area.x,
-                        self->client->area.y);
+        XReparentWindow(obt_display, self->client->window, obt_root(ob_screen),
+                        self->client->area.x, self->client->area.y);

     }
 
     /* remove all the windows for the frame from the window_map */
     }
 
     /* remove all the windows for the frame from the window_map */

-    g_hash_table_remove(window_map, &self->window);
-    g_hash_table_remove(window_map, &self->plate);
-    g_hash_table_remove(window_map, &self->inner);
-    g_hash_table_remove(window_map, &self->title);
-    g_hash_table_remove(window_map, &self->label);
-    g_hash_table_remove(window_map, &self->max);
-    g_hash_table_remove(window_map, &self->close);
-    g_hash_table_remove(window_map, &self->desk);
-    g_hash_table_remove(window_map, &self->shade);
-    g_hash_table_remove(window_map, &self->icon);
-    g_hash_table_remove(window_map, &self->iconify);
-    g_hash_table_remove(window_map, &self->handle);
-    g_hash_table_remove(window_map, &self->lgrip);
-    g_hash_table_remove(window_map, &self->rgrip);
-    g_hash_table_remove(window_map, &self->tltresize);
-    g_hash_table_remove(window_map, &self->tllresize);
-    g_hash_table_remove(window_map, &self->trtresize);
-    g_hash_table_remove(window_map, &self->trrresize);
-
-    ob_main_loop_timeout_remove_data(ob_main_loop, flash_timeout, self, TRUE);
+    window_remove(self->window);
+    window_remove(self->backback);
+    window_remove(self->backfront);
+    window_remove(self->innerleft);
+    window_remove(self->innertop);
+    window_remove(self->innerright);
+    window_remove(self->innerbottom);
+    window_remove(self->innerblb);
+    window_remove(self->innerbll);
+    window_remove(self->innerbrb);
+    window_remove(self->innerbrr);
+    window_remove(self->title);
+    window_remove(self->label);
+    window_remove(self->max);
+    window_remove(self->close);
+    window_remove(self->desk);
+    window_remove(self->shade);
+    window_remove(self->icon);
+    window_remove(self->iconify);
+    window_remove(self->handle);
+    window_remove(self->lgrip);
+    window_remove(self->rgrip);
+    window_remove(self->topresize);
+    window_remove(self->tltresize);
+    window_remove(self->tllresize);
+    window_remove(self->trtresize);
+    window_remove(self->trrresize);
+    window_remove(self->left);
+    window_remove(self->right);
+    window_remove(self->titleleft);
+    window_remove(self->titletop);
+    window_remove(self->titletopleft);
+    window_remove(self->titletopright);
+    window_remove(self->titleright);
+    window_remove(self->titlebottom);
+    window_remove(self->handleleft);
+    window_remove(self->handletop);
+    window_remove(self->handleright);
+    window_remove(self->handlebottom);
+    window_remove(self->lgripleft);
+    window_remove(self->lgriptop);
+    window_remove(self->lgripbottom);
+    window_remove(self->rgripright);
+    window_remove(self->rgriptop);
+    window_remove(self->rgripbottom);
+
+    if (self->flash_timer) g_source_remove(self->flash_timer);

 }
 
 /* is there anything present between us and the label? */
 }
 
 /* is there anything present between us and the label? */


@@ -680,16 +1156,38 @@ static gboolean is_button_present(ObFrame *self, const gchar *lc, gint dir) {
     return FALSE;
 }
 
     return FALSE;
 }
 

+static void place_button(ObFrame *self, const char *lc, gint bwidth,
+                         gint left, gint i,
+                         gint *x, gint *button_on, gint *button_x)
+{
+  if (!(*button_on = is_button_present(self, lc, i)))
+    return;
+
+  self->label_width -= bwidth;
+  if (i > 0)
+    *button_x = *x;
+  *x += i * bwidth;
+  if (i < 0) {
+    if (self->label_x <= left || *x > self->label_x) {
+      *button_x = *x;
+    } else {
+      /* the button would have been drawn on top of another button */
+      *button_on = FALSE;
+      self->label_width += bwidth;
+    }
+  }
+}
+

 static void layout_title(ObFrame *self)
 {
     gchar *lc;
     gint i;
 
     const gint bwidth = ob_rr_theme->button_size + ob_rr_theme->paddingx + 1;
 static void layout_title(ObFrame *self)
 {
     gchar *lc;
     gint i;
 
     const gint bwidth = ob_rr_theme->button_size + ob_rr_theme->paddingx + 1;

-    /* position of the left most button */
+    /* position of the leftmost button */

     const gint left = ob_rr_theme->paddingx + 1;
     const gint left = ob_rr_theme->paddingx + 1;

-    /* position of the right most button */
-    const gint right = self->width - bwidth;
+    /* position of the rightmost button */
+    const gint right = self->width;

 
     /* turn them all off */
     self->icon_on = self->desk_on = self->shade_on = self->iconify_on =
 
     /* turn them all off */
     self->icon_on = self->desk_on = self->shade_on = self->iconify_on =


@@ -697,7 +1195,7 @@ static void layout_title(ObFrame *self)
     self->label_width = self->width - (ob_rr_theme->paddingx + 1) * 2;
     self->leftmost = self->rightmost = OB_FRAME_CONTEXT_NONE;
 
     self->label_width = self->width - (ob_rr_theme->paddingx + 1) * 2;
     self->leftmost = self->rightmost = OB_FRAME_CONTEXT_NONE;
 

-    /* figure out what's being show, find each element's position, and the
+    /* figure out what's being shown, find each element's position, and the

        width of the label
 
        do the ones before the label, then after the label,
        width of the label
 
        do the ones before the label, then after the label,


@@ -727,47 +1225,23 @@ static void layout_title(ObFrame *self)
                 break; /* break the for loop, do other side of label */
             } else if (*lc == 'N') {
                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_ICON;
                 break; /* break the for loop, do other side of label */
             } else if (*lc == 'N') {
                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_ICON;

-                if ((self->icon_on = is_button_present(self, lc, i))) {
-                    /* icon gets extra padding */
-                    self->label_width -= bwidth + 2;
-                    self->icon_x = x + (i * 1);
-                    x += i * (bwidth + 2);
-                }
+                /* icon is bigger than buttons */
+                place_button(self, lc, bwidth + 2, left, i, &x, &self->icon_on, &self->icon_x);

             } else if (*lc == 'D') {
                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_ALLDESKTOPS;
             } else if (*lc == 'D') {
                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_ALLDESKTOPS;

-                if ((self->desk_on = is_button_present(self, lc, i))) {
-                    self->label_width -= bwidth;
-                    self->desk_x = x;
-                    x += i * bwidth;
-                }
+                place_button(self, lc, bwidth, left, i, &x, &self->desk_on, &self->desk_x);

             } else if (*lc == 'S') {
                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_SHADE;
             } else if (*lc == 'S') {
                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_SHADE;

-                if ((self->shade_on = is_button_present(self, lc, i))) {
-                    self->label_width -= bwidth;
-                    self->shade_x = x;
-                    x += i * bwidth;
-                }
+                place_button(self, lc, bwidth, left, i, &x, &self->shade_on, &self->shade_x);

             } else if (*lc == 'I') {
                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_ICONIFY;
             } else if (*lc == 'I') {
                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_ICONIFY;

-                if ((self->iconify_on = is_button_present(self, lc, i))) {
-                    self->label_width -= bwidth;
-                    self->iconify_x = x;
-                    x += i * bwidth;
-                }
+                place_button(self, lc, bwidth, left, i, &x, &self->iconify_on, &self->iconify_x);

             } else if (*lc == 'M') {
                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_MAXIMIZE;
             } else if (*lc == 'M') {
                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_MAXIMIZE;

-                if ((self->max_on = is_button_present(self, lc, i))) {
-                    self->label_width -= bwidth;
-                    self->max_x = x;
-                    x += i * bwidth;
-                }
+                place_button(self, lc, bwidth, left, i, &x, &self->max_on, &self->max_x);

             } else if (*lc == 'C') {
                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_CLOSE;
             } else if (*lc == 'C') {
                 if (firstcon) *firstcon = OB_FRAME_CONTEXT_CLOSE;

-                if ((self->close_on = is_button_present(self, lc, i))) {
-                    self->label_width -= bwidth;
-                    self->close_x = x;
-                    x += i * bwidth;
-                }
+                place_button(self, lc, bwidth, left, i, &x, &self->close_on, &self->close_x);

             } else
                 continue; /* don't set firstcon */
             firstcon = NULL;
             } else
                 continue; /* don't set firstcon */
             firstcon = NULL;


@@ -776,66 +1250,109 @@ static void layout_title(ObFrame *self)
 
     /* position and map the elements */
     if (self->icon_on) {
 
     /* position and map the elements */
     if (self->icon_on) {

-        XMapWindow(ob_display, self->icon);
-        XMoveWindow(ob_display, self->icon, self->icon_x,
+        XMapWindow(obt_display, self->icon);
+        XMoveWindow(obt_display, self->icon, self->icon_x,

                     ob_rr_theme->paddingy);
     } else
                     ob_rr_theme->paddingy);
     } else

-        XUnmapWindow(ob_display, self->icon);
+        XUnmapWindow(obt_display, self->icon);

 
     if (self->desk_on) {
 
     if (self->desk_on) {

-        XMapWindow(ob_display, self->desk);
-        XMoveWindow(ob_display, self->desk, self->desk_x,
+        XMapWindow(obt_display, self->desk);
+        XMoveWindow(obt_display, self->desk, self->desk_x,

                     ob_rr_theme->paddingy + 1);
     } else
                     ob_rr_theme->paddingy + 1);
     } else

-        XUnmapWindow(ob_display, self->desk);
+        XUnmapWindow(obt_display, self->desk);

 
     if (self->shade_on) {
 
     if (self->shade_on) {

-        XMapWindow(ob_display, self->shade);
-        XMoveWindow(ob_display, self->shade, self->shade_x,
+        XMapWindow(obt_display, self->shade);
+        XMoveWindow(obt_display, self->shade, self->shade_x,

                     ob_rr_theme->paddingy + 1);
     } else
                     ob_rr_theme->paddingy + 1);
     } else

-        XUnmapWindow(ob_display, self->shade);
+        XUnmapWindow(obt_display, self->shade);

 
     if (self->iconify_on) {
 
     if (self->iconify_on) {

-        XMapWindow(ob_display, self->iconify);
-        XMoveWindow(ob_display, self->iconify, self->iconify_x,
+        XMapWindow(obt_display, self->iconify);
+        XMoveWindow(obt_display, self->iconify, self->iconify_x,

                     ob_rr_theme->paddingy + 1);
     } else
                     ob_rr_theme->paddingy + 1);
     } else

-        XUnmapWindow(ob_display, self->iconify);
+        XUnmapWindow(obt_display, self->iconify);

 
     if (self->max_on) {
 
     if (self->max_on) {

-        XMapWindow(ob_display, self->max);
-        XMoveWindow(ob_display, self->max, self->max_x,
+        XMapWindow(obt_display, self->max);
+        XMoveWindow(obt_display, self->max, self->max_x,

                     ob_rr_theme->paddingy + 1);
     } else
                     ob_rr_theme->paddingy + 1);
     } else

-        XUnmapWindow(ob_display, self->max);
+        XUnmapWindow(obt_display, self->max);

 
     if (self->close_on) {
 
     if (self->close_on) {

-        XMapWindow(ob_display, self->close);
-        XMoveWindow(ob_display, self->close, self->close_x,
+        XMapWindow(obt_display, self->close);
+        XMoveWindow(obt_display, self->close, self->close_x,

                     ob_rr_theme->paddingy + 1);
     } else
                     ob_rr_theme->paddingy + 1);
     } else

-        XUnmapWindow(ob_display, self->close);
+        XUnmapWindow(obt_display, self->close);

 
 

-    if (self->label_on) {
-        self->label_width = MAX(1, self->label_width); /* no lower than 1 */
-        XMapWindow(ob_display, self->label);
-        XMoveWindow(ob_display, self->label, self->label_x,
+    if (self->label_on && self->label_width > 0) {
+        XMapWindow(obt_display, self->label);
+        XMoveWindow(obt_display, self->label, self->label_x,

                     ob_rr_theme->paddingy);
     } else
                     ob_rr_theme->paddingy);
     } else

-        XUnmapWindow(ob_display, self->label);
+        XUnmapWindow(obt_display, self->label);
+}
+
+gboolean frame_next_context_from_string(gchar *names, ObFrameContext *cx)
+{
+    gchar *p, *n;
+
+    if (!*names) /* empty string */
+        return FALSE;
+
+    /* find the first space */
+    for (p = names; *p; p = g_utf8_next_char(p)) {
+        const gunichar c = g_utf8_get_char(p);
+        if (g_unichar_isspace(c)) break;
+    }
+
+    if (p == names) {
+        /* leading spaces in the string */
+        n = g_utf8_next_char(names);
+        if (!frame_next_context_from_string(n, cx))
+            return FALSE;
+    } else {
+        n = p;
+        if (*p) {
+            /* delete the space with null zero(s) */
+            while (n < g_utf8_next_char(p))
+                *(n++) = '\0';
+        }
+
+        *cx = frame_context_from_string(names);
+
+        /* find the next non-space */
+        for (; *n; n = g_utf8_next_char(n)) {
+            const gunichar c = g_utf8_get_char(n);
+            if (!g_unichar_isspace(c)) break;
+        }
+    }
+
+    /* delete everything we just read (copy everything at n to the start of
+       the string */
+    for (p = names; *n; ++p, ++n)
+        *p = *n;
+    *p = *n;
+
+    return TRUE;

 }
 
 ObFrameContext frame_context_from_string(const gchar *name)
 {
     if (!g_ascii_strcasecmp("Desktop", name))
         return OB_FRAME_CONTEXT_DESKTOP;
 }
 
 ObFrameContext frame_context_from_string(const gchar *name)
 {
     if (!g_ascii_strcasecmp("Desktop", name))
         return OB_FRAME_CONTEXT_DESKTOP;

+    else if (!g_ascii_strcasecmp("Root", name))
+        return OB_FRAME_CONTEXT_ROOT;

     else if (!g_ascii_strcasecmp("Client", name))
         return OB_FRAME_CONTEXT_CLIENT;
     else if (!g_ascii_strcasecmp("Titlebar", name))
         return OB_FRAME_CONTEXT_TITLEBAR;
     else if (!g_ascii_strcasecmp("Client", name))
         return OB_FRAME_CONTEXT_CLIENT;
     else if (!g_ascii_strcasecmp("Titlebar", name))
         return OB_FRAME_CONTEXT_TITLEBAR;

-    else if (!g_ascii_strcasecmp("Handle", name))
-        return OB_FRAME_CONTEXT_HANDLE;

     else if (!g_ascii_strcasecmp("Frame", name))
         return OB_FRAME_CONTEXT_FRAME;
     else if (!g_ascii_strcasecmp("TLCorner", name))
     else if (!g_ascii_strcasecmp("Frame", name))
         return OB_FRAME_CONTEXT_FRAME;
     else if (!g_ascii_strcasecmp("TLCorner", name))


@@ -846,6 +1363,14 @@ ObFrameContext frame_context_from_string(const gchar *name)
         return OB_FRAME_CONTEXT_BLCORNER;
     else if (!g_ascii_strcasecmp("BRCorner", name))
         return OB_FRAME_CONTEXT_BRCORNER;
         return OB_FRAME_CONTEXT_BLCORNER;
     else if (!g_ascii_strcasecmp("BRCorner", name))
         return OB_FRAME_CONTEXT_BRCORNER;

+    else if (!g_ascii_strcasecmp("Top", name))
+        return OB_FRAME_CONTEXT_TOP;
+    else if (!g_ascii_strcasecmp("Bottom", name))
+        return OB_FRAME_CONTEXT_BOTTOM;
+    else if (!g_ascii_strcasecmp("Left", name))
+        return OB_FRAME_CONTEXT_LEFT;
+    else if (!g_ascii_strcasecmp("Right", name))
+        return OB_FRAME_CONTEXT_RIGHT;

     else if (!g_ascii_strcasecmp("Maximize", name))
         return OB_FRAME_CONTEXT_MAXIMIZE;
     else if (!g_ascii_strcasecmp("AllDesktops", name))
     else if (!g_ascii_strcasecmp("Maximize", name))
         return OB_FRAME_CONTEXT_MAXIMIZE;
     else if (!g_ascii_strcasecmp("AllDesktops", name))


@@ -860,18 +1385,27 @@ ObFrameContext frame_context_from_string(const gchar *name)
         return OB_FRAME_CONTEXT_CLOSE;
     else if (!g_ascii_strcasecmp("MoveResize", name))
         return OB_FRAME_CONTEXT_MOVE_RESIZE;
         return OB_FRAME_CONTEXT_CLOSE;
     else if (!g_ascii_strcasecmp("MoveResize", name))
         return OB_FRAME_CONTEXT_MOVE_RESIZE;

+    else if (!g_ascii_strcasecmp("Dock", name))
+        return OB_FRAME_CONTEXT_DOCK;
+

     return OB_FRAME_CONTEXT_NONE;
 }
 
 ObFrameContext frame_context(ObClient *client, Window win, gint x, gint y)
 {
     ObFrame *self;
     return OB_FRAME_CONTEXT_NONE;
 }
 
 ObFrameContext frame_context(ObClient *client, Window win, gint x, gint y)
 {
     ObFrame *self;

+    ObWindow *obwin;

 
     if (moveresize_in_progress)
         return OB_FRAME_CONTEXT_MOVE_RESIZE;
 
 
     if (moveresize_in_progress)
         return OB_FRAME_CONTEXT_MOVE_RESIZE;
 

-    if (win == RootWindow(ob_display, ob_screen))
-        return OB_FRAME_CONTEXT_DESKTOP;
+    if (win == obt_root(ob_screen))
+        return OB_FRAME_CONTEXT_ROOT;
+    if ((obwin = window_find(win))) {
+        if (WINDOW_IS_DOCK(obwin)) {
+          return OB_FRAME_CONTEXT_DOCK;
+        }
+    }

     if (client == NULL) return OB_FRAME_CONTEXT_NONE;
     if (win == client->window) {
         /* conceptually, this is the desktop, as far as users are
     if (client == NULL) return OB_FRAME_CONTEXT_NONE;
     if (win == client->window) {
         /* conceptually, this is the desktop, as far as users are


@@ -882,57 +1416,118 @@ ObFrameContext frame_context(ObClient *client, Window win, gint x, gint y)
     }
 
     self = client->frame;
     }
 
     self = client->frame;

-    if (win == self->inner || win == self->plate) {
-        /* conceptually, this is the desktop, as far as users are
-           concerned */
-        if (client->type == OB_CLIENT_TYPE_DESKTOP)
-            return OB_FRAME_CONTEXT_DESKTOP;
-        return OB_FRAME_CONTEXT_CLIENT;
-    }

 
 

-    if (win == self->title) {
-        /* when the user clicks in the corners of the titlebar and the client
-           is fully maximized, then treat it like they clicked in the
-           button that is there */
-        if (self->client->max_horz && self->client->max_vert &&
-            y < ob_rr_theme->paddingy + 1 + ob_rr_theme->button_size)
+    /* when the user clicks in the corners of the titlebar and the client
+       is fully maximized, then treat it like they clicked in the
+       button that is there */
+    if (self->max_horz && self->max_vert &&
+        (win == self->title || win == self->titletop ||
+         win == self->titleleft || win == self->titletopleft ||
+         win == self->titleright || win == self->titletopright))
+    {
+        /* get the mouse coords in reference to the whole frame */
+        gint fx = x;
+        gint fy = y;
+
+        /* these windows are down a border width from the top of the frame */
+        if (win == self->title ||
+            win == self->titleleft || win == self->titleright)
+            fy += self->bwidth;
+
+        /* title is a border width in from the edge */
+        if (win == self->title)
+            fx += self->bwidth;
+        /* titletop is a bit to the right */
+        else if (win == self->titletop)
+            fx += ob_rr_theme->grip_width + self->bwidth;
+        /* titletopright is way to the right edge */
+        else if (win == self->titletopright)
+            fx += self->area.width - (ob_rr_theme->grip_width + self->bwidth);
+        /* titleright is even more way to the right edge */
+        else if (win == self->titleright)
+            fx += self->area.width - self->bwidth;
+
+        /* figure out if we're over the area that should be considered a
+           button */
+        if (fy < self->bwidth + ob_rr_theme->paddingy + 1 +
+            ob_rr_theme->button_size)

         {
         {

-            if (x < ((ob_rr_theme->paddingx + 1) * 2 +
-                     ob_rr_theme->button_size)) {
+            if (fx < (self->bwidth + ob_rr_theme->paddingx + 1 +
+                      ob_rr_theme->button_size))
+            {

                 if (self->leftmost != OB_FRAME_CONTEXT_NONE)
                     return self->leftmost;
             }
                 if (self->leftmost != OB_FRAME_CONTEXT_NONE)
                     return self->leftmost;
             }

-            else if (x > (self->width -
-                          (ob_rr_theme->paddingx + 1 +
-                           ob_rr_theme->button_size)))
+            else if (fx >= (self->area.width -
+                            (self->bwidth + ob_rr_theme->paddingx + 1 +
+                             ob_rr_theme->button_size)))

             {
                 if (self->rightmost != OB_FRAME_CONTEXT_NONE)
                     return self->rightmost;
             }
         }
             {
                 if (self->rightmost != OB_FRAME_CONTEXT_NONE)
                     return self->rightmost;
             }
         }

+
+        /* there is no resizing maximized windows so make them the titlebar
+           context */

         return OB_FRAME_CONTEXT_TITLEBAR;
     }
         return OB_FRAME_CONTEXT_TITLEBAR;
     }

+    else if (self->max_vert &&
+             (win == self->titletop || win == self->topresize))
+        /* can't resize vertically when max vert */
+        return OB_FRAME_CONTEXT_TITLEBAR;
+    else if (self->shaded &&
+             (win == self->titletop || win == self->topresize))
+        /* can't resize vertically when shaded */
+        return OB_FRAME_CONTEXT_TITLEBAR;

 
 

-    if (win == self->window)    return OB_FRAME_CONTEXT_FRAME;
-    if (win == self->label)     return OB_FRAME_CONTEXT_TITLEBAR;
-    if (win == self->handle)    return OB_FRAME_CONTEXT_HANDLE;
-    if (win == self->lgrip)     return OB_FRAME_CONTEXT_BLCORNER;
-    if (win == self->rgrip)     return OB_FRAME_CONTEXT_BRCORNER;
-    if (win == self->tltresize) return OB_FRAME_CONTEXT_TLCORNER;
-    if (win == self->tllresize) return OB_FRAME_CONTEXT_TLCORNER;
-    if (win == self->trtresize) return OB_FRAME_CONTEXT_TRCORNER;
-    if (win == self->trrresize) return OB_FRAME_CONTEXT_TRCORNER;
-    if (win == self->max)       return OB_FRAME_CONTEXT_MAXIMIZE;
-    if (win == self->iconify)   return OB_FRAME_CONTEXT_ICONIFY;
-    if (win == self->close)     return OB_FRAME_CONTEXT_CLOSE;
-    if (win == self->icon)      return OB_FRAME_CONTEXT_ICON;
-    if (win == self->desk)      return OB_FRAME_CONTEXT_ALLDESKTOPS;
-    if (win == self->shade)     return OB_FRAME_CONTEXT_SHADE;
+    if (win == self->window)            return OB_FRAME_CONTEXT_FRAME;
+    if (win == self->label)             return OB_FRAME_CONTEXT_TITLEBAR;
+    if (win == self->handle)            return OB_FRAME_CONTEXT_BOTTOM;
+    if (win == self->handletop)         return OB_FRAME_CONTEXT_BOTTOM;
+    if (win == self->handlebottom)      return OB_FRAME_CONTEXT_BOTTOM;
+    if (win == self->handleleft)        return OB_FRAME_CONTEXT_BLCORNER;
+    if (win == self->lgrip)             return OB_FRAME_CONTEXT_BLCORNER;
+    if (win == self->lgripleft)         return OB_FRAME_CONTEXT_BLCORNER;
+    if (win == self->lgriptop)          return OB_FRAME_CONTEXT_BLCORNER;
+    if (win == self->lgripbottom)       return OB_FRAME_CONTEXT_BLCORNER;
+    if (win == self->handleright)       return OB_FRAME_CONTEXT_BRCORNER;
+    if (win == self->rgrip)             return OB_FRAME_CONTEXT_BRCORNER;
+    if (win == self->rgripright)        return OB_FRAME_CONTEXT_BRCORNER;
+    if (win == self->rgriptop)          return OB_FRAME_CONTEXT_BRCORNER;
+    if (win == self->rgripbottom)       return OB_FRAME_CONTEXT_BRCORNER;
+    if (win == self->title)             return OB_FRAME_CONTEXT_TITLEBAR;
+    if (win == self->titlebottom)       return OB_FRAME_CONTEXT_TITLEBAR;
+    if (win == self->titleleft)         return OB_FRAME_CONTEXT_TLCORNER;
+    if (win == self->titletopleft)      return OB_FRAME_CONTEXT_TLCORNER;
+    if (win == self->titleright)        return OB_FRAME_CONTEXT_TRCORNER;
+    if (win == self->titletopright)     return OB_FRAME_CONTEXT_TRCORNER;
+    if (win == self->titletop)          return OB_FRAME_CONTEXT_TOP;
+    if (win == self->topresize)         return OB_FRAME_CONTEXT_TOP;
+    if (win == self->tltresize)         return OB_FRAME_CONTEXT_TLCORNER;
+    if (win == self->tllresize)         return OB_FRAME_CONTEXT_TLCORNER;
+    if (win == self->trtresize)         return OB_FRAME_CONTEXT_TRCORNER;
+    if (win == self->trrresize)         return OB_FRAME_CONTEXT_TRCORNER;
+    if (win == self->left)              return OB_FRAME_CONTEXT_LEFT;
+    if (win == self->right)             return OB_FRAME_CONTEXT_RIGHT;
+    if (win == self->innertop)          return OB_FRAME_CONTEXT_TITLEBAR;
+    if (win == self->innerleft)         return OB_FRAME_CONTEXT_LEFT;
+    if (win == self->innerbottom)       return OB_FRAME_CONTEXT_BOTTOM;
+    if (win == self->innerright)        return OB_FRAME_CONTEXT_RIGHT;
+    if (win == self->innerbll)          return OB_FRAME_CONTEXT_BLCORNER;
+    if (win == self->innerblb)          return OB_FRAME_CONTEXT_BLCORNER;
+    if (win == self->innerbrr)          return OB_FRAME_CONTEXT_BRCORNER;
+    if (win == self->innerbrb)          return OB_FRAME_CONTEXT_BRCORNER;
+    if (win == self->max)               return OB_FRAME_CONTEXT_MAXIMIZE;
+    if (win == self->iconify)           return OB_FRAME_CONTEXT_ICONIFY;
+    if (win == self->close)             return OB_FRAME_CONTEXT_CLOSE;
+    if (win == self->icon)              return OB_FRAME_CONTEXT_ICON;
+    if (win == self->desk)              return OB_FRAME_CONTEXT_ALLDESKTOPS;
+    if (win == self->shade)             return OB_FRAME_CONTEXT_SHADE;

 
     return OB_FRAME_CONTEXT_NONE;
 }
 
 
     return OB_FRAME_CONTEXT_NONE;
 }
 

-void frame_client_gravity(ObFrame *self, gint *x, gint *y, gint w, gint h)
+void frame_client_gravity(ObFrame *self, gint *x, gint *y)

 {
     /* horizontal */
     switch (self->client->gravity) {
 {
     /* horizontal */
     switch (self->client->gravity) {


@@ -945,18 +1540,22 @@ void frame_client_gravity(ObFrame *self, gint *x, gint *y, gint w, gint h)
     case NorthGravity:
     case SouthGravity:
     case CenterGravity:
     case NorthGravity:
     case SouthGravity:
     case CenterGravity:

-        *x -= (self->size.left + w) / 2;
+        /* the middle of the client will be the middle of the frame */
+        *x -= (self->size.right - self->size.left) / 2;

         break;
 
     case NorthEastGravity:
     case SouthEastGravity:
     case EastGravity:
         break;
 
     case NorthEastGravity:
     case SouthEastGravity:
     case EastGravity:

-        *x -= (self->size.left + self->size.right + w) - 1;
+        /* the right side of the client will be the right side of the frame */
+        *x -= self->size.right + self->size.left -
+            self->client->border_width * 2;

         break;
 
     case ForgetGravity:
     case StaticGravity:
         break;
 
     case ForgetGravity:
     case StaticGravity:

-        *x -= self->size.left;
+        /* the client's position won't move */
+        *x -= self->size.left - self->client->border_width;

         break;
     }
 
         break;
     }
 


@@ -971,23 +1570,27 @@ void frame_client_gravity(ObFrame *self, gint *x, gint *y, gint w, gint h)
     case CenterGravity:
     case EastGravity:
     case WestGravity:
     case CenterGravity:
     case EastGravity:
     case WestGravity:

-        *y -= (self->size.top + h) / 2;
+        /* the middle of the client will be the middle of the frame */
+        *y -= (self->size.bottom - self->size.top) / 2;

         break;
 
     case SouthWestGravity:
     case SouthEastGravity:
     case SouthGravity:
         break;
 
     case SouthWestGravity:
     case SouthEastGravity:
     case SouthGravity:

-        *y -= (self->size.top + self->size.bottom + h) - 1;
+        /* the bottom of the client will be the bottom of the frame */
+        *y -= self->size.bottom + self->size.top -
+            self->client->border_width * 2;

         break;
 
     case ForgetGravity:
     case StaticGravity:
         break;
 
     case ForgetGravity:
     case StaticGravity:

-        *y -= self->size.top;
+        /* the client's position won't move */
+        *y -= self->size.top - self->client->border_width;

         break;
     }
 }
 
         break;
     }
 }
 

-void frame_frame_gravity(ObFrame *self, gint *x, gint *y, gint w, gint h)
+void frame_frame_gravity(ObFrame *self, gint *x, gint *y)

 {
     /* horizontal */
     switch (self->client->gravity) {
 {
     /* horizontal */
     switch (self->client->gravity) {


@@ -999,16 +1602,20 @@ void frame_frame_gravity(ObFrame *self, gint *x, gint *y, gint w, gint h)
     case NorthGravity:
     case CenterGravity:
     case SouthGravity:
     case NorthGravity:
     case CenterGravity:
     case SouthGravity:

-        *x += (self->size.left + w) / 2;
+        /* the middle of the client will be the middle of the frame */
+        *x += (self->size.right - self->size.left) / 2;

         break;
     case NorthEastGravity:
     case EastGravity:
     case SouthEastGravity:
         break;
     case NorthEastGravity:
     case EastGravity:
     case SouthEastGravity:

-        *x += (self->size.left + self->size.right + w) - 1;
+        /* the right side of the client will be the right side of the frame */
+        *x += self->size.right + self->size.left -
+            self->client->border_width * 2;

         break;
     case StaticGravity:
     case ForgetGravity:
         break;
     case StaticGravity:
     case ForgetGravity:

-        *x += self->size.left;
+        /* the client's position won't move */
+        *x += self->size.left - self->client->border_width;

         break;
     }
 
         break;
     }
 


@@ -1022,20 +1629,38 @@ void frame_frame_gravity(ObFrame *self, gint *x, gint *y, gint w, gint h)
     case WestGravity:
     case CenterGravity:
     case EastGravity:
     case WestGravity:
     case CenterGravity:
     case EastGravity:

-        *y += (self->size.top + h) / 2;
+        /* the middle of the client will be the middle of the frame */
+        *y += (self->size.bottom - self->size.top) / 2;

         break;
     case SouthWestGravity:
     case SouthGravity:
     case SouthEastGravity:
         break;
     case SouthWestGravity:
     case SouthGravity:
     case SouthEastGravity:

-        *y += (self->size.top + self->size.bottom + h) - 1;
+        /* the bottom of the client will be the bottom of the frame */
+        *y += self->size.bottom + self->size.top -
+            self->client->border_width * 2;

         break;
     case StaticGravity:
     case ForgetGravity:
         break;
     case StaticGravity:
     case ForgetGravity:

-        *y += self->size.top;
+        /* the client's position won't move */
+        *y += self->size.top - self->client->border_width;

         break;
     }
 }
 
         break;
     }
 }
 

+void frame_rect_to_frame(ObFrame *self, Rect *r)
+{
+    r->width += self->size.left + self->size.right;
+    r->height += self->size.top + self->size.bottom;
+    frame_client_gravity(self, &r->x, &r->y);
+}
+
+void frame_rect_to_client(ObFrame *self, Rect *r)
+{
+    r->width -= self->size.left + self->size.right;
+    r->height -= self->size.top + self->size.bottom;
+    frame_frame_gravity(self, &r->x, &r->y);
+}
+

 static void flash_done(gpointer data)
 {
     ObFrame *self = data;
 static void flash_done(gpointer data)
 {
     ObFrame *self = data;


@@ -1049,11 +1674,13 @@ static gboolean flash_timeout(gpointer data)
     ObFrame *self = data;
     GTimeVal now;
 
     ObFrame *self = data;
     GTimeVal now;
 

-    g_get_current_time(&now);
-    if (now.tv_sec > self->flash_end.tv_sec ||
-        (now.tv_sec == self->flash_end.tv_sec &&
-         now.tv_usec >= self->flash_end.tv_usec))
-        self->flashing = FALSE;
+    if (config_frame_flash_duration != 0) {
+        g_get_current_time(&now);
+        if (now.tv_sec > self->flash_end.tv_sec ||
+            (now.tv_sec == self->flash_end.tv_sec &&
+             now.tv_usec >= self->flash_end.tv_usec))
+            self->flashing = FALSE;
+    }

 
     if (!self->flashing)
         return FALSE; /* we are done */
 
     if (!self->flashing)
         return FALSE; /* we are done */


@@ -1069,18 +1696,20 @@ static gboolean flash_timeout(gpointer data)
 
 void frame_flash_start(ObFrame *self)
 {
 
 void frame_flash_start(ObFrame *self)
 {

+    if (config_frame_flash_delay == 0) return;
+

     self->flash_on = self->focused;
 
     if (!self->flashing)
     self->flash_on = self->focused;
 
     if (!self->flashing)

-        ob_main_loop_timeout_add(ob_main_loop,
-                                 G_USEC_PER_SEC * 0.6,
-                                 flash_timeout,
-                                 self,
-                                 g_direct_equal,
-                                 flash_done);
-    g_get_current_time(&self->flash_end);
-    g_time_val_add(&self->flash_end, G_USEC_PER_SEC * 5);
-    
+        self->flash_timer = g_timeout_add_full(G_PRIORITY_DEFAULT,
+                                               config_frame_flash_delay, flash_timeout, self,
+                                               flash_done);
+
+    if (config_frame_flash_duration != 0) {
+        g_get_current_time(&self->flash_end);
+        g_time_val_add(&self->flash_end, 1000 * config_frame_flash_duration);
+    }
+

     self->flashing = TRUE;
 }
 
     self->flashing = TRUE;
 }
 


@@ -1114,7 +1743,9 @@ static gboolean frame_animate_iconify(gpointer p)
 
     if (self->client->icon_geometry.width == 0) {
         /* there is no icon geometry set so just go straight down */
 
     if (self->client->icon_geometry.width == 0) {
         /* there is no icon geometry set so just go straight down */

-        Rect *a = screen_physical_area();
+        const Rect *a;
+
+        a = screen_physical_area_monitor(screen_find_monitor(&self->area));

         iconx = self->area.x + self->area.width / 2 + 32;
         icony = a->y + a->width;
         iconw = 64;
         iconx = self->area.x + self->area.width / 2 + 32;
         icony = a->y + a->width;
         iconw = 64;


@@ -1129,19 +1760,19 @@ static gboolean frame_animate_iconify(gpointer p)
     /* how far do we have left to go ? */
     g_get_current_time(&now);
     time = frame_animate_iconify_time_left(self, &now);
     /* how far do we have left to go ? */
     g_get_current_time(&now);
     time = frame_animate_iconify_time_left(self, &now);

-    
-    if (time == 0 || iconifying) {
+
+    if ((time > 0 && iconifying) || (time == 0 && !iconifying)) {

         /* start where the frame is supposed to be */
         x = self->area.x;
         y = self->area.y;
         /* start where the frame is supposed to be */
         x = self->area.x;
         y = self->area.y;

-        w = self->area.width - self->bwidth * 2;
-        h = self->area.height - self->bwidth * 2;
+        w = self->area.width;
+        h = self->area.height;

     } else {
         /* start at the icon */
         x = iconx;
         y = icony;
         w = iconw;
     } else {
         /* start at the icon */
         x = iconx;
         y = icony;
         w = iconw;

-        h = self->innersize.top; /* just the titlebar */
+        h = self->size.top; /* just the titlebar */

     }
 
     if (time > 0) {
     }
 
     if (time > 0) {


@@ -1158,15 +1789,14 @@ static gboolean frame_animate_iconify(gpointer p)
         x = x - (dx * elapsed) / FRAME_ANIMATE_ICONIFY_TIME;
         y = y - (dy * elapsed) / FRAME_ANIMATE_ICONIFY_TIME;
         w = w - (dw * elapsed) / FRAME_ANIMATE_ICONIFY_TIME;
         x = x - (dx * elapsed) / FRAME_ANIMATE_ICONIFY_TIME;
         y = y - (dy * elapsed) / FRAME_ANIMATE_ICONIFY_TIME;
         w = w - (dw * elapsed) / FRAME_ANIMATE_ICONIFY_TIME;

-        h = self->innersize.top; /* just the titlebar */
+        h = self->size.top; /* just the titlebar */

     }
 
     }
 

+    XMoveResizeWindow(obt_display, self->window, x, y, w, h);
+    XFlush(obt_display);
+

     if (time == 0)
         frame_end_iconify_animation(self);
     if (time == 0)
         frame_end_iconify_animation(self);

-    else {
-        XMoveResizeWindow(ob_display, self->window, x, y, w, h);
-        XFlush(ob_display);
-    }

 
     return time > 0; /* repeat until we're out of time */
 }
 
     return time > 0; /* repeat until we're out of time */
 }


@@ -1177,16 +1807,25 @@ void frame_end_iconify_animation(ObFrame *self)
     if (self->iconify_animation_going == 0) return;
 
     if (!self->visible)
     if (self->iconify_animation_going == 0) return;
 
     if (!self->visible)

-        XUnmapWindow(ob_display, self->window);
+        XUnmapWindow(obt_display, self->window);
+    else {
+        /* Send a ConfigureNotify when the animation is done, this fixes
+           KDE's pager showing the window in the wrong place.  since the
+           window is mapped at a different location and is then moved, we
+           need to send the synthetic configurenotify, since apps may have
+           read the position when the client mapped, apparently. */
+        client_reconfigure(self->client, TRUE);
+    }

 
     /* we're not animating any more ! */
     self->iconify_animation_going = 0;
 
 
     /* we're not animating any more ! */
     self->iconify_animation_going = 0;
 

-    XMoveResizeWindow(ob_display, self->window,
+    XMoveResizeWindow(obt_display, self->window,

                       self->area.x, self->area.y,
                       self->area.x, self->area.y,

-                      self->area.width - self->bwidth * 2,
-                      self->area.height - self->bwidth * 2);
-    XFlush(ob_display);
+                      self->area.width, self->area.height);
+    /* we delay re-rendering until after we're done animating */
+    framerender_frame(self);
+    XFlush(obt_display);

 }
 
 void frame_begin_iconify_animation(ObFrame *self, gboolean iconifying)
 }
 
 void frame_begin_iconify_animation(ObFrame *self, gboolean iconifying)


@@ -1225,18 +1864,19 @@ void frame_begin_iconify_animation(ObFrame *self, gboolean iconifying)
     }
 
     if (new_anim) {
     }
 
     if (new_anim) {

-        ob_main_loop_timeout_remove_data(ob_main_loop, frame_animate_iconify,
-                                         self, FALSE);
-        ob_main_loop_timeout_add(ob_main_loop,
-                                 FRAME_ANIMATE_ICONIFY_STEP_TIME,
-                                 frame_animate_iconify, self,
-                                 g_direct_equal, NULL);
+        if (self->iconify_animation_timer)
+            g_source_remove(self->iconify_animation_timer);
+        self->iconify_animation_timer =
+            g_timeout_add_full(G_PRIORITY_DEFAULT,
+                               FRAME_ANIMATE_ICONIFY_STEP_TIME,
+                               frame_animate_iconify, self, NULL);
+                               

 
         /* do the first step */
         frame_animate_iconify(self);
 
         /* show it during the animation even if it is not "visible" */
         if (!self->visible)
 
         /* do the first step */
         frame_animate_iconify(self);
 
         /* show it during the animation even if it is not "visible" */
         if (!self->visible)

-            XMapWindow(ob_display, self->window);
+            XMapWindow(obt_display, self->window);

     }
 }
     }
 }