Merge branch 'backport' into work

[chaz/openbox] / openbox / frame.c

diff --git a/openbox/frame.c b/openbox/frame.c
index 9e176a5079cc6e28a7384dfcd5b464d1ba3df9bd..72eab32bff10c1198d5d595f5a3afb560c20ee17 100644 (file)
--- a/openbox/frame.c
+++ b/openbox/frame.c
@@ -20,17 +20,16 @@
 #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 "config.h"
 #include "framerender.h"
 #include "config.h"
 #include "framerender.h"

-#include "mainloop.h"

 #include "focus_cycle.h"
 #include "focus_cycle_indicator.h"
 #include "focus_cycle.h"
 #include "focus_cycle_indicator.h"

-#include "composite.h"

 #include "moveresize.h"
 #include "screen.h"
 #include "render/theme.h"
 #include "moveresize.h"
 #include "screen.h"
 #include "render/theme.h"

+#include "obt/display.h"
+#include "obt/prop.h"

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


@@ -51,19 +50,35 @@ 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_shape(ObFrame *self);

 static void frame_adjust_cursors(ObFrame *self);
 static void frame_adjust_cursors(ObFrame *self);

-static void frame_get_offscreen_buffer(ObFrame *self);
-static void frame_free_offscreen_buffer(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)
+{
+    XWindowAttributes wattrib;
+    Status ret;
+
+    /* 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);
+
+    if (wattrib.depth == 32)
+        return wattrib.visual;
+    return NULL;

 }
 
 ObFrame *frame_new(ObClient *client)
 }
 
 ObFrame *frame_new(ObClient *client)


@@ -71,43 +86,35 @@ ObFrame *frame_new(ObClient *client)
     XSetWindowAttributes attrib;
     gulong mask;
     ObFrame *self;
     XSetWindowAttributes attrib;
     gulong mask;
     ObFrame *self;

-    XWindowAttributes wattrib;
-    Status ret;
+    Visual *visual;

 
     self = g_new0(ObFrame, 1);
     self->client = client;
 
 
     self = g_new0(ObFrame, 1);
     self->client = client;
 

-    ret = XGetWindowAttributes(ob_display, client->window, &wattrib);
-    g_assert(ret != BadDrawable);
-    g_assert(ret != BadWindow);
-    self->has_alpha = composite_window_has_alpha(wattrib.visual);
+    visual = check_32bit_client(client);

 
     /* create the non-visible decor windows */
 
     mask = 0;
 
     /* create the non-visible decor windows */
 
     mask = 0;

-    if (self->has_alpha) {
-        /* the colormap/backpixel/borderpixel are required for supporting
-           windows with 32bit visuals */
+    if (visual) {
+        /* client has a 32-bit visual */

         mask = CWColormap | CWBackPixel | CWBorderPixel;
         /* create a colormap with the visual */
         self->colormap = attrib.colormap =
         mask = CWColormap | CWBackPixel | CWBorderPixel;
         /* create a colormap with the visual */
         self->colormap = attrib.colormap =

-            XCreateColormap(ob_display,
-                            RootWindow(ob_display, ob_screen),
-                            wattrib.visual, AllocNone);
-        attrib.background_pixel = BlackPixel(ob_display, ob_screen);
-        attrib.border_pixel = BlackPixel(ob_display, ob_screen);
+            XCreateColormap(obt_display, obt_root(ob_screen),
+                            visual, AllocNone);
+        attrib.background_pixel = BlackPixel(obt_display, ob_screen);
+        attrib.border_pixel = BlackPixel(obt_display, ob_screen);

     }
     }

-
-    self->window = createWindow(RootWindow(ob_display, ob_screen),
-                                (self->has_alpha ? wattrib.visual : NULL),
+    self->window = createWindow(obt_root(ob_screen), visual,

                                 mask, &attrib);
 
     /* create the visible decor windows */
 
     mask = 0;
                                 mask, &attrib);
 
     /* create the visible decor windows */
 
     mask = 0;

-    if (self->has_alpha) {
+    if (visual) {

         /* client has a 32-bit 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);
     }
 


@@ -121,6 +128,11 @@ ObFrame *frame_new(ObClient *client)
     self->innerright = createWindow(self->window, NULL, mask, &attrib);
     self->innerbottom = createWindow(self->window, NULL, mask, &attrib);
 
     self->innerright = createWindow(self->window, NULL, mask, &attrib);
     self->innerbottom = createWindow(self->window, NULL, mask, &attrib);
 

+    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->title = createWindow(self->window, NULL, mask, &attrib);
     self->titleleft = createWindow(self->window, NULL, mask, &attrib);
     self->titletop = createWindow(self->window, NULL, mask, &attrib);


@@ -148,7 +160,7 @@ ObFrame *frame_new(ObClient *client)
 
     self->handle = createWindow(self->window, NULL, mask, &attrib);
     self->lgrip = createWindow(self->handle, NULL, mask, &attrib);
 
     self->handle = createWindow(self->window, NULL, mask, &attrib);
     self->lgrip = createWindow(self->handle, NULL, mask, &attrib);

-    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->handleleft = createWindow(self->handle, NULL, mask, &attrib);
     self->handleright = createWindow(self->handle, NULL, mask, &attrib);


@@ -165,74 +177,56 @@ ObFrame *frame_new(ObClient *client)
     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->label);
-    XMapWindow(ob_display, self->backback);
-    XMapWindow(ob_display, self->backfront);
+    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;
 
     set_theme_statics(self);
 
         self->iconify_hover = self->shade_hover = FALSE;
 
     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 */

-    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);

-    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);
-    frame_free_offscreen_buffer(self);
+        XFreeColormap(obt_display, self->colormap);

 
     g_free(self);
 }
 
     g_free(self);
 }


@@ -242,10 +236,13 @@ void frame_show(ObFrame *self)
     if (!self->visible) {
         self->visible = TRUE;
         framerender_frame(self);
     if (!self->visible) {
         self->visible = TRUE;
         framerender_frame(self);

-        XMapWindow(ob_display, self->client->window);
-        XMapWindow(ob_display, self->window);
-
-        frame_get_offscreen_buffer(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);

     }
 }
 
     }
 }
 


@@ -254,11 +251,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;
     }
 }


@@ -269,25 +265,26 @@ 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];
 

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

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

-        XShapeCombineMask(ob_display, self->window, ShapeBounding,
+        XShapeCombineMask(obt_display, self->window, kind,

                           self->size.left,
                           self->size.top,
                           None, ShapeSet);
     } else {
         /* make the frame's shape match the clients */
                           self->size.left,
                           self->size.top,
                           None, ShapeSet);
     } else {
         /* make the frame's shape match the clients */

-        XShapeCombineShape(ob_display, self->window, ShapeBounding,
+        XShapeCombineShape(obt_display, self->window, kind,

                            self->size.left,
                            self->size.top,
                            self->client->window,
                            self->size.left,
                            self->size.top,
                            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) {


@@ -309,10 +306,18 @@ void frame_adjust_shape(ObFrame *self)
             ++num;
         }
 
             ++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);
+  frame_adjust_shape_kind(self, ShapeInput);

 #endif
 }
 
 #endif
 }
 


@@ -333,13 +338,14 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
         self->max_vert = self->client->max_vert;
         self->shaded = self->client->shaded;
 
         self->max_vert = self->client->max_vert;
         self->shaded = self->client->shaded;
 

-        if (self->decorations & OB_FRAME_DECOR_BORDER ||
-            (self->client->undecorated && config_theme_keepborder))
+        if (self->decorations & OB_FRAME_DECOR_BORDER)

             self->bwidth = ob_rr_theme->fbwidth;
         else
             self->bwidth = 0;
 
             self->bwidth = ob_rr_theme->fbwidth;
         else
             self->bwidth = 0;
 

-        if (self->decorations & OB_FRAME_DECOR_BORDER) {
+        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_r = ob_rr_theme->cbwidthx;
             self->cbwidth_t = self->cbwidth_b = ob_rr_theme->cbwidthy;
         } else


@@ -362,10 +368,11 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
 
         STRUT_SET(self->size,
                   self->cbwidth_l + (!self->max_horz ? self->bwidth : 0),
 
         STRUT_SET(self->size,
                   self->cbwidth_l + (!self->max_horz ? self->bwidth : 0),

-                  self->cbwidth_t + self->bwidth,
+                  self->cbwidth_t +
+                  (!self->max_horz || !self->max_vert ? self->bwidth : 0),

                   self->cbwidth_r + (!self->max_horz ? self->bwidth : 0),
                   self->cbwidth_r + (!self->max_horz ? self->bwidth : 0),

-                  self->cbwidth_b + (!self->max_horz || !self->max_vert ?
-                                     self->bwidth : 0));
+                  self->cbwidth_b +
+                  (!self->max_horz || !self->max_vert ? self->bwidth : 0));

 
         if (self->decorations & OB_FRAME_DECOR_TITLEBAR)
             self->size.top += ob_rr_theme->title_height + self->bwidth;
 
         if (self->decorations & OB_FRAME_DECOR_TITLEBAR)
             self->size.top += ob_rr_theme->title_height + self->bwidth;


@@ -374,53 +381,99 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
         {
             self->size.bottom += ob_rr_theme->handle_height + 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) {
             if (self->cbwidth_l) {

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

                                   self->size.left - self->cbwidth_l,
                                   self->size.top,
                                   self->cbwidth_l, self->client->area.height);
 
                                   self->size.left - self->cbwidth_l,
                                   self->size.top,
                                   self->cbwidth_l, self->client->area.height);
 

-                XMapWindow(ob_display, self->innerleft);
+                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
             } else

-                XUnmapWindow(ob_display, self->innerleft);
+                XUnmapWindow(obt_display, self->innerbll);

 
             if (self->cbwidth_r) {
 
             if (self->cbwidth_r) {

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

                                   self->size.left + self->client->area.width,
                                   self->size.top,
                                   self->cbwidth_r, self->client->area.height);
 
                                   self->size.left + self->client->area.width,
                                   self->size.top,
                                   self->cbwidth_r, self->client->area.height);
 

-                XMapWindow(ob_display, self->innerright);
+                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
             } else

-                XUnmapWindow(ob_display, self->innerright);
+                XUnmapWindow(obt_display, self->innerbrr);

 
             if (self->cbwidth_t) {
 
             if (self->cbwidth_t) {

-                XMoveResizeWindow(ob_display, self->innertop,
+                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);
 
                                   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(ob_display, self->innertop);
+                XMapWindow(obt_display, self->innertop);

             } else
             } else

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

 
             if (self->cbwidth_b) {
 
             if (self->cbwidth_b) {

-                XMoveResizeWindow(ob_display, self->innerbottom,
+                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);
 
                                   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);
 

-                XMapWindow(ob_display, self->innerbottom);
-            } else
-                XUnmapWindow(ob_display, self->innerbottom);
+                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;
 
             if (self->bwidth) {
                 gint titlesides;


@@ -428,16 +481,16 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
                 /* height of titleleft and titleright */
                 titlesides = (!self->max_horz ? ob_rr_theme->grip_width : 0);
 
                 /* height of titleleft and titleright */
                 titlesides = (!self->max_horz ? ob_rr_theme->grip_width : 0);
 

-                XMoveResizeWindow(ob_display, self->titletop,
+                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);
                                   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(ob_display, self->titletopleft,
+                XMoveResizeWindow(obt_display, self->titletopleft,

                                   0, 0,
                                   ob_rr_theme->grip_width + self->bwidth,
                                   self->bwidth);
                                   0, 0,
                                   ob_rr_theme->grip_width + self->bwidth,
                                   self->bwidth);

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

                                   self->client->area.width +
                                   self->size.left + self->size.right -
                                   ob_rr_theme->grip_width - self->bwidth,
                                   self->client->area.width +
                                   self->size.left + self->size.right -
                                   ob_rr_theme->grip_width - self->bwidth,


@@ -446,11 +499,11 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
                                   self->bwidth);
 
                 if (titlesides > 0) {
                                   self->bwidth);
 
                 if (titlesides > 0) {

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

                                       0, self->bwidth,
                                       self->bwidth,
                                       titlesides);
                                       0, self->bwidth,
                                       self->bwidth,
                                       titlesides);

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

                                       self->client->area.width +
                                       self->size.left + self->size.right -
                                       self->bwidth,
                                       self->client->area.width +
                                       self->size.left + self->size.right -
                                       self->bwidth,


@@ -458,73 +511,73 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
                                       self->bwidth,
                                       titlesides);
 
                                       self->bwidth,
                                       titlesides);
 

-                    XMapWindow(ob_display, self->titleleft);
-                    XMapWindow(ob_display, self->titleright);
+                    XMapWindow(obt_display, self->titleleft);
+                    XMapWindow(obt_display, self->titleright);

                 } else {
                 } else {

-                    XUnmapWindow(ob_display, self->titleleft);
-                    XUnmapWindow(ob_display, self->titleright);
+                    XUnmapWindow(obt_display, self->titleleft);
+                    XUnmapWindow(obt_display, self->titleright);

                 }
 
                 }
 

-                XMapWindow(ob_display, self->titletop);
-                XMapWindow(ob_display, self->titletopleft);
-                XMapWindow(ob_display, self->titletopright);
+                XMapWindow(obt_display, self->titletop);
+                XMapWindow(obt_display, self->titletopleft);
+                XMapWindow(obt_display, self->titletopright);

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

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

                                       (self->max_horz ? 0 : self->bwidth),
                                       ob_rr_theme->title_height + self->bwidth,
                                       self->width,
                                       self->bwidth);
 
                                       (self->max_horz ? 0 : self->bwidth),
                                       ob_rr_theme->title_height + self->bwidth,
                                       self->width,
                                       self->bwidth);
 

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

                 } else
                 } else

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

             } else {
             } else {

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

 
 

-                XUnmapWindow(ob_display, self->titletop);
-                XUnmapWindow(ob_display, self->titletopleft);
-                XUnmapWindow(ob_display, self->titletopright);
-                XUnmapWindow(ob_display, self->titleleft);
-                XUnmapWindow(ob_display, self->titleright);
+                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,
+                XMoveResizeWindow(obt_display, self->title,

                                   (self->max_horz ? 0 : self->bwidth),
                                   self->bwidth,
                                   self->width, ob_rr_theme->title_height);
 
                                   (self->max_horz ? 0 : self->bwidth),
                                   self->bwidth,
                                   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) {

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

                                       ob_rr_theme->grip_width,
                                       0,
                                       self->width - ob_rr_theme->grip_width *2,
                                       ob_rr_theme->paddingy + 1);
 
                                       ob_rr_theme->grip_width,
                                       0,
                                       self->width - ob_rr_theme->grip_width *2,
                                       ob_rr_theme->paddingy + 1);
 

-                    XMoveWindow(ob_display, self->tltresize, 0, 0);
-                    XMoveWindow(ob_display, self->tllresize, 0, 0);
-                    XMoveWindow(ob_display, self->trtresize,
+                    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->topresize);
-                    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->topresize);
-                    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))


@@ -535,7 +588,7 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
             gint sidebwidth = self->max_horz ? 0 : self->bwidth;
 
             if (self->bwidth && self->size.bottom) {
             gint sidebwidth = self->max_horz ? 0 : self->bwidth;
 
             if (self->bwidth && self->size.bottom) {

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

                                   ob_rr_theme->grip_width +
                                   self->bwidth + sidebwidth,
                                   self->size.top + self->client->area.height +
                                   ob_rr_theme->grip_width +
                                   self->bwidth + sidebwidth,
                                   self->size.top + self->client->area.height +


@@ -544,9 +597,9 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
                                                  sidebwidth) * 2,
                                   self->bwidth);
 
                                                  sidebwidth) * 2,
                                   self->bwidth);
 

-                
+

                 if (sidebwidth) {
                 if (sidebwidth) {

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

                                       0,
                                       self->size.top +
                                       self->client->area.height +
                                       0,
                                       self->size.top +
                                       self->client->area.height +


@@ -558,7 +611,7 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
                                       (!self->max_horz ?
                                        ob_rr_theme->grip_width :
                                        self->size.bottom - self->cbwidth_b));
                                       (!self->max_horz ?
                                        ob_rr_theme->grip_width :
                                        self->size.bottom - self->cbwidth_b));

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

                                   self->size.left +
                                       self->client->area.width +
                                       self->size.right - self->bwidth,
                                   self->size.left +
                                       self->client->area.width +
                                       self->size.right - self->bwidth,


@@ -573,51 +626,51 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
                                        ob_rr_theme->grip_width :
                                        self->size.bottom - self->cbwidth_b));
 
                                        ob_rr_theme->grip_width :
                                        self->size.bottom - self->cbwidth_b));
 

-                    XMapWindow(ob_display, self->lgripleft);
-                    XMapWindow(ob_display, self->rgripright);
+                    XMapWindow(obt_display, self->lgripleft);
+                    XMapWindow(obt_display, self->rgripright);

                 } else {
                 } else {

-                    XUnmapWindow(ob_display, self->lgripleft);
-                    XUnmapWindow(ob_display, self->rgripright);
+                    XUnmapWindow(obt_display, self->lgripleft);
+                    XUnmapWindow(obt_display, self->rgripright);

                 }
 
                 }
 

-                XMoveResizeWindow(ob_display, self->lgripbottom,
+                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);
                                   sidebwidth,
                                   self->size.top + self->client->area.height +
                                   self->size.bottom - self->bwidth,
                                   ob_rr_theme->grip_width + self->bwidth,
                                   self->bwidth);

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

                                   self->size.left + self->client->area.width +
                                   self->size.left + self->client->area.width +

-                                  self->size.right - self->bwidth - sidebwidth -
+                                  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);
 
                                   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(ob_display, self->handlebottom);
-                XMapWindow(ob_display, self->lgripbottom);
-                XMapWindow(ob_display, self->rgripbottom);
+                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)
                 {
 
                 if (self->decorations & OB_FRAME_DECOR_HANDLE &&
                     ob_rr_theme->handle_height > 0)
                 {

-                    XMoveResizeWindow(ob_display, self->handletop,
+                    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);
                                       ob_rr_theme->grip_width +
                                       self->bwidth + sidebwidth,
                                       FRAME_HANDLE_Y(self),
                                       self->width - (ob_rr_theme->grip_width +
                                                      sidebwidth) * 2,
                                       self->bwidth);

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

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

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

                                           ob_rr_theme->grip_width,
                                           0,
                                           self->bwidth,
                                           ob_rr_theme->handle_height);
                                           ob_rr_theme->grip_width,
                                           0,
                                           self->bwidth,
                                           ob_rr_theme->handle_height);

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

                                           self->width -
                                           ob_rr_theme->grip_width -
                                           self->bwidth,
                                           self->width -
                                           ob_rr_theme->grip_width -
                                           self->bwidth,


@@ -625,13 +678,13 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
                                           self->bwidth,
                                           ob_rr_theme->handle_height);
 
                                           self->bwidth,
                                           ob_rr_theme->handle_height);
 

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

                                           sidebwidth,
                                           FRAME_HANDLE_Y(self),
                                           ob_rr_theme->grip_width +
                                           self->bwidth,
                                           self->bwidth);
                                           sidebwidth,
                                           FRAME_HANDLE_Y(self),
                                           ob_rr_theme->grip_width +
                                           self->bwidth,
                                           self->bwidth);

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

                                           self->size.left +
                                           self->client->area.width +
                                           self->size.right - self->bwidth -
                                           self->size.left +
                                           self->client->area.width +
                                           self->size.right - self->bwidth -


@@ -641,74 +694,77 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
                                           self->bwidth,
                                           self->bwidth);
 
                                           self->bwidth,
                                           self->bwidth);
 

-                        XMapWindow(ob_display, self->handleleft);
-                        XMapWindow(ob_display, self->handleright);
-                        XMapWindow(ob_display, self->lgriptop);
-                        XMapWindow(ob_display, self->rgriptop);
+                        XMapWindow(obt_display, self->handleleft);
+                        XMapWindow(obt_display, self->handleright);
+                        XMapWindow(obt_display, self->lgriptop);
+                        XMapWindow(obt_display, self->rgriptop);

                     } else {
                     } else {

-                        XUnmapWindow(ob_display, self->handleleft);
-                        XUnmapWindow(ob_display, self->handleright);
-                        XUnmapWindow(ob_display, self->lgriptop);
-                        XUnmapWindow(ob_display, self->rgriptop);
+                        XUnmapWindow(obt_display, self->handleleft);
+                        XUnmapWindow(obt_display, self->handleright);
+                        XUnmapWindow(obt_display, self->lgriptop);
+                        XUnmapWindow(obt_display, self->rgriptop);

                     }
                 } else {
                     }
                 } else {

-                    XUnmapWindow(ob_display, self->handleleft);
-                    XUnmapWindow(ob_display, self->handleright);
-                    XUnmapWindow(ob_display, self->lgriptop);
-                    XUnmapWindow(ob_display, self->rgriptop);
+                    XUnmapWindow(obt_display, self->handleleft);
+                    XUnmapWindow(obt_display, self->handleright);
+                    XUnmapWindow(obt_display, self->lgriptop);
+                    XUnmapWindow(obt_display, self->rgriptop);

 
 

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

                 }
             } else {
                 }
             } else {

-                XUnmapWindow(ob_display, self->handleleft);
-                XUnmapWindow(ob_display, self->handleright);
-                XUnmapWindow(ob_display, self->lgriptop);
-                XUnmapWindow(ob_display, self->rgriptop);
-
-                XUnmapWindow(ob_display, self->handletop);
-
-                XUnmapWindow(ob_display, self->handlebottom);
-                XUnmapWindow(ob_display, self->lgripleft);
-                XUnmapWindow(ob_display, self->rgripright);
-                XUnmapWindow(ob_display, self->lgripbottom);
-                XUnmapWindow(ob_display, self->rgripbottom);
+                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,
+                XMoveResizeWindow(obt_display, self->handle,

                                   sidebwidth,
                                   FRAME_HANDLE_Y(self) + self->bwidth,
                                   self->width, ob_rr_theme->handle_height);
                                   sidebwidth,
                                   FRAME_HANDLE_Y(self) + self->bwidth,
                                   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) {

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

                                       0, 0,
                                       ob_rr_theme->grip_width,
                                       ob_rr_theme->handle_height);
                                       0, 0,
                                       ob_rr_theme->grip_width,
                                       ob_rr_theme->handle_height);

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

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

-                    XMapWindow(ob_display, self->lgrip);
-                    XMapWindow(ob_display, self->rgrip);
+                    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 {
                 }
             } else {

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

 
 

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

             }
 
             }
 

-            if (self->bwidth && !self->max_horz) {
-                XMoveResizeWindow(ob_display, self->left,
+            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,
                                   0,
                                   self->bwidth + ob_rr_theme->grip_width,
                                   self->bwidth,


@@ -716,25 +772,28 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
                                   self->size.top + self->size.bottom -
                                   ob_rr_theme->grip_width * 2);
 
                                   self->size.top + self->size.bottom -
                                   ob_rr_theme->grip_width * 2);
 

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

             } else
             } else

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

 
 

-            if (self->bwidth && !self->max_horz) {
-                XMoveResizeWindow(ob_display, self->right,
-                                  self->client->area.width +
-                                  self->cbwidth_l + self->cbwidth_r + 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);
 
                                   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(ob_display, self->right);
+                XMapWindow(obt_display, self->right);

             } else
             } else

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

 
 

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

                               self->size.left, self->size.top,
                               self->client->area.width,
                               self->client->area.height);
                               self->size.left, self->size.top,
                               self->client->area.width,
                               self->client->area.height);


@@ -762,11 +821,11 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
         if (!frame_iconify_animating(self))
             /* move and resize the top level frame.
                shading can change without being moved or resized.
         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,
+            XMoveResizeWindow(obt_display, self->window,

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


@@ -776,16 +835,13 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
            also this correctly positions the client when it maps.
            this also needs to be run when the frame's decorations sizes change!
         */
            also this correctly positions the client when it maps.
            this also needs to be run when the frame's decorations sizes change!
         */

-        XMoveWindow(ob_display, self->client->window,
+        XMoveWindow(obt_display, self->client->window,

                     self->size.left, self->size.top);
 
         if (resized) {
             self->need_render = TRUE;
             framerender_frame(self);
             frame_adjust_shape(self);
                     self->size.left, self->size.top);
 
         if (resized) {
             self->need_render = TRUE;
             framerender_frame(self);
             frame_adjust_shape(self);

-
-            /* the offscreen buffer's shape needs to match */
-            frame_get_offscreen_buffer(self);

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


@@ -794,19 +850,19 @@ void frame_adjust_area(ObFrame *self, gboolean moved,
             vals[1] = self->size.right;
             vals[2] = self->size.top;
             vals[3] = self->size.bottom;
             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);

         }
 
         /* 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(self->client);
+            focus_cycle_update_indicator(self->client);

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

-        XResizeWindow(ob_display, self->label, self->label_width,
+        XResizeWindow(obt_display, self->label, self->label_width,

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


@@ -828,54 +884,58 @@ static void frame_adjust_cursors(ObFrame *self)
         /* these ones turn off when max vert, and some when shaded */
         a.cursor = ob_cursor(r && topbot && !sh ?
                              OB_CURSOR_NORTH : OB_CURSOR_NONE);
         /* 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(ob_display, self->topresize, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->titletop, CWCursor, &a);
+        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);
         a.cursor = ob_cursor(r && topbot ? OB_CURSOR_SOUTH : OB_CURSOR_NONE);

-        XChangeWindowAttributes(ob_display, self->handle, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->handletop, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->handlebottom, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->innerbottom, CWCursor, &a);
+        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);
 
         /* these ones change when shaded */
         a.cursor = ob_cursor(r ? (sh ? OB_CURSOR_WEST : OB_CURSOR_NORTHWEST) :
                              OB_CURSOR_NONE);

-        XChangeWindowAttributes(ob_display, self->titleleft, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->tltresize, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->tllresize, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->titletopleft, CWCursor, &a);
+        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);
         a.cursor = ob_cursor(r ? (sh ? OB_CURSOR_EAST : OB_CURSOR_NORTHEAST) :
                              OB_CURSOR_NONE);

-        XChangeWindowAttributes(ob_display, self->titleright, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->trtresize, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->trrresize, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->titletopright, CWCursor, &a);
+        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);
 
         /* these ones are pretty static */
         a.cursor = ob_cursor(r ? OB_CURSOR_WEST : OB_CURSOR_NONE);

-        XChangeWindowAttributes(ob_display, self->left, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->innerleft, CWCursor, &a);
+        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);
         a.cursor = ob_cursor(r ? OB_CURSOR_EAST : OB_CURSOR_NONE);

-        XChangeWindowAttributes(ob_display, self->right, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->innerright, CWCursor, &a);
+        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);
         a.cursor = ob_cursor(r ? OB_CURSOR_SOUTHWEST : OB_CURSOR_NONE);

-        XChangeWindowAttributes(ob_display, self->lgrip, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->handleleft, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->lgripleft, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->lgriptop, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->lgripbottom, CWCursor, &a);
+        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);
         a.cursor = ob_cursor(r ? OB_CURSOR_SOUTHEAST : OB_CURSOR_NONE);

-        XChangeWindowAttributes(ob_display, self->rgrip, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->handleright, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->rgripright, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->rgriptop, CWCursor, &a);
-        XChangeWindowAttributes(ob_display, self->rgripbottom, CWCursor, &a);
+        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)
 {
     /* adjust the window which is there to prevent flashing on unmap */
     }
 }
 
 void frame_adjust_client_area(ObFrame *self)
 {
     /* adjust the window which is there to prevent flashing on unmap */

-    XMoveResizeWindow(ob_display, self->backfront, 0, 0,
+    XMoveResizeWindow(obt_display, self->backfront, 0, 0,

                       self->client->area.width,
                       self->client->area.height);
 }
                       self->client->area.width,
                       self->client->area.height);
 }


@@ -891,7 +951,7 @@ void frame_adjust_focus(ObFrame *self, gboolean hilite)
     self->focused = hilite;
     self->need_render = TRUE;
     framerender_frame(self);
     self->focused = hilite;
     self->need_render = TRUE;
     framerender_frame(self);

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

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


@@ -914,10 +974,7 @@ void frame_grab_client(ObFrame *self)
     */
 
     /* reparent the client to the frame */
     */
 
     /* reparent the client to the frame */

-    XReparentWindow(ob_display, self->client->window, self->window, 0, 0);
-
-    /* enable the offscreen composite buffer for the client window */
-    composite_enable_for_window(self->client->window);
+    XReparentWindow(obt_display, self->client->window, self->window, 0, 0);

 
     /*
       When reparenting the client window, it is usually not mapped yet, since
 
     /*
       When reparenting the client window, it is usually not mapped yet, since


@@ -930,50 +987,54 @@ void frame_grab_client(ObFrame *self)
 
     /* 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->window, FRAME_EVENTMASK);
+    XSelectInput(obt_display, self->window, FRAME_EVENTMASK);

 
     /* set all the windows for the frame in the window_map */
 
     /* 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->backback, self->client);
-    g_hash_table_insert(window_map, &self->backfront, self->client);
-    g_hash_table_insert(window_map, &self->innerleft, self->client);
-    g_hash_table_insert(window_map, &self->innertop, self->client);
-    g_hash_table_insert(window_map, &self->innerright, self->client);
-    g_hash_table_insert(window_map, &self->innerbottom, 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->topresize, 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);
-    g_hash_table_insert(window_map, &self->left, self->client);
-    g_hash_table_insert(window_map, &self->right, self->client);
-    g_hash_table_insert(window_map, &self->titleleft, self->client);
-    g_hash_table_insert(window_map, &self->titletop, self->client);
-    g_hash_table_insert(window_map, &self->titletopleft, self->client);
-    g_hash_table_insert(window_map, &self->titletopright, self->client);
-    g_hash_table_insert(window_map, &self->titleright, self->client);
-    g_hash_table_insert(window_map, &self->titlebottom, self->client);
-    g_hash_table_insert(window_map, &self->handleleft, self->client);
-    g_hash_table_insert(window_map, &self->handletop, self->client);
-    g_hash_table_insert(window_map, &self->handleright, self->client);
-    g_hash_table_insert(window_map, &self->handlebottom, self->client);
-    g_hash_table_insert(window_map, &self->lgripleft, self->client);
-    g_hash_table_insert(window_map, &self->lgriptop, self->client);
-    g_hash_table_insert(window_map, &self->lgripbottom, self->client);
-    g_hash_table_insert(window_map, &self->rgripright, self->client);
-    g_hash_table_insert(window_map, &self->rgriptop, self->client);
-    g_hash_table_insert(window_map, &self->rgripbottom, self->client);
+    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));

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


@@ -982,11 +1043,11 @@ void frame_release_client(ObFrame *self)
     gboolean reparent = TRUE;
 
     /* if there was any animation going on, kill it */
     gboolean reparent = TRUE;
 
     /* if there was any animation going on, kill it */

-    ob_main_loop_timeout_remove_data(ob_main_loop, frame_animate_iconify,
-                                     self, FALSE);
+    obt_main_loop_timeout_remove_data(ob_main_loop, frame_animate_iconify,
+                                      self, FALSE);

 
     /* 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,
+    while (XCheckTypedWindowEvent(obt_display, self->client->window,

                                   ReparentNotify, &ev))
     {
         /* This check makes sure we don't catch our own reparent action to
                                   ReparentNotify, &ev))
     {
         /* This check makes sure we don't catch our own reparent action to


@@ -998,7 +1059,7 @@ void frame_release_client(ObFrame *self)
         */
         if (ev.xreparent.parent != self->window) {
             reparent = FALSE;
         */
         if (ev.xreparent.parent != self->window) {
             reparent = FALSE;

-            XPutBackEvent(ob_display, &ev);
+            XPutBackEvent(obt_display, &ev);

             break;
         }
     }
             break;
         }
     }


@@ -1006,56 +1067,58 @@ void frame_release_client(ObFrame *self)
     if (reparent) {
         /* according to the ICCCM - if the client doesn't reparent itself,
            then we will reparent the window to root for them */
     if (reparent) {
         /* 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->backback);
-    g_hash_table_remove(window_map, &self->backfront);
-    g_hash_table_remove(window_map, &self->innerleft);
-    g_hash_table_remove(window_map, &self->innertop);
-    g_hash_table_remove(window_map, &self->innerright);
-    g_hash_table_remove(window_map, &self->innerbottom);
-    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->topresize);
-    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);
-    g_hash_table_remove(window_map, &self->left);
-    g_hash_table_remove(window_map, &self->right);
-    g_hash_table_remove(window_map, &self->titleleft);
-    g_hash_table_remove(window_map, &self->titletop);
-    g_hash_table_remove(window_map, &self->titletopleft);
-    g_hash_table_remove(window_map, &self->titletopright);
-    g_hash_table_remove(window_map, &self->titleright);
-    g_hash_table_remove(window_map, &self->titlebottom);
-    g_hash_table_remove(window_map, &self->handleleft);
-    g_hash_table_remove(window_map, &self->handletop);
-    g_hash_table_remove(window_map, &self->handleright);
-    g_hash_table_remove(window_map, &self->handlebottom);
-    g_hash_table_remove(window_map, &self->lgripleft);
-    g_hash_table_remove(window_map, &self->lgriptop);
-    g_hash_table_remove(window_map, &self->lgripbottom);
-    g_hash_table_remove(window_map, &self->rgripright);
-    g_hash_table_remove(window_map, &self->rgriptop);
-    g_hash_table_remove(window_map, &self->rgripbottom);
-
-    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);
+
+    obt_main_loop_timeout_remove_data(ob_main_loop, flash_timeout, self, TRUE);

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


@@ -1079,15 +1142,37 @@ 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 */
+    /* position of the rightmost button */

     const gint right = self->width;
 
     /* turn them all off */
     const gint right = self->width;
 
     /* turn them all off */


@@ -1096,7 +1181,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,


@@ -1126,53 +1211,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 is bigger than buttons */
-                    self->label_width -= bwidth + 2;
-                    if (i > 0) self->icon_x = x;
-                    x += i * (bwidth + 2);
-                    if (i < 0) self->icon_x = x;
-                }
+                /* 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;
-                    if (i > 0) self->desk_x = x;
-                    x += i * bwidth;
-                    if (i < 0) self->desk_x = x;
-                }
+                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;
-                    if (i > 0) self->shade_x = x;
-                    x += i * bwidth;
-                    if (i < 0) self->shade_x = x;
-                }
+                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;
-                    if (i > 0) self->iconify_x = x;
-                    x += i * bwidth;
-                    if (i < 0) self->iconify_x = x;
-                }
+                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;
-                    if (i > 0) self->max_x = x;
-                    x += i * bwidth;
-                    if (i < 0) self->max_x = x;
-                }
+                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;
-                    if (i > 0) self->close_x = x;
-                    x += i * bwidth;
-                    if (i < 0) self->close_x = x;
-                }
+                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;


@@ -1181,54 +1236,53 @@ 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);

 }
 
 ObFrameContext frame_context_from_string(const gchar *name)
 }
 
 ObFrameContext frame_context_from_string(const gchar *name)


@@ -1283,7 +1337,7 @@ ObFrameContext frame_context(ObClient *client, Window win, gint x, gint y)
     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))
+    if (win == obt_root(ob_screen))

         return OB_FRAME_CONTEXT_ROOT ;
     if (client == NULL) return OB_FRAME_CONTEXT_NONE;
     if (win == client->window) {
         return OB_FRAME_CONTEXT_ROOT ;
     if (client == NULL) return OB_FRAME_CONTEXT_NONE;
     if (win == client->window) {


@@ -1371,9 +1425,9 @@ ObFrameContext frame_context(ObClient *client, Window win, gint x, gint y)
     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->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_BLCORNER;
-    if (win == self->rgriptop)          return OB_FRAME_CONTEXT_BLCORNER;
-    if (win == self->rgripbottom)       return OB_FRAME_CONTEXT_BLCORNER;
+    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->title)             return OB_FRAME_CONTEXT_TITLEBAR;
     if (win == self->titlebottom)       return OB_FRAME_CONTEXT_TITLEBAR;
     if (win == self->titleleft)         return OB_FRAME_CONTEXT_TLCORNER;


@@ -1392,6 +1446,10 @@ ObFrameContext frame_context(ObClient *client, Window win, gint x, gint y)
     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->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->max)               return OB_FRAME_CONTEXT_MAXIMIZE;
     if (win == self->iconify)           return OB_FRAME_CONTEXT_ICONIFY;
     if (win == self->close)             return OB_FRAME_CONTEXT_CLOSE;


@@ -1529,6 +1587,13 @@ void frame_rect_to_frame(ObFrame *self, Rect *r)
     frame_client_gravity(self, &r->x, &r->y);
 }
 
     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;


@@ -1565,15 +1630,15 @@ void frame_flash_start(ObFrame *self)
     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);
+        obt_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);
     g_get_current_time(&self->flash_end);
     g_time_val_add(&self->flash_end, G_USEC_PER_SEC * 5);

-    
+

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


@@ -1624,8 +1689,8 @@ 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;


@@ -1656,12 +1721,11 @@ static gboolean frame_animate_iconify(gpointer p)
         h = self->size.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 */
 }


@@ -1672,25 +1736,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
     else {
         /* Send a ConfigureNotify when the animation is done, this fixes

-           KDE's pager showing the window in the wrong place. */
+           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);
         client_reconfigure(self->client, TRUE);

-
-        /* the offscreen buffer is invalid when the window is resized */
-        frame_get_offscreen_buffer(self);

     }
 
     /* 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.width, self->area.height);
     /* we delay re-rendering until after we're done animating */
     framerender_frame(self);
                       self->area.x, self->area.y,
                       self->area.width, self->area.height);
     /* we delay re-rendering until after we're done animating */
     framerender_frame(self);

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

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


@@ -1729,49 +1793,18 @@ 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);
+        obt_main_loop_timeout_remove_data(ob_main_loop, frame_animate_iconify,
+                                          self, FALSE);
+        obt_main_loop_timeout_add(ob_main_loop,
+                                  FRAME_ANIMATE_ICONIFY_STEP_TIME,
+                                  frame_animate_iconify, self,
+                                  g_direct_equal, 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);
-    }
-}
-
-static void frame_get_offscreen_buffer(ObFrame *self)
-{
-    frame_free_offscreen_buffer(self);
-
-    if (self->visible || frame_iconify_animating(self)) {
-        self->pixmap = composite_get_window_pixmap(self->client->window);
-
-#ifdef SHAPE
-        /* shape the offscreen buffer to match the window */
-        XShapeCombineShape(ob_display, self->pixmap, ShapeBounding,
-                           0, 0, self->client->window,
-                           ShapeBounding, ShapeSet);
-#endif
-
-        /*
-          self->picture = composite_create_picture(self->window,
-          wattrib.visual,
-          &self->has_alpha);
-        */
-    }
-
-}
-
-static void frame_free_offscreen_buffer(ObFrame *self)
-{
-    if (self->pixmap) {
-        XFreePixmap(ob_display, self->pixmap);
-        self->pixmap = None;
+            XMapWindow(obt_display, self->window);

     }
 }
     }
 }