Merge branch 'backport' into work

Conflicts:

	openbox/frame.c

diff --combined obrender/image.c
index 671b7aeeb294f0c09beffad2121017c443bc3b46,3698e81dff29b23f63db6212fc9b04fa667cd876..f86a3ee008c2410964f435b49116743651735c26
--- 1/obrender/image.c
--- 2/render/image.c
+++ b/obrender/image.c
@@@ -21,9 -21,6 +21,9 @@@
  #include "image.h"
  #include "color.h"
  #include "imagecache.h"
 +#ifdef USE_IMLIB2
 +#include <Imlib2.h>
 +#endif
  
  #include <glib.h>
  
@@@ -31,8 -28,7 +31,8 @@@
  #define FLOOR(i)        ((i) & (~0UL << FRACTION))
  #define AVERAGE(a, b)   (((((a) ^ (b)) & 0xfefefefeL) >> 1) + ((a) & (b)))
  
 -void RrImagePicInit(RrImagePic *pic, gint w, gint h, RrPixel32 *data)
 +void RrImagePicInit(RrImagePic *pic, const gchar *name,
 +                    gint w, gint h, RrPixel32 *data)
  {
      gint i;
  
@@@ -42,14 -38,12 +42,14 @@@
      pic->sum = 0;
      for (i = w*h; i > 0; --i)
          pic->sum += *(data++);
 +    pic->name = g_strdup(name);
  }
  
  static void RrImagePicFree(RrImagePic *pic)
  {
      if (pic) {
          g_free(pic->data);
 +        g_free(pic->name);
          g_free(pic);
      }
  }
@@@ -64,10 -58,7 +64,10 @@@ static void AddPicture(RrImage *self, R
  
      g_assert(pic->width > 0 && pic->height > 0);
  
 -    g_assert(g_hash_table_lookup(self->cache->table, pic) == NULL);
 +    if (pic->name)
 +        g_assert(!g_hash_table_lookup(self->cache->name_table, pic->name));
 +    else
 +        g_assert(!g_hash_table_lookup(self->cache->pic_table, pic));
  
      /* grow the list */
      *list = g_renew(RrImagePic*, *list, ++*len);
@@@ -79,19 -70,15 +79,19 @@@
      /* set the new picture up at the front of the list */
      (*list)[0] = pic;
  
 -    /* add the picture as a key to point to this image in the cache */
 -    g_hash_table_insert(self->cache->table, (*list)[0], self);
 +    /* add the name or the picture as a key to point to this image in the
 +       cache */
 +    if (pic->name)
 +        g_hash_table_insert(self->cache->name_table, pic->name, self);
 +    else
 +        g_hash_table_insert(self->cache->pic_table, (*list)[0], self);
  
  /*
  #ifdef DEBUG
 -    g_message("Adding %s picture to the cache:\n    "
 -              "Image 0x%x, w %d h %d Hash %u",
 -              (*list == self->original ? "ORIGINAL" : "RESIZED"),
 -              (guint)self, pic->width, pic->height, RrImagePicHash(pic));
 +    g_debug("Adding %s picture to the cache:\n    "
 +            "Image 0x%lx, w %d h %d Hash %u",
 +            (*list == self->original ? "ORIGINAL" : "RESIZED"),
 +            (gulong)self, pic->width, pic->height, RrImagePicHash(pic));
  #endif
  */
  }
@@@ -105,19 -92,16 +105,19 @@@ static void RemovePicture(RrImage *self
  
  /*
  #ifdef DEBUG
 -    g_message("Removing %s picture from the cache:\n    "
 -              "Image 0x%x, w %d h %d Hash %u",
 -              (*list == self->original ? "ORIGINAL" : "RESIZED"),
 -              (guint)self, (*list)[i]->width, (*list)[i]->height,
 -              RrImagePicHash((*list)[i]));
 +    g_debug("Removing %s picture from the cache:\n    "
 +            "Image 0x%lx, w %d h %d Hash %u",
 +            (*list == self->original ? "ORIGINAL" : "RESIZED"),
 +            (gulong)self, (*list)[i]->width, (*list)[i]->height,
 +            RrImagePicHash((*list)[i]));
  #endif
  */
  
 -    /* remove the picture as a key in the cache */
 -    g_hash_table_remove(self->cache->table, (*list)[i]);
 +    /* remove the name or picture as a key in the cache */
 +    if ((*list)[i]->name)
 +        g_hash_table_remove(self->cache->name_table, (*list)[i]->name);
 +    else
 +        g_hash_table_remove(self->cache->pic_table, (*list)[i]);
  
      /* free the picture */
      RrImagePicFree((*list)[i]);
@@@ -236,7 -220,7 +236,7 @@@ static RrImagePic* ResizeImage(RrPixel3
      }
  
      pic = g_new(RrImagePic, 1);
 -    RrImagePicInit(pic, dstW, dstH, dststart);
 +    RrImagePicInit(pic, NULL, dstW, dstH, dststart);
  
      return pic;
  }
@@@ -341,14 -325,6 +341,14 @@@ RrImage* RrImageNew(RrImageCache *cache
      return self;
  }
  
 +/*! Set function that will be called just before RrImage is destroyed. */
 +void RrImageSetDestroyFunc(RrImage *image, RrImageDestroyFunc func,
 +                           gpointer data)
 +{
 +    image->destroy_func = func;
 +    image->destroy_data = data;
 +}
 +
  void RrImageRef(RrImage *self)
  {
      ++self->ref;
@@@ -359,12 -335,10 +359,12 @@@ void RrImageUnref(RrImage *self
      if (self && --self->ref == 0) {
  /*
  #ifdef DEBUG
 -        g_message("Refcount to 0, removing ALL pictures from the cache:\n    "
 -                  "Image 0x%x", (guint)self);
 +        g_debug("Refcount to 0, removing ALL pictures from the cache:\n    "
 +                "Image 0x%lx", (gulong)self);
  #endif
  */
 +        if (self->destroy_func)
 +            self->destroy_func(self, self->destroy_data);
          while (self->n_original > 0)
              RemovePicture(self, &self->original, 0, &self->n_original);
          while (self->n_resized > 0)
@@@ -373,8 -347,10 +373,8 @@@
      }
  }
  
 -/*! Add a new picture with the given RGBA pixel data and dimensions into the
 -  RrImage.  This adds an "original" picture to the image.
 -*/
 -void RrImageAddPicture(RrImage *self, RrPixel32 *data, gint w, gint h)
 +static void AddPictureFromData(RrImage *self, const char *name,
 +                               const RrPixel32 *data, gint w, gint h)
  {
      gint i;
      RrImagePic *pic;
@@@ -384,8 -360,8 +384,8 @@@
          if (self->original[i]->width == w && self->original[i]->height == h) {
  /*
  #ifdef DEBUG
 -            g_message("Found duplicate ORIGINAL image:\n    "
 -                      "Image 0x%x, w %d h %d", (guint)self, w, h);
 +            g_debug("Found duplicate ORIGINAL image:\n    "
 +                    "Image 0x%lx, w %d h %d", (gulong)self, w, h);
  #endif
  */
              return;
@@@ -400,55 -376,10 +400,55 @@@
  
      /* add the new picture */
      pic = g_new(RrImagePic, 1);
 -    RrImagePicInit(pic, w, h, g_memdup(data, w*h*sizeof(RrPixel32)));
 +    RrImagePicInit(pic, name, w, h, g_memdup(data, w*h*sizeof(RrPixel32)));
      AddPicture(self, &self->original, &self->n_original, pic);
  }
  
 +gboolean RrImageAddPictureName(RrImage *self, const gchar *name)
 +{
 +#ifdef USE_IMLIB2
 +    Imlib_Image img;
 +    gint w, h;
 +    RrPixel32 *data;
 +    gchar *path;
 +
 +    /* XXX find the path via freedesktop icon spec (use obt) ! */
 +    path = g_strdup(name);
 +
 +    if (!(img = imlib_load_image(path)))
 +        g_message("Cannot load image \"%s\" from file \"%s\"", name, path);
 +    g_free(path);
 +
 +    if (!img)
 +        return FALSE; /* failed to load it */
 +
 +    /* Get data and dimensions of the image.
 +
 +       WARNING: This stuff is NOT threadsafe !!
 +    */
 +    imlib_context_set_image(img);
 +    data = imlib_image_get_data_for_reading_only();
 +    w = imlib_image_get_width();
 +    h = imlib_image_get_height();
 +
 +    /* add it to the RrImage, and set its name */
 +    AddPictureFromData(self, name, data, w, h);
 +
 +    imlib_free_image();
 +    return TRUE;
 +#else
 +    return FALSE;
 +#endif
 +}
 +
 +/*! Add a new picture with the given RGBA pixel data and dimensions into the
 +  RrImage.  This adds an "original" picture to the image.
 +*/
 +void RrImageAddPicture(RrImage *self, const RrPixel32 *data, gint w, gint h)
 +{
 +    AddPictureFromData(self, NULL, data, w, h);    
 +}
 +
  /*! Remove the picture from the RrImage which has the given dimensions. This
   removes an "original" picture from the image.
  */
@@@ -532,7 -463,9 +532,9 @@@ void RrImageDrawImage(RrPixel32 *target
  
              /* our size difference metric.. */
              wdiff = self->original[i]->width - area->width;
+             if (wdiff < 0) wdiff *= 2; /* prefer scaling down than up */
              hdiff = self->original[i]->height - area->height;
+             if (hdiff < 0) hdiff *= 2; /* prefer scaling down than up */
              diff = (wdiff * wdiff) + (hdiff * hdiff);
  
              /* find the smallest difference */

diff --combined openbox/frame.c
index 084f3f6accd60c6040f6a6adf6bcf7044de93b1e,67adb40535e113a1f23676746d93efeb5852e39a..8835c6326b15836e499b39b3fc5046437d92ec9f
--- 1/openbox/frame.c
--- 2/openbox/frame.c
+++ b/openbox/frame.c
@@@ -20,17 -20,18 +20,17 @@@
  #include "frame.h"
  #include "client.h"
  #include "openbox.h"
 -#include "extensions.h"
 -#include "prop.h"
  #include "grab.h"
  #include "debug.h"
  #include "config.h"
  #include "framerender.h"
 -#include "mainloop.h"
  #include "focus_cycle.h"
  #include "focus_cycle_indicator.h"
  #include "moveresize.h"
  #include "screen.h"
 -#include "render/theme.h"
 +#include "obrender/theme.h"
 +#include "obt/display.h"
 +#include "obt/prop.h"
  
  #define FRAME_EVENTMASK (EnterWindowMask | LeaveWindowMask | \
                           ButtonPressMask | ButtonReleaseMask | \
@@@ -56,7 -57,7 +56,7 @@@ static void frame_adjust_cursors(ObFram
  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);
@@@ -73,7 -74,7 +73,7 @@@ static Visual *check_32bit_client(ObCli
      if (RrDepth(ob_rr_inst) == 32)
          return NULL;
  
 -    ret = XGetWindowAttributes(ob_display, c->window, &wattrib);
 +    ret = XGetWindowAttributes(obt_display, c->window, &wattrib);
      g_assert(ret != BadDrawable);
      g_assert(ret != BadWindow);
  
@@@ -102,12 -103,13 +102,12 @@@ ObFrame *frame_new(ObClient *client
          mask = CWColormap | CWBackPixel | CWBorderPixel;
          /* create a colormap with the visual */
          self->colormap = attrib.colormap =
 -            XCreateColormap(ob_display,
 -                            RootWindow(ob_display, ob_screen),
 +            XCreateColormap(obt_display, obt_root(ob_screen),
                              visual, AllocNone);
 -        attrib.background_pixel = BlackPixel(ob_display, ob_screen);
 -        attrib.border_pixel = BlackPixel(ob_display, ob_screen);
 +        attrib.background_pixel = BlackPixel(obt_display, ob_screen);
 +        attrib.border_pixel = BlackPixel(obt_display, ob_screen);
      }
 -    self->window = createWindow(RootWindow(ob_display, ob_screen), visual,
 +    self->window = createWindow(obt_root(ob_screen), visual,
                                  mask, &attrib);
  
      /* create the visible decor windows */
@@@ -178,9 -180,9 +178,9 @@@
      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->iconify_press = self->shade_press = FALSE;
@@@ -195,25 -197,25 +195,25 @@@
  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);
 -    XResizeWindow(ob_display, self->iconify,
 +    XResizeWindow(obt_display, self->iconify,
                    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);
 -    XResizeWindow(ob_display, self->close,
 +    XResizeWindow(obt_display, self->close,
                    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);
 -    XResizeWindow(ob_display, self->shade,
 +    XResizeWindow(obt_display, self->shade,
                    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);
 -    XResizeWindow(ob_display, self->trtresize,
 +    XResizeWindow(obt_display, self->trtresize,
                    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);
 -    XResizeWindow(ob_display, self->trrresize,
 +    XResizeWindow(obt_display, self->trrresize,
                    ob_rr_theme->paddingx + 1, ob_rr_theme->title_height);
  }
  
@@@ -225,9 -227,9 +225,9 @@@ void frame_free(ObFrame *self
  {
      free_theme_statics(self);
  
 -    XDestroyWindow(ob_display, self->window);
 +    XDestroyWindow(obt_display, self->window);
      if (self->colormap)
 -        XFreeColormap(ob_display, self->colormap);
 +        XFreeColormap(obt_display, self->colormap);
  
      g_free(self);
  }
@@@ -241,8 -243,8 +241,8 @@@ void frame_show(ObFrame *self
             the client gets its MapNotify, i.e. to make sure the client is
             _visible_ when it gets MapNotify. */
          grab_server(TRUE);
 -        XMapWindow(ob_display, self->client->window);
 -        XMapWindow(ob_display, self->window);
 +        XMapWindow(obt_display, self->client->window);
 +        XMapWindow(obt_display, self->window);
          grab_server(FALSE);
      }
  }
@@@ -252,10 -254,10 +252,10 @@@ void frame_hide(ObFrame *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! */
 -        XUnmapWindow(ob_display, self->client->window);
 +        XUnmapWindow(obt_display, self->client->window);
          self->client->ignore_unmaps += 1;
      }
  }
@@@ -275,13 -277,13 +275,13 @@@ void frame_adjust_shape_kind(ObFrame *s
      if (!((kind == ShapeBounding && self->client->shaped) ||
            (kind == ShapeInput && self->client->shaped_input))) {
          /* clear the shape on the frame window */
 -        XShapeCombineMask(ob_display, self->window, kind,
 +        XShapeCombineMask(obt_display, self->window, kind,
                            self->size.left,
                            self->size.top,
                            None, ShapeSet);
      } else {
          /* make the frame's shape match the clients */
 -        XShapeCombineShape(ob_display, self->window, kind,
 +        XShapeCombineShape(obt_display, self->window, kind,
                             self->size.left,
                             self->size.top,
                             self->client->window,
@@@ -307,8 -309,8 +307,8 @@@
              ++num;
          }
  
 -        XShapeCombineRectangles(ob_display, self->window,
 -                                kind, 0, 0, xrect, num,
 +        XShapeCombineRectangles(obt_display, self->window,
 +                                ShapeBounding, 0, 0, xrect, num,
                                  ShapeUnion, Unsorted);
      }
  }
@@@ -389,17 -391,17 +389,17 @@@ void frame_adjust_area(ObFrame *self, g
                  ob_rr_theme->grip_width - self->size.bottom;
  
              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);
  
 -                XMapWindow(ob_display, self->innerleft);
 +                XMapWindow(obt_display, self->innerleft);
              } else
 -                XUnmapWindow(ob_display, self->innerleft);
 +                XUnmapWindow(obt_display, self->innerleft);
  
              if (self->cbwidth_l && innercornerheight > 0) {
 -                XMoveResizeWindow(ob_display, self->innerbll,
 +                XMoveResizeWindow(obt_display, self->innerbll,
                                    0,
                                    self->client->area.height - 
                                    (ob_rr_theme->grip_width -
@@@ -407,22 -409,22 +407,22 @@@
                                    self->cbwidth_l,
                                    ob_rr_theme->grip_width - self->size.bottom);
  
 -                XMapWindow(ob_display, self->innerbll);
 +                XMapWindow(obt_display, self->innerbll);
              } else
 -                XUnmapWindow(ob_display, self->innerbll);
 +                XUnmapWindow(obt_display, self->innerbll);
  
              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);
  
 -                XMapWindow(ob_display, self->innerright);
 +                XMapWindow(obt_display, self->innerright);
              } else
 -                XUnmapWindow(ob_display, self->innerright);
 +                XUnmapWindow(obt_display, self->innerright);
  
              if (self->cbwidth_r && innercornerheight > 0) {
 -                XMoveResizeWindow(ob_display, self->innerbrr,
 +                XMoveResizeWindow(obt_display, self->innerbrr,
                                    0,
                                    self->client->area.height - 
                                    (ob_rr_theme->grip_width -
@@@ -430,35 -432,35 +430,35 @@@
                                    self->cbwidth_r,
                                    ob_rr_theme->grip_width - self->size.bottom);
  
 -                XMapWindow(ob_display, self->innerbrr);
 +                XMapWindow(obt_display, self->innerbrr);
              } else
 -                XUnmapWindow(ob_display, self->innerbrr);
 +                XUnmapWindow(obt_display, self->innerbrr);
  
              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);
  
 -                XMapWindow(ob_display, self->innertop);
 +                XMapWindow(obt_display, self->innertop);
              } else
 -                XUnmapWindow(ob_display, self->innertop);
 +                XUnmapWindow(obt_display, self->innertop);
  
              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);
  
 -                XMoveResizeWindow(ob_display, self->innerblb,
 +                XMoveResizeWindow(obt_display, self->innerblb,
                                    0, 0,
                                    ob_rr_theme->grip_width + self->bwidth,
                                    self->cbwidth_b);
 -                XMoveResizeWindow(ob_display, self->innerbrb,
 +                XMoveResizeWindow(obt_display, self->innerbrb,
                                    self->client->area.width +
                                    self->cbwidth_l + self->cbwidth_r -
                                    (ob_rr_theme->grip_width + self->bwidth),
@@@ -466,13 -468,13 +466,13 @@@
                                    ob_rr_theme->grip_width + self->bwidth,
                                    self->cbwidth_b);
  
 -                XMapWindow(ob_display, self->innerbottom);
 -                XMapWindow(ob_display, self->innerblb);
 -                XMapWindow(ob_display, self->innerbrb);
 +                XMapWindow(obt_display, self->innerbottom);
 +                XMapWindow(obt_display, self->innerblb);
 +                XMapWindow(obt_display, self->innerbrb);
              } else {
 -                XUnmapWindow(ob_display, self->innerbottom);
 -                XUnmapWindow(ob_display, self->innerblb);
 -                XUnmapWindow(ob_display, self->innerbrb);
 +                XUnmapWindow(obt_display, self->innerbottom);
 +                XUnmapWindow(obt_display, self->innerblb);
 +                XUnmapWindow(obt_display, self->innerbrb);
              }
  
              if (self->bwidth) {
@@@ -481,16 -483,16 +481,16 @@@
                  /* 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);
 -                XMoveResizeWindow(ob_display, self->titletopleft,
 +                XMoveResizeWindow(obt_display, self->titletopleft,
                                    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,
@@@ -499,11 -501,11 +499,11 @@@
                                    self->bwidth);
  
                  if (titlesides > 0) {
 -                    XMoveResizeWindow(ob_display, self->titleleft,
 +                    XMoveResizeWindow(obt_display, self->titleleft,
                                        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,
@@@ -511,73 -513,73 +511,73 @@@
                                        self->bwidth,
                                        titlesides);
  
 -                    XMapWindow(ob_display, self->titleleft);
 -                    XMapWindow(ob_display, self->titleright);
 +                    XMapWindow(obt_display, self->titleleft);
 +                    XMapWindow(obt_display, self->titleright);
                  } 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) {
 -                    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);
  
 -                    XMapWindow(ob_display, self->titlebottom);
 +                    XMapWindow(obt_display, self->titlebottom);
                  } else
 -                    XUnmapWindow(ob_display, self->titlebottom);
 +                    XUnmapWindow(obt_display, self->titlebottom);
              } 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) {
 -                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);
  
 -                XMapWindow(ob_display, self->title);
 +                XMapWindow(obt_display, self->title);
  
                  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);
  
 -                    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);
 -                    XMoveWindow(ob_display, self->trrresize,
 +                    XMoveWindow(obt_display, self->trrresize,
                                  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 {
 -                    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
 -                XUnmapWindow(ob_display, self->title);
 +                XUnmapWindow(obt_display, self->title);
          }
  
          if ((self->decorations & OB_FRAME_DECOR_TITLEBAR))
@@@ -588,7 -590,7 +588,7 @@@
              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 +
@@@ -597,9 -599,8 +597,9 @@@
                                                   sidebwidth) * 2,
                                    self->bwidth);
  
 +
                  if (sidebwidth) {
 -                    XMoveResizeWindow(ob_display, self->lgripleft,
 +                    XMoveResizeWindow(obt_display, self->lgripleft,
                                        0,
                                        self->size.top +
                                        self->client->area.height +
@@@ -611,7 -612,7 +611,7 @@@
                                        (!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,
@@@ -626,20 -627,20 +626,20 @@@
                                         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 {
 -                    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);
 -                XMoveResizeWindow(ob_display, self->rgripbottom,
 +                XMoveResizeWindow(obt_display, self->rgripbottom,
                                    self->size.left + self->client->area.width +
                                    self->size.right - self->bwidth - sidebwidth-
                                    ob_rr_theme->grip_width,
@@@ -648,29 -649,29 +648,29 @@@
                                    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)
                  {
 -                    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);
 -                    XMapWindow(ob_display, self->handletop);
 +                    XMapWindow(obt_display, self->handletop);
  
                      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);
 -                        XMoveResizeWindow(ob_display, self->handleright,
 +                        XMoveResizeWindow(obt_display, self->handleright,
                                            self->width -
                                            ob_rr_theme->grip_width -
                                            self->bwidth,
@@@ -678,13 -679,13 +678,13 @@@
                                            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);
 -                        XMoveResizeWindow(ob_display, self->rgriptop,
 +                        XMoveResizeWindow(obt_display, self->rgriptop,
                                            self->size.left +
                                            self->client->area.width +
                                            self->size.right - self->bwidth -
@@@ -694,77 -695,77 +694,77 @@@
                                            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 {
 -                        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 {
 -                    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 {
 -                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)
              {
 -                XMoveResizeWindow(ob_display, self->handle,
 +                XMoveResizeWindow(obt_display, self->handle,
                                    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) {
 -                    XMoveResizeWindow(ob_display, self->lgrip,
 +                    XMoveResizeWindow(obt_display, self->lgrip,
                                        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);
  
 -                    XMapWindow(ob_display, self->lgrip);
 -                    XMapWindow(ob_display, self->rgrip);
 +                    XMapWindow(obt_display, self->lgrip);
 +                    XMapWindow(obt_display, self->rgrip);
                  } else {
 -                    XUnmapWindow(ob_display, self->lgrip);
 -                    XUnmapWindow(ob_display, self->rgrip);
 +                    XUnmapWindow(obt_display, self->lgrip);
 +                    XUnmapWindow(obt_display, self->rgrip);
                  }
              } 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 &&
                  (self->client->area.height + self->size.top +
                   self->size.bottom) > ob_rr_theme->grip_width * 2)
              {
 -                XMoveResizeWindow(ob_display, self->left,
 +                XMoveResizeWindow(obt_display, self->left,
                                    0,
                                    self->bwidth + ob_rr_theme->grip_width,
                                    self->bwidth,
@@@ -772,15 -773,15 +772,15 @@@
                                    self->size.top + self->size.bottom -
                                    ob_rr_theme->grip_width * 2);
  
 -                XMapWindow(ob_display, self->left);
 +                XMapWindow(obt_display, self->left);
              } else
 -                XUnmapWindow(ob_display, self->left);
 +                XUnmapWindow(obt_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(ob_display, self->right,
 +                XMoveResizeWindow(obt_display, self->right,
                                    self->client->area.width + self->cbwidth_l +
                                    self->cbwidth_r + self->bwidth,
                                    self->bwidth + ob_rr_theme->grip_width,
@@@ -789,11 -790,11 +789,11 @@@
                                    self->size.top + self->size.bottom -
                                    ob_rr_theme->grip_width * 2);
  
 -                XMapWindow(ob_display, self->right);
 +                XMapWindow(obt_display, self->right);
              } 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);
@@@ -825,7 -826,7 +825,7 @@@
                 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,
@@@ -835,7 -836,7 +835,7 @@@
             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) {
@@@ -850,10 -851,10 +850,10 @@@
              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
@@@ -861,10 -862,12 +861,12 @@@
          if (focus_cycle_target == self->client)
              focus_cycle_update_indicator(self->client);
      }
-     if (resized && (self->decorations & OB_FRAME_DECOR_TITLEBAR))
+     if (resized && (self->decorations & OB_FRAME_DECOR_TITLEBAR) &&
+         self->label_width)
+     {
 -        XResizeWindow(ob_display, self->label, self->label_width,
 +        XResizeWindow(obt_display, self->label, self->label_width,
                        ob_rr_theme->label_height);
- 
+     }
  }
  
  static void frame_adjust_cursors(ObFrame *self)
@@@ -884,58 -887,58 +886,58 @@@
          /* 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);
 -        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);
 -        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);
 -        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);
 -        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);
 -        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);
 -        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(ob_display, self->innerbll, CWCursor, &a);
 -        XChangeWindowAttributes(ob_display, self->innerblb, 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);
 -        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(ob_display, self->innerbrr, CWCursor, &a);
 -        XChangeWindowAttributes(ob_display, self->innerbrb, 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 */
 -    XMoveResizeWindow(ob_display, self->backfront, 0, 0,
 +    XMoveResizeWindow(obt_display, self->backfront, 0, 0,
                        self->client->area.width,
                        self->client->area.height);
  }
@@@ -954,7 -957,7 +956,7 @@@ void frame_adjust_focus(ObFrame *self, 
      self->focused = hilite;
      self->need_render = TRUE;
      framerender_frame(self);
 -    XFlush(ob_display);
 +    XFlush(obt_display);
  }
  
  void frame_adjust_title(ObFrame *self)
@@@ -977,7 -980,7 +979,7 @@@ void frame_grab_client(ObFrame *self
      */
  
      /* reparent the client to the frame */
 -    XReparentWindow(ob_display, self->client->window, self->window, 0, 0);
 +    XReparentWindow(obt_display, self->client->window, self->window, 0, 0);
  
      /*
        When reparenting the client window, it is usually not mapped yet, since
@@@ -990,54 -993,54 +992,54 @@@
  
      /* 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 */
 -    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->innerblb, self->client);
 -    g_hash_table_insert(window_map, &self->innerbll, self->client);
 -    g_hash_table_insert(window_map, &self->innerbrb, self->client);
 -    g_hash_table_insert(window_map, &self->innerbrr, 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)
@@@ -1046,11 -1049,11 +1048,11 @@@
      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 */
 -    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
@@@ -1062,7 -1065,7 +1064,7 @@@
          */
          if (ev.xreparent.parent != self->window) {
              reparent = FALSE;
 -            XPutBackEvent(ob_display, &ev);
 +            XPutBackEvent(obt_display, &ev);
              break;
          }
      }
@@@ -1070,58 -1073,60 +1072,58 @@@
      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 */
 -    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->innerblb);
 -    g_hash_table_remove(window_map, &self->innerbll);
 -    g_hash_table_remove(window_map, &self->innerbrb);
 -    g_hash_table_remove(window_map, &self->innerbrr);
 -    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? */
@@@ -1239,53 -1244,53 +1241,53 @@@ static void layout_title(ObFrame *self
  
      /* 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
 -        XUnmapWindow(ob_display, self->icon);
 +        XUnmapWindow(obt_display, self->icon);
  
      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
 -        XUnmapWindow(ob_display, self->desk);
 +        XUnmapWindow(obt_display, self->desk);
  
      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
 -        XUnmapWindow(ob_display, self->shade);
 +        XUnmapWindow(obt_display, self->shade);
  
      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
 -        XUnmapWindow(ob_display, self->iconify);
 +        XUnmapWindow(obt_display, self->iconify);
  
      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
 -        XUnmapWindow(ob_display, self->max);
 +        XUnmapWindow(obt_display, self->max);
  
      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
 -        XUnmapWindow(ob_display, self->close);
 +        XUnmapWindow(obt_display, self->close);
  
      if (self->label_on && self->label_width > 0) {
 -        XMapWindow(ob_display, self->label);
 -        XMoveWindow(ob_display, self->label, self->label_x,
 +        XMapWindow(obt_display, self->label);
 +        XMoveWindow(obt_display, self->label, self->label_x,
                      ob_rr_theme->paddingy);
      } else
 -        XUnmapWindow(ob_display, self->label);
 +        XUnmapWindow(obt_display, self->label);
  }
  
  ObFrameContext frame_context_from_string(const gchar *name)
@@@ -1340,7 -1345,7 +1342,7 @@@ ObFrameContext frame_context(ObClient *
      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) {
@@@ -1633,12 -1638,12 +1635,12 @@@ void frame_flash_start(ObFrame *self
      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);
  
@@@ -1724,8 -1729,8 +1726,8 @@@ static gboolean frame_animate_iconify(g
          h = self->size.top; /* just the titlebar */
      }
  
 -    XMoveResizeWindow(ob_display, self->window, x, y, w, h);
 -    XFlush(ob_display);
 +    XMoveResizeWindow(obt_display, self->window, x, y, w, h);
 +    XFlush(obt_display);
  
      if (time == 0)
          frame_end_iconify_animation(self);
@@@ -1739,7 -1744,7 +1741,7 @@@ void frame_end_iconify_animation(ObFram
      if (self->iconify_animation_going == 0) return;
  
      if (!self->visible)
 -        XUnmapWindow(ob_display, self->window);
 +        XUnmapWindow(obt_display, self->window);
      else {
          /* Send a ConfigureNotify when the animation is done, this fixes
             KDE's pager showing the window in the wrong place.  since the
@@@ -1752,12 -1757,12 +1754,12 @@@
      /* 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);
 -    XFlush(ob_display);
 +    XFlush(obt_display);
  }
  
  void frame_begin_iconify_animation(ObFrame *self, gboolean iconifying)
@@@ -1796,18 -1801,18 +1798,18 @@@
      }
  
      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)
 -            XMapWindow(ob_display, self->window);
 +            XMapWindow(obt_display, self->window);
      }
  }